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 demand_empty_rest_of_line ();
1478 mri_comment_end (stop, stopc);
1485 s_comm_internal (ignore, NULL);
1488 /* The MRI COMMON pseudo-op. We handle this by creating a common
1489 symbol with the appropriate name. We make s_space do the right
1490 thing by increasing the size. */
1493 s_mri_common (int small ATTRIBUTE_UNUSED)
1509 stop = mri_comment_field (&stopc);
1513 name = input_line_pointer;
1514 if (!ISDIGIT (*name))
1515 c = get_symbol_end ();
1520 ++input_line_pointer;
1522 while (ISDIGIT (*input_line_pointer));
1524 c = *input_line_pointer;
1525 *input_line_pointer = '\0';
1527 if (line_label != NULL)
1529 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1530 + (input_line_pointer - name)
1532 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1537 sym = symbol_find_or_make (name);
1538 *input_line_pointer = c;
1542 if (*input_line_pointer != ',')
1546 ++input_line_pointer;
1547 align = get_absolute_expression ();
1550 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1552 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1553 ignore_rest_of_line ();
1554 mri_comment_end (stop, stopc);
1558 S_SET_EXTERNAL (sym);
1559 mri_common_symbol = sym;
1563 S_SET_ALIGN (sym, align);
1566 if (line_label != NULL)
1569 exp.X_op = O_symbol;
1570 exp.X_add_symbol = sym;
1571 exp.X_add_number = 0;
1572 symbol_set_value_expression (line_label, &exp);
1573 symbol_set_frag (line_label, &zero_address_frag);
1574 S_SET_SEGMENT (line_label, expr_section);
1577 /* FIXME: We just ignore the small argument, which distinguishes
1578 COMMON and COMMON.S. I don't know what we can do about it. */
1580 /* Ignore the type and hptype. */
1581 if (*input_line_pointer == ',')
1582 input_line_pointer += 2;
1583 if (*input_line_pointer == ',')
1584 input_line_pointer += 2;
1586 demand_empty_rest_of_line ();
1588 mri_comment_end (stop, stopc);
1592 s_data (int ignore ATTRIBUTE_UNUSED)
1597 temp = get_absolute_expression ();
1598 if (flag_readonly_data_in_text)
1600 section = text_section;
1604 section = data_section;
1606 subseg_set (section, (subsegT) temp);
1611 demand_empty_rest_of_line ();
1614 /* Handle the .appfile pseudo-op. This is automatically generated by
1615 do_scrub_chars when a preprocessor # line comment is seen with a
1616 file name. This default definition may be overridden by the object
1617 or CPU specific pseudo-ops. This function is also the default
1618 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1622 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1626 listing_source_file (file);
1628 register_dependency (file);
1630 obj_app_file (file, appfile);
1635 s_app_file (int appfile)
1640 /* Some assemblers tolerate immediately following '"'. */
1641 if ((s = demand_copy_string (&length)) != 0)
1643 /* If this is a fake .appfile, a fake newline was inserted into
1644 the buffer. Passing -2 to new_logical_line tells it to
1647 = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
1649 /* In MRI mode, the preprocessor may have inserted an extraneous
1652 && *input_line_pointer == '\''
1653 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1654 ++input_line_pointer;
1656 demand_empty_rest_of_line ();
1658 s_app_file_string (s, appfile);
1662 /* Handle the .appline pseudo-op. This is automatically generated by
1663 do_scrub_chars when a preprocessor # line comment is seen. This
1664 default definition may be overridden by the object or CPU specific
1668 s_app_line (int ignore ATTRIBUTE_UNUSED)
1672 /* The given number is that of the next line. */
1673 l = get_absolute_expression () - 1;
1675 /* Some of the back ends can't deal with non-positive line numbers.
1676 Besides, it's silly. */
1677 as_warn (_("line numbers must be positive; line number %d rejected"),
1681 new_logical_line ((char *) NULL, l);
1684 listing_source_line (l);
1687 demand_empty_rest_of_line ();
1690 /* Handle the .end pseudo-op. Actually, the real work is done in
1691 read_a_source_file. */
1694 s_end (int ignore ATTRIBUTE_UNUSED)
1698 /* The MRI assembler permits the start symbol to follow .end,
1699 but we don't support that. */
1701 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1702 && *input_line_pointer != '*'
1703 && *input_line_pointer != '!')
1704 as_warn (_("start address not supported"));
1708 /* Handle the .err pseudo-op. */
1711 s_err (int ignore ATTRIBUTE_UNUSED)
1713 as_bad (_(".err encountered"));
1714 demand_empty_rest_of_line ();
1717 /* Handle the .error and .warning pseudo-ops. */
1723 /* The purpose for the conditional assignment is not to
1724 internationalize the directive itself, but that we need a
1725 self-contained message, one that can be passed like the
1726 demand_copy_C_string return value, and with no assumption on the
1727 location of the name of the directive within the message. */
1729 = (err ? _(".error directive invoked in source file")
1730 : _(".warning directive invoked in source file"));
1732 if (!is_it_end_of_statement ())
1734 if (*input_line_pointer != '\"')
1736 as_bad (_("%s argument must be a string"),
1737 err ? ".error" : ".warning");
1738 discard_rest_of_line ();
1742 msg = demand_copy_C_string (&len);
1750 as_warn ("%s", msg);
1751 demand_empty_rest_of_line ();
1754 /* Handle the MRI fail pseudo-op. */
1757 s_fail (int ignore ATTRIBUTE_UNUSED)
1764 stop = mri_comment_field (&stopc);
1766 temp = get_absolute_expression ();
1768 as_warn (_(".fail %ld encountered"), (long) temp);
1770 as_bad (_(".fail %ld encountered"), (long) temp);
1772 demand_empty_rest_of_line ();
1775 mri_comment_end (stop, stopc);
1779 s_fill (int ignore ATTRIBUTE_UNUSED)
1781 expressionS rep_exp;
1783 register long fill = 0;
1786 #ifdef md_flush_pending_output
1787 md_flush_pending_output ();
1790 get_known_segmented_expression (&rep_exp);
1791 if (*input_line_pointer == ',')
1793 input_line_pointer++;
1794 size = get_absolute_expression ();
1795 if (*input_line_pointer == ',')
1797 input_line_pointer++;
1798 fill = get_absolute_expression ();
1802 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1803 #define BSD_FILL_SIZE_CROCK_8 (8)
1804 if (size > BSD_FILL_SIZE_CROCK_8)
1806 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1807 size = BSD_FILL_SIZE_CROCK_8;
1811 as_warn (_("size negative; .fill ignored"));
1814 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1816 if (rep_exp.X_add_number < 0)
1817 as_warn (_("repeat < 0; .fill ignored"));
1821 if (size && !need_pass_2)
1823 if (rep_exp.X_op == O_constant)
1825 p = frag_var (rs_fill, (int) size, (int) size,
1826 (relax_substateT) 0, (symbolS *) 0,
1827 (offsetT) rep_exp.X_add_number,
1832 /* We don't have a constant repeat count, so we can't use
1833 rs_fill. We can get the same results out of rs_space,
1834 but its argument is in bytes, so we must multiply the
1835 repeat count by size. */
1838 rep_sym = make_expr_symbol (&rep_exp);
1841 expressionS size_exp;
1842 size_exp.X_op = O_constant;
1843 size_exp.X_add_number = size;
1845 rep_exp.X_op = O_multiply;
1846 rep_exp.X_add_symbol = rep_sym;
1847 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1848 rep_exp.X_add_number = 0;
1849 rep_sym = make_expr_symbol (&rep_exp);
1852 p = frag_var (rs_space, (int) size, (int) size,
1853 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1856 memset (p, 0, (unsigned int) size);
1858 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1859 flavoured AS. The following bizarre behaviour is to be
1860 compatible with above. I guess they tried to take up to 8
1861 bytes from a 4-byte expression and they forgot to sign
1863 #define BSD_FILL_SIZE_CROCK_4 (4)
1864 md_number_to_chars (p, (valueT) fill,
1865 (size > BSD_FILL_SIZE_CROCK_4
1866 ? BSD_FILL_SIZE_CROCK_4
1868 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1869 but emits no error message because it seems a legal thing to do.
1870 It is a degenerate case of .fill but could be emitted by a
1873 demand_empty_rest_of_line ();
1877 s_globl (int ignore ATTRIBUTE_UNUSED)
1886 stop = mri_comment_field (&stopc);
1890 name = input_line_pointer;
1891 c = get_symbol_end ();
1892 symbolP = symbol_find_or_make (name);
1893 S_SET_EXTERNAL (symbolP);
1895 *input_line_pointer = c;
1897 c = *input_line_pointer;
1900 input_line_pointer++;
1902 if (is_end_of_line[(unsigned char) *input_line_pointer])
1908 demand_empty_rest_of_line ();
1911 mri_comment_end (stop, stopc);
1914 /* Handle the MRI IRP and IRPC pseudo-ops. */
1925 as_where (&file, &line);
1928 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1929 sb_add_char (&s, *input_line_pointer++);
1933 err = expand_irp (irpc, 0, &s, &out, get_line_sb);
1935 as_bad_where (file, line, "%s", err);
1939 input_scrub_include_sb (&out, input_line_pointer, 1);
1941 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1944 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1945 the section to only be linked once. However, this is not supported
1946 by most object file formats. This takes an optional argument,
1947 which is what to do about duplicates. */
1950 s_linkonce (int ignore ATTRIBUTE_UNUSED)
1952 enum linkonce_type type;
1956 type = LINKONCE_DISCARD;
1958 if (!is_end_of_line[(unsigned char) *input_line_pointer])
1963 s = input_line_pointer;
1964 c = get_symbol_end ();
1965 if (strcasecmp (s, "discard") == 0)
1966 type = LINKONCE_DISCARD;
1967 else if (strcasecmp (s, "one_only") == 0)
1968 type = LINKONCE_ONE_ONLY;
1969 else if (strcasecmp (s, "same_size") == 0)
1970 type = LINKONCE_SAME_SIZE;
1971 else if (strcasecmp (s, "same_contents") == 0)
1972 type = LINKONCE_SAME_CONTENTS;
1974 as_warn (_("unrecognized .linkonce type `%s'"), s);
1976 *input_line_pointer = c;
1979 #ifdef obj_handle_link_once
1980 obj_handle_link_once (type);
1981 #else /* ! defined (obj_handle_link_once) */
1982 #ifdef BFD_ASSEMBLER
1986 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
1987 as_warn (_(".linkonce is not supported for this object file format"));
1989 flags = bfd_get_section_flags (stdoutput, now_seg);
1990 flags |= SEC_LINK_ONCE;
1995 case LINKONCE_DISCARD:
1996 flags |= SEC_LINK_DUPLICATES_DISCARD;
1998 case LINKONCE_ONE_ONLY:
1999 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2001 case LINKONCE_SAME_SIZE:
2002 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2004 case LINKONCE_SAME_CONTENTS:
2005 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2008 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2009 as_bad (_("bfd_set_section_flags: %s"),
2010 bfd_errmsg (bfd_get_error ()));
2012 #else /* ! defined (BFD_ASSEMBLER) */
2013 as_warn (_(".linkonce is not supported for this object file format"));
2014 #endif /* ! defined (BFD_ASSEMBLER) */
2015 #endif /* ! defined (obj_handle_link_once) */
2017 demand_empty_rest_of_line ();
2021 bss_alloc (symbolS *symbolP, addressT size, int align)
2024 segT current_seg = now_seg;
2025 subsegT current_subseg = now_subseg;
2026 segT bss_seg = bss_section;
2028 #if defined (TC_MIPS) || defined (TC_ALPHA)
2029 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2030 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2032 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2033 if (size <= bfd_get_gp_size (stdoutput))
2035 bss_seg = subseg_new (".sbss", 1);
2036 seg_info (bss_seg)->bss = 1;
2037 #ifdef BFD_ASSEMBLER
2038 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2039 as_warn (_("error setting flags for \".sbss\": %s"),
2040 bfd_errmsg (bfd_get_error ()));
2045 subseg_set (bss_seg, 1);
2049 record_alignment (bss_seg, align);
2050 frag_align (align, 0, 0);
2053 /* Detach from old frag. */
2054 if (S_GET_SEGMENT (symbolP) == bss_seg)
2055 symbol_get_frag (symbolP)->fr_symbol = NULL;
2057 symbol_set_frag (symbolP, frag_now);
2058 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2062 S_SET_SIZE (symbolP, size);
2064 S_SET_SEGMENT (symbolP, bss_seg);
2067 /* The symbol may already have been created with a preceding
2068 ".globl" directive -- be careful not to step on storage class
2069 in that case. Otherwise, set it to static. */
2070 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2071 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2072 #endif /* OBJ_COFF */
2074 subseg_set (current_seg, current_subseg);
2078 parse_align (int align_bytes)
2084 if (*input_line_pointer != ',')
2087 as_bad (_("expected alignment after size"));
2088 ignore_rest_of_line ();
2092 input_line_pointer++;
2095 align = get_absolute_expr (&exp);
2096 if (exp.X_op == O_absent)
2099 if (!exp.X_unsigned)
2101 as_warn (_("alignment negative; 0 assumed"));
2105 if (align_bytes && align != 0)
2107 /* convert to a power of 2 alignment */
2108 unsigned int alignp2 = 0;
2109 while ((align & 1) == 0)
2110 align >>= 1, ++alignp2;
2113 as_bad (_("alignment not a power of 2"));
2114 ignore_rest_of_line ();
2122 /* Called from s_comm_internal after symbol name and size have been
2123 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2124 1 if this was a ".bss" directive which has a 3rd argument
2125 (alignment as a power of 2), or 2 if this was a ".bss" directive
2126 with alignment in bytes. */
2129 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2135 align = parse_align (needs_align - 1);
2136 if (align == (addressT) -1)
2140 /* Assume some objects may require alignment on some systems. */
2141 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2143 bss_alloc (symbolP, size, align);
2148 s_lcomm (int needs_align)
2150 s_comm_internal (needs_align, s_lcomm_internal);
2154 s_lcomm_bytes (int needs_align)
2156 s_comm_internal (needs_align * 2, s_lcomm_internal);
2160 s_lsym (int ignore ATTRIBUTE_UNUSED)
2162 register char *name;
2166 register symbolS *symbolP;
2168 /* We permit ANY defined expression: BSD4.2 demands constants. */
2169 name = input_line_pointer;
2170 c = get_symbol_end ();
2171 p = input_line_pointer;
2176 as_bad (_("expected symbol name"));
2177 discard_rest_of_line ();
2183 if (*input_line_pointer != ',')
2186 as_bad (_("expected comma after \"%s\""), name);
2188 ignore_rest_of_line ();
2192 input_line_pointer++;
2195 if (exp.X_op != O_constant
2196 && exp.X_op != O_register)
2198 as_bad (_("bad expression"));
2199 ignore_rest_of_line ();
2204 symbolP = symbol_find_or_make (name);
2206 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2207 symbolP->sy_desc == 0) out of this test because coff doesn't have
2208 those fields, and I can't see when they'd ever be tripped. I
2209 don't think I understand why they were here so I may have
2210 introduced a bug. As recently as 1.37 didn't have this test
2211 anyway. xoxorich. */
2213 if (S_GET_SEGMENT (symbolP) == undefined_section
2214 && S_GET_VALUE (symbolP) == 0)
2216 /* The name might be an undefined .global symbol; be sure to
2217 keep the "external" bit. */
2218 S_SET_SEGMENT (symbolP,
2219 (exp.X_op == O_constant
2222 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2226 as_bad (_("symbol `%s' is already defined"), name);
2230 demand_empty_rest_of_line ();
2233 /* Read a line into an sb. Returns the character that ended the line
2234 or zero if there are no more lines. */
2237 get_line_sb (sb *line)
2239 char quote1, quote2, inquote;
2242 if (input_line_pointer[-1] == '\n')
2243 bump_line_counters ();
2245 if (input_line_pointer >= buffer_limit)
2247 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2248 if (buffer_limit == 0)
2252 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2253 code needs to be changed. */
2262 #ifdef LEX_IS_STRINGQUOTE
2268 while ((c = * input_line_pointer ++) != 0
2269 && (!is_end_of_line[c]
2270 || (inquote != '\0' && c != '\n')))
2274 else if (inquote == '\0')
2278 else if (c == quote2)
2282 sb_add_char (line, c);
2285 /* Don't skip multiple end-of-line characters, because that breaks support
2286 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2287 characters but isn't. Instead just skip one end of line character and
2288 return the character skipped so that the caller can re-insert it if
2293 /* Define a macro. This is an interface to macro.c. */
2296 s_macro (int ignore ATTRIBUTE_UNUSED)
2305 as_where (&file, &line);
2308 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2309 sb_add_char (&s, *input_line_pointer++);
2312 if (line_label != NULL)
2313 sb_add_string (&label, S_GET_NAME (line_label));
2315 err = define_macro (0, &s, &label, get_line_sb, &name);
2317 as_bad_where (file, line, "%s", err);
2320 if (line_label != NULL)
2322 S_SET_SEGMENT (line_label, undefined_section);
2323 S_SET_VALUE (line_label, 0);
2324 symbol_set_frag (line_label, &zero_address_frag);
2327 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2328 && hash_find (po_hash, name) != NULL)
2331 && hash_find (po_hash, name + 1) != NULL))
2332 as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2339 /* Handle the .mexit pseudo-op, which immediately exits a macro
2343 s_mexit (int ignore ATTRIBUTE_UNUSED)
2345 cond_exit_macro (macro_nest);
2346 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2349 /* Switch in and out of MRI mode. */
2352 s_mri (int ignore ATTRIBUTE_UNUSED)
2356 on = get_absolute_expression ();
2357 old_flag = flag_mri;
2375 /* Operator precedence changes in m68k MRI mode, so we need to
2376 update the operator rankings. */
2377 expr_set_precedence ();
2379 #ifdef MRI_MODE_CHANGE
2381 MRI_MODE_CHANGE (on);
2384 demand_empty_rest_of_line ();
2387 /* Handle changing the location counter. */
2390 do_org (segT segment, expressionS *exp, int fill)
2392 if (segment != now_seg && segment != absolute_section)
2393 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2395 if (now_seg == absolute_section)
2398 as_warn (_("ignoring fill value in absolute section"));
2399 if (exp->X_op != O_constant)
2401 as_bad (_("only constant offsets supported in absolute section"));
2402 exp->X_add_number = 0;
2404 abs_section_offset = exp->X_add_number;
2409 symbolS *sym = exp->X_add_symbol;
2410 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2412 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2414 /* Handle complex expressions. */
2415 sym = make_expr_symbol (exp);
2419 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2425 s_org (int ignore ATTRIBUTE_UNUSED)
2427 register segT segment;
2429 register long temp_fill;
2431 #ifdef md_flush_pending_output
2432 md_flush_pending_output ();
2435 /* The m68k MRI assembler has a different meaning for .org. It
2436 means to create an absolute section at a given address. We can't
2437 support that--use a linker script instead. */
2440 as_bad (_("MRI style ORG pseudo-op not supported"));
2441 ignore_rest_of_line ();
2445 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2446 thing as a sub-segment-relative origin. Any absolute origin is
2447 given a warning, then assumed to be segment-relative. Any
2448 segmented origin expression ("foo+42") had better be in the right
2449 segment or the .org is ignored.
2451 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2452 we never know sub-segment sizes when we are reading code. BSD
2453 will crash trying to emit negative numbers of filler bytes in
2454 certain .orgs. We don't crash, but see as-write for that code.
2456 Don't make frag if need_pass_2==1. */
2457 segment = get_known_segmented_expression (&exp);
2458 if (*input_line_pointer == ',')
2460 input_line_pointer++;
2461 temp_fill = get_absolute_expression ();
2467 do_org (segment, &exp, temp_fill);
2469 demand_empty_rest_of_line ();
2472 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2473 called by the obj-format routine which handles section changing
2474 when in MRI mode. It will create a new section, and return it. It
2475 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2476 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2477 flags will be set in the section. */
2480 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2490 name = input_line_pointer;
2491 if (!ISDIGIT (*name))
2492 c = get_symbol_end ();
2497 ++input_line_pointer;
2499 while (ISDIGIT (*input_line_pointer));
2501 c = *input_line_pointer;
2502 *input_line_pointer = '\0';
2505 name = xstrdup (name);
2507 *input_line_pointer = c;
2509 seg = subseg_new (name, 0);
2511 if (*input_line_pointer == ',')
2515 ++input_line_pointer;
2516 align = get_absolute_expression ();
2517 record_alignment (seg, align);
2521 if (*input_line_pointer == ',')
2523 c = *++input_line_pointer;
2525 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2528 as_bad (_("unrecognized section type"));
2529 ++input_line_pointer;
2531 #ifdef BFD_ASSEMBLER
2535 flags = SEC_NO_FLAGS;
2537 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2538 else if (*type == 'D' || *type == 'M')
2539 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2540 else if (*type == 'R')
2541 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2542 if (flags != SEC_NO_FLAGS)
2544 if (!bfd_set_section_flags (stdoutput, seg, flags))
2545 as_warn (_("error setting flags for \"%s\": %s"),
2546 bfd_section_name (stdoutput, seg),
2547 bfd_errmsg (bfd_get_error ()));
2553 /* Ignore the HP type. */
2554 if (*input_line_pointer == ',')
2555 input_line_pointer += 2;
2557 demand_empty_rest_of_line ();
2559 #else /* ! TC_M68K */
2568 name = input_line_pointer;
2569 c = get_symbol_end ();
2571 name = xstrdup (name);
2573 *input_line_pointer = c;
2575 seg = subseg_new (name, 0);
2577 if (*input_line_pointer != ',')
2583 ++input_line_pointer;
2585 sectype = input_line_pointer;
2586 c = get_symbol_end ();
2587 if (*sectype == '\0')
2589 else if (strcasecmp (sectype, "text") == 0)
2591 else if (strcasecmp (sectype, "data") == 0)
2593 else if (strcasecmp (sectype, "romdata") == 0)
2596 as_warn (_("unrecognized section type `%s'"), sectype);
2597 *input_line_pointer = c;
2600 if (*input_line_pointer == ',')
2604 ++input_line_pointer;
2606 seccmd = input_line_pointer;
2607 c = get_symbol_end ();
2608 if (strcasecmp (seccmd, "absolute") == 0)
2610 as_bad (_("absolute sections are not supported"));
2611 *input_line_pointer = c;
2612 ignore_rest_of_line ();
2615 else if (strcasecmp (seccmd, "align") == 0)
2619 *input_line_pointer = c;
2620 align = get_absolute_expression ();
2621 record_alignment (seg, align);
2625 as_warn (_("unrecognized section command `%s'"), seccmd);
2626 *input_line_pointer = c;
2630 demand_empty_rest_of_line ();
2632 #else /* ! TC_I960 */
2633 /* The MRI assembler seems to use different forms of .sect for
2634 different targets. */
2635 as_bad ("MRI mode not supported for this target");
2636 ignore_rest_of_line ();
2637 #endif /* ! TC_I960 */
2638 #endif /* ! TC_M68K */
2641 /* Handle the .print pseudo-op. */
2644 s_print (int ignore ATTRIBUTE_UNUSED)
2649 s = demand_copy_C_string (&len);
2652 demand_empty_rest_of_line ();
2655 /* Handle the .purgem pseudo-op. */
2658 s_purgem (int ignore ATTRIBUTE_UNUSED)
2660 if (is_it_end_of_statement ())
2662 demand_empty_rest_of_line ();
2672 name = input_line_pointer;
2673 c = get_symbol_end ();
2674 delete_macro (name);
2675 *input_line_pointer = c;
2678 while (*input_line_pointer++ == ',');
2680 --input_line_pointer;
2681 demand_empty_rest_of_line ();
2684 /* Handle the .endm/.endr pseudo-ops. */
2687 s_bad_end (int endr)
2689 as_warn (_(".end%c encountered without preceeding %s"),
2691 endr ? ".rept, .irp, or .irpc" : ".macro");
2692 demand_empty_rest_of_line ();
2695 /* Handle the .rept pseudo-op. */
2698 s_rept (int ignore ATTRIBUTE_UNUSED)
2702 count = get_absolute_expression ();
2704 do_repeat (count, "REPT", "ENDR");
2707 /* This function provides a generic repeat block implementation. It allows
2708 different directives to be used as the start/end keys. */
2711 do_repeat (int count, const char *start, const char *end)
2717 if (!buffer_and_nest (start, end, &one, get_line_sb))
2719 as_bad (_("%s without %s"), start, end);
2725 sb_add_sb (&many, &one);
2729 input_scrub_include_sb (&many, input_line_pointer, 1);
2731 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2734 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2735 input buffers to skip. Assumes that conditionals preceding the loop end
2736 are properly nested.
2738 This function makes it easier to implement a premature "break" out of the
2739 loop. The EXTRA arg accounts for other buffers we might have inserted,
2740 such as line substitutions. */
2743 end_repeat (int extra)
2745 cond_exit_macro (macro_nest);
2746 while (extra-- >= 0)
2747 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2751 assign_symbol (const char *name, int no_reassign)
2755 if (name[0] == '.' && name[1] == '\0')
2757 /* Turn '. = mumble' into a .org mumble. */
2761 segment = get_known_segmented_expression (&exp);
2764 do_org (segment, &exp, 0);
2769 if ((symbolP = symbol_find (name)) == NULL
2770 && (symbolP = md_undefined_symbol (name)) == NULL)
2772 symbolP = symbol_find_or_make (name);
2774 /* When doing symbol listings, play games with dummy fragments living
2775 outside the normal fragment chain to record the file and line info
2777 if (listing & LISTING_SYMBOLS)
2779 extern struct list_info_struct *listing_tail;
2780 fragS *dummy_frag = (fragS *) xcalloc (sizeof (fragS));
2781 dummy_frag->line = listing_tail;
2782 dummy_frag->fr_symbol = symbolP;
2783 symbol_set_frag (symbolP, dummy_frag);
2786 #if defined (OBJ_COFF) || defined (OBJ_MAYBE_COFF)
2787 #if defined (BFD_ASSEMBLER) && defined (OBJ_MAYBE_COFF)
2788 if (OUTPUT_FLAVOR == bfd_target_coff_flavour)
2790 /* "set" symbols are local unless otherwise specified. */
2791 SF_SET_LOCAL (symbolP);
2795 /* Permit register names to be redefined. */
2797 && S_IS_DEFINED (symbolP)
2798 && S_GET_SEGMENT (symbolP) != reg_section)
2799 as_bad (_("symbol `%s' is already defined"), name);
2801 pseudo_set (symbolP);
2803 demand_empty_rest_of_line ();
2806 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2807 this is .equiv, and it is an error if the symbol is already
2817 /* Especial apologies for the random logic:
2818 this just grew, and could be parsed much more simply!
2820 name = input_line_pointer;
2821 delim = get_symbol_end ();
2822 end_name = input_line_pointer;
2825 if (name == end_name)
2827 as_bad (_("expected symbol name"));
2828 discard_rest_of_line ();
2834 if (*input_line_pointer != ',')
2837 as_bad (_("expected comma after \"%s\""), name);
2839 ignore_rest_of_line ();
2843 input_line_pointer++;
2846 assign_symbol (name, equiv);
2860 #ifdef md_flush_pending_output
2861 md_flush_pending_output ();
2865 stop = mri_comment_field (&stopc);
2867 /* In m68k MRI mode, we need to align to a word boundary, unless
2869 if (flag_m68k_mri && mult > 1)
2871 if (now_seg == absolute_section)
2873 abs_section_offset += abs_section_offset & 1;
2874 if (line_label != NULL)
2875 S_SET_VALUE (line_label, abs_section_offset);
2877 else if (mri_common_symbol != NULL)
2881 val = S_GET_VALUE (mri_common_symbol);
2884 S_SET_VALUE (mri_common_symbol, val + 1);
2885 if (line_label != NULL)
2887 expressionS *symexp;
2889 symexp = symbol_get_value_expression (line_label);
2890 know (symexp->X_op == O_symbol);
2891 know (symexp->X_add_symbol == mri_common_symbol);
2892 symexp->X_add_number += 1;
2898 do_align (1, (char *) NULL, 0, 0);
2899 if (line_label != NULL)
2901 symbol_set_frag (line_label, frag_now);
2902 S_SET_VALUE (line_label, frag_now_fix ());
2912 if (*input_line_pointer == ',')
2914 ++input_line_pointer;
2919 val.X_op = O_constant;
2920 val.X_add_number = 0;
2923 if (val.X_op != O_constant
2924 || val.X_add_number < - 0x80
2925 || val.X_add_number > 0xff
2926 || (mult != 0 && mult != 1 && val.X_add_number != 0))
2928 if (exp.X_op != O_constant)
2929 as_bad (_("unsupported variable size or fill value"));
2936 bytes = mult * exp.X_add_number;
2937 for (i = 0; i < exp.X_add_number; i++)
2938 emit_expr (&val, mult);
2943 if (exp.X_op == O_constant)
2947 repeat = exp.X_add_number;
2954 as_warn (_(".space repeat count is zero, ignored"));
2955 else if (repeat < 0)
2956 as_warn (_(".space repeat count is negative, ignored"));
2960 /* If we are in the absolute section, just bump the offset. */
2961 if (now_seg == absolute_section)
2963 abs_section_offset += repeat;
2967 /* If we are secretly in an MRI common section, then
2968 creating space just increases the size of the common
2970 if (mri_common_symbol != NULL)
2972 S_SET_VALUE (mri_common_symbol,
2973 S_GET_VALUE (mri_common_symbol) + repeat);
2978 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2979 (offsetT) repeat, (char *) 0);
2983 if (now_seg == absolute_section)
2985 as_bad (_("space allocation too complex in absolute section"));
2986 subseg_set (text_section, 0);
2989 if (mri_common_symbol != NULL)
2991 as_bad (_("space allocation too complex in common section"));
2992 mri_common_symbol = NULL;
2996 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2997 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3001 *p = val.X_add_number;
3006 /* In MRI mode, after an odd number of bytes, we must align to an
3007 even word boundary, unless the next instruction is a dc.b, ds.b
3009 if (flag_mri && (bytes & 1) != 0)
3010 mri_pending_align = 1;
3012 demand_empty_rest_of_line ();
3015 mri_comment_end (stop, stopc);
3018 /* This is like s_space, but the value is a floating point number with
3019 the given precision. This is for the MRI dcb.s pseudo-op and
3023 s_float_space (int float_type)
3027 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3032 stop = mri_comment_field (&stopc);
3034 count = get_absolute_expression ();
3037 if (*input_line_pointer != ',')
3039 as_bad (_("missing value"));
3040 ignore_rest_of_line ();
3042 mri_comment_end (stop, stopc);
3046 ++input_line_pointer;
3050 /* Skip any 0{letter} that may be present. Don't even check if the
3051 * letter is legal. */
3052 if (input_line_pointer[0] == '0'
3053 && ISALPHA (input_line_pointer[1]))
3054 input_line_pointer += 2;
3056 /* Accept :xxxx, where the x's are hex digits, for a floating point
3057 with the exact digits specified. */
3058 if (input_line_pointer[0] == ':')
3060 flen = hex_float (float_type, temp);
3063 ignore_rest_of_line ();
3065 mri_comment_end (stop, stopc);
3073 err = md_atof (float_type, temp, &flen);
3074 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3078 as_bad (_("bad floating literal: %s"), err);
3079 ignore_rest_of_line ();
3081 mri_comment_end (stop, stopc);
3086 while (--count >= 0)
3090 p = frag_more (flen);
3091 memcpy (p, temp, (unsigned int) flen);
3094 demand_empty_rest_of_line ();
3097 mri_comment_end (stop, stopc);
3100 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3103 s_struct (int ignore ATTRIBUTE_UNUSED)
3109 stop = mri_comment_field (&stopc);
3110 abs_section_offset = get_absolute_expression ();
3111 subseg_set (absolute_section, 0);
3112 demand_empty_rest_of_line ();
3114 mri_comment_end (stop, stopc);
3118 s_text (int ignore ATTRIBUTE_UNUSED)
3122 temp = get_absolute_expression ();
3123 subseg_set (text_section, (subsegT) temp);
3124 demand_empty_rest_of_line ();
3126 const_flag &= ~IN_DEFAULT_SECTION;
3131 /* Verify that we are at the end of a line. If not, issue an error and
3135 demand_empty_rest_of_line (void)
3138 if (is_end_of_line[(unsigned char) *input_line_pointer])
3139 input_line_pointer++;
3142 if (ISPRINT (*input_line_pointer))
3143 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3144 *input_line_pointer);
3146 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3147 *input_line_pointer);
3148 ignore_rest_of_line ();
3151 /* Return pointing just after end-of-line. */
3152 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3155 /* Silently advance to the end of line. Use this after already having
3156 issued an error about something bad. */
3159 ignore_rest_of_line (void)
3161 while (input_line_pointer < buffer_limit
3162 && !is_end_of_line[(unsigned char) *input_line_pointer])
3163 input_line_pointer++;
3165 input_line_pointer++;
3167 /* Return pointing just after end-of-line. */
3168 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3172 discard_rest_of_line (void)
3174 while (input_line_pointer < buffer_limit
3175 && !is_end_of_line[(unsigned char) *input_line_pointer])
3176 input_line_pointer++;
3178 input_line_pointer++;
3180 /* Return pointing just after end-of-line. */
3181 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3184 /* Sets frag for given symbol to zero_address_frag, except when the
3185 symbol frag is already set to a dummy listing frag. */
3188 set_zero_frag (symbolS *symbolP)
3190 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3191 symbol_set_frag (symbolP, &zero_address_frag);
3194 /* In: Pointer to a symbol.
3195 Input_line_pointer->expression.
3197 Out: Input_line_pointer->just after any whitespace after expression.
3198 Tried to set symbol to value of expression.
3199 Will change symbols type, value, and frag; */
3202 pseudo_set (symbolS *symbolP)
3206 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3208 #endif /* OBJ_AOUT or OBJ_BOUT */
3210 know (symbolP); /* NULL pointer is logic error. */
3212 (void) expression (&exp);
3214 if (exp.X_op == O_illegal)
3215 as_bad (_("illegal expression"));
3216 else if (exp.X_op == O_absent)
3217 as_bad (_("missing expression"));
3218 else if (exp.X_op == O_big)
3220 if (exp.X_add_number > 0)
3221 as_bad (_("bignum invalid"));
3223 as_bad (_("floating point number invalid"));
3225 else if (exp.X_op == O_subtract
3226 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3227 && (symbol_get_frag (exp.X_add_symbol)
3228 == symbol_get_frag (exp.X_op_symbol)))
3230 exp.X_op = O_constant;
3231 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3232 - S_GET_VALUE (exp.X_op_symbol));
3235 if (symbol_section_p (symbolP))
3237 as_bad ("attempt to set value of section symbol");
3240 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3241 ext = S_IS_EXTERNAL (symbolP);
3242 #endif /* OBJ_AOUT or OBJ_BOUT */
3249 exp.X_add_number = 0;
3252 S_SET_SEGMENT (symbolP, absolute_section);
3253 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3254 set_zero_frag (symbolP);
3258 S_SET_SEGMENT (symbolP, reg_section);
3259 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3260 set_zero_frag (symbolP);
3264 seg = S_GET_SEGMENT (exp.X_add_symbol);
3265 /* For x=undef+const, create an expression symbol.
3266 For x=x+const, just update x except when x is an undefined symbol
3267 For x=defined+const, evaluate x. */
3268 if (symbolP == exp.X_add_symbol
3269 && (seg != undefined_section
3270 || !symbol_constant_p (symbolP)))
3272 *symbol_X_add_number (symbolP) += exp.X_add_number;
3275 else if (seg != undefined_section)
3277 symbolS *s = exp.X_add_symbol;
3279 S_SET_SEGMENT (symbolP, seg);
3280 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3281 symbol_set_frag (symbolP, symbol_get_frag (s));
3282 copy_symbol_attributes (symbolP, s);
3288 /* The value is some complex expression.
3289 Set segment and frag back to that of a newly created symbol. */
3290 S_SET_SEGMENT (symbolP, undefined_section);
3291 symbol_set_value_expression (symbolP, &exp);
3292 set_zero_frag (symbolP);
3296 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3298 S_SET_EXTERNAL (symbolP);
3300 S_CLEAR_EXTERNAL (symbolP);
3301 #endif /* OBJ_AOUT or OBJ_BOUT */
3306 CONStruct more frag of .bytes, or .words etc.
3307 Should need_pass_2 be 1 then emit no frag(s).
3308 This understands EXPRESSIONS.
3312 This has a split personality. We use expression() to read the
3313 value. We can detect if the value won't fit in a byte or word.
3314 But we can't detect if expression() discarded significant digits
3315 in the case of a long. Not worth the crocks required to fix it. */
3317 /* Select a parser for cons expressions. */
3319 /* Some targets need to parse the expression in various fancy ways.
3320 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3321 (for example, the HPPA does this). Otherwise, you can define
3322 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3323 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3324 are defined, which is the normal case, then only simple expressions
3329 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3332 #ifndef TC_PARSE_CONS_EXPRESSION
3333 #ifdef BITFIELD_CONS_EXPRESSIONS
3334 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3336 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3338 #ifdef REPEAT_CONS_EXPRESSIONS
3339 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3341 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3344 /* If we haven't gotten one yet, just call expression. */
3345 #ifndef TC_PARSE_CONS_EXPRESSION
3346 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3351 do_parse_cons_expression (expressionS *exp,
3352 int nbytes ATTRIBUTE_UNUSED)
3354 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3358 /* Worker to do .byte etc statements.
3359 Clobbers input_line_pointer and checks end-of-line. */
3362 cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3370 #ifdef md_flush_pending_output
3371 md_flush_pending_output ();
3375 stop = mri_comment_field (&stopc);
3377 if (is_it_end_of_statement ())
3379 demand_empty_rest_of_line ();
3381 mri_comment_end (stop, stopc);
3385 #ifdef TC_ADDRESS_BYTES
3387 nbytes = TC_ADDRESS_BYTES ();
3390 #ifdef md_cons_align
3391 md_cons_align (nbytes);
3399 parse_mri_cons (&exp, (unsigned int) nbytes);
3402 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3406 if (exp.X_op == O_symbol)
3407 exp.X_op = O_symbol_rva;
3409 as_fatal (_("rva without symbol"));
3411 emit_expr (&exp, (unsigned int) nbytes);
3414 while (*input_line_pointer++ == ',');
3416 /* In MRI mode, after an odd number of bytes, we must align to an
3417 even word boundary, unless the next instruction is a dc.b, ds.b
3419 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3420 mri_pending_align = 1;
3422 input_line_pointer--; /* Put terminator back into stream. */
3424 demand_empty_rest_of_line ();
3427 mri_comment_end (stop, stopc);
3433 cons_worker (size, 0);
3439 cons_worker (size, 1);
3442 /* Put the contents of expression EXP into the object file using
3443 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3446 emit_expr (expressionS *exp, unsigned int nbytes)
3450 valueT extra_digit = 0;
3452 /* Don't do anything if we are going to make another pass. */
3456 dot_value = frag_now_fix ();
3460 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3461 appear as a four byte positive constant in the .line section,
3462 followed by a 2 byte 0xffff. Look for that case here. */
3464 static int dwarf_line = -1;
3466 if (strcmp (segment_name (now_seg), ".line") != 0)
3468 else if (dwarf_line >= 0
3470 && exp->X_op == O_constant
3471 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3472 listing_source_line ((unsigned int) dwarf_line);
3473 else if (nbytes == 4
3474 && exp->X_op == O_constant
3475 && exp->X_add_number >= 0)
3476 dwarf_line = exp->X_add_number;
3481 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3482 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3483 AT_sibling (0x12) followed by a four byte address of the sibling
3484 followed by a 2 byte AT_name (0x38) followed by the name of the
3485 file. We look for that case here. */
3487 static int dwarf_file = 0;
3489 if (strcmp (segment_name (now_seg), ".debug") != 0)
3491 else if (dwarf_file == 0
3493 && exp->X_op == O_constant
3494 && exp->X_add_number == 0x11)
3496 else if (dwarf_file == 1
3498 && exp->X_op == O_constant
3499 && exp->X_add_number == 0x12)
3501 else if (dwarf_file == 2
3504 else if (dwarf_file == 3
3506 && exp->X_op == O_constant
3507 && exp->X_add_number == 0x38)
3512 /* The variable dwarf_file_string tells stringer that the string
3513 may be the name of the source file. */
3514 if (dwarf_file == 4)
3515 dwarf_file_string = 1;
3517 dwarf_file_string = 0;
3522 if (check_eh_frame (exp, &nbytes))
3527 /* Allow `.word 0' in the absolute section. */
3528 if (now_seg == absolute_section)
3530 if (op != O_constant || exp->X_add_number != 0)
3531 as_bad (_("attempt to store value in absolute section"));
3532 abs_section_offset += nbytes;
3536 /* Handle a negative bignum. */
3538 && exp->X_add_number == 0
3539 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3540 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3543 unsigned long carry;
3545 exp = symbol_get_value_expression (exp->X_add_symbol);
3547 /* Negate the bignum: one's complement each digit and add 1. */
3549 for (i = 0; i < exp->X_add_number; i++)
3553 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3556 generic_bignum[i] = next & LITTLENUM_MASK;
3557 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3560 /* We can ignore any carry out, because it will be handled by
3561 extra_digit if it is needed. */
3563 extra_digit = (valueT) -1;
3567 if (op == O_absent || op == O_illegal)
3569 as_warn (_("zero assumed for missing expression"));
3570 exp->X_add_number = 0;
3573 else if (op == O_big && exp->X_add_number <= 0)
3575 as_bad (_("floating point number invalid"));
3576 exp->X_add_number = 0;
3579 else if (op == O_register)
3581 as_warn (_("register value used as expression"));
3585 p = frag_more ((int) nbytes);
3587 #ifndef WORKING_DOT_WORD
3588 /* If we have the difference of two symbols in a word, save it on
3589 the broken_words list. See the code in write.c. */
3590 if (op == O_subtract && nbytes == 2)
3592 struct broken_word *x;
3594 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3595 x->next_broken_word = broken_words;
3598 x->subseg = now_subseg;
3600 x->word_goes_here = p;
3602 x->add = exp->X_add_symbol;
3603 x->sub = exp->X_op_symbol;
3604 x->addnum = exp->X_add_number;
3612 /* If we have an integer, but the number of bytes is too large to
3613 pass to md_number_to_chars, handle it as a bignum. */
3614 if (op == O_constant && nbytes > sizeof (valueT))
3616 extra_digit = exp->X_unsigned ? 0 : -1;
3617 convert_to_bignum (exp);
3621 if (op == O_constant)
3623 register valueT get;
3624 register valueT use;
3625 register valueT mask;
3627 register valueT unmask;
3629 /* JF << of >= number of bits in the object is undefined. In
3630 particular SPARC (Sun 4) has problems. */
3631 if (nbytes >= sizeof (valueT))
3634 if (nbytes > sizeof (valueT))
3637 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3641 /* Don't store these bits. */
3642 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3643 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3646 unmask = ~mask; /* Do store these bits. */
3649 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3650 mask = ~(unmask >> 1); /* Includes sign bit now. */
3653 get = exp->X_add_number;
3655 if ((get & mask) != 0
3656 && ((get & mask) != mask
3657 || (get & hibit) == 0))
3658 { /* Leading bits contain both 0s & 1s. */
3659 as_warn (_("value 0x%lx truncated to 0x%lx"),
3660 (unsigned long) get, (unsigned long) use);
3662 /* Put bytes in right order. */
3663 md_number_to_chars (p, use, (int) nbytes);
3665 else if (op == O_big)
3668 LITTLENUM_TYPE *nums;
3670 know (nbytes % CHARS_PER_LITTLENUM == 0);
3672 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3675 as_warn (_("bignum truncated to %d bytes"), nbytes);
3679 if (target_big_endian)
3681 while (nbytes > size)
3683 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3684 nbytes -= CHARS_PER_LITTLENUM;
3685 p += CHARS_PER_LITTLENUM;
3688 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3689 while (size >= CHARS_PER_LITTLENUM)
3692 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3693 size -= CHARS_PER_LITTLENUM;
3694 p += CHARS_PER_LITTLENUM;
3699 nums = generic_bignum;
3700 while (size >= CHARS_PER_LITTLENUM)
3702 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3704 size -= CHARS_PER_LITTLENUM;
3705 p += CHARS_PER_LITTLENUM;
3706 nbytes -= CHARS_PER_LITTLENUM;
3709 while (nbytes >= CHARS_PER_LITTLENUM)
3711 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3712 nbytes -= CHARS_PER_LITTLENUM;
3713 p += CHARS_PER_LITTLENUM;
3719 memset (p, 0, nbytes);
3721 /* Now we need to generate a fixS to record the symbol value.
3722 This is easy for BFD. For other targets it can be more
3723 complex. For very complex cases (currently, the HPPA and
3724 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3725 want. For simpler cases, you can define TC_CONS_RELOC to be
3726 the name of the reloc code that should be stored in the fixS.
3727 If neither is defined, the code uses NO_RELOC if it is
3728 defined, and otherwise uses 0. */
3730 #ifdef BFD_ASSEMBLER
3731 #ifdef TC_CONS_FIX_NEW
3732 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3735 bfd_reloc_code_real_type r;
3752 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3756 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3761 #ifdef TC_CONS_FIX_NEW
3762 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3764 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3765 it is defined, otherwise use NO_RELOC if it is defined,
3767 #ifndef TC_CONS_RELOC
3769 #define TC_CONS_RELOC NO_RELOC
3771 #define TC_CONS_RELOC 0
3774 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3776 #endif /* TC_CONS_FIX_NEW */
3777 #endif /* BFD_ASSEMBLER */
3781 #ifdef BITFIELD_CONS_EXPRESSIONS
3783 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3784 w:x,y:z, where w and y are bitwidths and x and y are values. They
3785 then pack them all together. We do a little better in that we allow
3786 them in words, longs, etc. and we'll pack them in target byte order
3789 The rules are: pack least significant bit first, if a field doesn't
3790 entirely fit, put it in the next unit. Overflowing the bitfield is
3791 explicitly *not* even a warning. The bitwidth should be considered
3794 To use this function the tc-XXX.h file should define
3795 BITFIELD_CONS_EXPRESSIONS. */
3798 parse_bitfield_cons (exp, nbytes)
3800 unsigned int nbytes;
3802 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3803 char *hold = input_line_pointer;
3805 (void) expression (exp);
3807 if (*input_line_pointer == ':')
3814 unsigned long width;
3816 if (*input_line_pointer != ':')
3818 input_line_pointer = hold;
3820 } /* Next piece is not a bitfield. */
3822 /* In the general case, we can't allow
3823 full expressions with symbol
3824 differences and such. The relocation
3825 entries for symbols not defined in this
3826 assembly would require arbitrary field
3827 widths, positions, and masks which most
3828 of our current object formats don't
3831 In the specific case where a symbol
3832 *is* defined in this assembly, we
3833 *could* build fixups and track it, but
3834 this could lead to confusion for the
3835 backends. I'm lazy. I'll take any
3836 SEG_ABSOLUTE. I think that means that
3837 you can use a previous .set or
3838 .equ type symbol. xoxorich. */
3840 if (exp->X_op == O_absent)
3842 as_warn (_("using a bit field width of zero"));
3843 exp->X_add_number = 0;
3844 exp->X_op = O_constant;
3845 } /* Implied zero width bitfield. */
3847 if (exp->X_op != O_constant)
3849 *input_line_pointer = '\0';
3850 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3851 *input_line_pointer = ':';
3852 demand_empty_rest_of_line ();
3854 } /* Too complex. */
3856 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3858 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3859 width, nbytes, (BITS_PER_CHAR * nbytes));
3860 width = BITS_PER_CHAR * nbytes;
3863 if (width > bits_available)
3865 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3866 input_line_pointer = hold;
3867 exp->X_add_number = value;
3872 hold = ++input_line_pointer;
3874 (void) expression (exp);
3875 if (exp->X_op != O_constant)
3877 char cache = *input_line_pointer;
3879 *input_line_pointer = '\0';
3880 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3881 *input_line_pointer = cache;
3882 demand_empty_rest_of_line ();
3884 } /* Too complex. */
3886 value |= ((~(-1 << width) & exp->X_add_number)
3887 << ((BITS_PER_CHAR * nbytes) - bits_available));
3889 if ((bits_available -= width) == 0
3890 || is_it_end_of_statement ()
3891 || *input_line_pointer != ',')
3894 } /* All the bitfields we're gonna get. */
3896 hold = ++input_line_pointer;
3897 (void) expression (exp);
3900 exp->X_add_number = value;
3901 exp->X_op = O_constant;
3902 exp->X_unsigned = 1;
3906 #endif /* BITFIELD_CONS_EXPRESSIONS */
3908 /* Handle an MRI style string expression. */
3912 parse_mri_cons (exp, nbytes)
3914 unsigned int nbytes;
3916 if (*input_line_pointer != '\''
3917 && (input_line_pointer[1] != '\''
3918 || (*input_line_pointer != 'A'
3919 && *input_line_pointer != 'E')))
3920 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3924 unsigned int result = 0;
3926 /* An MRI style string. Cut into as many bytes as will fit into
3927 a nbyte chunk, left justify if necessary, and separate with
3928 commas so we can try again later. */
3929 if (*input_line_pointer == 'A')
3930 ++input_line_pointer;
3931 else if (*input_line_pointer == 'E')
3933 as_bad (_("EBCDIC constants are not supported"));
3934 ++input_line_pointer;
3937 input_line_pointer++;
3938 for (scan = 0; scan < nbytes; scan++)
3940 if (*input_line_pointer == '\'')
3942 if (input_line_pointer[1] == '\'')
3944 input_line_pointer++;
3949 result = (result << 8) | (*input_line_pointer++);
3953 while (scan < nbytes)
3959 /* Create correct expression. */
3960 exp->X_op = O_constant;
3961 exp->X_add_number = result;
3963 /* Fake it so that we can read the next char too. */
3964 if (input_line_pointer[0] != '\'' ||
3965 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3967 input_line_pointer -= 2;
3968 input_line_pointer[0] = ',';
3969 input_line_pointer[1] = '\'';
3972 input_line_pointer++;
3975 #endif /* TC_M68K */
3977 #ifdef REPEAT_CONS_EXPRESSIONS
3979 /* Parse a repeat expression for cons. This is used by the MIPS
3980 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3981 object file COUNT times.
3983 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3986 parse_repeat_cons (exp, nbytes)
3988 unsigned int nbytes;
3995 if (*input_line_pointer != ':')
3997 /* No repeat count. */
4001 ++input_line_pointer;
4002 expression (&count);
4003 if (count.X_op != O_constant
4004 || count.X_add_number <= 0)
4006 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4010 /* The cons function is going to output this expression once. So we
4011 output it count - 1 times. */
4012 for (i = count.X_add_number - 1; i > 0; i--)
4013 emit_expr (exp, nbytes);
4016 #endif /* REPEAT_CONS_EXPRESSIONS */
4018 /* Parse a floating point number represented as a hex constant. This
4019 permits users to specify the exact bits they want in the floating
4023 hex_float (int float_type, char *bytes)
4055 as_bad (_("unknown floating type type '%c'"), float_type);
4059 /* It would be nice if we could go through expression to parse the
4060 hex constant, but if we get a bignum it's a pain to sort it into
4061 the buffer correctly. */
4063 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4067 /* The MRI assembler accepts arbitrary underscores strewn about
4068 through the hex constant, so we ignore them as well. */
4069 if (*input_line_pointer == '_')
4071 ++input_line_pointer;
4077 as_warn (_("floating point constant too large"));
4080 d = hex_value (*input_line_pointer) << 4;
4081 ++input_line_pointer;
4082 while (*input_line_pointer == '_')
4083 ++input_line_pointer;
4084 if (hex_p (*input_line_pointer))
4086 d += hex_value (*input_line_pointer);
4087 ++input_line_pointer;
4089 if (target_big_endian)
4092 bytes[length - i - 1] = d;
4098 if (target_big_endian)
4099 memset (bytes + i, 0, length - i);
4101 memset (bytes, 0, length - i);
4109 CONStruct some more frag chars of .floats .ffloats etc.
4110 Makes 0 or more new frags.
4111 If need_pass_2 == 1, no frags are emitted.
4112 This understands only floating literals, not expressions. Sorry.
4114 A floating constant is defined by atof_generic(), except it is preceded
4115 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4116 reading, I decided to be incompatible. This always tries to give you
4117 rounded bits to the precision of the pseudo-op. Former AS did premature
4118 truncation, restored noisy bits instead of trailing 0s AND gave you
4119 a choice of 2 flavours of noise according to which of 2 floating-point
4120 scanners you directed AS to use.
4122 In: input_line_pointer->whitespace before, or '0' of flonum. */
4125 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4126 register int float_type /* 'f':.ffloat ... 'F':.float ... */)
4129 int length; /* Number of chars in an object. */
4130 register char *err; /* Error from scanning floating literal. */
4131 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4133 if (is_it_end_of_statement ())
4135 demand_empty_rest_of_line ();
4139 #ifdef md_flush_pending_output
4140 md_flush_pending_output ();
4145 /* input_line_pointer->1st char of a flonum (we hope!). */
4148 /* Skip any 0{letter} that may be present. Don't even check if the
4149 letter is legal. Someone may invent a "z" format and this routine
4150 has no use for such information. Lusers beware: you get
4151 diagnostics if your input is ill-conditioned. */
4152 if (input_line_pointer[0] == '0'
4153 && ISALPHA (input_line_pointer[1]))
4154 input_line_pointer += 2;
4156 /* Accept :xxxx, where the x's are hex digits, for a floating
4157 point with the exact digits specified. */
4158 if (input_line_pointer[0] == ':')
4160 ++input_line_pointer;
4161 length = hex_float (float_type, temp);
4164 ignore_rest_of_line ();
4170 err = md_atof (float_type, temp, &length);
4171 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4175 as_bad (_("bad floating literal: %s"), err);
4176 ignore_rest_of_line ();
4187 #ifdef REPEAT_CONS_EXPRESSIONS
4188 if (*input_line_pointer == ':')
4190 expressionS count_exp;
4192 ++input_line_pointer;
4193 expression (&count_exp);
4195 if (count_exp.X_op != O_constant
4196 || count_exp.X_add_number <= 0)
4197 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4199 count = count_exp.X_add_number;
4203 while (--count >= 0)
4205 p = frag_more (length);
4206 memcpy (p, temp, (unsigned int) length);
4211 while (*input_line_pointer++ == ',');
4213 /* Put terminator back into stream. */
4214 --input_line_pointer;
4215 demand_empty_rest_of_line ();
4218 /* Return the size of a LEB128 value. */
4221 sizeof_sleb128 (offsetT value)
4223 register int size = 0;
4224 register unsigned byte;
4228 byte = (value & 0x7f);
4229 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4230 Fortunately, we can structure things so that the extra work reduces
4231 to a noop on systems that do things "properly". */
4232 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4235 while (!(((value == 0) && ((byte & 0x40) == 0))
4236 || ((value == -1) && ((byte & 0x40) != 0))));
4242 sizeof_uleb128 (valueT value)
4244 register int size = 0;
4245 register unsigned byte;
4249 byte = (value & 0x7f);
4259 sizeof_leb128 (valueT value, int sign)
4262 return sizeof_sleb128 ((offsetT) value);
4264 return sizeof_uleb128 (value);
4267 /* Output a LEB128 value. */
4270 output_sleb128 (char *p, offsetT value)
4272 register char *orig = p;
4277 unsigned byte = (value & 0x7f);
4279 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4280 Fortunately, we can structure things so that the extra work reduces
4281 to a noop on systems that do things "properly". */
4282 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4284 more = !((((value == 0) && ((byte & 0x40) == 0))
4285 || ((value == -1) && ((byte & 0x40) != 0))));
4297 output_uleb128 (char *p, valueT value)
4303 unsigned byte = (value & 0x7f);
4306 /* More bytes to follow. */
4317 output_leb128 (char *p, valueT value, int sign)
4320 return output_sleb128 (p, (offsetT) value);
4322 return output_uleb128 (p, value);
4325 /* Do the same for bignums. We combine sizeof with output here in that
4326 we don't output for NULL values of P. It isn't really as critical as
4327 for "normal" values that this be streamlined. */
4330 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4337 /* Strip leading sign extensions off the bignum. */
4339 && bignum[size - 1] == LITTLENUM_MASK
4340 && bignum[size - 2] > LITTLENUM_MASK / 2)
4345 /* OR in the next part of the littlenum. */
4346 val |= (*bignum << loaded);
4347 loaded += LITTLENUM_NUMBER_OF_BITS;
4351 /* Add bytes until there are less than 7 bits left in VAL
4352 or until every non-sign bit has been written. */
4359 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4366 while ((byte & 0x80) != 0 && loaded >= 7);
4370 /* Mop up any left-over bits (of which there will be less than 7). */
4371 if ((byte & 0x80) != 0)
4373 /* Sign-extend VAL. */
4374 if (val & (1 << (loaded - 1)))
4375 val |= ~0 << loaded;
4385 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4392 /* Strip leading zeros off the bignum. */
4393 /* XXX: Is this needed? */
4394 while (size > 0 && bignum[size - 1] == 0)
4399 if (loaded < 7 && size > 0)
4401 val |= (*bignum << loaded);
4402 loaded += 8 * CHARS_PER_LITTLENUM;
4411 if (size > 0 || val)
4418 while (byte & 0x80);
4424 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4427 return output_big_sleb128 (p, bignum, size);
4429 return output_big_uleb128 (p, bignum, size);
4432 /* Generate the appropriate fragments for a given expression to emit a
4436 emit_leb128_expr (expressionS *exp, int sign)
4438 operatorT op = exp->X_op;
4439 unsigned int nbytes;
4441 if (op == O_absent || op == O_illegal)
4443 as_warn (_("zero assumed for missing expression"));
4444 exp->X_add_number = 0;
4447 else if (op == O_big && exp->X_add_number <= 0)
4449 as_bad (_("floating point number invalid"));
4450 exp->X_add_number = 0;
4453 else if (op == O_register)
4455 as_warn (_("register value used as expression"));
4458 else if (op == O_constant
4460 && (exp->X_add_number < 0) != !exp->X_unsigned)
4462 /* We're outputting a signed leb128 and the sign of X_add_number
4463 doesn't reflect the sign of the original value. Convert EXP
4464 to a correctly-extended bignum instead. */
4465 convert_to_bignum (exp);
4469 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4470 a signal that this is leb128 data. It shouldn't optimize this away. */
4471 nbytes = (unsigned int) -1;
4472 if (check_eh_frame (exp, &nbytes))
4475 /* Let the backend know that subsequent data may be byte aligned. */
4476 #ifdef md_cons_align
4480 if (op == O_constant)
4482 /* If we've got a constant, emit the thing directly right now. */
4484 valueT value = exp->X_add_number;
4488 size = sizeof_leb128 (value, sign);
4489 p = frag_more (size);
4490 output_leb128 (p, value, sign);
4492 else if (op == O_big)
4494 /* O_big is a different sort of constant. */
4499 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4500 p = frag_more (size);
4501 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4505 /* Otherwise, we have to create a variable sized fragment and
4506 resolve things later. */
4508 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4509 make_expr_symbol (exp), 0, (char *) NULL);
4513 /* Parse the .sleb128 and .uleb128 pseudos. */
4520 #ifdef md_flush_pending_output
4521 md_flush_pending_output ();
4527 emit_leb128_expr (&exp, sign);
4529 while (*input_line_pointer++ == ',');
4531 input_line_pointer--;
4532 demand_empty_rest_of_line ();
4535 /* We read 0 or more ',' separated, double-quoted strings.
4536 Caller should have checked need_pass_2 is FALSE because we don't
4540 stringer (/* Worker to do .ascii etc statements. */
4541 /* Checks end-of-line. */
4542 register int append_zero /* 0: don't append '\0', else 1. */)
4544 register unsigned int c;
4547 #ifdef md_flush_pending_output
4548 md_flush_pending_output ();
4551 /* The following awkward logic is to parse ZERO or more strings,
4552 comma separated. Recall a string expression includes spaces
4553 before the opening '\"' and spaces after the closing '\"'.
4554 We fake a leading ',' if there is (supposed to be)
4555 a 1st, expression. We keep demanding expressions for each ','. */
4556 if (is_it_end_of_statement ())
4558 c = 0; /* Skip loop. */
4559 ++input_line_pointer; /* Compensate for end of loop. */
4563 c = ','; /* Do loop. */
4565 /* If we have been switched into the abs_section then we
4566 will not have an obstack onto which we can hang strings. */
4567 if (now_seg == absolute_section)
4569 as_bad (_("strings must be placed into a section"));
4571 ignore_rest_of_line ();
4574 while (c == ',' || c == '<' || c == '"')
4577 switch (*input_line_pointer)
4580 ++input_line_pointer; /*->1st char of string. */
4581 start = input_line_pointer;
4582 while (is_a_char (c = next_char_of_string ()))
4584 FRAG_APPEND_1_CHAR (c);
4588 FRAG_APPEND_1_CHAR (0);
4590 know (input_line_pointer[-1] == '\"');
4594 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4595 will emit .string with a filename in the .debug section
4596 after a sequence of constants. See the comment in
4597 emit_expr for the sequence. emit_expr will set
4598 dwarf_file_string to non-zero if this string might be a
4599 source file name. */
4600 if (strcmp (segment_name (now_seg), ".debug") != 0)
4601 dwarf_file_string = 0;
4602 else if (dwarf_file_string)
4604 c = input_line_pointer[-1];
4605 input_line_pointer[-1] = '\0';
4606 listing_source_file (start);
4607 input_line_pointer[-1] = c;
4614 input_line_pointer++;
4615 c = get_single_number ();
4616 FRAG_APPEND_1_CHAR (c);
4617 if (*input_line_pointer != '>')
4619 as_bad (_("expected <nn>"));
4621 input_line_pointer++;
4624 input_line_pointer++;
4628 c = *input_line_pointer;
4631 demand_empty_rest_of_line ();
4634 /* FIXME-SOMEDAY: I had trouble here on characters with the
4635 high bits set. We'll probably also have trouble with
4636 multibyte chars, wide chars, etc. Also be careful about
4637 returning values bigger than 1 byte. xoxorich. */
4640 next_char_of_string (void)
4642 register unsigned int c;
4644 c = *input_line_pointer++ & CHAR_MASK;
4652 as_warn (_("unterminated string; newline inserted"));
4653 bump_line_counters ();
4656 #ifndef NO_STRING_ESCAPES
4658 switch (c = *input_line_pointer++)
4686 break; /* As itself. */
4702 for (i = 0, number = 0;
4703 ISDIGIT (c) && i < 3;
4704 c = *input_line_pointer++, i++)
4706 number = number * 8 + c - '0';
4711 --input_line_pointer;
4720 c = *input_line_pointer++;
4721 while (ISXDIGIT (c))
4724 number = number * 16 + c - '0';
4725 else if (ISUPPER (c))
4726 number = number * 16 + c - 'A' + 10;
4728 number = number * 16 + c - 'a' + 10;
4729 c = *input_line_pointer++;
4732 --input_line_pointer;
4737 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4738 as_warn (_("unterminated string; newline inserted"));
4740 bump_line_counters ();
4745 #ifdef ONLY_STANDARD_ESCAPES
4746 as_bad (_("bad escaped character in string"));
4748 #endif /* ONLY_STANDARD_ESCAPES */
4753 #endif /* ! defined (NO_STRING_ESCAPES) */
4762 get_segmented_expression (register expressionS *expP)
4764 register segT retval;
4766 retval = expression (expP);
4767 if (expP->X_op == O_illegal
4768 || expP->X_op == O_absent
4769 || expP->X_op == O_big)
4771 as_bad (_("expected address expression"));
4772 expP->X_op = O_constant;
4773 expP->X_add_number = 0;
4774 retval = absolute_section;
4780 get_known_segmented_expression (register expressionS *expP)
4782 register segT retval;
4784 if ((retval = get_segmented_expression (expP)) == undefined_section)
4786 /* There is no easy way to extract the undefined symbol from the
4788 if (expP->X_add_symbol != NULL
4789 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4790 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4791 S_GET_NAME (expP->X_add_symbol));
4793 as_warn (_("some symbol undefined; zero assumed"));
4794 retval = absolute_section;
4795 expP->X_op = O_constant;
4796 expP->X_add_number = 0;
4798 know (retval == absolute_section || SEG_NORMAL (retval));
4803 get_absolute_expr (expressionS *exp)
4806 if (exp->X_op != O_constant)
4808 if (exp->X_op != O_absent)
4809 as_bad (_("bad or irreducible absolute expression"));
4810 exp->X_add_number = 0;
4812 return exp->X_add_number;
4816 get_absolute_expression (void)
4820 return get_absolute_expr (&exp);
4823 char /* Return terminator. */
4824 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
4826 /* FIXME: val_pointer should probably be offsetT *. */
4827 *val_pointer = (long) get_absolute_expression ();
4828 return (*input_line_pointer++);
4831 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4832 Give a warning if that happens. */
4835 demand_copy_C_string (int *len_pointer)
4839 if ((s = demand_copy_string (len_pointer)) != 0)
4843 for (len = *len_pointer; len > 0; len--)
4850 as_bad (_("this string may not contain \'\\0\'"));
4858 /* Demand string, but return a safe (=private) copy of the string.
4859 Return NULL if we can't read a string here. */
4862 demand_copy_string (int *lenP)
4864 register unsigned int c;
4870 if (*input_line_pointer == '\"')
4872 input_line_pointer++; /* Skip opening quote. */
4874 while (is_a_char (c = next_char_of_string ()))
4876 obstack_1grow (¬es, c);
4879 /* JF this next line is so demand_copy_C_string will return a
4880 null terminated string. */
4881 obstack_1grow (¬es, '\0');
4882 retval = obstack_finish (¬es);
4886 as_bad (_("missing string"));
4888 ignore_rest_of_line ();
4894 /* In: Input_line_pointer->next character.
4896 Do: Skip input_line_pointer over all whitespace.
4898 Out: 1 if input_line_pointer->end-of-line. */
4901 is_it_end_of_statement (void)
4904 return (is_end_of_line[(unsigned char) *input_line_pointer]);
4908 equals (char *sym_name, int reassign)
4913 input_line_pointer++;
4914 if (*input_line_pointer == '=')
4915 input_line_pointer++;
4917 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4918 input_line_pointer++;
4921 stop = mri_comment_field (&stopc);
4923 assign_symbol (sym_name, !reassign);
4926 mri_comment_end (stop, stopc);
4929 /* .incbin -- include a file verbatim at the current location. */
4932 s_incbin (int x ATTRIBUTE_UNUSED)
4943 #ifdef md_flush_pending_output
4944 md_flush_pending_output ();
4948 filename = demand_copy_string (& len);
4949 if (filename == NULL)
4954 /* Look for optional skip and count. */
4955 if (* input_line_pointer == ',')
4957 ++ input_line_pointer;
4958 skip = get_absolute_expression ();
4962 if (* input_line_pointer == ',')
4964 ++ input_line_pointer;
4966 count = get_absolute_expression ();
4968 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
4974 demand_empty_rest_of_line ();
4976 /* Try opening absolute path first, then try include dirs. */
4977 binfile = fopen (filename, FOPEN_RB);
4978 if (binfile == NULL)
4982 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
4984 for (i = 0; i < include_dir_count; i++)
4986 sprintf (path, "%s/%s", include_dirs[i], filename);
4988 binfile = fopen (path, FOPEN_RB);
4989 if (binfile != NULL)
4993 if (binfile == NULL)
4994 as_bad (_("file not found: %s"), filename);
4997 path = xstrdup (filename);
5003 register_dependency (path);
5005 /* Compute the length of the file. */
5006 if (fseek (binfile, 0, SEEK_END) != 0)
5008 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5011 file_len = ftell (binfile);
5013 /* If a count was not specified use the remainder of the file. */
5015 count = file_len - skip;
5017 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5019 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5020 skip, count, file_len);
5024 if (fseek (binfile, skip, SEEK_SET) != 0)
5026 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5030 /* Allocate frag space and store file contents in it. */
5031 binfrag = frag_more (count);
5033 bytes = fread (binfrag, 1, count, binfile);
5035 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5036 path, bytes, count);
5039 if (binfile != NULL)
5045 /* .include -- include a file at this point. */
5048 s_include (int arg ATTRIBUTE_UNUSED)
5057 filename = demand_copy_string (&i);
5058 if (filename == NULL)
5060 /* demand_copy_string has already printed an error and
5061 called ignore_rest_of_line. */
5069 while (!is_end_of_line[(unsigned char) *input_line_pointer]
5070 && *input_line_pointer != ' '
5071 && *input_line_pointer != '\t')
5073 obstack_1grow (¬es, *input_line_pointer);
5074 ++input_line_pointer;
5078 obstack_1grow (¬es, '\0');
5079 filename = obstack_finish (¬es);
5080 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5081 ++input_line_pointer;
5084 demand_empty_rest_of_line ();
5085 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
5087 for (i = 0; i < include_dir_count; i++)
5089 strcpy (path, include_dirs[i]);
5091 strcat (path, filename);
5092 if (0 != (try = fopen (path, FOPEN_RT)))
5102 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5103 register_dependency (path);
5104 input_scrub_insert_file (path);
5108 add_include_dir (char *path)
5112 if (include_dir_count == 0)
5114 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5115 include_dirs[0] = "."; /* Current dir. */
5116 include_dir_count = 2;
5120 include_dir_count++;
5122 (char **) realloc (include_dirs,
5123 include_dir_count * sizeof (*include_dirs));
5126 include_dirs[include_dir_count - 1] = path; /* New one. */
5129 if (i > include_dir_maxlen)
5130 include_dir_maxlen = i;
5133 /* Output debugging information to denote the source file. */
5136 generate_file_debug (void)
5138 if (debug_type == DEBUG_STABS)
5139 stabs_generate_asm_file ();
5142 /* Output line number debugging information for the current source line. */
5145 generate_lineno_debug (void)
5149 case DEBUG_UNSPECIFIED:
5154 stabs_generate_asm_lineno ();
5157 ecoff_generate_asm_lineno ();
5160 /* ??? We could here indicate to dwarf2dbg.c that something
5161 has changed. However, since there is additional backend
5162 support that is required (calling dwarf2_emit_insn), we
5163 let dwarf2dbg.c call as_where on its own. */
5168 /* Output debugging information to mark a function entry point or end point.
5169 END_P is zero for .func, and non-zero for .endfunc. */
5174 do_s_func (end_p, NULL);
5177 /* Subroutine of s_func so targets can choose a different default prefix.
5178 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5181 do_s_func (int end_p, const char *default_prefix)
5183 /* Record the current function so that we can issue an error message for
5184 misplaced .func,.endfunc, and also so that .endfunc needs no
5186 static char *current_name;
5187 static char *current_label;
5191 if (current_name == NULL)
5193 as_bad (_("missing .func"));
5194 ignore_rest_of_line ();
5198 if (debug_type == DEBUG_STABS)
5199 stabs_generate_asm_endfunc (current_name, current_label);
5201 current_name = current_label = NULL;
5206 char delim1, delim2;
5208 if (current_name != NULL)
5210 as_bad (_(".endfunc missing for previous .func"));
5211 ignore_rest_of_line ();
5215 name = input_line_pointer;
5216 delim1 = get_symbol_end ();
5217 name = xstrdup (name);
5218 *input_line_pointer = delim1;
5220 if (*input_line_pointer != ',')
5223 asprintf (&label, "%s%s", default_prefix, name);
5226 char leading_char = 0;
5227 #ifdef BFD_ASSEMBLER
5228 leading_char = bfd_get_symbol_leading_char (stdoutput);
5230 /* Missing entry point, use function's name with the leading
5233 asprintf (&label, "%c%s", leading_char, name);
5240 ++input_line_pointer;
5242 label = input_line_pointer;
5243 delim2 = get_symbol_end ();
5244 label = xstrdup (label);
5245 *input_line_pointer = delim2;
5248 if (debug_type == DEBUG_STABS)
5249 stabs_generate_asm_func (name, label);
5251 current_name = name;
5252 current_label = label;
5255 demand_empty_rest_of_line ();
5259 s_ignore (int arg ATTRIBUTE_UNUSED)
5261 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5263 ++input_line_pointer;
5265 ++input_line_pointer;
5269 read_print_statistics (FILE *file)
5271 hash_print_statistics (file, "pseudo-op table", po_hash);
5274 /* Inserts the given line into the input stream.
5276 This call avoids macro/conditionals nesting checking, since the contents of
5277 the line are assumed to replace the contents of a line already scanned.
5279 An appropriate use of this function would be substitution of input lines when
5280 called by md_start_line_hook(). The given line is assumed to already be
5281 properly scrubbed. */
5284 input_scrub_insert_line (const char *line)
5288 sb_add_string (&newline, line);
5289 input_scrub_include_sb (&newline, input_line_pointer, 0);
5291 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5294 /* Insert a file into the input stream; the path must resolve to an actual
5295 file; no include path searching or dependency registering is performed. */
5298 input_scrub_insert_file (char *path)
5300 input_scrub_include_file (path, input_line_pointer);
5301 buffer_limit = input_scrub_next_buffer (&input_line_pointer);