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