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