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