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