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 6This file is part of GAS, the GNU Assembler. 7 8GAS is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GAS is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GAS; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 2102110-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 66char *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!)! */ 71die 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[]. */ 109char 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. */ 130char 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 154char original_case_string[128]; 155#endif 156 157/* Functions private to this file. */ 158 159static char *buffer; /* 1st char of each buffer of lines is here. */ 160static 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. */ 165int 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. */ 170char **include_dirs; 171 172/* How many are in the table. */ 173int include_dir_count; 174 175/* Length of longest in table. */ 176int include_dir_maxlen = 1; 177 178#ifndef WORKING_DOT_WORD 179struct broken_word *broken_words; 180int 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. */ 186addressT 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. */ 190symbolS *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. */ 195symbolS *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. */ 201static 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. */ 208static int dwarf_file_string; 209#endif 210#endif 211 212static void do_s_func (int end_p, const char *default_prefix); 213static void do_align (int, char *, int, int); 214static void s_align (int, int); 215static void s_altmacro (int); 216static void s_bad_end (int); 217static int hex_float (int, char *); 218static segT get_known_segmented_expression (expressionS * expP); 219static void pobegin (void); 220static int get_line_sb (sb *); 221static void generate_file_debug (void); 222static char *_find_end_of_line (char *, int, int); 223 224void 225read_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 249static inline int 250address_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 264static struct hash_control *po_hash; 265 266static 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 443static offsetT 444get_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 456offsetT 457get_absolute_expression (void) 458{ 459 expressionS exp; 460 461 return get_absolute_expr (&exp); 462} 463 464static int pop_override_ok = 0; 465static const char *pop_table_name; 466 467void 468pop_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 493static void 494pobegin (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 532static char *scrub_string; 533static char *scrub_string_end; 534 535static int 536scrub_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. */ 549static int 550try_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. */ 576void 577read_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 1141static void 1142convert_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 1169char * 1170mri_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 1200void 1201mri_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 1211void 1212s_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 1223static void 1224do_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 1276static void 1277s_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 1392void 1393s_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 1401void 1402s_align_ptwo (int arg) 1403{ 1404 s_align (arg, 0); 1405} 1406 1407/* Switch in and out of alternate macro mode. */ 1408 1409void 1410s_altmacro (int on) 1411{ 1412 demand_empty_rest_of_line (); 1413 macro_set_alternate (on); 1414} 1415 1416symbolS * 1417s_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 1522void 1523s_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 1532void 1533s_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 1632void 1633s_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 1662void 1663s_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 1675void 1676s_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 1708void 1709s_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 1742void 1743s_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 1759void 1760s_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 1768void 1769s_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 1805void 1806s_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 1827void 1828s_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 1925void 1926s_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 1965void 1966s_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 1999void 2000s_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 2066void 2067bss_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 2121offsetT 2122parse_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 2172symbolS * 2173s_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 2191void 2192s_lcomm (int needs_align) 2193{ 2194 s_comm_internal (needs_align, s_lcomm_internal); 2195} 2196 2197void 2198s_lcomm_bytes (int needs_align) 2199{ 2200 s_comm_internal (needs_align * 2, s_lcomm_internal); 2201} 2202 2203void 2204s_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 2272static int 2273get_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 2301void 2302s_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 2356void 2357s_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 2365void 2366s_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 2403static void 2404do_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 2438void 2439s_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 2492void 2493s_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 2654void 2655s_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 2668void 2669s_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 2697static void 2698s_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 2708void 2709s_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 2721void 2722do_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 2753void 2754end_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 2761static void 2762assign_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 2835void 2836s_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 2877void 2878s_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 3053void 3054s_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 3133void 3134s_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 3148void 3149s_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. */ 3163void 3164s_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 3299void 3300demand_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 3323void 3324ignore_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 3339static void 3340set_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 3353void 3354pseudo_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 3477static void 3478parse_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) 3484static void 3485parse_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) 3489static void 3490parse_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 3499void 3500do_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 3510static void 3511cons_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 3579void 3580cons (int size) 3581{ 3582 cons_worker (size, 0); 3583} 3584 3585void 3586s_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 3594void 3595emit_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 know (nbytes % CHARS_PER_LITTLENUM == 0); 3820 3821 size = exp->X_add_number * CHARS_PER_LITTLENUM; 3822 if (nbytes < size) 3823 { 3824 as_warn (_("bignum truncated to %d bytes"), nbytes); 3825 size = nbytes; 3826 } 3827 3828 if (target_big_endian) 3829 { 3830 while (nbytes > size) 3831 { 3832 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3833 nbytes -= CHARS_PER_LITTLENUM; 3834 p += CHARS_PER_LITTLENUM; 3835 } 3836 3837 nums = generic_bignum + size / CHARS_PER_LITTLENUM; 3838 while (size >= CHARS_PER_LITTLENUM) 3839 { 3840 --nums; 3841 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3842 size -= CHARS_PER_LITTLENUM; 3843 p += CHARS_PER_LITTLENUM; 3844 } 3845 } 3846 else 3847 { 3848 nums = generic_bignum; 3849 while (size >= CHARS_PER_LITTLENUM) 3850 { 3851 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3852 ++nums; 3853 size -= CHARS_PER_LITTLENUM; 3854 p += CHARS_PER_LITTLENUM; 3855 nbytes -= CHARS_PER_LITTLENUM; 3856 } 3857 3858 while (nbytes >= CHARS_PER_LITTLENUM) 3859 { 3860 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3861 nbytes -= CHARS_PER_LITTLENUM; 3862 p += CHARS_PER_LITTLENUM; 3863 } 3864 } 3865 } 3866 else 3867 { 3868 memset (p, 0, nbytes); 3869 3870 /* Now we need to generate a fixS to record the symbol value. */ 3871 3872#ifdef TC_CONS_FIX_NEW 3873 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); 3874#else 3875 { 3876 bfd_reloc_code_real_type r; 3877 3878 switch (nbytes) 3879 { 3880 case 1: 3881 r = BFD_RELOC_8; 3882 break; 3883 case 2: 3884 r = BFD_RELOC_16; 3885 break; 3886 case 4: 3887 r = BFD_RELOC_32; 3888 break; 3889 case 8: 3890 r = BFD_RELOC_64; 3891 break; 3892 default: 3893 as_bad (_("unsupported BFD relocation size %u"), nbytes); 3894 r = BFD_RELOC_32; 3895 break; 3896 } 3897 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 3898 0, r); 3899 } 3900#endif 3901 } 3902} 3903 3904#ifdef BITFIELD_CONS_EXPRESSIONS 3905 3906/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as 3907 w:x,y:z, where w and y are bitwidths and x and y are values. They 3908 then pack them all together. We do a little better in that we allow 3909 them in words, longs, etc. and we'll pack them in target byte order 3910 for you. 3911 3912 The rules are: pack least significant bit first, if a field doesn't 3913 entirely fit, put it in the next unit. Overflowing the bitfield is 3914 explicitly *not* even a warning. The bitwidth should be considered 3915 a "mask". 3916 3917 To use this function the tc-XXX.h file should define 3918 BITFIELD_CONS_EXPRESSIONS. */ 3919 3920static void 3921parse_bitfield_cons (exp, nbytes) 3922 expressionS *exp; 3923 unsigned int nbytes; 3924{ 3925 unsigned int bits_available = BITS_PER_CHAR * nbytes; 3926 char *hold = input_line_pointer; 3927 3928 (void) expression (exp); 3929 3930 if (*input_line_pointer == ':') 3931 { 3932 /* Bitfields. */ 3933 long value = 0; 3934 3935 for (;;) 3936 { 3937 unsigned long width; 3938 3939 if (*input_line_pointer != ':') 3940 { 3941 input_line_pointer = hold; 3942 break; 3943 } /* Next piece is not a bitfield. */ 3944 3945 /* In the general case, we can't allow 3946 full expressions with symbol 3947 differences and such. The relocation 3948 entries for symbols not defined in this 3949 assembly would require arbitrary field 3950 widths, positions, and masks which most 3951 of our current object formats don't 3952 support. 3953 3954 In the specific case where a symbol 3955 *is* defined in this assembly, we 3956 *could* build fixups and track it, but 3957 this could lead to confusion for the 3958 backends. I'm lazy. I'll take any 3959 SEG_ABSOLUTE. I think that means that 3960 you can use a previous .set or 3961 .equ type symbol. xoxorich. */ 3962 3963 if (exp->X_op == O_absent) 3964 { 3965 as_warn (_("using a bit field width of zero")); 3966 exp->X_add_number = 0; 3967 exp->X_op = O_constant; 3968 } /* Implied zero width bitfield. */ 3969 3970 if (exp->X_op != O_constant) 3971 { 3972 *input_line_pointer = '\0'; 3973 as_bad (_("field width \"%s\" too complex for a bitfield"), hold); 3974 *input_line_pointer = ':'; 3975 demand_empty_rest_of_line (); 3976 return; 3977 } /* Too complex. */ 3978 3979 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) 3980 { 3981 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"), 3982 width, nbytes, (BITS_PER_CHAR * nbytes)); 3983 width = BITS_PER_CHAR * nbytes; 3984 } /* Too big. */ 3985 3986 if (width > bits_available) 3987 { 3988 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */ 3989 input_line_pointer = hold; 3990 exp->X_add_number = value; 3991 break; 3992 } /* Won't fit. */ 3993 3994 /* Skip ':'. */ 3995 hold = ++input_line_pointer; 3996 3997 (void) expression (exp); 3998 if (exp->X_op != O_constant) 3999 { 4000 char cache = *input_line_pointer; 4001 4002 *input_line_pointer = '\0'; 4003 as_bad (_("field value \"%s\" too complex for a bitfield"), hold); 4004 *input_line_pointer = cache; 4005 demand_empty_rest_of_line (); 4006 return; 4007 } /* Too complex. */ 4008 4009 value |= ((~(-1 << width) & exp->X_add_number) 4010 << ((BITS_PER_CHAR * nbytes) - bits_available)); 4011 4012 if ((bits_available -= width) == 0 4013 || is_it_end_of_statement () 4014 || *input_line_pointer != ',') 4015 { 4016 break; 4017 } /* All the bitfields we're gonna get. */ 4018 4019 hold = ++input_line_pointer; 4020 (void) expression (exp); 4021 } 4022 4023 exp->X_add_number = value; 4024 exp->X_op = O_constant; 4025 exp->X_unsigned = 1; 4026 } 4027} 4028 4029#endif /* BITFIELD_CONS_EXPRESSIONS */ 4030 4031/* Handle an MRI style string expression. */ 4032 4033#ifdef TC_M68K 4034static void 4035parse_mri_cons (exp, nbytes) 4036 expressionS *exp; 4037 unsigned int nbytes; 4038{ 4039 if (*input_line_pointer != '\'' 4040 && (input_line_pointer[1] != '\'' 4041 || (*input_line_pointer != 'A' 4042 && *input_line_pointer != 'E'))) 4043 TC_PARSE_CONS_EXPRESSION (exp, nbytes); 4044 else 4045 { 4046 unsigned int scan; 4047 unsigned int result = 0; 4048 4049 /* An MRI style string. Cut into as many bytes as will fit into 4050 a nbyte chunk, left justify if necessary, and separate with 4051 commas so we can try again later. */ 4052 if (*input_line_pointer == 'A') 4053 ++input_line_pointer; 4054 else if (*input_line_pointer == 'E') 4055 { 4056 as_bad (_("EBCDIC constants are not supported")); 4057 ++input_line_pointer; 4058 } 4059 4060 input_line_pointer++; 4061 for (scan = 0; scan < nbytes; scan++) 4062 { 4063 if (*input_line_pointer == '\'') 4064 { 4065 if (input_line_pointer[1] == '\'') 4066 { 4067 input_line_pointer++; 4068 } 4069 else 4070 break; 4071 } 4072 result = (result << 8) | (*input_line_pointer++); 4073 } 4074 4075 /* Left justify. */ 4076 while (scan < nbytes) 4077 { 4078 result <<= 8; 4079 scan++; 4080 } 4081 4082 /* Create correct expression. */ 4083 exp->X_op = O_constant; 4084 exp->X_add_number = result; 4085 4086 /* Fake it so that we can read the next char too. */ 4087 if (input_line_pointer[0] != '\'' || 4088 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\'')) 4089 { 4090 input_line_pointer -= 2; 4091 input_line_pointer[0] = ','; 4092 input_line_pointer[1] = '\''; 4093 } 4094 else 4095 input_line_pointer++; 4096 } 4097} 4098#endif /* TC_M68K */ 4099 4100#ifdef REPEAT_CONS_EXPRESSIONS 4101 4102/* Parse a repeat expression for cons. This is used by the MIPS 4103 assembler. The format is NUMBER:COUNT; NUMBER appears in the 4104 object file COUNT times. 4105 4106 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */ 4107 4108static void 4109parse_repeat_cons (exp, nbytes) 4110 expressionS *exp; 4111 unsigned int nbytes; 4112{ 4113 expressionS count; 4114 register int i; 4115 4116 expression (exp); 4117 4118 if (*input_line_pointer != ':') 4119 { 4120 /* No repeat count. */ 4121 return; 4122 } 4123 4124 ++input_line_pointer; 4125 expression (&count); 4126 if (count.X_op != O_constant 4127 || count.X_add_number <= 0) 4128 { 4129 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 4130 return; 4131 } 4132 4133 /* The cons function is going to output this expression once. So we 4134 output it count - 1 times. */ 4135 for (i = count.X_add_number - 1; i > 0; i--) 4136 emit_expr (exp, nbytes); 4137} 4138 4139#endif /* REPEAT_CONS_EXPRESSIONS */ 4140 4141/* Parse a floating point number represented as a hex constant. This 4142 permits users to specify the exact bits they want in the floating 4143 point number. */ 4144 4145static int 4146hex_float (int float_type, char *bytes) 4147{ 4148 int length; 4149 int i; 4150 4151 switch (float_type) 4152 { 4153 case 'f': 4154 case 'F': 4155 case 's': 4156 case 'S': 4157 length = 4; 4158 break; 4159 4160 case 'd': 4161 case 'D': 4162 case 'r': 4163 case 'R': 4164 length = 8; 4165 break; 4166 4167 case 'x': 4168 case 'X': 4169 length = 12; 4170 break; 4171 4172 case 'p': 4173 case 'P': 4174 length = 12; 4175 break; 4176 4177 default: 4178 as_bad (_("unknown floating type type '%c'"), float_type); 4179 return -1; 4180 } 4181 4182 /* It would be nice if we could go through expression to parse the 4183 hex constant, but if we get a bignum it's a pain to sort it into 4184 the buffer correctly. */ 4185 i = 0; 4186 while (hex_p (*input_line_pointer) || *input_line_pointer == '_') 4187 { 4188 int d; 4189 4190 /* The MRI assembler accepts arbitrary underscores strewn about 4191 through the hex constant, so we ignore them as well. */ 4192 if (*input_line_pointer == '_') 4193 { 4194 ++input_line_pointer; 4195 continue; 4196 } 4197 4198 if (i >= length) 4199 { 4200 as_warn (_("floating point constant too large")); 4201 return -1; 4202 } 4203 d = hex_value (*input_line_pointer) << 4; 4204 ++input_line_pointer; 4205 while (*input_line_pointer == '_') 4206 ++input_line_pointer; 4207 if (hex_p (*input_line_pointer)) 4208 { 4209 d += hex_value (*input_line_pointer); 4210 ++input_line_pointer; 4211 } 4212 if (target_big_endian) 4213 bytes[i] = d; 4214 else 4215 bytes[length - i - 1] = d; 4216 ++i; 4217 } 4218 4219 if (i < length) 4220 { 4221 if (target_big_endian) 4222 memset (bytes + i, 0, length - i); 4223 else 4224 memset (bytes, 0, length - i); 4225 } 4226 4227 return length; 4228} 4229 4230/* float_cons() 4231 4232 CONStruct some more frag chars of .floats .ffloats etc. 4233 Makes 0 or more new frags. 4234 If need_pass_2 == 1, no frags are emitted. 4235 This understands only floating literals, not expressions. Sorry. 4236 4237 A floating constant is defined by atof_generic(), except it is preceded 4238 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its 4239 reading, I decided to be incompatible. This always tries to give you 4240 rounded bits to the precision of the pseudo-op. Former AS did premature 4241 truncation, restored noisy bits instead of trailing 0s AND gave you 4242 a choice of 2 flavours of noise according to which of 2 floating-point 4243 scanners you directed AS to use. 4244 4245 In: input_line_pointer->whitespace before, or '0' of flonum. */ 4246 4247void 4248float_cons (/* Clobbers input_line-pointer, checks end-of-line. */ 4249 register int float_type /* 'f':.ffloat ... 'F':.float ... */) 4250{ 4251 register char *p; 4252 int length; /* Number of chars in an object. */ 4253 register char *err; /* Error from scanning floating literal. */ 4254 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 4255 4256 if (is_it_end_of_statement ()) 4257 { 4258 demand_empty_rest_of_line (); 4259 return; 4260 } 4261 4262#ifdef md_flush_pending_output 4263 md_flush_pending_output (); 4264#endif 4265 4266 do 4267 { 4268 /* input_line_pointer->1st char of a flonum (we hope!). */ 4269 SKIP_WHITESPACE (); 4270 4271 /* Skip any 0{letter} that may be present. Don't even check if the 4272 letter is legal. Someone may invent a "z" format and this routine 4273 has no use for such information. Lusers beware: you get 4274 diagnostics if your input is ill-conditioned. */ 4275 if (input_line_pointer[0] == '0' 4276 && ISALPHA (input_line_pointer[1])) 4277 input_line_pointer += 2; 4278 4279 /* Accept :xxxx, where the x's are hex digits, for a floating 4280 point with the exact digits specified. */ 4281 if (input_line_pointer[0] == ':') 4282 { 4283 ++input_line_pointer; 4284 length = hex_float (float_type, temp); 4285 if (length < 0) 4286 { 4287 ignore_rest_of_line (); 4288 return; 4289 } 4290 } 4291 else 4292 { 4293 err = md_atof (float_type, temp, &length); 4294 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 4295 know (length > 0); 4296 if (err) 4297 { 4298 as_bad (_("bad floating literal: %s"), err); 4299 ignore_rest_of_line (); 4300 return; 4301 } 4302 } 4303 4304 if (!need_pass_2) 4305 { 4306 int count; 4307 4308 count = 1; 4309 4310#ifdef REPEAT_CONS_EXPRESSIONS 4311 if (*input_line_pointer == ':') 4312 { 4313 expressionS count_exp; 4314 4315 ++input_line_pointer; 4316 expression (&count_exp); 4317 4318 if (count_exp.X_op != O_constant 4319 || count_exp.X_add_number <= 0) 4320 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 4321 else 4322 count = count_exp.X_add_number; 4323 } 4324#endif 4325 4326 while (--count >= 0) 4327 { 4328 p = frag_more (length); 4329 memcpy (p, temp, (unsigned int) length); 4330 } 4331 } 4332 SKIP_WHITESPACE (); 4333 } 4334 while (*input_line_pointer++ == ','); 4335 4336 /* Put terminator back into stream. */ 4337 --input_line_pointer; 4338 demand_empty_rest_of_line (); 4339} 4340 4341/* Return the size of a LEB128 value. */ 4342 4343static inline int 4344sizeof_sleb128 (offsetT value) 4345{ 4346 register int size = 0; 4347 register unsigned byte; 4348 4349 do 4350 { 4351 byte = (value & 0x7f); 4352 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4353 Fortunately, we can structure things so that the extra work reduces 4354 to a noop on systems that do things "properly". */ 4355 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4356 size += 1; 4357 } 4358 while (!(((value == 0) && ((byte & 0x40) == 0)) 4359 || ((value == -1) && ((byte & 0x40) != 0)))); 4360 4361 return size; 4362} 4363 4364static inline int 4365sizeof_uleb128 (valueT value) 4366{ 4367 register int size = 0; 4368 register unsigned byte; 4369 4370 do 4371 { 4372 byte = (value & 0x7f); 4373 value >>= 7; 4374 size += 1; 4375 } 4376 while (value != 0); 4377 4378 return size; 4379} 4380 4381int 4382sizeof_leb128 (valueT value, int sign) 4383{ 4384 if (sign) 4385 return sizeof_sleb128 ((offsetT) value); 4386 else 4387 return sizeof_uleb128 (value); 4388} 4389 4390/* Output a LEB128 value. */ 4391 4392static inline int 4393output_sleb128 (char *p, offsetT value) 4394{ 4395 register char *orig = p; 4396 register int more; 4397 4398 do 4399 { 4400 unsigned byte = (value & 0x7f); 4401 4402 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4403 Fortunately, we can structure things so that the extra work reduces 4404 to a noop on systems that do things "properly". */ 4405 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4406 4407 more = !((((value == 0) && ((byte & 0x40) == 0)) 4408 || ((value == -1) && ((byte & 0x40) != 0)))); 4409 if (more) 4410 byte |= 0x80; 4411 4412 *p++ = byte; 4413 } 4414 while (more); 4415 4416 return p - orig; 4417} 4418 4419static inline int 4420output_uleb128 (char *p, valueT value) 4421{ 4422 char *orig = p; 4423 4424 do 4425 { 4426 unsigned byte = (value & 0x7f); 4427 value >>= 7; 4428 if (value != 0) 4429 /* More bytes to follow. */ 4430 byte |= 0x80; 4431 4432 *p++ = byte; 4433 } 4434 while (value != 0); 4435 4436 return p - orig; 4437} 4438 4439int 4440output_leb128 (char *p, valueT value, int sign) 4441{ 4442 if (sign) 4443 return output_sleb128 (p, (offsetT) value); 4444 else 4445 return output_uleb128 (p, value); 4446} 4447 4448/* Do the same for bignums. We combine sizeof with output here in that 4449 we don't output for NULL values of P. It isn't really as critical as 4450 for "normal" values that this be streamlined. */ 4451 4452static inline int 4453output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size) 4454{ 4455 char *orig = p; 4456 valueT val = 0; 4457 int loaded = 0; 4458 unsigned byte; 4459 4460 /* Strip leading sign extensions off the bignum. */ 4461 while (size > 1 4462 && bignum[size - 1] == LITTLENUM_MASK 4463 && bignum[size - 2] > LITTLENUM_MASK / 2) 4464 size--; 4465 4466 do 4467 { 4468 /* OR in the next part of the littlenum. */ 4469 val |= (*bignum << loaded); 4470 loaded += LITTLENUM_NUMBER_OF_BITS; 4471 size--; 4472 bignum++; 4473 4474 /* Add bytes until there are less than 7 bits left in VAL 4475 or until every non-sign bit has been written. */ 4476 do 4477 { 4478 byte = val & 0x7f; 4479 loaded -= 7; 4480 val >>= 7; 4481 if (size > 0 4482 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1)) 4483 byte |= 0x80; 4484 4485 if (orig) 4486 *p = byte; 4487 p++; 4488 } 4489 while ((byte & 0x80) != 0 && loaded >= 7); 4490 } 4491 while (size > 0); 4492 4493 /* Mop up any left-over bits (of which there will be less than 7). */ 4494 if ((byte & 0x80) != 0) 4495 { 4496 /* Sign-extend VAL. */ 4497 if (val & (1 << (loaded - 1))) 4498 val |= ~0 << loaded; 4499 if (orig) 4500 *p = val & 0x7f; 4501 p++; 4502 } 4503 4504 return p - orig; 4505} 4506 4507static inline int 4508output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size) 4509{ 4510 char *orig = p; 4511 valueT val = 0; 4512 int loaded = 0; 4513 unsigned byte; 4514 4515 /* Strip leading zeros off the bignum. */ 4516 /* XXX: Is this needed? */ 4517 while (size > 0 && bignum[size - 1] == 0) 4518 size--; 4519 4520 do 4521 { 4522 if (loaded < 7 && size > 0) 4523 { 4524 val |= (*bignum << loaded); 4525 loaded += 8 * CHARS_PER_LITTLENUM; 4526 size--; 4527 bignum++; 4528 } 4529 4530 byte = val & 0x7f; 4531 loaded -= 7; 4532 val >>= 7; 4533 4534 if (size > 0 || val) 4535 byte |= 0x80; 4536 4537 if (orig) 4538 *p = byte; 4539 p++; 4540 } 4541 while (byte & 0x80); 4542 4543 return p - orig; 4544} 4545 4546static int 4547output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign) 4548{ 4549 if (sign) 4550 return output_big_sleb128 (p, bignum, size); 4551 else 4552 return output_big_uleb128 (p, bignum, size); 4553} 4554 4555/* Generate the appropriate fragments for a given expression to emit a 4556 leb128 value. */ 4557 4558static void 4559emit_leb128_expr (expressionS *exp, int sign) 4560{ 4561 operatorT op = exp->X_op; 4562 unsigned int nbytes; 4563 4564 if (op == O_absent || op == O_illegal) 4565 { 4566 as_warn (_("zero assumed for missing expression")); 4567 exp->X_add_number = 0; 4568 op = O_constant; 4569 } 4570 else if (op == O_big && exp->X_add_number <= 0) 4571 { 4572 as_bad (_("floating point number invalid")); 4573 exp->X_add_number = 0; 4574 op = O_constant; 4575 } 4576 else if (op == O_register) 4577 { 4578 as_warn (_("register value used as expression")); 4579 op = O_constant; 4580 } 4581 else if (op == O_constant 4582 && sign 4583 && (exp->X_add_number < 0) != !exp->X_unsigned) 4584 { 4585 /* We're outputting a signed leb128 and the sign of X_add_number 4586 doesn't reflect the sign of the original value. Convert EXP 4587 to a correctly-extended bignum instead. */ 4588 convert_to_bignum (exp); 4589 op = O_big; 4590 } 4591 4592 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is 4593 a signal that this is leb128 data. It shouldn't optimize this away. */ 4594 nbytes = (unsigned int) -1; 4595 if (check_eh_frame (exp, &nbytes)) 4596 abort (); 4597 4598 /* Let the backend know that subsequent data may be byte aligned. */ 4599#ifdef md_cons_align 4600 md_cons_align (1); 4601#endif 4602 4603 if (op == O_constant) 4604 { 4605 /* If we've got a constant, emit the thing directly right now. */ 4606 4607 valueT value = exp->X_add_number; 4608 int size; 4609 char *p; 4610 4611 size = sizeof_leb128 (value, sign); 4612 p = frag_more (size); 4613 output_leb128 (p, value, sign); 4614 } 4615 else if (op == O_big) 4616 { 4617 /* O_big is a different sort of constant. */ 4618 4619 int size; 4620 char *p; 4621 4622 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); 4623 p = frag_more (size); 4624 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign); 4625 } 4626 else 4627 { 4628 /* Otherwise, we have to create a variable sized fragment and 4629 resolve things later. */ 4630 4631 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign, 4632 make_expr_symbol (exp), 0, (char *) NULL); 4633 } 4634} 4635 4636/* Parse the .sleb128 and .uleb128 pseudos. */ 4637 4638void 4639s_leb128 (int sign) 4640{ 4641 expressionS exp; 4642 4643#ifdef md_flush_pending_output 4644 md_flush_pending_output (); 4645#endif 4646 4647 do 4648 { 4649 expression (&exp); 4650 emit_leb128_expr (&exp, sign); 4651 } 4652 while (*input_line_pointer++ == ','); 4653 4654 input_line_pointer--; 4655 demand_empty_rest_of_line (); 4656} 4657 4658/* We read 0 or more ',' separated, double-quoted strings. 4659 Caller should have checked need_pass_2 is FALSE because we don't 4660 check it. */ 4661 4662void 4663stringer (/* Worker to do .ascii etc statements. */ 4664 /* Checks end-of-line. */ 4665 register int append_zero /* 0: don't append '\0', else 1. */) 4666{ 4667 register unsigned int c; 4668 char *start; 4669 4670#ifdef md_flush_pending_output 4671 md_flush_pending_output (); 4672#endif 4673 4674 /* The following awkward logic is to parse ZERO or more strings, 4675 comma separated. Recall a string expression includes spaces 4676 before the opening '\"' and spaces after the closing '\"'. 4677 We fake a leading ',' if there is (supposed to be) 4678 a 1st, expression. We keep demanding expressions for each ','. */ 4679 if (is_it_end_of_statement ()) 4680 { 4681 c = 0; /* Skip loop. */ 4682 ++input_line_pointer; /* Compensate for end of loop. */ 4683 } 4684 else 4685 { 4686 c = ','; /* Do loop. */ 4687 } 4688 /* If we have been switched into the abs_section then we 4689 will not have an obstack onto which we can hang strings. */ 4690 if (now_seg == absolute_section) 4691 { 4692 as_bad (_("strings must be placed into a section")); 4693 c = 0; 4694 ignore_rest_of_line (); 4695 } 4696 4697 while (c == ',' || c == '<' || c == '"') 4698 { 4699 SKIP_WHITESPACE (); 4700 switch (*input_line_pointer) 4701 { 4702 case '\"': 4703 ++input_line_pointer; /*->1st char of string. */ 4704 start = input_line_pointer; 4705 while (is_a_char (c = next_char_of_string ())) 4706 { 4707 FRAG_APPEND_1_CHAR (c); 4708 } 4709 if (append_zero) 4710 { 4711 FRAG_APPEND_1_CHAR (0); 4712 } 4713 know (input_line_pointer[-1] == '\"'); 4714 4715#ifndef NO_LISTING 4716#ifdef OBJ_ELF 4717 /* In ELF, when gcc is emitting DWARF 1 debugging output, it 4718 will emit .string with a filename in the .debug section 4719 after a sequence of constants. See the comment in 4720 emit_expr for the sequence. emit_expr will set 4721 dwarf_file_string to non-zero if this string might be a 4722 source file name. */ 4723 if (strcmp (segment_name (now_seg), ".debug") != 0) 4724 dwarf_file_string = 0; 4725 else if (dwarf_file_string) 4726 { 4727 c = input_line_pointer[-1]; 4728 input_line_pointer[-1] = '\0'; 4729 listing_source_file (start); 4730 input_line_pointer[-1] = c; 4731 } 4732#endif 4733#endif 4734 4735 break; 4736 case '<': 4737 input_line_pointer++; 4738 c = get_single_number (); 4739 FRAG_APPEND_1_CHAR (c); 4740 if (*input_line_pointer != '>') 4741 { 4742 as_bad (_("expected <nn>")); 4743 } 4744 input_line_pointer++; 4745 break; 4746 case ',': 4747 input_line_pointer++; 4748 break; 4749 } 4750 SKIP_WHITESPACE (); 4751 c = *input_line_pointer; 4752 } 4753 4754 demand_empty_rest_of_line (); 4755} /* stringer() */ 4756 4757/* FIXME-SOMEDAY: I had trouble here on characters with the 4758 high bits set. We'll probably also have trouble with 4759 multibyte chars, wide chars, etc. Also be careful about 4760 returning values bigger than 1 byte. xoxorich. */ 4761 4762unsigned int 4763next_char_of_string (void) 4764{ 4765 register unsigned int c; 4766 4767 c = *input_line_pointer++ & CHAR_MASK; 4768 switch (c) 4769 { 4770 case '\"': 4771 c = NOT_A_CHAR; 4772 break; 4773 4774 case '\n': 4775 as_warn (_("unterminated string; newline inserted")); 4776 bump_line_counters (); 4777 break; 4778 4779#ifndef NO_STRING_ESCAPES 4780 case '\\': 4781 switch (c = *input_line_pointer++) 4782 { 4783 case 'b': 4784 c = '\b'; 4785 break; 4786 4787 case 'f': 4788 c = '\f'; 4789 break; 4790 4791 case 'n': 4792 c = '\n'; 4793 break; 4794 4795 case 'r': 4796 c = '\r'; 4797 break; 4798 4799 case 't': 4800 c = '\t'; 4801 break; 4802 4803 case 'v': 4804 c = '\013'; 4805 break; 4806 4807 case '\\': 4808 case '"': 4809 break; /* As itself. */ 4810 4811 case '0': 4812 case '1': 4813 case '2': 4814 case '3': 4815 case '4': 4816 case '5': 4817 case '6': 4818 case '7': 4819 case '8': 4820 case '9': 4821 { 4822 long number; 4823 int i; 4824 4825 for (i = 0, number = 0; 4826 ISDIGIT (c) && i < 3; 4827 c = *input_line_pointer++, i++) 4828 { 4829 number = number * 8 + c - '0'; 4830 } 4831 4832 c = number & 0xff; 4833 } 4834 --input_line_pointer; 4835 break; 4836 4837 case 'x': 4838 case 'X': 4839 { 4840 long number; 4841 4842 number = 0; 4843 c = *input_line_pointer++; 4844 while (ISXDIGIT (c)) 4845 { 4846 if (ISDIGIT (c)) 4847 number = number * 16 + c - '0'; 4848 else if (ISUPPER (c)) 4849 number = number * 16 + c - 'A' + 10; 4850 else 4851 number = number * 16 + c - 'a' + 10; 4852 c = *input_line_pointer++; 4853 } 4854 c = number & 0xff; 4855 --input_line_pointer; 4856 } 4857 break; 4858 4859 case '\n': 4860 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */ 4861 as_warn (_("unterminated string; newline inserted")); 4862 c = '\n'; 4863 bump_line_counters (); 4864 break; 4865 4866 default: 4867 4868#ifdef ONLY_STANDARD_ESCAPES 4869 as_bad (_("bad escaped character in string")); 4870 c = '?'; 4871#endif /* ONLY_STANDARD_ESCAPES */ 4872 4873 break; 4874 } 4875 break; 4876#endif /* ! defined (NO_STRING_ESCAPES) */ 4877 4878 default: 4879 break; 4880 } 4881 return (c); 4882} 4883 4884static segT 4885get_segmented_expression (register expressionS *expP) 4886{ 4887 register segT retval; 4888 4889 retval = expression (expP); 4890 if (expP->X_op == O_illegal 4891 || expP->X_op == O_absent 4892 || expP->X_op == O_big) 4893 { 4894 as_bad (_("expected address expression")); 4895 expP->X_op = O_constant; 4896 expP->X_add_number = 0; 4897 retval = absolute_section; 4898 } 4899 return retval; 4900} 4901 4902static segT 4903get_known_segmented_expression (register expressionS *expP) 4904{ 4905 register segT retval; 4906 4907 if ((retval = get_segmented_expression (expP)) == undefined_section) 4908 { 4909 /* There is no easy way to extract the undefined symbol from the 4910 expression. */ 4911 if (expP->X_add_symbol != NULL 4912 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section) 4913 as_warn (_("symbol \"%s\" undefined; zero assumed"), 4914 S_GET_NAME (expP->X_add_symbol)); 4915 else 4916 as_warn (_("some symbol undefined; zero assumed")); 4917 retval = absolute_section; 4918 expP->X_op = O_constant; 4919 expP->X_add_number = 0; 4920 } 4921 know (retval == absolute_section || SEG_NORMAL (retval)); 4922 return (retval); 4923} 4924 4925char /* Return terminator. */ 4926get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */) 4927{ 4928 /* FIXME: val_pointer should probably be offsetT *. */ 4929 *val_pointer = (long) get_absolute_expression (); 4930 return (*input_line_pointer++); 4931} 4932 4933/* Like demand_copy_string, but return NULL if the string contains any '\0's. 4934 Give a warning if that happens. */ 4935 4936char * 4937demand_copy_C_string (int *len_pointer) 4938{ 4939 register char *s; 4940 4941 if ((s = demand_copy_string (len_pointer)) != 0) 4942 { 4943 register int len; 4944 4945 for (len = *len_pointer; len > 0; len--) 4946 { 4947 if (*s == 0) 4948 { 4949 s = 0; 4950 len = 1; 4951 *len_pointer = 0; 4952 as_bad (_("this string may not contain \'\\0\'")); 4953 } 4954 } 4955 } 4956 4957 return s; 4958} 4959 4960/* Demand string, but return a safe (=private) copy of the string. 4961 Return NULL if we can't read a string here. */ 4962 4963char * 4964demand_copy_string (int *lenP) 4965{ 4966 register unsigned int c; 4967 register int len; 4968 char *retval; 4969 4970 len = 0; 4971 SKIP_WHITESPACE (); 4972 if (*input_line_pointer == '\"') 4973 { 4974 input_line_pointer++; /* Skip opening quote. */ 4975 4976 while (is_a_char (c = next_char_of_string ())) 4977 { 4978 obstack_1grow (¬es, c); 4979 len++; 4980 } 4981 /* JF this next line is so demand_copy_C_string will return a 4982 null terminated string. */ 4983 obstack_1grow (¬es, '\0'); 4984 retval = obstack_finish (¬es); 4985 } 4986 else 4987 { 4988 as_bad (_("missing string")); 4989 retval = NULL; 4990 ignore_rest_of_line (); 4991 } 4992 *lenP = len; 4993 return (retval); 4994} 4995 4996/* In: Input_line_pointer->next character. 4997 4998 Do: Skip input_line_pointer over all whitespace. 4999 5000 Out: 1 if input_line_pointer->end-of-line. */ 5001 5002int 5003is_it_end_of_statement (void) 5004{ 5005 SKIP_WHITESPACE (); 5006 return (is_end_of_line[(unsigned char) *input_line_pointer]); 5007} 5008 5009void 5010equals (char *sym_name, int reassign) 5011{ 5012 char *stop = NULL; 5013 char stopc; 5014 5015 input_line_pointer++; 5016 if (*input_line_pointer == '=') 5017 input_line_pointer++; 5018 if (reassign < 0 && *input_line_pointer == '=') 5019 input_line_pointer++; 5020 5021 while (*input_line_pointer == ' ' || *input_line_pointer == '\t') 5022 input_line_pointer++; 5023 5024 if (flag_mri) 5025 stop = mri_comment_field (&stopc); 5026 5027 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign); 5028 5029 if (flag_mri) 5030 { 5031 demand_empty_rest_of_line (); 5032 mri_comment_end (stop, stopc); 5033 } 5034} 5035 5036/* .incbin -- include a file verbatim at the current location. */ 5037 5038void 5039s_incbin (int x ATTRIBUTE_UNUSED) 5040{ 5041 FILE * binfile; 5042 char * path; 5043 char * filename; 5044 char * binfrag; 5045 long skip = 0; 5046 long count = 0; 5047 long bytes; 5048 int len; 5049 5050#ifdef md_flush_pending_output 5051 md_flush_pending_output (); 5052#endif 5053 5054 SKIP_WHITESPACE (); 5055 filename = demand_copy_string (& len); 5056 if (filename == NULL) 5057 return; 5058 5059 SKIP_WHITESPACE (); 5060 5061 /* Look for optional skip and count. */ 5062 if (* input_line_pointer == ',') 5063 { 5064 ++ input_line_pointer; 5065 skip = get_absolute_expression (); 5066 5067 SKIP_WHITESPACE (); 5068 5069 if (* input_line_pointer == ',') 5070 { 5071 ++ input_line_pointer; 5072 5073 count = get_absolute_expression (); 5074 if (count == 0) 5075 as_warn (_(".incbin count zero, ignoring `%s'"), filename); 5076 5077 SKIP_WHITESPACE (); 5078 } 5079 } 5080 5081 demand_empty_rest_of_line (); 5082 5083 /* Try opening absolute path first, then try include dirs. */ 5084 binfile = fopen (filename, FOPEN_RB); 5085 if (binfile == NULL) 5086 { 5087 int i; 5088 5089 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5); 5090 5091 for (i = 0; i < include_dir_count; i++) 5092 { 5093 sprintf (path, "%s/%s", include_dirs[i], filename); 5094 5095 binfile = fopen (path, FOPEN_RB); 5096 if (binfile != NULL) 5097 break; 5098 } 5099 5100 if (binfile == NULL) 5101 as_bad (_("file not found: %s"), filename); 5102 } 5103 else 5104 path = xstrdup (filename); 5105 5106 if (binfile) 5107 { 5108 long file_len; 5109 5110 register_dependency (path); 5111 5112 /* Compute the length of the file. */ 5113 if (fseek (binfile, 0, SEEK_END) != 0) 5114 { 5115 as_bad (_("seek to end of .incbin file failed `%s'"), path); 5116 goto done; 5117 } 5118 file_len = ftell (binfile); 5119 5120 /* If a count was not specified use the remainder of the file. */ 5121 if (count == 0) 5122 count = file_len - skip; 5123 5124 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len) 5125 { 5126 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"), 5127 skip, count, file_len); 5128 goto done; 5129 } 5130 5131 if (fseek (binfile, skip, SEEK_SET) != 0) 5132 { 5133 as_bad (_("could not skip to %ld in file `%s'"), skip, path); 5134 goto done; 5135 } 5136 5137 /* Allocate frag space and store file contents in it. */ 5138 binfrag = frag_more (count); 5139 5140 bytes = fread (binfrag, 1, count, binfile); 5141 if (bytes < count) 5142 as_warn (_("truncated file `%s', %ld of %ld bytes read"), 5143 path, bytes, count); 5144 } 5145done: 5146 if (binfile != NULL) 5147 fclose (binfile); 5148 if (path) 5149 free (path); 5150} 5151 5152/* .include -- include a file at this point. */ 5153 5154void 5155s_include (int arg ATTRIBUTE_UNUSED) 5156{ 5157 char *filename; 5158 int i; 5159 FILE *try; 5160 char *path; 5161 5162 if (!flag_m68k_mri) 5163 { 5164 filename = demand_copy_string (&i); 5165 if (filename == NULL) 5166 { 5167 /* demand_copy_string has already printed an error and 5168 called ignore_rest_of_line. */ 5169 return; 5170 } 5171 } 5172 else 5173 { 5174 SKIP_WHITESPACE (); 5175 i = 0; 5176 while (!is_end_of_line[(unsigned char) *input_line_pointer] 5177 && *input_line_pointer != ' ' 5178 && *input_line_pointer != '\t') 5179 { 5180 obstack_1grow (¬es, *input_line_pointer); 5181 ++input_line_pointer; 5182 ++i; 5183 } 5184 5185 obstack_1grow (¬es, '\0'); 5186 filename = obstack_finish (¬es); 5187 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 5188 ++input_line_pointer; 5189 } 5190 5191 demand_empty_rest_of_line (); 5192 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ ); 5193 5194 for (i = 0; i < include_dir_count; i++) 5195 { 5196 strcpy (path, include_dirs[i]); 5197 strcat (path, "/"); 5198 strcat (path, filename); 5199 if (0 != (try = fopen (path, FOPEN_RT))) 5200 { 5201 fclose (try); 5202 goto gotit; 5203 } 5204 } 5205 5206 free (path); 5207 path = filename; 5208gotit: 5209 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */ 5210 register_dependency (path); 5211 input_scrub_insert_file (path); 5212} 5213 5214void 5215add_include_dir (char *path) 5216{ 5217 int i; 5218 5219 if (include_dir_count == 0) 5220 { 5221 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs)); 5222 include_dirs[0] = "."; /* Current dir. */ 5223 include_dir_count = 2; 5224 } 5225 else 5226 { 5227 include_dir_count++; 5228 include_dirs = 5229 (char **) realloc (include_dirs, 5230 include_dir_count * sizeof (*include_dirs)); 5231 } 5232 5233 include_dirs[include_dir_count - 1] = path; /* New one. */ 5234 5235 i = strlen (path); 5236 if (i > include_dir_maxlen) 5237 include_dir_maxlen = i; 5238} 5239 5240/* Output debugging information to denote the source file. */ 5241 5242static void 5243generate_file_debug (void) 5244{ 5245 if (debug_type == DEBUG_STABS) 5246 stabs_generate_asm_file (); 5247} 5248 5249/* Output line number debugging information for the current source line. */ 5250 5251void 5252generate_lineno_debug (void) 5253{ 5254 switch (debug_type) 5255 { 5256 case DEBUG_UNSPECIFIED: 5257 case DEBUG_NONE: 5258 case DEBUG_DWARF: 5259 break; 5260 case DEBUG_STABS: 5261 stabs_generate_asm_lineno (); 5262 break; 5263 case DEBUG_ECOFF: 5264 ecoff_generate_asm_lineno (); 5265 break; 5266 case DEBUG_DWARF2: 5267 /* ??? We could here indicate to dwarf2dbg.c that something 5268 has changed. However, since there is additional backend 5269 support that is required (calling dwarf2_emit_insn), we 5270 let dwarf2dbg.c call as_where on its own. */ 5271 break; 5272 } 5273} 5274 5275/* Output debugging information to mark a function entry point or end point. 5276 END_P is zero for .func, and non-zero for .endfunc. */ 5277 5278void 5279s_func (int end_p) 5280{ 5281 do_s_func (end_p, NULL); 5282} 5283 5284/* Subroutine of s_func so targets can choose a different default prefix. 5285 If DEFAULT_PREFIX is NULL, use the target's "leading char". */ 5286 5287static void 5288do_s_func (int end_p, const char *default_prefix) 5289{ 5290 /* Record the current function so that we can issue an error message for 5291 misplaced .func,.endfunc, and also so that .endfunc needs no 5292 arguments. */ 5293 static char *current_name; 5294 static char *current_label; 5295 5296 if (end_p) 5297 { 5298 if (current_name == NULL) 5299 { 5300 as_bad (_("missing .func")); 5301 ignore_rest_of_line (); 5302 return; 5303 } 5304 5305 if (debug_type == DEBUG_STABS) 5306 stabs_generate_asm_endfunc (current_name, current_label); 5307 5308 current_name = current_label = NULL; 5309 } 5310 else /* ! end_p */ 5311 { 5312 char *name, *label; 5313 char delim1, delim2; 5314 5315 if (current_name != NULL) 5316 { 5317 as_bad (_(".endfunc missing for previous .func")); 5318 ignore_rest_of_line (); 5319 return; 5320 } 5321 5322 name = input_line_pointer; 5323 delim1 = get_symbol_end (); 5324 name = xstrdup (name); 5325 *input_line_pointer = delim1; 5326 SKIP_WHITESPACE (); 5327 if (*input_line_pointer != ',') 5328 { 5329 if (default_prefix) 5330 asprintf (&label, "%s%s", default_prefix, name); 5331 else 5332 { 5333 char leading_char = bfd_get_symbol_leading_char (stdoutput); 5334 /* Missing entry point, use function's name with the leading 5335 char prepended. */ 5336 if (leading_char) 5337 asprintf (&label, "%c%s", leading_char, name); 5338 else 5339 label = name; 5340 } 5341 } 5342 else 5343 { 5344 ++input_line_pointer; 5345 SKIP_WHITESPACE (); 5346 label = input_line_pointer; 5347 delim2 = get_symbol_end (); 5348 label = xstrdup (label); 5349 *input_line_pointer = delim2; 5350 } 5351 5352 if (debug_type == DEBUG_STABS) 5353 stabs_generate_asm_func (name, label); 5354 5355 current_name = name; 5356 current_label = label; 5357 } 5358 5359 demand_empty_rest_of_line (); 5360} 5361 5362void 5363s_ignore (int arg ATTRIBUTE_UNUSED) 5364{ 5365 ignore_rest_of_line (); 5366} 5367 5368void 5369read_print_statistics (FILE *file) 5370{ 5371 hash_print_statistics (file, "pseudo-op table", po_hash); 5372} 5373 5374/* Inserts the given line into the input stream. 5375 5376 This call avoids macro/conditionals nesting checking, since the contents of 5377 the line are assumed to replace the contents of a line already scanned. 5378 5379 An appropriate use of this function would be substitution of input lines when 5380 called by md_start_line_hook(). The given line is assumed to already be 5381 properly scrubbed. */ 5382 5383void 5384input_scrub_insert_line (const char *line) 5385{ 5386 sb newline; 5387 sb_new (&newline); 5388 sb_add_string (&newline, line); 5389 input_scrub_include_sb (&newline, input_line_pointer, 0); 5390 sb_kill (&newline); 5391 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5392} 5393 5394/* Insert a file into the input stream; the path must resolve to an actual 5395 file; no include path searching or dependency registering is performed. */ 5396 5397void 5398input_scrub_insert_file (char *path) 5399{ 5400 input_scrub_include_file (path, input_line_pointer); 5401 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5402} 5403 5404/* Find the end of a line, considering quotation and escaping of quotes. */ 5405 5406#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS) 5407# define TC_SINGLE_QUOTE_STRINGS 1 5408#endif 5409 5410static char * 5411_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED) 5412{ 5413 char inquote = '\0'; 5414 int inescape = 0; 5415 5416 while (!is_end_of_line[(unsigned char) *s] 5417 || (inquote && !ISCNTRL (*s)) 5418 || (inquote == '\'' && flag_mri) 5419#ifdef TC_EOL_IN_INSN 5420 || (insn && TC_EOL_IN_INSN (s)) 5421#endif 5422 ) 5423 { 5424 if (mri_string && *s == '\'') 5425 inquote ^= *s; 5426 else if (inescape) 5427 inescape = 0; 5428 else if (*s == '\\') 5429 inescape = 1; 5430 else if (!inquote 5431 ? *s == '"' 5432#ifdef TC_SINGLE_QUOTE_STRINGS 5433 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'') 5434#endif 5435 : *s == inquote) 5436 inquote ^= *s; 5437 ++s; 5438 } 5439 if (inquote) 5440 as_warn (_("missing closing `%c'"), inquote); 5441 if (inescape) 5442 as_warn (_("stray `\\'")); 5443 return s; 5444} 5445 5446char * 5447find_end_of_line (char *s, int mri_string) 5448{ 5449 return _find_end_of_line (s, mri_string, 0); 5450} 5451