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