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