1 /* read.c - read a source file -
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
24 But then, GNU isn't spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.) */
26 #define MASK_CHAR ((int)(unsigned char) -1)
28 /* This is the largest known floating point format (for now). It will
29 grow when we do 4361 style flonums. */
30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
32 /* Routines that read assembler source text to build spaghetti in memory.
33 Another group of these functions is in the expr.c module. */
36 #include "safe-ctype.h"
43 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(x,y) (x == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer; /*->next char of source file to parse. */
68 #if BITS_PER_CHAR != 8
69 /* The following table is indexed by[(char)] and will break if
70 a char does not have exactly 256 states (hopefully 0:255!)! */
75 /* The m88k unfortunately uses @ as a label beginner. */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
101 /* The a29k assembler does not permits labels to start with $. */
106 /* The Delta 68k assembler permits ~ at start of label names. */
110 /* Used by is_... macros. our ctype[]. */
111 char lex_type[256] = {
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
114 0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM, /* 0123456789:;<=>? */
116 LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
118 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 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
131 Out: 1 if this character ends a line. */
132 char is_end_of_line[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 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 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string[128];
159 /* Functions private to this file. */
161 static char *buffer; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
174 /* How many are in the table. */
175 int include_dir_count;
177 /* Length of longest in table. */
178 int include_dir_maxlen = 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word *broken_words;
182 int new_broken_words;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS *mri_common_symbol;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string;
214 static void do_align (int, char *, int, int);
215 static void s_align (int, int);
216 static void s_altmacro (int);
217 static void s_bad_end (int);
218 static int hex_float (int, char *);
219 static segT get_known_segmented_expression (expressionS * expP);
220 static void pobegin (void);
221 static int get_line_sb (sb *);
222 static void generate_file_debug (void);
230 obj_read_begin_hook ();
232 /* Something close -- but not too close -- to a multiple of 1024.
233 The debugging malloc I'm using has 24 bytes of overhead. */
234 obstack_begin (¬es, chunksize);
235 obstack_begin (&cond_obstack, chunksize);
237 /* Use machine dependent syntax. */
238 for (p = line_separator_chars; *p; p++)
239 is_end_of_line[(unsigned char) *p] = 1;
240 /* Use more. FIXME-SOMEDAY. */
246 #ifndef TC_ADDRESS_BYTES
248 #define TC_ADDRESS_BYTES address_bytes
253 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
254 contain an address. */
255 int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
264 /* Set up pseudo-op tables. */
266 static struct hash_control *po_hash;
268 static const pseudo_typeS potable[] = {
269 {"abort", s_abort, 0},
270 {"align", s_align_ptwo, 0},
271 {"altmacro", s_altmacro, 1},
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},
280 {"common", s_mri_common, 0},
281 {"common.s", s_mri_common, 1},
284 #ifdef TC_ADDRESS_BYTES
288 {"dc.d", float_cons, 'd'},
290 {"dc.s", float_cons, 'f'},
292 {"dc.x", float_cons, 'x'},
294 {"dcb.b", s_space, 1},
295 {"dcb.d", s_float_space, 'd'},
296 {"dcb.l", s_space, 4},
297 {"dcb.s", s_float_space, 'f'},
298 {"dcb.w", s_space, 2},
299 {"dcb.x", s_float_space, 'x'},
301 {"ds.b", s_space, 1},
302 {"ds.d", s_space, 8},
303 {"ds.l", s_space, 4},
304 {"ds.p", s_space, 12},
305 {"ds.s", s_space, 4},
306 {"ds.w", s_space, 2},
307 {"ds.x", s_space, 12},
308 {"debug", s_ignore, 0},
313 {"double", float_cons, 'd'},
315 {"eject", listing_eject, 0}, /* Formfeed listing. */
317 {"elsec", s_else, 0},
318 {"elseif", s_elseif, (int) O_ne},
320 {"endc", s_endif, 0},
321 {"endfunc", s_func, 1},
322 {"endif", s_endif, 0},
323 {"endm", s_bad_end, 0},
324 {"endr", s_bad_end, 1},
329 {"error", s_errwarn, 1},
330 {"exitm", s_mexit, 0},
332 {"extern", s_ignore, 0}, /* We treat all undef as ext. */
333 {"appfile", s_app_file, 1},
334 {"appline", s_app_line, 0},
336 {"file", s_app_file, 0},
338 {"float", float_cons, 'f'},
339 {"format", s_ignore, 0},
341 {"global", s_globl, 0},
342 {"globl", s_globl, 0},
344 {"if", s_if, (int) O_ne},
346 {"ifdef", s_ifdef, 0},
347 {"ifeq", s_if, (int) O_eq},
348 {"ifeqs", s_ifeqs, 0},
349 {"ifge", s_if, (int) O_ge},
350 {"ifgt", s_if, (int) O_gt},
351 {"ifle", s_if, (int) O_le},
352 {"iflt", s_if, (int) O_lt},
354 {"ifndef", s_ifdef, 1},
355 {"ifne", s_if, (int) O_ne},
356 {"ifnes", s_ifeqs, 1},
357 {"ifnotdef", s_ifdef, 1},
358 {"incbin", s_incbin, 0},
359 {"include", s_include, 0},
365 {"lcomm", s_lcomm, 0},
366 {"lflags", listing_flags, 0}, /* Listing flags. */
367 {"linkonce", s_linkonce, 0},
368 {"list", listing_list, 1}, /* Turn listing on. */
369 {"llen", listing_psize, 1},
372 {"macro", s_macro, 0},
373 {"mexit", s_mexit, 0},
375 {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */
376 {"name", s_ignore, 0},
377 {"noaltmacro", s_altmacro, 0},
378 {"noformat", s_ignore, 0},
379 {"nolist", listing_list, 0}, /* Turn listing off. */
380 {"nopage", listing_nopage, 0},
382 {"offset", s_struct, 0},
384 {"p2align", s_align_ptwo, 0},
385 {"p2alignw", s_align_ptwo, -2},
386 {"p2alignl", s_align_ptwo, -4},
387 {"page", listing_eject, 0},
388 {"plen", listing_psize, 0},
389 {"print", s_print, 0},
390 {"psize", listing_psize, 0}, /* Set paper size. */
391 {"purgem", s_purgem, 0},
396 {"sbttl", listing_title, 1}, /* Subtitle of listing. */
401 {"single", float_cons, 'f'},
403 {"space", s_space, 0},
404 {"skip", s_space, 0},
405 {"sleb128", s_leb128, 1},
406 {"spc", s_ignore, 0},
407 {"stabd", s_stab, 'd'},
408 {"stabn", s_stab, 'n'},
409 {"stabs", s_stab, 's'},
410 {"string", stringer, 1},
411 {"struct", s_struct, 0},
415 /* This is for gcc to use. It's only just been added (2/94), so gcc
416 won't be able to use it for a while -- probably a year or more.
417 But once this has been released, check with gcc maintainers
418 before deleting it or even changing the spelling. */
419 {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
420 /* If we're folding case -- done for some targets, not necessarily
421 all -- the above string in an input file will be converted to
422 this one. Match it either way... */
423 {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
425 {"title", listing_title, 0}, /* Listing title. */
426 {"ttl", listing_title, 0},
428 {"uleb128", s_leb128, 0},
432 {"xdef", s_globl, 0},
433 {"xref", s_ignore, 0},
434 {"xstabs", s_xstab, 's'},
435 {"warning", s_errwarn, 0},
437 {"zero", s_space, 0},
438 {NULL, NULL, 0} /* End sentinel. */
441 static int pop_override_ok = 0;
442 static const char *pop_table_name;
445 pop_insert (const pseudo_typeS *table)
448 const pseudo_typeS *pop;
449 for (pop = table; pop->poc_name; pop++)
451 errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
452 if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
453 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
458 #ifndef md_pop_insert
459 #define md_pop_insert() pop_insert(md_pseudo_table)
462 #ifndef obj_pop_insert
463 #define obj_pop_insert() pop_insert(obj_pseudo_table)
466 #ifndef cfi_pop_insert
467 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
473 po_hash = hash_new ();
475 /* Do the target-specific pseudo ops. */
476 pop_table_name = "md";
479 /* Now object specific. Skip any that were in the target table. */
480 pop_table_name = "obj";
484 /* Now portable ones. Skip any that we've seen already. */
485 pop_table_name = "standard";
486 pop_insert (potable);
488 #ifdef TARGET_USE_CFIPOP
489 pop_table_name = "cfi";
495 #define HANDLE_CONDITIONAL_ASSEMBLY() \
496 if (ignore_input ()) \
498 while (!is_end_of_line[(unsigned char) *input_line_pointer++]) \
499 if (input_line_pointer == buffer_limit) \
504 /* This function is used when scrubbing the characters between #APP
507 static char *scrub_string;
508 static char *scrub_string_end;
511 scrub_from_string (char *buf, int buflen)
515 copy = scrub_string_end - scrub_string;
518 memcpy (buf, scrub_string, copy);
519 scrub_string += copy;
523 /* We read the file, putting things into a web that represents what we
524 have been reading. */
526 read_a_source_file (char *name)
529 register char *s; /* String of symbol, '\0' appended. */
537 buffer = input_scrub_new_file (name);
540 listing_newline (NULL);
541 register_dependency (name);
543 /* Generate debugging information before we've read anything in to denote
544 this file as the "main" source file and not a subordinate one
545 (e.g. N_SO vs N_SOL in stabs). */
546 generate_file_debug ();
548 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
549 { /* We have another line to parse. */
550 know (buffer_limit[-1] == '\n'); /* Must have a sentinel. */
552 while (input_line_pointer < buffer_limit)
554 /* We have more of this buffer to parse. */
556 /* We now have input_line_pointer->1st char of next line.
557 If input_line_pointer [-1] == '\n' then we just
558 scanned another line: so bump line counters. */
559 if (is_end_of_line[(unsigned char) input_line_pointer[-1]])
561 #ifdef md_start_line_hook
562 md_start_line_hook ();
564 if (input_line_pointer[-1] == '\n')
565 bump_line_counters ();
569 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
571 /* Text at the start of a line must be a label, we
572 run down and stick a colon in. */
573 if (is_name_beginner (*input_line_pointer))
575 char *line_start = input_line_pointer;
580 HANDLE_CONDITIONAL_ASSEMBLY ();
582 c = get_symbol_end ();
584 /* In MRI mode, the EQU and MACRO pseudoops must
585 be handled specially. */
589 char *rest = input_line_pointer + 1;
593 if (*rest == ' ' || *rest == '\t')
595 if ((strncasecmp (rest, "EQU", 3) == 0
596 || strncasecmp (rest, "SET", 3) == 0)
597 && (rest[3] == ' ' || rest[3] == '\t'))
599 input_line_pointer = rest + 3;
601 strncasecmp (rest, "SET", 3) == 0);
604 if (strncasecmp (rest, "MACRO", 5) == 0
607 || is_end_of_line[(unsigned char) rest[5]]))
611 /* In MRI mode, we need to handle the MACRO
612 pseudo-op specially: we don't want to put the
613 symbol in the symbol table. */
615 #ifdef TC_START_LABEL_WITHOUT_COLON
616 && TC_START_LABEL_WITHOUT_COLON(c,
620 line_label = colon (line_start);
622 line_label = symbol_create (line_start,
627 *input_line_pointer = c;
629 input_line_pointer++;
634 /* We are at the beginning of a line, or similar place.
635 We expect a well-formed assembler statement.
636 A "symbol-name:" is a statement.
638 Depending on what compiler is used, the order of these tests
639 may vary to catch most common case 1st.
640 Each test is independent of all other tests at the (top) level.
641 PLEASE make a compiler that doesn't use this assembler.
642 It is crufty to waste a compiler's time encoding things for this
643 assembler, which then wastes more time decoding it.
644 (And communicating via (linear) files is silly!
645 If you must pass stuff, please pass a tree!) */
646 if ((c = *input_line_pointer++) == '\t'
650 c = *input_line_pointer++;
652 know (c != ' '); /* No further leading whitespace. */
655 /* If listing is on, and we are expanding a macro, then give
656 the listing code the contents of the expanded line. */
659 if ((listing & LISTING_MACEXP) && macro_nest > 0)
664 /* Find the end of the current expanded macro line. */
665 for (s = input_line_pointer - 1; *s; ++s)
666 if (is_end_of_line[(unsigned char) *s])
669 /* Copy it for safe keeping. Also give an indication of
670 how much macro nesting is involved at this point. */
671 len = s - (input_line_pointer - 1);
672 copy = (char *) xmalloc (len + macro_nest + 2);
673 memset (copy, '>', macro_nest);
674 copy[macro_nest] = ' ';
675 memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
676 copy[macro_nest + 1 + len] = '\0';
678 /* Install the line with the listing facility. */
679 listing_newline (copy);
682 listing_newline (NULL);
685 /* C is the 1st significant character.
686 Input_line_pointer points after that character. */
687 if (is_name_beginner (c))
689 /* Want user-defined label or pseudo/opcode. */
690 HANDLE_CONDITIONAL_ASSEMBLY ();
692 s = --input_line_pointer;
693 c = get_symbol_end (); /* name's delimiter. */
695 /* C is character after symbol.
696 That character's place in the input line is now '\0'.
697 S points to the beginning of the symbol.
698 [In case of pseudo-op, s->'.'.]
699 Input_line_pointer->'\0' where c was. */
700 if (TC_START_LABEL (c, input_line_pointer))
704 char *rest = input_line_pointer + 1;
706 /* In MRI mode, \tsym: set 0 is permitted. */
710 if (*rest == ' ' || *rest == '\t')
713 if ((strncasecmp (rest, "EQU", 3) == 0
714 || strncasecmp (rest, "SET", 3) == 0)
715 && (rest[3] == ' ' || rest[3] == '\t'))
717 input_line_pointer = rest + 3;
723 line_label = colon (s); /* User-defined label. */
724 /* Put ':' back for error messages' sake. */
725 *input_line_pointer++ = ':';
726 #ifdef tc_check_label
727 tc_check_label (line_label);
729 /* Input_line_pointer->after ':'. */
733 || ((c == ' ' || c == '\t')
734 && input_line_pointer[1] == '='))
735 #ifdef TC_EQUAL_IN_INSN
736 && !TC_EQUAL_IN_INSN (c, s)
741 demand_empty_rest_of_line ();
745 /* Expect pseudo-op or machine instruction. */
748 #ifndef TC_CASE_SENSITIVE
752 strncpy (original_case_string, s2, sizeof (original_case_string));
753 original_case_string[sizeof (original_case_string) - 1] = 0;
762 if (NO_PSEUDO_DOT || flag_m68k_mri)
764 /* The MRI assembler and the m88k use pseudo-ops
766 pop = (pseudo_typeS *) hash_find (po_hash, s);
767 if (pop != NULL && pop->poc_handler == NULL)
772 || (!flag_m68k_mri && *s == '.'))
776 WARNING: c has next char, which may be end-of-line.
777 We lookup the pseudo-op table with s+1 because we
778 already know that the pseudo-op begins with a '.'. */
781 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
782 if (pop && !pop->poc_handler)
785 /* In MRI mode, we may need to insert an
786 automatic alignment directive. What a hack
788 if (mri_pending_align
790 || !((pop->poc_handler == cons
791 && pop->poc_val == 1)
792 || (pop->poc_handler == s_space
793 && pop->poc_val == 1)
794 #ifdef tc_conditional_pseudoop
795 || tc_conditional_pseudoop (pop)
797 || pop->poc_handler == s_if
798 || pop->poc_handler == s_ifdef
799 || pop->poc_handler == s_ifc
800 || pop->poc_handler == s_ifeqs
801 || pop->poc_handler == s_else
802 || pop->poc_handler == s_endif
803 || pop->poc_handler == s_globl
804 || pop->poc_handler == s_ignore)))
806 do_align (1, (char *) NULL, 0, 0);
807 mri_pending_align = 0;
809 if (line_label != NULL)
811 symbol_set_frag (line_label, frag_now);
812 S_SET_VALUE (line_label, frag_now_fix ());
816 /* Print the error msg now, while we still can. */
819 as_bad (_("unknown pseudo-op: `%s'"), s);
820 *input_line_pointer = c;
825 /* Put it back for error messages etc. */
826 *input_line_pointer = c;
827 /* The following skip of whitespace is compulsory.
828 A well shaped space is sometimes all that separates
829 keyword from operands. */
830 if (c == ' ' || c == '\t')
831 input_line_pointer++;
833 /* Input_line is restored.
834 Input_line_pointer->1st non-blank char
835 after pseudo-operation. */
836 (*pop->poc_handler) (pop->poc_val);
838 /* If that was .end, just get out now. */
839 if (pop->poc_handler == s_end)
845 #ifdef QUOTES_IN_INSN
849 /* WARNING: c has char, which may be end-of-line. */
850 /* Also: input_line_pointer->`\0` where c was. */
851 *input_line_pointer = c;
852 while (!is_end_of_line[(unsigned char) *input_line_pointer]
854 #ifdef TC_EOL_IN_INSN
855 || TC_EOL_IN_INSN (input_line_pointer)
859 if (flag_m68k_mri && *input_line_pointer == '\'')
861 #ifdef QUOTES_IN_INSN
864 else if (*input_line_pointer == '"')
866 else if (*input_line_pointer == '\\')
869 input_line_pointer++;
872 c = *input_line_pointer;
873 *input_line_pointer = '\0';
875 generate_lineno_debug ();
883 if (check_macro (s, &out, &err, ¯o))
887 *input_line_pointer++ = c;
888 input_scrub_include_sb (&out,
889 input_line_pointer, 1);
892 input_scrub_next_buffer (&input_line_pointer);
894 md_macro_info (macro);
900 if (mri_pending_align)
902 do_align (1, (char *) NULL, 0, 0);
903 mri_pending_align = 0;
904 if (line_label != NULL)
906 symbol_set_frag (line_label, frag_now);
907 S_SET_VALUE (line_label, frag_now_fix ());
911 md_assemble (s); /* Assemble 1 instruction. */
913 *input_line_pointer++ = c;
915 /* We resume loop AFTER the end-of-line from
922 /* Empty statement? */
923 if (is_end_of_line[(unsigned char) c])
926 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
928 /* local label ("4:") */
929 char *backup = input_line_pointer;
931 HANDLE_CONDITIONAL_ASSEMBLY ();
935 /* Read the whole number. */
936 while (ISDIGIT (*input_line_pointer))
938 temp = (temp * 10) + *input_line_pointer - '0';
939 ++input_line_pointer;
942 if (LOCAL_LABELS_DOLLAR
943 && *input_line_pointer == '$'
944 && *(input_line_pointer + 1) == ':')
946 input_line_pointer += 2;
948 if (dollar_label_defined (temp))
950 as_fatal (_("label \"%d$\" redefined"), temp);
953 define_dollar_label (temp);
954 colon (dollar_label_name (temp, 0));
959 && *input_line_pointer++ == ':')
961 fb_label_instance_inc (temp);
962 colon (fb_label_name (temp, 0));
966 input_line_pointer = backup;
967 } /* local label ("4:") */
969 if (c && strchr (line_comment_chars, c))
970 { /* Its a comment. Better say APP or NO_APP. */
975 unsigned int new_length;
978 bump_line_counters ();
979 s = input_line_pointer;
980 if (strncmp (s, "APP\n", 4))
981 continue; /* We ignore it */
985 ends = strstr (s, "#NO_APP\n");
989 unsigned int tmp_len;
992 /* The end of the #APP wasn't in this buffer. We
993 keep reading in buffers until we find the #NO_APP
994 that goes with this #APP There is one. The specs
996 tmp_len = buffer_limit - s;
997 tmp_buf = xmalloc (tmp_len + 1);
998 memcpy (tmp_buf, s, tmp_len);
1001 new_tmp = input_scrub_next_buffer (&buffer);
1005 buffer_limit = new_tmp;
1006 input_line_pointer = buffer;
1007 ends = strstr (buffer, "#NO_APP\n");
1009 num = ends - buffer;
1011 num = buffer_limit - buffer;
1013 tmp_buf = xrealloc (tmp_buf, tmp_len + num);
1014 memcpy (tmp_buf + tmp_len, buffer, num);
1019 input_line_pointer = ends ? ends + 8 : NULL;
1027 input_line_pointer = ends + 8;
1031 scrub_string_end = ends;
1033 new_length = ends - s;
1034 new_buf = (char *) xmalloc (new_length);
1041 space = (new_buf + new_length) - new_tmp;
1042 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1050 new_buf = xrealloc (new_buf, new_length + 100);
1051 new_tmp = new_buf + new_length;
1058 /* We've "scrubbed" input to the preferred format. In the
1059 process we may have consumed the whole of the remaining
1060 file (and included files). We handle this formatted
1061 input similar to that of macro expansion, letting
1062 actual macro expansion (possibly nested) and other
1063 input expansion work. Beware that in messages, line
1064 numbers and possibly file names will be incorrect. */
1065 sb_add_string (&sbuf, new_buf);
1066 input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1068 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1073 HANDLE_CONDITIONAL_ASSEMBLY ();
1075 #ifdef tc_unrecognized_line
1076 if (tc_unrecognized_line (c))
1079 input_line_pointer--;
1080 /* Report unknown char as ignored. */
1081 demand_empty_rest_of_line ();
1084 #ifdef md_after_pass_hook
1085 md_after_pass_hook ();
1094 /* Close the input file. */
1095 input_scrub_close ();
1096 #ifdef WARN_COMMENTS
1098 if (warn_comment && found_comment)
1099 as_warn_where (found_comment_file, found_comment,
1100 "first comment found here");
1105 /* Convert O_constant expression EXP into the equivalent O_big representation.
1106 Take the sign of the number from X_unsigned rather than X_add_number. */
1109 convert_to_bignum (expressionS *exp)
1114 value = exp->X_add_number;
1115 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1117 generic_bignum[i] = value & LITTLENUM_MASK;
1118 value >>= LITTLENUM_NUMBER_OF_BITS;
1120 /* Add a sequence of sign bits if the top bit of X_add_number is not
1121 the sign of the original value. */
1122 if ((exp->X_add_number < 0) != !exp->X_unsigned)
1123 generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1125 exp->X_add_number = i;
1128 /* For most MRI pseudo-ops, the line actually ends at the first
1129 nonquoted space. This function looks for that point, stuffs a null
1130 in, and sets *STOPCP to the character that used to be there, and
1131 returns the location.
1133 Until I hear otherwise, I am going to assume that this is only true
1134 for the m68k MRI assembler. */
1137 mri_comment_field (char *stopcp)
1143 know (flag_m68k_mri);
1145 for (s = input_line_pointer;
1146 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1154 for (s = input_line_pointer;
1155 !is_end_of_line[(unsigned char) *s];
1165 /* Skip to the end of an MRI comment field. */
1168 mri_comment_end (char *stop, int stopc)
1172 input_line_pointer = stop;
1174 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1175 ++input_line_pointer;
1179 s_abort (int ignore ATTRIBUTE_UNUSED)
1181 as_fatal (_(".abort detected. Abandoning ship."));
1184 /* Guts of .align directive. N is the power of two to which to align.
1185 FILL may be NULL, or it may point to the bytes of the fill pattern.
1186 LEN is the length of whatever FILL points to, if anything. MAX is
1187 the maximum number of characters to skip when doing the alignment,
1188 or 0 if there is no maximum. */
1191 do_align (int n, char *fill, int len, int max)
1193 if (now_seg == absolute_section)
1197 if (*fill++ != '\0')
1199 as_warn (_("ignoring fill value in absolute section"));
1206 #ifdef md_flush_pending_output
1207 md_flush_pending_output ();
1210 md_do_align (n, fill, len, max, just_record_alignment);
1213 /* Only make a frag if we HAVE to... */
1214 if (n != 0 && !need_pass_2)
1218 if (subseg_text_p (now_seg))
1219 frag_align_code (n, max);
1221 frag_align (n, 0, max);
1224 frag_align (n, *fill, max);
1226 frag_align_pattern (n, fill, len, max);
1230 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1233 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1236 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1237 (in bytes). A negative ARG is the negative of the length of the
1238 fill pattern. BYTES_P is non-zero if the alignment value should be
1239 interpreted as the byte boundary, rather than the power of 2. */
1241 #ifdef BFD_ASSEMBLER
1242 #define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1244 #define ALIGN_LIMIT 15
1248 s_align (int arg, int bytes_p)
1250 unsigned int align_limit = ALIGN_LIMIT;
1259 stop = mri_comment_field (&stopc);
1261 if (is_end_of_line[(unsigned char) *input_line_pointer])
1266 align = arg; /* Default value from pseudo-op table. */
1270 align = get_absolute_expression ();
1276 /* Convert to a power of 2. */
1281 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1284 as_bad (_("alignment not a power of 2"));
1290 if (align > align_limit)
1292 align = align_limit;
1293 as_warn (_("alignment too large: %u assumed"), align);
1296 if (*input_line_pointer != ',')
1303 ++input_line_pointer;
1304 if (*input_line_pointer == ',')
1308 fill = get_absolute_expression ();
1313 if (*input_line_pointer != ',')
1317 ++input_line_pointer;
1318 max = get_absolute_expression ();
1325 as_warn (_("expected fill pattern missing"));
1326 do_align (align, (char *) NULL, 0, max);
1341 do_align (align, &fill_char, fill_len, max);
1347 if ((size_t) fill_len > sizeof ab)
1349 md_number_to_chars (ab, fill, fill_len);
1350 do_align (align, ab, fill_len, max);
1354 demand_empty_rest_of_line ();
1357 mri_comment_end (stop, stopc);
1360 /* Handle the .align pseudo-op on machines where ".align 4" means
1361 align to a 4 byte boundary. */
1364 s_align_bytes (int arg)
1369 /* Handle the .align pseudo-op on machines where ".align 4" means align
1370 to a 2**4 boundary. */
1373 s_align_ptwo (int arg)
1378 /* Switch in and out of alternate macro mode. */
1383 demand_empty_rest_of_line ();
1384 macro_set_alternate (on);
1388 s_comm_internal (int param,
1389 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1395 symbolS *symbolP = NULL;
1401 stop = mri_comment_field (&stopc);
1403 name = input_line_pointer;
1404 c = get_symbol_end ();
1405 /* Just after name is now '\0'. */
1406 p = input_line_pointer;
1411 as_bad (_("expected symbol name"));
1412 discard_rest_of_line ();
1418 /* Accept an optional comma after the name. The comma used to be
1419 required, but Irix 5 cc does not generate it for .lcomm. */
1420 if (*input_line_pointer == ',')
1421 input_line_pointer++;
1423 temp = get_absolute_expr (&exp);
1425 #ifdef BFD_ASSEMBLER
1426 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1428 if (exp.X_op == O_absent)
1430 as_bad (_("missing size expression"));
1431 ignore_rest_of_line ();
1434 else if (temp != size || !exp.X_unsigned)
1436 as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1437 ignore_rest_of_line ();
1442 symbolP = symbol_find_or_make (name);
1443 if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
1446 as_bad (_("symbol `%s' is already defined"), name);
1448 ignore_rest_of_line ();
1452 size = S_GET_VALUE (symbolP);
1455 else if (size != temp)
1456 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1457 name, (long) size, (long) temp);
1460 if (comm_parse_extra != NULL)
1461 symbolP = (*comm_parse_extra) (param, symbolP, size);
1464 S_SET_VALUE (symbolP, (valueT) size);
1465 S_SET_EXTERNAL (symbolP);
1468 extern int flag_one;
1469 if (size == 0 || !flag_one)
1470 S_GET_OTHER (symbolP) = const_flag;
1475 know (symbolP == NULL || symbolP->sy_frag == &zero_address_frag);
1476 demand_empty_rest_of_line ();
1479 mri_comment_end (stop, stopc);
1486 s_comm_internal (ignore, NULL);
1489 /* The MRI COMMON pseudo-op. We handle this by creating a common
1490 symbol with the appropriate name. We make s_space do the right
1491 thing by increasing the size. */
1494 s_mri_common (int small ATTRIBUTE_UNUSED)
1510 stop = mri_comment_field (&stopc);
1514 name = input_line_pointer;
1515 if (!ISDIGIT (*name))
1516 c = get_symbol_end ();
1521 ++input_line_pointer;
1523 while (ISDIGIT (*input_line_pointer));
1525 c = *input_line_pointer;
1526 *input_line_pointer = '\0';
1528 if (line_label != NULL)
1530 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1531 + (input_line_pointer - name)
1533 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1538 sym = symbol_find_or_make (name);
1539 *input_line_pointer = c;
1543 if (*input_line_pointer != ',')
1547 ++input_line_pointer;
1548 align = get_absolute_expression ();
1551 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1553 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1554 ignore_rest_of_line ();
1555 mri_comment_end (stop, stopc);
1559 S_SET_EXTERNAL (sym);
1560 mri_common_symbol = sym;
1564 S_SET_ALIGN (sym, align);
1567 if (line_label != NULL)
1570 exp.X_op = O_symbol;
1571 exp.X_add_symbol = sym;
1572 exp.X_add_number = 0;
1573 symbol_set_value_expression (line_label, &exp);
1574 symbol_set_frag (line_label, &zero_address_frag);
1575 S_SET_SEGMENT (line_label, expr_section);
1578 /* FIXME: We just ignore the small argument, which distinguishes
1579 COMMON and COMMON.S. I don't know what we can do about it. */
1581 /* Ignore the type and hptype. */
1582 if (*input_line_pointer == ',')
1583 input_line_pointer += 2;
1584 if (*input_line_pointer == ',')
1585 input_line_pointer += 2;
1587 demand_empty_rest_of_line ();
1589 mri_comment_end (stop, stopc);
1593 s_data (int ignore ATTRIBUTE_UNUSED)
1598 temp = get_absolute_expression ();
1599 if (flag_readonly_data_in_text)
1601 section = text_section;
1605 section = data_section;
1607 subseg_set (section, (subsegT) temp);
1612 demand_empty_rest_of_line ();
1615 /* Handle the .appfile pseudo-op. This is automatically generated by
1616 do_scrub_chars when a preprocessor # line comment is seen with a
1617 file name. This default definition may be overridden by the object
1618 or CPU specific pseudo-ops. This function is also the default
1619 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1623 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1627 listing_source_file (file);
1629 register_dependency (file);
1631 obj_app_file (file, appfile);
1636 s_app_file (int appfile)
1641 /* Some assemblers tolerate immediately following '"'. */
1642 if ((s = demand_copy_string (&length)) != 0)
1644 /* If this is a fake .appfile, a fake newline was inserted into
1645 the buffer. Passing -2 to new_logical_line tells it to
1648 = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
1650 /* In MRI mode, the preprocessor may have inserted an extraneous
1653 && *input_line_pointer == '\''
1654 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1655 ++input_line_pointer;
1657 demand_empty_rest_of_line ();
1659 s_app_file_string (s, appfile);
1663 /* Handle the .appline pseudo-op. This is automatically generated by
1664 do_scrub_chars when a preprocessor # line comment is seen. This
1665 default definition may be overridden by the object or CPU specific
1669 s_app_line (int ignore ATTRIBUTE_UNUSED)
1673 /* The given number is that of the next line. */
1674 l = get_absolute_expression () - 1;
1676 /* Some of the back ends can't deal with non-positive line numbers.
1677 Besides, it's silly. */
1678 as_warn (_("line numbers must be positive; line number %d rejected"),
1682 new_logical_line ((char *) NULL, l);
1685 listing_source_line (l);
1688 demand_empty_rest_of_line ();
1691 /* Handle the .end pseudo-op. Actually, the real work is done in
1692 read_a_source_file. */
1695 s_end (int ignore ATTRIBUTE_UNUSED)
1699 /* The MRI assembler permits the start symbol to follow .end,
1700 but we don't support that. */
1702 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1703 && *input_line_pointer != '*'
1704 && *input_line_pointer != '!')
1705 as_warn (_("start address not supported"));
1709 /* Handle the .err pseudo-op. */
1712 s_err (int ignore ATTRIBUTE_UNUSED)
1714 as_bad (_(".err encountered"));
1715 demand_empty_rest_of_line ();
1718 /* Handle the .error and .warning pseudo-ops. */
1724 /* The purpose for the conditional assignment is not to
1725 internationalize the directive itself, but that we need a
1726 self-contained message, one that can be passed like the
1727 demand_copy_C_string return value, and with no assumption on the
1728 location of the name of the directive within the message. */
1730 = (err ? _(".error directive invoked in source file")
1731 : _(".warning directive invoked in source file"));
1733 if (!is_it_end_of_statement ())
1735 if (*input_line_pointer != '\"')
1737 as_bad (_("%s argument must be a string"),
1738 err ? ".error" : ".warning");
1739 discard_rest_of_line ();
1743 msg = demand_copy_C_string (&len);
1751 as_warn ("%s", msg);
1752 demand_empty_rest_of_line ();
1755 /* Handle the MRI fail pseudo-op. */
1758 s_fail (int ignore ATTRIBUTE_UNUSED)
1765 stop = mri_comment_field (&stopc);
1767 temp = get_absolute_expression ();
1769 as_warn (_(".fail %ld encountered"), (long) temp);
1771 as_bad (_(".fail %ld encountered"), (long) temp);
1773 demand_empty_rest_of_line ();
1776 mri_comment_end (stop, stopc);
1780 s_fill (int ignore ATTRIBUTE_UNUSED)
1782 expressionS rep_exp;
1784 register long fill = 0;
1787 #ifdef md_flush_pending_output
1788 md_flush_pending_output ();
1791 get_known_segmented_expression (&rep_exp);
1792 if (*input_line_pointer == ',')
1794 input_line_pointer++;
1795 size = get_absolute_expression ();
1796 if (*input_line_pointer == ',')
1798 input_line_pointer++;
1799 fill = get_absolute_expression ();
1803 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1804 #define BSD_FILL_SIZE_CROCK_8 (8)
1805 if (size > BSD_FILL_SIZE_CROCK_8)
1807 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1808 size = BSD_FILL_SIZE_CROCK_8;
1812 as_warn (_("size negative; .fill ignored"));
1815 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1817 if (rep_exp.X_add_number < 0)
1818 as_warn (_("repeat < 0; .fill ignored"));
1822 if (size && !need_pass_2)
1824 if (rep_exp.X_op == O_constant)
1826 p = frag_var (rs_fill, (int) size, (int) size,
1827 (relax_substateT) 0, (symbolS *) 0,
1828 (offsetT) rep_exp.X_add_number,
1833 /* We don't have a constant repeat count, so we can't use
1834 rs_fill. We can get the same results out of rs_space,
1835 but its argument is in bytes, so we must multiply the
1836 repeat count by size. */
1839 rep_sym = make_expr_symbol (&rep_exp);
1842 expressionS size_exp;
1843 size_exp.X_op = O_constant;
1844 size_exp.X_add_number = size;
1846 rep_exp.X_op = O_multiply;
1847 rep_exp.X_add_symbol = rep_sym;
1848 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1849 rep_exp.X_add_number = 0;
1850 rep_sym = make_expr_symbol (&rep_exp);
1853 p = frag_var (rs_space, (int) size, (int) size,
1854 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1857 memset (p, 0, (unsigned int) size);
1859 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1860 flavoured AS. The following bizarre behaviour is to be
1861 compatible with above. I guess they tried to take up to 8
1862 bytes from a 4-byte expression and they forgot to sign
1864 #define BSD_FILL_SIZE_CROCK_4 (4)
1865 md_number_to_chars (p, (valueT) fill,
1866 (size > BSD_FILL_SIZE_CROCK_4
1867 ? BSD_FILL_SIZE_CROCK_4
1869 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1870 but emits no error message because it seems a legal thing to do.
1871 It is a degenerate case of .fill but could be emitted by a
1874 demand_empty_rest_of_line ();
1878 s_globl (int ignore ATTRIBUTE_UNUSED)
1887 stop = mri_comment_field (&stopc);
1891 name = input_line_pointer;
1892 c = get_symbol_end ();
1893 symbolP = symbol_find_or_make (name);
1894 S_SET_EXTERNAL (symbolP);
1896 *input_line_pointer = c;
1898 c = *input_line_pointer;
1901 input_line_pointer++;
1903 if (is_end_of_line[(unsigned char) *input_line_pointer])
1909 demand_empty_rest_of_line ();
1912 mri_comment_end (stop, stopc);
1915 /* Handle the MRI IRP and IRPC pseudo-ops. */
1926 as_where (&file, &line);
1929 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1930 sb_add_char (&s, *input_line_pointer++);
1934 err = expand_irp (irpc, 0, &s, &out, get_line_sb);
1936 as_bad_where (file, line, "%s", err);
1940 input_scrub_include_sb (&out, input_line_pointer, 1);
1942 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1945 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1946 the section to only be linked once. However, this is not supported
1947 by most object file formats. This takes an optional argument,
1948 which is what to do about duplicates. */
1951 s_linkonce (int ignore ATTRIBUTE_UNUSED)
1953 enum linkonce_type type;
1957 type = LINKONCE_DISCARD;
1959 if (!is_end_of_line[(unsigned char) *input_line_pointer])
1964 s = input_line_pointer;
1965 c = get_symbol_end ();
1966 if (strcasecmp (s, "discard") == 0)
1967 type = LINKONCE_DISCARD;
1968 else if (strcasecmp (s, "one_only") == 0)
1969 type = LINKONCE_ONE_ONLY;
1970 else if (strcasecmp (s, "same_size") == 0)
1971 type = LINKONCE_SAME_SIZE;
1972 else if (strcasecmp (s, "same_contents") == 0)
1973 type = LINKONCE_SAME_CONTENTS;
1975 as_warn (_("unrecognized .linkonce type `%s'"), s);
1977 *input_line_pointer = c;
1980 #ifdef obj_handle_link_once
1981 obj_handle_link_once (type);
1982 #else /* ! defined (obj_handle_link_once) */
1983 #ifdef BFD_ASSEMBLER
1987 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
1988 as_warn (_(".linkonce is not supported for this object file format"));
1990 flags = bfd_get_section_flags (stdoutput, now_seg);
1991 flags |= SEC_LINK_ONCE;
1996 case LINKONCE_DISCARD:
1997 flags |= SEC_LINK_DUPLICATES_DISCARD;
1999 case LINKONCE_ONE_ONLY:
2000 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2002 case LINKONCE_SAME_SIZE:
2003 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2005 case LINKONCE_SAME_CONTENTS:
2006 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2009 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2010 as_bad (_("bfd_set_section_flags: %s"),
2011 bfd_errmsg (bfd_get_error ()));
2013 #else /* ! defined (BFD_ASSEMBLER) */
2014 as_warn (_(".linkonce is not supported for this object file format"));
2015 #endif /* ! defined (BFD_ASSEMBLER) */
2016 #endif /* ! defined (obj_handle_link_once) */
2018 demand_empty_rest_of_line ();
2022 bss_alloc (symbolS *symbolP, addressT size, int align)
2025 segT current_seg = now_seg;
2026 subsegT current_subseg = now_subseg;
2027 segT bss_seg = bss_section;
2029 #if defined (TC_MIPS) || defined (TC_ALPHA)
2030 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2031 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2033 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2034 if (size <= bfd_get_gp_size (stdoutput))
2036 bss_seg = subseg_new (".sbss", 1);
2037 seg_info (bss_seg)->bss = 1;
2038 #ifdef BFD_ASSEMBLER
2039 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2040 as_warn (_("error setting flags for \".sbss\": %s"),
2041 bfd_errmsg (bfd_get_error ()));
2046 subseg_set (bss_seg, 1);
2050 record_alignment (bss_seg, align);
2051 frag_align (align, 0, 0);
2054 /* Detach from old frag. */
2055 if (S_GET_SEGMENT (symbolP) == bss_seg)
2056 symbol_get_frag (symbolP)->fr_symbol = NULL;
2058 symbol_set_frag (symbolP, frag_now);
2059 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2063 S_SET_SIZE (symbolP, size);
2065 S_SET_SEGMENT (symbolP, bss_seg);
2068 /* The symbol may already have been created with a preceding
2069 ".globl" directive -- be careful not to step on storage class
2070 in that case. Otherwise, set it to static. */
2071 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2072 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2073 #endif /* OBJ_COFF */
2075 subseg_set (current_seg, current_subseg);
2079 parse_align (int align_bytes)
2085 if (*input_line_pointer != ',')
2088 as_bad (_("expected alignment after size"));
2089 ignore_rest_of_line ();
2093 input_line_pointer++;
2096 align = get_absolute_expr (&exp);
2097 if (exp.X_op == O_absent)
2100 if (!exp.X_unsigned)
2102 as_warn (_("alignment negative; 0 assumed"));
2106 if (align_bytes && align != 0)
2108 /* convert to a power of 2 alignment */
2109 unsigned int alignp2 = 0;
2110 while ((align & 1) == 0)
2111 align >>= 1, ++alignp2;
2114 as_bad (_("alignment not a power of 2"));
2115 ignore_rest_of_line ();
2123 /* Called from s_comm_internal after symbol name and size have been
2124 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2125 1 if this was a ".bss" directive which has a 3rd argument
2126 (alignment as a power of 2), or 2 if this was a ".bss" directive
2127 with alignment in bytes. */
2130 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2136 align = parse_align (needs_align - 1);
2137 if (align == (addressT) -1)
2141 /* Assume some objects may require alignment on some systems. */
2142 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2144 bss_alloc (symbolP, size, align);
2149 s_lcomm (int needs_align)
2151 s_comm_internal (needs_align, s_lcomm_internal);
2155 s_lcomm_bytes (int needs_align)
2157 s_comm_internal (needs_align * 2, s_lcomm_internal);
2161 s_lsym (int ignore ATTRIBUTE_UNUSED)
2163 register char *name;
2167 register symbolS *symbolP;
2169 /* We permit ANY defined expression: BSD4.2 demands constants. */
2170 name = input_line_pointer;
2171 c = get_symbol_end ();
2172 p = input_line_pointer;
2177 as_bad (_("expected symbol name"));
2178 discard_rest_of_line ();
2184 if (*input_line_pointer != ',')
2187 as_bad (_("expected comma after \"%s\""), name);
2189 ignore_rest_of_line ();
2193 input_line_pointer++;
2196 if (exp.X_op != O_constant
2197 && exp.X_op != O_register)
2199 as_bad (_("bad expression"));
2200 ignore_rest_of_line ();
2205 symbolP = symbol_find_or_make (name);
2207 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2208 symbolP->sy_desc == 0) out of this test because coff doesn't have
2209 those fields, and I can't see when they'd ever be tripped. I
2210 don't think I understand why they were here so I may have
2211 introduced a bug. As recently as 1.37 didn't have this test
2212 anyway. xoxorich. */
2214 if (S_GET_SEGMENT (symbolP) == undefined_section
2215 && S_GET_VALUE (symbolP) == 0)
2217 /* The name might be an undefined .global symbol; be sure to
2218 keep the "external" bit. */
2219 S_SET_SEGMENT (symbolP,
2220 (exp.X_op == O_constant
2223 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2227 as_bad (_("symbol `%s' is already defined"), name);
2231 demand_empty_rest_of_line ();
2234 /* Read a line into an sb. Returns the character that ended the line
2235 or zero if there are no more lines. */
2238 get_line_sb (sb *line)
2240 char quote1, quote2, inquote;
2243 if (input_line_pointer[-1] == '\n')
2244 bump_line_counters ();
2246 if (input_line_pointer >= buffer_limit)
2248 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2249 if (buffer_limit == 0)
2253 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2254 code needs to be changed. */
2263 #ifdef LEX_IS_STRINGQUOTE
2269 while ((c = * input_line_pointer ++) != 0
2270 && (!is_end_of_line[c]
2271 || (inquote != '\0' && c != '\n')))
2275 else if (inquote == '\0')
2279 else if (c == quote2)
2283 sb_add_char (line, c);
2286 /* Don't skip multiple end-of-line characters, because that breaks support
2287 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2288 characters but isn't. Instead just skip one end of line character and
2289 return the character skipped so that the caller can re-insert it if
2294 /* Define a macro. This is an interface to macro.c. */
2297 s_macro (int ignore ATTRIBUTE_UNUSED)
2306 as_where (&file, &line);
2309 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2310 sb_add_char (&s, *input_line_pointer++);
2313 if (line_label != NULL)
2314 sb_add_string (&label, S_GET_NAME (line_label));
2316 err = define_macro (0, &s, &label, get_line_sb, &name);
2318 as_bad_where (file, line, "%s", err);
2321 if (line_label != NULL)
2323 S_SET_SEGMENT (line_label, undefined_section);
2324 S_SET_VALUE (line_label, 0);
2325 symbol_set_frag (line_label, &zero_address_frag);
2328 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2329 && hash_find (po_hash, name) != NULL)
2332 && hash_find (po_hash, name + 1) != NULL))
2333 as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2340 /* Handle the .mexit pseudo-op, which immediately exits a macro
2344 s_mexit (int ignore ATTRIBUTE_UNUSED)
2346 cond_exit_macro (macro_nest);
2347 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2350 /* Switch in and out of MRI mode. */
2353 s_mri (int ignore ATTRIBUTE_UNUSED)
2357 on = get_absolute_expression ();
2358 old_flag = flag_mri;
2376 /* Operator precedence changes in m68k MRI mode, so we need to
2377 update the operator rankings. */
2378 expr_set_precedence ();
2380 #ifdef MRI_MODE_CHANGE
2382 MRI_MODE_CHANGE (on);
2385 demand_empty_rest_of_line ();
2388 /* Handle changing the location counter. */
2391 do_org (segT segment, expressionS *exp, int fill)
2393 if (segment != now_seg && segment != absolute_section)
2394 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2396 if (now_seg == absolute_section)
2399 as_warn (_("ignoring fill value in absolute section"));
2400 if (exp->X_op != O_constant)
2402 as_bad (_("only constant offsets supported in absolute section"));
2403 exp->X_add_number = 0;
2405 abs_section_offset = exp->X_add_number;
2410 symbolS *sym = exp->X_add_symbol;
2411 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2413 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2415 /* Handle complex expressions. */
2416 sym = make_expr_symbol (exp);
2420 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2426 s_org (int ignore ATTRIBUTE_UNUSED)
2428 register segT segment;
2430 register long temp_fill;
2432 #ifdef md_flush_pending_output
2433 md_flush_pending_output ();
2436 /* The m68k MRI assembler has a different meaning for .org. It
2437 means to create an absolute section at a given address. We can't
2438 support that--use a linker script instead. */
2441 as_bad (_("MRI style ORG pseudo-op not supported"));
2442 ignore_rest_of_line ();
2446 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2447 thing as a sub-segment-relative origin. Any absolute origin is
2448 given a warning, then assumed to be segment-relative. Any
2449 segmented origin expression ("foo+42") had better be in the right
2450 segment or the .org is ignored.
2452 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2453 we never know sub-segment sizes when we are reading code. BSD
2454 will crash trying to emit negative numbers of filler bytes in
2455 certain .orgs. We don't crash, but see as-write for that code.
2457 Don't make frag if need_pass_2==1. */
2458 segment = get_known_segmented_expression (&exp);
2459 if (*input_line_pointer == ',')
2461 input_line_pointer++;
2462 temp_fill = get_absolute_expression ();
2468 do_org (segment, &exp, temp_fill);
2470 demand_empty_rest_of_line ();
2473 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2474 called by the obj-format routine which handles section changing
2475 when in MRI mode. It will create a new section, and return it. It
2476 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2477 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2478 flags will be set in the section. */
2481 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2491 name = input_line_pointer;
2492 if (!ISDIGIT (*name))
2493 c = get_symbol_end ();
2498 ++input_line_pointer;
2500 while (ISDIGIT (*input_line_pointer));
2502 c = *input_line_pointer;
2503 *input_line_pointer = '\0';
2506 name = xstrdup (name);
2508 *input_line_pointer = c;
2510 seg = subseg_new (name, 0);
2512 if (*input_line_pointer == ',')
2516 ++input_line_pointer;
2517 align = get_absolute_expression ();
2518 record_alignment (seg, align);
2522 if (*input_line_pointer == ',')
2524 c = *++input_line_pointer;
2526 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2529 as_bad (_("unrecognized section type"));
2530 ++input_line_pointer;
2532 #ifdef BFD_ASSEMBLER
2536 flags = SEC_NO_FLAGS;
2538 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2539 else if (*type == 'D' || *type == 'M')
2540 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2541 else if (*type == 'R')
2542 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2543 if (flags != SEC_NO_FLAGS)
2545 if (!bfd_set_section_flags (stdoutput, seg, flags))
2546 as_warn (_("error setting flags for \"%s\": %s"),
2547 bfd_section_name (stdoutput, seg),
2548 bfd_errmsg (bfd_get_error ()));
2554 /* Ignore the HP type. */
2555 if (*input_line_pointer == ',')
2556 input_line_pointer += 2;
2558 demand_empty_rest_of_line ();
2560 #else /* ! TC_M68K */
2569 name = input_line_pointer;
2570 c = get_symbol_end ();
2572 name = xstrdup (name);
2574 *input_line_pointer = c;
2576 seg = subseg_new (name, 0);
2578 if (*input_line_pointer != ',')
2584 ++input_line_pointer;
2586 sectype = input_line_pointer;
2587 c = get_symbol_end ();
2588 if (*sectype == '\0')
2590 else if (strcasecmp (sectype, "text") == 0)
2592 else if (strcasecmp (sectype, "data") == 0)
2594 else if (strcasecmp (sectype, "romdata") == 0)
2597 as_warn (_("unrecognized section type `%s'"), sectype);
2598 *input_line_pointer = c;
2601 if (*input_line_pointer == ',')
2605 ++input_line_pointer;
2607 seccmd = input_line_pointer;
2608 c = get_symbol_end ();
2609 if (strcasecmp (seccmd, "absolute") == 0)
2611 as_bad (_("absolute sections are not supported"));
2612 *input_line_pointer = c;
2613 ignore_rest_of_line ();
2616 else if (strcasecmp (seccmd, "align") == 0)
2620 *input_line_pointer = c;
2621 align = get_absolute_expression ();
2622 record_alignment (seg, align);
2626 as_warn (_("unrecognized section command `%s'"), seccmd);
2627 *input_line_pointer = c;
2631 demand_empty_rest_of_line ();
2633 #else /* ! TC_I960 */
2634 /* The MRI assembler seems to use different forms of .sect for
2635 different targets. */
2636 as_bad ("MRI mode not supported for this target");
2637 ignore_rest_of_line ();
2638 #endif /* ! TC_I960 */
2639 #endif /* ! TC_M68K */
2642 /* Handle the .print pseudo-op. */
2645 s_print (int ignore ATTRIBUTE_UNUSED)
2650 s = demand_copy_C_string (&len);
2653 demand_empty_rest_of_line ();
2656 /* Handle the .purgem pseudo-op. */
2659 s_purgem (int ignore ATTRIBUTE_UNUSED)
2661 if (is_it_end_of_statement ())
2663 demand_empty_rest_of_line ();
2673 name = input_line_pointer;
2674 c = get_symbol_end ();
2675 delete_macro (name);
2676 *input_line_pointer = c;
2679 while (*input_line_pointer++ == ',');
2681 --input_line_pointer;
2682 demand_empty_rest_of_line ();
2685 /* Handle the .endm/.endr pseudo-ops. */
2688 s_bad_end (int endr)
2690 as_warn (_(".end%c encountered without preceeding %s"),
2692 endr ? ".rept, .irp, or .irpc" : ".macro");
2693 demand_empty_rest_of_line ();
2696 /* Handle the .rept pseudo-op. */
2699 s_rept (int ignore ATTRIBUTE_UNUSED)
2703 count = get_absolute_expression ();
2705 do_repeat (count, "REPT", "ENDR");
2708 /* This function provides a generic repeat block implementation. It allows
2709 different directives to be used as the start/end keys. */
2712 do_repeat (int count, const char *start, const char *end)
2718 if (!buffer_and_nest (start, end, &one, get_line_sb))
2720 as_bad (_("%s without %s"), start, end);
2726 sb_add_sb (&many, &one);
2730 input_scrub_include_sb (&many, input_line_pointer, 1);
2732 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2735 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2736 input buffers to skip. Assumes that conditionals preceding the loop end
2737 are properly nested.
2739 This function makes it easier to implement a premature "break" out of the
2740 loop. The EXTRA arg accounts for other buffers we might have inserted,
2741 such as line substitutions. */
2744 end_repeat (int extra)
2746 cond_exit_macro (macro_nest);
2747 while (extra-- >= 0)
2748 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2751 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2752 this is .equiv, and it is an error if the symbol is already
2758 register char *name;
2759 register char delim;
2760 register char *end_name;
2761 register symbolS *symbolP;
2763 /* Especial apologies for the random logic:
2764 this just grew, and could be parsed much more simply!
2766 name = input_line_pointer;
2767 delim = get_symbol_end ();
2768 end_name = input_line_pointer;
2771 if (name == end_name)
2773 as_bad (_("expected symbol name"));
2774 discard_rest_of_line ();
2780 if (*input_line_pointer != ',')
2783 as_bad (_("expected comma after \"%s\""), name);
2785 ignore_rest_of_line ();
2789 input_line_pointer++;
2792 if (name[0] == '.' && name[1] == '\0')
2794 /* Turn '. = mumble' into a .org mumble. */
2795 register segT segment;
2798 segment = get_known_segmented_expression (&exp);
2801 do_org (segment, &exp, 0);
2807 if ((symbolP = symbol_find (name)) == NULL
2808 && (symbolP = md_undefined_symbol (name)) == NULL)
2811 /* When doing symbol listings, play games with dummy fragments living
2812 outside the normal fragment chain to record the file and line info
2814 if (listing & LISTING_SYMBOLS)
2816 extern struct list_info_struct *listing_tail;
2817 fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
2818 memset (dummy_frag, 0, sizeof (fragS));
2819 dummy_frag->fr_type = rs_fill;
2820 dummy_frag->line = listing_tail;
2821 symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2822 dummy_frag->fr_symbol = symbolP;
2826 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2829 /* "set" symbols are local unless otherwise specified. */
2830 SF_SET_LOCAL (symbolP);
2831 #endif /* OBJ_COFF */
2834 symbol_table_insert (symbolP);
2839 && S_IS_DEFINED (symbolP)
2840 && S_GET_SEGMENT (symbolP) != reg_section)
2841 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
2843 pseudo_set (symbolP);
2844 demand_empty_rest_of_line ();
2857 #ifdef md_flush_pending_output
2858 md_flush_pending_output ();
2862 stop = mri_comment_field (&stopc);
2864 /* In m68k MRI mode, we need to align to a word boundary, unless
2866 if (flag_m68k_mri && mult > 1)
2868 if (now_seg == absolute_section)
2870 abs_section_offset += abs_section_offset & 1;
2871 if (line_label != NULL)
2872 S_SET_VALUE (line_label, abs_section_offset);
2874 else if (mri_common_symbol != NULL)
2878 val = S_GET_VALUE (mri_common_symbol);
2881 S_SET_VALUE (mri_common_symbol, val + 1);
2882 if (line_label != NULL)
2884 expressionS *symexp;
2886 symexp = symbol_get_value_expression (line_label);
2887 know (symexp->X_op == O_symbol);
2888 know (symexp->X_add_symbol == mri_common_symbol);
2889 symexp->X_add_number += 1;
2895 do_align (1, (char *) NULL, 0, 0);
2896 if (line_label != NULL)
2898 symbol_set_frag (line_label, frag_now);
2899 S_SET_VALUE (line_label, frag_now_fix ());
2909 if (*input_line_pointer == ',')
2911 ++input_line_pointer;
2916 val.X_op = O_constant;
2917 val.X_add_number = 0;
2920 if (val.X_op != O_constant
2921 || val.X_add_number < - 0x80
2922 || val.X_add_number > 0xff
2923 || (mult != 0 && mult != 1 && val.X_add_number != 0))
2925 if (exp.X_op != O_constant)
2926 as_bad (_("unsupported variable size or fill value"));
2933 bytes = mult * exp.X_add_number;
2934 for (i = 0; i < exp.X_add_number; i++)
2935 emit_expr (&val, mult);
2940 if (exp.X_op == O_constant)
2944 repeat = exp.X_add_number;
2951 as_warn (_(".space repeat count is zero, ignored"));
2952 else if (repeat < 0)
2953 as_warn (_(".space repeat count is negative, ignored"));
2957 /* If we are in the absolute section, just bump the offset. */
2958 if (now_seg == absolute_section)
2960 abs_section_offset += repeat;
2964 /* If we are secretly in an MRI common section, then
2965 creating space just increases the size of the common
2967 if (mri_common_symbol != NULL)
2969 S_SET_VALUE (mri_common_symbol,
2970 S_GET_VALUE (mri_common_symbol) + repeat);
2975 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2976 (offsetT) repeat, (char *) 0);
2980 if (now_seg == absolute_section)
2982 as_bad (_("space allocation too complex in absolute section"));
2983 subseg_set (text_section, 0);
2986 if (mri_common_symbol != NULL)
2988 as_bad (_("space allocation too complex in common section"));
2989 mri_common_symbol = NULL;
2993 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2994 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
2998 *p = val.X_add_number;
3003 /* In MRI mode, after an odd number of bytes, we must align to an
3004 even word boundary, unless the next instruction is a dc.b, ds.b
3006 if (flag_mri && (bytes & 1) != 0)
3007 mri_pending_align = 1;
3009 demand_empty_rest_of_line ();
3012 mri_comment_end (stop, stopc);
3015 /* This is like s_space, but the value is a floating point number with
3016 the given precision. This is for the MRI dcb.s pseudo-op and
3020 s_float_space (int float_type)
3024 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3029 stop = mri_comment_field (&stopc);
3031 count = get_absolute_expression ();
3034 if (*input_line_pointer != ',')
3036 as_bad (_("missing value"));
3037 ignore_rest_of_line ();
3039 mri_comment_end (stop, stopc);
3043 ++input_line_pointer;
3047 /* Skip any 0{letter} that may be present. Don't even check if the
3048 * letter is legal. */
3049 if (input_line_pointer[0] == '0'
3050 && ISALPHA (input_line_pointer[1]))
3051 input_line_pointer += 2;
3053 /* Accept :xxxx, where the x's are hex digits, for a floating point
3054 with the exact digits specified. */
3055 if (input_line_pointer[0] == ':')
3057 flen = hex_float (float_type, temp);
3060 ignore_rest_of_line ();
3062 mri_comment_end (stop, stopc);
3070 err = md_atof (float_type, temp, &flen);
3071 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3075 as_bad (_("bad floating literal: %s"), err);
3076 ignore_rest_of_line ();
3078 mri_comment_end (stop, stopc);
3083 while (--count >= 0)
3087 p = frag_more (flen);
3088 memcpy (p, temp, (unsigned int) flen);
3091 demand_empty_rest_of_line ();
3094 mri_comment_end (stop, stopc);
3097 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3100 s_struct (int ignore ATTRIBUTE_UNUSED)
3106 stop = mri_comment_field (&stopc);
3107 abs_section_offset = get_absolute_expression ();
3108 subseg_set (absolute_section, 0);
3109 demand_empty_rest_of_line ();
3111 mri_comment_end (stop, stopc);
3115 s_text (int ignore ATTRIBUTE_UNUSED)
3119 temp = get_absolute_expression ();
3120 subseg_set (text_section, (subsegT) temp);
3121 demand_empty_rest_of_line ();
3123 const_flag &= ~IN_DEFAULT_SECTION;
3128 /* Verify that we are at the end of a line. If not, issue an error and
3132 demand_empty_rest_of_line (void)
3135 if (is_end_of_line[(unsigned char) *input_line_pointer])
3136 input_line_pointer++;
3139 if (ISPRINT (*input_line_pointer))
3140 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3141 *input_line_pointer);
3143 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3144 *input_line_pointer);
3145 ignore_rest_of_line ();
3148 /* Return pointing just after end-of-line. */
3149 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3152 /* Silently advance to the end of line. Use this after already having
3153 issued an error about something bad. */
3156 ignore_rest_of_line (void)
3158 while (input_line_pointer < buffer_limit
3159 && !is_end_of_line[(unsigned char) *input_line_pointer])
3160 input_line_pointer++;
3162 input_line_pointer++;
3164 /* Return pointing just after end-of-line. */
3165 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3169 discard_rest_of_line (void)
3171 while (input_line_pointer < buffer_limit
3172 && !is_end_of_line[(unsigned char) *input_line_pointer])
3173 input_line_pointer++;
3175 input_line_pointer++;
3177 /* Return pointing just after end-of-line. */
3178 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3181 /* In: Pointer to a symbol.
3182 Input_line_pointer->expression.
3184 Out: Input_line_pointer->just after any whitespace after expression.
3185 Tried to set symbol to value of expression.
3186 Will change symbols type, value, and frag; */
3189 pseudo_set (symbolS *symbolP)
3192 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3194 #endif /* OBJ_AOUT or OBJ_BOUT */
3196 know (symbolP); /* NULL pointer is logic error. */
3197 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3198 ext = S_IS_EXTERNAL (symbolP);
3199 #endif /* OBJ_AOUT or OBJ_BOUT */
3201 (void) expression (&exp);
3203 if (exp.X_op == O_illegal)
3204 as_bad (_("illegal expression"));
3205 else if (exp.X_op == O_absent)
3206 as_bad (_("missing expression"));
3207 else if (exp.X_op == O_big)
3209 if (exp.X_add_number > 0)
3210 as_bad (_("bignum invalid"));
3212 as_bad (_("floating point number invalid"));
3214 else if (exp.X_op == O_subtract
3215 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3216 && (symbol_get_frag (exp.X_add_symbol)
3217 == symbol_get_frag (exp.X_op_symbol)))
3219 exp.X_op = O_constant;
3220 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3221 - S_GET_VALUE (exp.X_op_symbol));
3229 exp.X_add_number = 0;
3232 S_SET_SEGMENT (symbolP, absolute_section);
3233 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3235 S_SET_EXTERNAL (symbolP);
3237 S_CLEAR_EXTERNAL (symbolP);
3238 #endif /* OBJ_AOUT or OBJ_BOUT */
3239 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3240 if (exp.X_op != O_constant)
3241 symbol_set_frag (symbolP, &zero_address_frag);
3245 S_SET_SEGMENT (symbolP, reg_section);
3246 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3247 symbol_set_frag (symbolP, &zero_address_frag);
3251 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3252 || exp.X_add_number != 0)
3253 symbol_set_value_expression (symbolP, &exp);
3254 else if (symbol_section_p (symbolP))
3255 as_bad ("attempt to set value of section symbol");
3258 symbolS *s = exp.X_add_symbol;
3260 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3261 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3263 S_SET_EXTERNAL (symbolP);
3265 S_CLEAR_EXTERNAL (symbolP);
3266 #endif /* OBJ_AOUT or OBJ_BOUT */
3267 S_SET_VALUE (symbolP,
3268 exp.X_add_number + S_GET_VALUE (s));
3269 symbol_set_frag (symbolP, symbol_get_frag (s));
3270 copy_symbol_attributes (symbolP, s);
3275 /* The value is some complex expression.
3276 FIXME: Should we set the segment to anything? */
3277 symbol_set_value_expression (symbolP, &exp);
3284 CONStruct more frag of .bytes, or .words etc.
3285 Should need_pass_2 be 1 then emit no frag(s).
3286 This understands EXPRESSIONS.
3290 This has a split personality. We use expression() to read the
3291 value. We can detect if the value won't fit in a byte or word.
3292 But we can't detect if expression() discarded significant digits
3293 in the case of a long. Not worth the crocks required to fix it. */
3295 /* Select a parser for cons expressions. */
3297 /* Some targets need to parse the expression in various fancy ways.
3298 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3299 (for example, the HPPA does this). Otherwise, you can define
3300 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3301 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3302 are defined, which is the normal case, then only simple expressions
3307 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3310 #ifndef TC_PARSE_CONS_EXPRESSION
3311 #ifdef BITFIELD_CONS_EXPRESSIONS
3312 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3314 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3316 #ifdef REPEAT_CONS_EXPRESSIONS
3317 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3319 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3322 /* If we haven't gotten one yet, just call expression. */
3323 #ifndef TC_PARSE_CONS_EXPRESSION
3324 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3329 do_parse_cons_expression (expressionS *exp,
3330 int nbytes ATTRIBUTE_UNUSED)
3332 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3336 /* Worker to do .byte etc statements.
3337 Clobbers input_line_pointer and checks end-of-line. */
3340 cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3348 #ifdef md_flush_pending_output
3349 md_flush_pending_output ();
3353 stop = mri_comment_field (&stopc);
3355 if (is_it_end_of_statement ())
3357 demand_empty_rest_of_line ();
3359 mri_comment_end (stop, stopc);
3363 #ifdef TC_ADDRESS_BYTES
3365 nbytes = TC_ADDRESS_BYTES ();
3368 #ifdef md_cons_align
3369 md_cons_align (nbytes);
3377 parse_mri_cons (&exp, (unsigned int) nbytes);
3380 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3384 if (exp.X_op == O_symbol)
3385 exp.X_op = O_symbol_rva;
3387 as_fatal (_("rva without symbol"));
3389 emit_expr (&exp, (unsigned int) nbytes);
3392 while (*input_line_pointer++ == ',');
3394 /* In MRI mode, after an odd number of bytes, we must align to an
3395 even word boundary, unless the next instruction is a dc.b, ds.b
3397 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3398 mri_pending_align = 1;
3400 input_line_pointer--; /* Put terminator back into stream. */
3402 demand_empty_rest_of_line ();
3405 mri_comment_end (stop, stopc);
3411 cons_worker (size, 0);
3417 cons_worker (size, 1);
3420 /* Put the contents of expression EXP into the object file using
3421 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3424 emit_expr (expressionS *exp, unsigned int nbytes)
3428 valueT extra_digit = 0;
3430 /* Don't do anything if we are going to make another pass. */
3434 dot_value = frag_now_fix ();
3438 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3439 appear as a four byte positive constant in the .line section,
3440 followed by a 2 byte 0xffff. Look for that case here. */
3442 static int dwarf_line = -1;
3444 if (strcmp (segment_name (now_seg), ".line") != 0)
3446 else if (dwarf_line >= 0
3448 && exp->X_op == O_constant
3449 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3450 listing_source_line ((unsigned int) dwarf_line);
3451 else if (nbytes == 4
3452 && exp->X_op == O_constant
3453 && exp->X_add_number >= 0)
3454 dwarf_line = exp->X_add_number;
3459 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3460 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3461 AT_sibling (0x12) followed by a four byte address of the sibling
3462 followed by a 2 byte AT_name (0x38) followed by the name of the
3463 file. We look for that case here. */
3465 static int dwarf_file = 0;
3467 if (strcmp (segment_name (now_seg), ".debug") != 0)
3469 else if (dwarf_file == 0
3471 && exp->X_op == O_constant
3472 && exp->X_add_number == 0x11)
3474 else if (dwarf_file == 1
3476 && exp->X_op == O_constant
3477 && exp->X_add_number == 0x12)
3479 else if (dwarf_file == 2
3482 else if (dwarf_file == 3
3484 && exp->X_op == O_constant
3485 && exp->X_add_number == 0x38)
3490 /* The variable dwarf_file_string tells stringer that the string
3491 may be the name of the source file. */
3492 if (dwarf_file == 4)
3493 dwarf_file_string = 1;
3495 dwarf_file_string = 0;
3500 if (check_eh_frame (exp, &nbytes))
3505 /* Allow `.word 0' in the absolute section. */
3506 if (now_seg == absolute_section)
3508 if (op != O_constant || exp->X_add_number != 0)
3509 as_bad (_("attempt to store value in absolute section"));
3510 abs_section_offset += nbytes;
3514 /* Handle a negative bignum. */
3516 && exp->X_add_number == 0
3517 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3518 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3521 unsigned long carry;
3523 exp = symbol_get_value_expression (exp->X_add_symbol);
3525 /* Negate the bignum: one's complement each digit and add 1. */
3527 for (i = 0; i < exp->X_add_number; i++)
3531 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3534 generic_bignum[i] = next & LITTLENUM_MASK;
3535 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3538 /* We can ignore any carry out, because it will be handled by
3539 extra_digit if it is needed. */
3541 extra_digit = (valueT) -1;
3545 if (op == O_absent || op == O_illegal)
3547 as_warn (_("zero assumed for missing expression"));
3548 exp->X_add_number = 0;
3551 else if (op == O_big && exp->X_add_number <= 0)
3553 as_bad (_("floating point number invalid"));
3554 exp->X_add_number = 0;
3557 else if (op == O_register)
3559 as_warn (_("register value used as expression"));
3563 p = frag_more ((int) nbytes);
3565 #ifndef WORKING_DOT_WORD
3566 /* If we have the difference of two symbols in a word, save it on
3567 the broken_words list. See the code in write.c. */
3568 if (op == O_subtract && nbytes == 2)
3570 struct broken_word *x;
3572 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3573 x->next_broken_word = broken_words;
3576 x->subseg = now_subseg;
3578 x->word_goes_here = p;
3580 x->add = exp->X_add_symbol;
3581 x->sub = exp->X_op_symbol;
3582 x->addnum = exp->X_add_number;
3590 /* If we have an integer, but the number of bytes is too large to
3591 pass to md_number_to_chars, handle it as a bignum. */
3592 if (op == O_constant && nbytes > sizeof (valueT))
3594 extra_digit = exp->X_unsigned ? 0 : -1;
3595 convert_to_bignum (exp);
3599 if (op == O_constant)
3601 register valueT get;
3602 register valueT use;
3603 register valueT mask;
3605 register valueT unmask;
3607 /* JF << of >= number of bits in the object is undefined. In
3608 particular SPARC (Sun 4) has problems. */
3609 if (nbytes >= sizeof (valueT))
3612 if (nbytes > sizeof (valueT))
3615 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3619 /* Don't store these bits. */
3620 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3621 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3624 unmask = ~mask; /* Do store these bits. */
3627 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3628 mask = ~(unmask >> 1); /* Includes sign bit now. */
3631 get = exp->X_add_number;
3633 if ((get & mask) != 0
3634 && ((get & mask) != mask
3635 || (get & hibit) == 0))
3636 { /* Leading bits contain both 0s & 1s. */
3637 as_warn (_("value 0x%lx truncated to 0x%lx"),
3638 (unsigned long) get, (unsigned long) use);
3640 /* Put bytes in right order. */
3641 md_number_to_chars (p, use, (int) nbytes);
3643 else if (op == O_big)
3646 LITTLENUM_TYPE *nums;
3648 know (nbytes % CHARS_PER_LITTLENUM == 0);
3650 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3653 as_warn (_("bignum truncated to %d bytes"), nbytes);
3657 if (target_big_endian)
3659 while (nbytes > size)
3661 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3662 nbytes -= CHARS_PER_LITTLENUM;
3663 p += CHARS_PER_LITTLENUM;
3666 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3667 while (size >= CHARS_PER_LITTLENUM)
3670 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3671 size -= CHARS_PER_LITTLENUM;
3672 p += CHARS_PER_LITTLENUM;
3677 nums = generic_bignum;
3678 while (size >= CHARS_PER_LITTLENUM)
3680 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3682 size -= CHARS_PER_LITTLENUM;
3683 p += CHARS_PER_LITTLENUM;
3684 nbytes -= CHARS_PER_LITTLENUM;
3687 while (nbytes >= CHARS_PER_LITTLENUM)
3689 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3690 nbytes -= CHARS_PER_LITTLENUM;
3691 p += CHARS_PER_LITTLENUM;
3697 memset (p, 0, nbytes);
3699 /* Now we need to generate a fixS to record the symbol value.
3700 This is easy for BFD. For other targets it can be more
3701 complex. For very complex cases (currently, the HPPA and
3702 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3703 want. For simpler cases, you can define TC_CONS_RELOC to be
3704 the name of the reloc code that should be stored in the fixS.
3705 If neither is defined, the code uses NO_RELOC if it is
3706 defined, and otherwise uses 0. */
3708 #ifdef BFD_ASSEMBLER
3709 #ifdef TC_CONS_FIX_NEW
3710 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3713 bfd_reloc_code_real_type r;
3730 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3734 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3739 #ifdef TC_CONS_FIX_NEW
3740 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3742 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3743 it is defined, otherwise use NO_RELOC if it is defined,
3745 #ifndef TC_CONS_RELOC
3747 #define TC_CONS_RELOC NO_RELOC
3749 #define TC_CONS_RELOC 0
3752 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3754 #endif /* TC_CONS_FIX_NEW */
3755 #endif /* BFD_ASSEMBLER */
3759 #ifdef BITFIELD_CONS_EXPRESSIONS
3761 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3762 w:x,y:z, where w and y are bitwidths and x and y are values. They
3763 then pack them all together. We do a little better in that we allow
3764 them in words, longs, etc. and we'll pack them in target byte order
3767 The rules are: pack least significant bit first, if a field doesn't
3768 entirely fit, put it in the next unit. Overflowing the bitfield is
3769 explicitly *not* even a warning. The bitwidth should be considered
3772 To use this function the tc-XXX.h file should define
3773 BITFIELD_CONS_EXPRESSIONS. */
3776 parse_bitfield_cons (exp, nbytes)
3778 unsigned int nbytes;
3780 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3781 char *hold = input_line_pointer;
3783 (void) expression (exp);
3785 if (*input_line_pointer == ':')
3792 unsigned long width;
3794 if (*input_line_pointer != ':')
3796 input_line_pointer = hold;
3798 } /* Next piece is not a bitfield. */
3800 /* In the general case, we can't allow
3801 full expressions with symbol
3802 differences and such. The relocation
3803 entries for symbols not defined in this
3804 assembly would require arbitrary field
3805 widths, positions, and masks which most
3806 of our current object formats don't
3809 In the specific case where a symbol
3810 *is* defined in this assembly, we
3811 *could* build fixups and track it, but
3812 this could lead to confusion for the
3813 backends. I'm lazy. I'll take any
3814 SEG_ABSOLUTE. I think that means that
3815 you can use a previous .set or
3816 .equ type symbol. xoxorich. */
3818 if (exp->X_op == O_absent)
3820 as_warn (_("using a bit field width of zero"));
3821 exp->X_add_number = 0;
3822 exp->X_op = O_constant;
3823 } /* Implied zero width bitfield. */
3825 if (exp->X_op != O_constant)
3827 *input_line_pointer = '\0';
3828 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3829 *input_line_pointer = ':';
3830 demand_empty_rest_of_line ();
3832 } /* Too complex. */
3834 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3836 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3837 width, nbytes, (BITS_PER_CHAR * nbytes));
3838 width = BITS_PER_CHAR * nbytes;
3841 if (width > bits_available)
3843 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3844 input_line_pointer = hold;
3845 exp->X_add_number = value;
3850 hold = ++input_line_pointer;
3852 (void) expression (exp);
3853 if (exp->X_op != O_constant)
3855 char cache = *input_line_pointer;
3857 *input_line_pointer = '\0';
3858 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3859 *input_line_pointer = cache;
3860 demand_empty_rest_of_line ();
3862 } /* Too complex. */
3864 value |= ((~(-1 << width) & exp->X_add_number)
3865 << ((BITS_PER_CHAR * nbytes) - bits_available));
3867 if ((bits_available -= width) == 0
3868 || is_it_end_of_statement ()
3869 || *input_line_pointer != ',')
3872 } /* All the bitfields we're gonna get. */
3874 hold = ++input_line_pointer;
3875 (void) expression (exp);
3878 exp->X_add_number = value;
3879 exp->X_op = O_constant;
3880 exp->X_unsigned = 1;
3884 #endif /* BITFIELD_CONS_EXPRESSIONS */
3886 /* Handle an MRI style string expression. */
3890 parse_mri_cons (exp, nbytes)
3892 unsigned int nbytes;
3894 if (*input_line_pointer != '\''
3895 && (input_line_pointer[1] != '\''
3896 || (*input_line_pointer != 'A'
3897 && *input_line_pointer != 'E')))
3898 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3902 unsigned int result = 0;
3904 /* An MRI style string. Cut into as many bytes as will fit into
3905 a nbyte chunk, left justify if necessary, and separate with
3906 commas so we can try again later. */
3907 if (*input_line_pointer == 'A')
3908 ++input_line_pointer;
3909 else if (*input_line_pointer == 'E')
3911 as_bad (_("EBCDIC constants are not supported"));
3912 ++input_line_pointer;
3915 input_line_pointer++;
3916 for (scan = 0; scan < nbytes; scan++)
3918 if (*input_line_pointer == '\'')
3920 if (input_line_pointer[1] == '\'')
3922 input_line_pointer++;
3927 result = (result << 8) | (*input_line_pointer++);
3931 while (scan < nbytes)
3937 /* Create correct expression. */
3938 exp->X_op = O_constant;
3939 exp->X_add_number = result;
3941 /* Fake it so that we can read the next char too. */
3942 if (input_line_pointer[0] != '\'' ||
3943 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3945 input_line_pointer -= 2;
3946 input_line_pointer[0] = ',';
3947 input_line_pointer[1] = '\'';
3950 input_line_pointer++;
3953 #endif /* TC_M68K */
3955 #ifdef REPEAT_CONS_EXPRESSIONS
3957 /* Parse a repeat expression for cons. This is used by the MIPS
3958 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3959 object file COUNT times.
3961 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3964 parse_repeat_cons (exp, nbytes)
3966 unsigned int nbytes;
3973 if (*input_line_pointer != ':')
3975 /* No repeat count. */
3979 ++input_line_pointer;
3980 expression (&count);
3981 if (count.X_op != O_constant
3982 || count.X_add_number <= 0)
3984 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
3988 /* The cons function is going to output this expression once. So we
3989 output it count - 1 times. */
3990 for (i = count.X_add_number - 1; i > 0; i--)
3991 emit_expr (exp, nbytes);
3994 #endif /* REPEAT_CONS_EXPRESSIONS */
3996 /* Parse a floating point number represented as a hex constant. This
3997 permits users to specify the exact bits they want in the floating
4001 hex_float (int float_type, char *bytes)
4033 as_bad (_("unknown floating type type '%c'"), float_type);
4037 /* It would be nice if we could go through expression to parse the
4038 hex constant, but if we get a bignum it's a pain to sort it into
4039 the buffer correctly. */
4041 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4045 /* The MRI assembler accepts arbitrary underscores strewn about
4046 through the hex constant, so we ignore them as well. */
4047 if (*input_line_pointer == '_')
4049 ++input_line_pointer;
4055 as_warn (_("floating point constant too large"));
4058 d = hex_value (*input_line_pointer) << 4;
4059 ++input_line_pointer;
4060 while (*input_line_pointer == '_')
4061 ++input_line_pointer;
4062 if (hex_p (*input_line_pointer))
4064 d += hex_value (*input_line_pointer);
4065 ++input_line_pointer;
4067 if (target_big_endian)
4070 bytes[length - i - 1] = d;
4076 if (target_big_endian)
4077 memset (bytes + i, 0, length - i);
4079 memset (bytes, 0, length - i);
4087 CONStruct some more frag chars of .floats .ffloats etc.
4088 Makes 0 or more new frags.
4089 If need_pass_2 == 1, no frags are emitted.
4090 This understands only floating literals, not expressions. Sorry.
4092 A floating constant is defined by atof_generic(), except it is preceded
4093 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4094 reading, I decided to be incompatible. This always tries to give you
4095 rounded bits to the precision of the pseudo-op. Former AS did premature
4096 truncation, restored noisy bits instead of trailing 0s AND gave you
4097 a choice of 2 flavours of noise according to which of 2 floating-point
4098 scanners you directed AS to use.
4100 In: input_line_pointer->whitespace before, or '0' of flonum. */
4103 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4104 register int float_type /* 'f':.ffloat ... 'F':.float ... */)
4107 int length; /* Number of chars in an object. */
4108 register char *err; /* Error from scanning floating literal. */
4109 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4111 if (is_it_end_of_statement ())
4113 demand_empty_rest_of_line ();
4117 #ifdef md_flush_pending_output
4118 md_flush_pending_output ();
4123 /* input_line_pointer->1st char of a flonum (we hope!). */
4126 /* Skip any 0{letter} that may be present. Don't even check if the
4127 letter is legal. Someone may invent a "z" format and this routine
4128 has no use for such information. Lusers beware: you get
4129 diagnostics if your input is ill-conditioned. */
4130 if (input_line_pointer[0] == '0'
4131 && ISALPHA (input_line_pointer[1]))
4132 input_line_pointer += 2;
4134 /* Accept :xxxx, where the x's are hex digits, for a floating
4135 point with the exact digits specified. */
4136 if (input_line_pointer[0] == ':')
4138 ++input_line_pointer;
4139 length = hex_float (float_type, temp);
4142 ignore_rest_of_line ();
4148 err = md_atof (float_type, temp, &length);
4149 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4153 as_bad (_("bad floating literal: %s"), err);
4154 ignore_rest_of_line ();
4165 #ifdef REPEAT_CONS_EXPRESSIONS
4166 if (*input_line_pointer == ':')
4168 expressionS count_exp;
4170 ++input_line_pointer;
4171 expression (&count_exp);
4173 if (count_exp.X_op != O_constant
4174 || count_exp.X_add_number <= 0)
4175 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4177 count = count_exp.X_add_number;
4181 while (--count >= 0)
4183 p = frag_more (length);
4184 memcpy (p, temp, (unsigned int) length);
4189 while (*input_line_pointer++ == ',');
4191 /* Put terminator back into stream. */
4192 --input_line_pointer;
4193 demand_empty_rest_of_line ();
4196 /* Return the size of a LEB128 value. */
4199 sizeof_sleb128 (offsetT value)
4201 register int size = 0;
4202 register unsigned byte;
4206 byte = (value & 0x7f);
4207 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4208 Fortunately, we can structure things so that the extra work reduces
4209 to a noop on systems that do things "properly". */
4210 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4213 while (!(((value == 0) && ((byte & 0x40) == 0))
4214 || ((value == -1) && ((byte & 0x40) != 0))));
4220 sizeof_uleb128 (valueT value)
4222 register int size = 0;
4223 register unsigned byte;
4227 byte = (value & 0x7f);
4237 sizeof_leb128 (valueT value, int sign)
4240 return sizeof_sleb128 ((offsetT) value);
4242 return sizeof_uleb128 (value);
4245 /* Output a LEB128 value. */
4248 output_sleb128 (char *p, offsetT value)
4250 register char *orig = p;
4255 unsigned byte = (value & 0x7f);
4257 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4258 Fortunately, we can structure things so that the extra work reduces
4259 to a noop on systems that do things "properly". */
4260 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4262 more = !((((value == 0) && ((byte & 0x40) == 0))
4263 || ((value == -1) && ((byte & 0x40) != 0))));
4275 output_uleb128 (char *p, valueT value)
4281 unsigned byte = (value & 0x7f);
4284 /* More bytes to follow. */
4295 output_leb128 (char *p, valueT value, int sign)
4298 return output_sleb128 (p, (offsetT) value);
4300 return output_uleb128 (p, value);
4303 /* Do the same for bignums. We combine sizeof with output here in that
4304 we don't output for NULL values of P. It isn't really as critical as
4305 for "normal" values that this be streamlined. */
4308 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4315 /* Strip leading sign extensions off the bignum. */
4317 && bignum[size - 1] == LITTLENUM_MASK
4318 && bignum[size - 2] > LITTLENUM_MASK / 2)
4323 /* OR in the next part of the littlenum. */
4324 val |= (*bignum << loaded);
4325 loaded += LITTLENUM_NUMBER_OF_BITS;
4329 /* Add bytes until there are less than 7 bits left in VAL
4330 or until every non-sign bit has been written. */
4337 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4344 while ((byte & 0x80) != 0 && loaded >= 7);
4348 /* Mop up any left-over bits (of which there will be less than 7). */
4349 if ((byte & 0x80) != 0)
4351 /* Sign-extend VAL. */
4352 if (val & (1 << (loaded - 1)))
4353 val |= ~0 << loaded;
4363 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4370 /* Strip leading zeros off the bignum. */
4371 /* XXX: Is this needed? */
4372 while (size > 0 && bignum[size - 1] == 0)
4377 if (loaded < 7 && size > 0)
4379 val |= (*bignum << loaded);
4380 loaded += 8 * CHARS_PER_LITTLENUM;
4389 if (size > 0 || val)
4396 while (byte & 0x80);
4402 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4405 return output_big_sleb128 (p, bignum, size);
4407 return output_big_uleb128 (p, bignum, size);
4410 /* Generate the appropriate fragments for a given expression to emit a
4414 emit_leb128_expr (expressionS *exp, int sign)
4416 operatorT op = exp->X_op;
4417 unsigned int nbytes;
4419 if (op == O_absent || op == O_illegal)
4421 as_warn (_("zero assumed for missing expression"));
4422 exp->X_add_number = 0;
4425 else if (op == O_big && exp->X_add_number <= 0)
4427 as_bad (_("floating point number invalid"));
4428 exp->X_add_number = 0;
4431 else if (op == O_register)
4433 as_warn (_("register value used as expression"));
4436 else if (op == O_constant
4438 && (exp->X_add_number < 0) != !exp->X_unsigned)
4440 /* We're outputting a signed leb128 and the sign of X_add_number
4441 doesn't reflect the sign of the original value. Convert EXP
4442 to a correctly-extended bignum instead. */
4443 convert_to_bignum (exp);
4447 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4448 a signal that this is leb128 data. It shouldn't optimize this away. */
4449 nbytes = (unsigned int) -1;
4450 if (check_eh_frame (exp, &nbytes))
4453 /* Let the backend know that subsequent data may be byte aligned. */
4454 #ifdef md_cons_align
4458 if (op == O_constant)
4460 /* If we've got a constant, emit the thing directly right now. */
4462 valueT value = exp->X_add_number;
4466 size = sizeof_leb128 (value, sign);
4467 p = frag_more (size);
4468 output_leb128 (p, value, sign);
4470 else if (op == O_big)
4472 /* O_big is a different sort of constant. */
4477 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4478 p = frag_more (size);
4479 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4483 /* Otherwise, we have to create a variable sized fragment and
4484 resolve things later. */
4486 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4487 make_expr_symbol (exp), 0, (char *) NULL);
4491 /* Parse the .sleb128 and .uleb128 pseudos. */
4498 #ifdef md_flush_pending_output
4499 md_flush_pending_output ();
4505 emit_leb128_expr (&exp, sign);
4507 while (*input_line_pointer++ == ',');
4509 input_line_pointer--;
4510 demand_empty_rest_of_line ();
4513 /* We read 0 or more ',' separated, double-quoted strings.
4514 Caller should have checked need_pass_2 is FALSE because we don't
4518 stringer (/* Worker to do .ascii etc statements. */
4519 /* Checks end-of-line. */
4520 register int append_zero /* 0: don't append '\0', else 1. */)
4522 register unsigned int c;
4525 #ifdef md_flush_pending_output
4526 md_flush_pending_output ();
4529 /* The following awkward logic is to parse ZERO or more strings,
4530 comma separated. Recall a string expression includes spaces
4531 before the opening '\"' and spaces after the closing '\"'.
4532 We fake a leading ',' if there is (supposed to be)
4533 a 1st, expression. We keep demanding expressions for each ','. */
4534 if (is_it_end_of_statement ())
4536 c = 0; /* Skip loop. */
4537 ++input_line_pointer; /* Compensate for end of loop. */
4541 c = ','; /* Do loop. */
4543 /* If we have been switched into the abs_section then we
4544 will not have an obstack onto which we can hang strings. */
4545 if (now_seg == absolute_section)
4547 as_bad (_("strings must be placed into a section"));
4549 ignore_rest_of_line ();
4552 while (c == ',' || c == '<' || c == '"')
4555 switch (*input_line_pointer)
4558 ++input_line_pointer; /*->1st char of string. */
4559 start = input_line_pointer;
4560 while (is_a_char (c = next_char_of_string ()))
4562 FRAG_APPEND_1_CHAR (c);
4566 FRAG_APPEND_1_CHAR (0);
4568 know (input_line_pointer[-1] == '\"');
4572 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4573 will emit .string with a filename in the .debug section
4574 after a sequence of constants. See the comment in
4575 emit_expr for the sequence. emit_expr will set
4576 dwarf_file_string to non-zero if this string might be a
4577 source file name. */
4578 if (strcmp (segment_name (now_seg), ".debug") != 0)
4579 dwarf_file_string = 0;
4580 else if (dwarf_file_string)
4582 c = input_line_pointer[-1];
4583 input_line_pointer[-1] = '\0';
4584 listing_source_file (start);
4585 input_line_pointer[-1] = c;
4592 input_line_pointer++;
4593 c = get_single_number ();
4594 FRAG_APPEND_1_CHAR (c);
4595 if (*input_line_pointer != '>')
4597 as_bad (_("expected <nn>"));
4599 input_line_pointer++;
4602 input_line_pointer++;
4606 c = *input_line_pointer;
4609 demand_empty_rest_of_line ();
4612 /* FIXME-SOMEDAY: I had trouble here on characters with the
4613 high bits set. We'll probably also have trouble with
4614 multibyte chars, wide chars, etc. Also be careful about
4615 returning values bigger than 1 byte. xoxorich. */
4618 next_char_of_string (void)
4620 register unsigned int c;
4622 c = *input_line_pointer++ & CHAR_MASK;
4630 as_warn (_("unterminated string; newline inserted"));
4631 bump_line_counters ();
4634 #ifndef NO_STRING_ESCAPES
4636 switch (c = *input_line_pointer++)
4664 break; /* As itself. */
4680 for (i = 0, number = 0;
4681 ISDIGIT (c) && i < 3;
4682 c = *input_line_pointer++, i++)
4684 number = number * 8 + c - '0';
4689 --input_line_pointer;
4698 c = *input_line_pointer++;
4699 while (ISXDIGIT (c))
4702 number = number * 16 + c - '0';
4703 else if (ISUPPER (c))
4704 number = number * 16 + c - 'A' + 10;
4706 number = number * 16 + c - 'a' + 10;
4707 c = *input_line_pointer++;
4710 --input_line_pointer;
4715 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4716 as_warn (_("unterminated string; newline inserted"));
4718 bump_line_counters ();
4723 #ifdef ONLY_STANDARD_ESCAPES
4724 as_bad (_("bad escaped character in string"));
4726 #endif /* ONLY_STANDARD_ESCAPES */
4731 #endif /* ! defined (NO_STRING_ESCAPES) */
4740 get_segmented_expression (register expressionS *expP)
4742 register segT retval;
4744 retval = expression (expP);
4745 if (expP->X_op == O_illegal
4746 || expP->X_op == O_absent
4747 || expP->X_op == O_big)
4749 as_bad (_("expected address expression"));
4750 expP->X_op = O_constant;
4751 expP->X_add_number = 0;
4752 retval = absolute_section;
4758 get_known_segmented_expression (register expressionS *expP)
4760 register segT retval;
4762 if ((retval = get_segmented_expression (expP)) == undefined_section)
4764 /* There is no easy way to extract the undefined symbol from the
4766 if (expP->X_add_symbol != NULL
4767 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4768 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4769 S_GET_NAME (expP->X_add_symbol));
4771 as_warn (_("some symbol undefined; zero assumed"));
4772 retval = absolute_section;
4773 expP->X_op = O_constant;
4774 expP->X_add_number = 0;
4776 know (retval == absolute_section || SEG_NORMAL (retval));
4781 get_absolute_expr (expressionS *exp)
4784 if (exp->X_op != O_constant)
4786 if (exp->X_op != O_absent)
4787 as_bad (_("bad or irreducible absolute expression"));
4788 exp->X_add_number = 0;
4790 return exp->X_add_number;
4794 get_absolute_expression (void)
4798 return get_absolute_expr (&exp);
4801 char /* Return terminator. */
4802 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
4804 /* FIXME: val_pointer should probably be offsetT *. */
4805 *val_pointer = (long) get_absolute_expression ();
4806 return (*input_line_pointer++);
4809 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4810 Give a warning if that happens. */
4813 demand_copy_C_string (int *len_pointer)
4817 if ((s = demand_copy_string (len_pointer)) != 0)
4821 for (len = *len_pointer; len > 0; len--)
4828 as_bad (_("this string may not contain \'\\0\'"));
4836 /* Demand string, but return a safe (=private) copy of the string.
4837 Return NULL if we can't read a string here. */
4840 demand_copy_string (int *lenP)
4842 register unsigned int c;
4848 if (*input_line_pointer == '\"')
4850 input_line_pointer++; /* Skip opening quote. */
4852 while (is_a_char (c = next_char_of_string ()))
4854 obstack_1grow (¬es, c);
4857 /* JF this next line is so demand_copy_C_string will return a
4858 null terminated string. */
4859 obstack_1grow (¬es, '\0');
4860 retval = obstack_finish (¬es);
4864 as_bad (_("missing string"));
4866 ignore_rest_of_line ();
4872 /* In: Input_line_pointer->next character.
4874 Do: Skip input_line_pointer over all whitespace.
4876 Out: 1 if input_line_pointer->end-of-line. */
4879 is_it_end_of_statement (void)
4882 return (is_end_of_line[(unsigned char) *input_line_pointer]);
4886 equals (char *sym_name, int reassign)
4888 register symbolS *symbolP; /* Symbol we are working with. */
4892 input_line_pointer++;
4893 if (*input_line_pointer == '=')
4894 input_line_pointer++;
4896 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4897 input_line_pointer++;
4900 stop = mri_comment_field (&stopc);
4902 if (sym_name[0] == '.' && sym_name[1] == '\0')
4904 /* Turn '. = mumble' into a .org mumble. */
4905 register segT segment;
4908 segment = get_known_segmented_expression (&exp);
4910 do_org (segment, &exp, 0);
4917 symbolP = symbol_find (sym_name);
4918 local = symbolP == NULL;
4920 #endif /* OBJ_COFF */
4921 symbolP = symbol_find_or_make (sym_name);
4922 /* Permit register names to be redefined. */
4924 && S_IS_DEFINED (symbolP)
4925 && S_GET_SEGMENT (symbolP) != reg_section)
4926 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
4929 /* "set" symbols are local unless otherwise specified. */
4931 SF_SET_LOCAL (symbolP);
4932 #endif /* OBJ_COFF */
4934 pseudo_set (symbolP);
4939 /* Check garbage after the expression. */
4940 demand_empty_rest_of_line ();
4941 mri_comment_end (stop, stopc);
4945 /* .incbin -- include a file verbatim at the current location. */
4948 s_incbin (int x ATTRIBUTE_UNUSED)
4959 #ifdef md_flush_pending_output
4960 md_flush_pending_output ();
4964 filename = demand_copy_string (& len);
4965 if (filename == NULL)
4970 /* Look for optional skip and count. */
4971 if (* input_line_pointer == ',')
4973 ++ input_line_pointer;
4974 skip = get_absolute_expression ();
4978 if (* input_line_pointer == ',')
4980 ++ input_line_pointer;
4982 count = get_absolute_expression ();
4984 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
4990 demand_empty_rest_of_line ();
4992 /* Try opening absolute path first, then try include dirs. */
4993 binfile = fopen (filename, FOPEN_RB);
4994 if (binfile == NULL)
4998 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5000 for (i = 0; i < include_dir_count; i++)
5002 sprintf (path, "%s/%s", include_dirs[i], filename);
5004 binfile = fopen (path, FOPEN_RB);
5005 if (binfile != NULL)
5009 if (binfile == NULL)
5010 as_bad (_("file not found: %s"), filename);
5013 path = xstrdup (filename);
5019 register_dependency (path);
5021 /* Compute the length of the file. */
5022 if (fseek (binfile, 0, SEEK_END) != 0)
5024 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5027 file_len = ftell (binfile);
5029 /* If a count was not specified use the remainder of the file. */
5031 count = file_len - skip;
5033 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5035 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5036 skip, count, file_len);
5040 if (fseek (binfile, skip, SEEK_SET) != 0)
5042 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5046 /* Allocate frag space and store file contents in it. */
5047 binfrag = frag_more (count);
5049 bytes = fread (binfrag, 1, count, binfile);
5051 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5052 path, bytes, count);
5055 if (binfile != NULL)
5061 /* .include -- include a file at this point. */
5064 s_include (int arg ATTRIBUTE_UNUSED)
5073 filename = demand_copy_string (&i);
5074 if (filename == NULL)
5076 /* demand_copy_string has already printed an error and
5077 called ignore_rest_of_line. */
5085 while (!is_end_of_line[(unsigned char) *input_line_pointer]
5086 && *input_line_pointer != ' '
5087 && *input_line_pointer != '\t')
5089 obstack_1grow (¬es, *input_line_pointer);
5090 ++input_line_pointer;
5094 obstack_1grow (¬es, '\0');
5095 filename = obstack_finish (¬es);
5096 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5097 ++input_line_pointer;
5100 demand_empty_rest_of_line ();
5101 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
5103 for (i = 0; i < include_dir_count; i++)
5105 strcpy (path, include_dirs[i]);
5107 strcat (path, filename);
5108 if (0 != (try = fopen (path, FOPEN_RT)))
5118 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5119 register_dependency (path);
5120 input_scrub_insert_file (path);
5124 add_include_dir (char *path)
5128 if (include_dir_count == 0)
5130 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5131 include_dirs[0] = "."; /* Current dir. */
5132 include_dir_count = 2;
5136 include_dir_count++;
5138 (char **) realloc (include_dirs,
5139 include_dir_count * sizeof (*include_dirs));
5142 include_dirs[include_dir_count - 1] = path; /* New one. */
5145 if (i > include_dir_maxlen)
5146 include_dir_maxlen = i;
5149 /* Output debugging information to denote the source file. */
5152 generate_file_debug (void)
5154 if (debug_type == DEBUG_STABS)
5155 stabs_generate_asm_file ();
5158 /* Output line number debugging information for the current source line. */
5161 generate_lineno_debug (void)
5165 case DEBUG_UNSPECIFIED:
5170 stabs_generate_asm_lineno ();
5173 ecoff_generate_asm_lineno ();
5176 /* ??? We could here indicate to dwarf2dbg.c that something
5177 has changed. However, since there is additional backend
5178 support that is required (calling dwarf2_emit_insn), we
5179 let dwarf2dbg.c call as_where on its own. */
5184 /* Output debugging information to mark a function entry point or end point.
5185 END_P is zero for .func, and non-zero for .endfunc. */
5190 do_s_func (end_p, NULL);
5193 /* Subroutine of s_func so targets can choose a different default prefix.
5194 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5197 do_s_func (int end_p, const char *default_prefix)
5199 /* Record the current function so that we can issue an error message for
5200 misplaced .func,.endfunc, and also so that .endfunc needs no
5202 static char *current_name;
5203 static char *current_label;
5207 if (current_name == NULL)
5209 as_bad (_("missing .func"));
5210 ignore_rest_of_line ();
5214 if (debug_type == DEBUG_STABS)
5215 stabs_generate_asm_endfunc (current_name, current_label);
5217 current_name = current_label = NULL;
5222 char delim1, delim2;
5224 if (current_name != NULL)
5226 as_bad (_(".endfunc missing for previous .func"));
5227 ignore_rest_of_line ();
5231 name = input_line_pointer;
5232 delim1 = get_symbol_end ();
5233 name = xstrdup (name);
5234 *input_line_pointer = delim1;
5236 if (*input_line_pointer != ',')
5239 asprintf (&label, "%s%s", default_prefix, name);
5242 char leading_char = 0;
5243 #ifdef BFD_ASSEMBLER
5244 leading_char = bfd_get_symbol_leading_char (stdoutput);
5246 /* Missing entry point, use function's name with the leading
5249 asprintf (&label, "%c%s", leading_char, name);
5256 ++input_line_pointer;
5258 label = input_line_pointer;
5259 delim2 = get_symbol_end ();
5260 label = xstrdup (label);
5261 *input_line_pointer = delim2;
5264 if (debug_type == DEBUG_STABS)
5265 stabs_generate_asm_func (name, label);
5267 current_name = name;
5268 current_label = label;
5271 demand_empty_rest_of_line ();
5275 s_ignore (int arg ATTRIBUTE_UNUSED)
5277 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5279 ++input_line_pointer;
5281 ++input_line_pointer;
5285 read_print_statistics (FILE *file)
5287 hash_print_statistics (file, "pseudo-op table", po_hash);
5290 /* Inserts the given line into the input stream.
5292 This call avoids macro/conditionals nesting checking, since the contents of
5293 the line are assumed to replace the contents of a line already scanned.
5295 An appropriate use of this function would be substitution of input lines when
5296 called by md_start_line_hook(). The given line is assumed to already be
5297 properly scrubbed. */
5300 input_scrub_insert_line (const char *line)
5304 sb_add_string (&newline, line);
5305 input_scrub_include_sb (&newline, input_line_pointer, 0);
5307 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5310 /* Insert a file into the input stream; the path must resolve to an actual
5311 file; no include path searching or dependency registering is performed. */
5314 input_scrub_insert_file (char *path)
5316 input_scrub_include_file (path, input_line_pointer);
5317 buffer_limit = input_scrub_next_buffer (&input_line_pointer);