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