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 know (nbytes % CHARS_PER_LITTLENUM == 0); 3553 3554 size = exp->X_add_number * CHARS_PER_LITTLENUM; 3555 if (nbytes < size) 3556 { 3557 as_warn (_("bignum truncated to %d bytes"), nbytes); 3558 size = nbytes; 3559 } 3560 3561 if (target_big_endian) 3562 { 3563 while (nbytes > size) 3564 { 3565 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3566 nbytes -= CHARS_PER_LITTLENUM; 3567 p += CHARS_PER_LITTLENUM; 3568 } 3569 3570 nums = generic_bignum + size / CHARS_PER_LITTLENUM; 3571 while (size >= CHARS_PER_LITTLENUM) 3572 { 3573 --nums; 3574 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3575 size -= CHARS_PER_LITTLENUM; 3576 p += CHARS_PER_LITTLENUM; 3577 } 3578 } 3579 else 3580 { 3581 nums = generic_bignum; 3582 while (size >= CHARS_PER_LITTLENUM) 3583 { 3584 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3585 ++nums; 3586 size -= CHARS_PER_LITTLENUM; 3587 p += CHARS_PER_LITTLENUM; 3588 nbytes -= CHARS_PER_LITTLENUM; 3589 } 3590 3591 while (nbytes >= CHARS_PER_LITTLENUM) 3592 { 3593 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3594 nbytes -= CHARS_PER_LITTLENUM; 3595 p += CHARS_PER_LITTLENUM; 3596 } 3597 } 3598 } 3599 else 3600 { 3601 memset (p, 0, nbytes); 3602 3603 /* Now we need to generate a fixS to record the symbol value. 3604 This is easy for BFD. For other targets it can be more 3605 complex. For very complex cases (currently, the HPPA and 3606 NS32K), you can define TC_CONS_FIX_NEW to do whatever you 3607 want. For simpler cases, you can define TC_CONS_RELOC to be 3608 the name of the reloc code that should be stored in the fixS. 3609 If neither is defined, the code uses NO_RELOC if it is 3610 defined, and otherwise uses 0. */ 3611 3612 #ifdef BFD_ASSEMBLER 3613 #ifdef TC_CONS_FIX_NEW 3614 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); 3615 #else 3616 { 3617 bfd_reloc_code_real_type r; 3618 3619 switch (nbytes) 3620 { 3621 case 1: 3622 r = BFD_RELOC_8; 3623 break; 3624 case 2: 3625 r = BFD_RELOC_16; 3626 break; 3627 case 4: 3628 r = BFD_RELOC_32; 3629 break; 3630 case 8: 3631 r = BFD_RELOC_64; 3632 break; 3633 default: 3634 as_bad (_("unsupported BFD relocation size %u"), nbytes); 3635 r = BFD_RELOC_32; 3636 break; 3637 } 3638 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 3639 0, r); 3640 } 3641 #endif 3642 #else 3643 #ifdef TC_CONS_FIX_NEW 3644 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); 3645 #else 3646 /* Figure out which reloc number to use. Use TC_CONS_RELOC if 3647 it is defined, otherwise use NO_RELOC if it is defined, 3648 otherwise use 0. */ 3649 #ifndef TC_CONS_RELOC 3650 #ifdef NO_RELOC 3651 #define TC_CONS_RELOC NO_RELOC 3652 #else 3653 #define TC_CONS_RELOC 0 3654 #endif 3655 #endif 3656 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0, 3657 TC_CONS_RELOC); 3658 #endif /* TC_CONS_FIX_NEW */ 3659 #endif /* BFD_ASSEMBLER */ 3660 } 3661 } 3662 3663 #ifdef BITFIELD_CONS_EXPRESSIONS 3664 3665 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as 3666 w:x,y:z, where w and y are bitwidths and x and y are values. They 3667 then pack them all together. We do a little better in that we allow 3668 them in words, longs, etc. and we'll pack them in target byte order 3669 for you. 3670 3671 The rules are: pack least significant bit first, if a field doesn't 3672 entirely fit, put it in the next unit. Overflowing the bitfield is 3673 explicitly *not* even a warning. The bitwidth should be considered 3674 a "mask". 3675 3676 To use this function the tc-XXX.h file should define 3677 BITFIELD_CONS_EXPRESSIONS. */ 3678 3679 static void 3680 parse_bitfield_cons (exp, nbytes) 3681 expressionS *exp; 3682 unsigned int nbytes; 3683 { 3684 unsigned int bits_available = BITS_PER_CHAR * nbytes; 3685 char *hold = input_line_pointer; 3686 3687 (void) expression (exp); 3688 3689 if (*input_line_pointer == ':') 3690 { 3691 /* Bitfields. */ 3692 long value = 0; 3693 3694 for (;;) 3695 { 3696 unsigned long width; 3697 3698 if (*input_line_pointer != ':') 3699 { 3700 input_line_pointer = hold; 3701 break; 3702 } /* Next piece is not a bitfield. */ 3703 3704 /* In the general case, we can't allow 3705 full expressions with symbol 3706 differences and such. The relocation 3707 entries for symbols not defined in this 3708 assembly would require arbitrary field 3709 widths, positions, and masks which most 3710 of our current object formats don't 3711 support. 3712 3713 In the specific case where a symbol 3714 *is* defined in this assembly, we 3715 *could* build fixups and track it, but 3716 this could lead to confusion for the 3717 backends. I'm lazy. I'll take any 3718 SEG_ABSOLUTE. I think that means that 3719 you can use a previous .set or 3720 .equ type symbol. xoxorich. */ 3721 3722 if (exp->X_op == O_absent) 3723 { 3724 as_warn (_("using a bit field width of zero")); 3725 exp->X_add_number = 0; 3726 exp->X_op = O_constant; 3727 } /* Implied zero width bitfield. */ 3728 3729 if (exp->X_op != O_constant) 3730 { 3731 *input_line_pointer = '\0'; 3732 as_bad (_("field width \"%s\" too complex for a bitfield"), hold); 3733 *input_line_pointer = ':'; 3734 demand_empty_rest_of_line (); 3735 return; 3736 } /* Too complex. */ 3737 3738 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) 3739 { 3740 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"), 3741 width, nbytes, (BITS_PER_CHAR * nbytes)); 3742 width = BITS_PER_CHAR * nbytes; 3743 } /* Too big. */ 3744 3745 if (width > bits_available) 3746 { 3747 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */ 3748 input_line_pointer = hold; 3749 exp->X_add_number = value; 3750 break; 3751 } /* Won't fit. */ 3752 3753 /* Skip ':'. */ 3754 hold = ++input_line_pointer; 3755 3756 (void) expression (exp); 3757 if (exp->X_op != O_constant) 3758 { 3759 char cache = *input_line_pointer; 3760 3761 *input_line_pointer = '\0'; 3762 as_bad (_("field value \"%s\" too complex for a bitfield"), hold); 3763 *input_line_pointer = cache; 3764 demand_empty_rest_of_line (); 3765 return; 3766 } /* Too complex. */ 3767 3768 value |= ((~(-1 << width) & exp->X_add_number) 3769 << ((BITS_PER_CHAR * nbytes) - bits_available)); 3770 3771 if ((bits_available -= width) == 0 3772 || is_it_end_of_statement () 3773 || *input_line_pointer != ',') 3774 { 3775 break; 3776 } /* All the bitfields we're gonna get. */ 3777 3778 hold = ++input_line_pointer; 3779 (void) expression (exp); 3780 } 3781 3782 exp->X_add_number = value; 3783 exp->X_op = O_constant; 3784 exp->X_unsigned = 1; 3785 } 3786 } 3787 3788 #endif /* BITFIELD_CONS_EXPRESSIONS */ 3789 3790 /* Handle an MRI style string expression. */ 3791 3792 #ifdef TC_M68K 3793 static void 3794 parse_mri_cons (exp, nbytes) 3795 expressionS *exp; 3796 unsigned int nbytes; 3797 { 3798 if (*input_line_pointer != '\'' 3799 && (input_line_pointer[1] != '\'' 3800 || (*input_line_pointer != 'A' 3801 && *input_line_pointer != 'E'))) 3802 TC_PARSE_CONS_EXPRESSION (exp, nbytes); 3803 else 3804 { 3805 unsigned int scan; 3806 unsigned int result = 0; 3807 3808 /* An MRI style string. Cut into as many bytes as will fit into 3809 a nbyte chunk, left justify if necessary, and separate with 3810 commas so we can try again later. */ 3811 if (*input_line_pointer == 'A') 3812 ++input_line_pointer; 3813 else if (*input_line_pointer == 'E') 3814 { 3815 as_bad (_("EBCDIC constants are not supported")); 3816 ++input_line_pointer; 3817 } 3818 3819 input_line_pointer++; 3820 for (scan = 0; scan < nbytes; scan++) 3821 { 3822 if (*input_line_pointer == '\'') 3823 { 3824 if (input_line_pointer[1] == '\'') 3825 { 3826 input_line_pointer++; 3827 } 3828 else 3829 break; 3830 } 3831 result = (result << 8) | (*input_line_pointer++); 3832 } 3833 3834 /* Left justify. */ 3835 while (scan < nbytes) 3836 { 3837 result <<= 8; 3838 scan++; 3839 } 3840 3841 /* Create correct expression. */ 3842 exp->X_op = O_constant; 3843 exp->X_add_number = result; 3844 3845 /* Fake it so that we can read the next char too. */ 3846 if (input_line_pointer[0] != '\'' || 3847 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\'')) 3848 { 3849 input_line_pointer -= 2; 3850 input_line_pointer[0] = ','; 3851 input_line_pointer[1] = '\''; 3852 } 3853 else 3854 input_line_pointer++; 3855 } 3856 } 3857 #endif /* TC_M68K */ 3858 3859 #ifdef REPEAT_CONS_EXPRESSIONS 3860 3861 /* Parse a repeat expression for cons. This is used by the MIPS 3862 assembler. The format is NUMBER:COUNT; NUMBER appears in the 3863 object file COUNT times. 3864 3865 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */ 3866 3867 static void 3868 parse_repeat_cons (exp, nbytes) 3869 expressionS *exp; 3870 unsigned int nbytes; 3871 { 3872 expressionS count; 3873 register int i; 3874 3875 expression (exp); 3876 3877 if (*input_line_pointer != ':') 3878 { 3879 /* No repeat count. */ 3880 return; 3881 } 3882 3883 ++input_line_pointer; 3884 expression (&count); 3885 if (count.X_op != O_constant 3886 || count.X_add_number <= 0) 3887 { 3888 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 3889 return; 3890 } 3891 3892 /* The cons function is going to output this expression once. So we 3893 output it count - 1 times. */ 3894 for (i = count.X_add_number - 1; i > 0; i--) 3895 emit_expr (exp, nbytes); 3896 } 3897 3898 #endif /* REPEAT_CONS_EXPRESSIONS */ 3899 3900 /* Parse a floating point number represented as a hex constant. This 3901 permits users to specify the exact bits they want in the floating 3902 point number. */ 3903 3904 static int 3905 hex_float (int float_type, char *bytes) 3906 { 3907 int length; 3908 int i; 3909 3910 switch (float_type) 3911 { 3912 case 'f': 3913 case 'F': 3914 case 's': 3915 case 'S': 3916 length = 4; 3917 break; 3918 3919 case 'd': 3920 case 'D': 3921 case 'r': 3922 case 'R': 3923 length = 8; 3924 break; 3925 3926 case 'x': 3927 case 'X': 3928 length = 12; 3929 break; 3930 3931 case 'p': 3932 case 'P': 3933 length = 12; 3934 break; 3935 3936 default: 3937 as_bad (_("unknown floating type type '%c'"), float_type); 3938 return -1; 3939 } 3940 3941 /* It would be nice if we could go through expression to parse the 3942 hex constant, but if we get a bignum it's a pain to sort it into 3943 the buffer correctly. */ 3944 i = 0; 3945 while (hex_p (*input_line_pointer) || *input_line_pointer == '_') 3946 { 3947 int d; 3948 3949 /* The MRI assembler accepts arbitrary underscores strewn about 3950 through the hex constant, so we ignore them as well. */ 3951 if (*input_line_pointer == '_') 3952 { 3953 ++input_line_pointer; 3954 continue; 3955 } 3956 3957 if (i >= length) 3958 { 3959 as_warn (_("floating point constant too large")); 3960 return -1; 3961 } 3962 d = hex_value (*input_line_pointer) << 4; 3963 ++input_line_pointer; 3964 while (*input_line_pointer == '_') 3965 ++input_line_pointer; 3966 if (hex_p (*input_line_pointer)) 3967 { 3968 d += hex_value (*input_line_pointer); 3969 ++input_line_pointer; 3970 } 3971 if (target_big_endian) 3972 bytes[i] = d; 3973 else 3974 bytes[length - i - 1] = d; 3975 ++i; 3976 } 3977 3978 if (i < length) 3979 { 3980 if (target_big_endian) 3981 memset (bytes + i, 0, length - i); 3982 else 3983 memset (bytes, 0, length - i); 3984 } 3985 3986 return length; 3987 } 3988 3989 /* float_cons() 3990 3991 CONStruct some more frag chars of .floats .ffloats etc. 3992 Makes 0 or more new frags. 3993 If need_pass_2 == 1, no frags are emitted. 3994 This understands only floating literals, not expressions. Sorry. 3995 3996 A floating constant is defined by atof_generic(), except it is preceded 3997 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its 3998 reading, I decided to be incompatible. This always tries to give you 3999 rounded bits to the precision of the pseudo-op. Former AS did premature 4000 truncation, restored noisy bits instead of trailing 0s AND gave you 4001 a choice of 2 flavours of noise according to which of 2 floating-point 4002 scanners you directed AS to use. 4003 4004 In: input_line_pointer->whitespace before, or '0' of flonum. */ 4005 4006 void 4007 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ 4008 register int float_type /* 'f':.ffloat ... 'F':.float ... */) 4009 { 4010 register char *p; 4011 int length; /* Number of chars in an object. */ 4012 register char *err; /* Error from scanning floating literal. */ 4013 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 4014 4015 if (is_it_end_of_statement ()) 4016 { 4017 demand_empty_rest_of_line (); 4018 return; 4019 } 4020 4021 #ifdef md_flush_pending_output 4022 md_flush_pending_output (); 4023 #endif 4024 4025 do 4026 { 4027 /* input_line_pointer->1st char of a flonum (we hope!). */ 4028 SKIP_WHITESPACE (); 4029 4030 /* Skip any 0{letter} that may be present. Don't even check if the 4031 letter is legal. Someone may invent a "z" format and this routine 4032 has no use for such information. Lusers beware: you get 4033 diagnostics if your input is ill-conditioned. */ 4034 if (input_line_pointer[0] == '0' 4035 && ISALPHA (input_line_pointer[1])) 4036 input_line_pointer += 2; 4037 4038 /* Accept :xxxx, where the x's are hex digits, for a floating 4039 point with the exact digits specified. */ 4040 if (input_line_pointer[0] == ':') 4041 { 4042 ++input_line_pointer; 4043 length = hex_float (float_type, temp); 4044 if (length < 0) 4045 { 4046 ignore_rest_of_line (); 4047 return; 4048 } 4049 } 4050 else 4051 { 4052 err = md_atof (float_type, temp, &length); 4053 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 4054 know (length > 0); 4055 if (err) 4056 { 4057 as_bad (_("bad floating literal: %s"), err); 4058 ignore_rest_of_line (); 4059 return; 4060 } 4061 } 4062 4063 if (!need_pass_2) 4064 { 4065 int count; 4066 4067 count = 1; 4068 4069 #ifdef REPEAT_CONS_EXPRESSIONS 4070 if (*input_line_pointer == ':') 4071 { 4072 expressionS count_exp; 4073 4074 ++input_line_pointer; 4075 expression (&count_exp); 4076 4077 if (count_exp.X_op != O_constant 4078 || count_exp.X_add_number <= 0) 4079 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 4080 else 4081 count = count_exp.X_add_number; 4082 } 4083 #endif 4084 4085 while (--count >= 0) 4086 { 4087 p = frag_more (length); 4088 memcpy (p, temp, (unsigned int) length); 4089 } 4090 } 4091 SKIP_WHITESPACE (); 4092 } 4093 while (*input_line_pointer++ == ','); 4094 4095 /* Put terminator back into stream. */ 4096 --input_line_pointer; 4097 demand_empty_rest_of_line (); 4098 } 4099 4100 /* Return the size of a LEB128 value. */ 4101 4102 static inline int 4103 sizeof_sleb128 (offsetT value) 4104 { 4105 register int size = 0; 4106 register unsigned byte; 4107 4108 do 4109 { 4110 byte = (value & 0x7f); 4111 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4112 Fortunately, we can structure things so that the extra work reduces 4113 to a noop on systems that do things "properly". */ 4114 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4115 size += 1; 4116 } 4117 while (!(((value == 0) && ((byte & 0x40) == 0)) 4118 || ((value == -1) && ((byte & 0x40) != 0)))); 4119 4120 return size; 4121 } 4122 4123 static inline int 4124 sizeof_uleb128 (valueT value) 4125 { 4126 register int size = 0; 4127 register unsigned byte; 4128 4129 do 4130 { 4131 byte = (value & 0x7f); 4132 value >>= 7; 4133 size += 1; 4134 } 4135 while (value != 0); 4136 4137 return size; 4138 } 4139 4140 int 4141 sizeof_leb128 (valueT value, int sign) 4142 { 4143 if (sign) 4144 return sizeof_sleb128 ((offsetT) value); 4145 else 4146 return sizeof_uleb128 (value); 4147 } 4148 4149 /* Output a LEB128 value. */ 4150 4151 static inline int 4152 output_sleb128 (char *p, offsetT value) 4153 { 4154 register char *orig = p; 4155 register int more; 4156 4157 do 4158 { 4159 unsigned byte = (value & 0x7f); 4160 4161 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4162 Fortunately, we can structure things so that the extra work reduces 4163 to a noop on systems that do things "properly". */ 4164 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4165 4166 more = !((((value == 0) && ((byte & 0x40) == 0)) 4167 || ((value == -1) && ((byte & 0x40) != 0)))); 4168 if (more) 4169 byte |= 0x80; 4170 4171 *p++ = byte; 4172 } 4173 while (more); 4174 4175 return p - orig; 4176 } 4177 4178 static inline int 4179 output_uleb128 (char *p, valueT value) 4180 { 4181 char *orig = p; 4182 4183 do 4184 { 4185 unsigned byte = (value & 0x7f); 4186 value >>= 7; 4187 if (value != 0) 4188 /* More bytes to follow. */ 4189 byte |= 0x80; 4190 4191 *p++ = byte; 4192 } 4193 while (value != 0); 4194 4195 return p - orig; 4196 } 4197 4198 int 4199 output_leb128 (char *p, valueT value, int sign) 4200 { 4201 if (sign) 4202 return output_sleb128 (p, (offsetT) value); 4203 else 4204 return output_uleb128 (p, value); 4205 } 4206 4207 /* Do the same for bignums. We combine sizeof with output here in that 4208 we don't output for NULL values of P. It isn't really as critical as 4209 for "normal" values that this be streamlined. */ 4210 4211 static inline int 4212 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size) 4213 { 4214 char *orig = p; 4215 valueT val = 0; 4216 int loaded = 0; 4217 unsigned byte; 4218 4219 /* Strip leading sign extensions off the bignum. */ 4220 while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1) 4221 size--; 4222 4223 do 4224 { 4225 if (loaded < 7 && size > 0) 4226 { 4227 val |= (*bignum << loaded); 4228 loaded += 8 * CHARS_PER_LITTLENUM; 4229 size--; 4230 bignum++; 4231 } 4232 4233 byte = val & 0x7f; 4234 loaded -= 7; 4235 val >>= 7; 4236 4237 if (size == 0) 4238 { 4239 if ((val == 0 && (byte & 0x40) == 0) 4240 || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0 4241 && (byte & 0x40) != 0)) 4242 byte |= 0x80; 4243 } 4244 4245 if (orig) 4246 *p = byte; 4247 p++; 4248 } 4249 while (byte & 0x80); 4250 4251 return p - orig; 4252 } 4253 4254 static inline int 4255 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size) 4256 { 4257 char *orig = p; 4258 valueT val = 0; 4259 int loaded = 0; 4260 unsigned byte; 4261 4262 /* Strip leading zeros off the bignum. */ 4263 /* XXX: Is this needed? */ 4264 while (size > 0 && bignum[size - 1] == 0) 4265 size--; 4266 4267 do 4268 { 4269 if (loaded < 7 && size > 0) 4270 { 4271 val |= (*bignum << loaded); 4272 loaded += 8 * CHARS_PER_LITTLENUM; 4273 size--; 4274 bignum++; 4275 } 4276 4277 byte = val & 0x7f; 4278 loaded -= 7; 4279 val >>= 7; 4280 4281 if (size > 0 || val) 4282 byte |= 0x80; 4283 4284 if (orig) 4285 *p = byte; 4286 p++; 4287 } 4288 while (byte & 0x80); 4289 4290 return p - orig; 4291 } 4292 4293 static int 4294 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign) 4295 { 4296 if (sign) 4297 return output_big_sleb128 (p, bignum, size); 4298 else 4299 return output_big_uleb128 (p, bignum, size); 4300 } 4301 4302 /* Generate the appropriate fragments for a given expression to emit a 4303 leb128 value. */ 4304 4305 void 4306 emit_leb128_expr (expressionS *exp, int sign) 4307 { 4308 operatorT op = exp->X_op; 4309 int nbytes; 4310 4311 if (op == O_absent || op == O_illegal) 4312 { 4313 as_warn (_("zero assumed for missing expression")); 4314 exp->X_add_number = 0; 4315 op = O_constant; 4316 } 4317 else if (op == O_big && exp->X_add_number <= 0) 4318 { 4319 as_bad (_("floating point number invalid")); 4320 exp->X_add_number = 0; 4321 op = O_constant; 4322 } 4323 else if (op == O_register) 4324 { 4325 as_warn (_("register value used as expression")); 4326 op = O_constant; 4327 } 4328 4329 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is 4330 a signal that this is leb128 data. It shouldn't optimize this away. */ 4331 nbytes = -1; 4332 if (check_eh_frame (exp, &nbytes)) 4333 abort (); 4334 4335 /* Let the backend know that subsequent data may be byte aligned. */ 4336 #ifdef md_cons_align 4337 md_cons_align (1); 4338 #endif 4339 4340 if (op == O_constant) 4341 { 4342 /* If we've got a constant, emit the thing directly right now. */ 4343 4344 valueT value = exp->X_add_number; 4345 int size; 4346 char *p; 4347 4348 size = sizeof_leb128 (value, sign); 4349 p = frag_more (size); 4350 output_leb128 (p, value, sign); 4351 } 4352 else if (op == O_big) 4353 { 4354 /* O_big is a different sort of constant. */ 4355 4356 int size; 4357 char *p; 4358 4359 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); 4360 p = frag_more (size); 4361 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign); 4362 } 4363 else 4364 { 4365 /* Otherwise, we have to create a variable sized fragment and 4366 resolve things later. */ 4367 4368 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign, 4369 make_expr_symbol (exp), 0, (char *) NULL); 4370 } 4371 } 4372 4373 /* Parse the .sleb128 and .uleb128 pseudos. */ 4374 4375 void 4376 s_leb128 (int sign) 4377 { 4378 expressionS exp; 4379 4380 #ifdef md_flush_pending_output 4381 md_flush_pending_output (); 4382 #endif 4383 4384 #ifdef md_flush_pending_output 4385 md_flush_pending_output (); 4386 #endif 4387 4388 do 4389 { 4390 expression (&exp); 4391 emit_leb128_expr (&exp, sign); 4392 } 4393 while (*input_line_pointer++ == ','); 4394 4395 input_line_pointer--; 4396 demand_empty_rest_of_line (); 4397 } 4398 4399 /* We read 0 or more ',' separated, double-quoted strings. 4400 Caller should have checked need_pass_2 is FALSE because we don't 4401 check it. */ 4402 4403 void 4404 stringer (/* Worker to do .ascii etc statements. */ 4405 /* Checks end-of-line. */ 4406 register int append_zero /* 0: don't append '\0', else 1. */) 4407 { 4408 register unsigned int c; 4409 char *start; 4410 4411 #ifdef md_flush_pending_output 4412 md_flush_pending_output (); 4413 #endif 4414 4415 /* The following awkward logic is to parse ZERO or more strings, 4416 comma separated. Recall a string expression includes spaces 4417 before the opening '\"' and spaces after the closing '\"'. 4418 We fake a leading ',' if there is (supposed to be) 4419 a 1st, expression. We keep demanding expressions for each ','. */ 4420 if (is_it_end_of_statement ()) 4421 { 4422 c = 0; /* Skip loop. */ 4423 ++input_line_pointer; /* Compensate for end of loop. */ 4424 } 4425 else 4426 { 4427 c = ','; /* Do loop. */ 4428 } 4429 /* If we have been switched into the abs_section then we 4430 will not have an obstack onto which we can hang strings. */ 4431 if (now_seg == absolute_section) 4432 { 4433 as_bad (_("strings must be placed into a section")); 4434 c = 0; 4435 ignore_rest_of_line (); 4436 } 4437 4438 while (c == ',' || c == '<' || c == '"') 4439 { 4440 SKIP_WHITESPACE (); 4441 switch (*input_line_pointer) 4442 { 4443 case '\"': 4444 ++input_line_pointer; /*->1st char of string. */ 4445 start = input_line_pointer; 4446 while (is_a_char (c = next_char_of_string ())) 4447 { 4448 FRAG_APPEND_1_CHAR (c); 4449 } 4450 if (append_zero) 4451 { 4452 FRAG_APPEND_1_CHAR (0); 4453 } 4454 know (input_line_pointer[-1] == '\"'); 4455 4456 #ifndef NO_LISTING 4457 #ifdef OBJ_ELF 4458 /* In ELF, when gcc is emitting DWARF 1 debugging output, it 4459 will emit .string with a filename in the .debug section 4460 after a sequence of constants. See the comment in 4461 emit_expr for the sequence. emit_expr will set 4462 dwarf_file_string to non-zero if this string might be a 4463 source file name. */ 4464 if (strcmp (segment_name (now_seg), ".debug") != 0) 4465 dwarf_file_string = 0; 4466 else if (dwarf_file_string) 4467 { 4468 c = input_line_pointer[-1]; 4469 input_line_pointer[-1] = '\0'; 4470 listing_source_file (start); 4471 input_line_pointer[-1] = c; 4472 } 4473 #endif 4474 #endif 4475 4476 break; 4477 case '<': 4478 input_line_pointer++; 4479 c = get_single_number (); 4480 FRAG_APPEND_1_CHAR (c); 4481 if (*input_line_pointer != '>') 4482 { 4483 as_bad (_("expected <nn>")); 4484 } 4485 input_line_pointer++; 4486 break; 4487 case ',': 4488 input_line_pointer++; 4489 break; 4490 } 4491 SKIP_WHITESPACE (); 4492 c = *input_line_pointer; 4493 } 4494 4495 demand_empty_rest_of_line (); 4496 } /* stringer() */ 4497 4498 /* FIXME-SOMEDAY: I had trouble here on characters with the 4499 high bits set. We'll probably also have trouble with 4500 multibyte chars, wide chars, etc. Also be careful about 4501 returning values bigger than 1 byte. xoxorich. */ 4502 4503 unsigned int 4504 next_char_of_string (void) 4505 { 4506 register unsigned int c; 4507 4508 c = *input_line_pointer++ & CHAR_MASK; 4509 switch (c) 4510 { 4511 case '\"': 4512 c = NOT_A_CHAR; 4513 break; 4514 4515 case '\n': 4516 as_warn (_("unterminated string; newline inserted")); 4517 bump_line_counters (); 4518 break; 4519 4520 #ifndef NO_STRING_ESCAPES 4521 case '\\': 4522 switch (c = *input_line_pointer++) 4523 { 4524 case 'b': 4525 c = '\b'; 4526 break; 4527 4528 case 'f': 4529 c = '\f'; 4530 break; 4531 4532 case 'n': 4533 c = '\n'; 4534 break; 4535 4536 case 'r': 4537 c = '\r'; 4538 break; 4539 4540 case 't': 4541 c = '\t'; 4542 break; 4543 4544 case 'v': 4545 c = '\013'; 4546 break; 4547 4548 case '\\': 4549 case '"': 4550 break; /* As itself. */ 4551 4552 case '0': 4553 case '1': 4554 case '2': 4555 case '3': 4556 case '4': 4557 case '5': 4558 case '6': 4559 case '7': 4560 case '8': 4561 case '9': 4562 { 4563 long number; 4564 int i; 4565 4566 for (i = 0, number = 0; 4567 i < 3 && ISDIGIT (c); 4568 c = *input_line_pointer++, i++) 4569 { 4570 number = number * 8 + c - '0'; 4571 } 4572 4573 c = number & 0xff; 4574 } 4575 --input_line_pointer; 4576 break; 4577 4578 case 'x': 4579 case 'X': 4580 { 4581 long number; 4582 4583 number = 0; 4584 c = *input_line_pointer++; 4585 while (ISXDIGIT (c)) 4586 { 4587 if (ISDIGIT (c)) 4588 number = number * 16 + c - '0'; 4589 else if (ISUPPER (c)) 4590 number = number * 16 + c - 'A' + 10; 4591 else 4592 number = number * 16 + c - 'a' + 10; 4593 c = *input_line_pointer++; 4594 } 4595 c = number & 0xff; 4596 --input_line_pointer; 4597 } 4598 break; 4599 4600 case '\n': 4601 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */ 4602 as_warn (_("unterminated string; newline inserted")); 4603 c = '\n'; 4604 bump_line_counters (); 4605 break; 4606 4607 default: 4608 4609 #ifdef ONLY_STANDARD_ESCAPES 4610 as_bad (_("bad escaped character in string")); 4611 c = '?'; 4612 #endif /* ONLY_STANDARD_ESCAPES */ 4613 4614 break; 4615 } 4616 break; 4617 #endif /* ! defined (NO_STRING_ESCAPES) */ 4618 4619 default: 4620 break; 4621 } 4622 return (c); 4623 } 4624 4625 static segT 4626 get_segmented_expression (register expressionS *expP) 4627 { 4628 register segT retval; 4629 4630 retval = expression (expP); 4631 if (expP->X_op == O_illegal 4632 || expP->X_op == O_absent 4633 || expP->X_op == O_big) 4634 { 4635 as_bad (_("expected address expression")); 4636 expP->X_op = O_constant; 4637 expP->X_add_number = 0; 4638 retval = absolute_section; 4639 } 4640 return retval; 4641 } 4642 4643 static segT 4644 get_known_segmented_expression (register expressionS *expP) 4645 { 4646 register segT retval; 4647 4648 if ((retval = get_segmented_expression (expP)) == undefined_section) 4649 { 4650 /* There is no easy way to extract the undefined symbol from the 4651 expression. */ 4652 if (expP->X_add_symbol != NULL 4653 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section) 4654 as_warn (_("symbol \"%s\" undefined; zero assumed"), 4655 S_GET_NAME (expP->X_add_symbol)); 4656 else 4657 as_warn (_("some symbol undefined; zero assumed")); 4658 retval = absolute_section; 4659 expP->X_op = O_constant; 4660 expP->X_add_number = 0; 4661 } 4662 know (retval == absolute_section || SEG_NORMAL (retval)); 4663 return (retval); 4664 } 4665 4666 offsetT 4667 get_absolute_expr (expressionS *exp) 4668 { 4669 expression (exp); 4670 if (exp->X_op != O_constant) 4671 { 4672 if (exp->X_op != O_absent) 4673 as_bad (_("bad or irreducible absolute expression")); 4674 exp->X_add_number = 0; 4675 } 4676 return exp->X_add_number; 4677 } 4678 4679 offsetT 4680 get_absolute_expression (void) 4681 { 4682 expressionS exp; 4683 4684 return get_absolute_expr (&exp); 4685 } 4686 4687 char /* Return terminator. */ 4688 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */) 4689 { 4690 /* FIXME: val_pointer should probably be offsetT *. */ 4691 *val_pointer = (long) get_absolute_expression (); 4692 return (*input_line_pointer++); 4693 } 4694 4695 /* Like demand_copy_string, but return NULL if the string contains any '\0's. 4696 Give a warning if that happens. */ 4697 4698 char * 4699 demand_copy_C_string (int *len_pointer) 4700 { 4701 register char *s; 4702 4703 if ((s = demand_copy_string (len_pointer)) != 0) 4704 { 4705 register int len; 4706 4707 for (len = *len_pointer; len > 0; len--) 4708 { 4709 if (*s == 0) 4710 { 4711 s = 0; 4712 len = 1; 4713 *len_pointer = 0; 4714 as_bad (_("this string may not contain \'\\0\'")); 4715 } 4716 } 4717 } 4718 4719 return s; 4720 } 4721 4722 /* Demand string, but return a safe (=private) copy of the string. 4723 Return NULL if we can't read a string here. */ 4724 4725 char * 4726 demand_copy_string (int *lenP) 4727 { 4728 register unsigned int c; 4729 register int len; 4730 char *retval; 4731 4732 len = 0; 4733 SKIP_WHITESPACE (); 4734 if (*input_line_pointer == '\"') 4735 { 4736 input_line_pointer++; /* Skip opening quote. */ 4737 4738 while (is_a_char (c = next_char_of_string ())) 4739 { 4740 obstack_1grow (¬es, c); 4741 len++; 4742 } 4743 /* JF this next line is so demand_copy_C_string will return a 4744 null terminated string. */ 4745 obstack_1grow (¬es, '\0'); 4746 retval = obstack_finish (¬es); 4747 } 4748 else 4749 { 4750 as_bad (_("missing string")); 4751 retval = NULL; 4752 ignore_rest_of_line (); 4753 } 4754 *lenP = len; 4755 return (retval); 4756 } 4757 4758 /* In: Input_line_pointer->next character. 4759 4760 Do: Skip input_line_pointer over all whitespace. 4761 4762 Out: 1 if input_line_pointer->end-of-line. */ 4763 4764 int 4765 is_it_end_of_statement (void) 4766 { 4767 SKIP_WHITESPACE (); 4768 return (is_end_of_line[(unsigned char) *input_line_pointer]); 4769 } 4770 4771 void 4772 equals (char *sym_name, int reassign) 4773 { 4774 register symbolS *symbolP; /* Symbol we are working with. */ 4775 char *stop = NULL; 4776 char stopc; 4777 4778 input_line_pointer++; 4779 if (*input_line_pointer == '=') 4780 input_line_pointer++; 4781 4782 while (*input_line_pointer == ' ' || *input_line_pointer == '\t') 4783 input_line_pointer++; 4784 4785 if (flag_mri) 4786 stop = mri_comment_field (&stopc); 4787 4788 if (sym_name[0] == '.' && sym_name[1] == '\0') 4789 { 4790 /* Turn '. = mumble' into a .org mumble. */ 4791 register segT segment; 4792 expressionS exp; 4793 4794 segment = get_known_segmented_expression (&exp); 4795 if (!need_pass_2) 4796 do_org (segment, &exp, 0); 4797 } 4798 else 4799 { 4800 #ifdef OBJ_COFF 4801 int local; 4802 4803 symbolP = symbol_find (sym_name); 4804 local = symbolP == NULL; 4805 if (local) 4806 #endif /* OBJ_COFF */ 4807 symbolP = symbol_find_or_make (sym_name); 4808 /* Permit register names to be redefined. */ 4809 if (!reassign 4810 && S_IS_DEFINED (symbolP) 4811 && S_GET_SEGMENT (symbolP) != reg_section) 4812 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP)); 4813 4814 #ifdef OBJ_COFF 4815 /* "set" symbols are local unless otherwise specified. */ 4816 if (local) 4817 SF_SET_LOCAL (symbolP); 4818 #endif /* OBJ_COFF */ 4819 4820 pseudo_set (symbolP); 4821 } 4822 4823 if (flag_mri) 4824 { 4825 /* Check garbage after the expression. */ 4826 demand_empty_rest_of_line (); 4827 mri_comment_end (stop, stopc); 4828 } 4829 } 4830 4831 /* .incbin -- include a file verbatim at the current location. */ 4832 4833 void 4834 s_incbin (int x ATTRIBUTE_UNUSED) 4835 { 4836 FILE * binfile; 4837 char * path; 4838 char * filename; 4839 char * binfrag; 4840 long skip = 0; 4841 long count = 0; 4842 long bytes; 4843 int len; 4844 4845 #ifdef md_flush_pending_output 4846 md_flush_pending_output (); 4847 #endif 4848 4849 SKIP_WHITESPACE (); 4850 filename = demand_copy_string (& len); 4851 if (filename == NULL) 4852 return; 4853 4854 SKIP_WHITESPACE (); 4855 4856 /* Look for optional skip and count. */ 4857 if (* input_line_pointer == ',') 4858 { 4859 ++ input_line_pointer; 4860 skip = get_absolute_expression (); 4861 4862 SKIP_WHITESPACE (); 4863 4864 if (* input_line_pointer == ',') 4865 { 4866 ++ input_line_pointer; 4867 4868 count = get_absolute_expression (); 4869 if (count == 0) 4870 as_warn (_(".incbin count zero, ignoring `%s'"), filename); 4871 4872 SKIP_WHITESPACE (); 4873 } 4874 } 4875 4876 demand_empty_rest_of_line (); 4877 4878 /* Try opening absolute path first, then try include dirs. */ 4879 binfile = fopen (filename, FOPEN_RB); 4880 if (binfile == NULL) 4881 { 4882 int i; 4883 4884 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5); 4885 4886 for (i = 0; i < include_dir_count; i++) 4887 { 4888 sprintf (path, "%s/%s", include_dirs[i], filename); 4889 4890 binfile = fopen (path, FOPEN_RB); 4891 if (binfile != NULL) 4892 break; 4893 } 4894 4895 if (binfile == NULL) 4896 as_bad (_("file not found: %s"), filename); 4897 } 4898 else 4899 path = xstrdup (filename); 4900 4901 if (binfile) 4902 { 4903 long file_len; 4904 4905 register_dependency (path); 4906 4907 /* Compute the length of the file. */ 4908 if (fseek (binfile, 0, SEEK_END) != 0) 4909 { 4910 as_bad (_("seek to end of .incbin file failed `%s'"), path); 4911 goto done; 4912 } 4913 file_len = ftell (binfile); 4914 4915 /* If a count was not specified use the size of the file. */ 4916 if (count == 0) 4917 count = file_len; 4918 4919 if (skip + count > file_len) 4920 { 4921 as_bad (_("skip (%ld) + count (%ld) larger than file size (%ld)"), 4922 skip, count, file_len); 4923 goto done; 4924 } 4925 4926 if (fseek (binfile, skip, SEEK_SET) != 0) 4927 { 4928 as_bad (_("could not skip to %ld in file `%s'"), skip, path); 4929 goto done; 4930 } 4931 4932 /* Allocate frag space and store file contents in it. */ 4933 binfrag = frag_more (count); 4934 4935 bytes = fread (binfrag, 1, count, binfile); 4936 if (bytes < count) 4937 as_warn (_("truncated file `%s', %ld of %ld bytes read"), 4938 path, bytes, count); 4939 } 4940 done: 4941 if (binfile != NULL) 4942 fclose (binfile); 4943 if (path) 4944 free (path); 4945 } 4946 4947 /* .include -- include a file at this point. */ 4948 4949 void 4950 s_include (int arg ATTRIBUTE_UNUSED) 4951 { 4952 char *filename; 4953 int i; 4954 FILE *try; 4955 char *path; 4956 4957 if (!flag_m68k_mri) 4958 { 4959 filename = demand_copy_string (&i); 4960 if (filename == NULL) 4961 { 4962 /* demand_copy_string has already printed an error and 4963 called ignore_rest_of_line. */ 4964 return; 4965 } 4966 } 4967 else 4968 { 4969 SKIP_WHITESPACE (); 4970 i = 0; 4971 while (!is_end_of_line[(unsigned char) *input_line_pointer] 4972 && *input_line_pointer != ' ' 4973 && *input_line_pointer != '\t') 4974 { 4975 obstack_1grow (¬es, *input_line_pointer); 4976 ++input_line_pointer; 4977 ++i; 4978 } 4979 4980 obstack_1grow (¬es, '\0'); 4981 filename = obstack_finish (¬es); 4982 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 4983 ++input_line_pointer; 4984 } 4985 4986 demand_empty_rest_of_line (); 4987 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ ); 4988 4989 for (i = 0; i < include_dir_count; i++) 4990 { 4991 strcpy (path, include_dirs[i]); 4992 strcat (path, "/"); 4993 strcat (path, filename); 4994 if (0 != (try = fopen (path, FOPEN_RT))) 4995 { 4996 fclose (try); 4997 goto gotit; 4998 } 4999 } 5000 5001 free (path); 5002 path = filename; 5003 gotit: 5004 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */ 5005 register_dependency (path); 5006 input_scrub_insert_file (path); 5007 } 5008 5009 void 5010 add_include_dir (char *path) 5011 { 5012 int i; 5013 5014 if (include_dir_count == 0) 5015 { 5016 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs)); 5017 include_dirs[0] = "."; /* Current dir. */ 5018 include_dir_count = 2; 5019 } 5020 else 5021 { 5022 include_dir_count++; 5023 include_dirs = 5024 (char **) realloc (include_dirs, 5025 include_dir_count * sizeof (*include_dirs)); 5026 } 5027 5028 include_dirs[include_dir_count - 1] = path; /* New one. */ 5029 5030 i = strlen (path); 5031 if (i > include_dir_maxlen) 5032 include_dir_maxlen = i; 5033 } 5034 5035 /* Output debugging information to denote the source file. */ 5036 5037 static void 5038 generate_file_debug (void) 5039 { 5040 if (debug_type == DEBUG_STABS) 5041 stabs_generate_asm_file (); 5042 } 5043 5044 /* Output line number debugging information for the current source line. */ 5045 5046 void 5047 generate_lineno_debug (void) 5048 { 5049 switch (debug_type) 5050 { 5051 case DEBUG_UNSPECIFIED: 5052 case DEBUG_NONE: 5053 case DEBUG_DWARF: 5054 break; 5055 case DEBUG_STABS: 5056 stabs_generate_asm_lineno (); 5057 break; 5058 case DEBUG_ECOFF: 5059 ecoff_generate_asm_lineno (); 5060 break; 5061 case DEBUG_DWARF2: 5062 /* ??? We could here indicate to dwarf2dbg.c that something 5063 has changed. However, since there is additional backend 5064 support that is required (calling dwarf2_emit_insn), we 5065 let dwarf2dbg.c call as_where on its own. */ 5066 break; 5067 } 5068 } 5069 5070 /* Output debugging information to mark a function entry point or end point. 5071 END_P is zero for .func, and non-zero for .endfunc. */ 5072 5073 void 5074 s_func (int end_p) 5075 { 5076 do_s_func (end_p, NULL); 5077 } 5078 5079 /* Subroutine of s_func so targets can choose a different default prefix. 5080 If DEFAULT_PREFIX is NULL, use the target's "leading char". */ 5081 5082 void 5083 do_s_func (int end_p, const char *default_prefix) 5084 { 5085 /* Record the current function so that we can issue an error message for 5086 misplaced .func,.endfunc, and also so that .endfunc needs no 5087 arguments. */ 5088 static char *current_name; 5089 static char *current_label; 5090 5091 if (end_p) 5092 { 5093 if (current_name == NULL) 5094 { 5095 as_bad (_("missing .func")); 5096 ignore_rest_of_line (); 5097 return; 5098 } 5099 5100 if (debug_type == DEBUG_STABS) 5101 stabs_generate_asm_endfunc (current_name, current_label); 5102 5103 current_name = current_label = NULL; 5104 } 5105 else /* ! end_p */ 5106 { 5107 char *name, *label; 5108 char delim1, delim2; 5109 5110 if (current_name != NULL) 5111 { 5112 as_bad (_(".endfunc missing for previous .func")); 5113 ignore_rest_of_line (); 5114 return; 5115 } 5116 5117 name = input_line_pointer; 5118 delim1 = get_symbol_end (); 5119 name = xstrdup (name); 5120 *input_line_pointer = delim1; 5121 SKIP_WHITESPACE (); 5122 if (*input_line_pointer != ',') 5123 { 5124 if (default_prefix) 5125 asprintf (&label, "%s%s", default_prefix, name); 5126 else 5127 { 5128 char leading_char = 0; 5129 #ifdef BFD_ASSEMBLER 5130 leading_char = bfd_get_symbol_leading_char (stdoutput); 5131 #endif 5132 /* Missing entry point, use function's name with the leading 5133 char prepended. */ 5134 if (leading_char) 5135 asprintf (&label, "%c%s", leading_char, name); 5136 else 5137 label = name; 5138 } 5139 } 5140 else 5141 { 5142 ++input_line_pointer; 5143 SKIP_WHITESPACE (); 5144 label = input_line_pointer; 5145 delim2 = get_symbol_end (); 5146 label = xstrdup (label); 5147 *input_line_pointer = delim2; 5148 } 5149 5150 if (debug_type == DEBUG_STABS) 5151 stabs_generate_asm_func (name, label); 5152 5153 current_name = name; 5154 current_label = label; 5155 } 5156 5157 demand_empty_rest_of_line (); 5158 } 5159 5160 void 5161 s_ignore (int arg ATTRIBUTE_UNUSED) 5162 { 5163 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 5164 { 5165 ++input_line_pointer; 5166 } 5167 ++input_line_pointer; 5168 } 5169 5170 void 5171 read_print_statistics (FILE *file) 5172 { 5173 hash_print_statistics (file, "pseudo-op table", po_hash); 5174 } 5175 5176 /* Inserts the given line into the input stream. 5177 5178 This call avoids macro/conditionals nesting checking, since the contents of 5179 the line are assumed to replace the contents of a line already scanned. 5180 5181 An appropriate use of this function would be substitution of input lines when 5182 called by md_start_line_hook(). The given line is assumed to already be 5183 properly scrubbed. */ 5184 5185 void 5186 input_scrub_insert_line (const char *line) 5187 { 5188 sb newline; 5189 sb_new (&newline); 5190 sb_add_string (&newline, line); 5191 input_scrub_include_sb (&newline, input_line_pointer, 0); 5192 sb_kill (&newline); 5193 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5194 } 5195 5196 /* Insert a file into the input stream; the path must resolve to an actual 5197 file; no include path searching or dependency registering is performed. */ 5198 5199 void 5200 input_scrub_insert_file (char *path) 5201 { 5202 input_scrub_include_file (path, input_line_pointer); 5203 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5204 } 5205