read.c revision 77298
1/* read.c - read a source file - 2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 3 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 2383 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, exp->X_add_symbol, 2384 exp->X_add_number * OCTETS_PER_BYTE, (char *) NULL); 2385 *p = fill; 2386 } 2387} 2388 2389void 2390s_org (ignore) 2391 int ignore ATTRIBUTE_UNUSED; 2392{ 2393 register segT segment; 2394 expressionS exp; 2395 register long temp_fill; 2396 2397#ifdef md_flush_pending_output 2398 md_flush_pending_output (); 2399#endif 2400 2401 /* The m68k MRI assembler has a different meaning for .org. It 2402 means to create an absolute section at a given address. We can't 2403 support that--use a linker script instead. */ 2404 if (flag_m68k_mri) 2405 { 2406 as_bad (_("MRI style ORG pseudo-op not supported")); 2407 ignore_rest_of_line (); 2408 return; 2409 } 2410 2411 /* Don't believe the documentation of BSD 4.2 AS. There is no such 2412 thing as a sub-segment-relative origin. Any absolute origin is 2413 given a warning, then assumed to be segment-relative. Any 2414 segmented origin expression ("foo+42") had better be in the right 2415 segment or the .org is ignored. 2416 2417 BSD 4.2 AS warns if you try to .org backwards. We cannot because 2418 we never know sub-segment sizes when we are reading code. BSD 2419 will crash trying to emit negative numbers of filler bytes in 2420 certain .orgs. We don't crash, but see as-write for that code. 2421 2422 Don't make frag if need_pass_2==1. */ 2423 segment = get_known_segmented_expression (&exp); 2424 if (*input_line_pointer == ',') 2425 { 2426 input_line_pointer++; 2427 temp_fill = get_absolute_expression (); 2428 } 2429 else 2430 temp_fill = 0; 2431 2432 if (!need_pass_2) 2433 do_org (segment, &exp, temp_fill); 2434 2435 demand_empty_rest_of_line (); 2436} 2437 2438/* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be 2439 called by the obj-format routine which handles section changing 2440 when in MRI mode. It will create a new section, and return it. It 2441 will set *TYPE to the section type: one of 'C' (code), 'D' (data), 2442 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the 2443 flags will be set in the section. */ 2444 2445void 2446s_mri_sect (type) 2447 char *type ATTRIBUTE_UNUSED; 2448{ 2449#ifdef TC_M68K 2450 2451 char *name; 2452 char c; 2453 segT seg; 2454 2455 SKIP_WHITESPACE (); 2456 2457 name = input_line_pointer; 2458 if (!isdigit ((unsigned char) *name)) 2459 c = get_symbol_end (); 2460 else 2461 { 2462 do 2463 { 2464 ++input_line_pointer; 2465 } 2466 while (isdigit ((unsigned char) *input_line_pointer)); 2467 2468 c = *input_line_pointer; 2469 *input_line_pointer = '\0'; 2470 } 2471 2472 name = xstrdup (name); 2473 2474 *input_line_pointer = c; 2475 2476 seg = subseg_new (name, 0); 2477 2478 if (*input_line_pointer == ',') 2479 { 2480 int align; 2481 2482 ++input_line_pointer; 2483 align = get_absolute_expression (); 2484 record_alignment (seg, align); 2485 } 2486 2487 *type = 'C'; 2488 if (*input_line_pointer == ',') 2489 { 2490 c = *++input_line_pointer; 2491 c = toupper ((unsigned char) c); 2492 if (c == 'C' || c == 'D' || c == 'M' || c == 'R') 2493 *type = c; 2494 else 2495 as_bad (_("unrecognized section type")); 2496 ++input_line_pointer; 2497 2498#ifdef BFD_ASSEMBLER 2499 { 2500 flagword flags; 2501 2502 flags = SEC_NO_FLAGS; 2503 if (*type == 'C') 2504 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE; 2505 else if (*type == 'D' || *type == 'M') 2506 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA; 2507 else if (*type == 'R') 2508 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM; 2509 if (flags != SEC_NO_FLAGS) 2510 { 2511 if (!bfd_set_section_flags (stdoutput, seg, flags)) 2512 as_warn (_("error setting flags for \"%s\": %s"), 2513 bfd_section_name (stdoutput, seg), 2514 bfd_errmsg (bfd_get_error ())); 2515 } 2516 } 2517#endif 2518 } 2519 2520 /* Ignore the HP type. */ 2521 if (*input_line_pointer == ',') 2522 input_line_pointer += 2; 2523 2524 demand_empty_rest_of_line (); 2525 2526#else /* ! TC_M68K */ 2527#ifdef TC_I960 2528 2529 char *name; 2530 char c; 2531 segT seg; 2532 2533 SKIP_WHITESPACE (); 2534 2535 name = input_line_pointer; 2536 c = get_symbol_end (); 2537 2538 name = xstrdup (name); 2539 2540 *input_line_pointer = c; 2541 2542 seg = subseg_new (name, 0); 2543 2544 if (*input_line_pointer != ',') 2545 *type = 'C'; 2546 else 2547 { 2548 char *sectype; 2549 2550 ++input_line_pointer; 2551 SKIP_WHITESPACE (); 2552 sectype = input_line_pointer; 2553 c = get_symbol_end (); 2554 if (*sectype == '\0') 2555 *type = 'C'; 2556 else if (strcasecmp (sectype, "text") == 0) 2557 *type = 'C'; 2558 else if (strcasecmp (sectype, "data") == 0) 2559 *type = 'D'; 2560 else if (strcasecmp (sectype, "romdata") == 0) 2561 *type = 'R'; 2562 else 2563 as_warn (_("unrecognized section type `%s'"), sectype); 2564 *input_line_pointer = c; 2565 } 2566 2567 if (*input_line_pointer == ',') 2568 { 2569 char *seccmd; 2570 2571 ++input_line_pointer; 2572 SKIP_WHITESPACE (); 2573 seccmd = input_line_pointer; 2574 c = get_symbol_end (); 2575 if (strcasecmp (seccmd, "absolute") == 0) 2576 { 2577 as_bad (_("absolute sections are not supported")); 2578 *input_line_pointer = c; 2579 ignore_rest_of_line (); 2580 return; 2581 } 2582 else if (strcasecmp (seccmd, "align") == 0) 2583 { 2584 int align; 2585 2586 *input_line_pointer = c; 2587 align = get_absolute_expression (); 2588 record_alignment (seg, align); 2589 } 2590 else 2591 { 2592 as_warn (_("unrecognized section command `%s'"), seccmd); 2593 *input_line_pointer = c; 2594 } 2595 } 2596 2597 demand_empty_rest_of_line (); 2598 2599#else /* ! TC_I960 */ 2600 /* The MRI assembler seems to use different forms of .sect for 2601 different targets. */ 2602 as_bad ("MRI mode not supported for this target"); 2603 ignore_rest_of_line (); 2604#endif /* ! TC_I960 */ 2605#endif /* ! TC_M68K */ 2606} 2607 2608/* Handle the .print pseudo-op. */ 2609 2610void 2611s_print (ignore) 2612 int ignore ATTRIBUTE_UNUSED; 2613{ 2614 char *s; 2615 int len; 2616 2617 s = demand_copy_C_string (&len); 2618 printf ("%s\n", s); 2619 demand_empty_rest_of_line (); 2620} 2621 2622/* Handle the .purgem pseudo-op. */ 2623 2624void 2625s_purgem (ignore) 2626 int ignore ATTRIBUTE_UNUSED; 2627{ 2628 if (is_it_end_of_statement ()) 2629 { 2630 demand_empty_rest_of_line (); 2631 return; 2632 } 2633 2634 do 2635 { 2636 char *name; 2637 char c; 2638 2639 SKIP_WHITESPACE (); 2640 name = input_line_pointer; 2641 c = get_symbol_end (); 2642 delete_macro (name); 2643 *input_line_pointer = c; 2644 SKIP_WHITESPACE (); 2645 } 2646 while (*input_line_pointer++ == ','); 2647 2648 --input_line_pointer; 2649 demand_empty_rest_of_line (); 2650} 2651 2652/* Handle the .rept pseudo-op. */ 2653 2654void 2655s_rept (ignore) 2656 int ignore ATTRIBUTE_UNUSED; 2657{ 2658 int count; 2659 2660 count = get_absolute_expression (); 2661 2662 do_repeat (count, "REPT", "ENDR"); 2663} 2664 2665/* This function provides a generic repeat block implementation. It allows 2666 different directives to be used as the start/end keys. */ 2667 2668void 2669do_repeat (count, start, end) 2670 int count; 2671 const char *start; 2672 const char *end; 2673{ 2674 sb one; 2675 sb many; 2676 2677 sb_new (&one); 2678 if (!buffer_and_nest (start, end, &one, get_line_sb)) 2679 { 2680 as_bad (_("%s without %s"), start, end); 2681 return; 2682 } 2683 2684 sb_new (&many); 2685 while (count-- > 0) 2686 sb_add_sb (&many, &one); 2687 2688 sb_kill (&one); 2689 2690 input_scrub_include_sb (&many, input_line_pointer, 1); 2691 sb_kill (&many); 2692 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 2693} 2694 2695/* Skip to end of current repeat loop; EXTRA indicates how many additional 2696 input buffers to skip. Assumes that conditionals preceding the loop end 2697 are properly nested. 2698 2699 This function makes it easier to implement a premature "break" out of the 2700 loop. The EXTRA arg accounts for other buffers we might have inserted, 2701 such as line substitutions. */ 2702 2703void 2704end_repeat (extra) 2705 int extra; 2706{ 2707 cond_exit_macro (macro_nest); 2708 while (extra-- >= 0) 2709 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 2710} 2711 2712/* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then 2713 this is .equiv, and it is an error if the symbol is already 2714 defined. */ 2715 2716void 2717s_set (equiv) 2718 int equiv; 2719{ 2720 register char *name; 2721 register char delim; 2722 register char *end_name; 2723 register symbolS *symbolP; 2724 2725 /* Especial apologies for the random logic: 2726 this just grew, and could be parsed much more simply! 2727 Dean in haste. */ 2728 name = input_line_pointer; 2729 delim = get_symbol_end (); 2730 end_name = input_line_pointer; 2731 *end_name = delim; 2732 SKIP_WHITESPACE (); 2733 2734 if (*input_line_pointer != ',') 2735 { 2736 *end_name = 0; 2737 as_bad (_("Expected comma after name \"%s\""), name); 2738 *end_name = delim; 2739 ignore_rest_of_line (); 2740 return; 2741 } 2742 2743 input_line_pointer++; 2744 *end_name = 0; 2745 2746 if (name[0] == '.' && name[1] == '\0') 2747 { 2748 /* Turn '. = mumble' into a .org mumble. */ 2749 register segT segment; 2750 expressionS exp; 2751 2752 segment = get_known_segmented_expression (&exp); 2753 2754 if (!need_pass_2) 2755 do_org (segment, &exp, 0); 2756 2757 *end_name = delim; 2758 return; 2759 } 2760 2761 if ((symbolP = symbol_find (name)) == NULL 2762 && (symbolP = md_undefined_symbol (name)) == NULL) 2763 { 2764#ifndef NO_LISTING 2765 /* When doing symbol listings, play games with dummy fragments living 2766 outside the normal fragment chain to record the file and line info 2767 for this symbol. */ 2768 if (listing & LISTING_SYMBOLS) 2769 { 2770 extern struct list_info_struct *listing_tail; 2771 fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS)); 2772 memset (dummy_frag, 0, sizeof (fragS)); 2773 dummy_frag->fr_type = rs_fill; 2774 dummy_frag->line = listing_tail; 2775 symbolP = symbol_new (name, undefined_section, 0, dummy_frag); 2776 dummy_frag->fr_symbol = symbolP; 2777 } 2778 else 2779#endif 2780 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag); 2781 2782#ifdef OBJ_COFF 2783 /* "set" symbols are local unless otherwise specified. */ 2784 SF_SET_LOCAL (symbolP); 2785#endif /* OBJ_COFF */ 2786 } 2787 2788 symbol_table_insert (symbolP); 2789 2790 *end_name = delim; 2791 2792 if (equiv 2793 && S_IS_DEFINED (symbolP) 2794 && S_GET_SEGMENT (symbolP) != reg_section) 2795 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP)); 2796 2797 pseudo_set (symbolP); 2798 demand_empty_rest_of_line (); 2799} 2800 2801void 2802s_space (mult) 2803 int mult; 2804{ 2805 expressionS exp; 2806 expressionS val; 2807 char *p = 0; 2808 char *stop = NULL; 2809 char stopc; 2810 int bytes; 2811 2812#ifdef md_flush_pending_output 2813 md_flush_pending_output (); 2814#endif 2815 2816 if (flag_mri) 2817 stop = mri_comment_field (&stopc); 2818 2819 /* In m68k MRI mode, we need to align to a word boundary, unless 2820 this is ds.b. */ 2821 if (flag_m68k_mri && mult > 1) 2822 { 2823 if (now_seg == absolute_section) 2824 { 2825 abs_section_offset += abs_section_offset & 1; 2826 if (line_label != NULL) 2827 S_SET_VALUE (line_label, abs_section_offset); 2828 } 2829 else if (mri_common_symbol != NULL) 2830 { 2831 valueT val; 2832 2833 val = S_GET_VALUE (mri_common_symbol); 2834 if ((val & 1) != 0) 2835 { 2836 S_SET_VALUE (mri_common_symbol, val + 1); 2837 if (line_label != NULL) 2838 { 2839 expressionS *symexp; 2840 2841 symexp = symbol_get_value_expression (line_label); 2842 know (symexp->X_op == O_symbol); 2843 know (symexp->X_add_symbol == mri_common_symbol); 2844 symexp->X_add_number += 1; 2845 } 2846 } 2847 } 2848 else 2849 { 2850 do_align (1, (char *) NULL, 0, 0); 2851 if (line_label != NULL) 2852 { 2853 symbol_set_frag (line_label, frag_now); 2854 S_SET_VALUE (line_label, frag_now_fix ()); 2855 } 2856 } 2857 } 2858 2859 bytes = mult; 2860 2861 expression (&exp); 2862 2863 SKIP_WHITESPACE (); 2864 if (*input_line_pointer == ',') 2865 { 2866 ++input_line_pointer; 2867 expression (&val); 2868 } 2869 else 2870 { 2871 val.X_op = O_constant; 2872 val.X_add_number = 0; 2873 } 2874 2875 if (val.X_op != O_constant 2876 || val.X_add_number < - 0x80 2877 || val.X_add_number > 0xff 2878 || (mult != 0 && mult != 1 && val.X_add_number != 0)) 2879 { 2880 if (exp.X_op != O_constant) 2881 as_bad (_("Unsupported variable size or fill value")); 2882 else 2883 { 2884 offsetT i; 2885 2886 if (mult == 0) 2887 mult = 1; 2888 bytes = mult * exp.X_add_number; 2889 for (i = 0; i < exp.X_add_number; i++) 2890 emit_expr (&val, mult); 2891 } 2892 } 2893 else 2894 { 2895 if (exp.X_op == O_constant) 2896 { 2897 long repeat; 2898 2899 repeat = exp.X_add_number; 2900 if (mult) 2901 repeat *= mult; 2902 bytes = repeat; 2903 if (repeat <= 0) 2904 { 2905 if (!flag_mri) 2906 as_warn (_(".space repeat count is zero, ignored")); 2907 else if (repeat < 0) 2908 as_warn (_(".space repeat count is negative, ignored")); 2909 goto getout; 2910 } 2911 2912 /* If we are in the absolute section, just bump the offset. */ 2913 if (now_seg == absolute_section) 2914 { 2915 abs_section_offset += repeat; 2916 goto getout; 2917 } 2918 2919 /* If we are secretly in an MRI common section, then 2920 creating space just increases the size of the common 2921 symbol. */ 2922 if (mri_common_symbol != NULL) 2923 { 2924 S_SET_VALUE (mri_common_symbol, 2925 S_GET_VALUE (mri_common_symbol) + repeat); 2926 goto getout; 2927 } 2928 2929 if (!need_pass_2) 2930 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0, 2931 (offsetT) repeat, (char *) 0); 2932 } 2933 else 2934 { 2935 if (now_seg == absolute_section) 2936 { 2937 as_bad (_("space allocation too complex in absolute section")); 2938 subseg_set (text_section, 0); 2939 } 2940 2941 if (mri_common_symbol != NULL) 2942 { 2943 as_bad (_("space allocation too complex in common section")); 2944 mri_common_symbol = NULL; 2945 } 2946 2947 if (!need_pass_2) 2948 p = frag_var (rs_space, 1, 1, (relax_substateT) 0, 2949 make_expr_symbol (&exp), (offsetT) 0, (char *) 0); 2950 } 2951 2952 if (p) 2953 *p = val.X_add_number; 2954 } 2955 2956 getout: 2957 2958 /* In MRI mode, after an odd number of bytes, we must align to an 2959 even word boundary, unless the next instruction is a dc.b, ds.b 2960 or dcb.b. */ 2961 if (flag_mri && (bytes & 1) != 0) 2962 mri_pending_align = 1; 2963 2964 demand_empty_rest_of_line (); 2965 2966 if (flag_mri) 2967 mri_comment_end (stop, stopc); 2968} 2969 2970/* This is like s_space, but the value is a floating point number with 2971 the given precision. This is for the MRI dcb.s pseudo-op and 2972 friends. */ 2973 2974void 2975s_float_space (float_type) 2976 int float_type; 2977{ 2978 offsetT count; 2979 int flen; 2980 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 2981 char *stop = NULL; 2982 char stopc; 2983 2984 if (flag_mri) 2985 stop = mri_comment_field (&stopc); 2986 2987 count = get_absolute_expression (); 2988 2989 SKIP_WHITESPACE (); 2990 if (*input_line_pointer != ',') 2991 { 2992 as_bad (_("missing value")); 2993 ignore_rest_of_line (); 2994 if (flag_mri) 2995 mri_comment_end (stop, stopc); 2996 return; 2997 } 2998 2999 ++input_line_pointer; 3000 3001 SKIP_WHITESPACE (); 3002 3003 /* Skip any 0{letter} that may be present. Don't even check if the 3004 * letter is legal. */ 3005 if (input_line_pointer[0] == '0' 3006 && isalpha ((unsigned char) input_line_pointer[1])) 3007 input_line_pointer += 2; 3008 3009 /* Accept :xxxx, where the x's are hex digits, for a floating point 3010 with the exact digits specified. */ 3011 if (input_line_pointer[0] == ':') 3012 { 3013 flen = hex_float (float_type, temp); 3014 if (flen < 0) 3015 { 3016 ignore_rest_of_line (); 3017 if (flag_mri) 3018 mri_comment_end (stop, stopc); 3019 return; 3020 } 3021 } 3022 else 3023 { 3024 char *err; 3025 3026 err = md_atof (float_type, temp, &flen); 3027 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 3028 know (flen > 0); 3029 if (err) 3030 { 3031 as_bad (_("Bad floating literal: %s"), err); 3032 ignore_rest_of_line (); 3033 if (flag_mri) 3034 mri_comment_end (stop, stopc); 3035 return; 3036 } 3037 } 3038 3039 while (--count >= 0) 3040 { 3041 char *p; 3042 3043 p = frag_more (flen); 3044 memcpy (p, temp, (unsigned int) flen); 3045 } 3046 3047 demand_empty_rest_of_line (); 3048 3049 if (flag_mri) 3050 mri_comment_end (stop, stopc); 3051} 3052 3053/* Handle the .struct pseudo-op, as found in MIPS assemblers. */ 3054 3055void 3056s_struct (ignore) 3057 int ignore ATTRIBUTE_UNUSED; 3058{ 3059 char *stop = NULL; 3060 char stopc; 3061 3062 if (flag_mri) 3063 stop = mri_comment_field (&stopc); 3064 abs_section_offset = get_absolute_expression (); 3065 subseg_set (absolute_section, 0); 3066 demand_empty_rest_of_line (); 3067 if (flag_mri) 3068 mri_comment_end (stop, stopc); 3069} 3070 3071void 3072s_text (ignore) 3073 int ignore ATTRIBUTE_UNUSED; 3074{ 3075 register int temp; 3076 3077 temp = get_absolute_expression (); 3078 subseg_set (text_section, (subsegT) temp); 3079 demand_empty_rest_of_line (); 3080#ifdef OBJ_VMS 3081 const_flag &= ~IN_DEFAULT_SECTION; 3082#endif 3083} 3084 3085void 3086demand_empty_rest_of_line () 3087{ 3088 SKIP_WHITESPACE (); 3089 if (is_end_of_line[(unsigned char) *input_line_pointer]) 3090 input_line_pointer++; 3091 else 3092 ignore_rest_of_line (); 3093 3094 /* Return having already swallowed end-of-line. */ 3095} 3096 3097void 3098ignore_rest_of_line () 3099{ 3100 /* For suspect lines: gives warning. */ 3101 if (!is_end_of_line[(unsigned char) *input_line_pointer]) 3102 { 3103 if (isprint ((unsigned char) *input_line_pointer)) 3104 as_bad (_("Rest of line ignored. First ignored character is `%c'."), 3105 *input_line_pointer); 3106 else 3107 as_bad (_("Rest of line ignored. First ignored character valued 0x%x."), 3108 *input_line_pointer); 3109 3110 while (input_line_pointer < buffer_limit 3111 && !is_end_of_line[(unsigned char) *input_line_pointer]) 3112 input_line_pointer++; 3113 } 3114 3115 input_line_pointer++; 3116 3117 /* Return pointing just after end-of-line. */ 3118 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); 3119} 3120 3121void 3122discard_rest_of_line () 3123{ 3124 while (input_line_pointer < buffer_limit 3125 && !is_end_of_line[(unsigned char) *input_line_pointer]) 3126 input_line_pointer++; 3127 3128 input_line_pointer++; 3129 3130 /* Return pointing just after end-of-line. */ 3131 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]); 3132} 3133 3134/* In: Pointer to a symbol. 3135 Input_line_pointer->expression. 3136 3137 Out: Input_line_pointer->just after any whitespace after expression. 3138 Tried to set symbol to value of expression. 3139 Will change symbols type, value, and frag; */ 3140 3141void 3142pseudo_set (symbolP) 3143 symbolS *symbolP; 3144{ 3145 expressionS exp; 3146#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) 3147 int ext; 3148#endif /* OBJ_AOUT or OBJ_BOUT */ 3149 3150 know (symbolP); /* NULL pointer is logic error. */ 3151#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) 3152 ext = S_IS_EXTERNAL (symbolP); 3153#endif /* OBJ_AOUT or OBJ_BOUT */ 3154 3155 (void) expression (&exp); 3156 3157 if (exp.X_op == O_illegal) 3158 as_bad (_("illegal expression; zero assumed")); 3159 else if (exp.X_op == O_absent) 3160 as_bad (_("missing expression; zero assumed")); 3161 else if (exp.X_op == O_big) 3162 { 3163 if (exp.X_add_number > 0) 3164 as_bad (_("bignum invalid; zero assumed")); 3165 else 3166 as_bad (_("floating point number invalid; zero assumed")); 3167 } 3168 else if (exp.X_op == O_subtract 3169 && (S_GET_SEGMENT (exp.X_add_symbol) 3170 == S_GET_SEGMENT (exp.X_op_symbol)) 3171 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol)) 3172 && (symbol_get_frag (exp.X_add_symbol) 3173 == symbol_get_frag (exp.X_op_symbol))) 3174 { 3175 exp.X_op = O_constant; 3176 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol) 3177 - S_GET_VALUE (exp.X_op_symbol)); 3178 } 3179 3180 switch (exp.X_op) 3181 { 3182 case O_illegal: 3183 case O_absent: 3184 case O_big: 3185 exp.X_add_number = 0; 3186 /* Fall through. */ 3187 case O_constant: 3188 S_SET_SEGMENT (symbolP, absolute_section); 3189#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) 3190 if (ext) 3191 S_SET_EXTERNAL (symbolP); 3192 else 3193 S_CLEAR_EXTERNAL (symbolP); 3194#endif /* OBJ_AOUT or OBJ_BOUT */ 3195 S_SET_VALUE (symbolP, (valueT) exp.X_add_number); 3196 if (exp.X_op != O_constant) 3197 symbol_set_frag (symbolP, &zero_address_frag); 3198 break; 3199 3200 case O_register: 3201 S_SET_SEGMENT (symbolP, reg_section); 3202 S_SET_VALUE (symbolP, (valueT) exp.X_add_number); 3203 symbol_set_frag (symbolP, &zero_address_frag); 3204 break; 3205 3206 case O_symbol: 3207 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section 3208 || exp.X_add_number != 0) 3209 symbol_set_value_expression (symbolP, &exp); 3210 else if (symbol_section_p (symbolP)) 3211 as_bad ("invalid attempt to set value of section symbol"); 3212 else 3213 { 3214 symbolS *s = exp.X_add_symbol; 3215 3216 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s)); 3217#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER) 3218 if (ext) 3219 S_SET_EXTERNAL (symbolP); 3220 else 3221 S_CLEAR_EXTERNAL (symbolP); 3222#endif /* OBJ_AOUT or OBJ_BOUT */ 3223 S_SET_VALUE (symbolP, 3224 exp.X_add_number + S_GET_VALUE (s)); 3225 symbol_set_frag (symbolP, symbol_get_frag (s)); 3226 copy_symbol_attributes (symbolP, s); 3227 } 3228 break; 3229 3230 default: 3231 /* The value is some complex expression. 3232 FIXME: Should we set the segment to anything? */ 3233 symbol_set_value_expression (symbolP, &exp); 3234 break; 3235 } 3236} 3237 3238/* cons() 3239 3240 CONStruct more frag of .bytes, or .words etc. 3241 Should need_pass_2 be 1 then emit no frag(s). 3242 This understands EXPRESSIONS. 3243 3244 Bug (?) 3245 3246 This has a split personality. We use expression() to read the 3247 value. We can detect if the value won't fit in a byte or word. 3248 But we can't detect if expression() discarded significant digits 3249 in the case of a long. Not worth the crocks required to fix it. */ 3250 3251/* Select a parser for cons expressions. */ 3252 3253/* Some targets need to parse the expression in various fancy ways. 3254 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like 3255 (for example, the HPPA does this). Otherwise, you can define 3256 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or 3257 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these 3258 are defined, which is the normal case, then only simple expressions 3259 are permitted. */ 3260 3261#ifdef TC_M68K 3262static void 3263parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes)); 3264#endif 3265 3266#ifndef TC_PARSE_CONS_EXPRESSION 3267#ifdef BITFIELD_CONS_EXPRESSIONS 3268#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES) 3269static void 3270parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes)); 3271#endif 3272#ifdef REPEAT_CONS_EXPRESSIONS 3273#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES) 3274static void 3275parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes)); 3276#endif 3277 3278/* If we haven't gotten one yet, just call expression. */ 3279#ifndef TC_PARSE_CONS_EXPRESSION 3280#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP) 3281#endif 3282#endif 3283 3284/* Worker to do .byte etc statements. 3285 Clobbers input_line_pointer and checks end-of-line. */ 3286 3287static void 3288cons_worker (nbytes, rva) 3289 register int nbytes; /* 1=.byte, 2=.word, 4=.long. */ 3290 int rva; 3291{ 3292 int c; 3293 expressionS exp; 3294 char *stop = NULL; 3295 char stopc; 3296 3297#ifdef md_flush_pending_output 3298 md_flush_pending_output (); 3299#endif 3300 3301 if (flag_mri) 3302 stop = mri_comment_field (&stopc); 3303 3304 if (is_it_end_of_statement ()) 3305 { 3306 demand_empty_rest_of_line (); 3307 if (flag_mri) 3308 mri_comment_end (stop, stopc); 3309 return; 3310 } 3311 3312#ifdef md_cons_align 3313 md_cons_align (nbytes); 3314#endif 3315 3316 c = 0; 3317 do 3318 { 3319#ifdef TC_M68K 3320 if (flag_m68k_mri) 3321 parse_mri_cons (&exp, (unsigned int) nbytes); 3322 else 3323#endif 3324 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes); 3325 3326 if (rva) 3327 { 3328 if (exp.X_op == O_symbol) 3329 exp.X_op = O_symbol_rva; 3330 else 3331 as_fatal (_("rva without symbol")); 3332 } 3333 emit_expr (&exp, (unsigned int) nbytes); 3334 ++c; 3335 } 3336 while (*input_line_pointer++ == ','); 3337 3338 /* In MRI mode, after an odd number of bytes, we must align to an 3339 even word boundary, unless the next instruction is a dc.b, ds.b 3340 or dcb.b. */ 3341 if (flag_mri && nbytes == 1 && (c & 1) != 0) 3342 mri_pending_align = 1; 3343 3344 input_line_pointer--; /* Put terminator back into stream. */ 3345 3346 demand_empty_rest_of_line (); 3347 3348 if (flag_mri) 3349 mri_comment_end (stop, stopc); 3350} 3351 3352void 3353cons (size) 3354 int size; 3355{ 3356 cons_worker (size, 0); 3357} 3358 3359void 3360s_rva (size) 3361 int size; 3362{ 3363 cons_worker (size, 1); 3364} 3365 3366/* Put the contents of expression EXP into the object file using 3367 NBYTES bytes. If need_pass_2 is 1, this does nothing. */ 3368 3369void 3370emit_expr (exp, nbytes) 3371 expressionS *exp; 3372 unsigned int nbytes; 3373{ 3374 operatorT op; 3375 register char *p; 3376 valueT extra_digit = 0; 3377 3378 /* Don't do anything if we are going to make another pass. */ 3379 if (need_pass_2) 3380 return; 3381 3382#ifndef NO_LISTING 3383#ifdef OBJ_ELF 3384 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will 3385 appear as a four byte positive constant in the .line section, 3386 followed by a 2 byte 0xffff. Look for that case here. */ 3387 { 3388 static int dwarf_line = -1; 3389 3390 if (strcmp (segment_name (now_seg), ".line") != 0) 3391 dwarf_line = -1; 3392 else if (dwarf_line >= 0 3393 && nbytes == 2 3394 && exp->X_op == O_constant 3395 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff)) 3396 listing_source_line ((unsigned int) dwarf_line); 3397 else if (nbytes == 4 3398 && exp->X_op == O_constant 3399 && exp->X_add_number >= 0) 3400 dwarf_line = exp->X_add_number; 3401 else 3402 dwarf_line = -1; 3403 } 3404 3405 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will 3406 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte 3407 AT_sibling (0x12) followed by a four byte address of the sibling 3408 followed by a 2 byte AT_name (0x38) followed by the name of the 3409 file. We look for that case here. */ 3410 { 3411 static int dwarf_file = 0; 3412 3413 if (strcmp (segment_name (now_seg), ".debug") != 0) 3414 dwarf_file = 0; 3415 else if (dwarf_file == 0 3416 && nbytes == 2 3417 && exp->X_op == O_constant 3418 && exp->X_add_number == 0x11) 3419 dwarf_file = 1; 3420 else if (dwarf_file == 1 3421 && nbytes == 2 3422 && exp->X_op == O_constant 3423 && exp->X_add_number == 0x12) 3424 dwarf_file = 2; 3425 else if (dwarf_file == 2 3426 && nbytes == 4) 3427 dwarf_file = 3; 3428 else if (dwarf_file == 3 3429 && nbytes == 2 3430 && exp->X_op == O_constant 3431 && exp->X_add_number == 0x38) 3432 dwarf_file = 4; 3433 else 3434 dwarf_file = 0; 3435 3436 /* The variable dwarf_file_string tells stringer that the string 3437 may be the name of the source file. */ 3438 if (dwarf_file == 4) 3439 dwarf_file_string = 1; 3440 else 3441 dwarf_file_string = 0; 3442 } 3443#endif 3444#endif 3445 3446 if (check_eh_frame (exp, &nbytes)) 3447 return; 3448 3449 op = exp->X_op; 3450 3451 /* Allow `.word 0' in the absolute section. */ 3452 if (now_seg == absolute_section) 3453 { 3454 if (op != O_constant || exp->X_add_number != 0) 3455 as_bad (_("attempt to store value in absolute section")); 3456 abs_section_offset += nbytes; 3457 return; 3458 } 3459 3460 /* Handle a negative bignum. */ 3461 if (op == O_uminus 3462 && exp->X_add_number == 0 3463 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big 3464 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0) 3465 { 3466 int i; 3467 unsigned long carry; 3468 3469 exp = symbol_get_value_expression (exp->X_add_symbol); 3470 3471 /* Negate the bignum: one's complement each digit and add 1. */ 3472 carry = 1; 3473 for (i = 0; i < exp->X_add_number; i++) 3474 { 3475 unsigned long next; 3476 3477 next = (((~(generic_bignum[i] & LITTLENUM_MASK)) 3478 & LITTLENUM_MASK) 3479 + carry); 3480 generic_bignum[i] = next & LITTLENUM_MASK; 3481 carry = next >> LITTLENUM_NUMBER_OF_BITS; 3482 } 3483 3484 /* We can ignore any carry out, because it will be handled by 3485 extra_digit if it is needed. */ 3486 3487 extra_digit = (valueT) -1; 3488 op = O_big; 3489 } 3490 3491 if (op == O_absent || op == O_illegal) 3492 { 3493 as_warn (_("zero assumed for missing expression")); 3494 exp->X_add_number = 0; 3495 op = O_constant; 3496 } 3497 else if (op == O_big && exp->X_add_number <= 0) 3498 { 3499 as_bad (_("floating point number invalid; zero assumed")); 3500 exp->X_add_number = 0; 3501 op = O_constant; 3502 } 3503 else if (op == O_register) 3504 { 3505 as_warn (_("register value used as expression")); 3506 op = O_constant; 3507 } 3508 3509 p = frag_more ((int) nbytes); 3510 3511#ifndef WORKING_DOT_WORD 3512 /* If we have the difference of two symbols in a word, save it on 3513 the broken_words list. See the code in write.c. */ 3514 if (op == O_subtract && nbytes == 2) 3515 { 3516 struct broken_word *x; 3517 3518 x = (struct broken_word *) xmalloc (sizeof (struct broken_word)); 3519 x->next_broken_word = broken_words; 3520 broken_words = x; 3521 x->seg = now_seg; 3522 x->subseg = now_subseg; 3523 x->frag = frag_now; 3524 x->word_goes_here = p; 3525 x->dispfrag = 0; 3526 x->add = exp->X_add_symbol; 3527 x->sub = exp->X_op_symbol; 3528 x->addnum = exp->X_add_number; 3529 x->added = 0; 3530 new_broken_words++; 3531 return; 3532 } 3533#endif 3534 3535 /* If we have an integer, but the number of bytes is too large to 3536 pass to md_number_to_chars, handle it as a bignum. */ 3537 if (op == O_constant && nbytes > sizeof (valueT)) 3538 { 3539 valueT val; 3540 int gencnt; 3541 3542 if (!exp->X_unsigned && exp->X_add_number < 0) 3543 extra_digit = (valueT) -1; 3544 val = (valueT) exp->X_add_number; 3545 gencnt = 0; 3546 do 3547 { 3548 generic_bignum[gencnt] = val & LITTLENUM_MASK; 3549 val >>= LITTLENUM_NUMBER_OF_BITS; 3550 ++gencnt; 3551 } 3552 while (val != 0); 3553 op = exp->X_op = O_big; 3554 exp->X_add_number = gencnt; 3555 } 3556 3557 if (op == O_constant) 3558 { 3559 register valueT get; 3560 register valueT use; 3561 register valueT mask; 3562 valueT hibit; 3563 register valueT unmask; 3564 3565 /* JF << of >= number of bits in the object is undefined. In 3566 particular SPARC (Sun 4) has problems. */ 3567 if (nbytes >= sizeof (valueT)) 3568 { 3569 mask = 0; 3570 if (nbytes > sizeof (valueT)) 3571 hibit = 0; 3572 else 3573 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1); 3574 } 3575 else 3576 { 3577 /* Don't store these bits. */ 3578 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes); 3579 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1); 3580 } 3581 3582 unmask = ~mask; /* Do store these bits. */ 3583 3584#ifdef NEVER 3585 "Do this mod if you want every overflow check to assume SIGNED 2's complement data."; 3586 mask = ~(unmask >> 1); /* Includes sign bit now. */ 3587#endif 3588 3589 get = exp->X_add_number; 3590 use = get & unmask; 3591 if ((get & mask) != 0 3592 && ((get & mask) != mask 3593 || (get & hibit) == 0)) 3594 { /* Leading bits contain both 0s & 1s. */ 3595 as_warn (_("Value 0x%lx truncated to 0x%lx."), 3596 (unsigned long) get, (unsigned long) use); 3597 } 3598 /* Put bytes in right order. */ 3599 md_number_to_chars (p, use, (int) nbytes); 3600 } 3601 else if (op == O_big) 3602 { 3603 unsigned int size; 3604 LITTLENUM_TYPE *nums; 3605 3606 know (nbytes % CHARS_PER_LITTLENUM == 0); 3607 3608 size = exp->X_add_number * CHARS_PER_LITTLENUM; 3609 if (nbytes < size) 3610 { 3611 as_warn (_("Bignum truncated to %d bytes"), nbytes); 3612 size = nbytes; 3613 } 3614 3615 if (target_big_endian) 3616 { 3617 while (nbytes > size) 3618 { 3619 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3620 nbytes -= CHARS_PER_LITTLENUM; 3621 p += CHARS_PER_LITTLENUM; 3622 } 3623 3624 nums = generic_bignum + size / CHARS_PER_LITTLENUM; 3625 while (size > 0) 3626 { 3627 --nums; 3628 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3629 size -= CHARS_PER_LITTLENUM; 3630 p += CHARS_PER_LITTLENUM; 3631 } 3632 } 3633 else 3634 { 3635 nums = generic_bignum; 3636 while (size > 0) 3637 { 3638 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM); 3639 ++nums; 3640 size -= CHARS_PER_LITTLENUM; 3641 p += CHARS_PER_LITTLENUM; 3642 nbytes -= CHARS_PER_LITTLENUM; 3643 } 3644 3645 while (nbytes > 0) 3646 { 3647 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM); 3648 nbytes -= CHARS_PER_LITTLENUM; 3649 p += CHARS_PER_LITTLENUM; 3650 } 3651 } 3652 } 3653 else 3654 { 3655 memset (p, 0, nbytes); 3656 3657 /* Now we need to generate a fixS to record the symbol value. 3658 This is easy for BFD. For other targets it can be more 3659 complex. For very complex cases (currently, the HPPA and 3660 NS32K), you can define TC_CONS_FIX_NEW to do whatever you 3661 want. For simpler cases, you can define TC_CONS_RELOC to be 3662 the name of the reloc code that should be stored in the fixS. 3663 If neither is defined, the code uses NO_RELOC if it is 3664 defined, and otherwise uses 0. */ 3665 3666#ifdef BFD_ASSEMBLER 3667#ifdef TC_CONS_FIX_NEW 3668 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); 3669#else 3670 { 3671 bfd_reloc_code_real_type r; 3672 3673 switch (nbytes) 3674 { 3675 case 1: 3676 r = BFD_RELOC_8; 3677 break; 3678 case 2: 3679 r = BFD_RELOC_16; 3680 break; 3681 case 4: 3682 r = BFD_RELOC_32; 3683 break; 3684 case 8: 3685 r = BFD_RELOC_64; 3686 break; 3687 default: 3688 as_bad (_("unsupported BFD relocation size %u"), nbytes); 3689 r = BFD_RELOC_32; 3690 break; 3691 } 3692 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 3693 0, r); 3694 } 3695#endif 3696#else 3697#ifdef TC_CONS_FIX_NEW 3698 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp); 3699#else 3700 /* Figure out which reloc number to use. Use TC_CONS_RELOC if 3701 it is defined, otherwise use NO_RELOC if it is defined, 3702 otherwise use 0. */ 3703#ifndef TC_CONS_RELOC 3704#ifdef NO_RELOC 3705#define TC_CONS_RELOC NO_RELOC 3706#else 3707#define TC_CONS_RELOC 0 3708#endif 3709#endif 3710 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0, 3711 TC_CONS_RELOC); 3712#endif /* TC_CONS_FIX_NEW */ 3713#endif /* BFD_ASSEMBLER */ 3714 } 3715} 3716 3717#ifdef BITFIELD_CONS_EXPRESSIONS 3718 3719/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as 3720 w:x,y:z, where w and y are bitwidths and x and y are values. They 3721 then pack them all together. We do a little better in that we allow 3722 them in words, longs, etc. and we'll pack them in target byte order 3723 for you. 3724 3725 The rules are: pack least significat bit first, if a field doesn't 3726 entirely fit, put it in the next unit. Overflowing the bitfield is 3727 explicitly *not* even a warning. The bitwidth should be considered 3728 a "mask". 3729 3730 To use this function the tc-XXX.h file should define 3731 BITFIELD_CONS_EXPRESSIONS. */ 3732 3733static void 3734parse_bitfield_cons (exp, nbytes) 3735 expressionS *exp; 3736 unsigned int nbytes; 3737{ 3738 unsigned int bits_available = BITS_PER_CHAR * nbytes; 3739 char *hold = input_line_pointer; 3740 3741 (void) expression (exp); 3742 3743 if (*input_line_pointer == ':') 3744 { 3745 /* Bitfields. */ 3746 long value = 0; 3747 3748 for (;;) 3749 { 3750 unsigned long width; 3751 3752 if (*input_line_pointer != ':') 3753 { 3754 input_line_pointer = hold; 3755 break; 3756 } /* Next piece is not a bitfield. */ 3757 3758 /* In the general case, we can't allow 3759 full expressions with symbol 3760 differences and such. The relocation 3761 entries for symbols not defined in this 3762 assembly would require arbitrary field 3763 widths, positions, and masks which most 3764 of our current object formats don't 3765 support. 3766 3767 In the specific case where a symbol 3768 *is* defined in this assembly, we 3769 *could* build fixups and track it, but 3770 this could lead to confusion for the 3771 backends. I'm lazy. I'll take any 3772 SEG_ABSOLUTE. I think that means that 3773 you can use a previous .set or 3774 .equ type symbol. xoxorich. */ 3775 3776 if (exp->X_op == O_absent) 3777 { 3778 as_warn (_("using a bit field width of zero")); 3779 exp->X_add_number = 0; 3780 exp->X_op = O_constant; 3781 } /* Implied zero width bitfield. */ 3782 3783 if (exp->X_op != O_constant) 3784 { 3785 *input_line_pointer = '\0'; 3786 as_bad (_("field width \"%s\" too complex for a bitfield"), hold); 3787 *input_line_pointer = ':'; 3788 demand_empty_rest_of_line (); 3789 return; 3790 } /* Too complex. */ 3791 3792 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes)) 3793 { 3794 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"), 3795 width, nbytes, (BITS_PER_CHAR * nbytes)); 3796 width = BITS_PER_CHAR * nbytes; 3797 } /* Too big. */ 3798 3799 if (width > bits_available) 3800 { 3801 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */ 3802 input_line_pointer = hold; 3803 exp->X_add_number = value; 3804 break; 3805 } /* Won't fit. */ 3806 3807 /* Skip ':'. */ 3808 hold = ++input_line_pointer; 3809 3810 (void) expression (exp); 3811 if (exp->X_op != O_constant) 3812 { 3813 char cache = *input_line_pointer; 3814 3815 *input_line_pointer = '\0'; 3816 as_bad (_("field value \"%s\" too complex for a bitfield"), hold); 3817 *input_line_pointer = cache; 3818 demand_empty_rest_of_line (); 3819 return; 3820 } /* Too complex. */ 3821 3822 value |= ((~(-1 << width) & exp->X_add_number) 3823 << ((BITS_PER_CHAR * nbytes) - bits_available)); 3824 3825 if ((bits_available -= width) == 0 3826 || is_it_end_of_statement () 3827 || *input_line_pointer != ',') 3828 { 3829 break; 3830 } /* All the bitfields we're gonna get. */ 3831 3832 hold = ++input_line_pointer; 3833 (void) expression (exp); 3834 } 3835 3836 exp->X_add_number = value; 3837 exp->X_op = O_constant; 3838 exp->X_unsigned = 1; 3839 } 3840} 3841 3842#endif /* BITFIELD_CONS_EXPRESSIONS */ 3843 3844/* Handle an MRI style string expression. */ 3845 3846#ifdef TC_M68K 3847static void 3848parse_mri_cons (exp, nbytes) 3849 expressionS *exp; 3850 unsigned int nbytes; 3851{ 3852 if (*input_line_pointer != '\'' 3853 && (input_line_pointer[1] != '\'' 3854 || (*input_line_pointer != 'A' 3855 && *input_line_pointer != 'E'))) 3856 TC_PARSE_CONS_EXPRESSION (exp, nbytes); 3857 else 3858 { 3859 unsigned int scan; 3860 unsigned int result = 0; 3861 3862 /* An MRI style string. Cut into as many bytes as will fit into 3863 a nbyte chunk, left justify if necessary, and separate with 3864 commas so we can try again later. */ 3865 if (*input_line_pointer == 'A') 3866 ++input_line_pointer; 3867 else if (*input_line_pointer == 'E') 3868 { 3869 as_bad (_("EBCDIC constants are not supported")); 3870 ++input_line_pointer; 3871 } 3872 3873 input_line_pointer++; 3874 for (scan = 0; scan < nbytes; scan++) 3875 { 3876 if (*input_line_pointer == '\'') 3877 { 3878 if (input_line_pointer[1] == '\'') 3879 { 3880 input_line_pointer++; 3881 } 3882 else 3883 break; 3884 } 3885 result = (result << 8) | (*input_line_pointer++); 3886 } 3887 3888 /* Left justify. */ 3889 while (scan < nbytes) 3890 { 3891 result <<= 8; 3892 scan++; 3893 } 3894 3895 /* Create correct expression. */ 3896 exp->X_op = O_constant; 3897 exp->X_add_number = result; 3898 3899 /* Fake it so that we can read the next char too. */ 3900 if (input_line_pointer[0] != '\'' || 3901 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\'')) 3902 { 3903 input_line_pointer -= 2; 3904 input_line_pointer[0] = ','; 3905 input_line_pointer[1] = '\''; 3906 } 3907 else 3908 input_line_pointer++; 3909 } 3910} 3911#endif /* TC_M68K */ 3912 3913#ifdef REPEAT_CONS_EXPRESSIONS 3914 3915/* Parse a repeat expression for cons. This is used by the MIPS 3916 assembler. The format is NUMBER:COUNT; NUMBER appears in the 3917 object file COUNT times. 3918 3919 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */ 3920 3921static void 3922parse_repeat_cons (exp, nbytes) 3923 expressionS *exp; 3924 unsigned int nbytes; 3925{ 3926 expressionS count; 3927 register int i; 3928 3929 expression (exp); 3930 3931 if (*input_line_pointer != ':') 3932 { 3933 /* No repeat count. */ 3934 return; 3935 } 3936 3937 ++input_line_pointer; 3938 expression (&count); 3939 if (count.X_op != O_constant 3940 || count.X_add_number <= 0) 3941 { 3942 as_warn (_("Unresolvable or nonpositive repeat count; using 1")); 3943 return; 3944 } 3945 3946 /* The cons function is going to output this expression once. So we 3947 output it count - 1 times. */ 3948 for (i = count.X_add_number - 1; i > 0; i--) 3949 emit_expr (exp, nbytes); 3950} 3951 3952#endif /* REPEAT_CONS_EXPRESSIONS */ 3953 3954/* Parse a floating point number represented as a hex constant. This 3955 permits users to specify the exact bits they want in the floating 3956 point number. */ 3957 3958static int 3959hex_float (float_type, bytes) 3960 int float_type; 3961 char *bytes; 3962{ 3963 int length; 3964 int i; 3965 3966 switch (float_type) 3967 { 3968 case 'f': 3969 case 'F': 3970 case 's': 3971 case 'S': 3972 length = 4; 3973 break; 3974 3975 case 'd': 3976 case 'D': 3977 case 'r': 3978 case 'R': 3979 length = 8; 3980 break; 3981 3982 case 'x': 3983 case 'X': 3984 length = 12; 3985 break; 3986 3987 case 'p': 3988 case 'P': 3989 length = 12; 3990 break; 3991 3992 default: 3993 as_bad (_("Unknown floating type type '%c'"), float_type); 3994 return -1; 3995 } 3996 3997 /* It would be nice if we could go through expression to parse the 3998 hex constant, but if we get a bignum it's a pain to sort it into 3999 the buffer correctly. */ 4000 i = 0; 4001 while (hex_p (*input_line_pointer) || *input_line_pointer == '_') 4002 { 4003 int d; 4004 4005 /* The MRI assembler accepts arbitrary underscores strewn about 4006 through the hex constant, so we ignore them as well. */ 4007 if (*input_line_pointer == '_') 4008 { 4009 ++input_line_pointer; 4010 continue; 4011 } 4012 4013 if (i >= length) 4014 { 4015 as_warn (_("Floating point constant too large")); 4016 return -1; 4017 } 4018 d = hex_value (*input_line_pointer) << 4; 4019 ++input_line_pointer; 4020 while (*input_line_pointer == '_') 4021 ++input_line_pointer; 4022 if (hex_p (*input_line_pointer)) 4023 { 4024 d += hex_value (*input_line_pointer); 4025 ++input_line_pointer; 4026 } 4027 if (target_big_endian) 4028 bytes[i] = d; 4029 else 4030 bytes[length - i - 1] = d; 4031 ++i; 4032 } 4033 4034 if (i < length) 4035 { 4036 if (target_big_endian) 4037 memset (bytes + i, 0, length - i); 4038 else 4039 memset (bytes, 0, length - i); 4040 } 4041 4042 return length; 4043} 4044 4045/* float_cons() 4046 4047 CONStruct some more frag chars of .floats .ffloats etc. 4048 Makes 0 or more new frags. 4049 If need_pass_2 == 1, no frags are emitted. 4050 This understands only floating literals, not expressions. Sorry. 4051 4052 A floating constant is defined by atof_generic(), except it is preceded 4053 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its 4054 reading, I decided to be incompatible. This always tries to give you 4055 rounded bits to the precision of the pseudo-op. Former AS did premature 4056 truncatation, restored noisy bits instead of trailing 0s AND gave you 4057 a choice of 2 flavours of noise according to which of 2 floating-point 4058 scanners you directed AS to use. 4059 4060 In: input_line_pointer->whitespace before, or '0' of flonum. */ 4061 4062void 4063float_cons (float_type) 4064 /* Clobbers input_line-pointer, checks end-of-line. */ 4065 register int float_type; /* 'f':.ffloat ... 'F':.float ... */ 4066{ 4067 register char *p; 4068 int length; /* Number of chars in an object. */ 4069 register char *err; /* Error from scanning floating literal. */ 4070 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; 4071 4072 if (is_it_end_of_statement ()) 4073 { 4074 demand_empty_rest_of_line (); 4075 return; 4076 } 4077 4078#ifdef md_flush_pending_output 4079 md_flush_pending_output (); 4080#endif 4081 4082 do 4083 { 4084 /* input_line_pointer->1st char of a flonum (we hope!). */ 4085 SKIP_WHITESPACE (); 4086 4087 /* Skip any 0{letter} that may be present. Don't even check if the 4088 letter is legal. Someone may invent a "z" format and this routine 4089 has no use for such information. Lusers beware: you get 4090 diagnostics if your input is ill-conditioned. */ 4091 if (input_line_pointer[0] == '0' 4092 && isalpha ((unsigned char) input_line_pointer[1])) 4093 input_line_pointer += 2; 4094 4095 /* Accept :xxxx, where the x's are hex digits, for a floating 4096 point with the exact digits specified. */ 4097 if (input_line_pointer[0] == ':') 4098 { 4099 ++input_line_pointer; 4100 length = hex_float (float_type, temp); 4101 if (length < 0) 4102 { 4103 ignore_rest_of_line (); 4104 return; 4105 } 4106 } 4107 else 4108 { 4109 err = md_atof (float_type, temp, &length); 4110 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); 4111 know (length > 0); 4112 if (err) 4113 { 4114 as_bad (_("Bad floating literal: %s"), err); 4115 ignore_rest_of_line (); 4116 return; 4117 } 4118 } 4119 4120 if (!need_pass_2) 4121 { 4122 int count; 4123 4124 count = 1; 4125 4126#ifdef REPEAT_CONS_EXPRESSIONS 4127 if (*input_line_pointer == ':') 4128 { 4129 expressionS count_exp; 4130 4131 ++input_line_pointer; 4132 expression (&count_exp); 4133 4134 if (count_exp.X_op != O_constant 4135 || count_exp.X_add_number <= 0) 4136 as_warn (_("unresolvable or nonpositive repeat count; using 1")); 4137 else 4138 count = count_exp.X_add_number; 4139 } 4140#endif 4141 4142 while (--count >= 0) 4143 { 4144 p = frag_more (length); 4145 memcpy (p, temp, (unsigned int) length); 4146 } 4147 } 4148 SKIP_WHITESPACE (); 4149 } 4150 while (*input_line_pointer++ == ','); 4151 4152 /* Put terminator back into stream. */ 4153 --input_line_pointer; 4154 demand_empty_rest_of_line (); 4155} 4156 4157/* Return the size of a LEB128 value. */ 4158 4159static inline int 4160sizeof_sleb128 (value) 4161 offsetT value; 4162{ 4163 register int size = 0; 4164 register unsigned byte; 4165 4166 do 4167 { 4168 byte = (value & 0x7f); 4169 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4170 Fortunately, we can structure things so that the extra work reduces 4171 to a noop on systems that do things "properly". */ 4172 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4173 size += 1; 4174 } 4175 while (!(((value == 0) && ((byte & 0x40) == 0)) 4176 || ((value == -1) && ((byte & 0x40) != 0)))); 4177 4178 return size; 4179} 4180 4181static inline int 4182sizeof_uleb128 (value) 4183 valueT value; 4184{ 4185 register int size = 0; 4186 register unsigned byte; 4187 4188 do 4189 { 4190 byte = (value & 0x7f); 4191 value >>= 7; 4192 size += 1; 4193 } 4194 while (value != 0); 4195 4196 return size; 4197} 4198 4199int 4200sizeof_leb128 (value, sign) 4201 valueT value; 4202 int sign; 4203{ 4204 if (sign) 4205 return sizeof_sleb128 ((offsetT) value); 4206 else 4207 return sizeof_uleb128 (value); 4208} 4209 4210/* Output a LEB128 value. */ 4211 4212static inline int 4213output_sleb128 (p, value) 4214 char *p; 4215 offsetT value; 4216{ 4217 register char *orig = p; 4218 register int more; 4219 4220 do 4221 { 4222 unsigned byte = (value & 0x7f); 4223 4224 /* Sadly, we cannot rely on typical arithmetic right shift behaviour. 4225 Fortunately, we can structure things so that the extra work reduces 4226 to a noop on systems that do things "properly". */ 4227 value = (value >> 7) | ~(-(offsetT)1 >> 7); 4228 4229 more = !((((value == 0) && ((byte & 0x40) == 0)) 4230 || ((value == -1) && ((byte & 0x40) != 0)))); 4231 if (more) 4232 byte |= 0x80; 4233 4234 *p++ = byte; 4235 } 4236 while (more); 4237 4238 return p - orig; 4239} 4240 4241static inline int 4242output_uleb128 (p, value) 4243 char *p; 4244 valueT value; 4245{ 4246 char *orig = p; 4247 4248 do 4249 { 4250 unsigned byte = (value & 0x7f); 4251 value >>= 7; 4252 if (value != 0) 4253 /* More bytes to follow. */ 4254 byte |= 0x80; 4255 4256 *p++ = byte; 4257 } 4258 while (value != 0); 4259 4260 return p - orig; 4261} 4262 4263int 4264output_leb128 (p, value, sign) 4265 char *p; 4266 valueT value; 4267 int sign; 4268{ 4269 if (sign) 4270 return output_sleb128 (p, (offsetT) value); 4271 else 4272 return output_uleb128 (p, value); 4273} 4274 4275/* Do the same for bignums. We combine sizeof with output here in that 4276 we don't output for NULL values of P. It isn't really as critical as 4277 for "normal" values that this be streamlined. */ 4278 4279static inline int 4280output_big_sleb128 (p, bignum, size) 4281 char *p; 4282 LITTLENUM_TYPE *bignum; 4283 int size; 4284{ 4285 char *orig = p; 4286 valueT val = 0; 4287 int loaded = 0; 4288 unsigned byte; 4289 4290 /* Strip leading sign extensions off the bignum. */ 4291 while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1) 4292 size--; 4293 4294 do 4295 { 4296 if (loaded < 7 && size > 0) 4297 { 4298 val |= (*bignum << loaded); 4299 loaded += 8 * CHARS_PER_LITTLENUM; 4300 size--; 4301 bignum++; 4302 } 4303 4304 byte = val & 0x7f; 4305 loaded -= 7; 4306 val >>= 7; 4307 4308 if (size == 0) 4309 { 4310 if ((val == 0 && (byte & 0x40) == 0) 4311 || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0 4312 && (byte & 0x40) != 0)) 4313 byte |= 0x80; 4314 } 4315 4316 if (orig) 4317 *p = byte; 4318 p++; 4319 } 4320 while (byte & 0x80); 4321 4322 return p - orig; 4323} 4324 4325static inline int 4326output_big_uleb128 (p, bignum, size) 4327 char *p; 4328 LITTLENUM_TYPE *bignum; 4329 int size; 4330{ 4331 char *orig = p; 4332 valueT val = 0; 4333 int loaded = 0; 4334 unsigned byte; 4335 4336 /* Strip leading zeros off the bignum. */ 4337 /* XXX: Is this needed? */ 4338 while (size > 0 && bignum[size - 1] == 0) 4339 size--; 4340 4341 do 4342 { 4343 if (loaded < 7 && size > 0) 4344 { 4345 val |= (*bignum << loaded); 4346 loaded += 8 * CHARS_PER_LITTLENUM; 4347 size--; 4348 bignum++; 4349 } 4350 4351 byte = val & 0x7f; 4352 loaded -= 7; 4353 val >>= 7; 4354 4355 if (size > 0 || val) 4356 byte |= 0x80; 4357 4358 if (orig) 4359 *p = byte; 4360 p++; 4361 } 4362 while (byte & 0x80); 4363 4364 return p - orig; 4365} 4366 4367static int 4368output_big_leb128 (p, bignum, size, sign) 4369 char *p; 4370 LITTLENUM_TYPE *bignum; 4371 int size, sign; 4372{ 4373 if (sign) 4374 return output_big_sleb128 (p, bignum, size); 4375 else 4376 return output_big_uleb128 (p, bignum, size); 4377} 4378 4379/* Generate the appropriate fragments for a given expression to emit a 4380 leb128 value. */ 4381 4382void 4383emit_leb128_expr (exp, sign) 4384 expressionS *exp; 4385 int sign; 4386{ 4387 operatorT op = exp->X_op; 4388 4389 if (op == O_absent || op == O_illegal) 4390 { 4391 as_warn (_("zero assumed for missing expression")); 4392 exp->X_add_number = 0; 4393 op = O_constant; 4394 } 4395 else if (op == O_big && exp->X_add_number <= 0) 4396 { 4397 as_bad (_("floating point number invalid; zero assumed")); 4398 exp->X_add_number = 0; 4399 op = O_constant; 4400 } 4401 else if (op == O_register) 4402 { 4403 as_warn (_("register value used as expression")); 4404 op = O_constant; 4405 } 4406 4407 if (op == O_constant) 4408 { 4409 /* If we've got a constant, emit the thing directly right now. */ 4410 4411 valueT value = exp->X_add_number; 4412 int size; 4413 char *p; 4414 4415 size = sizeof_leb128 (value, sign); 4416 p = frag_more (size); 4417 output_leb128 (p, value, sign); 4418 } 4419 else if (op == O_big) 4420 { 4421 /* O_big is a different sort of constant. */ 4422 4423 int size; 4424 char *p; 4425 4426 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); 4427 p = frag_more (size); 4428 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign); 4429 } 4430 else 4431 { 4432 /* Otherwise, we have to create a variable sized fragment and 4433 resolve things later. */ 4434 4435 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign, 4436 make_expr_symbol (exp), 0, (char *) NULL); 4437 } 4438} 4439 4440/* Parse the .sleb128 and .uleb128 pseudos. */ 4441 4442void 4443s_leb128 (sign) 4444 int sign; 4445{ 4446 expressionS exp; 4447 4448 do 4449 { 4450 expression (&exp); 4451 emit_leb128_expr (&exp, sign); 4452 } 4453 while (*input_line_pointer++ == ','); 4454 4455 input_line_pointer--; 4456 demand_empty_rest_of_line (); 4457} 4458 4459/* We read 0 or more ',' separated, double-quoted strings. 4460 Caller should have checked need_pass_2 is FALSE because we don't 4461 check it. */ 4462 4463void 4464stringer (append_zero) /* Worker to do .ascii etc statements. */ 4465 /* Checks end-of-line. */ 4466 register int append_zero; /* 0: don't append '\0', else 1. */ 4467{ 4468 register unsigned int c; 4469 char *start; 4470 4471#ifdef md_flush_pending_output 4472 md_flush_pending_output (); 4473#endif 4474 4475 /* The following awkward logic is to parse ZERO or more strings, 4476 comma separated. Recall a string expression includes spaces 4477 before the opening '\"' and spaces after the closing '\"'. 4478 We fake a leading ',' if there is (supposed to be) 4479 a 1st, expression. We keep demanding expressions for each ','. */ 4480 if (is_it_end_of_statement ()) 4481 { 4482 c = 0; /* Skip loop. */ 4483 ++input_line_pointer; /* Compensate for end of loop. */ 4484 } 4485 else 4486 { 4487 c = ','; /* Do loop. */ 4488 } 4489 while (c == ',' || c == '<' || c == '"') 4490 { 4491 SKIP_WHITESPACE (); 4492 switch (*input_line_pointer) 4493 { 4494 case '\"': 4495 ++input_line_pointer; /*->1st char of string. */ 4496 start = input_line_pointer; 4497 while (is_a_char (c = next_char_of_string ())) 4498 { 4499 FRAG_APPEND_1_CHAR (c); 4500 } 4501 if (append_zero) 4502 { 4503 FRAG_APPEND_1_CHAR (0); 4504 } 4505 know (input_line_pointer[-1] == '\"'); 4506 4507#ifndef NO_LISTING 4508#ifdef OBJ_ELF 4509 /* In ELF, when gcc is emitting DWARF 1 debugging output, it 4510 will emit .string with a filename in the .debug section 4511 after a sequence of constants. See the comment in 4512 emit_expr for the sequence. emit_expr will set 4513 dwarf_file_string to non-zero if this string might be a 4514 source file name. */ 4515 if (strcmp (segment_name (now_seg), ".debug") != 0) 4516 dwarf_file_string = 0; 4517 else if (dwarf_file_string) 4518 { 4519 c = input_line_pointer[-1]; 4520 input_line_pointer[-1] = '\0'; 4521 listing_source_file (start); 4522 input_line_pointer[-1] = c; 4523 } 4524#endif 4525#endif 4526 4527 break; 4528 case '<': 4529 input_line_pointer++; 4530 c = get_single_number (); 4531 FRAG_APPEND_1_CHAR (c); 4532 if (*input_line_pointer != '>') 4533 { 4534 as_bad (_("Expected <nn>")); 4535 } 4536 input_line_pointer++; 4537 break; 4538 case ',': 4539 input_line_pointer++; 4540 break; 4541 } 4542 SKIP_WHITESPACE (); 4543 c = *input_line_pointer; 4544 } 4545 4546 demand_empty_rest_of_line (); 4547} /* stringer() */ 4548 4549/* FIXME-SOMEDAY: I had trouble here on characters with the 4550 high bits set. We'll probably also have trouble with 4551 multibyte chars, wide chars, etc. Also be careful about 4552 returning values bigger than 1 byte. xoxorich. */ 4553 4554unsigned int 4555next_char_of_string () 4556{ 4557 register unsigned int c; 4558 4559 c = *input_line_pointer++ & CHAR_MASK; 4560 switch (c) 4561 { 4562 case '\"': 4563 c = NOT_A_CHAR; 4564 break; 4565 4566 case '\n': 4567 as_warn (_("Unterminated string: Newline inserted.")); 4568 bump_line_counters (); 4569 break; 4570 4571#ifndef NO_STRING_ESCAPES 4572 case '\\': 4573 switch (c = *input_line_pointer++) 4574 { 4575 case 'b': 4576 c = '\b'; 4577 break; 4578 4579 case 'f': 4580 c = '\f'; 4581 break; 4582 4583 case 'n': 4584 c = '\n'; 4585 break; 4586 4587 case 'r': 4588 c = '\r'; 4589 break; 4590 4591 case 't': 4592 c = '\t'; 4593 break; 4594 4595 case 'v': 4596 c = '\013'; 4597 break; 4598 4599 case '\\': 4600 case '"': 4601 break; /* As itself. */ 4602 4603 case '0': 4604 case '1': 4605 case '2': 4606 case '3': 4607 case '4': 4608 case '5': 4609 case '6': 4610 case '7': 4611 case '8': 4612 case '9': 4613 { 4614 long number; 4615 int i; 4616 4617 for (i = 0, number = 0; 4618 isdigit (c) && i < 3; 4619 c = *input_line_pointer++, i++) 4620 { 4621 number = number * 8 + c - '0'; 4622 } 4623 4624 c = number & 0xff; 4625 } 4626 --input_line_pointer; 4627 break; 4628 4629 case 'x': 4630 case 'X': 4631 { 4632 long number; 4633 4634 number = 0; 4635 c = *input_line_pointer++; 4636 while (isxdigit (c)) 4637 { 4638 if (isdigit (c)) 4639 number = number * 16 + c - '0'; 4640 else if (isupper (c)) 4641 number = number * 16 + c - 'A' + 10; 4642 else 4643 number = number * 16 + c - 'a' + 10; 4644 c = *input_line_pointer++; 4645 } 4646 c = number & 0xff; 4647 --input_line_pointer; 4648 } 4649 break; 4650 4651 case '\n': 4652 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */ 4653 as_warn (_("Unterminated string: Newline inserted.")); 4654 c = '\n'; 4655 bump_line_counters (); 4656 break; 4657 4658 default: 4659 4660#ifdef ONLY_STANDARD_ESCAPES 4661 as_bad (_("Bad escaped character in string, '?' assumed")); 4662 c = '?'; 4663#endif /* ONLY_STANDARD_ESCAPES */ 4664 4665 break; 4666 } 4667 break; 4668#endif /* ! defined (NO_STRING_ESCAPES) */ 4669 4670 default: 4671 break; 4672 } 4673 return (c); 4674} 4675 4676static segT 4677get_segmented_expression (expP) 4678 register expressionS *expP; 4679{ 4680 register segT retval; 4681 4682 retval = expression (expP); 4683 if (expP->X_op == O_illegal 4684 || expP->X_op == O_absent 4685 || expP->X_op == O_big) 4686 { 4687 as_bad (_("expected address expression; zero assumed")); 4688 expP->X_op = O_constant; 4689 expP->X_add_number = 0; 4690 retval = absolute_section; 4691 } 4692 return retval; 4693} 4694 4695static segT 4696get_known_segmented_expression (expP) 4697 register expressionS *expP; 4698{ 4699 register segT retval; 4700 4701 if ((retval = get_segmented_expression (expP)) == undefined_section) 4702 { 4703 /* There is no easy way to extract the undefined symbol from the 4704 expression. */ 4705 if (expP->X_add_symbol != NULL 4706 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section) 4707 as_warn (_("symbol \"%s\" undefined; zero assumed"), 4708 S_GET_NAME (expP->X_add_symbol)); 4709 else 4710 as_warn (_("some symbol undefined; zero assumed")); 4711 retval = absolute_section; 4712 expP->X_op = O_constant; 4713 expP->X_add_number = 0; 4714 } 4715 know (retval == absolute_section || SEG_NORMAL (retval)); 4716 return (retval); 4717} 4718 4719offsetT 4720get_absolute_expression () 4721{ 4722 expressionS exp; 4723 4724 expression (&exp); 4725 if (exp.X_op != O_constant) 4726 { 4727 if (exp.X_op != O_absent) 4728 as_bad (_("bad or irreducible absolute expression; zero assumed")); 4729 exp.X_add_number = 0; 4730 } 4731 return exp.X_add_number; 4732} 4733 4734char /* Return terminator. */ 4735get_absolute_expression_and_terminator (val_pointer) 4736 long *val_pointer; /* Return value of expression. */ 4737{ 4738 /* FIXME: val_pointer should probably be offsetT *. */ 4739 *val_pointer = (long) get_absolute_expression (); 4740 return (*input_line_pointer++); 4741} 4742 4743/* Like demand_copy_string, but return NULL if the string contains any '\0's. 4744 Give a warning if that happens. */ 4745 4746char * 4747demand_copy_C_string (len_pointer) 4748 int *len_pointer; 4749{ 4750 register char *s; 4751 4752 if ((s = demand_copy_string (len_pointer)) != 0) 4753 { 4754 register int len; 4755 4756 for (len = *len_pointer; len > 0; len--) 4757 { 4758 if (*s == 0) 4759 { 4760 s = 0; 4761 len = 1; 4762 *len_pointer = 0; 4763 as_bad (_("This string may not contain \'\\0\'")); 4764 } 4765 } 4766 } 4767 4768 return s; 4769} 4770 4771/* Demand string, but return a safe (=private) copy of the string. 4772 Return NULL if we can't read a string here. */ 4773 4774char * 4775demand_copy_string (lenP) 4776 int *lenP; 4777{ 4778 register unsigned int c; 4779 register int len; 4780 char *retval; 4781 4782 len = 0; 4783 SKIP_WHITESPACE (); 4784 if (*input_line_pointer == '\"') 4785 { 4786 input_line_pointer++; /* Skip opening quote. */ 4787 4788 while (is_a_char (c = next_char_of_string ())) 4789 { 4790 obstack_1grow (¬es, c); 4791 len++; 4792 } 4793 /* JF this next line is so demand_copy_C_string will return a 4794 null terminated string. */ 4795 obstack_1grow (¬es, '\0'); 4796 retval = obstack_finish (¬es); 4797 } 4798 else 4799 { 4800 as_warn (_("Missing string")); 4801 retval = NULL; 4802 ignore_rest_of_line (); 4803 } 4804 *lenP = len; 4805 return (retval); 4806} 4807 4808/* In: Input_line_pointer->next character. 4809 4810 Do: Skip input_line_pointer over all whitespace. 4811 4812 Out: 1 if input_line_pointer->end-of-line. */ 4813 4814int 4815is_it_end_of_statement () 4816{ 4817 SKIP_WHITESPACE (); 4818 return (is_end_of_line[(unsigned char) *input_line_pointer]); 4819} 4820 4821void 4822equals (sym_name, reassign) 4823 char *sym_name; 4824 int reassign; 4825{ 4826 register symbolS *symbolP; /* Symbol we are working with. */ 4827 char *stop = NULL; 4828 char stopc; 4829 4830 input_line_pointer++; 4831 if (*input_line_pointer == '=') 4832 input_line_pointer++; 4833 4834 while (*input_line_pointer == ' ' || *input_line_pointer == '\t') 4835 input_line_pointer++; 4836 4837 if (flag_mri) 4838 stop = mri_comment_field (&stopc); 4839 4840 if (sym_name[0] == '.' && sym_name[1] == '\0') 4841 { 4842 /* Turn '. = mumble' into a .org mumble. */ 4843 register segT segment; 4844 expressionS exp; 4845 4846 segment = get_known_segmented_expression (&exp); 4847 if (!need_pass_2) 4848 do_org (segment, &exp, 0); 4849 } 4850 else 4851 { 4852 symbolP = symbol_find_or_make (sym_name); 4853 /* Permit register names to be redefined. */ 4854 if (!reassign 4855 && S_IS_DEFINED (symbolP) 4856 && S_GET_SEGMENT (symbolP) != reg_section) 4857 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP)); 4858 pseudo_set (symbolP); 4859 } 4860 4861 if (flag_mri) 4862 { 4863 /* Check garbage after the expression. */ 4864 ignore_rest_of_line (); 4865 mri_comment_end (stop, stopc); 4866 } 4867} 4868 4869/* .include -- include a file at this point. */ 4870 4871void 4872s_include (arg) 4873 int arg ATTRIBUTE_UNUSED; 4874{ 4875 char *filename; 4876 int i; 4877 FILE *try; 4878 char *path; 4879 4880 if (!flag_m68k_mri) 4881 { 4882 filename = demand_copy_string (&i); 4883 if (filename == NULL) 4884 { 4885 /* demand_copy_string has already printed an error and 4886 called ignore_rest_of_line. */ 4887 return; 4888 } 4889 } 4890 else 4891 { 4892 SKIP_WHITESPACE (); 4893 i = 0; 4894 while (!is_end_of_line[(unsigned char) *input_line_pointer] 4895 && *input_line_pointer != ' ' 4896 && *input_line_pointer != '\t') 4897 { 4898 obstack_1grow (¬es, *input_line_pointer); 4899 ++input_line_pointer; 4900 ++i; 4901 } 4902 4903 obstack_1grow (¬es, '\0'); 4904 filename = obstack_finish (¬es); 4905 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 4906 ++input_line_pointer; 4907 } 4908 4909 demand_empty_rest_of_line (); 4910 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ ); 4911 4912 for (i = 0; i < include_dir_count; i++) 4913 { 4914 strcpy (path, include_dirs[i]); 4915 strcat (path, "/"); 4916 strcat (path, filename); 4917 if (0 != (try = fopen (path, "r"))) 4918 { 4919 fclose (try); 4920 goto gotit; 4921 } 4922 } 4923 4924 free (path); 4925 path = filename; 4926gotit: 4927 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */ 4928 register_dependency (path); 4929 input_scrub_insert_file (path); 4930} 4931 4932void 4933add_include_dir (path) 4934 char *path; 4935{ 4936 int i; 4937 4938 if (include_dir_count == 0) 4939 { 4940 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs)); 4941 include_dirs[0] = "."; /* Current dir. */ 4942 include_dir_count = 2; 4943 } 4944 else 4945 { 4946 include_dir_count++; 4947 include_dirs = 4948 (char **) realloc (include_dirs, 4949 include_dir_count * sizeof (*include_dirs)); 4950 } 4951 4952 include_dirs[include_dir_count - 1] = path; /* New one. */ 4953 4954 i = strlen (path); 4955 if (i > include_dir_maxlen) 4956 include_dir_maxlen = i; 4957} 4958 4959/* Output debugging information to denote the source file. */ 4960 4961static void 4962generate_file_debug () 4963{ 4964 if (debug_type == DEBUG_STABS) 4965 stabs_generate_asm_file (); 4966} 4967 4968/* Output line number debugging information for the current source line. */ 4969 4970void 4971generate_lineno_debug () 4972{ 4973 switch (debug_type) 4974 { 4975 case DEBUG_UNSPECIFIED: 4976 case DEBUG_NONE: 4977 case DEBUG_DWARF: 4978 break; 4979 case DEBUG_STABS: 4980 stabs_generate_asm_lineno (); 4981 break; 4982 case DEBUG_ECOFF: 4983 ecoff_generate_asm_lineno (); 4984 break; 4985 case DEBUG_DWARF2: 4986 /* ??? We could here indicate to dwarf2dbg.c that something 4987 has changed. However, since there is additional backend 4988 support that is required (calling dwarf2_emit_insn), we 4989 let dwarf2dbg.c call as_where on its own. */ 4990 break; 4991 } 4992} 4993 4994/* Output debugging information to mark a function entry point or end point. 4995 END_P is zero for .func, and non-zero for .endfunc. */ 4996 4997void 4998s_func (end_p) 4999 int end_p; 5000{ 5001 do_s_func (end_p, NULL); 5002} 5003 5004/* Subroutine of s_func so targets can choose a different default prefix. 5005 If DEFAULT_PREFIX is NULL, use the target's "leading char". */ 5006 5007void 5008do_s_func (end_p, default_prefix) 5009 int end_p; 5010 const char *default_prefix; 5011{ 5012 /* Record the current function so that we can issue an error message for 5013 misplaced .func,.endfunc, and also so that .endfunc needs no 5014 arguments. */ 5015 static char *current_name; 5016 static char *current_label; 5017 5018 if (end_p) 5019 { 5020 if (current_name == NULL) 5021 { 5022 as_bad (_("missing .func")); 5023 ignore_rest_of_line (); 5024 return; 5025 } 5026 5027 if (debug_type == DEBUG_STABS) 5028 stabs_generate_asm_endfunc (current_name, current_label); 5029 5030 current_name = current_label = NULL; 5031 } 5032 else /* ! end_p */ 5033 { 5034 char *name, *label; 5035 char delim1, delim2; 5036 5037 if (current_name != NULL) 5038 { 5039 as_bad (_(".endfunc missing for previous .func")); 5040 ignore_rest_of_line (); 5041 return; 5042 } 5043 5044 name = input_line_pointer; 5045 delim1 = get_symbol_end (); 5046 name = xstrdup (name); 5047 *input_line_pointer = delim1; 5048 SKIP_WHITESPACE (); 5049 if (*input_line_pointer != ',') 5050 { 5051 if (default_prefix) 5052 asprintf (&label, "%s%s", default_prefix, name); 5053 else 5054 { 5055 char leading_char = 0; 5056#ifdef BFD_ASSEMBLER 5057 leading_char = bfd_get_symbol_leading_char (stdoutput); 5058#endif 5059 /* Missing entry point, use function's name with the leading 5060 char prepended. */ 5061 if (leading_char) 5062 asprintf (&label, "%c%s", leading_char, name); 5063 else 5064 label = name; 5065 } 5066 } 5067 else 5068 { 5069 ++input_line_pointer; 5070 SKIP_WHITESPACE (); 5071 label = input_line_pointer; 5072 delim2 = get_symbol_end (); 5073 label = xstrdup (label); 5074 *input_line_pointer = delim2; 5075 } 5076 5077 if (debug_type == DEBUG_STABS) 5078 stabs_generate_asm_func (name, label); 5079 5080 current_name = name; 5081 current_label = label; 5082 } 5083 5084 demand_empty_rest_of_line (); 5085} 5086 5087void 5088s_ignore (arg) 5089 int arg ATTRIBUTE_UNUSED; 5090{ 5091 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 5092 { 5093 ++input_line_pointer; 5094 } 5095 ++input_line_pointer; 5096} 5097 5098void 5099read_print_statistics (file) 5100 FILE *file; 5101{ 5102 hash_print_statistics (file, "pseudo-op table", po_hash); 5103} 5104 5105/* Inserts the given line into the input stream. 5106 5107 This call avoids macro/conditionals nesting checking, since the contents of 5108 the line are assumed to replace the contents of a line already scanned. 5109 5110 An appropriate use of this function would be substition of input lines when 5111 called by md_start_line_hook(). The given line is assumed to already be 5112 properly scrubbed. */ 5113 5114void 5115input_scrub_insert_line (line) 5116 const char *line; 5117{ 5118 sb newline; 5119 sb_new (&newline); 5120 sb_add_string (&newline, line); 5121 input_scrub_include_sb (&newline, input_line_pointer, 0); 5122 sb_kill (&newline); 5123 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5124} 5125 5126/* Insert a file into the input stream; the path must resolve to an actual 5127 file; no include path searching or dependency registering is performed. */ 5128 5129void 5130input_scrub_insert_file (path) 5131 char *path; 5132{ 5133 input_scrub_include_file (path, input_line_pointer); 5134 buffer_limit = input_scrub_next_buffer (&input_line_pointer); 5135} 5136