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