1/* read.c - read a source file - 2 Copyright (C) 1986-2017 Free Software Foundation, Inc. 3 4 This file is part of GAS, the GNU Assembler. 5 6 GAS is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GAS is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GAS; see the file COPYING. If not, write to the Free 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21/* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF). 22 But then, GNU isn't spozed to run on your machine anyway. 23 (RMS is so shortsighted sometimes.) */ 24#define MASK_CHAR ((int)(unsigned char) -1) 25 26/* This is the largest known floating point format (for now). It will 27 grow when we do 4361 style flonums. */ 28#define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16) 29 30/* Routines that read assembler source text to build spaghetti in memory. 31 Another group of these functions is in the expr.c module. */ 32 33#include "as.h" 34#include "safe-ctype.h" 35#include "subsegs.h" 36#include "sb.h" 37#include "macro.h" 38#include "obstack.h" 39#include "ecoff.h" 40#include "dw2gencfi.h" 41#include "wchar.h" 42 43#ifndef TC_START_LABEL 44#define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':') 45#endif 46 47/* Set by the object-format or the target. */ 48#ifndef TC_IMPLICIT_LCOMM_ALIGNMENT 49#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \ 50 do \ 51 { \ 52 if ((SIZE) >= 8) \ 53 (P2VAR) = 3; \ 54 else if ((SIZE) >= 4) \ 55 (P2VAR) = 2; \ 56 else if ((SIZE) >= 2) \ 57 (P2VAR) = 1; \ 58 else \ 59 (P2VAR) = 0; \ 60 } \ 61 while (0) 62#endif 63 64char *input_line_pointer; /*->next char of source file to parse. */ 65 66#if BITS_PER_CHAR != 8 67/* The following table is indexed by[(char)] and will break if 68 a char does not have exactly 256 states (hopefully 0:255!)! */ 69die horribly; 70#endif 71 72#ifndef LEX_AT 73#define LEX_AT 0 74#endif 75 76#ifndef LEX_BR 77/* The RS/6000 assembler uses {,},[,] as parts of symbol names. */ 78#define LEX_BR 0 79#endif 80 81#ifndef LEX_PCT 82/* The Delta 68k assembler permits % inside label names. */ 83#define LEX_PCT 0 84#endif 85 86#ifndef LEX_QM 87/* The PowerPC Windows NT assemblers permits ? inside label names. */ 88#define LEX_QM 0 89#endif 90 91#ifndef LEX_HASH 92/* The IA-64 assembler uses # as a suffix designating a symbol. We include 93 it in the symbol and strip it out in tc_canonicalize_symbol_name. */ 94#define LEX_HASH 0 95#endif 96 97#ifndef LEX_DOLLAR 98#define LEX_DOLLAR 3 99#endif 100 101#ifndef LEX_TILDE 102/* The Delta 68k assembler permits ~ at start of label names. */ 103#define LEX_TILDE 0 104#endif 105 106/* Used by is_... macros. our ctype[]. */ 107char lex_type[256] = { 108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */ 109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */ 110 0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */ 111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM, /* 0123456789:;<=>? */ 112 LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */ 113 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */ 114 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */ 115 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */ 116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 124}; 125 126/* In: a character. 127 Out: 1 if this character ends a line. 128 2 if this character is a line separator. */ 129char is_end_of_line[256] = { 130#ifdef CR_EOL 131 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */ 132#else 133 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */ 134#endif 135 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */ 137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */ 138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ 149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */ 150}; 151 152#ifndef TC_CASE_SENSITIVE 153char original_case_string[128]; 154#endif 155 156/* Functions private to this file. */ 157 158static char *buffer; /* 1st char of each buffer of lines is here. */ 159static char *buffer_limit; /*->1 + last char in buffer. */ 160 161/* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1 162 in the tc-<CPU>.h file. See the "Porting GAS" section of the 163 internals manual. */ 164int target_big_endian = TARGET_BYTES_BIG_ENDIAN; 165 166/* Variables for handling include file directory table. */ 167 168/* Table of pointers to directories to search for .include's. */ 169const char **include_dirs; 170 171/* How many are in the table. */ 172int include_dir_count; 173 174/* Length of longest in table. */ 175int include_dir_maxlen = 1; 176 177#ifndef WORKING_DOT_WORD 178struct broken_word *broken_words; 179int new_broken_words; 180#endif 181 182/* The current offset into the absolute section. We don't try to 183 build frags in the absolute section, since no data can be stored 184 there. We just keep track of the current offset. */ 185addressT abs_section_offset; 186 187/* If this line had an MRI style label, it is stored in this variable. 188 This is used by some of the MRI pseudo-ops. */ 189symbolS *line_label; 190 191/* This global variable is used to support MRI common sections. We 192 translate such sections into a common symbol. This variable is 193 non-NULL when we are in an MRI common section. */ 194symbolS *mri_common_symbol; 195 196/* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we 197 need to align to an even byte boundary unless the next pseudo-op is 198 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment 199 may be needed. */ 200static int mri_pending_align; 201 202#ifndef NO_LISTING 203#ifdef OBJ_ELF 204/* This variable is set to be non-zero if the next string we see might 205 be the name of the source file in DWARF debugging information. See 206 the comment in emit_expr for the format we look for. */ 207static int dwarf_file_string; 208#endif 209#endif 210 211/* If the target defines the md_frag_max_var hook then we know 212 enough to implement the .bundle_align_mode features. */ 213#ifdef md_frag_max_var 214# define HANDLE_BUNDLE 215#endif 216 217#ifdef HANDLE_BUNDLE 218/* .bundle_align_mode sets this. Normally it's zero. When nonzero, 219 it's the exponent of the bundle size, and aligned instruction bundle 220 mode is in effect. */ 221static unsigned int bundle_align_p2; 222 223/* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets 224 bundle_lock_frag to frag_now and then starts a new frag with 225 frag_align_code. At the same time, bundle_lock_frain gets frchain_now, 226 so that .bundle_unlock can verify that we didn't change segments. 227 .bundle_unlock resets both to NULL. If we detect a bundling violation, 228 then we reset bundle_lock_frchain to NULL as an indicator that we've 229 already diagnosed the error with as_bad and don't need a cascade of 230 redundant errors, but bundle_lock_frag remains set to indicate that 231 we are expecting to see .bundle_unlock. */ 232static fragS *bundle_lock_frag; 233static frchainS *bundle_lock_frchain; 234 235/* This is incremented by .bundle_lock and decremented by .bundle_unlock, 236 to allow nesting. */ 237static unsigned int bundle_lock_depth; 238#endif 239 240static void do_s_func (int end_p, const char *default_prefix); 241static void s_align (int, int); 242static void s_altmacro (int); 243static void s_bad_end (int); 244static void s_reloc (int); 245static int hex_float (int, char *); 246static segT get_known_segmented_expression (expressionS * expP); 247static void pobegin (void); 248static size_t get_non_macro_line_sb (sb *); 249static void generate_file_debug (void); 250static char *_find_end_of_line (char *, int, int, int); 251 252void 253read_begin (void) 254{ 255 const char *p; 256 257 pobegin (); 258 obj_read_begin_hook (); 259 260 /* Something close -- but not too close -- to a multiple of 1024. 261 The debugging malloc I'm using has 24 bytes of overhead. */ 262 obstack_begin (¬es, chunksize); 263 obstack_begin (&cond_obstack, chunksize); 264 265#ifndef tc_line_separator_chars 266#define tc_line_separator_chars line_separator_chars 267#endif 268 /* Use machine dependent syntax. */ 269 for (p = tc_line_separator_chars; *p; p++) 270 is_end_of_line[(unsigned char) *p] = 2; 271 /* Use more. FIXME-SOMEDAY. */ 272 273 if (flag_mri) 274 lex_type['?'] = 3; 275} 276 277#ifndef TC_ADDRESS_BYTES 278#define TC_ADDRESS_BYTES address_bytes 279 280static inline int 281address_bytes (void) 282{ 283 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to 284 contain an address. */ 285 int n = (stdoutput->arch_info->bits_per_address - 1) / 8; 286 n |= n >> 1; 287 n |= n >> 2; 288 n += 1; 289 return n; 290} 291#endif 292 293/* Set up pseudo-op tables. */ 294 295static struct hash_control *po_hash; 296 297static const pseudo_typeS potable[] = { 298 {"abort", s_abort, 0}, 299 {"align", s_align_ptwo, 0}, 300 {"altmacro", s_altmacro, 1}, 301 {"ascii", stringer, 8+0}, 302 {"asciz", stringer, 8+1}, 303 {"balign", s_align_bytes, 0}, 304 {"balignw", s_align_bytes, -2}, 305 {"balignl", s_align_bytes, -4}, 306/* block */ 307#ifdef HANDLE_BUNDLE 308 {"bundle_align_mode", s_bundle_align_mode, 0}, 309 {"bundle_lock", s_bundle_lock, 0}, 310 {"bundle_unlock", s_bundle_unlock, 0}, 311#endif 312 {"byte", cons, 1}, 313 {"comm", s_comm, 0}, 314 {"common", s_mri_common, 0}, 315 {"common.s", s_mri_common, 1}, 316 {"data", s_data, 0}, 317 {"dc", cons, 2}, 318#ifdef TC_ADDRESS_BYTES 319 {"dc.a", cons, 0}, 320#endif 321 {"dc.b", cons, 1}, 322 {"dc.d", float_cons, 'd'}, 323 {"dc.l", cons, 4}, 324 {"dc.s", float_cons, 'f'}, 325 {"dc.w", cons, 2}, 326 {"dc.x", float_cons, 'x'}, 327 {"dcb", s_space, 2}, 328 {"dcb.b", s_space, 1}, 329 {"dcb.d", s_float_space, 'd'}, 330 {"dcb.l", s_space, 4}, 331 {"dcb.s", s_float_space, 'f'}, 332 {"dcb.w", s_space, 2}, 333 {"dcb.x", s_float_space, 'x'}, 334 {"ds", s_space, 2}, 335 {"ds.b", s_space, 1}, 336 {"ds.d", s_space, 8}, 337 {"ds.l", s_space, 4}, 338 {"ds.p", s_space, 12}, 339 {"ds.s", s_space, 4}, 340 {"ds.w", s_space, 2}, 341 {"ds.x", s_space, 12}, 342 {"debug", s_ignore, 0}, 343#ifdef S_SET_DESC 344 {"desc", s_desc, 0}, 345#endif 346/* dim */ 347 {"double", float_cons, 'd'}, 348/* dsect */ 349 {"eject", listing_eject, 0}, /* Formfeed listing. */ 350 {"else", s_else, 0}, 351 {"elsec", s_else, 0}, 352 {"elseif", s_elseif, (int) O_ne}, 353 {"end", s_end, 0}, 354 {"endc", s_endif, 0}, 355 {"endfunc", s_func, 1}, 356 {"endif", s_endif, 0}, 357 {"endm", s_bad_end, 0}, 358 {"endr", s_bad_end, 1}, 359/* endef */ 360 {"equ", s_set, 0}, 361 {"equiv", s_set, 1}, 362 {"eqv", s_set, -1}, 363 {"err", s_err, 0}, 364 {"error", s_errwarn, 1}, 365 {"exitm", s_mexit, 0}, 366/* extend */ 367 {"extern", s_ignore, 0}, /* We treat all undef as ext. */ 368 {"appfile", s_app_file, 1}, 369 {"appline", s_app_line, 1}, 370 {"fail", s_fail, 0}, 371 {"file", s_app_file, 0}, 372 {"fill", s_fill, 0}, 373 {"float", float_cons, 'f'}, 374 {"format", s_ignore, 0}, 375 {"func", s_func, 0}, 376 {"global", s_globl, 0}, 377 {"globl", s_globl, 0}, 378 {"hword", cons, 2}, 379 {"if", s_if, (int) O_ne}, 380 {"ifb", s_ifb, 1}, 381 {"ifc", s_ifc, 0}, 382 {"ifdef", s_ifdef, 0}, 383 {"ifeq", s_if, (int) O_eq}, 384 {"ifeqs", s_ifeqs, 0}, 385 {"ifge", s_if, (int) O_ge}, 386 {"ifgt", s_if, (int) O_gt}, 387 {"ifle", s_if, (int) O_le}, 388 {"iflt", s_if, (int) O_lt}, 389 {"ifnb", s_ifb, 0}, 390 {"ifnc", s_ifc, 1}, 391 {"ifndef", s_ifdef, 1}, 392 {"ifne", s_if, (int) O_ne}, 393 {"ifnes", s_ifeqs, 1}, 394 {"ifnotdef", s_ifdef, 1}, 395 {"incbin", s_incbin, 0}, 396 {"include", s_include, 0}, 397 {"int", cons, 4}, 398 {"irp", s_irp, 0}, 399 {"irep", s_irp, 0}, 400 {"irpc", s_irp, 1}, 401 {"irepc", s_irp, 1}, 402 {"lcomm", s_lcomm, 0}, 403 {"lflags", s_ignore, 0}, /* Listing flags. */ 404 {"linefile", s_app_line, 0}, 405 {"linkonce", s_linkonce, 0}, 406 {"list", listing_list, 1}, /* Turn listing on. */ 407 {"llen", listing_psize, 1}, 408 {"long", cons, 4}, 409 {"lsym", s_lsym, 0}, 410 {"macro", s_macro, 0}, 411 {"mexit", s_mexit, 0}, 412 {"mri", s_mri, 0}, 413 {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */ 414 {"name", s_ignore, 0}, 415 {"noaltmacro", s_altmacro, 0}, 416 {"noformat", s_ignore, 0}, 417 {"nolist", listing_list, 0}, /* Turn listing off. */ 418 {"nopage", listing_nopage, 0}, 419 {"octa", cons, 16}, 420 {"offset", s_struct, 0}, 421 {"org", s_org, 0}, 422 {"p2align", s_align_ptwo, 0}, 423 {"p2alignw", s_align_ptwo, -2}, 424 {"p2alignl", s_align_ptwo, -4}, 425 {"page", listing_eject, 0}, 426 {"plen", listing_psize, 0}, 427 {"print", s_print, 0}, 428 {"psize", listing_psize, 0}, /* Set paper size. */ 429 {"purgem", s_purgem, 0}, 430 {"quad", cons, 8}, 431 {"reloc", s_reloc, 0}, 432 {"rep", s_rept, 0}, 433 {"rept", s_rept, 0}, 434 {"rva", s_rva, 4}, 435 {"sbttl", listing_title, 1}, /* Subtitle of listing. */ 436/* scl */ 437/* sect */ 438 {"set", s_set, 0}, 439 {"short", cons, 2}, 440 {"single", float_cons, 'f'}, 441/* size */ 442 {"space", s_space, 0}, 443 {"skip", s_space, 0}, 444 {"sleb128", s_leb128, 1}, 445 {"spc", s_ignore, 0}, 446 {"stabd", s_stab, 'd'}, 447 {"stabn", s_stab, 'n'}, 448 {"stabs", s_stab, 's'}, 449 {"string", stringer, 8+1}, 450 {"string8", stringer, 8+1}, 451 {"string16", stringer, 16+1}, 452 {"string32", stringer, 32+1}, 453 {"string64", stringer, 64+1}, 454 {"struct", s_struct, 0}, 455/* tag */ 456 {"text", s_text, 0}, 457 458 /* This is for gcc to use. It's only just been added (2/94), so gcc 459 won't be able to use it for a while -- probably a year or more. 460 But once this has been released, check with gcc maintainers 461 before deleting it or even changing the spelling. */ 462 {"this_GCC_requires_the_GNU_assembler", s_ignore, 0}, 463 /* If we're folding case -- done for some targets, not necessarily 464 all -- the above string in an input file will be converted to 465 this one. Match it either way... */ 466 {"this_gcc_requires_the_gnu_assembler", s_ignore, 0}, 467 468 {"title", listing_title, 0}, /* Listing title. */ 469 {"ttl", listing_title, 0}, 470/* type */ 471 {"uleb128", s_leb128, 0}, 472/* use */ 473/* val */ 474 {"xcom", s_comm, 0}, 475 {"xdef", s_globl, 0}, 476 {"xref", s_ignore, 0}, 477 {"xstabs", s_xstab, 's'}, 478 {"warning", s_errwarn, 0}, 479 {"weakref", s_weakref, 0}, 480 {"word", cons, 2}, 481 {"zero", s_space, 0}, 482 {NULL, NULL, 0} /* End sentinel. */ 483}; 484 485static offsetT 486get_absolute_expr (expressionS *exp) 487{ 488 expression_and_evaluate (exp); 489 490 if (exp->X_op != O_constant) 491 { 492 if (exp->X_op != O_absent) 493 as_bad (_("bad or irreducible absolute expression")); 494 exp->X_add_number = 0; 495 } 496 return exp->X_add_number; 497} 498 499offsetT 500get_absolute_expression (void) 501{ 502 expressionS exp; 503 504 return get_absolute_expr (&exp); 505} 506 507static int pop_override_ok = 0; 508static const char *pop_table_name; 509 510void 511pop_insert (const pseudo_typeS *table) 512{ 513 const char *errtxt; 514 const pseudo_typeS *pop; 515 for (pop = table; pop->poc_name; pop++) 516 { 517 errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop); 518 if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists"))) 519 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name, 520 errtxt); 521 } 522} 523 524#ifndef md_pop_insert 525#define md_pop_insert() pop_insert(md_pseudo_table) 526#endif 527 528#ifndef obj_pop_insert 529#define obj_pop_insert() pop_insert(obj_pseudo_table) 530#endif 531 532#ifndef cfi_pop_insert 533#define cfi_pop_insert() pop_insert(cfi_pseudo_table) 534#endif 535 536static void 537pobegin (void) 538{ 539 po_hash = hash_new (); 540 541 /* Do the target-specific pseudo ops. */ 542 pop_table_name = "md"; 543 md_pop_insert (); 544 545 /* Now object specific. Skip any that were in the target table. */ 546 pop_table_name = "obj"; 547 pop_override_ok = 1; 548 obj_pop_insert (); 549 550 /* Now portable ones. Skip any that we've seen already. */ 551 pop_table_name = "standard"; 552 pop_insert (potable); 553 554 /* Now CFI ones. */ 555 pop_table_name = "cfi"; 556 pop_override_ok = 1; 557 cfi_pop_insert (); 558} 559 560#define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \ 561 if (ignore_input ()) \ 562 { \ 563 char *eol = find_end_of_line (input_line_pointer - (num_read), \ 564 flag_m68k_mri); \ 565 input_line_pointer = (input_line_pointer <= buffer_limit \ 566 && eol >= buffer_limit) \ 567 ? buffer_limit \ 568 : eol + 1; \ 569 continue; \ 570 } 571 572/* This function is used when scrubbing the characters between #APP 573 and #NO_APP. */ 574 575static char *scrub_string; 576static char *scrub_string_end; 577 578static size_t 579scrub_from_string (char *buf, size_t buflen) 580{ 581 size_t copy; 582 583 copy = scrub_string_end - scrub_string; 584 if (copy > buflen) 585 copy = buflen; 586 memcpy (buf, scrub_string, copy); 587 scrub_string += copy; 588 return copy; 589} 590 591/* Helper function of read_a_source_file, which tries to expand a macro. */ 592static int 593try_macro (char term, const char *line) 594{ 595 sb out; 596 const char *err; 597 macro_entry *macro; 598 599 if (check_macro (line, &out, &err, ¯o)) 600 { 601 if (err != NULL) 602 as_bad ("%s", err); 603 *input_line_pointer++ = term; 604 input_scrub_include_sb (&out, 605 input_line_pointer, 1); 606 sb_kill (&out); 607 buffer_limit = 608 input_scrub_next_buffer (&input_line_pointer); 609#ifdef md_macro_info 610 md_macro_info (macro); 611#endif 612 return 1; 613 } 614 return 0; 615} 616 617#ifdef HANDLE_BUNDLE 618/* Start a new instruction bundle. Returns the rs_align_code frag that 619 will be used to align the new bundle. */ 620static fragS * 621start_bundle (void) 622{ 623 fragS *frag = frag_now; 624 625 frag_align_code (0, 0); 626 627 while (frag->fr_type != rs_align_code) 628 frag = frag->fr_next; 629 630 gas_assert (frag != frag_now); 631 632 return frag; 633} 634 635/* Calculate the maximum size after relaxation of the region starting 636 at the given frag and extending through frag_now (which is unfinished). */ 637static unsigned int 638pending_bundle_size (fragS *frag) 639{ 640 unsigned int offset = frag->fr_fix; 641 unsigned int size = 0; 642 643 gas_assert (frag != frag_now); 644 gas_assert (frag->fr_type == rs_align_code); 645 646 while (frag != frag_now) 647 { 648 /* This should only happen in what will later become an error case. */ 649 if (frag == NULL) 650 return 0; 651 652 size += frag->fr_fix; 653 if (frag->fr_type == rs_machine_dependent) 654 size += md_frag_max_var (frag); 655 656 frag = frag->fr_next; 657 } 658 659 gas_assert (frag == frag_now); 660 size += frag_now_fix (); 661 if (frag->fr_type == rs_machine_dependent) 662 size += md_frag_max_var (frag); 663 664 gas_assert (size >= offset); 665 666 return size - offset; 667} 668 669/* Finish off the frag created to ensure bundle alignment. */ 670static void 671finish_bundle (fragS *frag, unsigned int size) 672{ 673 gas_assert (bundle_align_p2 > 0); 674 gas_assert (frag->fr_type == rs_align_code); 675 676 if (size > 1) 677 { 678 /* If there is more than a single byte, then we need to set up the 679 alignment frag. Otherwise we leave it at its initial state from 680 calling frag_align_code (0, 0), so that it does nothing. */ 681 frag->fr_offset = bundle_align_p2; 682 frag->fr_subtype = size - 1; 683 } 684 685 /* We do this every time rather than just in s_bundle_align_mode 686 so that we catch any affected section without needing hooks all 687 over for all paths that do section changes. It's cheap enough. */ 688 if (bundle_align_p2 > OCTETS_PER_BYTE_POWER) 689 record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER); 690} 691 692/* Assemble one instruction. This takes care of the bundle features 693 around calling md_assemble. */ 694static void 695assemble_one (char *line) 696{ 697 fragS *insn_start_frag = NULL; 698 699 if (bundle_lock_frchain != NULL && bundle_lock_frchain != frchain_now) 700 { 701 as_bad (_("cannot change section or subsection inside .bundle_lock")); 702 /* Clearing this serves as a marker that we have already complained. */ 703 bundle_lock_frchain = NULL; 704 } 705 706 if (bundle_lock_frchain == NULL && bundle_align_p2 > 0) 707 insn_start_frag = start_bundle (); 708 709 md_assemble (line); 710 711 if (bundle_lock_frchain != NULL) 712 { 713 /* Make sure this hasn't pushed the locked sequence 714 past the bundle size. */ 715 unsigned int bundle_size = pending_bundle_size (bundle_lock_frag); 716 if (bundle_size > (1U << bundle_align_p2)) 717 as_bad (_("\ 718.bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"), 719 bundle_size, 1U << bundle_align_p2); 720 } 721 else if (bundle_align_p2 > 0) 722 { 723 unsigned int insn_size = pending_bundle_size (insn_start_frag); 724 725 if (insn_size > (1U << bundle_align_p2)) 726 as_bad (_("\ 727single instruction is %u bytes long but .bundle_align_mode limit is %u"), 728 (unsigned int) insn_size, 1U << bundle_align_p2); 729 730 finish_bundle (insn_start_frag, insn_size); 731 } 732} 733 734#else /* !HANDLE_BUNDLE */ 735 736# define assemble_one(line) md_assemble(line) 737 738#endif /* HANDLE_BUNDLE */ 739 740static bfd_boolean 741in_bss (void) 742{ 743 flagword flags = bfd_get_section_flags (stdoutput, now_seg); 744 745 return (flags & SEC_ALLOC) && !(flags & (SEC_LOAD | SEC_HAS_CONTENTS)); 746} 747 748/* Guts of .align directive: 749 N is the power of two to which to align. A value of zero is accepted but 750 ignored: the default alignment of the section will be at least this. 751 FILL may be NULL, or it may point to the bytes of the fill pattern. 752 LEN is the length of whatever FILL points to, if anything. If LEN is zero 753 but FILL is not NULL then LEN is treated as if it were one. 754 MAX is the maximum number of characters to skip when doing the alignment, 755 or 0 if there is no maximum. */ 756 757void 758do_align (unsigned int n, char *fill, unsigned int len, unsigned int max) 759{ 760 if (now_seg == absolute_section || in_bss ()) 761 { 762 if (fill != NULL) 763 while (len-- > 0) 764 if (*fill++ != '\0') 765 { 766 if (now_seg == absolute_section) 767 as_warn (_("ignoring fill value in absolute section")); 768 else 769 as_warn (_("ignoring fill value in section `%s'"), 770 segment_name (now_seg)); 771 break; 772 } 773 fill = NULL; 774 len = 0; 775 } 776 777#ifdef md_flush_pending_output 778 md_flush_pending_output (); 779#endif 780 781#ifdef md_do_align 782 md_do_align (n, fill, len, max, just_record_alignment); 783#endif 784 785 /* Only make a frag if we HAVE to... */ 786 if ((n > OCTETS_PER_BYTE_POWER) && !need_pass_2) 787 { 788 if (fill == NULL) 789 { 790 if (subseg_text_p (now_seg)) 791 frag_align_code (n, max); 792 else 793 frag_align (n, 0, max); 794 } 795 else if (len <= 1) 796 frag_align (n, *fill, max); 797 else 798 frag_align_pattern (n, fill, len, max); 799 } 800 801#ifdef md_do_align 802 just_record_alignment: ATTRIBUTE_UNUSED_LABEL 803#endif 804 805 if (n > OCTETS_PER_BYTE_POWER) 806 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER); 807} 808 809/* We read the file, putting things into a web that represents what we 810 have been reading. */ 811void 812read_a_source_file (const char *name) 813{ 814 char nul_char; 815 char next_char; 816 char *s; /* String of symbol, '\0' appended. */ 817 int temp; 818 pseudo_typeS *pop; 819 820#ifdef WARN_COMMENTS 821 found_comment = 0; 822#endif 823 824 buffer = input_scrub_new_file (name); 825 826 listing_file (name); 827 listing_newline (NULL); 828 register_dependency (name); 829 830 /* Generate debugging information before we've read anything in to denote 831 this file as the "main" source file and not a subordinate one 832 (e.g. N_SO vs N_SOL in stabs). */ 833 generate_file_debug (); 834 835 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0) 836 { /* We have another line to parse. */ 837#ifndef NO_LISTING 838 /* In order to avoid listing macro expansion lines with labels 839 multiple times, keep track of which line was last issued. */ 840 static char *last_eol; 841 842 last_eol = NULL; 843#endif 844 while (input_line_pointer < buffer_limit) 845 { 846 bfd_boolean was_new_line; 847 /* We have more of this buffer to parse. */ 848 849 /* We now have input_line_pointer->1st char of next line. 850 If input_line_pointer [-1] == '\n' then we just 851 scanned another line: so bump line counters. */ 852 was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]]; 853 if (was_new_line) 854 { 855 symbol_set_value_now (&dot_symbol); 856#ifdef md_start_line_hook 857 md_start_line_hook (); 858#endif 859 if (input_line_pointer[-1] == '\n') 860 bump_line_counters (); 861 } 862 863#ifndef NO_LISTING 864 /* If listing is on, and we are expanding a macro, then give 865 the listing code the contents of the expanded line. */ 866 if (listing) 867 { 868 if ((listing & LISTING_MACEXP) && macro_nest > 0) 869 { 870 /* Find the end of the current expanded macro line. */ 871 s = find_end_of_line (input_line_pointer, flag_m68k_mri); 872 873 if (s != last_eol) 874 { 875 char *copy; 876 int len; 877 878 last_eol = s; 879 /* Copy it for safe keeping. Also give an indication of 880 how much macro nesting is involved at this point. */ 881 len = s - input_line_pointer; 882 copy = XNEWVEC (char, len + macro_nest + 2); 883 memset (copy, '>', macro_nest); 884 copy[macro_nest] = ' '; 885 memcpy (copy + macro_nest + 1, input_line_pointer, len); 886 copy[macro_nest + 1 + len] = '\0'; 887 888 /* Install the line with the listing facility. */ 889 listing_newline (copy); 890 } 891 } 892 else 893 listing_newline (NULL); 894 } 895#endif 896 if (was_new_line) 897 { 898 line_label = NULL; 899 900 if (LABELS_WITHOUT_COLONS || flag_m68k_mri) 901 { 902 next_char = * input_line_pointer; 903 /* Text at the start of a line must be a label, we 904 run down and stick a colon in. */ 905 if (is_name_beginner (next_char) || next_char == '"') 906 { 907 char *line_start; 908 int mri_line_macro; 909 910 HANDLE_CONDITIONAL_ASSEMBLY (0); 911 912 nul_char = get_symbol_name (& line_start); 913 next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char); 914 915 /* In MRI mode, the EQU and MACRO pseudoops must 916 be handled specially. */ 917 mri_line_macro = 0; 918 if (flag_m68k_mri) 919 { 920 char *rest = input_line_pointer + 1; 921 922 if (*rest == ':') 923 ++rest; 924 if (*rest == ' ' || *rest == '\t') 925 ++rest; 926 if ((strncasecmp (rest, "EQU", 3) == 0 927 || strncasecmp (rest, "SET", 3) == 0) 928 && (rest[3] == ' ' || rest[3] == '\t')) 929 { 930 input_line_pointer = rest + 3; 931 equals (line_start, 932 strncasecmp (rest, "SET", 3) == 0); 933 continue; 934 } 935 if (strncasecmp (rest, "MACRO", 5) == 0 936 && (rest[5] == ' ' 937 || rest[5] == '\t' 938 || is_end_of_line[(unsigned char) rest[5]])) 939 mri_line_macro = 1; 940 } 941 942 /* In MRI mode, we need to handle the MACRO 943 pseudo-op specially: we don't want to put the 944 symbol in the symbol table. */ 945 if (!mri_line_macro 946#ifdef TC_START_LABEL_WITHOUT_COLON 947 && TC_START_LABEL_WITHOUT_COLON (nul_char, next_char) 948#endif 949 ) 950 line_label = colon (line_start); 951 else 952 line_label = symbol_create (line_start, 953 absolute_section, 954 (valueT) 0, 955 &zero_address_frag); 956 957 next_char = restore_line_pointer (nul_char); 958 if (next_char == ':') 959 input_line_pointer++; 960 } 961 } 962 } 963 964 /* We are at the beginning of a line, or similar place. 965 We expect a well-formed assembler statement. 966 A "symbol-name:" is a statement. 967 968 Depending on what compiler is used, the order of these tests 969 may vary to catch most common case 1st. 970 Each test is independent of all other tests at the (top) 971 level. */ 972 do 973 nul_char = next_char = *input_line_pointer++; 974 while (next_char == '\t' || next_char == ' ' || next_char == '\f'); 975 976 /* C is the 1st significant character. 977 Input_line_pointer points after that character. */ 978 if (is_name_beginner (next_char) || next_char == '"') 979 { 980 char *rest; 981 982 /* Want user-defined label or pseudo/opcode. */ 983 HANDLE_CONDITIONAL_ASSEMBLY (1); 984 985 --input_line_pointer; 986 nul_char = get_symbol_name (& s); /* name's delimiter. */ 987 next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char); 988 rest = input_line_pointer + (nul_char == '"' ? 2 : 1); 989 990 /* NEXT_CHAR is character after symbol. 991 The end of symbol in the input line is now '\0'. 992 S points to the beginning of the symbol. 993 [In case of pseudo-op, s->'.'.] 994 Input_line_pointer->'\0' where NUL_CHAR was. */ 995 if (TC_START_LABEL (s, nul_char, next_char)) 996 { 997 if (flag_m68k_mri) 998 { 999 /* In MRI mode, \tsym: set 0 is permitted. */ 1000 if (*rest == ':') 1001 ++rest; 1002 1003 if (*rest == ' ' || *rest == '\t') 1004 ++rest; 1005 1006 if ((strncasecmp (rest, "EQU", 3) == 0 1007 || strncasecmp (rest, "SET", 3) == 0) 1008 && (rest[3] == ' ' || rest[3] == '\t')) 1009 { 1010 input_line_pointer = rest + 3; 1011 equals (s, 1); 1012 continue; 1013 } 1014 } 1015 1016 line_label = colon (s); /* User-defined label. */ 1017 restore_line_pointer (nul_char); 1018 ++ input_line_pointer; 1019#ifdef tc_check_label 1020 tc_check_label (line_label); 1021#endif 1022 /* Input_line_pointer->after ':'. */ 1023 SKIP_WHITESPACE (); 1024 } 1025 else if ((next_char == '=' && *rest == '=') 1026 || ((next_char == ' ' || next_char == '\t') 1027 && rest[0] == '=' 1028 && rest[1] == '=')) 1029 { 1030 equals (s, -1); 1031 demand_empty_rest_of_line (); 1032 } 1033 else if ((next_char == '=' 1034 || ((next_char == ' ' || next_char == '\t') 1035 && *rest == '=')) 1036#ifdef TC_EQUAL_IN_INSN 1037 && !TC_EQUAL_IN_INSN (next_char, s) 1038#endif 1039 ) 1040 { 1041 equals (s, 1); 1042 demand_empty_rest_of_line (); 1043 } 1044 else 1045 { 1046 /* Expect pseudo-op or machine instruction. */ 1047 pop = NULL; 1048 1049#ifndef TC_CASE_SENSITIVE 1050 { 1051 char *s2 = s; 1052 1053 strncpy (original_case_string, s2, sizeof (original_case_string)); 1054 original_case_string[sizeof (original_case_string) - 1] = 0; 1055 1056 while (*s2) 1057 { 1058 *s2 = TOLOWER (*s2); 1059 s2++; 1060 } 1061 } 1062#endif 1063 if (NO_PSEUDO_DOT || flag_m68k_mri) 1064 { 1065 /* The MRI assembler uses pseudo-ops without 1066 a period. */ 1067 pop = (pseudo_typeS *) hash_find (po_hash, s); 1068 if (pop != NULL && pop->poc_handler == NULL) 1069 pop = NULL; 1070 } 1071 1072 if (pop != NULL 1073 || (!flag_m68k_mri && *s == '.')) 1074 { 1075 /* PSEUDO - OP. 1076 1077 WARNING: next_char may be end-of-line. 1078 We lookup the pseudo-op table with s+1 because we 1079 already know that the pseudo-op begins with a '.'. */ 1080 1081 if (pop == NULL) 1082 pop = (pseudo_typeS *) hash_find (po_hash, s + 1); 1083 if (pop && !pop->poc_handler) 1084 pop = NULL; 1085 1086 /* In MRI mode, we may need to insert an 1087 automatic alignment directive. What a hack 1088 this is. */ 1089 if (mri_pending_align 1090 && (pop == NULL 1091 || !((pop->poc_handler == cons 1092 && pop->poc_val == 1) 1093 || (pop->poc_handler == s_space 1094 && pop->poc_val == 1) 1095#ifdef tc_conditional_pseudoop 1096 || tc_conditional_pseudoop (pop) 1097#endif 1098 || pop->poc_handler == s_if 1099 || pop->poc_handler == s_ifdef 1100 || pop->poc_handler == s_ifc 1101 || pop->poc_handler == s_ifeqs 1102 || pop->poc_handler == s_else 1103 || pop->poc_handler == s_endif 1104 || pop->poc_handler == s_globl 1105 || pop->poc_handler == s_ignore))) 1106 { 1107 do_align (1, (char *) NULL, 0, 0); 1108 mri_pending_align = 0; 1109 1110 if (line_label != NULL) 1111 { 1112 symbol_set_frag (line_label, frag_now); 1113 S_SET_VALUE (line_label, frag_now_fix ()); 1114 } 1115 } 1116 1117 /* Print the error msg now, while we still can. */ 1118 if (pop == NULL) 1119 { 1120 char *end = input_line_pointer; 1121 1122 (void) restore_line_pointer (nul_char); 1123 s_ignore (0); 1124 nul_char = next_char = *--input_line_pointer; 1125 *input_line_pointer = '\0'; 1126 if (! macro_defined || ! try_macro (next_char, s)) 1127 { 1128 *end = '\0'; 1129 as_bad (_("unknown pseudo-op: `%s'"), s); 1130 *input_line_pointer++ = nul_char; 1131 } 1132 continue; 1133 } 1134 1135 /* Put it back for error messages etc. */ 1136 next_char = restore_line_pointer (nul_char); 1137 /* The following skip of whitespace is compulsory. 1138 A well shaped space is sometimes all that separates 1139 keyword from operands. */ 1140 if (next_char == ' ' || next_char == '\t') 1141 input_line_pointer++; 1142 1143 /* Input_line is restored. 1144 Input_line_pointer->1st non-blank char 1145 after pseudo-operation. */ 1146 (*pop->poc_handler) (pop->poc_val); 1147 1148 /* If that was .end, just get out now. */ 1149 if (pop->poc_handler == s_end) 1150 goto quit; 1151 } 1152 else 1153 { 1154 /* WARNING: next_char may be end-of-line. */ 1155 /* Also: input_line_pointer->`\0` where nul_char was. */ 1156 (void) restore_line_pointer (nul_char); 1157 input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0); 1158 next_char = nul_char = *input_line_pointer; 1159 *input_line_pointer = '\0'; 1160 1161 generate_lineno_debug (); 1162 1163 if (macro_defined && try_macro (next_char, s)) 1164 continue; 1165 1166 if (mri_pending_align) 1167 { 1168 do_align (1, (char *) NULL, 0, 0); 1169 mri_pending_align = 0; 1170 if (line_label != NULL) 1171 { 1172 symbol_set_frag (line_label, frag_now); 1173 S_SET_VALUE (line_label, frag_now_fix ()); 1174 } 1175 } 1176 1177 assemble_one (s); /* Assemble 1 instruction. */ 1178 1179 /* PR 19630: The backend may have set ilp to NULL 1180 if it encountered a catastrophic failure. */ 1181 if (input_line_pointer == NULL) 1182 as_fatal (_("unable to continue with assembly.")); 1183 1184 *input_line_pointer++ = nul_char; 1185 1186 /* We resume loop AFTER the end-of-line from 1187 this instruction. */ 1188 } 1189 } 1190 continue; 1191 } 1192 1193 /* Empty statement? */ 1194 if (is_end_of_line[(unsigned char) next_char]) 1195 continue; 1196 1197 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (next_char)) 1198 { 1199 /* local label ("4:") */ 1200 char *backup = input_line_pointer; 1201 1202 HANDLE_CONDITIONAL_ASSEMBLY (1); 1203 1204 temp = next_char - '0'; 1205 1206 if (nul_char == '"') 1207 ++ input_line_pointer; 1208 1209 /* Read the whole number. */ 1210 while (ISDIGIT (*input_line_pointer)) 1211 { 1212 temp = (temp * 10) + *input_line_pointer - '0'; 1213 ++input_line_pointer; 1214 } 1215 1216 if (LOCAL_LABELS_DOLLAR 1217 && *input_line_pointer == '$' 1218 && *(input_line_pointer + 1) == ':') 1219 { 1220 input_line_pointer += 2; 1221 1222 if (dollar_label_defined (temp)) 1223 { 1224 as_fatal (_("label \"%d$\" redefined"), temp); 1225 } 1226 1227 define_dollar_label (temp); 1228 colon (dollar_label_name (temp, 0)); 1229 continue; 1230 } 1231 1232 if (LOCAL_LABELS_FB 1233 && *input_line_pointer++ == ':') 1234 { 1235 fb_label_instance_inc (temp); 1236 colon (fb_label_name (temp, 0)); 1237 continue; 1238 } 1239 1240 input_line_pointer = backup; 1241 } 1242 1243 if (next_char && strchr (line_comment_chars, next_char)) 1244 { /* Its a comment. Better say APP or NO_APP. */ 1245 sb sbuf; 1246 char *ends; 1247 char *new_buf; 1248 char *new_tmp; 1249 unsigned int new_length; 1250 char *tmp_buf = 0; 1251 1252 s = input_line_pointer; 1253 if (strncmp (s, "APP\n", 4)) 1254 { 1255 /* We ignore it. */ 1256 ignore_rest_of_line (); 1257 continue; 1258 } 1259 bump_line_counters (); 1260 s += 4; 1261 1262 ends = strstr (s, "#NO_APP\n"); 1263 1264 if (!ends) 1265 { 1266 unsigned int tmp_len; 1267 unsigned int num; 1268 1269 /* The end of the #APP wasn't in this buffer. We 1270 keep reading in buffers until we find the #NO_APP 1271 that goes with this #APP There is one. The specs 1272 guarantee it... */ 1273 tmp_len = buffer_limit - s; 1274 tmp_buf = XNEWVEC (char, tmp_len + 1); 1275 memcpy (tmp_buf, s, tmp_len); 1276 do 1277 { 1278 new_tmp = input_scrub_next_buffer (&buffer); 1279 if (!new_tmp) 1280 break; 1281 else 1282 buffer_limit = new_tmp; 1283 input_line_pointer = buffer; 1284 ends = strstr (buffer, "#NO_APP\n"); 1285 if (ends) 1286 num = ends - buffer; 1287 else 1288 num = buffer_limit - buffer; 1289 1290 tmp_buf = XRESIZEVEC (char, tmp_buf, tmp_len + num); 1291 memcpy (tmp_buf + tmp_len, buffer, num); 1292 tmp_len += num; 1293 } 1294 while (!ends); 1295 1296 input_line_pointer = ends ? ends + 8 : NULL; 1297 1298 s = tmp_buf; 1299 ends = s + tmp_len; 1300 1301 } 1302 else 1303 { 1304 input_line_pointer = ends + 8; 1305 } 1306 1307 scrub_string = s; 1308 scrub_string_end = ends; 1309 1310 new_length = ends - s; 1311 new_buf = XNEWVEC (char, new_length); 1312 new_tmp = new_buf; 1313 for (;;) 1314 { 1315 size_t space; 1316 size_t size; 1317 1318 space = (new_buf + new_length) - new_tmp; 1319 size = do_scrub_chars (scrub_from_string, new_tmp, space); 1320 1321 if (size < space) 1322 { 1323 new_tmp[size] = 0; 1324 break; 1325 } 1326 1327 new_buf = XRESIZEVEC (char, new_buf, new_length + 100); 1328 new_tmp = new_buf + new_length; 1329 new_length += 100; 1330 } 1331 1332 if (tmp_buf) 1333 free (tmp_buf); 1334 1335 /* We've "scrubbed" input to the preferred format. In the 1336 process we may have consumed the whole of the remaining 1337 file (and included files). We handle this formatted 1338 input similar to that of macro expansion, letting 1339 actual macro expansion (possibly nested) and other 1340 input expansion work. Beware that in messages, line 1341 numbers and possibly file names will be incorrect. */ 1342 new_length = strlen (new_buf); 1343 sb_build (&sbuf, new_length); 1344 sb_add_buffer (&sbuf, new_buf, new_length); 1345 input_scrub_include_sb (&sbuf, input_line_pointer, 0); 1346 sb_kill (&sbuf); 1347 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 1348 free (new_buf); 1349 continue; 1350 } 1351 1352 HANDLE_CONDITIONAL_ASSEMBLY (1); 1353 1354#ifdef tc_unrecognized_line 1355 if (tc_unrecognized_line (next_char)) 1356 continue; 1357#endif 1358 input_line_pointer--; 1359 /* Report unknown char as error. */ 1360 demand_empty_rest_of_line (); 1361 } 1362 } 1363 1364 quit: 1365 symbol_set_value_now (&dot_symbol); 1366 1367#ifdef HANDLE_BUNDLE 1368 if (bundle_lock_frag != NULL) 1369 { 1370 as_bad_where (bundle_lock_frag->fr_file, bundle_lock_frag->fr_line, 1371 _(".bundle_lock with no matching .bundle_unlock")); 1372 bundle_lock_frag = NULL; 1373 bundle_lock_frchain = NULL; 1374 bundle_lock_depth = 0; 1375 } 1376#endif 1377 1378#ifdef md_cleanup 1379 md_cleanup (); 1380#endif 1381 /* Close the input file. */ 1382 input_scrub_close (); 1383#ifdef WARN_COMMENTS 1384 { 1385 if (warn_comment && found_comment) 1386 as_warn_where (found_comment_file, found_comment, 1387 "first comment found here"); 1388 } 1389#endif 1390} 1391 1392/* Convert O_constant expression EXP into the equivalent O_big representation. 1393 Take the sign of the number from SIGN rather than X_add_number. */ 1394 1395static void 1396convert_to_bignum (expressionS *exp, int sign) 1397{ 1398 valueT value; 1399 unsigned int i; 1400 1401 value = exp->X_add_number; 1402 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++) 1403 { 1404 generic_bignum[i] = value & LITTLENUM_MASK; 1405 value >>= LITTLENUM_NUMBER_OF_BITS; 1406 } 1407 /* Add a sequence of sign bits if the top bit of X_add_number is not 1408 the sign of the original value. */ 1409 if ((exp->X_add_number < 0) == !sign) 1410 generic_bignum[i++] = sign ? LITTLENUM_MASK : 0; 1411 exp->X_op = O_big; 1412 exp->X_add_number = i; 1413} 1414 1415/* For most MRI pseudo-ops, the line actually ends at the first 1416 nonquoted space. This function looks for that point, stuffs a null 1417 in, and sets *STOPCP to the character that used to be there, and 1418 returns the location. 1419 1420 Until I hear otherwise, I am going to assume that this is only true 1421 for the m68k MRI assembler. */ 1422 1423char * 1424mri_comment_field (char *stopcp) 1425{ 1426 char *s; 1427#ifdef TC_M68K 1428 int inquote = 0; 1429 1430 know (flag_m68k_mri); 1431 1432 for (s = input_line_pointer; 1433 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t') 1434 || inquote); 1435 s++) 1436 { 1437 if (*s == '\'') 1438 inquote = !inquote; 1439 } 1440#else 1441 for (s = input_line_pointer; 1442 !is_end_of_line[(unsigned char) *s]; 1443 s++) 1444 ; 1445#endif 1446 *stopcp = *s; 1447 *s = '\0'; 1448 1449 return s; 1450} 1451 1452/* Skip to the end of an MRI comment field. */ 1453 1454void 1455mri_comment_end (char *stop, int stopc) 1456{ 1457 know (flag_mri); 1458 1459 input_line_pointer = stop; 1460 *stop = stopc; 1461 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 1462 ++input_line_pointer; 1463} 1464 1465void 1466s_abort (int ignore ATTRIBUTE_UNUSED) 1467{ 1468 as_fatal (_(".abort detected. Abandoning ship.")); 1469} 1470 1471/* Handle the .align pseudo-op. A positive ARG is a default alignment 1472 (in bytes). A negative ARG is the negative of the length of the 1473 fill pattern. BYTES_P is non-zero if the alignment value should be 1474 interpreted as the byte boundary, rather than the power of 2. */ 1475#ifndef TC_ALIGN_LIMIT 1476#define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1) 1477#endif 1478 1479static void 1480s_align (signed int arg, int bytes_p) 1481{ 1482 unsigned int align_limit = TC_ALIGN_LIMIT; 1483 unsigned int align; 1484 char *stop = NULL; 1485 char stopc = 0; 1486 offsetT fill = 0; 1487 unsigned int max; 1488 int fill_p; 1489 1490 if (flag_mri) 1491 stop = mri_comment_field (&stopc); 1492 1493 if (is_end_of_line[(unsigned char) *input_line_pointer]) 1494 { 1495 if (arg < 0) 1496 align = 0; 1497 else 1498 align = arg; /* Default value from pseudo-op table. */ 1499 } 1500 else 1501 { 1502 align = get_absolute_expression (); 1503 SKIP_WHITESPACE (); 1504 1505#ifdef TC_ALIGN_ZERO_IS_DEFAULT 1506 if (arg > 0 && align == 0) 1507 align = arg; 1508#endif 1509 } 1510 1511 if (bytes_p) 1512 { 1513 /* Convert to a power of 2. */ 1514 if (align != 0) 1515 { 1516 unsigned int i; 1517 1518 for (i = 0; (align & 1) == 0; align >>= 1, ++i) 1519 ; 1520 if (align != 1) 1521 as_bad (_("alignment not a power of 2")); 1522 1523 align = i; 1524 } 1525 } 1526 1527 if (align > align_limit) 1528 { 1529 align = align_limit; 1530 as_warn (_("alignment too large: %u assumed"), align); 1531 } 1532 1533 if (*input_line_pointer != ',') 1534 { 1535 fill_p = 0; 1536 max = 0; 1537 } 1538 else 1539 { 1540 ++input_line_pointer; 1541 if (*input_line_pointer == ',') 1542 fill_p = 0; 1543 else 1544 { 1545 fill = get_absolute_expression (); 1546 SKIP_WHITESPACE (); 1547 fill_p = 1; 1548 } 1549 1550 if (*input_line_pointer != ',') 1551 max = 0; 1552 else 1553 { 1554 ++input_line_pointer; 1555 max = get_absolute_expression (); 1556 } 1557 } 1558 1559 if (!fill_p) 1560 { 1561 if (arg < 0) 1562 as_warn (_("expected fill pattern missing")); 1563 do_align (align, (char *) NULL, 0, max); 1564 } 1565 else 1566 { 1567 unsigned int fill_len; 1568 1569 if (arg >= 0) 1570 fill_len = 1; 1571 else 1572 fill_len = -arg; 1573 1574 if (fill_len <= 1) 1575 { 1576 char fill_char = 0; 1577 1578 fill_char = fill; 1579 do_align (align, &fill_char, fill_len, max); 1580 } 1581 else 1582 { 1583 char ab[16]; 1584 1585 if ((size_t) fill_len > sizeof ab) 1586 { 1587 as_warn (_("fill pattern too long, truncating to %u"), 1588 (unsigned) sizeof ab); 1589 fill_len = sizeof ab; 1590 } 1591 1592 md_number_to_chars (ab, fill, fill_len); 1593 do_align (align, ab, fill_len, max); 1594 } 1595 } 1596 1597 demand_empty_rest_of_line (); 1598 1599 if (flag_mri) 1600 mri_comment_end (stop, stopc); 1601} 1602 1603/* Handle the .align pseudo-op on machines where ".align 4" means 1604 align to a 4 byte boundary. */ 1605 1606void 1607s_align_bytes (int arg) 1608{ 1609 s_align (arg, 1); 1610} 1611 1612/* Handle the .align pseudo-op on machines where ".align 4" means align 1613 to a 2**4 boundary. */ 1614 1615void 1616s_align_ptwo (int arg) 1617{ 1618 s_align (arg, 0); 1619} 1620 1621/* Switch in and out of alternate macro mode. */ 1622 1623static void 1624s_altmacro (int on) 1625{ 1626 demand_empty_rest_of_line (); 1627 macro_set_alternate (on); 1628} 1629 1630/* Read a symbol name from input_line_pointer. 1631 1632 Stores the symbol name in a buffer and returns a pointer to this buffer. 1633 The buffer is xalloc'ed. It is the caller's responsibility to free 1634 this buffer. 1635 1636 The name is not left in the i_l_p buffer as it may need processing 1637 to handle escape characters. 1638 1639 Advances i_l_p to the next non-whitespace character. 1640 1641 If a symbol name could not be read, the routine issues an error 1642 messages, skips to the end of the line and returns NULL. */ 1643 1644char * 1645read_symbol_name (void) 1646{ 1647 char * name; 1648 char * start; 1649 char c; 1650 1651 c = *input_line_pointer++; 1652 1653 if (c == '"') 1654 { 1655#define SYM_NAME_CHUNK_LEN 128 1656 ptrdiff_t len = SYM_NAME_CHUNK_LEN; 1657 char * name_end; 1658 unsigned int C; 1659 1660 start = name = XNEWVEC (char, len + 1); 1661 1662 name_end = name + SYM_NAME_CHUNK_LEN; 1663 1664 while (is_a_char (C = next_char_of_string ())) 1665 { 1666 if (name >= name_end) 1667 { 1668 ptrdiff_t sofar; 1669 1670 sofar = name - start; 1671 len += SYM_NAME_CHUNK_LEN; 1672 start = XRESIZEVEC (char, start, len + 1); 1673 name_end = start + len; 1674 name = start + sofar; 1675 } 1676 1677 *name++ = (char) C; 1678 } 1679 *name = 0; 1680 1681 /* Since quoted symbol names can contain non-ASCII characters, 1682 check the string and warn if it cannot be recognised by the 1683 current character set. */ 1684 if (mbstowcs (NULL, name, len) == (size_t) -1) 1685 as_warn (_("symbol name not recognised in the current locale")); 1686 } 1687 else if (is_name_beginner (c) || c == '\001') 1688 { 1689 ptrdiff_t len; 1690 1691 name = input_line_pointer - 1; 1692 1693 /* We accept \001 in a name in case this is 1694 being called with a constructed string. */ 1695 while (is_part_of_name (c = *input_line_pointer++) 1696 || c == '\001') 1697 ; 1698 1699 len = (input_line_pointer - name) - 1; 1700 start = XNEWVEC (char, len + 1); 1701 1702 memcpy (start, name, len); 1703 start[len] = 0; 1704 1705 /* Skip a name ender char if one is present. */ 1706 if (! is_name_ender (c)) 1707 --input_line_pointer; 1708 } 1709 else 1710 name = start = NULL; 1711 1712 if (name == start) 1713 { 1714 as_bad (_("expected symbol name")); 1715 ignore_rest_of_line (); 1716 return NULL; 1717 } 1718 1719 SKIP_WHITESPACE (); 1720 1721 return start; 1722} 1723 1724 1725symbolS * 1726s_comm_internal (int param, 1727 symbolS *(*comm_parse_extra) (int, symbolS *, addressT)) 1728{ 1729 char *name; 1730 offsetT temp, size; 1731 symbolS *symbolP = NULL; 1732 char *stop = NULL; 1733 char stopc = 0; 1734 expressionS exp; 1735 1736 if (flag_mri) 1737 stop = mri_comment_field (&stopc); 1738 1739 if ((name = read_symbol_name ()) == NULL) 1740 goto out; 1741 1742 /* Accept an optional comma after the name. The comma used to be 1743 required, but Irix 5 cc does not generate it for .lcomm. */ 1744 if (*input_line_pointer == ',') 1745 input_line_pointer++; 1746 1747 temp = get_absolute_expr (&exp); 1748 size = temp; 1749 size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1; 1750 if (exp.X_op == O_absent) 1751 { 1752 as_bad (_("missing size expression")); 1753 ignore_rest_of_line (); 1754 goto out; 1755 } 1756 else if (temp != size || !exp.X_unsigned) 1757 { 1758 as_warn (_("size (%ld) out of range, ignored"), (long) temp); 1759 ignore_rest_of_line (); 1760 goto out; 1761 } 1762 1763 symbolP = symbol_find_or_make (name); 1764 if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) 1765 && !S_IS_COMMON (symbolP)) 1766 { 1767 if (!S_IS_VOLATILE (symbolP)) 1768 { 1769 symbolP = NULL; 1770 as_bad (_("symbol `%s' is already defined"), name); 1771 ignore_rest_of_line (); 1772 goto out; 1773 } 1774 symbolP = symbol_clone (symbolP, 1); 1775 S_SET_SEGMENT (symbolP, undefined_section); 1776 S_SET_VALUE (symbolP, 0); 1777 symbol_set_frag (symbolP, &zero_address_frag); 1778 S_CLEAR_VOLATILE (symbolP); 1779 } 1780 1781 size = S_GET_VALUE (symbolP); 1782 if (size == 0) 1783 size = temp; 1784 else if (size != temp) 1785 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"), 1786 name, (long) size, (long) temp); 1787 1788 if (comm_parse_extra != NULL) 1789 symbolP = (*comm_parse_extra) (param, symbolP, size); 1790 else 1791 { 1792 S_SET_VALUE (symbolP, (valueT) size); 1793 S_SET_EXTERNAL (symbolP); 1794 S_SET_SEGMENT (symbolP, bfd_com_section_ptr); 1795 } 1796 1797 demand_empty_rest_of_line (); 1798 out: 1799 if (flag_mri) 1800 mri_comment_end (stop, stopc); 1801 if (name != NULL) 1802 free (name); 1803 return symbolP; 1804} 1805 1806void 1807s_comm (int ignore) 1808{ 1809 s_comm_internal (ignore, NULL); 1810} 1811 1812/* The MRI COMMON pseudo-op. We handle this by creating a common 1813 symbol with the appropriate name. We make s_space do the right 1814 thing by increasing the size. */ 1815 1816void 1817s_mri_common (int small ATTRIBUTE_UNUSED) 1818{ 1819 char *name; 1820 char c; 1821 char *alc = NULL; 1822 symbolS *sym; 1823 offsetT align; 1824 char *stop = NULL; 1825 char stopc = 0; 1826 1827 if (!flag_mri) 1828 { 1829 s_comm (0); 1830 return; 1831 } 1832 1833 stop = mri_comment_field (&stopc); 1834 1835 SKIP_WHITESPACE (); 1836 1837 name = input_line_pointer; 1838 if (!ISDIGIT (*name)) 1839 c = get_symbol_name (& name); 1840 else 1841 { 1842 do 1843 { 1844 ++input_line_pointer; 1845 } 1846 while (ISDIGIT (*input_line_pointer)); 1847 1848 c = *input_line_pointer; 1849 *input_line_pointer = '\0'; 1850 1851 if (line_label != NULL) 1852 { 1853 alc = XNEWVEC (char, strlen (S_GET_NAME (line_label)) 1854 + (input_line_pointer - name) + 1); 1855 sprintf (alc, "%s%s", name, S_GET_NAME (line_label)); 1856 name = alc; 1857 } 1858 } 1859 1860 sym = symbol_find_or_make (name); 1861 c = restore_line_pointer (c); 1862 if (alc != NULL) 1863 free (alc); 1864 1865 if (*input_line_pointer != ',') 1866 align = 0; 1867 else 1868 { 1869 ++input_line_pointer; 1870 align = get_absolute_expression (); 1871 } 1872 1873 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym)) 1874 { 1875 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym)); 1876 ignore_rest_of_line (); 1877 mri_comment_end (stop, stopc); 1878 return; 1879 } 1880 1881 S_SET_EXTERNAL (sym); 1882 S_SET_SEGMENT (sym, bfd_com_section_ptr); 1883 mri_common_symbol = sym; 1884 1885#ifdef S_SET_ALIGN 1886 if (align != 0) 1887 S_SET_ALIGN (sym, align); 1888#else 1889 (void) align; 1890#endif 1891 1892 if (line_label != NULL) 1893 { 1894 expressionS exp; 1895 exp.X_op = O_symbol; 1896 exp.X_add_symbol = sym; 1897 exp.X_add_number = 0; 1898 symbol_set_value_expression (line_label, &exp); 1899 symbol_set_frag (line_label, &zero_address_frag); 1900 S_SET_SEGMENT (line_label, expr_section); 1901 } 1902 1903 /* FIXME: We just ignore the small argument, which distinguishes 1904 COMMON and COMMON.S. I don't know what we can do about it. */ 1905 1906 /* Ignore the type and hptype. */ 1907 if (*input_line_pointer == ',') 1908 input_line_pointer += 2; 1909 if (*input_line_pointer == ',') 1910 input_line_pointer += 2; 1911 1912 demand_empty_rest_of_line (); 1913 1914 mri_comment_end (stop, stopc); 1915} 1916 1917void 1918s_data (int ignore ATTRIBUTE_UNUSED) 1919{ 1920 segT section; 1921 int temp; 1922 1923 temp = get_absolute_expression (); 1924 if (flag_readonly_data_in_text) 1925 { 1926 section = text_section; 1927 temp += 1000; 1928 } 1929 else 1930 section = data_section; 1931 1932 subseg_set (section, (subsegT) temp); 1933 1934 demand_empty_rest_of_line (); 1935} 1936 1937/* Handle the .appfile pseudo-op. This is automatically generated by 1938 do_scrub_chars when a preprocessor # line comment is seen with a 1939 file name. This default definition may be overridden by the object 1940 or CPU specific pseudo-ops. This function is also the default 1941 definition for .file; the APPFILE argument is 1 for .appfile, 0 for 1942 .file. */ 1943 1944void 1945s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED) 1946{ 1947#ifdef LISTING 1948 if (listing) 1949 listing_source_file (file); 1950#endif 1951 register_dependency (file); 1952#ifdef obj_app_file 1953 obj_app_file (file, appfile); 1954#endif 1955} 1956 1957void 1958s_app_file (int appfile) 1959{ 1960 char *s; 1961 int length; 1962 1963 /* Some assemblers tolerate immediately following '"'. */ 1964 if ((s = demand_copy_string (&length)) != 0) 1965 { 1966 int may_omit 1967 = (!new_logical_line_flags (s, -1, 1) && appfile); 1968 1969 /* In MRI mode, the preprocessor may have inserted an extraneous 1970 backquote. */ 1971 if (flag_m68k_mri 1972 && *input_line_pointer == '\'' 1973 && is_end_of_line[(unsigned char) input_line_pointer[1]]) 1974 ++input_line_pointer; 1975 1976 demand_empty_rest_of_line (); 1977 if (!may_omit) 1978 s_app_file_string (s, appfile); 1979 } 1980} 1981 1982static int 1983get_linefile_number (int *flag) 1984{ 1985 SKIP_WHITESPACE (); 1986 1987 if (*input_line_pointer < '0' || *input_line_pointer > '9') 1988 return 0; 1989 1990 *flag = get_absolute_expression (); 1991 1992 return 1; 1993} 1994 1995/* Handle the .appline pseudo-op. This is automatically generated by 1996 do_scrub_chars when a preprocessor # line comment is seen. This 1997 default definition may be overridden by the object or CPU specific 1998 pseudo-ops. */ 1999 2000void 2001s_app_line (int appline) 2002{ 2003 char *file = NULL; 2004 int l; 2005 2006 /* The given number is that of the next line. */ 2007 if (appline) 2008 l = get_absolute_expression (); 2009 else if (!get_linefile_number (&l)) 2010 { 2011 ignore_rest_of_line (); 2012 return; 2013 } 2014 2015 l--; 2016 2017 if (l < -1) 2018 /* Some of the back ends can't deal with non-positive line numbers. 2019 Besides, it's silly. GCC however will generate a line number of 2020 zero when it is pre-processing builtins for assembler-with-cpp files: 2021 2022 # 0 "<built-in>" 2023 2024 We do not want to barf on this, especially since such files are used 2025 in the GCC and GDB testsuites. So we check for negative line numbers 2026 rather than non-positive line numbers. */ 2027 as_warn (_("line numbers must be positive; line number %d rejected"), 2028 l + 1); 2029 else 2030 { 2031 int flags = 0; 2032 int length = 0; 2033 2034 if (!appline) 2035 { 2036 SKIP_WHITESPACE (); 2037 2038 if (*input_line_pointer == '"') 2039 file = demand_copy_string (&length); 2040 2041 if (file) 2042 { 2043 int this_flag; 2044 2045 while (get_linefile_number (&this_flag)) 2046 switch (this_flag) 2047 { 2048 /* From GCC's cpp documentation: 2049 1: start of a new file. 2050 2: returning to a file after having included 2051 another file. 2052 3: following text comes from a system header file. 2053 4: following text should be treated as extern "C". 2054 2055 4 is nonsensical for the assembler; 3, we don't 2056 care about, so we ignore it just in case a 2057 system header file is included while 2058 preprocessing assembly. So 1 and 2 are all we 2059 care about, and they are mutually incompatible. 2060 new_logical_line_flags() demands this. */ 2061 case 1: 2062 case 2: 2063 if (flags && flags != (1 << this_flag)) 2064 as_warn (_("incompatible flag %i in line directive"), 2065 this_flag); 2066 else 2067 flags |= 1 << this_flag; 2068 break; 2069 2070 case 3: 2071 case 4: 2072 /* We ignore these. */ 2073 break; 2074 2075 default: 2076 as_warn (_("unsupported flag %i in line directive"), 2077 this_flag); 2078 break; 2079 } 2080 2081 if (!is_end_of_line[(unsigned char)*input_line_pointer]) 2082 file = 0; 2083 } 2084 } 2085 2086 if (appline || file) 2087 { 2088 new_logical_line_flags (file, l, flags); 2089#ifdef LISTING 2090 if (listing) 2091 listing_source_line (l); 2092#endif 2093 } 2094 } 2095 if (appline || file) 2096 demand_empty_rest_of_line (); 2097 else 2098 ignore_rest_of_line (); 2099} 2100 2101/* Handle the .end pseudo-op. Actually, the real work is done in 2102 read_a_source_file. */ 2103 2104void 2105s_end (int ignore ATTRIBUTE_UNUSED) 2106{ 2107 if (flag_mri) 2108 { 2109 /* The MRI assembler permits the start symbol to follow .end, 2110 but we don't support that. */ 2111 SKIP_WHITESPACE (); 2112 if (!is_end_of_line[(unsigned char) *input_line_pointer] 2113 && *input_line_pointer != '*' 2114 && *input_line_pointer != '!') 2115 as_warn (_("start address not supported")); 2116 } 2117} 2118 2119/* Handle the .err pseudo-op. */ 2120 2121void 2122s_err (int ignore ATTRIBUTE_UNUSED) 2123{ 2124 as_bad (_(".err encountered")); 2125 demand_empty_rest_of_line (); 2126} 2127 2128/* Handle the .error and .warning pseudo-ops. */ 2129 2130void 2131s_errwarn (int err) 2132{ 2133 int len; 2134 /* The purpose for the conditional assignment is not to 2135 internationalize the directive itself, but that we need a 2136 self-contained message, one that can be passed like the 2137 demand_copy_C_string return value, and with no assumption on the 2138 location of the name of the directive within the message. */ 2139 const char *msg 2140 = (err ? _(".error directive invoked in source file") 2141 : _(".warning directive invoked in source file")); 2142 2143 if (!is_it_end_of_statement ()) 2144 { 2145 if (*input_line_pointer != '\"') 2146 { 2147 as_bad (_("%s argument must be a string"), 2148 err ? ".error" : ".warning"); 2149 ignore_rest_of_line (); 2150 return; 2151 } 2152 2153 msg = demand_copy_C_string (&len); 2154 if (msg == NULL) 2155 return; 2156 } 2157 2158 if (err) 2159 as_bad ("%s", msg); 2160 else 2161 as_warn ("%s", msg); 2162 demand_empty_rest_of_line (); 2163} 2164 2165/* Handle the MRI fail pseudo-op. */ 2166 2167void 2168s_fail (int ignore ATTRIBUTE_UNUSED) 2169{ 2170 offsetT temp; 2171 char *stop = NULL; 2172 char stopc = 0; 2173 2174 if (flag_mri) 2175 stop = mri_comment_field (&stopc); 2176 2177 temp = get_absolute_expression (); 2178 if (temp >= 500) 2179 as_warn (_(".fail %ld encountered"), (long) temp); 2180 else 2181 as_bad (_(".fail %ld encountered"), (long) temp); 2182 2183 demand_empty_rest_of_line (); 2184 2185 if (flag_mri) 2186 mri_comment_end (stop, stopc); 2187} 2188 2189void 2190s_fill (int ignore ATTRIBUTE_UNUSED) 2191{ 2192 expressionS rep_exp; 2193 long size = 1; 2194 long fill = 0; 2195 char *p; 2196 2197#ifdef md_flush_pending_output 2198 md_flush_pending_output (); 2199#endif 2200 2201#ifdef md_cons_align 2202 md_cons_align (1); 2203#endif 2204 2205 get_known_segmented_expression (&rep_exp); 2206 if (*input_line_pointer == ',') 2207 { 2208 input_line_pointer++; 2209 size = get_absolute_expression (); 2210 if (*input_line_pointer == ',') 2211 { 2212 input_line_pointer++; 2213 fill = get_absolute_expression (); 2214 } 2215 } 2216 2217 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */ 2218#define BSD_FILL_SIZE_CROCK_8 (8) 2219 if (size > BSD_FILL_SIZE_CROCK_8) 2220 { 2221 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8); 2222 size = BSD_FILL_SIZE_CROCK_8; 2223 } 2224 if (size < 0) 2225 { 2226 as_warn (_("size negative; .fill ignored")); 2227 size = 0; 2228 } 2229 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0) 2230 { 2231 if (rep_exp.X_add_number < 0) 2232 as_warn (_("repeat < 0; .fill ignored")); 2233 size = 0; 2234 } 2235 2236 if (size && !need_pass_2) 2237 { 2238 if (now_seg == absolute_section) 2239 { 2240 if (rep_exp.X_op != O_constant) 2241 as_bad (_("non-constant fill count for absolute section")); 2242 else if (fill && rep_exp.X_add_number != 0) 2243 as_bad (_("attempt to fill absolute section with non-zero value")); 2244 abs_section_offset += rep_exp.X_add_number * size; 2245 } 2246 else if (fill 2247 && (rep_exp.X_op != O_constant || rep_exp.X_add_number != 0) 2248 && in_bss ()) 2249 as_bad (_("attempt to fill section `%s' with non-zero value"), 2250 segment_name (now_seg)); 2251 2252 if (rep_exp.X_op == O_constant) 2253 { 2254 p = frag_var (rs_fill, (int) size, (int) size, 2255 (relax_substateT) 0, (symbolS *) 0, 2256 (offsetT) rep_exp.X_add_number, 2257 (char *) 0); 2258 } 2259 else 2260 { 2261 /* We don't have a constant repeat count, so we can't use 2262 rs_fill. We can get the same results out of rs_space, 2263 but its argument is in bytes, so we must multiply the 2264 repeat count by size. */ 2265 2266 symbolS *rep_sym; 2267 rep_sym = make_expr_symbol (&rep_exp); 2268 if (size != 1) 2269 { 2270 expressionS size_exp; 2271 size_exp.X_op = O_constant; 2272 size_exp.X_add_number = size; 2273 2274 rep_exp.X_op = O_multiply; 2275 rep_exp.X_add_symbol = rep_sym; 2276 rep_exp.X_op_symbol = make_expr_symbol (&size_exp); 2277 rep_exp.X_add_number = 0; 2278 rep_sym = make_expr_symbol (&rep_exp); 2279 } 2280 2281 p = frag_var (rs_space, (int) size, (int) size, 2282 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0); 2283 } 2284 2285 memset (p, 0, (unsigned int) size); 2286 2287 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX 2288 flavoured AS. The following bizarre behaviour is to be 2289 compatible with above. I guess they tried to take up to 8 2290 bytes from a 4-byte expression and they forgot to sign 2291 extend. */ 2292#define BSD_FILL_SIZE_CROCK_4 (4) 2293 md_number_to_chars (p, (valueT) fill, 2294 (size > BSD_FILL_SIZE_CROCK_4 2295 ? BSD_FILL_SIZE_CROCK_4 2296 : (int) size)); 2297 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes) 2298 but emits no error message because it seems a legal thing to do. 2299 It is a degenerate case of .fill but could be emitted by a 2300 compiler. */ 2301 } 2302 demand_empty_rest_of_line (); 2303} 2304 2305void 2306s_globl (int ignore ATTRIBUTE_UNUSED) 2307{ 2308 char *name; 2309 int c; 2310 symbolS *symbolP; 2311 char *stop = NULL; 2312 char stopc = 0; 2313 2314 if (flag_mri) 2315 stop = mri_comment_field (&stopc); 2316 2317 do 2318 { 2319 if ((name = read_symbol_name ()) == NULL) 2320 return; 2321 2322 symbolP = symbol_find_or_make (name); 2323 S_SET_EXTERNAL (symbolP); 2324 2325 SKIP_WHITESPACE (); 2326 c = *input_line_pointer; 2327 if (c == ',') 2328 { 2329 input_line_pointer++; 2330 SKIP_WHITESPACE (); 2331 if (is_end_of_line[(unsigned char) *input_line_pointer]) 2332 c = '\n'; 2333 } 2334 2335 free (name); 2336 } 2337 while (c == ','); 2338 2339 demand_empty_rest_of_line (); 2340 2341 if (flag_mri) 2342 mri_comment_end (stop, stopc); 2343} 2344 2345/* Handle the MRI IRP and IRPC pseudo-ops. */ 2346 2347void 2348s_irp (int irpc) 2349{ 2350 char * eol; 2351 const char * file; 2352 unsigned int line; 2353 sb s; 2354 const char *err; 2355 sb out; 2356 2357 file = as_where (&line); 2358 2359 eol = find_end_of_line (input_line_pointer, 0); 2360 sb_build (&s, eol - input_line_pointer); 2361 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer); 2362 input_line_pointer = eol; 2363 2364 sb_new (&out); 2365 2366 err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb); 2367 if (err != NULL) 2368 as_bad_where (file, line, "%s", err); 2369 2370 sb_kill (&s); 2371 2372 input_scrub_include_sb (&out, input_line_pointer, 1); 2373 sb_kill (&out); 2374 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 2375} 2376 2377/* Handle the .linkonce pseudo-op. This tells the assembler to mark 2378 the section to only be linked once. However, this is not supported 2379 by most object file formats. This takes an optional argument, 2380 which is what to do about duplicates. */ 2381 2382void 2383s_linkonce (int ignore ATTRIBUTE_UNUSED) 2384{ 2385 enum linkonce_type type; 2386 2387 SKIP_WHITESPACE (); 2388 2389 type = LINKONCE_DISCARD; 2390 2391 if (!is_end_of_line[(unsigned char) *input_line_pointer]) 2392 { 2393 char *s; 2394 char c; 2395 2396 c = get_symbol_name (& s); 2397 if (strcasecmp (s, "discard") == 0) 2398 type = LINKONCE_DISCARD; 2399 else if (strcasecmp (s, "one_only") == 0) 2400 type = LINKONCE_ONE_ONLY; 2401 else if (strcasecmp (s, "same_size") == 0) 2402 type = LINKONCE_SAME_SIZE; 2403 else if (strcasecmp (s, "same_contents") == 0) 2404 type = LINKONCE_SAME_CONTENTS; 2405 else 2406 as_warn (_("unrecognized .linkonce type `%s'"), s); 2407 2408 (void) restore_line_pointer (c); 2409 } 2410 2411#ifdef obj_handle_link_once 2412 obj_handle_link_once (type); 2413#else /* ! defined (obj_handle_link_once) */ 2414 { 2415 flagword flags; 2416 2417 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0) 2418 as_warn (_(".linkonce is not supported for this object file format")); 2419 2420 flags = bfd_get_section_flags (stdoutput, now_seg); 2421 flags |= SEC_LINK_ONCE; 2422 switch (type) 2423 { 2424 default: 2425 abort (); 2426 case LINKONCE_DISCARD: 2427 flags |= SEC_LINK_DUPLICATES_DISCARD; 2428 break; 2429 case LINKONCE_ONE_ONLY: 2430 flags |= SEC_LINK_DUPLICATES_ONE_ONLY; 2431 break; 2432 case LINKONCE_SAME_SIZE: 2433 flags |= SEC_LINK_DUPLICATES_SAME_SIZE; 2434 break; 2435 case LINKONCE_SAME_CONTENTS: 2436 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; 2437 break; 2438 } 2439 if (!bfd_set_section_flags (stdoutput, now_seg, flags)) 2440 as_bad (_("bfd_set_section_flags: %s"), 2441 bfd_errmsg (bfd_get_error ())); 2442 } 2443#endif /* ! defined (obj_handle_link_once) */ 2444 2445 demand_empty_rest_of_line (); 2446} 2447 2448void 2449bss_alloc (symbolS *symbolP, addressT size, unsigned int align) 2450{ 2451 char *pfrag; 2452 segT current_seg = now_seg; 2453 subsegT current_subseg = now_subseg; 2454 segT bss_seg = bss_section; 2455 2456#if defined (TC_MIPS) || defined (TC_ALPHA) 2457 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour 2458 || OUTPUT_FLAVOR == bfd_target_elf_flavour) 2459 { 2460 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */ 2461 if (size <= bfd_get_gp_size (stdoutput)) 2462 { 2463 bss_seg = subseg_new (".sbss", 1); 2464 seg_info (bss_seg)->bss = 1; 2465 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC)) 2466 as_warn (_("error setting flags for \".sbss\": %s"), 2467 bfd_errmsg (bfd_get_error ())); 2468 } 2469 } 2470#endif 2471 subseg_set (bss_seg, 1); 2472 2473 if (align > OCTETS_PER_BYTE_POWER) 2474 { 2475 record_alignment (bss_seg, align); 2476 frag_align (align, 0, 0); 2477 } 2478 2479 /* Detach from old frag. */ 2480 if (S_GET_SEGMENT (symbolP) == bss_seg) 2481 symbol_get_frag (symbolP)->fr_symbol = NULL; 2482 2483 symbol_set_frag (symbolP, frag_now); 2484 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL); 2485 *pfrag = 0; 2486 2487#ifdef S_SET_SIZE 2488 S_SET_SIZE (symbolP, size); 2489#endif 2490 S_SET_SEGMENT (symbolP, bss_seg); 2491 2492#ifdef OBJ_COFF 2493 /* The symbol may already have been created with a preceding 2494 ".globl" directive -- be careful not to step on storage class 2495 in that case. Otherwise, set it to static. */ 2496 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT) 2497 S_SET_STORAGE_CLASS (symbolP, C_STAT); 2498#endif /* OBJ_COFF */ 2499 2500 subseg_set (current_seg, current_subseg); 2501} 2502 2503offsetT 2504parse_align (int align_bytes) 2505{ 2506 expressionS exp; 2507 addressT align; 2508 2509 SKIP_WHITESPACE (); 2510 if (*input_line_pointer != ',') 2511 { 2512 no_align: 2513 as_bad (_("expected alignment after size")); 2514 ignore_rest_of_line (); 2515 return -1; 2516 } 2517 2518 input_line_pointer++; 2519 SKIP_WHITESPACE (); 2520 2521 align = get_absolute_expr (&exp); 2522 if (exp.X_op == O_absent) 2523 goto no_align; 2524 2525 if (!exp.X_unsigned) 2526 { 2527 as_warn (_("alignment negative; 0 assumed")); 2528 align = 0; 2529 } 2530 2531 if (align_bytes && align != 0) 2532 { 2533 /* convert to a power of 2 alignment */ 2534 unsigned int alignp2 = 0; 2535 while ((align & 1) == 0) 2536 align >>= 1, ++alignp2; 2537 if (align != 1) 2538 { 2539 as_bad (_("alignment not a power of 2")); 2540 ignore_rest_of_line (); 2541 return -1; 2542 } 2543 align = alignp2; 2544 } 2545 return align; 2546} 2547 2548/* Called from s_comm_internal after symbol name and size have been 2549 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only), 2550 1 if this was a ".bss" directive which has a 3rd argument 2551 (alignment as a power of 2), or 2 if this was a ".bss" directive 2552 with alignment in bytes. */ 2553 2554symbolS * 2555s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size) 2556{ 2557 addressT align = 0; 2558 2559 if (needs_align) 2560 { 2561 align = parse_align (needs_align - 1); 2562 if (align == (addressT) -1) 2563 return NULL; 2564 } 2565 else 2566 /* Assume some objects may require alignment on some systems. */ 2567 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align); 2568 2569 bss_alloc (symbolP, size, align); 2570 return symbolP; 2571} 2572 2573void 2574s_lcomm (int needs_align) 2575{ 2576 s_comm_internal (needs_align, s_lcomm_internal); 2577} 2578 2579void 2580s_lcomm_bytes (int needs_align) 2581{ 2582 s_comm_internal (needs_align * 2, s_lcomm_internal); 2583} 2584 2585void 2586s_lsym (int ignore ATTRIBUTE_UNUSED) 2587{ 2588 char *name; 2589 expressionS exp; 2590 symbolS *symbolP; 2591 2592 /* We permit ANY defined expression: BSD4.2 demands constants. */ 2593 if ((name = read_symbol_name ()) == NULL) 2594 return; 2595 2596 if (*input_line_pointer != ',') 2597 { 2598 as_bad (_("expected comma after \"%s\""), name); 2599 goto err_out; 2600 } 2601 2602 input_line_pointer++; 2603 expression_and_evaluate (&exp); 2604 2605 if (exp.X_op != O_constant 2606 && exp.X_op != O_register) 2607 { 2608 as_bad (_("bad expression")); 2609 goto err_out; 2610 } 2611 2612 symbolP = symbol_find_or_make (name); 2613 2614 if (S_GET_SEGMENT (symbolP) == undefined_section) 2615 { 2616 /* The name might be an undefined .global symbol; be sure to 2617 keep the "external" bit. */ 2618 S_SET_SEGMENT (symbolP, 2619 (exp.X_op == O_constant 2620 ? absolute_section 2621 : reg_section)); 2622 S_SET_VALUE (symbolP, (valueT) exp.X_add_number); 2623 } 2624 else 2625 { 2626 as_bad (_("symbol `%s' is already defined"), name); 2627 } 2628 2629 demand_empty_rest_of_line (); 2630 free (name); 2631 return; 2632 2633 err_out: 2634 ignore_rest_of_line (); 2635 free (name); 2636 return; 2637} 2638 2639/* Read a line into an sb. Returns the character that ended the line 2640 or zero if there are no more lines. */ 2641 2642static int 2643get_line_sb (sb *line, int in_macro) 2644{ 2645 char *eol; 2646 2647 if (input_line_pointer[-1] == '\n') 2648 bump_line_counters (); 2649 2650 if (input_line_pointer >= buffer_limit) 2651 { 2652 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 2653 if (buffer_limit == 0) 2654 return 0; 2655 } 2656 2657 eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro); 2658 sb_add_buffer (line, input_line_pointer, eol - input_line_pointer); 2659 input_line_pointer = eol; 2660 2661 /* Don't skip multiple end-of-line characters, because that breaks support 2662 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line 2663 characters but isn't. Instead just skip one end of line character and 2664 return the character skipped so that the caller can re-insert it if 2665 necessary. */ 2666 return *input_line_pointer++; 2667} 2668 2669static size_t 2670get_non_macro_line_sb (sb *line) 2671{ 2672 return get_line_sb (line, 0); 2673} 2674 2675static size_t 2676get_macro_line_sb (sb *line) 2677{ 2678 return get_line_sb (line, 1); 2679} 2680 2681/* Define a macro. This is an interface to macro.c. */ 2682 2683void 2684s_macro (int ignore ATTRIBUTE_UNUSED) 2685{ 2686 char *eol; 2687 const char * file; 2688 unsigned int line; 2689 sb s; 2690 const char *err; 2691 const char *name; 2692 2693 file = as_where (&line); 2694 2695 eol = find_end_of_line (input_line_pointer, 0); 2696 sb_build (&s, eol - input_line_pointer); 2697 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer); 2698 input_line_pointer = eol; 2699 2700 if (line_label != NULL) 2701 { 2702 sb label; 2703 size_t len; 2704 2705 name = S_GET_NAME (line_label); 2706 len = strlen (name); 2707 sb_build (&label, len); 2708 sb_add_buffer (&label, name, len); 2709 err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name); 2710 sb_kill (&label); 2711 } 2712 else 2713 err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name); 2714 if (err != NULL) 2715 as_bad_where (file, line, err, name); 2716 else 2717 { 2718 if (line_label != NULL) 2719 { 2720 S_SET_SEGMENT (line_label, absolute_section); 2721 S_SET_VALUE (line_label, 0); 2722 symbol_set_frag (line_label, &zero_address_frag); 2723 } 2724 2725 if (((NO_PSEUDO_DOT || flag_m68k_mri) 2726 && hash_find (po_hash, name) != NULL) 2727 || (!flag_m68k_mri 2728 && *name == '.' 2729 && hash_find (po_hash, name + 1) != NULL)) 2730 as_warn_where (file, 2731 line, 2732 _("attempt to redefine pseudo-op `%s' ignored"), 2733 name); 2734 } 2735 2736 sb_kill (&s); 2737} 2738 2739/* Handle the .mexit pseudo-op, which immediately exits a macro 2740 expansion. */ 2741 2742void 2743s_mexit (int ignore ATTRIBUTE_UNUSED) 2744{ 2745 if (macro_nest) 2746 { 2747 cond_exit_macro (macro_nest); 2748 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 2749 } 2750 else 2751 as_warn (_("ignoring macro exit outside a macro definition.")); 2752} 2753 2754/* Switch in and out of MRI mode. */ 2755 2756void 2757s_mri (int ignore ATTRIBUTE_UNUSED) 2758{ 2759 int on; 2760#ifdef MRI_MODE_CHANGE 2761 int old_flag; 2762#endif 2763 2764 on = get_absolute_expression (); 2765#ifdef MRI_MODE_CHANGE 2766 old_flag = flag_mri; 2767#endif 2768 if (on != 0) 2769 { 2770 flag_mri = 1; 2771#ifdef TC_M68K 2772 flag_m68k_mri = 1; 2773#endif 2774 macro_mri_mode (1); 2775 } 2776 else 2777 { 2778 flag_mri = 0; 2779#ifdef TC_M68K 2780 flag_m68k_mri = 0; 2781#endif 2782 macro_mri_mode (0); 2783 } 2784 2785 /* Operator precedence changes in m68k MRI mode, so we need to 2786 update the operator rankings. */ 2787 expr_set_precedence (); 2788 2789#ifdef MRI_MODE_CHANGE 2790 if (on != old_flag) 2791 MRI_MODE_CHANGE (on); 2792#endif 2793 2794 demand_empty_rest_of_line (); 2795} 2796 2797/* Handle changing the location counter. */ 2798 2799static void 2800do_org (segT segment, expressionS *exp, int fill) 2801{ 2802 if (segment != now_seg 2803 && segment != absolute_section 2804 && segment != expr_section) 2805 as_bad (_("invalid segment \"%s\""), segment_name (segment)); 2806 2807 if (now_seg == absolute_section) 2808 { 2809 if (fill != 0) 2810 as_warn (_("ignoring fill value in absolute section")); 2811 if (exp->X_op != O_constant) 2812 { 2813 as_bad (_("only constant offsets supported in absolute section")); 2814 exp->X_add_number = 0; 2815 } 2816 abs_section_offset = exp->X_add_number; 2817 } 2818 else 2819 { 2820 char *p; 2821 symbolS *sym = exp->X_add_symbol; 2822 offsetT off = exp->X_add_number * OCTETS_PER_BYTE; 2823 2824 if (fill && in_bss ()) 2825 as_warn (_("ignoring fill value in section `%s'"), 2826 segment_name (now_seg)); 2827 2828 if (exp->X_op != O_constant && exp->X_op != O_symbol) 2829 { 2830 /* Handle complex expressions. */ 2831 sym = make_expr_symbol (exp); 2832 off = 0; 2833 } 2834 2835 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0); 2836 *p = fill; 2837 } 2838} 2839 2840void 2841s_org (int ignore ATTRIBUTE_UNUSED) 2842{ 2843 segT segment; 2844 expressionS exp; 2845 long temp_fill; 2846 2847#ifdef md_flush_pending_output 2848 md_flush_pending_output (); 2849#endif 2850 2851 /* The m68k MRI assembler has a different meaning for .org. It 2852 means to create an absolute section at a given address. We can't 2853 support that--use a linker script instead. */ 2854 if (flag_m68k_mri) 2855 { 2856 as_bad (_("MRI style ORG pseudo-op not supported")); 2857 ignore_rest_of_line (); 2858 return; 2859 } 2860 2861 /* Don't believe the documentation of BSD 4.2 AS. There is no such 2862 thing as a sub-segment-relative origin. Any absolute origin is 2863 given a warning, then assumed to be segment-relative. Any 2864 segmented origin expression ("foo+42") had better be in the right 2865 segment or the .org is ignored. 2866 2867 BSD 4.2 AS warns if you try to .org backwards. We cannot because 2868 we never know sub-segment sizes when we are reading code. BSD 2869 will crash trying to emit negative numbers of filler bytes in 2870 certain .orgs. We don't crash, but see as-write for that code. 2871 2872 Don't make frag if need_pass_2==1. */ 2873 segment = get_known_segmented_expression (&exp); 2874 if (*input_line_pointer == ',') 2875 { 2876 input_line_pointer++; 2877 temp_fill = get_absolute_expression (); 2878 } 2879 else 2880 temp_fill = 0; 2881 2882 if (!need_pass_2) 2883 do_org (segment, &exp, temp_fill); 2884 2885 demand_empty_rest_of_line (); 2886} 2887 2888/* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be 2889 called by the obj-format routine which handles section changing 2890 when in MRI mode. It will create a new section, and return it. It 2891 will set *TYPE to the section type: one of 'C' (code), 'D' (data), 2892 'M' (mixed), or 'R' (romable). The flags will be set in the section. */ 2893 2894void 2895s_mri_sect (char *type ATTRIBUTE_UNUSED) 2896{ 2897#ifdef TC_M68K 2898 2899 char *name; 2900 char c; 2901 segT seg; 2902 2903 SKIP_WHITESPACE (); 2904 2905 name = input_line_pointer; 2906 if (!ISDIGIT (*name)) 2907 c = get_symbol_name (& name); 2908 else 2909 { 2910 do 2911 { 2912 ++input_line_pointer; 2913 } 2914 while (ISDIGIT (*input_line_pointer)); 2915 2916 c = *input_line_pointer; 2917 *input_line_pointer = '\0'; 2918 } 2919 2920 name = xstrdup (name); 2921 2922 c = restore_line_pointer (c); 2923 2924 seg = subseg_new (name, 0); 2925 2926 if (c == ',') 2927 { 2928 unsigned int align; 2929 2930 ++input_line_pointer; 2931 align = get_absolute_expression (); 2932 record_alignment (seg, align); 2933 } 2934 2935 *type = 'C'; 2936 if (*input_line_pointer == ',') 2937 { 2938 c = *++input_line_pointer; 2939 c = TOUPPER (c); 2940 if (c == 'C' || c == 'D' || c == 'M' || c == 'R') 2941 *type = c; 2942 else 2943 as_bad (_("unrecognized section type")); 2944 ++input_line_pointer; 2945 2946 { 2947 flagword flags; 2948 2949 flags = SEC_NO_FLAGS; 2950 if (*type == 'C') 2951 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE; 2952 else if (*type == 'D' || *type == 'M') 2953 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA; 2954 else if (*type == 'R') 2955 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM; 2956 if (flags != SEC_NO_FLAGS) 2957 { 2958 if (!bfd_set_section_flags (stdoutput, seg, flags)) 2959 as_warn (_("error setting flags for \"%s\": %s"), 2960 bfd_section_name (stdoutput, seg), 2961 bfd_errmsg (bfd_get_error ())); 2962 } 2963 } 2964 } 2965 2966 /* Ignore the HP type. */ 2967 if (*input_line_pointer == ',') 2968 input_line_pointer += 2; 2969 2970 demand_empty_rest_of_line (); 2971 2972#else /* ! TC_M68K */ 2973#ifdef TC_I960 2974 2975 char *name; 2976 char c; 2977 segT seg; 2978 2979 SKIP_WHITESPACE (); 2980 2981 c = get_symbol_name (& name); 2982 2983 name = xstrdup (name); 2984 2985 c = restore_line_pointer (c); 2986 2987 seg = subseg_new (name, 0); 2988 2989 if (c != ',') 2990 *type = 'C'; 2991 else 2992 { 2993 char *sectype; 2994 2995 ++input_line_pointer; 2996 SKIP_WHITESPACE (); 2997 c = get_symbol_name (& sectype); 2998 if (*sectype == '\0') 2999 *type = 'C'; 3000 else if (strcasecmp (sectype, "text") == 0) 3001 *type = 'C'; 3002 else if (strcasecmp (sectype, "data") == 0) 3003 *type = 'D'; 3004 else if (strcasecmp (sectype, "romdata") == 0) 3005 *type = 'R'; 3006 else 3007 as_warn (_("unrecognized section type `%s'"), sectype); 3008 (void) restore_line_pointer (c); 3009 } 3010 3011 if (*input_line_pointer == ',') 3012 { 3013 char *seccmd; 3014 3015 ++input_line_pointer; 3016 SKIP_WHITESPACE (); 3017 c = get_symbol_name (& seccmd); 3018 if (strcasecmp (seccmd, "absolute") == 0) 3019 { 3020 as_bad (_("absolute sections are not supported")); 3021 *input_line_pointer = c; 3022 ignore_rest_of_line (); 3023 return; 3024 } 3025 else if (strcasecmp (seccmd, "align") == 0) 3026 { 3027 unsigned int align; 3028 3029 (void) restore_line_pointer (c); 3030 align = get_absolute_expression (); 3031 record_alignment (seg, align); 3032 } 3033 else 3034 { 3035 as_warn (_("unrecognized section command `%s'"), seccmd); 3036 (void) restore_line_pointer (c); 3037 } 3038 } 3039 3040 demand_empty_rest_of_line (); 3041 3042#else /* ! TC_I960 */ 3043 /* The MRI assembler seems to use different forms of .sect for 3044 different targets. */ 3045 as_bad ("MRI mode not supported for this target"); 3046 ignore_rest_of_line (); 3047#endif /* ! TC_I960 */ 3048#endif /* ! TC_M68K */ 3049} 3050 3051/* Handle the .print pseudo-op. */ 3052 3053void 3054s_print (int ignore ATTRIBUTE_UNUSED) 3055{ 3056 char *s; 3057 int len; 3058 3059 s = demand_copy_C_string (&len); 3060 if (s != NULL) 3061 printf ("%s\n", s); 3062 demand_empty_rest_of_line (); 3063} 3064 3065/* Handle the .purgem pseudo-op. */ 3066 3067void 3068s_purgem (int ignore ATTRIBUTE_UNUSED) 3069{ 3070 if (is_it_end_of_statement ()) 3071 { 3072 demand_empty_rest_of_line (); 3073 return; 3074 } 3075 3076 do 3077 { 3078 char *name; 3079 char c; 3080 3081 SKIP_WHITESPACE (); 3082 c = get_symbol_name (& name); 3083 delete_macro (name); 3084 *input_line_pointer = c; 3085 SKIP_WHITESPACE_AFTER_NAME (); 3086 } 3087 while (*input_line_pointer++ == ','); 3088 3089 --input_line_pointer; 3090 demand_empty_rest_of_line (); 3091} 3092 3093/* Handle the .endm/.endr pseudo-ops. */ 3094 3095static void 3096s_bad_end (int endr) 3097{ 3098 as_warn (_(".end%c encountered without preceding %s"), 3099 endr ? 'r' : 'm', 3100 endr ? ".rept, .irp, or .irpc" : ".macro"); 3101 demand_empty_rest_of_line (); 3102} 3103 3104/* Handle the .rept pseudo-op. */ 3105 3106void 3107s_rept (int ignore ATTRIBUTE_UNUSED) 3108{ 3109 int count; 3110 3111 count = get_absolute_expression (); 3112 3113 do_repeat (count, "REPT", "ENDR"); 3114} 3115 3116/* This function provides a generic repeat block implementation. It allows 3117 different directives to be used as the start/end keys. */ 3118 3119void 3120do_repeat (int count, const char *start, const char *end) 3121{ 3122 sb one; 3123 sb many; 3124 3125 sb_new (&one); 3126 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb)) 3127 { 3128 as_bad (_("%s without %s"), start, end); 3129 return; 3130 } 3131 3132 sb_build (&many, count * one.len); 3133 while (count-- > 0) 3134 sb_add_sb (&many, &one); 3135 3136 sb_kill (&one); 3137 3138 input_scrub_include_sb (&many, input_line_pointer, 1); 3139 sb_kill (&many); 3140 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 3141} 3142 3143/* Like do_repeat except that any text matching EXPANDER in the 3144 block is replaced by the itteration count. */ 3145 3146void 3147do_repeat_with_expander (int count, 3148 const char * start, 3149 const char * end, 3150 const char * expander) 3151{ 3152 sb one; 3153 sb many; 3154 3155 sb_new (&one); 3156 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb)) 3157 { 3158 as_bad (_("%s without %s"), start, end); 3159 return; 3160 } 3161 3162 sb_new (&many); 3163 3164 if (expander != NULL && strstr (one.ptr, expander) != NULL) 3165 { 3166 while (count -- > 0) 3167 { 3168 int len; 3169 char * sub; 3170 sb processed; 3171 3172 sb_build (& processed, one.len); 3173 sb_add_sb (& processed, & one); 3174 sub = strstr (processed.ptr, expander); 3175 len = sprintf (sub, "%d", count); 3176 gas_assert (len < 8); 3177 strcpy (sub + len, sub + 8); 3178 processed.len -= (8 - len); 3179 sb_add_sb (& many, & processed); 3180 sb_kill (& processed); 3181 } 3182 } 3183 else 3184 while (count-- > 0) 3185 sb_add_sb (&many, &one); 3186 3187 sb_kill (&one); 3188 3189 input_scrub_include_sb (&many, input_line_pointer, 1); 3190 sb_kill (&many); 3191 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 3192} 3193 3194/* Skip to end of current repeat loop; EXTRA indicates how many additional 3195 input buffers to skip. Assumes that conditionals preceding the loop end 3196 are properly nested. 3197 3198 This function makes it easier to implement a premature "break" out of the 3199 loop. The EXTRA arg accounts for other buffers we might have inserted, 3200 such as line substitutions. */ 3201 3202void 3203end_repeat (int extra) 3204{ 3205 cond_exit_macro (macro_nest); 3206 while (extra-- >= 0) 3207 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 3208} 3209 3210static void 3211assign_symbol (char *name, int mode) 3212{ 3213 symbolS *symbolP; 3214 3215 if (name[0] == '.' && name[1] == '\0') 3216 { 3217 /* Turn '. = mumble' into a .org mumble. */ 3218 segT segment; 3219 expressionS exp; 3220 3221 segment = get_known_segmented_expression (&exp); 3222 3223 if (!need_pass_2) 3224 do_org (segment, &exp, 0); 3225 3226 return; 3227 } 3228 3229 if ((symbolP = symbol_find (name)) == NULL 3230 && (symbolP = md_undefined_symbol (name)) == NULL) 3231 { 3232 symbolP = symbol_find_or_make (name); 3233#ifndef NO_LISTING 3234 /* When doing symbol listings, play games with dummy fragments living 3235 outside the normal fragment chain to record the file and line info 3236 for this symbol. */ 3237 if (listing & LISTING_SYMBOLS) 3238 { 3239 extern struct list_info_struct *listing_tail; 3240 fragS *dummy_frag = XCNEW (fragS); 3241 dummy_frag->line = listing_tail; 3242 dummy_frag->fr_symbol = symbolP; 3243 symbol_set_frag (symbolP, dummy_frag); 3244 } 3245#endif 3246#if defined (OBJ_COFF) && !defined (TE_PE) 3247 /* "set" symbols are local unless otherwise specified. */ 3248 SF_SET_LOCAL (symbolP); 3249#endif 3250 } 3251 3252 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) 3253 { 3254 if ((mode != 0 || !S_IS_VOLATILE (symbolP)) 3255 && !S_CAN_BE_REDEFINED (symbolP)) 3256 { 3257 as_bad (_("symbol `%s' is already defined"), name); 3258 ignore_rest_of_line (); 3259 input_line_pointer--; 3260 return; 3261 } 3262 /* If the symbol is volatile, copy the symbol and replace the 3263 original with the copy, so that previous uses of the symbol will 3264 retain the value of the symbol at the point of use. */ 3265 else if (S_IS_VOLATILE (symbolP)) 3266 symbolP = symbol_clone (symbolP, 1); 3267 } 3268 3269 if (mode == 0) 3270 S_SET_VOLATILE (symbolP); 3271 else if (mode < 0) 3272 S_SET_FORWARD_REF (symbolP); 3273 3274 pseudo_set (symbolP); 3275} 3276 3277/* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1, 3278 then this is .equiv, and it is an error if the symbol is already 3279 defined. If EQUIV is -1, the symbol additionally is a forward 3280 reference. */ 3281 3282void 3283s_set (int equiv) 3284{ 3285 char *name; 3286 3287 /* Especial apologies for the random logic: 3288 this just grew, and could be parsed much more simply! 3289 Dean in haste. */ 3290 if ((name = read_symbol_name ()) == NULL) 3291 return; 3292 3293 if (*input_line_pointer != ',') 3294 { 3295 as_bad (_("expected comma after \"%s\""), name); 3296 ignore_rest_of_line (); 3297 free (name); 3298 return; 3299 } 3300 3301 input_line_pointer++; 3302 assign_symbol (name, equiv); 3303 demand_empty_rest_of_line (); 3304 free (name); 3305} 3306 3307void 3308s_space (int mult) 3309{ 3310 expressionS exp; 3311 expressionS val; 3312 char *p = 0; 3313 char *stop = NULL; 3314 char stopc = 0; 3315 int bytes; 3316 3317#ifdef md_flush_pending_output 3318 md_flush_pending_output (); 3319#endif 3320 3321#ifdef md_cons_align 3322 md_cons_align (1); 3323#endif 3324 3325 if (flag_mri) 3326 stop = mri_comment_field (&stopc); 3327 3328 /* In m68k MRI mode, we need to align to a word boundary, unless 3329 this is ds.b. */ 3330 if (flag_m68k_mri && mult > 1) 3331 { 3332 if (now_seg == absolute_section) 3333 { 3334 abs_section_offset += abs_section_offset & 1; 3335 if (line_label != NULL) 3336 S_SET_VALUE (line_label, abs_section_offset); 3337 } 3338 else if (mri_common_symbol != NULL) 3339 { 3340 valueT mri_val; 3341 3342 mri_val = S_GET_VALUE (mri_common_symbol); 3343 if ((mri_val & 1) != 0) 3344 { 3345 S_SET_VALUE (mri_common_symbol, mri_val + 1); 3346 if (line_label != NULL) 3347 { 3348 expressionS *symexp; 3349 3350 symexp = symbol_get_value_expression (line_label); 3351 know (symexp->X_op == O_symbol); 3352 know (symexp->X_add_symbol == mri_common_symbol); 3353 symexp->X_add_number += 1; 3354 } 3355 } 3356 } 3357 else 3358 { 3359 do_align (1, (char *) NULL, 0, 0); 3360 if (line_label != NULL) 3361 { 3362 symbol_set_frag (line_label, frag_now); 3363 S_SET_VALUE (line_label, frag_now_fix ()); 3364 } 3365 } 3366 } 3367 3368 bytes = mult; 3369 3370 expression (&exp); 3371 3372 SKIP_WHITESPACE (); 3373 if (*input_line_pointer == ',') 3374 { 3375 ++input_line_pointer; 3376 expression (&val); 3377 } 3378 else 3379 { 3380 val.X_op = O_constant; 3381 val.X_add_number = 0; 3382 } 3383 3384 if ((val.X_op != O_constant 3385 || val.X_add_number < - 0x80 3386 || val.X_add_number > 0xff 3387 || (mult != 0 && mult != 1 && val.X_add_number != 0)) 3388 && (now_seg != absolute_section && !in_bss ())) 3389 { 3390 resolve_expression (&exp); 3391 if (exp.X_op != O_constant) 3392 as_bad (_("unsupported variable size or fill value")); 3393 else 3394 { 3395 offsetT i; 3396 3397 /* PR 20901: Check for excessive values. 3398 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */ 3399 if (exp.X_add_number < 0 || exp.X_add_number > (1 << 10)) 3400 as_bad (_("size value for space directive too large: %lx"), 3401 (long) exp.X_add_number); 3402 else 3403 { 3404 if (mult == 0) 3405 mult = 1; 3406 bytes = mult * exp.X_add_number; 3407 3408 for (i = 0; i < exp.X_add_number; i++) 3409 emit_expr (&val, mult); 3410 } 3411 } 3412 } 3413 else 3414 { 3415 if (now_seg == absolute_section || mri_common_symbol != NULL) 3416 resolve_expression (&exp); 3417 3418 if (exp.X_op == O_constant) 3419 { 3420 offsetT repeat; 3421 3422 repeat = exp.X_add_number; 3423 if (mult) 3424 repeat *= mult; 3425 bytes = repeat; 3426 if (repeat <= 0) 3427 { 3428 if (!flag_mri) 3429 as_warn (_(".space repeat count is zero, ignored")); 3430 else if (repeat < 0) 3431 as_warn (_(".space repeat count is negative, ignored")); 3432 goto getout; 3433 } 3434 3435 /* If we are in the absolute section, just bump the offset. */ 3436 if (now_seg == absolute_section) 3437 { 3438 if (val.X_op != O_constant || val.X_add_number != 0) 3439 as_warn (_("ignoring fill value in absolute section")); 3440 abs_section_offset += repeat; 3441 goto getout; 3442 } 3443 3444 /* If we are secretly in an MRI common section, then 3445 creating space just increases the size of the common 3446 symbol. */ 3447 if (mri_common_symbol != NULL) 3448 { 3449 S_SET_VALUE (mri_common_symbol, 3450 S_GET_VALUE (mri_common_symbol) + repeat); 3451 goto getout; 3452 } 3453 3454 if (!need_pass_2) 3455 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0, 3456 (offsetT) repeat, (char *) 0); 3457 } 3458 else 3459 { 3460 if (now_seg == absolute_section) 3461 { 3462 as_bad (_("space allocation too complex in absolute section")); 3463 subseg_set (text_section, 0); 3464 } 3465 3466 if (mri_common_symbol != NULL) 3467 { 3468 as_bad (_("space allocation too complex in common section")); 3469 mri_common_symbol = NULL; 3470 } 3471 3472 if (!need_pass_2) 3473 p = frag_var (rs_space, 1, 1, (relax_substateT) 0, 3474 make_expr_symbol (&exp), (offsetT) 0, (char *) 0); 3475 } 3476 3477 if ((val.X_op != O_constant || val.X_add_number != 0) && in_bss ()) 3478 as_warn (_("ignoring fill value in section `%s'"), 3479 segment_name (now_seg)); 3480 else if (p) 3481 *p = val.X_add_number; 3482 } 3483 3484 getout: 3485 3486 /* In MRI mode, after an odd number of bytes, we must align to an 3487 even word boundary, unless the next instruction is a dc.b, ds.b 3488 or dcb.b. */ 3489 if (flag_mri && (bytes & 1) != 0) 3490 mri_pending_align = 1; 3491 3492 demand_empty_rest_of_line (); 3493 3494 if (flag_mri) 3495 mri_comment_end (stop, stopc); 3496} 3497 3498/* This is like s_space, but the value is a floating point number with 3499 the given precision. This is for the MRI dcb.s pseudo-op and 3500 friends. */ 3501 3502void 3503s_float_space (int float_type) 3504{ 3505 offsetT count; 3506 int flen; 3507 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 3508 char *stop = NULL; 3509 char stopc = 0; 3510 3511#ifdef md_cons_align 3512 md_cons_align (1); 3513#endif 3514 3515 if (flag_mri) 3516 stop = mri_comment_field (&stopc); 3517 3518 count = get_absolute_expression (); 3519 3520 SKIP_WHITESPACE (); 3521 if (*input_line_pointer != ',') 3522 { 3523 as_bad (_("missing value")); 3524 ignore_rest_of_line (); 3525 if (flag_mri) 3526 mri_comment_end (stop, stopc); 3527 return; 3528 } 3529 3530 ++input_line_pointer; 3531 3532 SKIP_WHITESPACE (); 3533 3534 /* Skip any 0{letter} that may be present. Don't even check if the 3535 * letter is legal. */ 3536 if (input_line_pointer[0] == '0' 3537 && ISALPHA (input_line_pointer[1])) 3538 input_line_pointer += 2; 3539 3540 /* Accept :xxxx, where the x's are hex digits, for a floating point 3541 with the exact digits specified. */ 3542 if (input_line_pointer[0] == ':') 3543 { 3544 flen = hex_float (float_type, temp); 3545 if (flen < 0) 3546 { 3547 ignore_rest_of_line (); 3548 if (flag_mri) 3549 mri_comment_end (stop, stopc); 3550 return; 3551 } 3552 } 3553 else 3554 { 3555 const char *err; 3556 3557 err = md_atof (float_type, temp, &flen); 3558 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 3559 know (err != NULL || flen > 0); 3560 if (err) 3561 { 3562 as_bad (_("bad floating literal: %s"), err); 3563 ignore_rest_of_line (); 3564 if (flag_mri) 3565 mri_comment_end (stop, stopc); 3566 return; 3567 } 3568 } 3569 3570 while (--count >= 0) 3571 { 3572 char *p; 3573 3574 p = frag_more (flen); 3575 memcpy (p, temp, (unsigned int) flen); 3576 } 3577 3578 demand_empty_rest_of_line (); 3579 3580 if (flag_mri) 3581 mri_comment_end (stop, stopc); 3582} 3583 3584/* Handle the .struct pseudo-op, as found in MIPS assemblers. */ 3585 3586void 3587s_struct (int ignore ATTRIBUTE_UNUSED) 3588{ 3589 char *stop = NULL; 3590 char stopc = 0; 3591 3592 if (flag_mri) 3593 stop = mri_comment_field (&stopc); 3594 abs_section_offset = get_absolute_expression (); 3595#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) 3596 /* The ELF backend needs to know that we are changing sections, so 3597 that .previous works correctly. */ 3598 if (IS_ELF) 3599 obj_elf_section_change_hook (); 3600#endif 3601 subseg_set (absolute_section, 0); 3602 demand_empty_rest_of_line (); 3603 if (flag_mri) 3604 mri_comment_end (stop, stopc); 3605} 3606 3607void 3608s_text (int ignore ATTRIBUTE_UNUSED) 3609{ 3610 int temp; 3611 3612 temp = get_absolute_expression (); 3613 subseg_set (text_section, (subsegT) temp); 3614 demand_empty_rest_of_line (); 3615} 3616 3617/* .weakref x, y sets x as an alias to y that, as long as y is not 3618 referenced directly, will cause y to become a weak symbol. */ 3619void 3620s_weakref (int ignore ATTRIBUTE_UNUSED) 3621{ 3622 char *name; 3623 symbolS *symbolP; 3624 symbolS *symbolP2; 3625 expressionS exp; 3626 3627 if ((name = read_symbol_name ()) == NULL) 3628 return; 3629 3630 symbolP = symbol_find_or_make (name); 3631 3632 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) 3633 { 3634 if (!S_IS_VOLATILE (symbolP)) 3635 { 3636 as_bad (_("symbol `%s' is already defined"), name); 3637 goto err_out; 3638 } 3639 symbolP = symbol_clone (symbolP, 1); 3640 S_CLEAR_VOLATILE (symbolP); 3641 } 3642 3643 SKIP_WHITESPACE (); 3644 3645 if (*input_line_pointer != ',') 3646 { 3647 as_bad (_("expected comma after \"%s\""), name); 3648 goto err_out; 3649 } 3650 3651 input_line_pointer++; 3652 3653 SKIP_WHITESPACE (); 3654 free (name); 3655 3656 if ((name = read_symbol_name ()) == NULL) 3657 return; 3658 3659 if ((symbolP2 = symbol_find_noref (name, 1)) == NULL 3660 && (symbolP2 = md_undefined_symbol (name)) == NULL) 3661 { 3662 symbolP2 = symbol_find_or_make (name); 3663 S_SET_WEAKREFD (symbolP2); 3664 } 3665 else 3666 { 3667 symbolS *symp = symbolP2; 3668 3669 while (S_IS_WEAKREFR (symp) && symp != symbolP) 3670 { 3671 expressionS *expP = symbol_get_value_expression (symp); 3672 3673 gas_assert (expP->X_op == O_symbol 3674 && expP->X_add_number == 0); 3675 symp = expP->X_add_symbol; 3676 } 3677 if (symp == symbolP) 3678 { 3679 char *loop; 3680 3681 loop = concat (S_GET_NAME (symbolP), 3682 " => ", S_GET_NAME (symbolP2), (const char *) NULL); 3683 3684 symp = symbolP2; 3685 while (symp != symbolP) 3686 { 3687 char *old_loop = loop; 3688 3689 symp = symbol_get_value_expression (symp)->X_add_symbol; 3690 loop = concat (loop, " => ", S_GET_NAME (symp), 3691 (const char *) NULL); 3692 free (old_loop); 3693 } 3694 3695 as_bad (_("%s: would close weakref loop: %s"), 3696 S_GET_NAME (symbolP), loop); 3697 3698 free (loop); 3699 free (name); 3700 ignore_rest_of_line (); 3701 return; 3702 } 3703 3704 /* Short-circuiting instead of just checking here might speed 3705 things up a tiny little bit, but loop error messages would 3706 miss intermediate links. */ 3707 /* symbolP2 = symp; */ 3708 } 3709 3710 memset (&exp, 0, sizeof (exp)); 3711 exp.X_op = O_symbol; 3712 exp.X_add_symbol = symbolP2; 3713 3714 S_SET_SEGMENT (symbolP, undefined_section); 3715 symbol_set_value_expression (symbolP, &exp); 3716 symbol_set_frag (symbolP, &zero_address_frag); 3717 S_SET_WEAKREFR (symbolP); 3718 3719 demand_empty_rest_of_line (); 3720 free (name); 3721 return; 3722 3723 err_out: 3724 ignore_rest_of_line (); 3725 free (name); 3726 return; 3727} 3728 3729 3730/* Verify that we are at the end of a line. If not, issue an error and 3731 skip to EOL. */ 3732 3733void 3734demand_empty_rest_of_line (void) 3735{ 3736 SKIP_WHITESPACE (); 3737 if (is_end_of_line[(unsigned char) *input_line_pointer]) 3738 input_line_pointer++; 3739 else 3740 { 3741 if (ISPRINT (*input_line_pointer)) 3742 as_bad (_("junk at end of line, first unrecognized character is `%c'"), 3743 *input_line_pointer); 3744 else 3745 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"), 3746 *input_line_pointer); 3747 ignore_rest_of_line (); 3748 } 3749 3750 /* Return pointing just after end-of-line. */ 3751 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); 3752} 3753 3754/* Silently advance to the end of line. Use this after already having 3755 issued an error about something bad. */ 3756 3757void 3758ignore_rest_of_line (void) 3759{ 3760 while (input_line_pointer < buffer_limit 3761 && !is_end_of_line[(unsigned char) *input_line_pointer]) 3762 input_line_pointer++; 3763 3764 input_line_pointer++; 3765 3766 /* Return pointing just after end-of-line. */ 3767 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); 3768} 3769 3770/* Sets frag for given symbol to zero_address_frag, except when the 3771 symbol frag is already set to a dummy listing frag. */ 3772 3773static void 3774set_zero_frag (symbolS *symbolP) 3775{ 3776 if (symbol_get_frag (symbolP)->fr_type != rs_dummy) 3777 symbol_set_frag (symbolP, &zero_address_frag); 3778} 3779 3780/* In: Pointer to a symbol. 3781 Input_line_pointer->expression. 3782 3783 Out: Input_line_pointer->just after any whitespace after expression. 3784 Tried to set symbol to value of expression. 3785 Will change symbols type, value, and frag; */ 3786 3787void 3788pseudo_set (symbolS *symbolP) 3789{ 3790 expressionS exp; 3791 segT seg; 3792 3793 know (symbolP); /* NULL pointer is logic error. */ 3794 3795 if (!S_IS_FORWARD_REF (symbolP)) 3796 (void) expression (&exp); 3797 else 3798 (void) deferred_expression (&exp); 3799 3800 if (exp.X_op == O_illegal) 3801 as_bad (_("illegal expression")); 3802 else if (exp.X_op == O_absent) 3803 as_bad (_("missing expression")); 3804 else if (exp.X_op == O_big) 3805 { 3806 if (exp.X_add_number > 0) 3807 as_bad (_("bignum invalid")); 3808 else 3809 as_bad (_("floating point number invalid")); 3810 } 3811 else if (exp.X_op == O_subtract 3812 && !S_IS_FORWARD_REF (symbolP) 3813 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol)) 3814 && (symbol_get_frag (exp.X_add_symbol) 3815 == symbol_get_frag (exp.X_op_symbol))) 3816 { 3817 exp.X_op = O_constant; 3818 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol) 3819 - S_GET_VALUE (exp.X_op_symbol)); 3820 } 3821 3822 if (symbol_section_p (symbolP)) 3823 { 3824 as_bad ("attempt to set value of section symbol"); 3825 return; 3826 } 3827 3828 switch (exp.X_op) 3829 { 3830 case O_illegal: 3831 case O_absent: 3832 case O_big: 3833 exp.X_add_number = 0; 3834 /* Fall through. */ 3835 case O_constant: 3836 S_SET_SEGMENT (symbolP, absolute_section); 3837 S_SET_VALUE (symbolP, (valueT) exp.X_add_number); 3838 set_zero_frag (symbolP); 3839 break; 3840 3841 case O_register: 3842#ifndef TC_GLOBAL_REGISTER_SYMBOL_OK 3843 if (S_IS_EXTERNAL (symbolP)) 3844 { 3845 as_bad ("can't equate global symbol `%s' with register name", 3846 S_GET_NAME (symbolP)); 3847 return; 3848 } 3849#endif 3850 S_SET_SEGMENT (symbolP, reg_section); 3851 S_SET_VALUE (symbolP, (valueT) exp.X_add_number); 3852 set_zero_frag (symbolP); 3853 symbol_get_value_expression (symbolP)->X_op = O_register; 3854 break; 3855 3856 case O_symbol: 3857 seg = S_GET_SEGMENT (exp.X_add_symbol); 3858 /* For x=undef+const, create an expression symbol. 3859 For x=x+const, just update x except when x is an undefined symbol 3860 For x=defined+const, evaluate x. */ 3861 if (symbolP == exp.X_add_symbol 3862 && (seg != undefined_section 3863 || !symbol_constant_p (symbolP))) 3864 { 3865 *symbol_X_add_number (symbolP) += exp.X_add_number; 3866 break; 3867 } 3868 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section) 3869 { 3870 symbolS *s = exp.X_add_symbol; 3871 3872 if (S_IS_COMMON (s)) 3873 as_bad (_("`%s' can't be equated to common symbol '%s'"), 3874 S_GET_NAME (symbolP), S_GET_NAME (s)); 3875 3876 S_SET_SEGMENT (symbolP, seg); 3877 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s)); 3878 symbol_set_frag (symbolP, symbol_get_frag (s)); 3879 copy_symbol_attributes (symbolP, s); 3880 break; 3881 } 3882 S_SET_SEGMENT (symbolP, undefined_section); 3883 symbol_set_value_expression (symbolP, &exp); 3884 copy_symbol_attributes (symbolP, exp.X_add_symbol); 3885 set_zero_frag (symbolP); 3886 break; 3887 3888 default: 3889 /* The value is some complex expression. */ 3890 S_SET_SEGMENT (symbolP, expr_section); 3891 symbol_set_value_expression (symbolP, &exp); 3892 set_zero_frag (symbolP); 3893 break; 3894 } 3895} 3896 3897/* cons() 3898 3899 CONStruct more frag of .bytes, or .words etc. 3900 Should need_pass_2 be 1 then emit no frag(s). 3901 This understands EXPRESSIONS. 3902 3903 Bug (?) 3904 3905 This has a split personality. We use expression() to read the 3906 value. We can detect if the value won't fit in a byte or word. 3907 But we can't detect if expression() discarded significant digits 3908 in the case of a long. Not worth the crocks required to fix it. */ 3909 3910/* Select a parser for cons expressions. */ 3911 3912/* Some targets need to parse the expression in various fancy ways. 3913 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like 3914 (for example, the HPPA does this). Otherwise, you can define 3915 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or 3916 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these 3917 are defined, which is the normal case, then only simple expressions 3918 are permitted. */ 3919 3920#ifdef TC_M68K 3921static void 3922parse_mri_cons (expressionS *exp, unsigned int nbytes); 3923#endif 3924 3925#ifndef TC_PARSE_CONS_EXPRESSION 3926#ifdef BITFIELD_CONS_EXPRESSIONS 3927#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \ 3928 (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE) 3929static void 3930parse_bitfield_cons (expressionS *exp, unsigned int nbytes); 3931#endif 3932#ifdef REPEAT_CONS_EXPRESSIONS 3933#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \ 3934 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE) 3935static void 3936parse_repeat_cons (expressionS *exp, unsigned int nbytes); 3937#endif 3938 3939/* If we haven't gotten one yet, just call expression. */ 3940#ifndef TC_PARSE_CONS_EXPRESSION 3941#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \ 3942 (expression (EXP), TC_PARSE_CONS_RETURN_NONE) 3943#endif 3944#endif 3945 3946void 3947do_parse_cons_expression (expressionS *exp, 3948 int nbytes ATTRIBUTE_UNUSED) 3949{ 3950 (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes); 3951} 3952 3953 3954/* Worker to do .byte etc statements. 3955 Clobbers input_line_pointer and checks end-of-line. */ 3956 3957static void 3958cons_worker (int nbytes, /* 1=.byte, 2=.word, 4=.long. */ 3959 int rva) 3960{ 3961 int c; 3962 expressionS exp; 3963 char *stop = NULL; 3964 char stopc = 0; 3965 3966#ifdef md_flush_pending_output 3967 md_flush_pending_output (); 3968#endif 3969 3970 if (flag_mri) 3971 stop = mri_comment_field (&stopc); 3972 3973 if (is_it_end_of_statement ()) 3974 { 3975 demand_empty_rest_of_line (); 3976 if (flag_mri) 3977 mri_comment_end (stop, stopc); 3978 return; 3979 } 3980 3981#ifdef TC_ADDRESS_BYTES 3982 if (nbytes == 0) 3983 nbytes = TC_ADDRESS_BYTES (); 3984#endif 3985 3986#ifdef md_cons_align 3987 md_cons_align (nbytes); 3988#endif 3989 3990 c = 0; 3991 do 3992 { 3993 TC_PARSE_CONS_RETURN_TYPE ret = TC_PARSE_CONS_RETURN_NONE; 3994#ifdef TC_CONS_FIX_CHECK 3995 fixS **cur_fix = &frchain_now->fix_tail; 3996 3997 if (*cur_fix != NULL) 3998 cur_fix = &(*cur_fix)->fx_next; 3999#endif 4000 4001#ifdef TC_M68K 4002 if (flag_m68k_mri) 4003 parse_mri_cons (&exp, (unsigned int) nbytes); 4004 else 4005#endif 4006 { 4007#if 0 4008 if (*input_line_pointer == '"') 4009 { 4010 as_bad (_("unexpected `\"' in expression")); 4011 ignore_rest_of_line (); 4012 return; 4013 } 4014#endif 4015 ret = TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes); 4016 } 4017 4018 if (rva) 4019 { 4020 if (exp.X_op == O_symbol) 4021 exp.X_op = O_symbol_rva; 4022 else 4023 as_fatal (_("rva without symbol")); 4024 } 4025 emit_expr_with_reloc (&exp, (unsigned int) nbytes, ret); 4026#ifdef TC_CONS_FIX_CHECK 4027 TC_CONS_FIX_CHECK (&exp, nbytes, *cur_fix); 4028#endif 4029 ++c; 4030 } 4031 while (*input_line_pointer++ == ','); 4032 4033 /* In MRI mode, after an odd number of bytes, we must align to an 4034 even word boundary, unless the next instruction is a dc.b, ds.b 4035 or dcb.b. */ 4036 if (flag_mri && nbytes == 1 && (c & 1) != 0) 4037 mri_pending_align = 1; 4038 4039 input_line_pointer--; /* Put terminator back into stream. */ 4040 4041 demand_empty_rest_of_line (); 4042 4043 if (flag_mri) 4044 mri_comment_end (stop, stopc); 4045} 4046 4047void 4048cons (int size) 4049{ 4050 cons_worker (size, 0); 4051} 4052 4053void 4054s_rva (int size) 4055{ 4056 cons_worker (size, 1); 4057} 4058 4059/* .reloc offset, reloc_name, symbol+addend. */ 4060 4061static void 4062s_reloc (int ignore ATTRIBUTE_UNUSED) 4063{ 4064 char *stop = NULL; 4065 char stopc = 0; 4066 expressionS exp; 4067 char *r_name; 4068 int c; 4069 struct reloc_list *reloc; 4070 struct _bfd_rel { const char * name; bfd_reloc_code_real_type code; }; 4071 static struct _bfd_rel bfd_relocs[] = 4072 { 4073 { "NONE", BFD_RELOC_NONE }, 4074 { "8", BFD_RELOC_8 }, 4075 { "16", BFD_RELOC_16 }, 4076 { "32", BFD_RELOC_32 }, 4077 { "64", BFD_RELOC_64 } 4078 }; 4079 4080 reloc = XNEW (struct reloc_list); 4081 4082 if (flag_mri) 4083 stop = mri_comment_field (&stopc); 4084 4085 expression (&exp); 4086 switch (exp.X_op) 4087 { 4088 case O_illegal: 4089 case O_absent: 4090 case O_big: 4091 case O_register: 4092 as_bad (_("missing or bad offset expression")); 4093 goto err_out; 4094 case O_constant: 4095 exp.X_add_symbol = section_symbol (now_seg); 4096 exp.X_op = O_symbol; 4097 /* Fallthru */ 4098 case O_symbol: 4099 if (exp.X_add_number == 0) 4100 { 4101 reloc->u.a.offset_sym = exp.X_add_symbol; 4102 break; 4103 } 4104 /* Fallthru */ 4105 default: 4106 reloc->u.a.offset_sym = make_expr_symbol (&exp); 4107 break; 4108 } 4109 4110 SKIP_WHITESPACE (); 4111 if (*input_line_pointer != ',') 4112 { 4113 as_bad (_("missing reloc type")); 4114 goto err_out; 4115 } 4116 4117 ++input_line_pointer; 4118 SKIP_WHITESPACE (); 4119 c = get_symbol_name (& r_name); 4120 if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0) 4121 { 4122 unsigned int i; 4123 4124 for (reloc->u.a.howto = NULL, i = 0; i < ARRAY_SIZE (bfd_relocs); i++) 4125 if (strcasecmp (r_name + 10, bfd_relocs[i].name) == 0) 4126 { 4127 reloc->u.a.howto = bfd_reloc_type_lookup (stdoutput, 4128 bfd_relocs[i].code); 4129 break; 4130 } 4131 } 4132 else 4133 reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name); 4134 *input_line_pointer = c; 4135 if (reloc->u.a.howto == NULL) 4136 { 4137 as_bad (_("unrecognized reloc type")); 4138 goto err_out; 4139 } 4140 4141 exp.X_op = O_absent; 4142 SKIP_WHITESPACE_AFTER_NAME (); 4143 if (*input_line_pointer == ',') 4144 { 4145 ++input_line_pointer; 4146 expression (&exp); 4147 } 4148 switch (exp.X_op) 4149 { 4150 case O_illegal: 4151 case O_big: 4152 case O_register: 4153 as_bad (_("bad reloc expression")); 4154 err_out: 4155 ignore_rest_of_line (); 4156 free (reloc); 4157 if (flag_mri) 4158 mri_comment_end (stop, stopc); 4159 return; 4160 case O_absent: 4161 reloc->u.a.sym = NULL; 4162 reloc->u.a.addend = 0; 4163 break; 4164 case O_constant: 4165 reloc->u.a.sym = NULL; 4166 reloc->u.a.addend = exp.X_add_number; 4167 break; 4168 case O_symbol: 4169 reloc->u.a.sym = exp.X_add_symbol; 4170 reloc->u.a.addend = exp.X_add_number; 4171 break; 4172 default: 4173 reloc->u.a.sym = make_expr_symbol (&exp); 4174 reloc->u.a.addend = 0; 4175 break; 4176 } 4177 4178 reloc->file = as_where (&reloc->line); 4179 reloc->next = reloc_list; 4180 reloc_list = reloc; 4181 4182 demand_empty_rest_of_line (); 4183 if (flag_mri) 4184 mri_comment_end (stop, stopc); 4185} 4186 4187/* Put the contents of expression EXP into the object file using 4188 NBYTES bytes. If need_pass_2 is 1, this does nothing. */ 4189 4190void 4191emit_expr (expressionS *exp, unsigned int nbytes) 4192{ 4193 emit_expr_with_reloc (exp, nbytes, TC_PARSE_CONS_RETURN_NONE); 4194} 4195 4196void 4197emit_expr_with_reloc (expressionS *exp, 4198 unsigned int nbytes, 4199 TC_PARSE_CONS_RETURN_TYPE reloc) 4200{ 4201 operatorT op; 4202 char *p; 4203 valueT extra_digit = 0; 4204 4205 /* Don't do anything if we are going to make another pass. */ 4206 if (need_pass_2) 4207 return; 4208 4209 frag_grow (nbytes); 4210 dot_value = frag_now_fix (); 4211 dot_frag = frag_now; 4212 4213#ifndef NO_LISTING 4214#ifdef OBJ_ELF 4215 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will 4216 appear as a four byte positive constant in the .line section, 4217 followed by a 2 byte 0xffff. Look for that case here. */ 4218 { 4219 static int dwarf_line = -1; 4220 4221 if (strcmp (segment_name (now_seg), ".line") != 0) 4222 dwarf_line = -1; 4223 else if (dwarf_line >= 0 4224 && nbytes == 2 4225 && exp->X_op == O_constant 4226 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff)) 4227 listing_source_line ((unsigned int) dwarf_line); 4228 else if (nbytes == 4 4229 && exp->X_op == O_constant 4230 && exp->X_add_number >= 0) 4231 dwarf_line = exp->X_add_number; 4232 else 4233 dwarf_line = -1; 4234 } 4235 4236 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will 4237 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte 4238 AT_sibling (0x12) followed by a four byte address of the sibling 4239 followed by a 2 byte AT_name (0x38) followed by the name of the 4240 file. We look for that case here. */ 4241 { 4242 static int dwarf_file = 0; 4243 4244 if (strcmp (segment_name (now_seg), ".debug") != 0) 4245 dwarf_file = 0; 4246 else if (dwarf_file == 0 4247 && nbytes == 2 4248 && exp->X_op == O_constant 4249 && exp->X_add_number == 0x11) 4250 dwarf_file = 1; 4251 else if (dwarf_file == 1 4252 && nbytes == 2 4253 && exp->X_op == O_constant 4254 && exp->X_add_number == 0x12) 4255 dwarf_file = 2; 4256 else if (dwarf_file == 2 4257 && nbytes == 4) 4258 dwarf_file = 3; 4259 else if (dwarf_file == 3 4260 && nbytes == 2 4261 && exp->X_op == O_constant 4262 && exp->X_add_number == 0x38) 4263 dwarf_file = 4; 4264 else 4265 dwarf_file = 0; 4266 4267 /* The variable dwarf_file_string tells stringer that the string 4268 may be the name of the source file. */ 4269 if (dwarf_file == 4) 4270 dwarf_file_string = 1; 4271 else 4272 dwarf_file_string = 0; 4273 } 4274#endif 4275#endif 4276 4277 if (check_eh_frame (exp, &nbytes)) 4278 return; 4279 4280 op = exp->X_op; 4281 4282 /* Handle a negative bignum. */ 4283 if (op == O_uminus 4284 && exp->X_add_number == 0 4285 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big 4286 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0) 4287 { 4288 int i; 4289 unsigned long carry; 4290 4291 exp = symbol_get_value_expression (exp->X_add_symbol); 4292 4293 /* Negate the bignum: one's complement each digit and add 1. */ 4294 carry = 1; 4295 for (i = 0; i < exp->X_add_number; i++) 4296 { 4297 unsigned long next; 4298 4299 next = (((~(generic_bignum[i] & LITTLENUM_MASK)) 4300 & LITTLENUM_MASK) 4301 + carry); 4302 generic_bignum[i] = next & LITTLENUM_MASK; 4303 carry = next >> LITTLENUM_NUMBER_OF_BITS; 4304 } 4305 4306 /* We can ignore any carry out, because it will be handled by 4307 extra_digit if it is needed. */ 4308 4309 extra_digit = (valueT) -1; 4310 op = O_big; 4311 } 4312 4313 if (op == O_absent || op == O_illegal) 4314 { 4315 as_warn (_("zero assumed for missing expression")); 4316 exp->X_add_number = 0; 4317 op = O_constant; 4318 } 4319 else if (op == O_big && exp->X_add_number <= 0) 4320 { 4321 as_bad (_("floating point number invalid")); 4322 exp->X_add_number = 0; 4323 op = O_constant; 4324 } 4325 else if (op == O_register) 4326 { 4327 as_warn (_("register value used as expression")); 4328 op = O_constant; 4329 } 4330 4331 /* Allow `.word 0' in the absolute section. */ 4332 if (now_seg == absolute_section) 4333 { 4334 if (op != O_constant || exp->X_add_number != 0) 4335 as_bad (_("attempt to store value in absolute section")); 4336 abs_section_offset += nbytes; 4337 return; 4338 } 4339 4340 /* Allow `.word 0' in BSS style sections. */ 4341 if ((op != O_constant || exp->X_add_number != 0) && in_bss ()) 4342 as_bad (_("attempt to store non-zero value in section `%s'"), 4343 segment_name (now_seg)); 4344 4345 p = frag_more ((int) nbytes); 4346 4347 if (reloc != TC_PARSE_CONS_RETURN_NONE) 4348 { 4349 emit_expr_fix (exp, nbytes, frag_now, p, reloc); 4350 return; 4351 } 4352 4353#ifndef WORKING_DOT_WORD 4354 /* If we have the difference of two symbols in a word, save it on 4355 the broken_words list. See the code in write.c. */ 4356 if (op == O_subtract && nbytes == 2) 4357 { 4358 struct broken_word *x; 4359 4360 x = XNEW (struct broken_word); 4361 x->next_broken_word = broken_words; 4362 broken_words = x; 4363 x->seg = now_seg; 4364 x->subseg = now_subseg; 4365 x->frag = frag_now; 4366 x->word_goes_here = p; 4367 x->dispfrag = 0; 4368 x->add = exp->X_add_symbol; 4369 x->sub = exp->X_op_symbol; 4370 x->addnum = exp->X_add_number; 4371 x->added = 0; 4372 x->use_jump = 0; 4373 new_broken_words++; 4374 return; 4375 } 4376#endif 4377 4378 /* If we have an integer, but the number of bytes is too large to 4379 pass to md_number_to_chars, handle it as a bignum. */ 4380 if (op == O_constant && nbytes > sizeof (valueT)) 4381 { 4382 extra_digit = exp->X_unsigned ? 0 : -1; 4383 convert_to_bignum (exp, !exp->X_unsigned); 4384 op = O_big; 4385 } 4386 4387 if (op == O_constant) 4388 { 4389 valueT get; 4390 valueT use; 4391 valueT mask; 4392 valueT hibit; 4393 valueT unmask; 4394 4395 /* JF << of >= number of bits in the object is undefined. In 4396 particular SPARC (Sun 4) has problems. */ 4397 if (nbytes >= sizeof (valueT)) 4398 { 4399 mask = 0; 4400 if (nbytes > sizeof (valueT)) 4401 hibit = 0; 4402 else 4403 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1); 4404 } 4405 else 4406 { 4407 /* Don't store these bits. */ 4408 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes); 4409 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1); 4410 } 4411 4412 unmask = ~mask; /* Do store these bits. */ 4413 4414#ifdef NEVER 4415 "Do this mod if you want every overflow check to assume SIGNED 2's complement data."; 4416 mask = ~(unmask >> 1); /* Includes sign bit now. */ 4417#endif 4418 4419 get = exp->X_add_number; 4420 use = get & unmask; 4421 if ((get & mask) != 0 4422 && ((get & mask) != mask 4423 || (get & hibit) == 0)) 4424 { 4425 /* Leading bits contain both 0s & 1s. */ 4426#if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG 4427#ifndef __MSVCRT__ 4428 as_warn (_("value 0x%llx truncated to 0x%llx"), 4429 (unsigned long long) get, (unsigned long long) use); 4430#else 4431 as_warn (_("value 0x%I64x truncated to 0x%I64x"), 4432 (unsigned long long) get, (unsigned long long) use); 4433#endif 4434#else 4435 as_warn (_("value 0x%lx truncated to 0x%lx"), 4436 (unsigned long) get, (unsigned long) use); 4437#endif 4438 } 4439 /* Put bytes in right order. */ 4440 md_number_to_chars (p, use, (int) nbytes); 4441 } 4442 else if (op == O_big) 4443 { 4444 unsigned int size; 4445 LITTLENUM_TYPE *nums; 4446 4447 size = exp->X_add_number * CHARS_PER_LITTLENUM; 4448 if (nbytes < size) 4449 { 4450 int i = nbytes / CHARS_PER_LITTLENUM; 4451 4452 if (i != 0) 4453 { 4454 LITTLENUM_TYPE sign = 0; 4455 if ((generic_bignum[--i] 4456 & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0) 4457 sign = ~(LITTLENUM_TYPE) 0; 4458 4459 while (++i < exp->X_add_number) 4460 if (generic_bignum[i] != sign) 4461 break; 4462 } 4463 else if (nbytes == 1) 4464 { 4465 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably). 4466 Check that bits 8.. of generic_bignum[0] match bit 7 4467 and that they match all of generic_bignum[1..exp->X_add_number]. */ 4468 LITTLENUM_TYPE sign = (generic_bignum[0] & (1 << 7)) ? -1 : 0; 4469 LITTLENUM_TYPE himask = LITTLENUM_MASK & ~ 0xFF; 4470 4471 if ((generic_bignum[0] & himask) == (sign & himask)) 4472 { 4473 while (++i < exp->X_add_number) 4474 if (generic_bignum[i] != sign) 4475 break; 4476 } 4477 } 4478 4479 if (i < exp->X_add_number) 4480 as_warn (_("bignum truncated to %d bytes"), nbytes); 4481 size = nbytes; 4482 } 4483 4484 if (nbytes == 1) 4485 { 4486 md_number_to_chars (p, (valueT) generic_bignum[0], 1); 4487 return; 4488 } 4489 know (nbytes % CHARS_PER_LITTLENUM == 0); 4490 4491 if (target_big_endian) 4492 { 4493 while (nbytes > size) 4494 { 4495 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 4496 nbytes -= CHARS_PER_LITTLENUM; 4497 p += CHARS_PER_LITTLENUM; 4498 } 4499 4500 nums = generic_bignum + size / CHARS_PER_LITTLENUM; 4501 while (size >= CHARS_PER_LITTLENUM) 4502 { 4503 --nums; 4504 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 4505 size -= CHARS_PER_LITTLENUM; 4506 p += CHARS_PER_LITTLENUM; 4507 } 4508 } 4509 else 4510 { 4511 nums = generic_bignum; 4512 while (size >= CHARS_PER_LITTLENUM) 4513 { 4514 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 4515 ++nums; 4516 size -= CHARS_PER_LITTLENUM; 4517 p += CHARS_PER_LITTLENUM; 4518 nbytes -= CHARS_PER_LITTLENUM; 4519 } 4520 4521 while (nbytes >= CHARS_PER_LITTLENUM) 4522 { 4523 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 4524 nbytes -= CHARS_PER_LITTLENUM; 4525 p += CHARS_PER_LITTLENUM; 4526 } 4527 } 4528 } 4529 else 4530 emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE); 4531} 4532 4533void 4534emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p, 4535 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED) 4536{ 4537 int offset = 0; 4538 unsigned int size = nbytes; 4539 4540 memset (p, 0, size); 4541 4542 /* Generate a fixS to record the symbol value. */ 4543 4544#ifdef TC_CONS_FIX_NEW 4545 TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r); 4546#else 4547 if (r != TC_PARSE_CONS_RETURN_NONE) 4548 { 4549 reloc_howto_type *reloc_howto; 4550 4551 reloc_howto = bfd_reloc_type_lookup (stdoutput, r); 4552 size = bfd_get_reloc_size (reloc_howto); 4553 4554 if (size > nbytes) 4555 { 4556 as_bad (_("%s relocations do not fit in %u bytes\n"), 4557 reloc_howto->name, nbytes); 4558 return; 4559 } 4560 else if (target_big_endian) 4561 offset = nbytes - size; 4562 } 4563 else 4564 switch (size) 4565 { 4566 case 1: 4567 r = BFD_RELOC_8; 4568 break; 4569 case 2: 4570 r = BFD_RELOC_16; 4571 break; 4572 case 3: 4573 r = BFD_RELOC_24; 4574 break; 4575 case 4: 4576 r = BFD_RELOC_32; 4577 break; 4578 case 8: 4579 r = BFD_RELOC_64; 4580 break; 4581 default: 4582 as_bad (_("unsupported BFD relocation size %u"), size); 4583 return; 4584 } 4585 fix_new_exp (frag, p - frag->fr_literal + offset, size, 4586 exp, 0, r); 4587#endif 4588} 4589 4590#ifdef BITFIELD_CONS_EXPRESSIONS 4591 4592/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as 4593 w:x,y:z, where w and y are bitwidths and x and y are values. They 4594 then pack them all together. We do a little better in that we allow 4595 them in words, longs, etc. and we'll pack them in target byte order 4596 for you. 4597 4598 The rules are: pack least significant bit first, if a field doesn't 4599 entirely fit, put it in the next unit. Overflowing the bitfield is 4600 explicitly *not* even a warning. The bitwidth should be considered 4601 a "mask". 4602 4603 To use this function the tc-XXX.h file should define 4604 BITFIELD_CONS_EXPRESSIONS. */ 4605 4606static void 4607parse_bitfield_cons (expressionS *exp, unsigned int nbytes) 4608{ 4609 unsigned int bits_available = BITS_PER_CHAR * nbytes; 4610 char *hold = input_line_pointer; 4611 4612 (void) expression (exp); 4613 4614 if (*input_line_pointer == ':') 4615 { 4616 /* Bitfields. */ 4617 long value = 0; 4618 4619 for (;;) 4620 { 4621 unsigned long width; 4622 4623 if (*input_line_pointer != ':') 4624 { 4625 input_line_pointer = hold; 4626 break; 4627 } /* Next piece is not a bitfield. */ 4628 4629 /* In the general case, we can't allow 4630 full expressions with symbol 4631 differences and such. The relocation 4632 entries for symbols not defined in this 4633 assembly would require arbitrary field 4634 widths, positions, and masks which most 4635 of our current object formats don't 4636 support. 4637 4638 In the specific case where a symbol 4639 *is* defined in this assembly, we 4640 *could* build fixups and track it, but 4641 this could lead to confusion for the 4642 backends. I'm lazy. I'll take any 4643 SEG_ABSOLUTE. I think that means that 4644 you can use a previous .set or 4645 .equ type symbol. xoxorich. */ 4646 4647 if (exp->X_op == O_absent) 4648 { 4649 as_warn (_("using a bit field width of zero")); 4650 exp->X_add_number = 0; 4651 exp->X_op = O_constant; 4652 } /* Implied zero width bitfield. */ 4653 4654 if (exp->X_op != O_constant) 4655 { 4656 *input_line_pointer = '\0'; 4657 as_bad (_("field width \"%s\" too complex for a bitfield"), hold); 4658 *input_line_pointer = ':'; 4659 demand_empty_rest_of_line (); 4660 return; 4661 } /* Too complex. */ 4662 4663 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) 4664 { 4665 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"), 4666 width, nbytes, (BITS_PER_CHAR * nbytes)); 4667 width = BITS_PER_CHAR * nbytes; 4668 } /* Too big. */ 4669 4670 if (width > bits_available) 4671 { 4672 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */ 4673 input_line_pointer = hold; 4674 exp->X_add_number = value; 4675 break; 4676 } /* Won't fit. */ 4677 4678 /* Skip ':'. */ 4679 hold = ++input_line_pointer; 4680 4681 (void) expression (exp); 4682 if (exp->X_op != O_constant) 4683 { 4684 char cache = *input_line_pointer; 4685 4686 *input_line_pointer = '\0'; 4687 as_bad (_("field value \"%s\" too complex for a bitfield"), hold); 4688 *input_line_pointer = cache; 4689 demand_empty_rest_of_line (); 4690 return; 4691 } /* Too complex. */ 4692 4693 value |= ((~(-(1 << width)) & exp->X_add_number) 4694 << ((BITS_PER_CHAR * nbytes) - bits_available)); 4695 4696 if ((bits_available -= width) == 0 4697 || is_it_end_of_statement () 4698 || *input_line_pointer != ',') 4699 { 4700 break; 4701 } /* All the bitfields we're gonna get. */ 4702 4703 hold = ++input_line_pointer; 4704 (void) expression (exp); 4705 } 4706 4707 exp->X_add_number = value; 4708 exp->X_op = O_constant; 4709 exp->X_unsigned = 1; 4710 exp->X_extrabit = 0; 4711 } 4712} 4713 4714#endif /* BITFIELD_CONS_EXPRESSIONS */ 4715 4716/* Handle an MRI style string expression. */ 4717 4718#ifdef TC_M68K 4719static void 4720parse_mri_cons (expressionS *exp, unsigned int nbytes) 4721{ 4722 if (*input_line_pointer != '\'' 4723 && (input_line_pointer[1] != '\'' 4724 || (*input_line_pointer != 'A' 4725 && *input_line_pointer != 'E'))) 4726 (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes); 4727 else 4728 { 4729 unsigned int scan; 4730 unsigned int result = 0; 4731 4732 /* An MRI style string. Cut into as many bytes as will fit into 4733 a nbyte chunk, left justify if necessary, and separate with 4734 commas so we can try again later. */ 4735 if (*input_line_pointer == 'A') 4736 ++input_line_pointer; 4737 else if (*input_line_pointer == 'E') 4738 { 4739 as_bad (_("EBCDIC constants are not supported")); 4740 ++input_line_pointer; 4741 } 4742 4743 input_line_pointer++; 4744 for (scan = 0; scan < nbytes; scan++) 4745 { 4746 if (*input_line_pointer == '\'') 4747 { 4748 if (input_line_pointer[1] == '\'') 4749 { 4750 input_line_pointer++; 4751 } 4752 else 4753 break; 4754 } 4755 result = (result << 8) | (*input_line_pointer++); 4756 } 4757 4758 /* Left justify. */ 4759 while (scan < nbytes) 4760 { 4761 result <<= 8; 4762 scan++; 4763 } 4764 4765 /* Create correct expression. */ 4766 exp->X_op = O_constant; 4767 exp->X_add_number = result; 4768 4769 /* Fake it so that we can read the next char too. */ 4770 if (input_line_pointer[0] != '\'' || 4771 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\'')) 4772 { 4773 input_line_pointer -= 2; 4774 input_line_pointer[0] = ','; 4775 input_line_pointer[1] = '\''; 4776 } 4777 else 4778 input_line_pointer++; 4779 } 4780} 4781#endif /* TC_M68K */ 4782 4783#ifdef REPEAT_CONS_EXPRESSIONS 4784 4785/* Parse a repeat expression for cons. This is used by the MIPS 4786 assembler. The format is NUMBER:COUNT; NUMBER appears in the 4787 object file COUNT times. 4788 4789 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */ 4790 4791static void 4792parse_repeat_cons (expressionS *exp, unsigned int nbytes) 4793{ 4794 expressionS count; 4795 int i; 4796 4797 expression (exp); 4798 4799 if (*input_line_pointer != ':') 4800 { 4801 /* No repeat count. */ 4802 return; 4803 } 4804 4805 ++input_line_pointer; 4806 expression (&count); 4807 if (count.X_op != O_constant 4808 || count.X_add_number <= 0) 4809 { 4810 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 4811 return; 4812 } 4813 4814 /* The cons function is going to output this expression once. So we 4815 output it count - 1 times. */ 4816 for (i = count.X_add_number - 1; i > 0; i--) 4817 emit_expr (exp, nbytes); 4818} 4819 4820#endif /* REPEAT_CONS_EXPRESSIONS */ 4821 4822/* Parse a floating point number represented as a hex constant. This 4823 permits users to specify the exact bits they want in the floating 4824 point number. */ 4825 4826static int 4827hex_float (int float_type, char *bytes) 4828{ 4829 int length; 4830 int i; 4831 4832 switch (float_type) 4833 { 4834 case 'f': 4835 case 'F': 4836 case 's': 4837 case 'S': 4838 length = 4; 4839 break; 4840 4841 case 'd': 4842 case 'D': 4843 case 'r': 4844 case 'R': 4845 length = 8; 4846 break; 4847 4848 case 'x': 4849 case 'X': 4850 length = 12; 4851 break; 4852 4853 case 'p': 4854 case 'P': 4855 length = 12; 4856 break; 4857 4858 default: 4859 as_bad (_("unknown floating type type '%c'"), float_type); 4860 return -1; 4861 } 4862 4863 /* It would be nice if we could go through expression to parse the 4864 hex constant, but if we get a bignum it's a pain to sort it into 4865 the buffer correctly. */ 4866 i = 0; 4867 while (hex_p (*input_line_pointer) || *input_line_pointer == '_') 4868 { 4869 int d; 4870 4871 /* The MRI assembler accepts arbitrary underscores strewn about 4872 through the hex constant, so we ignore them as well. */ 4873 if (*input_line_pointer == '_') 4874 { 4875 ++input_line_pointer; 4876 continue; 4877 } 4878 4879 if (i >= length) 4880 { 4881 as_warn (_("floating point constant too large")); 4882 return -1; 4883 } 4884 d = hex_value (*input_line_pointer) << 4; 4885 ++input_line_pointer; 4886 while (*input_line_pointer == '_') 4887 ++input_line_pointer; 4888 if (hex_p (*input_line_pointer)) 4889 { 4890 d += hex_value (*input_line_pointer); 4891 ++input_line_pointer; 4892 } 4893 if (target_big_endian) 4894 bytes[i] = d; 4895 else 4896 bytes[length - i - 1] = d; 4897 ++i; 4898 } 4899 4900 if (i < length) 4901 { 4902 if (target_big_endian) 4903 memset (bytes + i, 0, length - i); 4904 else 4905 memset (bytes, 0, length - i); 4906 } 4907 4908 return length; 4909} 4910 4911/* float_cons() 4912 4913 CONStruct some more frag chars of .floats .ffloats etc. 4914 Makes 0 or more new frags. 4915 If need_pass_2 == 1, no frags are emitted. 4916 This understands only floating literals, not expressions. Sorry. 4917 4918 A floating constant is defined by atof_generic(), except it is preceded 4919 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its 4920 reading, I decided to be incompatible. This always tries to give you 4921 rounded bits to the precision of the pseudo-op. Former AS did premature 4922 truncation, restored noisy bits instead of trailing 0s AND gave you 4923 a choice of 2 flavours of noise according to which of 2 floating-point 4924 scanners you directed AS to use. 4925 4926 In: input_line_pointer->whitespace before, or '0' of flonum. */ 4927 4928void 4929float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ 4930 int float_type /* 'f':.ffloat ... 'F':.float ... */) 4931{ 4932 char *p; 4933 int length; /* Number of chars in an object. */ 4934 const char *err; /* Error from scanning floating literal. */ 4935 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 4936 4937 if (is_it_end_of_statement ()) 4938 { 4939 demand_empty_rest_of_line (); 4940 return; 4941 } 4942 4943 if (now_seg == absolute_section) 4944 { 4945 as_bad (_("attempt to store float in absolute section")); 4946 ignore_rest_of_line (); 4947 return; 4948 } 4949 4950 if (in_bss ()) 4951 { 4952 as_bad (_("attempt to store float in section `%s'"), 4953 segment_name (now_seg)); 4954 ignore_rest_of_line (); 4955 return; 4956 } 4957 4958#ifdef md_flush_pending_output 4959 md_flush_pending_output (); 4960#endif 4961 4962#ifdef md_cons_align 4963 md_cons_align (1); 4964#endif 4965 4966 do 4967 { 4968 /* input_line_pointer->1st char of a flonum (we hope!). */ 4969 SKIP_WHITESPACE (); 4970 4971 /* Skip any 0{letter} that may be present. Don't even check if the 4972 letter is legal. Someone may invent a "z" format and this routine 4973 has no use for such information. Lusers beware: you get 4974 diagnostics if your input is ill-conditioned. */ 4975 if (input_line_pointer[0] == '0' 4976 && ISALPHA (input_line_pointer[1])) 4977 input_line_pointer += 2; 4978 4979 /* Accept :xxxx, where the x's are hex digits, for a floating 4980 point with the exact digits specified. */ 4981 if (input_line_pointer[0] == ':') 4982 { 4983 ++input_line_pointer; 4984 length = hex_float (float_type, temp); 4985 if (length < 0) 4986 { 4987 ignore_rest_of_line (); 4988 return; 4989 } 4990 } 4991 else 4992 { 4993 err = md_atof (float_type, temp, &length); 4994 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 4995 know (err != NULL || length > 0); 4996 if (err) 4997 { 4998 as_bad (_("bad floating literal: %s"), err); 4999 ignore_rest_of_line (); 5000 return; 5001 } 5002 } 5003 5004 if (!need_pass_2) 5005 { 5006 int count; 5007 5008 count = 1; 5009 5010#ifdef REPEAT_CONS_EXPRESSIONS 5011 if (*input_line_pointer == ':') 5012 { 5013 expressionS count_exp; 5014 5015 ++input_line_pointer; 5016 expression (&count_exp); 5017 5018 if (count_exp.X_op != O_constant 5019 || count_exp.X_add_number <= 0) 5020 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 5021 else 5022 count = count_exp.X_add_number; 5023 } 5024#endif 5025 5026 while (--count >= 0) 5027 { 5028 p = frag_more (length); 5029 memcpy (p, temp, (unsigned int) length); 5030 } 5031 } 5032 SKIP_WHITESPACE (); 5033 } 5034 while (*input_line_pointer++ == ','); 5035 5036 /* Put terminator back into stream. */ 5037 --input_line_pointer; 5038 demand_empty_rest_of_line (); 5039} 5040 5041/* LEB128 Encoding. 5042 5043 Note - we are using the DWARF standard's definition of LEB128 encoding 5044 where each 7-bit value is a stored in a byte, *not* an octet. This 5045 means that on targets where a byte contains multiple octets there is 5046 a *huge waste of space*. (This also means that we do not have to 5047 have special versions of these functions for when OCTETS_PER_BYTE_POWER 5048 is non-zero). 5049 5050 If the 7-bit values were to be packed into N-bit bytes (where N > 8) 5051 we would then have to consider whether multiple, successive LEB128 5052 values should be packed into the bytes without padding (bad idea) or 5053 whether each LEB128 number is padded out to a whole number of bytes. 5054 Plus you have to decide on the endianness of packing octets into a 5055 byte. */ 5056 5057/* Return the size of a LEB128 value in bytes. */ 5058 5059static inline unsigned int 5060sizeof_sleb128 (offsetT value) 5061{ 5062 int size = 0; 5063 unsigned byte; 5064 5065 do 5066 { 5067 byte = (value & 0x7f); 5068 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 5069 Fortunately, we can structure things so that the extra work reduces 5070 to a noop on systems that do things "properly". */ 5071 value = (value >> 7) | ~(-(offsetT)1 >> 7); 5072 size += 1; 5073 } 5074 while (!(((value == 0) && ((byte & 0x40) == 0)) 5075 || ((value == -1) && ((byte & 0x40) != 0)))); 5076 5077 return size; 5078} 5079 5080static inline unsigned int 5081sizeof_uleb128 (valueT value) 5082{ 5083 int size = 0; 5084 5085 do 5086 { 5087 value >>= 7; 5088 size += 1; 5089 } 5090 while (value != 0); 5091 5092 return size; 5093} 5094 5095unsigned int 5096sizeof_leb128 (valueT value, int sign) 5097{ 5098 if (sign) 5099 return sizeof_sleb128 ((offsetT) value); 5100 else 5101 return sizeof_uleb128 (value); 5102} 5103 5104/* Output a LEB128 value. Returns the number of bytes used. */ 5105 5106static inline unsigned int 5107output_sleb128 (char *p, offsetT value) 5108{ 5109 char *orig = p; 5110 int more; 5111 5112 do 5113 { 5114 unsigned byte = (value & 0x7f); 5115 5116 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 5117 Fortunately, we can structure things so that the extra work reduces 5118 to a noop on systems that do things "properly". */ 5119 value = (value >> 7) | ~(-(offsetT)1 >> 7); 5120 5121 more = !((((value == 0) && ((byte & 0x40) == 0)) 5122 || ((value == -1) && ((byte & 0x40) != 0)))); 5123 if (more) 5124 byte |= 0x80; 5125 5126 *p++ = byte; 5127 } 5128 while (more); 5129 5130 return p - orig; 5131} 5132 5133static inline unsigned int 5134output_uleb128 (char *p, valueT value) 5135{ 5136 char *orig = p; 5137 5138 do 5139 { 5140 unsigned byte = (value & 0x7f); 5141 5142 value >>= 7; 5143 if (value != 0) 5144 /* More bytes to follow. */ 5145 byte |= 0x80; 5146 5147 *p++ = byte; 5148 } 5149 while (value != 0); 5150 5151 return p - orig; 5152} 5153 5154unsigned int 5155output_leb128 (char *p, valueT value, int sign) 5156{ 5157 if (sign) 5158 return output_sleb128 (p, (offsetT) value); 5159 else 5160 return output_uleb128 (p, value); 5161} 5162 5163/* Do the same for bignums. We combine sizeof with output here in that 5164 we don't output for NULL values of P. It isn't really as critical as 5165 for "normal" values that this be streamlined. Returns the number of 5166 bytes used. */ 5167 5168static inline unsigned int 5169output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size) 5170{ 5171 char *orig = p; 5172 valueT val = 0; 5173 int loaded = 0; 5174 unsigned byte; 5175 5176 /* Strip leading sign extensions off the bignum. */ 5177 while (size > 1 5178 && bignum[size - 1] == LITTLENUM_MASK 5179 && bignum[size - 2] > LITTLENUM_MASK / 2) 5180 size--; 5181 5182 do 5183 { 5184 /* OR in the next part of the littlenum. */ 5185 val |= (*bignum << loaded); 5186 loaded += LITTLENUM_NUMBER_OF_BITS; 5187 size--; 5188 bignum++; 5189 5190 /* Add bytes until there are less than 7 bits left in VAL 5191 or until every non-sign bit has been written. */ 5192 do 5193 { 5194 byte = val & 0x7f; 5195 loaded -= 7; 5196 val >>= 7; 5197 if (size > 0 5198 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1)) 5199 byte |= 0x80; 5200 5201 if (orig) 5202 *p = byte; 5203 p++; 5204 } 5205 while ((byte & 0x80) != 0 && loaded >= 7); 5206 } 5207 while (size > 0); 5208 5209 /* Mop up any left-over bits (of which there will be less than 7). */ 5210 if ((byte & 0x80) != 0) 5211 { 5212 /* Sign-extend VAL. */ 5213 if (val & (1 << (loaded - 1))) 5214 val |= ~0U << loaded; 5215 if (orig) 5216 *p = val & 0x7f; 5217 p++; 5218 } 5219 5220 return p - orig; 5221} 5222 5223static inline unsigned int 5224output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size) 5225{ 5226 char *orig = p; 5227 valueT val = 0; 5228 int loaded = 0; 5229 unsigned byte; 5230 5231 /* Strip leading zeros off the bignum. */ 5232 /* XXX: Is this needed? */ 5233 while (size > 0 && bignum[size - 1] == 0) 5234 size--; 5235 5236 do 5237 { 5238 if (loaded < 7 && size > 0) 5239 { 5240 val |= (*bignum << loaded); 5241 loaded += 8 * CHARS_PER_LITTLENUM; 5242 size--; 5243 bignum++; 5244 } 5245 5246 byte = val & 0x7f; 5247 loaded -= 7; 5248 val >>= 7; 5249 5250 if (size > 0 || val) 5251 byte |= 0x80; 5252 5253 if (orig) 5254 *p = byte; 5255 p++; 5256 } 5257 while (byte & 0x80); 5258 5259 return p - orig; 5260} 5261 5262static unsigned int 5263output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, unsigned int size, int sign) 5264{ 5265 if (sign) 5266 return output_big_sleb128 (p, bignum, size); 5267 else 5268 return output_big_uleb128 (p, bignum, size); 5269} 5270 5271/* Generate the appropriate fragments for a given expression to emit a 5272 leb128 value. SIGN is 1 for sleb, 0 for uleb. */ 5273 5274static void 5275emit_leb128_expr (expressionS *exp, int sign) 5276{ 5277 operatorT op = exp->X_op; 5278 unsigned int nbytes; 5279 5280 if (op == O_absent || op == O_illegal) 5281 { 5282 as_warn (_("zero assumed for missing expression")); 5283 exp->X_add_number = 0; 5284 op = O_constant; 5285 } 5286 else if (op == O_big && exp->X_add_number <= 0) 5287 { 5288 as_bad (_("floating point number invalid")); 5289 exp->X_add_number = 0; 5290 op = O_constant; 5291 } 5292 else if (op == O_register) 5293 { 5294 as_warn (_("register value used as expression")); 5295 op = O_constant; 5296 } 5297 else if (op == O_constant 5298 && sign 5299 && (exp->X_add_number < 0) == !exp->X_extrabit) 5300 { 5301 /* We're outputting a signed leb128 and the sign of X_add_number 5302 doesn't reflect the sign of the original value. Convert EXP 5303 to a correctly-extended bignum instead. */ 5304 convert_to_bignum (exp, exp->X_extrabit); 5305 op = O_big; 5306 } 5307 5308 if (now_seg == absolute_section) 5309 { 5310 if (op != O_constant || exp->X_add_number != 0) 5311 as_bad (_("attempt to store value in absolute section")); 5312 abs_section_offset++; 5313 return; 5314 } 5315 5316 if ((op != O_constant || exp->X_add_number != 0) && in_bss ()) 5317 as_bad (_("attempt to store non-zero value in section `%s'"), 5318 segment_name (now_seg)); 5319 5320 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is 5321 a signal that this is leb128 data. It shouldn't optimize this away. */ 5322 nbytes = (unsigned int) -1; 5323 if (check_eh_frame (exp, &nbytes)) 5324 abort (); 5325 5326 /* Let the backend know that subsequent data may be byte aligned. */ 5327#ifdef md_cons_align 5328 md_cons_align (1); 5329#endif 5330 5331 if (op == O_constant) 5332 { 5333 /* If we've got a constant, emit the thing directly right now. */ 5334 5335 valueT value = exp->X_add_number; 5336 unsigned int size; 5337 char *p; 5338 5339 size = sizeof_leb128 (value, sign); 5340 p = frag_more (size); 5341 if (output_leb128 (p, value, sign) > size) 5342 abort (); 5343 } 5344 else if (op == O_big) 5345 { 5346 /* O_big is a different sort of constant. */ 5347 5348 unsigned int size; 5349 char *p; 5350 5351 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); 5352 p = frag_more (size); 5353 if (output_big_leb128 (p, generic_bignum, exp->X_add_number, sign) > size) 5354 abort (); 5355 } 5356 else 5357 { 5358 /* Otherwise, we have to create a variable sized fragment and 5359 resolve things later. */ 5360 5361 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign, 5362 make_expr_symbol (exp), 0, (char *) NULL); 5363 } 5364} 5365 5366/* Parse the .sleb128 and .uleb128 pseudos. */ 5367 5368void 5369s_leb128 (int sign) 5370{ 5371 expressionS exp; 5372 5373#ifdef md_flush_pending_output 5374 md_flush_pending_output (); 5375#endif 5376 5377 do 5378 { 5379 expression (&exp); 5380 emit_leb128_expr (&exp, sign); 5381 } 5382 while (*input_line_pointer++ == ','); 5383 5384 input_line_pointer--; 5385 demand_empty_rest_of_line (); 5386} 5387 5388static void 5389stringer_append_char (int c, int bitsize) 5390{ 5391 if (c && in_bss ()) 5392 as_bad (_("attempt to store non-empty string in section `%s'"), 5393 segment_name (now_seg)); 5394 5395 if (!target_big_endian) 5396 FRAG_APPEND_1_CHAR (c); 5397 5398 switch (bitsize) 5399 { 5400 case 64: 5401 FRAG_APPEND_1_CHAR (0); 5402 FRAG_APPEND_1_CHAR (0); 5403 FRAG_APPEND_1_CHAR (0); 5404 FRAG_APPEND_1_CHAR (0); 5405 /* Fall through. */ 5406 case 32: 5407 FRAG_APPEND_1_CHAR (0); 5408 FRAG_APPEND_1_CHAR (0); 5409 /* Fall through. */ 5410 case 16: 5411 FRAG_APPEND_1_CHAR (0); 5412 /* Fall through. */ 5413 case 8: 5414 break; 5415 default: 5416 /* Called with invalid bitsize argument. */ 5417 abort (); 5418 break; 5419 } 5420 if (target_big_endian) 5421 FRAG_APPEND_1_CHAR (c); 5422} 5423 5424/* Worker to do .ascii etc statements. 5425 Reads 0 or more ',' separated, double-quoted strings. 5426 Caller should have checked need_pass_2 is FALSE because we don't 5427 check it. 5428 Checks for end-of-line. 5429 BITS_APPENDZERO says how many bits are in a target char. 5430 The bottom bit is set if a NUL char should be appended to the strings. */ 5431 5432void 5433stringer (int bits_appendzero) 5434{ 5435 const int bitsize = bits_appendzero & ~7; 5436 const int append_zero = bits_appendzero & 1; 5437 unsigned int c; 5438#if !defined(NO_LISTING) && defined (OBJ_ELF) 5439 char *start; 5440#endif 5441 5442#ifdef md_flush_pending_output 5443 md_flush_pending_output (); 5444#endif 5445 5446#ifdef md_cons_align 5447 md_cons_align (1); 5448#endif 5449 5450 /* If we have been switched into the abs_section then we 5451 will not have an obstack onto which we can hang strings. */ 5452 if (now_seg == absolute_section) 5453 { 5454 as_bad (_("strings must be placed into a section")); 5455 ignore_rest_of_line (); 5456 return; 5457 } 5458 5459 /* The following awkward logic is to parse ZERO or more strings, 5460 comma separated. Recall a string expression includes spaces 5461 before the opening '\"' and spaces after the closing '\"'. 5462 We fake a leading ',' if there is (supposed to be) 5463 a 1st, expression. We keep demanding expressions for each ','. */ 5464 if (is_it_end_of_statement ()) 5465 { 5466 c = 0; /* Skip loop. */ 5467 ++input_line_pointer; /* Compensate for end of loop. */ 5468 } 5469 else 5470 { 5471 c = ','; /* Do loop. */ 5472 } 5473 5474 while (c == ',' || c == '<' || c == '"') 5475 { 5476 SKIP_WHITESPACE (); 5477 switch (*input_line_pointer) 5478 { 5479 case '\"': 5480 ++input_line_pointer; /*->1st char of string. */ 5481#if !defined(NO_LISTING) && defined (OBJ_ELF) 5482 start = input_line_pointer; 5483#endif 5484 5485 while (is_a_char (c = next_char_of_string ())) 5486 stringer_append_char (c, bitsize); 5487 5488 if (append_zero) 5489 stringer_append_char (0, bitsize); 5490 5491 know (input_line_pointer[-1] == '\"'); 5492 5493#if !defined(NO_LISTING) && defined (OBJ_ELF) 5494 /* In ELF, when gcc is emitting DWARF 1 debugging output, it 5495 will emit .string with a filename in the .debug section 5496 after a sequence of constants. See the comment in 5497 emit_expr for the sequence. emit_expr will set 5498 dwarf_file_string to non-zero if this string might be a 5499 source file name. */ 5500 if (strcmp (segment_name (now_seg), ".debug") != 0) 5501 dwarf_file_string = 0; 5502 else if (dwarf_file_string) 5503 { 5504 c = input_line_pointer[-1]; 5505 input_line_pointer[-1] = '\0'; 5506 listing_source_file (start); 5507 input_line_pointer[-1] = c; 5508 } 5509#endif 5510 5511 break; 5512 case '<': 5513 input_line_pointer++; 5514 c = get_single_number (); 5515 stringer_append_char (c, bitsize); 5516 if (*input_line_pointer != '>') 5517 as_bad (_("expected <nn>")); 5518 5519 input_line_pointer++; 5520 break; 5521 case ',': 5522 input_line_pointer++; 5523 break; 5524 } 5525 SKIP_WHITESPACE (); 5526 c = *input_line_pointer; 5527 } 5528 5529 demand_empty_rest_of_line (); 5530} 5531 5532/* FIXME-SOMEDAY: I had trouble here on characters with the 5533 high bits set. We'll probably also have trouble with 5534 multibyte chars, wide chars, etc. Also be careful about 5535 returning values bigger than 1 byte. xoxorich. */ 5536 5537unsigned int 5538next_char_of_string (void) 5539{ 5540 unsigned int c; 5541 5542 c = *input_line_pointer++ & CHAR_MASK; 5543 switch (c) 5544 { 5545 case 0: 5546 /* PR 20902: Do not advance past the end of the buffer. */ 5547 -- input_line_pointer; 5548 c = NOT_A_CHAR; 5549 break; 5550 5551 case '\"': 5552 c = NOT_A_CHAR; 5553 break; 5554 5555 case '\n': 5556 as_warn (_("unterminated string; newline inserted")); 5557 bump_line_counters (); 5558 break; 5559 5560#ifndef NO_STRING_ESCAPES 5561 case '\\': 5562 switch (c = *input_line_pointer++ & CHAR_MASK) 5563 { 5564 case 'b': 5565 c = '\b'; 5566 break; 5567 5568 case 'f': 5569 c = '\f'; 5570 break; 5571 5572 case 'n': 5573 c = '\n'; 5574 break; 5575 5576 case 'r': 5577 c = '\r'; 5578 break; 5579 5580 case 't': 5581 c = '\t'; 5582 break; 5583 5584 case 'v': 5585 c = '\013'; 5586 break; 5587 5588 case '\\': 5589 case '"': 5590 break; /* As itself. */ 5591 5592 case '0': 5593 case '1': 5594 case '2': 5595 case '3': 5596 case '4': 5597 case '5': 5598 case '6': 5599 case '7': 5600 case '8': 5601 case '9': 5602 { 5603 long number; 5604 int i; 5605 5606 for (i = 0, number = 0; 5607 ISDIGIT (c) && i < 3; 5608 c = *input_line_pointer++, i++) 5609 { 5610 number = number * 8 + c - '0'; 5611 } 5612 5613 c = number & CHAR_MASK; 5614 } 5615 --input_line_pointer; 5616 break; 5617 5618 case 'x': 5619 case 'X': 5620 { 5621 long number; 5622 5623 number = 0; 5624 c = *input_line_pointer++; 5625 while (ISXDIGIT (c)) 5626 { 5627 if (ISDIGIT (c)) 5628 number = number * 16 + c - '0'; 5629 else if (ISUPPER (c)) 5630 number = number * 16 + c - 'A' + 10; 5631 else 5632 number = number * 16 + c - 'a' + 10; 5633 c = *input_line_pointer++; 5634 } 5635 c = number & CHAR_MASK; 5636 --input_line_pointer; 5637 } 5638 break; 5639 5640 case '\n': 5641 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */ 5642 as_warn (_("unterminated string; newline inserted")); 5643 c = '\n'; 5644 bump_line_counters (); 5645 break; 5646 5647 case 0: 5648 /* Do not advance past the end of the buffer. */ 5649 -- input_line_pointer; 5650 c = NOT_A_CHAR; 5651 break; 5652 5653 default: 5654 5655#ifdef ONLY_STANDARD_ESCAPES 5656 as_bad (_("bad escaped character in string")); 5657 c = '?'; 5658#endif /* ONLY_STANDARD_ESCAPES */ 5659 5660 break; 5661 } 5662 break; 5663#endif /* ! defined (NO_STRING_ESCAPES) */ 5664 5665 default: 5666 break; 5667 } 5668 return (c); 5669} 5670 5671static segT 5672get_segmented_expression (expressionS *expP) 5673{ 5674 segT retval; 5675 5676 retval = expression (expP); 5677 if (expP->X_op == O_illegal 5678 || expP->X_op == O_absent 5679 || expP->X_op == O_big) 5680 { 5681 as_bad (_("expected address expression")); 5682 expP->X_op = O_constant; 5683 expP->X_add_number = 0; 5684 retval = absolute_section; 5685 } 5686 return retval; 5687} 5688 5689static segT 5690get_known_segmented_expression (expressionS *expP) 5691{ 5692 segT retval = get_segmented_expression (expP); 5693 5694 if (retval == undefined_section) 5695 { 5696 /* There is no easy way to extract the undefined symbol from the 5697 expression. */ 5698 if (expP->X_add_symbol != NULL 5699 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section) 5700 as_warn (_("symbol \"%s\" undefined; zero assumed"), 5701 S_GET_NAME (expP->X_add_symbol)); 5702 else 5703 as_warn (_("some symbol undefined; zero assumed")); 5704 retval = absolute_section; 5705 expP->X_op = O_constant; 5706 expP->X_add_number = 0; 5707 } 5708 return retval; 5709} 5710 5711char /* Return terminator. */ 5712get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */) 5713{ 5714 /* FIXME: val_pointer should probably be offsetT *. */ 5715 *val_pointer = (long) get_absolute_expression (); 5716 return (*input_line_pointer++); 5717} 5718 5719/* Like demand_copy_string, but return NULL if the string contains any '\0's. 5720 Give a warning if that happens. */ 5721 5722char * 5723demand_copy_C_string (int *len_pointer) 5724{ 5725 char *s; 5726 5727 if ((s = demand_copy_string (len_pointer)) != 0) 5728 { 5729 int len; 5730 5731 for (len = *len_pointer; len > 0; len--) 5732 { 5733 if (*s == 0) 5734 { 5735 s = 0; 5736 len = 1; 5737 *len_pointer = 0; 5738 as_bad (_("this string may not contain \'\\0\'")); 5739 } 5740 } 5741 } 5742 5743 return s; 5744} 5745 5746/* Demand string, but return a safe (=private) copy of the string. 5747 Return NULL if we can't read a string here. */ 5748 5749char * 5750demand_copy_string (int *lenP) 5751{ 5752 unsigned int c; 5753 int len; 5754 char *retval; 5755 5756 len = 0; 5757 SKIP_WHITESPACE (); 5758 if (*input_line_pointer == '\"') 5759 { 5760 input_line_pointer++; /* Skip opening quote. */ 5761 5762 while (is_a_char (c = next_char_of_string ())) 5763 { 5764 obstack_1grow (¬es, c); 5765 len++; 5766 } 5767 /* JF this next line is so demand_copy_C_string will return a 5768 null terminated string. */ 5769 obstack_1grow (¬es, '\0'); 5770 retval = (char *) obstack_finish (¬es); 5771 } 5772 else 5773 { 5774 as_bad (_("missing string")); 5775 retval = NULL; 5776 ignore_rest_of_line (); 5777 } 5778 *lenP = len; 5779 return (retval); 5780} 5781 5782/* In: Input_line_pointer->next character. 5783 5784 Do: Skip input_line_pointer over all whitespace. 5785 5786 Out: 1 if input_line_pointer->end-of-line. */ 5787 5788int 5789is_it_end_of_statement (void) 5790{ 5791 SKIP_WHITESPACE (); 5792 return (is_end_of_line[(unsigned char) *input_line_pointer]); 5793} 5794 5795void 5796equals (char *sym_name, int reassign) 5797{ 5798 char *stop = NULL; 5799 char stopc = 0; 5800 5801 input_line_pointer++; 5802 if (*input_line_pointer == '=') 5803 input_line_pointer++; 5804 if (reassign < 0 && *input_line_pointer == '=') 5805 input_line_pointer++; 5806 5807 while (*input_line_pointer == ' ' || *input_line_pointer == '\t') 5808 input_line_pointer++; 5809 5810 if (flag_mri) 5811 stop = mri_comment_field (&stopc); 5812 5813 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign); 5814 5815 if (flag_mri) 5816 { 5817 demand_empty_rest_of_line (); 5818 mri_comment_end (stop, stopc); 5819 } 5820} 5821 5822/* .incbin -- include a file verbatim at the current location. */ 5823 5824void 5825s_incbin (int x ATTRIBUTE_UNUSED) 5826{ 5827 FILE * binfile; 5828 char * path; 5829 char * filename; 5830 char * binfrag; 5831 long skip = 0; 5832 long count = 0; 5833 long bytes; 5834 int len; 5835 5836#ifdef md_flush_pending_output 5837 md_flush_pending_output (); 5838#endif 5839 5840#ifdef md_cons_align 5841 md_cons_align (1); 5842#endif 5843 5844 SKIP_WHITESPACE (); 5845 filename = demand_copy_string (& len); 5846 if (filename == NULL) 5847 return; 5848 5849 SKIP_WHITESPACE (); 5850 5851 /* Look for optional skip and count. */ 5852 if (* input_line_pointer == ',') 5853 { 5854 ++ input_line_pointer; 5855 skip = get_absolute_expression (); 5856 5857 SKIP_WHITESPACE (); 5858 5859 if (* input_line_pointer == ',') 5860 { 5861 ++ input_line_pointer; 5862 5863 count = get_absolute_expression (); 5864 if (count == 0) 5865 as_warn (_(".incbin count zero, ignoring `%s'"), filename); 5866 5867 SKIP_WHITESPACE (); 5868 } 5869 } 5870 5871 demand_empty_rest_of_line (); 5872 5873 /* Try opening absolute path first, then try include dirs. */ 5874 binfile = fopen (filename, FOPEN_RB); 5875 if (binfile == NULL) 5876 { 5877 int i; 5878 5879 path = XNEWVEC (char, (unsigned long) len + include_dir_maxlen + 5); 5880 5881 for (i = 0; i < include_dir_count; i++) 5882 { 5883 sprintf (path, "%s/%s", include_dirs[i], filename); 5884 5885 binfile = fopen (path, FOPEN_RB); 5886 if (binfile != NULL) 5887 break; 5888 } 5889 5890 if (binfile == NULL) 5891 as_bad (_("file not found: %s"), filename); 5892 } 5893 else 5894 path = xstrdup (filename); 5895 5896 if (binfile) 5897 { 5898 long file_len; 5899 5900 register_dependency (path); 5901 5902 /* Compute the length of the file. */ 5903 if (fseek (binfile, 0, SEEK_END) != 0) 5904 { 5905 as_bad (_("seek to end of .incbin file failed `%s'"), path); 5906 goto done; 5907 } 5908 file_len = ftell (binfile); 5909 5910 /* If a count was not specified use the remainder of the file. */ 5911 if (count == 0) 5912 count = file_len - skip; 5913 5914 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len) 5915 { 5916 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"), 5917 skip, count, file_len); 5918 goto done; 5919 } 5920 5921 if (fseek (binfile, skip, SEEK_SET) != 0) 5922 { 5923 as_bad (_("could not skip to %ld in file `%s'"), skip, path); 5924 goto done; 5925 } 5926 5927 /* Allocate frag space and store file contents in it. */ 5928 binfrag = frag_more (count); 5929 5930 bytes = fread (binfrag, 1, count, binfile); 5931 if (bytes < count) 5932 as_warn (_("truncated file `%s', %ld of %ld bytes read"), 5933 path, bytes, count); 5934 } 5935done: 5936 if (binfile != NULL) 5937 fclose (binfile); 5938 if (path) 5939 free (path); 5940} 5941 5942/* .include -- include a file at this point. */ 5943 5944void 5945s_include (int arg ATTRIBUTE_UNUSED) 5946{ 5947 char *filename; 5948 int i; 5949 FILE *try_file; 5950 char *path; 5951 5952 if (!flag_m68k_mri) 5953 { 5954 filename = demand_copy_string (&i); 5955 if (filename == NULL) 5956 { 5957 /* demand_copy_string has already printed an error and 5958 called ignore_rest_of_line. */ 5959 return; 5960 } 5961 } 5962 else 5963 { 5964 SKIP_WHITESPACE (); 5965 i = 0; 5966 while (!is_end_of_line[(unsigned char) *input_line_pointer] 5967 && *input_line_pointer != ' ' 5968 && *input_line_pointer != '\t') 5969 { 5970 obstack_1grow (¬es, *input_line_pointer); 5971 ++input_line_pointer; 5972 ++i; 5973 } 5974 5975 obstack_1grow (¬es, '\0'); 5976 filename = (char *) obstack_finish (¬es); 5977 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 5978 ++input_line_pointer; 5979 } 5980 5981 demand_empty_rest_of_line (); 5982 path = XNEWVEC (char, (unsigned long) i 5983 + include_dir_maxlen + 5 /* slop */ ); 5984 5985 for (i = 0; i < include_dir_count; i++) 5986 { 5987 strcpy (path, include_dirs[i]); 5988 strcat (path, "/"); 5989 strcat (path, filename); 5990 if (0 != (try_file = fopen (path, FOPEN_RT))) 5991 { 5992 fclose (try_file); 5993 goto gotit; 5994 } 5995 } 5996 5997 free (path); 5998 path = filename; 5999gotit: 6000 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */ 6001 register_dependency (path); 6002 input_scrub_insert_file (path); 6003} 6004 6005void 6006add_include_dir (char *path) 6007{ 6008 int i; 6009 6010 if (include_dir_count == 0) 6011 { 6012 include_dirs = XNEWVEC (const char *, 2); 6013 include_dirs[0] = "."; /* Current dir. */ 6014 include_dir_count = 2; 6015 } 6016 else 6017 { 6018 include_dir_count++; 6019 include_dirs = XRESIZEVEC (const char *, include_dirs, 6020 include_dir_count); 6021 } 6022 6023 include_dirs[include_dir_count - 1] = path; /* New one. */ 6024 6025 i = strlen (path); 6026 if (i > include_dir_maxlen) 6027 include_dir_maxlen = i; 6028} 6029 6030/* Output debugging information to denote the source file. */ 6031 6032static void 6033generate_file_debug (void) 6034{ 6035 if (debug_type == DEBUG_STABS) 6036 stabs_generate_asm_file (); 6037} 6038 6039/* Output line number debugging information for the current source line. */ 6040 6041void 6042generate_lineno_debug (void) 6043{ 6044 switch (debug_type) 6045 { 6046 case DEBUG_UNSPECIFIED: 6047 case DEBUG_NONE: 6048 case DEBUG_DWARF: 6049 break; 6050 case DEBUG_STABS: 6051 stabs_generate_asm_lineno (); 6052 break; 6053 case DEBUG_ECOFF: 6054 ecoff_generate_asm_lineno (); 6055 break; 6056 case DEBUG_DWARF2: 6057 /* ??? We could here indicate to dwarf2dbg.c that something 6058 has changed. However, since there is additional backend 6059 support that is required (calling dwarf2_emit_insn), we 6060 let dwarf2dbg.c call as_where on its own. */ 6061 break; 6062 } 6063} 6064 6065/* Output debugging information to mark a function entry point or end point. 6066 END_P is zero for .func, and non-zero for .endfunc. */ 6067 6068void 6069s_func (int end_p) 6070{ 6071 do_s_func (end_p, NULL); 6072} 6073 6074/* Subroutine of s_func so targets can choose a different default prefix. 6075 If DEFAULT_PREFIX is NULL, use the target's "leading char". */ 6076 6077static void 6078do_s_func (int end_p, const char *default_prefix) 6079{ 6080 /* Record the current function so that we can issue an error message for 6081 misplaced .func,.endfunc, and also so that .endfunc needs no 6082 arguments. */ 6083 static char *current_name; 6084 static char *current_label; 6085 6086 if (end_p) 6087 { 6088 if (current_name == NULL) 6089 { 6090 as_bad (_("missing .func")); 6091 ignore_rest_of_line (); 6092 return; 6093 } 6094 6095 if (debug_type == DEBUG_STABS) 6096 stabs_generate_asm_endfunc (current_name, current_label); 6097 6098 current_name = current_label = NULL; 6099 } 6100 else /* ! end_p */ 6101 { 6102 char *name, *label; 6103 char delim1, delim2; 6104 6105 if (current_name != NULL) 6106 { 6107 as_bad (_(".endfunc missing for previous .func")); 6108 ignore_rest_of_line (); 6109 return; 6110 } 6111 6112 delim1 = get_symbol_name (& name); 6113 name = xstrdup (name); 6114 *input_line_pointer = delim1; 6115 SKIP_WHITESPACE_AFTER_NAME (); 6116 if (*input_line_pointer != ',') 6117 { 6118 if (default_prefix) 6119 { 6120 if (asprintf (&label, "%s%s", default_prefix, name) == -1) 6121 as_fatal ("%s", xstrerror (errno)); 6122 } 6123 else 6124 { 6125 char leading_char = bfd_get_symbol_leading_char (stdoutput); 6126 /* Missing entry point, use function's name with the leading 6127 char prepended. */ 6128 if (leading_char) 6129 { 6130 if (asprintf (&label, "%c%s", leading_char, name) == -1) 6131 as_fatal ("%s", xstrerror (errno)); 6132 } 6133 else 6134 label = name; 6135 } 6136 } 6137 else 6138 { 6139 ++input_line_pointer; 6140 SKIP_WHITESPACE (); 6141 delim2 = get_symbol_name (& label); 6142 label = xstrdup (label); 6143 restore_line_pointer (delim2); 6144 } 6145 6146 if (debug_type == DEBUG_STABS) 6147 stabs_generate_asm_func (name, label); 6148 6149 current_name = name; 6150 current_label = label; 6151 } 6152 6153 demand_empty_rest_of_line (); 6154} 6155 6156#ifdef HANDLE_BUNDLE 6157 6158void 6159s_bundle_align_mode (int arg ATTRIBUTE_UNUSED) 6160{ 6161 unsigned int align = get_absolute_expression (); 6162 SKIP_WHITESPACE (); 6163 demand_empty_rest_of_line (); 6164 6165 if (align > (unsigned int) TC_ALIGN_LIMIT) 6166 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"), 6167 (unsigned int) TC_ALIGN_LIMIT); 6168 6169 if (bundle_lock_frag != NULL) 6170 { 6171 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock")); 6172 return; 6173 } 6174 6175 bundle_align_p2 = align; 6176} 6177 6178void 6179s_bundle_lock (int arg ATTRIBUTE_UNUSED) 6180{ 6181 demand_empty_rest_of_line (); 6182 6183 if (bundle_align_p2 == 0) 6184 { 6185 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode")); 6186 return; 6187 } 6188 6189 if (bundle_lock_depth == 0) 6190 { 6191 bundle_lock_frchain = frchain_now; 6192 bundle_lock_frag = start_bundle (); 6193 } 6194 ++bundle_lock_depth; 6195} 6196 6197void 6198s_bundle_unlock (int arg ATTRIBUTE_UNUSED) 6199{ 6200 unsigned int size; 6201 6202 demand_empty_rest_of_line (); 6203 6204 if (bundle_lock_frag == NULL) 6205 { 6206 as_bad (_(".bundle_unlock without preceding .bundle_lock")); 6207 return; 6208 } 6209 6210 gas_assert (bundle_align_p2 > 0); 6211 6212 gas_assert (bundle_lock_depth > 0); 6213 if (--bundle_lock_depth > 0) 6214 return; 6215 6216 size = pending_bundle_size (bundle_lock_frag); 6217 6218 if (size > (1U << bundle_align_p2)) 6219 as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"), 6220 size, 1 << bundle_align_p2); 6221 else 6222 finish_bundle (bundle_lock_frag, size); 6223 6224 bundle_lock_frag = NULL; 6225 bundle_lock_frchain = NULL; 6226} 6227 6228#endif /* HANDLE_BUNDLE */ 6229 6230void 6231s_ignore (int arg ATTRIBUTE_UNUSED) 6232{ 6233 ignore_rest_of_line (); 6234} 6235 6236void 6237read_print_statistics (FILE *file) 6238{ 6239 hash_print_statistics (file, "pseudo-op table", po_hash); 6240} 6241 6242/* Inserts the given line into the input stream. 6243 6244 This call avoids macro/conditionals nesting checking, since the contents of 6245 the line are assumed to replace the contents of a line already scanned. 6246 6247 An appropriate use of this function would be substitution of input lines when 6248 called by md_start_line_hook(). The given line is assumed to already be 6249 properly scrubbed. */ 6250 6251void 6252input_scrub_insert_line (const char *line) 6253{ 6254 sb newline; 6255 size_t len = strlen (line); 6256 sb_build (&newline, len); 6257 sb_add_buffer (&newline, line, len); 6258 input_scrub_include_sb (&newline, input_line_pointer, 0); 6259 sb_kill (&newline); 6260 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 6261} 6262 6263/* Insert a file into the input stream; the path must resolve to an actual 6264 file; no include path searching or dependency registering is performed. */ 6265 6266void 6267input_scrub_insert_file (char *path) 6268{ 6269 input_scrub_include_file (path, input_line_pointer); 6270 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 6271} 6272 6273/* Find the end of a line, considering quotation and escaping of quotes. */ 6274 6275#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS) 6276# define TC_SINGLE_QUOTE_STRINGS 1 6277#endif 6278 6279static char * 6280_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED, 6281 int in_macro) 6282{ 6283 char inquote = '\0'; 6284 int inescape = 0; 6285 6286 while (!is_end_of_line[(unsigned char) *s] 6287 || (inquote && !ISCNTRL (*s)) 6288 || (inquote == '\'' && flag_mri) 6289#ifdef TC_EOL_IN_INSN 6290 || (insn && TC_EOL_IN_INSN (s)) 6291#endif 6292 /* PR 6926: When we are parsing the body of a macro the sequence 6293 \@ is special - it refers to the invocation count. If the @ 6294 character happens to be registered as a line-separator character 6295 by the target, then the is_end_of_line[] test above will have 6296 returned true, but we need to ignore the line separating 6297 semantics in this particular case. */ 6298 || (in_macro && inescape && *s == '@') 6299 ) 6300 { 6301 if (mri_string && *s == '\'') 6302 inquote ^= *s; 6303 else if (inescape) 6304 inescape = 0; 6305 else if (*s == '\\') 6306 inescape = 1; 6307 else if (!inquote 6308 ? *s == '"' 6309#ifdef TC_SINGLE_QUOTE_STRINGS 6310 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'') 6311#endif 6312 : *s == inquote) 6313 inquote ^= *s; 6314 ++s; 6315 } 6316 if (inquote) 6317 as_warn (_("missing closing `%c'"), inquote); 6318 if (inescape && !ignore_input ()) 6319 as_warn (_("stray `\\'")); 6320 return s; 6321} 6322 6323char * 6324find_end_of_line (char *s, int mri_string) 6325{ 6326 return _find_end_of_line (s, mri_string, 0, 0); 6327} 6328