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] == '='))
737 demand_empty_rest_of_line ();
741 /* Expect pseudo-op or machine instruction. */
744 #ifndef TC_CASE_SENSITIVE
748 strncpy (original_case_string, s2, sizeof (original_case_string));
749 original_case_string[sizeof (original_case_string) - 1] = 0;
758 if (NO_PSEUDO_DOT || flag_m68k_mri)
760 /* The MRI assembler and the m88k use pseudo-ops
762 pop = (pseudo_typeS *) hash_find (po_hash, s);
763 if (pop != NULL && pop->poc_handler == NULL)
768 || (!flag_m68k_mri && *s == '.'))
772 WARNING: c has next char, which may be end-of-line.
773 We lookup the pseudo-op table with s+1 because we
774 already know that the pseudo-op begins with a '.'. */
777 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
778 if (pop && !pop->poc_handler)
781 /* In MRI mode, we may need to insert an
782 automatic alignment directive. What a hack
784 if (mri_pending_align
786 || !((pop->poc_handler == cons
787 && pop->poc_val == 1)
788 || (pop->poc_handler == s_space
789 && pop->poc_val == 1)
790 #ifdef tc_conditional_pseudoop
791 || tc_conditional_pseudoop (pop)
793 || pop->poc_handler == s_if
794 || pop->poc_handler == s_ifdef
795 || pop->poc_handler == s_ifc
796 || pop->poc_handler == s_ifeqs
797 || pop->poc_handler == s_else
798 || pop->poc_handler == s_endif
799 || pop->poc_handler == s_globl
800 || pop->poc_handler == s_ignore)))
802 do_align (1, (char *) NULL, 0, 0);
803 mri_pending_align = 0;
805 if (line_label != NULL)
807 symbol_set_frag (line_label, frag_now);
808 S_SET_VALUE (line_label, frag_now_fix ());
812 /* Print the error msg now, while we still can. */
815 as_bad (_("unknown pseudo-op: `%s'"), s);
816 *input_line_pointer = c;
821 /* Put it back for error messages etc. */
822 *input_line_pointer = c;
823 /* The following skip of whitespace is compulsory.
824 A well shaped space is sometimes all that separates
825 keyword from operands. */
826 if (c == ' ' || c == '\t')
827 input_line_pointer++;
829 /* Input_line is restored.
830 Input_line_pointer->1st non-blank char
831 after pseudo-operation. */
832 (*pop->poc_handler) (pop->poc_val);
834 /* If that was .end, just get out now. */
835 if (pop->poc_handler == s_end)
841 #ifdef QUOTES_IN_INSN
845 /* WARNING: c has char, which may be end-of-line. */
846 /* Also: input_line_pointer->`\0` where c was. */
847 *input_line_pointer = c;
848 while (!is_end_of_line[(unsigned char) *input_line_pointer]
850 #ifdef TC_EOL_IN_INSN
851 || TC_EOL_IN_INSN (input_line_pointer)
855 if (flag_m68k_mri && *input_line_pointer == '\'')
857 #ifdef QUOTES_IN_INSN
860 else if (*input_line_pointer == '"')
862 else if (*input_line_pointer == '\\')
865 input_line_pointer++;
868 c = *input_line_pointer;
869 *input_line_pointer = '\0';
871 generate_lineno_debug ();
879 if (check_macro (s, &out, &err, ¯o))
883 *input_line_pointer++ = c;
884 input_scrub_include_sb (&out,
885 input_line_pointer, 1);
888 input_scrub_next_buffer (&input_line_pointer);
890 md_macro_info (macro);
896 if (mri_pending_align)
898 do_align (1, (char *) NULL, 0, 0);
899 mri_pending_align = 0;
900 if (line_label != NULL)
902 symbol_set_frag (line_label, frag_now);
903 S_SET_VALUE (line_label, frag_now_fix ());
907 md_assemble (s); /* Assemble 1 instruction. */
909 *input_line_pointer++ = c;
911 /* We resume loop AFTER the end-of-line from
918 /* Empty statement? */
919 if (is_end_of_line[(unsigned char) c])
922 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
924 /* local label ("4:") */
925 char *backup = input_line_pointer;
927 HANDLE_CONDITIONAL_ASSEMBLY ();
931 /* Read the whole number. */
932 while (ISDIGIT (*input_line_pointer))
934 temp = (temp * 10) + *input_line_pointer - '0';
935 ++input_line_pointer;
938 if (LOCAL_LABELS_DOLLAR
939 && *input_line_pointer == '$'
940 && *(input_line_pointer + 1) == ':')
942 input_line_pointer += 2;
944 if (dollar_label_defined (temp))
946 as_fatal (_("label \"%d$\" redefined"), temp);
949 define_dollar_label (temp);
950 colon (dollar_label_name (temp, 0));
955 && *input_line_pointer++ == ':')
957 fb_label_instance_inc (temp);
958 colon (fb_label_name (temp, 0));
962 input_line_pointer = backup;
963 } /* local label ("4:") */
965 if (c && strchr (line_comment_chars, c))
966 { /* Its a comment. Better say APP or NO_APP. */
971 unsigned int new_length;
974 bump_line_counters ();
975 s = input_line_pointer;
976 if (strncmp (s, "APP\n", 4))
977 continue; /* We ignore it */
981 ends = strstr (s, "#NO_APP\n");
985 unsigned int tmp_len;
988 /* The end of the #APP wasn't in this buffer. We
989 keep reading in buffers until we find the #NO_APP
990 that goes with this #APP There is one. The specs
992 tmp_len = buffer_limit - s;
993 tmp_buf = xmalloc (tmp_len + 1);
994 memcpy (tmp_buf, s, tmp_len);
997 new_tmp = input_scrub_next_buffer (&buffer);
1001 buffer_limit = new_tmp;
1002 input_line_pointer = buffer;
1003 ends = strstr (buffer, "#NO_APP\n");
1005 num = ends - buffer;
1007 num = buffer_limit - buffer;
1009 tmp_buf = xrealloc (tmp_buf, tmp_len + num);
1010 memcpy (tmp_buf + tmp_len, buffer, num);
1015 input_line_pointer = ends ? ends + 8 : NULL;
1023 input_line_pointer = ends + 8;
1027 scrub_string_end = ends;
1029 new_length = ends - s;
1030 new_buf = (char *) xmalloc (new_length);
1037 space = (new_buf + new_length) - new_tmp;
1038 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1046 new_buf = xrealloc (new_buf, new_length + 100);
1047 new_tmp = new_buf + new_length;
1054 /* We've "scrubbed" input to the preferred format. In the
1055 process we may have consumed the whole of the remaining
1056 file (and included files). We handle this formatted
1057 input similar to that of macro expansion, letting
1058 actual macro expansion (possibly nested) and other
1059 input expansion work. Beware that in messages, line
1060 numbers and possibly file names will be incorrect. */
1061 sb_add_string (&sbuf, new_buf);
1062 input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1064 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1069 HANDLE_CONDITIONAL_ASSEMBLY ();
1071 #ifdef tc_unrecognized_line
1072 if (tc_unrecognized_line (c))
1075 input_line_pointer--;
1076 /* Report unknown char as ignored. */
1077 demand_empty_rest_of_line ();
1080 #ifdef md_after_pass_hook
1081 md_after_pass_hook ();
1090 /* Close the input file. */
1091 input_scrub_close ();
1092 #ifdef WARN_COMMENTS
1094 if (warn_comment && found_comment)
1095 as_warn_where (found_comment_file, found_comment,
1096 "first comment found here");
1101 /* Convert O_constant expression EXP into the equivalent O_big representation.
1102 Take the sign of the number from X_unsigned rather than X_add_number. */
1105 convert_to_bignum (expressionS *exp)
1110 value = exp->X_add_number;
1111 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1113 generic_bignum[i] = value & LITTLENUM_MASK;
1114 value >>= LITTLENUM_NUMBER_OF_BITS;
1116 /* Add a sequence of sign bits if the top bit of X_add_number is not
1117 the sign of the original value. */
1118 if ((exp->X_add_number < 0) != !exp->X_unsigned)
1119 generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1121 exp->X_add_number = i;
1124 /* For most MRI pseudo-ops, the line actually ends at the first
1125 nonquoted space. This function looks for that point, stuffs a null
1126 in, and sets *STOPCP to the character that used to be there, and
1127 returns the location.
1129 Until I hear otherwise, I am going to assume that this is only true
1130 for the m68k MRI assembler. */
1133 mri_comment_field (char *stopcp)
1139 know (flag_m68k_mri);
1141 for (s = input_line_pointer;
1142 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1150 for (s = input_line_pointer;
1151 !is_end_of_line[(unsigned char) *s];
1161 /* Skip to the end of an MRI comment field. */
1164 mri_comment_end (char *stop, int stopc)
1168 input_line_pointer = stop;
1170 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1171 ++input_line_pointer;
1175 s_abort (int ignore ATTRIBUTE_UNUSED)
1177 as_fatal (_(".abort detected. Abandoning ship."));
1180 /* Guts of .align directive. N is the power of two to which to align.
1181 FILL may be NULL, or it may point to the bytes of the fill pattern.
1182 LEN is the length of whatever FILL points to, if anything. MAX is
1183 the maximum number of characters to skip when doing the alignment,
1184 or 0 if there is no maximum. */
1187 do_align (int n, char *fill, int len, int max)
1189 if (now_seg == absolute_section)
1193 if (*fill++ != '\0')
1195 as_warn (_("ignoring fill value in absolute section"));
1202 #ifdef md_flush_pending_output
1203 md_flush_pending_output ();
1206 md_do_align (n, fill, len, max, just_record_alignment);
1209 /* Only make a frag if we HAVE to... */
1210 if (n != 0 && !need_pass_2)
1214 if (subseg_text_p (now_seg))
1215 frag_align_code (n, max);
1217 frag_align (n, 0, max);
1220 frag_align (n, *fill, max);
1222 frag_align_pattern (n, fill, len, max);
1226 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1229 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1232 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1233 (in bytes). A negative ARG is the negative of the length of the
1234 fill pattern. BYTES_P is non-zero if the alignment value should be
1235 interpreted as the byte boundary, rather than the power of 2. */
1237 #ifdef BFD_ASSEMBLER
1238 #define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1240 #define ALIGN_LIMIT 15
1244 s_align (int arg, int bytes_p)
1246 unsigned int align_limit = ALIGN_LIMIT;
1255 stop = mri_comment_field (&stopc);
1257 if (is_end_of_line[(unsigned char) *input_line_pointer])
1262 align = arg; /* Default value from pseudo-op table. */
1266 align = get_absolute_expression ();
1272 /* Convert to a power of 2. */
1277 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1280 as_bad (_("alignment not a power of 2"));
1286 if (align > align_limit)
1288 align = align_limit;
1289 as_warn (_("alignment too large: %u assumed"), align);
1292 if (*input_line_pointer != ',')
1299 ++input_line_pointer;
1300 if (*input_line_pointer == ',')
1304 fill = get_absolute_expression ();
1309 if (*input_line_pointer != ',')
1313 ++input_line_pointer;
1314 max = get_absolute_expression ();
1321 as_warn (_("expected fill pattern missing"));
1322 do_align (align, (char *) NULL, 0, max);
1337 do_align (align, &fill_char, fill_len, max);
1343 if ((size_t) fill_len > sizeof ab)
1345 md_number_to_chars (ab, fill, fill_len);
1346 do_align (align, ab, fill_len, max);
1350 demand_empty_rest_of_line ();
1353 mri_comment_end (stop, stopc);
1356 /* Handle the .align pseudo-op on machines where ".align 4" means
1357 align to a 4 byte boundary. */
1360 s_align_bytes (int arg)
1365 /* Handle the .align pseudo-op on machines where ".align 4" means align
1366 to a 2**4 boundary. */
1369 s_align_ptwo (int arg)
1374 /* Switch in and out of alternate macro mode. */
1379 demand_empty_rest_of_line ();
1380 macro_set_alternate (on);
1384 s_comm_internal (int param,
1385 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1391 symbolS *symbolP = NULL;
1397 stop = mri_comment_field (&stopc);
1399 name = input_line_pointer;
1400 c = get_symbol_end ();
1401 /* Just after name is now '\0'. */
1402 p = input_line_pointer;
1407 as_bad (_("expected symbol name"));
1408 discard_rest_of_line ();
1414 /* Accept an optional comma after the name. The comma used to be
1415 required, but Irix 5 cc does not generate it for .lcomm. */
1416 if (*input_line_pointer == ',')
1417 input_line_pointer++;
1419 temp = get_absolute_expr (&exp);
1421 #ifdef BFD_ASSEMBLER
1422 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1424 if (exp.X_op == O_absent)
1426 as_bad (_("missing size expression"));
1427 ignore_rest_of_line ();
1430 else if (temp != size || !exp.X_unsigned)
1432 as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1433 ignore_rest_of_line ();
1438 symbolP = symbol_find_or_make (name);
1439 if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
1442 as_bad (_("symbol `%s' is already defined"), name);
1444 ignore_rest_of_line ();
1448 size = S_GET_VALUE (symbolP);
1451 else if (size != temp)
1452 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1453 name, (long) size, (long) temp);
1456 if (comm_parse_extra != NULL)
1457 symbolP = (*comm_parse_extra) (param, symbolP, size);
1460 S_SET_VALUE (symbolP, (valueT) size);
1461 S_SET_EXTERNAL (symbolP);
1464 extern int flag_one;
1465 if (size == 0 || !flag_one)
1466 S_GET_OTHER (symbolP) = const_flag;
1471 know (symbolP == NULL || symbolP->sy_frag == &zero_address_frag);
1472 demand_empty_rest_of_line ();
1475 mri_comment_end (stop, stopc);
1482 s_comm_internal (ignore, NULL);
1485 /* The MRI COMMON pseudo-op. We handle this by creating a common
1486 symbol with the appropriate name. We make s_space do the right
1487 thing by increasing the size. */
1490 s_mri_common (int small ATTRIBUTE_UNUSED)
1506 stop = mri_comment_field (&stopc);
1510 name = input_line_pointer;
1511 if (!ISDIGIT (*name))
1512 c = get_symbol_end ();
1517 ++input_line_pointer;
1519 while (ISDIGIT (*input_line_pointer));
1521 c = *input_line_pointer;
1522 *input_line_pointer = '\0';
1524 if (line_label != NULL)
1526 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1527 + (input_line_pointer - name)
1529 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1534 sym = symbol_find_or_make (name);
1535 *input_line_pointer = c;
1539 if (*input_line_pointer != ',')
1543 ++input_line_pointer;
1544 align = get_absolute_expression ();
1547 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1549 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1550 ignore_rest_of_line ();
1551 mri_comment_end (stop, stopc);
1555 S_SET_EXTERNAL (sym);
1556 mri_common_symbol = sym;
1560 S_SET_ALIGN (sym, align);
1563 if (line_label != NULL)
1566 exp.X_op = O_symbol;
1567 exp.X_add_symbol = sym;
1568 exp.X_add_number = 0;
1569 symbol_set_value_expression (line_label, &exp);
1570 symbol_set_frag (line_label, &zero_address_frag);
1571 S_SET_SEGMENT (line_label, expr_section);
1574 /* FIXME: We just ignore the small argument, which distinguishes
1575 COMMON and COMMON.S. I don't know what we can do about it. */
1577 /* Ignore the type and hptype. */
1578 if (*input_line_pointer == ',')
1579 input_line_pointer += 2;
1580 if (*input_line_pointer == ',')
1581 input_line_pointer += 2;
1583 demand_empty_rest_of_line ();
1585 mri_comment_end (stop, stopc);
1589 s_data (int ignore ATTRIBUTE_UNUSED)
1594 temp = get_absolute_expression ();
1595 if (flag_readonly_data_in_text)
1597 section = text_section;
1601 section = data_section;
1603 subseg_set (section, (subsegT) temp);
1608 demand_empty_rest_of_line ();
1611 /* Handle the .appfile pseudo-op. This is automatically generated by
1612 do_scrub_chars when a preprocessor # line comment is seen with a
1613 file name. This default definition may be overridden by the object
1614 or CPU specific pseudo-ops. This function is also the default
1615 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1619 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1623 listing_source_file (file);
1625 register_dependency (file);
1627 obj_app_file (file, appfile);
1632 s_app_file (int appfile)
1637 /* Some assemblers tolerate immediately following '"'. */
1638 if ((s = demand_copy_string (&length)) != 0)
1640 /* If this is a fake .appfile, a fake newline was inserted into
1641 the buffer. Passing -2 to new_logical_line tells it to
1644 = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
1646 /* In MRI mode, the preprocessor may have inserted an extraneous
1649 && *input_line_pointer == '\''
1650 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1651 ++input_line_pointer;
1653 demand_empty_rest_of_line ();
1655 s_app_file_string (s, appfile);
1659 /* Handle the .appline pseudo-op. This is automatically generated by
1660 do_scrub_chars when a preprocessor # line comment is seen. This
1661 default definition may be overridden by the object or CPU specific
1665 s_app_line (int ignore ATTRIBUTE_UNUSED)
1669 /* The given number is that of the next line. */
1670 l = get_absolute_expression () - 1;
1672 /* Some of the back ends can't deal with non-positive line numbers.
1673 Besides, it's silly. */
1674 as_warn (_("line numbers must be positive; line number %d rejected"),
1678 new_logical_line ((char *) NULL, l);
1681 listing_source_line (l);
1684 demand_empty_rest_of_line ();
1687 /* Handle the .end pseudo-op. Actually, the real work is done in
1688 read_a_source_file. */
1691 s_end (int ignore ATTRIBUTE_UNUSED)
1695 /* The MRI assembler permits the start symbol to follow .end,
1696 but we don't support that. */
1698 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1699 && *input_line_pointer != '*'
1700 && *input_line_pointer != '!')
1701 as_warn (_("start address not supported"));
1705 /* Handle the .err pseudo-op. */
1708 s_err (int ignore ATTRIBUTE_UNUSED)
1710 as_bad (_(".err encountered"));
1711 demand_empty_rest_of_line ();
1714 /* Handle the .error and .warning pseudo-ops. */
1720 /* The purpose for the conditional assignment is not to
1721 internationalize the directive itself, but that we need a
1722 self-contained message, one that can be passed like the
1723 demand_copy_C_string return value, and with no assumption on the
1724 location of the name of the directive within the message. */
1726 = (err ? _(".error directive invoked in source file")
1727 : _(".warning directive invoked in source file"));
1729 if (!is_it_end_of_statement ())
1731 if (*input_line_pointer != '\"')
1733 as_bad (_("%s argument must be a string"),
1734 err ? ".error" : ".warning");
1735 discard_rest_of_line ();
1739 msg = demand_copy_C_string (&len);
1747 as_warn ("%s", msg);
1748 demand_empty_rest_of_line ();
1751 /* Handle the MRI fail pseudo-op. */
1754 s_fail (int ignore ATTRIBUTE_UNUSED)
1761 stop = mri_comment_field (&stopc);
1763 temp = get_absolute_expression ();
1765 as_warn (_(".fail %ld encountered"), (long) temp);
1767 as_bad (_(".fail %ld encountered"), (long) temp);
1769 demand_empty_rest_of_line ();
1772 mri_comment_end (stop, stopc);
1776 s_fill (int ignore ATTRIBUTE_UNUSED)
1778 expressionS rep_exp;
1780 register long fill = 0;
1783 #ifdef md_flush_pending_output
1784 md_flush_pending_output ();
1787 get_known_segmented_expression (&rep_exp);
1788 if (*input_line_pointer == ',')
1790 input_line_pointer++;
1791 size = get_absolute_expression ();
1792 if (*input_line_pointer == ',')
1794 input_line_pointer++;
1795 fill = get_absolute_expression ();
1799 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1800 #define BSD_FILL_SIZE_CROCK_8 (8)
1801 if (size > BSD_FILL_SIZE_CROCK_8)
1803 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1804 size = BSD_FILL_SIZE_CROCK_8;
1808 as_warn (_("size negative; .fill ignored"));
1811 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1813 if (rep_exp.X_add_number < 0)
1814 as_warn (_("repeat < 0; .fill ignored"));
1818 if (size && !need_pass_2)
1820 if (rep_exp.X_op == O_constant)
1822 p = frag_var (rs_fill, (int) size, (int) size,
1823 (relax_substateT) 0, (symbolS *) 0,
1824 (offsetT) rep_exp.X_add_number,
1829 /* We don't have a constant repeat count, so we can't use
1830 rs_fill. We can get the same results out of rs_space,
1831 but its argument is in bytes, so we must multiply the
1832 repeat count by size. */
1835 rep_sym = make_expr_symbol (&rep_exp);
1838 expressionS size_exp;
1839 size_exp.X_op = O_constant;
1840 size_exp.X_add_number = size;
1842 rep_exp.X_op = O_multiply;
1843 rep_exp.X_add_symbol = rep_sym;
1844 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1845 rep_exp.X_add_number = 0;
1846 rep_sym = make_expr_symbol (&rep_exp);
1849 p = frag_var (rs_space, (int) size, (int) size,
1850 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1853 memset (p, 0, (unsigned int) size);
1855 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1856 flavoured AS. The following bizarre behaviour is to be
1857 compatible with above. I guess they tried to take up to 8
1858 bytes from a 4-byte expression and they forgot to sign
1860 #define BSD_FILL_SIZE_CROCK_4 (4)
1861 md_number_to_chars (p, (valueT) fill,
1862 (size > BSD_FILL_SIZE_CROCK_4
1863 ? BSD_FILL_SIZE_CROCK_4
1865 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1866 but emits no error message because it seems a legal thing to do.
1867 It is a degenerate case of .fill but could be emitted by a
1870 demand_empty_rest_of_line ();
1874 s_globl (int ignore ATTRIBUTE_UNUSED)
1883 stop = mri_comment_field (&stopc);
1887 name = input_line_pointer;
1888 c = get_symbol_end ();
1889 symbolP = symbol_find_or_make (name);
1890 S_SET_EXTERNAL (symbolP);
1892 *input_line_pointer = c;
1894 c = *input_line_pointer;
1897 input_line_pointer++;
1899 if (is_end_of_line[(unsigned char) *input_line_pointer])
1905 demand_empty_rest_of_line ();
1908 mri_comment_end (stop, stopc);
1911 /* Handle the MRI IRP and IRPC pseudo-ops. */
1922 as_where (&file, &line);
1925 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1926 sb_add_char (&s, *input_line_pointer++);
1930 err = expand_irp (irpc, 0, &s, &out, get_line_sb);
1932 as_bad_where (file, line, "%s", err);
1936 input_scrub_include_sb (&out, input_line_pointer, 1);
1938 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1941 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1942 the section to only be linked once. However, this is not supported
1943 by most object file formats. This takes an optional argument,
1944 which is what to do about duplicates. */
1947 s_linkonce (int ignore ATTRIBUTE_UNUSED)
1949 enum linkonce_type type;
1953 type = LINKONCE_DISCARD;
1955 if (!is_end_of_line[(unsigned char) *input_line_pointer])
1960 s = input_line_pointer;
1961 c = get_symbol_end ();
1962 if (strcasecmp (s, "discard") == 0)
1963 type = LINKONCE_DISCARD;
1964 else if (strcasecmp (s, "one_only") == 0)
1965 type = LINKONCE_ONE_ONLY;
1966 else if (strcasecmp (s, "same_size") == 0)
1967 type = LINKONCE_SAME_SIZE;
1968 else if (strcasecmp (s, "same_contents") == 0)
1969 type = LINKONCE_SAME_CONTENTS;
1971 as_warn (_("unrecognized .linkonce type `%s'"), s);
1973 *input_line_pointer = c;
1976 #ifdef obj_handle_link_once
1977 obj_handle_link_once (type);
1978 #else /* ! defined (obj_handle_link_once) */
1979 #ifdef BFD_ASSEMBLER
1983 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
1984 as_warn (_(".linkonce is not supported for this object file format"));
1986 flags = bfd_get_section_flags (stdoutput, now_seg);
1987 flags |= SEC_LINK_ONCE;
1992 case LINKONCE_DISCARD:
1993 flags |= SEC_LINK_DUPLICATES_DISCARD;
1995 case LINKONCE_ONE_ONLY:
1996 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1998 case LINKONCE_SAME_SIZE:
1999 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2001 case LINKONCE_SAME_CONTENTS:
2002 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2005 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2006 as_bad (_("bfd_set_section_flags: %s"),
2007 bfd_errmsg (bfd_get_error ()));
2009 #else /* ! defined (BFD_ASSEMBLER) */
2010 as_warn (_(".linkonce is not supported for this object file format"));
2011 #endif /* ! defined (BFD_ASSEMBLER) */
2012 #endif /* ! defined (obj_handle_link_once) */
2014 demand_empty_rest_of_line ();
2018 bss_alloc (symbolS *symbolP, addressT size, int align)
2021 segT current_seg = now_seg;
2022 subsegT current_subseg = now_subseg;
2023 segT bss_seg = bss_section;
2025 #if defined (TC_MIPS) || defined (TC_ALPHA)
2026 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2027 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2029 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2030 if (size <= bfd_get_gp_size (stdoutput))
2032 bss_seg = subseg_new (".sbss", 1);
2033 seg_info (bss_seg)->bss = 1;
2034 #ifdef BFD_ASSEMBLER
2035 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2036 as_warn (_("error setting flags for \".sbss\": %s"),
2037 bfd_errmsg (bfd_get_error ()));
2042 subseg_set (bss_seg, 1);
2046 record_alignment (bss_seg, align);
2047 frag_align (align, 0, 0);
2050 /* Detach from old frag. */
2051 if (S_GET_SEGMENT (symbolP) == bss_seg)
2052 symbol_get_frag (symbolP)->fr_symbol = NULL;
2054 symbol_set_frag (symbolP, frag_now);
2055 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2059 S_SET_SIZE (symbolP, size);
2061 S_SET_SEGMENT (symbolP, bss_seg);
2064 /* The symbol may already have been created with a preceding
2065 ".globl" directive -- be careful not to step on storage class
2066 in that case. Otherwise, set it to static. */
2067 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2068 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2069 #endif /* OBJ_COFF */
2071 subseg_set (current_seg, current_subseg);
2075 parse_align (int align_bytes)
2081 if (*input_line_pointer != ',')
2084 as_bad (_("expected alignment after size"));
2085 ignore_rest_of_line ();
2089 input_line_pointer++;
2092 align = get_absolute_expr (&exp);
2093 if (exp.X_op == O_absent)
2096 if (!exp.X_unsigned)
2098 as_warn (_("alignment negative; 0 assumed"));
2102 if (align_bytes && align != 0)
2104 /* convert to a power of 2 alignment */
2105 unsigned int alignp2 = 0;
2106 while ((align & 1) == 0)
2107 align >>= 1, ++alignp2;
2110 as_bad (_("alignment not a power of 2"));
2111 ignore_rest_of_line ();
2119 /* Called from s_comm_internal after symbol name and size have been
2120 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2121 1 if this was a ".bss" directive which has a 3rd argument
2122 (alignment as a power of 2), or 2 if this was a ".bss" directive
2123 with alignment in bytes. */
2126 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2132 align = parse_align (needs_align - 1);
2133 if (align == (addressT) -1)
2137 /* Assume some objects may require alignment on some systems. */
2138 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2140 bss_alloc (symbolP, size, align);
2145 s_lcomm (int needs_align)
2147 s_comm_internal (needs_align, s_lcomm_internal);
2151 s_lcomm_bytes (int needs_align)
2153 s_comm_internal (needs_align * 2, s_lcomm_internal);
2157 s_lsym (int ignore ATTRIBUTE_UNUSED)
2159 register char *name;
2163 register symbolS *symbolP;
2165 /* We permit ANY defined expression: BSD4.2 demands constants. */
2166 name = input_line_pointer;
2167 c = get_symbol_end ();
2168 p = input_line_pointer;
2173 as_bad (_("expected symbol name"));
2174 discard_rest_of_line ();
2180 if (*input_line_pointer != ',')
2183 as_bad (_("expected comma after \"%s\""), name);
2185 ignore_rest_of_line ();
2189 input_line_pointer++;
2192 if (exp.X_op != O_constant
2193 && exp.X_op != O_register)
2195 as_bad (_("bad expression"));
2196 ignore_rest_of_line ();
2201 symbolP = symbol_find_or_make (name);
2203 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2204 symbolP->sy_desc == 0) out of this test because coff doesn't have
2205 those fields, and I can't see when they'd ever be tripped. I
2206 don't think I understand why they were here so I may have
2207 introduced a bug. As recently as 1.37 didn't have this test
2208 anyway. xoxorich. */
2210 if (S_GET_SEGMENT (symbolP) == undefined_section
2211 && S_GET_VALUE (symbolP) == 0)
2213 /* The name might be an undefined .global symbol; be sure to
2214 keep the "external" bit. */
2215 S_SET_SEGMENT (symbolP,
2216 (exp.X_op == O_constant
2219 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2223 as_bad (_("symbol `%s' is already defined"), name);
2227 demand_empty_rest_of_line ();
2230 /* Read a line into an sb. Returns the character that ended the line
2231 or zero if there are no more lines. */
2234 get_line_sb (sb *line)
2236 char quote1, quote2, inquote;
2239 if (input_line_pointer[-1] == '\n')
2240 bump_line_counters ();
2242 if (input_line_pointer >= buffer_limit)
2244 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2245 if (buffer_limit == 0)
2249 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2250 code needs to be changed. */
2259 #ifdef LEX_IS_STRINGQUOTE
2265 while ((c = * input_line_pointer ++) != 0
2266 && (!is_end_of_line[c]
2267 || (inquote != '\0' && c != '\n')))
2271 else if (inquote == '\0')
2275 else if (c == quote2)
2279 sb_add_char (line, c);
2282 /* Don't skip multiple end-of-line characters, because that breaks support
2283 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2284 characters but isn't. Instead just skip one end of line character and
2285 return the character skipped so that the caller can re-insert it if
2290 /* Define a macro. This is an interface to macro.c. */
2293 s_macro (int ignore ATTRIBUTE_UNUSED)
2302 as_where (&file, &line);
2305 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2306 sb_add_char (&s, *input_line_pointer++);
2309 if (line_label != NULL)
2310 sb_add_string (&label, S_GET_NAME (line_label));
2312 err = define_macro (0, &s, &label, get_line_sb, &name);
2314 as_bad_where (file, line, "%s", err);
2317 if (line_label != NULL)
2319 S_SET_SEGMENT (line_label, undefined_section);
2320 S_SET_VALUE (line_label, 0);
2321 symbol_set_frag (line_label, &zero_address_frag);
2324 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2325 && hash_find (po_hash, name) != NULL)
2328 && hash_find (po_hash, name + 1) != NULL))
2329 as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2336 /* Handle the .mexit pseudo-op, which immediately exits a macro
2340 s_mexit (int ignore ATTRIBUTE_UNUSED)
2342 cond_exit_macro (macro_nest);
2343 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2346 /* Switch in and out of MRI mode. */
2349 s_mri (int ignore ATTRIBUTE_UNUSED)
2353 on = get_absolute_expression ();
2354 old_flag = flag_mri;
2372 /* Operator precedence changes in m68k MRI mode, so we need to
2373 update the operator rankings. */
2374 expr_set_precedence ();
2376 #ifdef MRI_MODE_CHANGE
2378 MRI_MODE_CHANGE (on);
2381 demand_empty_rest_of_line ();
2384 /* Handle changing the location counter. */
2387 do_org (segT segment, expressionS *exp, int fill)
2389 if (segment != now_seg && segment != absolute_section)
2390 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2392 if (now_seg == absolute_section)
2395 as_warn (_("ignoring fill value in absolute section"));
2396 if (exp->X_op != O_constant)
2398 as_bad (_("only constant offsets supported in absolute section"));
2399 exp->X_add_number = 0;
2401 abs_section_offset = exp->X_add_number;
2406 symbolS *sym = exp->X_add_symbol;
2407 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2409 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2411 /* Handle complex expressions. */
2412 sym = make_expr_symbol (exp);
2416 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2422 s_org (int ignore ATTRIBUTE_UNUSED)
2424 register segT segment;
2426 register long temp_fill;
2428 #ifdef md_flush_pending_output
2429 md_flush_pending_output ();
2432 /* The m68k MRI assembler has a different meaning for .org. It
2433 means to create an absolute section at a given address. We can't
2434 support that--use a linker script instead. */
2437 as_bad (_("MRI style ORG pseudo-op not supported"));
2438 ignore_rest_of_line ();
2442 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2443 thing as a sub-segment-relative origin. Any absolute origin is
2444 given a warning, then assumed to be segment-relative. Any
2445 segmented origin expression ("foo+42") had better be in the right
2446 segment or the .org is ignored.
2448 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2449 we never know sub-segment sizes when we are reading code. BSD
2450 will crash trying to emit negative numbers of filler bytes in
2451 certain .orgs. We don't crash, but see as-write for that code.
2453 Don't make frag if need_pass_2==1. */
2454 segment = get_known_segmented_expression (&exp);
2455 if (*input_line_pointer == ',')
2457 input_line_pointer++;
2458 temp_fill = get_absolute_expression ();
2464 do_org (segment, &exp, temp_fill);
2466 demand_empty_rest_of_line ();
2469 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2470 called by the obj-format routine which handles section changing
2471 when in MRI mode. It will create a new section, and return it. It
2472 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2473 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2474 flags will be set in the section. */
2477 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2487 name = input_line_pointer;
2488 if (!ISDIGIT (*name))
2489 c = get_symbol_end ();
2494 ++input_line_pointer;
2496 while (ISDIGIT (*input_line_pointer));
2498 c = *input_line_pointer;
2499 *input_line_pointer = '\0';
2502 name = xstrdup (name);
2504 *input_line_pointer = c;
2506 seg = subseg_new (name, 0);
2508 if (*input_line_pointer == ',')
2512 ++input_line_pointer;
2513 align = get_absolute_expression ();
2514 record_alignment (seg, align);
2518 if (*input_line_pointer == ',')
2520 c = *++input_line_pointer;
2522 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2525 as_bad (_("unrecognized section type"));
2526 ++input_line_pointer;
2528 #ifdef BFD_ASSEMBLER
2532 flags = SEC_NO_FLAGS;
2534 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2535 else if (*type == 'D' || *type == 'M')
2536 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2537 else if (*type == 'R')
2538 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2539 if (flags != SEC_NO_FLAGS)
2541 if (!bfd_set_section_flags (stdoutput, seg, flags))
2542 as_warn (_("error setting flags for \"%s\": %s"),
2543 bfd_section_name (stdoutput, seg),
2544 bfd_errmsg (bfd_get_error ()));
2550 /* Ignore the HP type. */
2551 if (*input_line_pointer == ',')
2552 input_line_pointer += 2;
2554 demand_empty_rest_of_line ();
2556 #else /* ! TC_M68K */
2565 name = input_line_pointer;
2566 c = get_symbol_end ();
2568 name = xstrdup (name);
2570 *input_line_pointer = c;
2572 seg = subseg_new (name, 0);
2574 if (*input_line_pointer != ',')
2580 ++input_line_pointer;
2582 sectype = input_line_pointer;
2583 c = get_symbol_end ();
2584 if (*sectype == '\0')
2586 else if (strcasecmp (sectype, "text") == 0)
2588 else if (strcasecmp (sectype, "data") == 0)
2590 else if (strcasecmp (sectype, "romdata") == 0)
2593 as_warn (_("unrecognized section type `%s'"), sectype);
2594 *input_line_pointer = c;
2597 if (*input_line_pointer == ',')
2601 ++input_line_pointer;
2603 seccmd = input_line_pointer;
2604 c = get_symbol_end ();
2605 if (strcasecmp (seccmd, "absolute") == 0)
2607 as_bad (_("absolute sections are not supported"));
2608 *input_line_pointer = c;
2609 ignore_rest_of_line ();
2612 else if (strcasecmp (seccmd, "align") == 0)
2616 *input_line_pointer = c;
2617 align = get_absolute_expression ();
2618 record_alignment (seg, align);
2622 as_warn (_("unrecognized section command `%s'"), seccmd);
2623 *input_line_pointer = c;
2627 demand_empty_rest_of_line ();
2629 #else /* ! TC_I960 */
2630 /* The MRI assembler seems to use different forms of .sect for
2631 different targets. */
2632 as_bad ("MRI mode not supported for this target");
2633 ignore_rest_of_line ();
2634 #endif /* ! TC_I960 */
2635 #endif /* ! TC_M68K */
2638 /* Handle the .print pseudo-op. */
2641 s_print (int ignore ATTRIBUTE_UNUSED)
2646 s = demand_copy_C_string (&len);
2649 demand_empty_rest_of_line ();
2652 /* Handle the .purgem pseudo-op. */
2655 s_purgem (int ignore ATTRIBUTE_UNUSED)
2657 if (is_it_end_of_statement ())
2659 demand_empty_rest_of_line ();
2669 name = input_line_pointer;
2670 c = get_symbol_end ();
2671 delete_macro (name);
2672 *input_line_pointer = c;
2675 while (*input_line_pointer++ == ',');
2677 --input_line_pointer;
2678 demand_empty_rest_of_line ();
2681 /* Handle the .endm/.endr pseudo-ops. */
2684 s_bad_end (int endr)
2686 as_warn (_(".end%c encountered without preceeding %s"),
2688 endr ? ".rept, .irp, or .irpc" : ".macro");
2689 demand_empty_rest_of_line ();
2692 /* Handle the .rept pseudo-op. */
2695 s_rept (int ignore ATTRIBUTE_UNUSED)
2699 count = get_absolute_expression ();
2701 do_repeat (count, "REPT", "ENDR");
2704 /* This function provides a generic repeat block implementation. It allows
2705 different directives to be used as the start/end keys. */
2708 do_repeat (int count, const char *start, const char *end)
2714 if (!buffer_and_nest (start, end, &one, get_line_sb))
2716 as_bad (_("%s without %s"), start, end);
2722 sb_add_sb (&many, &one);
2726 input_scrub_include_sb (&many, input_line_pointer, 1);
2728 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2731 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2732 input buffers to skip. Assumes that conditionals preceding the loop end
2733 are properly nested.
2735 This function makes it easier to implement a premature "break" out of the
2736 loop. The EXTRA arg accounts for other buffers we might have inserted,
2737 such as line substitutions. */
2740 end_repeat (int extra)
2742 cond_exit_macro (macro_nest);
2743 while (extra-- >= 0)
2744 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2747 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2748 this is .equiv, and it is an error if the symbol is already
2754 register char *name;
2755 register char delim;
2756 register char *end_name;
2757 register symbolS *symbolP;
2759 /* Especial apologies for the random logic:
2760 this just grew, and could be parsed much more simply!
2762 name = input_line_pointer;
2763 delim = get_symbol_end ();
2764 end_name = input_line_pointer;
2767 if (name == end_name)
2769 as_bad (_("expected symbol name"));
2770 discard_rest_of_line ();
2776 if (*input_line_pointer != ',')
2779 as_bad (_("expected comma after \"%s\""), name);
2781 ignore_rest_of_line ();
2785 input_line_pointer++;
2788 if (name[0] == '.' && name[1] == '\0')
2790 /* Turn '. = mumble' into a .org mumble. */
2791 register segT segment;
2794 segment = get_known_segmented_expression (&exp);
2797 do_org (segment, &exp, 0);
2803 if ((symbolP = symbol_find (name)) == NULL
2804 && (symbolP = md_undefined_symbol (name)) == NULL)
2807 /* When doing symbol listings, play games with dummy fragments living
2808 outside the normal fragment chain to record the file and line info
2810 if (listing & LISTING_SYMBOLS)
2812 extern struct list_info_struct *listing_tail;
2813 fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
2814 memset (dummy_frag, 0, sizeof (fragS));
2815 dummy_frag->fr_type = rs_fill;
2816 dummy_frag->line = listing_tail;
2817 symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2818 dummy_frag->fr_symbol = symbolP;
2822 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2825 /* "set" symbols are local unless otherwise specified. */
2826 SF_SET_LOCAL (symbolP);
2827 #endif /* OBJ_COFF */
2830 symbol_table_insert (symbolP);
2835 && S_IS_DEFINED (symbolP)
2836 && S_GET_SEGMENT (symbolP) != reg_section)
2837 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
2839 pseudo_set (symbolP);
2840 demand_empty_rest_of_line ();
2853 #ifdef md_flush_pending_output
2854 md_flush_pending_output ();
2858 stop = mri_comment_field (&stopc);
2860 /* In m68k MRI mode, we need to align to a word boundary, unless
2862 if (flag_m68k_mri && mult > 1)
2864 if (now_seg == absolute_section)
2866 abs_section_offset += abs_section_offset & 1;
2867 if (line_label != NULL)
2868 S_SET_VALUE (line_label, abs_section_offset);
2870 else if (mri_common_symbol != NULL)
2874 val = S_GET_VALUE (mri_common_symbol);
2877 S_SET_VALUE (mri_common_symbol, val + 1);
2878 if (line_label != NULL)
2880 expressionS *symexp;
2882 symexp = symbol_get_value_expression (line_label);
2883 know (symexp->X_op == O_symbol);
2884 know (symexp->X_add_symbol == mri_common_symbol);
2885 symexp->X_add_number += 1;
2891 do_align (1, (char *) NULL, 0, 0);
2892 if (line_label != NULL)
2894 symbol_set_frag (line_label, frag_now);
2895 S_SET_VALUE (line_label, frag_now_fix ());
2905 if (*input_line_pointer == ',')
2907 ++input_line_pointer;
2912 val.X_op = O_constant;
2913 val.X_add_number = 0;
2916 if (val.X_op != O_constant
2917 || val.X_add_number < - 0x80
2918 || val.X_add_number > 0xff
2919 || (mult != 0 && mult != 1 && val.X_add_number != 0))
2921 if (exp.X_op != O_constant)
2922 as_bad (_("unsupported variable size or fill value"));
2929 bytes = mult * exp.X_add_number;
2930 for (i = 0; i < exp.X_add_number; i++)
2931 emit_expr (&val, mult);
2936 if (exp.X_op == O_constant)
2940 repeat = exp.X_add_number;
2947 as_warn (_(".space repeat count is zero, ignored"));
2948 else if (repeat < 0)
2949 as_warn (_(".space repeat count is negative, ignored"));
2953 /* If we are in the absolute section, just bump the offset. */
2954 if (now_seg == absolute_section)
2956 abs_section_offset += repeat;
2960 /* If we are secretly in an MRI common section, then
2961 creating space just increases the size of the common
2963 if (mri_common_symbol != NULL)
2965 S_SET_VALUE (mri_common_symbol,
2966 S_GET_VALUE (mri_common_symbol) + repeat);
2971 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2972 (offsetT) repeat, (char *) 0);
2976 if (now_seg == absolute_section)
2978 as_bad (_("space allocation too complex in absolute section"));
2979 subseg_set (text_section, 0);
2982 if (mri_common_symbol != NULL)
2984 as_bad (_("space allocation too complex in common section"));
2985 mri_common_symbol = NULL;
2989 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2990 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
2994 *p = val.X_add_number;
2999 /* In MRI mode, after an odd number of bytes, we must align to an
3000 even word boundary, unless the next instruction is a dc.b, ds.b
3002 if (flag_mri && (bytes & 1) != 0)
3003 mri_pending_align = 1;
3005 demand_empty_rest_of_line ();
3008 mri_comment_end (stop, stopc);
3011 /* This is like s_space, but the value is a floating point number with
3012 the given precision. This is for the MRI dcb.s pseudo-op and
3016 s_float_space (int float_type)
3020 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3025 stop = mri_comment_field (&stopc);
3027 count = get_absolute_expression ();
3030 if (*input_line_pointer != ',')
3032 as_bad (_("missing value"));
3033 ignore_rest_of_line ();
3035 mri_comment_end (stop, stopc);
3039 ++input_line_pointer;
3043 /* Skip any 0{letter} that may be present. Don't even check if the
3044 * letter is legal. */
3045 if (input_line_pointer[0] == '0'
3046 && ISALPHA (input_line_pointer[1]))
3047 input_line_pointer += 2;
3049 /* Accept :xxxx, where the x's are hex digits, for a floating point
3050 with the exact digits specified. */
3051 if (input_line_pointer[0] == ':')
3053 flen = hex_float (float_type, temp);
3056 ignore_rest_of_line ();
3058 mri_comment_end (stop, stopc);
3066 err = md_atof (float_type, temp, &flen);
3067 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3071 as_bad (_("bad floating literal: %s"), err);
3072 ignore_rest_of_line ();
3074 mri_comment_end (stop, stopc);
3079 while (--count >= 0)
3083 p = frag_more (flen);
3084 memcpy (p, temp, (unsigned int) flen);
3087 demand_empty_rest_of_line ();
3090 mri_comment_end (stop, stopc);
3093 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3096 s_struct (int ignore ATTRIBUTE_UNUSED)
3102 stop = mri_comment_field (&stopc);
3103 abs_section_offset = get_absolute_expression ();
3104 subseg_set (absolute_section, 0);
3105 demand_empty_rest_of_line ();
3107 mri_comment_end (stop, stopc);
3111 s_text (int ignore ATTRIBUTE_UNUSED)
3115 temp = get_absolute_expression ();
3116 subseg_set (text_section, (subsegT) temp);
3117 demand_empty_rest_of_line ();
3119 const_flag &= ~IN_DEFAULT_SECTION;
3124 /* Verify that we are at the end of a line. If not, issue an error and
3128 demand_empty_rest_of_line (void)
3131 if (is_end_of_line[(unsigned char) *input_line_pointer])
3132 input_line_pointer++;
3135 if (ISPRINT (*input_line_pointer))
3136 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3137 *input_line_pointer);
3139 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3140 *input_line_pointer);
3141 ignore_rest_of_line ();
3144 /* Return pointing just after end-of-line. */
3145 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3148 /* Silently advance to the end of line. Use this after already having
3149 issued an error about something bad. */
3152 ignore_rest_of_line (void)
3154 while (input_line_pointer < buffer_limit
3155 && !is_end_of_line[(unsigned char) *input_line_pointer])
3156 input_line_pointer++;
3158 input_line_pointer++;
3160 /* Return pointing just after end-of-line. */
3161 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3165 discard_rest_of_line (void)
3167 while (input_line_pointer < buffer_limit
3168 && !is_end_of_line[(unsigned char) *input_line_pointer])
3169 input_line_pointer++;
3171 input_line_pointer++;
3173 /* Return pointing just after end-of-line. */
3174 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3177 /* In: Pointer to a symbol.
3178 Input_line_pointer->expression.
3180 Out: Input_line_pointer->just after any whitespace after expression.
3181 Tried to set symbol to value of expression.
3182 Will change symbols type, value, and frag; */
3185 pseudo_set (symbolS *symbolP)
3188 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3190 #endif /* OBJ_AOUT or OBJ_BOUT */
3192 know (symbolP); /* NULL pointer is logic error. */
3193 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3194 ext = S_IS_EXTERNAL (symbolP);
3195 #endif /* OBJ_AOUT or OBJ_BOUT */
3197 (void) expression (&exp);
3199 if (exp.X_op == O_illegal)
3200 as_bad (_("illegal expression"));
3201 else if (exp.X_op == O_absent)
3202 as_bad (_("missing expression"));
3203 else if (exp.X_op == O_big)
3205 if (exp.X_add_number > 0)
3206 as_bad (_("bignum invalid"));
3208 as_bad (_("floating point number invalid"));
3210 else if (exp.X_op == O_subtract
3211 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3212 && (symbol_get_frag (exp.X_add_symbol)
3213 == symbol_get_frag (exp.X_op_symbol)))
3215 exp.X_op = O_constant;
3216 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3217 - S_GET_VALUE (exp.X_op_symbol));
3225 exp.X_add_number = 0;
3228 S_SET_SEGMENT (symbolP, absolute_section);
3229 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3231 S_SET_EXTERNAL (symbolP);
3233 S_CLEAR_EXTERNAL (symbolP);
3234 #endif /* OBJ_AOUT or OBJ_BOUT */
3235 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3236 if (exp.X_op != O_constant)
3237 symbol_set_frag (symbolP, &zero_address_frag);
3241 S_SET_SEGMENT (symbolP, reg_section);
3242 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3243 symbol_set_frag (symbolP, &zero_address_frag);
3247 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3248 || exp.X_add_number != 0)
3249 symbol_set_value_expression (symbolP, &exp);
3250 else if (symbol_section_p (symbolP))
3251 as_bad ("attempt to set value of section symbol");
3254 symbolS *s = exp.X_add_symbol;
3256 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3257 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3259 S_SET_EXTERNAL (symbolP);
3261 S_CLEAR_EXTERNAL (symbolP);
3262 #endif /* OBJ_AOUT or OBJ_BOUT */
3263 S_SET_VALUE (symbolP,
3264 exp.X_add_number + S_GET_VALUE (s));
3265 symbol_set_frag (symbolP, symbol_get_frag (s));
3266 copy_symbol_attributes (symbolP, s);
3271 /* The value is some complex expression.
3272 FIXME: Should we set the segment to anything? */
3273 symbol_set_value_expression (symbolP, &exp);
3280 CONStruct more frag of .bytes, or .words etc.
3281 Should need_pass_2 be 1 then emit no frag(s).
3282 This understands EXPRESSIONS.
3286 This has a split personality. We use expression() to read the
3287 value. We can detect if the value won't fit in a byte or word.
3288 But we can't detect if expression() discarded significant digits
3289 in the case of a long. Not worth the crocks required to fix it. */
3291 /* Select a parser for cons expressions. */
3293 /* Some targets need to parse the expression in various fancy ways.
3294 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3295 (for example, the HPPA does this). Otherwise, you can define
3296 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3297 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3298 are defined, which is the normal case, then only simple expressions
3303 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3306 #ifndef TC_PARSE_CONS_EXPRESSION
3307 #ifdef BITFIELD_CONS_EXPRESSIONS
3308 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3310 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3312 #ifdef REPEAT_CONS_EXPRESSIONS
3313 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3315 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3318 /* If we haven't gotten one yet, just call expression. */
3319 #ifndef TC_PARSE_CONS_EXPRESSION
3320 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3325 do_parse_cons_expression (expressionS *exp,
3326 int nbytes ATTRIBUTE_UNUSED)
3328 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3332 /* Worker to do .byte etc statements.
3333 Clobbers input_line_pointer and checks end-of-line. */
3336 cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3344 #ifdef md_flush_pending_output
3345 md_flush_pending_output ();
3349 stop = mri_comment_field (&stopc);
3351 if (is_it_end_of_statement ())
3353 demand_empty_rest_of_line ();
3355 mri_comment_end (stop, stopc);
3359 #ifdef TC_ADDRESS_BYTES
3361 nbytes = TC_ADDRESS_BYTES ();
3364 #ifdef md_cons_align
3365 md_cons_align (nbytes);
3373 parse_mri_cons (&exp, (unsigned int) nbytes);
3376 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3380 if (exp.X_op == O_symbol)
3381 exp.X_op = O_symbol_rva;
3383 as_fatal (_("rva without symbol"));
3385 emit_expr (&exp, (unsigned int) nbytes);
3388 while (*input_line_pointer++ == ',');
3390 /* In MRI mode, after an odd number of bytes, we must align to an
3391 even word boundary, unless the next instruction is a dc.b, ds.b
3393 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3394 mri_pending_align = 1;
3396 input_line_pointer--; /* Put terminator back into stream. */
3398 demand_empty_rest_of_line ();
3401 mri_comment_end (stop, stopc);
3407 cons_worker (size, 0);
3413 cons_worker (size, 1);
3416 /* Put the contents of expression EXP into the object file using
3417 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3420 emit_expr (expressionS *exp, unsigned int nbytes)
3424 valueT extra_digit = 0;
3426 /* Don't do anything if we are going to make another pass. */
3430 dot_value = frag_now_fix ();
3434 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3435 appear as a four byte positive constant in the .line section,
3436 followed by a 2 byte 0xffff. Look for that case here. */
3438 static int dwarf_line = -1;
3440 if (strcmp (segment_name (now_seg), ".line") != 0)
3442 else if (dwarf_line >= 0
3444 && exp->X_op == O_constant
3445 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3446 listing_source_line ((unsigned int) dwarf_line);
3447 else if (nbytes == 4
3448 && exp->X_op == O_constant
3449 && exp->X_add_number >= 0)
3450 dwarf_line = exp->X_add_number;
3455 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3456 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3457 AT_sibling (0x12) followed by a four byte address of the sibling
3458 followed by a 2 byte AT_name (0x38) followed by the name of the
3459 file. We look for that case here. */
3461 static int dwarf_file = 0;
3463 if (strcmp (segment_name (now_seg), ".debug") != 0)
3465 else if (dwarf_file == 0
3467 && exp->X_op == O_constant
3468 && exp->X_add_number == 0x11)
3470 else if (dwarf_file == 1
3472 && exp->X_op == O_constant
3473 && exp->X_add_number == 0x12)
3475 else if (dwarf_file == 2
3478 else if (dwarf_file == 3
3480 && exp->X_op == O_constant
3481 && exp->X_add_number == 0x38)
3486 /* The variable dwarf_file_string tells stringer that the string
3487 may be the name of the source file. */
3488 if (dwarf_file == 4)
3489 dwarf_file_string = 1;
3491 dwarf_file_string = 0;
3496 if (check_eh_frame (exp, &nbytes))
3501 /* Allow `.word 0' in the absolute section. */
3502 if (now_seg == absolute_section)
3504 if (op != O_constant || exp->X_add_number != 0)
3505 as_bad (_("attempt to store value in absolute section"));
3506 abs_section_offset += nbytes;
3510 /* Handle a negative bignum. */
3512 && exp->X_add_number == 0
3513 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3514 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3517 unsigned long carry;
3519 exp = symbol_get_value_expression (exp->X_add_symbol);
3521 /* Negate the bignum: one's complement each digit and add 1. */
3523 for (i = 0; i < exp->X_add_number; i++)
3527 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3530 generic_bignum[i] = next & LITTLENUM_MASK;
3531 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3534 /* We can ignore any carry out, because it will be handled by
3535 extra_digit if it is needed. */
3537 extra_digit = (valueT) -1;
3541 if (op == O_absent || op == O_illegal)
3543 as_warn (_("zero assumed for missing expression"));
3544 exp->X_add_number = 0;
3547 else if (op == O_big && exp->X_add_number <= 0)
3549 as_bad (_("floating point number invalid"));
3550 exp->X_add_number = 0;
3553 else if (op == O_register)
3555 as_warn (_("register value used as expression"));
3559 p = frag_more ((int) nbytes);
3561 #ifndef WORKING_DOT_WORD
3562 /* If we have the difference of two symbols in a word, save it on
3563 the broken_words list. See the code in write.c. */
3564 if (op == O_subtract && nbytes == 2)
3566 struct broken_word *x;
3568 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3569 x->next_broken_word = broken_words;
3572 x->subseg = now_subseg;
3574 x->word_goes_here = p;
3576 x->add = exp->X_add_symbol;
3577 x->sub = exp->X_op_symbol;
3578 x->addnum = exp->X_add_number;
3586 /* If we have an integer, but the number of bytes is too large to
3587 pass to md_number_to_chars, handle it as a bignum. */
3588 if (op == O_constant && nbytes > sizeof (valueT))
3590 extra_digit = exp->X_unsigned ? 0 : -1;
3591 convert_to_bignum (exp);
3595 if (op == O_constant)
3597 register valueT get;
3598 register valueT use;
3599 register valueT mask;
3601 register valueT unmask;
3603 /* JF << of >= number of bits in the object is undefined. In
3604 particular SPARC (Sun 4) has problems. */
3605 if (nbytes >= sizeof (valueT))
3608 if (nbytes > sizeof (valueT))
3611 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3615 /* Don't store these bits. */
3616 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3617 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3620 unmask = ~mask; /* Do store these bits. */
3623 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3624 mask = ~(unmask >> 1); /* Includes sign bit now. */
3627 get = exp->X_add_number;
3629 if ((get & mask) != 0
3630 && ((get & mask) != mask
3631 || (get & hibit) == 0))
3632 { /* Leading bits contain both 0s & 1s. */
3633 as_warn (_("value 0x%lx truncated to 0x%lx"),
3634 (unsigned long) get, (unsigned long) use);
3636 /* Put bytes in right order. */
3637 md_number_to_chars (p, use, (int) nbytes);
3639 else if (op == O_big)
3642 LITTLENUM_TYPE *nums;
3644 know (nbytes % CHARS_PER_LITTLENUM == 0);
3646 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3649 as_warn (_("bignum truncated to %d bytes"), nbytes);
3653 if (target_big_endian)
3655 while (nbytes > size)
3657 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3658 nbytes -= CHARS_PER_LITTLENUM;
3659 p += CHARS_PER_LITTLENUM;
3662 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3663 while (size >= CHARS_PER_LITTLENUM)
3666 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3667 size -= CHARS_PER_LITTLENUM;
3668 p += CHARS_PER_LITTLENUM;
3673 nums = generic_bignum;
3674 while (size >= CHARS_PER_LITTLENUM)
3676 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3678 size -= CHARS_PER_LITTLENUM;
3679 p += CHARS_PER_LITTLENUM;
3680 nbytes -= CHARS_PER_LITTLENUM;
3683 while (nbytes >= CHARS_PER_LITTLENUM)
3685 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3686 nbytes -= CHARS_PER_LITTLENUM;
3687 p += CHARS_PER_LITTLENUM;
3693 memset (p, 0, nbytes);
3695 /* Now we need to generate a fixS to record the symbol value.
3696 This is easy for BFD. For other targets it can be more
3697 complex. For very complex cases (currently, the HPPA and
3698 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3699 want. For simpler cases, you can define TC_CONS_RELOC to be
3700 the name of the reloc code that should be stored in the fixS.
3701 If neither is defined, the code uses NO_RELOC if it is
3702 defined, and otherwise uses 0. */
3704 #ifdef BFD_ASSEMBLER
3705 #ifdef TC_CONS_FIX_NEW
3706 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3709 bfd_reloc_code_real_type r;
3726 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3730 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3735 #ifdef TC_CONS_FIX_NEW
3736 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3738 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3739 it is defined, otherwise use NO_RELOC if it is defined,
3741 #ifndef TC_CONS_RELOC
3743 #define TC_CONS_RELOC NO_RELOC
3745 #define TC_CONS_RELOC 0
3748 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3750 #endif /* TC_CONS_FIX_NEW */
3751 #endif /* BFD_ASSEMBLER */
3755 #ifdef BITFIELD_CONS_EXPRESSIONS
3757 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3758 w:x,y:z, where w and y are bitwidths and x and y are values. They
3759 then pack them all together. We do a little better in that we allow
3760 them in words, longs, etc. and we'll pack them in target byte order
3763 The rules are: pack least significant bit first, if a field doesn't
3764 entirely fit, put it in the next unit. Overflowing the bitfield is
3765 explicitly *not* even a warning. The bitwidth should be considered
3768 To use this function the tc-XXX.h file should define
3769 BITFIELD_CONS_EXPRESSIONS. */
3772 parse_bitfield_cons (exp, nbytes)
3774 unsigned int nbytes;
3776 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3777 char *hold = input_line_pointer;
3779 (void) expression (exp);
3781 if (*input_line_pointer == ':')
3788 unsigned long width;
3790 if (*input_line_pointer != ':')
3792 input_line_pointer = hold;
3794 } /* Next piece is not a bitfield. */
3796 /* In the general case, we can't allow
3797 full expressions with symbol
3798 differences and such. The relocation
3799 entries for symbols not defined in this
3800 assembly would require arbitrary field
3801 widths, positions, and masks which most
3802 of our current object formats don't
3805 In the specific case where a symbol
3806 *is* defined in this assembly, we
3807 *could* build fixups and track it, but
3808 this could lead to confusion for the
3809 backends. I'm lazy. I'll take any
3810 SEG_ABSOLUTE. I think that means that
3811 you can use a previous .set or
3812 .equ type symbol. xoxorich. */
3814 if (exp->X_op == O_absent)
3816 as_warn (_("using a bit field width of zero"));
3817 exp->X_add_number = 0;
3818 exp->X_op = O_constant;
3819 } /* Implied zero width bitfield. */
3821 if (exp->X_op != O_constant)
3823 *input_line_pointer = '\0';
3824 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3825 *input_line_pointer = ':';
3826 demand_empty_rest_of_line ();
3828 } /* Too complex. */
3830 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3832 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3833 width, nbytes, (BITS_PER_CHAR * nbytes));
3834 width = BITS_PER_CHAR * nbytes;
3837 if (width > bits_available)
3839 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3840 input_line_pointer = hold;
3841 exp->X_add_number = value;
3846 hold = ++input_line_pointer;
3848 (void) expression (exp);
3849 if (exp->X_op != O_constant)
3851 char cache = *input_line_pointer;
3853 *input_line_pointer = '\0';
3854 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3855 *input_line_pointer = cache;
3856 demand_empty_rest_of_line ();
3858 } /* Too complex. */
3860 value |= ((~(-1 << width) & exp->X_add_number)
3861 << ((BITS_PER_CHAR * nbytes) - bits_available));
3863 if ((bits_available -= width) == 0
3864 || is_it_end_of_statement ()
3865 || *input_line_pointer != ',')
3868 } /* All the bitfields we're gonna get. */
3870 hold = ++input_line_pointer;
3871 (void) expression (exp);
3874 exp->X_add_number = value;
3875 exp->X_op = O_constant;
3876 exp->X_unsigned = 1;
3880 #endif /* BITFIELD_CONS_EXPRESSIONS */
3882 /* Handle an MRI style string expression. */
3886 parse_mri_cons (exp, nbytes)
3888 unsigned int nbytes;
3890 if (*input_line_pointer != '\''
3891 && (input_line_pointer[1] != '\''
3892 || (*input_line_pointer != 'A'
3893 && *input_line_pointer != 'E')))
3894 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3898 unsigned int result = 0;
3900 /* An MRI style string. Cut into as many bytes as will fit into
3901 a nbyte chunk, left justify if necessary, and separate with
3902 commas so we can try again later. */
3903 if (*input_line_pointer == 'A')
3904 ++input_line_pointer;
3905 else if (*input_line_pointer == 'E')
3907 as_bad (_("EBCDIC constants are not supported"));
3908 ++input_line_pointer;
3911 input_line_pointer++;
3912 for (scan = 0; scan < nbytes; scan++)
3914 if (*input_line_pointer == '\'')
3916 if (input_line_pointer[1] == '\'')
3918 input_line_pointer++;
3923 result = (result << 8) | (*input_line_pointer++);
3927 while (scan < nbytes)
3933 /* Create correct expression. */
3934 exp->X_op = O_constant;
3935 exp->X_add_number = result;
3937 /* Fake it so that we can read the next char too. */
3938 if (input_line_pointer[0] != '\'' ||
3939 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3941 input_line_pointer -= 2;
3942 input_line_pointer[0] = ',';
3943 input_line_pointer[1] = '\'';
3946 input_line_pointer++;
3949 #endif /* TC_M68K */
3951 #ifdef REPEAT_CONS_EXPRESSIONS
3953 /* Parse a repeat expression for cons. This is used by the MIPS
3954 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3955 object file COUNT times.
3957 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3960 parse_repeat_cons (exp, nbytes)
3962 unsigned int nbytes;
3969 if (*input_line_pointer != ':')
3971 /* No repeat count. */
3975 ++input_line_pointer;
3976 expression (&count);
3977 if (count.X_op != O_constant
3978 || count.X_add_number <= 0)
3980 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
3984 /* The cons function is going to output this expression once. So we
3985 output it count - 1 times. */
3986 for (i = count.X_add_number - 1; i > 0; i--)
3987 emit_expr (exp, nbytes);
3990 #endif /* REPEAT_CONS_EXPRESSIONS */
3992 /* Parse a floating point number represented as a hex constant. This
3993 permits users to specify the exact bits they want in the floating
3997 hex_float (int float_type, char *bytes)
4029 as_bad (_("unknown floating type type '%c'"), float_type);
4033 /* It would be nice if we could go through expression to parse the
4034 hex constant, but if we get a bignum it's a pain to sort it into
4035 the buffer correctly. */
4037 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4041 /* The MRI assembler accepts arbitrary underscores strewn about
4042 through the hex constant, so we ignore them as well. */
4043 if (*input_line_pointer == '_')
4045 ++input_line_pointer;
4051 as_warn (_("floating point constant too large"));
4054 d = hex_value (*input_line_pointer) << 4;
4055 ++input_line_pointer;
4056 while (*input_line_pointer == '_')
4057 ++input_line_pointer;
4058 if (hex_p (*input_line_pointer))
4060 d += hex_value (*input_line_pointer);
4061 ++input_line_pointer;
4063 if (target_big_endian)
4066 bytes[length - i - 1] = d;
4072 if (target_big_endian)
4073 memset (bytes + i, 0, length - i);
4075 memset (bytes, 0, length - i);
4083 CONStruct some more frag chars of .floats .ffloats etc.
4084 Makes 0 or more new frags.
4085 If need_pass_2 == 1, no frags are emitted.
4086 This understands only floating literals, not expressions. Sorry.
4088 A floating constant is defined by atof_generic(), except it is preceded
4089 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4090 reading, I decided to be incompatible. This always tries to give you
4091 rounded bits to the precision of the pseudo-op. Former AS did premature
4092 truncation, restored noisy bits instead of trailing 0s AND gave you
4093 a choice of 2 flavours of noise according to which of 2 floating-point
4094 scanners you directed AS to use.
4096 In: input_line_pointer->whitespace before, or '0' of flonum. */
4099 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4100 register int float_type /* 'f':.ffloat ... 'F':.float ... */)
4103 int length; /* Number of chars in an object. */
4104 register char *err; /* Error from scanning floating literal. */
4105 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4107 if (is_it_end_of_statement ())
4109 demand_empty_rest_of_line ();
4113 #ifdef md_flush_pending_output
4114 md_flush_pending_output ();
4119 /* input_line_pointer->1st char of a flonum (we hope!). */
4122 /* Skip any 0{letter} that may be present. Don't even check if the
4123 letter is legal. Someone may invent a "z" format and this routine
4124 has no use for such information. Lusers beware: you get
4125 diagnostics if your input is ill-conditioned. */
4126 if (input_line_pointer[0] == '0'
4127 && ISALPHA (input_line_pointer[1]))
4128 input_line_pointer += 2;
4130 /* Accept :xxxx, where the x's are hex digits, for a floating
4131 point with the exact digits specified. */
4132 if (input_line_pointer[0] == ':')
4134 ++input_line_pointer;
4135 length = hex_float (float_type, temp);
4138 ignore_rest_of_line ();
4144 err = md_atof (float_type, temp, &length);
4145 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4149 as_bad (_("bad floating literal: %s"), err);
4150 ignore_rest_of_line ();
4161 #ifdef REPEAT_CONS_EXPRESSIONS
4162 if (*input_line_pointer == ':')
4164 expressionS count_exp;
4166 ++input_line_pointer;
4167 expression (&count_exp);
4169 if (count_exp.X_op != O_constant
4170 || count_exp.X_add_number <= 0)
4171 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4173 count = count_exp.X_add_number;
4177 while (--count >= 0)
4179 p = frag_more (length);
4180 memcpy (p, temp, (unsigned int) length);
4185 while (*input_line_pointer++ == ',');
4187 /* Put terminator back into stream. */
4188 --input_line_pointer;
4189 demand_empty_rest_of_line ();
4192 /* Return the size of a LEB128 value. */
4195 sizeof_sleb128 (offsetT value)
4197 register int size = 0;
4198 register unsigned byte;
4202 byte = (value & 0x7f);
4203 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4204 Fortunately, we can structure things so that the extra work reduces
4205 to a noop on systems that do things "properly". */
4206 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4209 while (!(((value == 0) && ((byte & 0x40) == 0))
4210 || ((value == -1) && ((byte & 0x40) != 0))));
4216 sizeof_uleb128 (valueT value)
4218 register int size = 0;
4219 register unsigned byte;
4223 byte = (value & 0x7f);
4233 sizeof_leb128 (valueT value, int sign)
4236 return sizeof_sleb128 ((offsetT) value);
4238 return sizeof_uleb128 (value);
4241 /* Output a LEB128 value. */
4244 output_sleb128 (char *p, offsetT value)
4246 register char *orig = p;
4251 unsigned byte = (value & 0x7f);
4253 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4254 Fortunately, we can structure things so that the extra work reduces
4255 to a noop on systems that do things "properly". */
4256 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4258 more = !((((value == 0) && ((byte & 0x40) == 0))
4259 || ((value == -1) && ((byte & 0x40) != 0))));
4271 output_uleb128 (char *p, valueT value)
4277 unsigned byte = (value & 0x7f);
4280 /* More bytes to follow. */
4291 output_leb128 (char *p, valueT value, int sign)
4294 return output_sleb128 (p, (offsetT) value);
4296 return output_uleb128 (p, value);
4299 /* Do the same for bignums. We combine sizeof with output here in that
4300 we don't output for NULL values of P. It isn't really as critical as
4301 for "normal" values that this be streamlined. */
4304 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4311 /* Strip leading sign extensions off the bignum. */
4313 && bignum[size - 1] == LITTLENUM_MASK
4314 && bignum[size - 2] > LITTLENUM_MASK / 2)
4319 /* OR in the next part of the littlenum. */
4320 val |= (*bignum << loaded);
4321 loaded += LITTLENUM_NUMBER_OF_BITS;
4325 /* Add bytes until there are less than 7 bits left in VAL
4326 or until every non-sign bit has been written. */
4333 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4340 while ((byte & 0x80) != 0 && loaded >= 7);
4344 /* Mop up any left-over bits (of which there will be less than 7). */
4345 if ((byte & 0x80) != 0)
4347 /* Sign-extend VAL. */
4348 if (val & (1 << (loaded - 1)))
4349 val |= ~0 << loaded;
4359 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4366 /* Strip leading zeros off the bignum. */
4367 /* XXX: Is this needed? */
4368 while (size > 0 && bignum[size - 1] == 0)
4373 if (loaded < 7 && size > 0)
4375 val |= (*bignum << loaded);
4376 loaded += 8 * CHARS_PER_LITTLENUM;
4385 if (size > 0 || val)
4392 while (byte & 0x80);
4398 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
4401 return output_big_sleb128 (p, bignum, size);
4403 return output_big_uleb128 (p, bignum, size);
4406 /* Generate the appropriate fragments for a given expression to emit a
4410 emit_leb128_expr (expressionS *exp, int sign)
4412 operatorT op = exp->X_op;
4415 if (op == O_absent || op == O_illegal)
4417 as_warn (_("zero assumed for missing expression"));
4418 exp->X_add_number = 0;
4421 else if (op == O_big && exp->X_add_number <= 0)
4423 as_bad (_("floating point number invalid"));
4424 exp->X_add_number = 0;
4427 else if (op == O_register)
4429 as_warn (_("register value used as expression"));
4432 else if (op == O_constant
4434 && (exp->X_add_number < 0) != !exp->X_unsigned)
4436 /* We're outputting a signed leb128 and the sign of X_add_number
4437 doesn't reflect the sign of the original value. Convert EXP
4438 to a correctly-extended bignum instead. */
4439 convert_to_bignum (exp);
4443 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4444 a signal that this is leb128 data. It shouldn't optimize this away. */
4446 if (check_eh_frame (exp, &nbytes))
4449 /* Let the backend know that subsequent data may be byte aligned. */
4450 #ifdef md_cons_align
4454 if (op == O_constant)
4456 /* If we've got a constant, emit the thing directly right now. */
4458 valueT value = exp->X_add_number;
4462 size = sizeof_leb128 (value, sign);
4463 p = frag_more (size);
4464 output_leb128 (p, value, sign);
4466 else if (op == O_big)
4468 /* O_big is a different sort of constant. */
4473 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4474 p = frag_more (size);
4475 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4479 /* Otherwise, we have to create a variable sized fragment and
4480 resolve things later. */
4482 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4483 make_expr_symbol (exp), 0, (char *) NULL);
4487 /* Parse the .sleb128 and .uleb128 pseudos. */
4494 #ifdef md_flush_pending_output
4495 md_flush_pending_output ();
4501 emit_leb128_expr (&exp, sign);
4503 while (*input_line_pointer++ == ',');
4505 input_line_pointer--;
4506 demand_empty_rest_of_line ();
4509 /* We read 0 or more ',' separated, double-quoted strings.
4510 Caller should have checked need_pass_2 is FALSE because we don't
4514 stringer (/* Worker to do .ascii etc statements. */
4515 /* Checks end-of-line. */
4516 register int append_zero /* 0: don't append '\0', else 1. */)
4518 register unsigned int c;
4521 #ifdef md_flush_pending_output
4522 md_flush_pending_output ();
4525 /* The following awkward logic is to parse ZERO or more strings,
4526 comma separated. Recall a string expression includes spaces
4527 before the opening '\"' and spaces after the closing '\"'.
4528 We fake a leading ',' if there is (supposed to be)
4529 a 1st, expression. We keep demanding expressions for each ','. */
4530 if (is_it_end_of_statement ())
4532 c = 0; /* Skip loop. */
4533 ++input_line_pointer; /* Compensate for end of loop. */
4537 c = ','; /* Do loop. */
4539 /* If we have been switched into the abs_section then we
4540 will not have an obstack onto which we can hang strings. */
4541 if (now_seg == absolute_section)
4543 as_bad (_("strings must be placed into a section"));
4545 ignore_rest_of_line ();
4548 while (c == ',' || c == '<' || c == '"')
4551 switch (*input_line_pointer)
4554 ++input_line_pointer; /*->1st char of string. */
4555 start = input_line_pointer;
4556 while (is_a_char (c = next_char_of_string ()))
4558 FRAG_APPEND_1_CHAR (c);
4562 FRAG_APPEND_1_CHAR (0);
4564 know (input_line_pointer[-1] == '\"');
4568 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4569 will emit .string with a filename in the .debug section
4570 after a sequence of constants. See the comment in
4571 emit_expr for the sequence. emit_expr will set
4572 dwarf_file_string to non-zero if this string might be a
4573 source file name. */
4574 if (strcmp (segment_name (now_seg), ".debug") != 0)
4575 dwarf_file_string = 0;
4576 else if (dwarf_file_string)
4578 c = input_line_pointer[-1];
4579 input_line_pointer[-1] = '\0';
4580 listing_source_file (start);
4581 input_line_pointer[-1] = c;
4588 input_line_pointer++;
4589 c = get_single_number ();
4590 FRAG_APPEND_1_CHAR (c);
4591 if (*input_line_pointer != '>')
4593 as_bad (_("expected <nn>"));
4595 input_line_pointer++;
4598 input_line_pointer++;
4602 c = *input_line_pointer;
4605 demand_empty_rest_of_line ();
4608 /* FIXME-SOMEDAY: I had trouble here on characters with the
4609 high bits set. We'll probably also have trouble with
4610 multibyte chars, wide chars, etc. Also be careful about
4611 returning values bigger than 1 byte. xoxorich. */
4614 next_char_of_string (void)
4616 register unsigned int c;
4618 c = *input_line_pointer++ & CHAR_MASK;
4626 as_warn (_("unterminated string; newline inserted"));
4627 bump_line_counters ();
4630 #ifndef NO_STRING_ESCAPES
4632 switch (c = *input_line_pointer++)
4660 break; /* As itself. */
4676 for (i = 0, number = 0;
4677 ISDIGIT (c) && i < 3;
4678 c = *input_line_pointer++, i++)
4680 number = number * 8 + c - '0';
4685 --input_line_pointer;
4694 c = *input_line_pointer++;
4695 while (ISXDIGIT (c))
4698 number = number * 16 + c - '0';
4699 else if (ISUPPER (c))
4700 number = number * 16 + c - 'A' + 10;
4702 number = number * 16 + c - 'a' + 10;
4703 c = *input_line_pointer++;
4706 --input_line_pointer;
4711 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4712 as_warn (_("unterminated string; newline inserted"));
4714 bump_line_counters ();
4719 #ifdef ONLY_STANDARD_ESCAPES
4720 as_bad (_("bad escaped character in string"));
4722 #endif /* ONLY_STANDARD_ESCAPES */
4727 #endif /* ! defined (NO_STRING_ESCAPES) */
4736 get_segmented_expression (register expressionS *expP)
4738 register segT retval;
4740 retval = expression (expP);
4741 if (expP->X_op == O_illegal
4742 || expP->X_op == O_absent
4743 || expP->X_op == O_big)
4745 as_bad (_("expected address expression"));
4746 expP->X_op = O_constant;
4747 expP->X_add_number = 0;
4748 retval = absolute_section;
4754 get_known_segmented_expression (register expressionS *expP)
4756 register segT retval;
4758 if ((retval = get_segmented_expression (expP)) == undefined_section)
4760 /* There is no easy way to extract the undefined symbol from the
4762 if (expP->X_add_symbol != NULL
4763 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4764 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4765 S_GET_NAME (expP->X_add_symbol));
4767 as_warn (_("some symbol undefined; zero assumed"));
4768 retval = absolute_section;
4769 expP->X_op = O_constant;
4770 expP->X_add_number = 0;
4772 know (retval == absolute_section || SEG_NORMAL (retval));
4777 get_absolute_expr (expressionS *exp)
4780 if (exp->X_op != O_constant)
4782 if (exp->X_op != O_absent)
4783 as_bad (_("bad or irreducible absolute expression"));
4784 exp->X_add_number = 0;
4786 return exp->X_add_number;
4790 get_absolute_expression (void)
4794 return get_absolute_expr (&exp);
4797 char /* Return terminator. */
4798 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
4800 /* FIXME: val_pointer should probably be offsetT *. */
4801 *val_pointer = (long) get_absolute_expression ();
4802 return (*input_line_pointer++);
4805 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4806 Give a warning if that happens. */
4809 demand_copy_C_string (int *len_pointer)
4813 if ((s = demand_copy_string (len_pointer)) != 0)
4817 for (len = *len_pointer; len > 0; len--)
4824 as_bad (_("this string may not contain \'\\0\'"));
4832 /* Demand string, but return a safe (=private) copy of the string.
4833 Return NULL if we can't read a string here. */
4836 demand_copy_string (int *lenP)
4838 register unsigned int c;
4844 if (*input_line_pointer == '\"')
4846 input_line_pointer++; /* Skip opening quote. */
4848 while (is_a_char (c = next_char_of_string ()))
4850 obstack_1grow (¬es, c);
4853 /* JF this next line is so demand_copy_C_string will return a
4854 null terminated string. */
4855 obstack_1grow (¬es, '\0');
4856 retval = obstack_finish (¬es);
4860 as_bad (_("missing string"));
4862 ignore_rest_of_line ();
4868 /* In: Input_line_pointer->next character.
4870 Do: Skip input_line_pointer over all whitespace.
4872 Out: 1 if input_line_pointer->end-of-line. */
4875 is_it_end_of_statement (void)
4878 return (is_end_of_line[(unsigned char) *input_line_pointer]);
4882 equals (char *sym_name, int reassign)
4884 register symbolS *symbolP; /* Symbol we are working with. */
4888 input_line_pointer++;
4889 if (*input_line_pointer == '=')
4890 input_line_pointer++;
4892 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4893 input_line_pointer++;
4896 stop = mri_comment_field (&stopc);
4898 if (sym_name[0] == '.' && sym_name[1] == '\0')
4900 /* Turn '. = mumble' into a .org mumble. */
4901 register segT segment;
4904 segment = get_known_segmented_expression (&exp);
4906 do_org (segment, &exp, 0);
4913 symbolP = symbol_find (sym_name);
4914 local = symbolP == NULL;
4916 #endif /* OBJ_COFF */
4917 symbolP = symbol_find_or_make (sym_name);
4918 /* Permit register names to be redefined. */
4920 && S_IS_DEFINED (symbolP)
4921 && S_GET_SEGMENT (symbolP) != reg_section)
4922 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
4925 /* "set" symbols are local unless otherwise specified. */
4927 SF_SET_LOCAL (symbolP);
4928 #endif /* OBJ_COFF */
4930 pseudo_set (symbolP);
4935 /* Check garbage after the expression. */
4936 demand_empty_rest_of_line ();
4937 mri_comment_end (stop, stopc);
4941 /* .incbin -- include a file verbatim at the current location. */
4944 s_incbin (int x ATTRIBUTE_UNUSED)
4955 #ifdef md_flush_pending_output
4956 md_flush_pending_output ();
4960 filename = demand_copy_string (& len);
4961 if (filename == NULL)
4966 /* Look for optional skip and count. */
4967 if (* input_line_pointer == ',')
4969 ++ input_line_pointer;
4970 skip = get_absolute_expression ();
4974 if (* input_line_pointer == ',')
4976 ++ input_line_pointer;
4978 count = get_absolute_expression ();
4980 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
4986 demand_empty_rest_of_line ();
4988 /* Try opening absolute path first, then try include dirs. */
4989 binfile = fopen (filename, FOPEN_RB);
4990 if (binfile == NULL)
4994 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
4996 for (i = 0; i < include_dir_count; i++)
4998 sprintf (path, "%s/%s", include_dirs[i], filename);
5000 binfile = fopen (path, FOPEN_RB);
5001 if (binfile != NULL)
5005 if (binfile == NULL)
5006 as_bad (_("file not found: %s"), filename);
5009 path = xstrdup (filename);
5015 register_dependency (path);
5017 /* Compute the length of the file. */
5018 if (fseek (binfile, 0, SEEK_END) != 0)
5020 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5023 file_len = ftell (binfile);
5025 /* If a count was not specified use the remainder of the file. */
5027 count = file_len - skip;
5029 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5031 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5032 skip, count, file_len);
5036 if (fseek (binfile, skip, SEEK_SET) != 0)
5038 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5042 /* Allocate frag space and store file contents in it. */
5043 binfrag = frag_more (count);
5045 bytes = fread (binfrag, 1, count, binfile);
5047 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5048 path, bytes, count);
5051 if (binfile != NULL)
5057 /* .include -- include a file at this point. */
5060 s_include (int arg ATTRIBUTE_UNUSED)
5069 filename = demand_copy_string (&i);
5070 if (filename == NULL)
5072 /* demand_copy_string has already printed an error and
5073 called ignore_rest_of_line. */
5081 while (!is_end_of_line[(unsigned char) *input_line_pointer]
5082 && *input_line_pointer != ' '
5083 && *input_line_pointer != '\t')
5085 obstack_1grow (¬es, *input_line_pointer);
5086 ++input_line_pointer;
5090 obstack_1grow (¬es, '\0');
5091 filename = obstack_finish (¬es);
5092 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5093 ++input_line_pointer;
5096 demand_empty_rest_of_line ();
5097 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
5099 for (i = 0; i < include_dir_count; i++)
5101 strcpy (path, include_dirs[i]);
5103 strcat (path, filename);
5104 if (0 != (try = fopen (path, FOPEN_RT)))
5114 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5115 register_dependency (path);
5116 input_scrub_insert_file (path);
5120 add_include_dir (char *path)
5124 if (include_dir_count == 0)
5126 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5127 include_dirs[0] = "."; /* Current dir. */
5128 include_dir_count = 2;
5132 include_dir_count++;
5134 (char **) realloc (include_dirs,
5135 include_dir_count * sizeof (*include_dirs));
5138 include_dirs[include_dir_count - 1] = path; /* New one. */
5141 if (i > include_dir_maxlen)
5142 include_dir_maxlen = i;
5145 /* Output debugging information to denote the source file. */
5148 generate_file_debug (void)
5150 if (debug_type == DEBUG_STABS)
5151 stabs_generate_asm_file ();
5154 /* Output line number debugging information for the current source line. */
5157 generate_lineno_debug (void)
5161 case DEBUG_UNSPECIFIED:
5166 stabs_generate_asm_lineno ();
5169 ecoff_generate_asm_lineno ();
5172 /* ??? We could here indicate to dwarf2dbg.c that something
5173 has changed. However, since there is additional backend
5174 support that is required (calling dwarf2_emit_insn), we
5175 let dwarf2dbg.c call as_where on its own. */
5180 /* Output debugging information to mark a function entry point or end point.
5181 END_P is zero for .func, and non-zero for .endfunc. */
5186 do_s_func (end_p, NULL);
5189 /* Subroutine of s_func so targets can choose a different default prefix.
5190 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5193 do_s_func (int end_p, const char *default_prefix)
5195 /* Record the current function so that we can issue an error message for
5196 misplaced .func,.endfunc, and also so that .endfunc needs no
5198 static char *current_name;
5199 static char *current_label;
5203 if (current_name == NULL)
5205 as_bad (_("missing .func"));
5206 ignore_rest_of_line ();
5210 if (debug_type == DEBUG_STABS)
5211 stabs_generate_asm_endfunc (current_name, current_label);
5213 current_name = current_label = NULL;
5218 char delim1, delim2;
5220 if (current_name != NULL)
5222 as_bad (_(".endfunc missing for previous .func"));
5223 ignore_rest_of_line ();
5227 name = input_line_pointer;
5228 delim1 = get_symbol_end ();
5229 name = xstrdup (name);
5230 *input_line_pointer = delim1;
5232 if (*input_line_pointer != ',')
5235 asprintf (&label, "%s%s", default_prefix, name);
5238 char leading_char = 0;
5239 #ifdef BFD_ASSEMBLER
5240 leading_char = bfd_get_symbol_leading_char (stdoutput);
5242 /* Missing entry point, use function's name with the leading
5245 asprintf (&label, "%c%s", leading_char, name);
5252 ++input_line_pointer;
5254 label = input_line_pointer;
5255 delim2 = get_symbol_end ();
5256 label = xstrdup (label);
5257 *input_line_pointer = delim2;
5260 if (debug_type == DEBUG_STABS)
5261 stabs_generate_asm_func (name, label);
5263 current_name = name;
5264 current_label = label;
5267 demand_empty_rest_of_line ();
5271 s_ignore (int arg ATTRIBUTE_UNUSED)
5273 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5275 ++input_line_pointer;
5277 ++input_line_pointer;
5281 read_print_statistics (FILE *file)
5283 hash_print_statistics (file, "pseudo-op table", po_hash);
5286 /* Inserts the given line into the input stream.
5288 This call avoids macro/conditionals nesting checking, since the contents of
5289 the line are assumed to replace the contents of a line already scanned.
5291 An appropriate use of this function would be substitution of input lines when
5292 called by md_start_line_hook(). The given line is assumed to already be
5293 properly scrubbed. */
5296 input_scrub_insert_line (const char *line)
5300 sb_add_string (&newline, line);
5301 input_scrub_include_sb (&newline, input_line_pointer, 0);
5303 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5306 /* Insert a file into the input stream; the path must resolve to an actual
5307 file; no include path searching or dependency registering is performed. */
5310 input_scrub_insert_file (char *path)
5312 input_scrub_include_file (path, input_line_pointer);
5313 buffer_limit = input_scrub_next_buffer (&input_line_pointer);