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, 2006, 2007, 2008, 2009,
4 2010, 2011 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 3, 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, 51 Franklin Street - Fifth Floor, 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"
42 #include "dw2gencfi.h"
44 #ifndef TC_START_LABEL
45 #define TC_START_LABEL(x,y,z) (x == ':')
48 /* Set by the object-format or the target. */
49 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
50 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
55 else if ((SIZE) >= 4) \
57 else if ((SIZE) >= 2) \
65 char *input_line_pointer; /*->next char of source file to parse. */
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
94 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
103 /* The Delta 68k assembler permits ~ at start of label names. */
107 /* Used by is_... macros. our ctype[]. */
108 char lex_type[256] = {
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
111 0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM, /* 0123456789:;<=>? */
113 LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
114 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
115 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
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
128 Out: 1 if this character ends a line.
129 2 if this character is a line separator. */
130 char is_end_of_line[256] = {
132 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
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, /* */
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 /* */
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string[128];
157 /* Functions private to this file. */
159 static char *buffer; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit; /*->1 + last char in buffer. */
162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
163 in the tc-<CPU>.h file. See the "Porting GAS" section of the
165 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
167 /* Variables for handling include file directory table. */
169 /* Table of pointers to directories to search for .include's. */
172 /* How many are in the table. */
173 int include_dir_count;
175 /* Length of longest in table. */
176 int include_dir_maxlen = 1;
178 #ifndef WORKING_DOT_WORD
179 struct broken_word *broken_words;
180 int new_broken_words;
183 /* The current offset into the absolute section. We don't try to
184 build frags in the absolute section, since no data can be stored
185 there. We just keep track of the current offset. */
186 addressT abs_section_offset;
188 /* If this line had an MRI style label, it is stored in this variable.
189 This is used by some of the MRI pseudo-ops. */
192 /* This global variable is used to support MRI common sections. We
193 translate such sections into a common symbol. This variable is
194 non-NULL when we are in an MRI common section. */
195 symbolS *mri_common_symbol;
197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
198 need to align to an even byte boundary unless the next pseudo-op is
199 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
201 static int mri_pending_align;
205 /* This variable is set to be non-zero if the next string we see might
206 be the name of the source file in DWARF debugging information. See
207 the comment in emit_expr for the format we look for. */
208 static int dwarf_file_string;
212 static void do_s_func (int end_p, const char *default_prefix);
213 static void do_align (int, char *, int, int);
214 static void s_align (int, int);
215 static void s_altmacro (int);
216 static void s_bad_end (int);
218 static void s_gnu_attribute (int);
220 static void s_reloc (int);
221 static int hex_float (int, char *);
222 static segT get_known_segmented_expression (expressionS * expP);
223 static void pobegin (void);
224 static int get_non_macro_line_sb (sb *);
225 static void generate_file_debug (void);
226 static char *_find_end_of_line (char *, int, int, int);
234 obj_read_begin_hook ();
236 /* Something close -- but not too close -- to a multiple of 1024.
237 The debugging malloc I'm using has 24 bytes of overhead. */
238 obstack_begin (¬es, chunksize);
239 obstack_begin (&cond_obstack, chunksize);
241 /* Use machine dependent syntax. */
242 for (p = line_separator_chars; *p; p++)
243 is_end_of_line[(unsigned char) *p] = 2;
244 /* Use more. FIXME-SOMEDAY. */
250 #ifndef TC_ADDRESS_BYTES
251 #define TC_ADDRESS_BYTES address_bytes
256 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
257 contain an address. */
258 int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
266 /* Set up pseudo-op tables. */
268 static struct hash_control *po_hash;
270 static const pseudo_typeS potable[] = {
271 {"abort", s_abort, 0},
272 {"align", s_align_ptwo, 0},
273 {"altmacro", s_altmacro, 1},
274 {"ascii", stringer, 8+0},
275 {"asciz", stringer, 8+1},
276 {"balign", s_align_bytes, 0},
277 {"balignw", s_align_bytes, -2},
278 {"balignl", s_align_bytes, -4},
282 {"common", s_mri_common, 0},
283 {"common.s", s_mri_common, 1},
286 #ifdef TC_ADDRESS_BYTES
290 {"dc.d", float_cons, 'd'},
292 {"dc.s", float_cons, 'f'},
294 {"dc.x", float_cons, 'x'},
296 {"dcb.b", s_space, 1},
297 {"dcb.d", s_float_space, 'd'},
298 {"dcb.l", s_space, 4},
299 {"dcb.s", s_float_space, 'f'},
300 {"dcb.w", s_space, 2},
301 {"dcb.x", s_float_space, 'x'},
303 {"ds.b", s_space, 1},
304 {"ds.d", s_space, 8},
305 {"ds.l", s_space, 4},
306 {"ds.p", s_space, 12},
307 {"ds.s", s_space, 4},
308 {"ds.w", s_space, 2},
309 {"ds.x", s_space, 12},
310 {"debug", s_ignore, 0},
315 {"double", float_cons, 'd'},
317 {"eject", listing_eject, 0}, /* Formfeed listing. */
319 {"elsec", s_else, 0},
320 {"elseif", s_elseif, (int) O_ne},
322 {"endc", s_endif, 0},
323 {"endfunc", s_func, 1},
324 {"endif", s_endif, 0},
325 {"endm", s_bad_end, 0},
326 {"endr", s_bad_end, 1},
332 {"error", s_errwarn, 1},
333 {"exitm", s_mexit, 0},
335 {"extern", s_ignore, 0}, /* We treat all undef as ext. */
336 {"appfile", s_app_file, 1},
337 {"appline", s_app_line, 1},
339 {"file", s_app_file, 0},
341 {"float", float_cons, 'f'},
342 {"format", s_ignore, 0},
344 {"global", s_globl, 0},
345 {"globl", s_globl, 0},
347 {"gnu_attribute", s_gnu_attribute, 0},
350 {"if", s_if, (int) O_ne},
353 {"ifdef", s_ifdef, 0},
354 {"ifeq", s_if, (int) O_eq},
355 {"ifeqs", s_ifeqs, 0},
356 {"ifge", s_if, (int) O_ge},
357 {"ifgt", s_if, (int) O_gt},
358 {"ifle", s_if, (int) O_le},
359 {"iflt", s_if, (int) O_lt},
362 {"ifndef", s_ifdef, 1},
363 {"ifne", s_if, (int) O_ne},
364 {"ifnes", s_ifeqs, 1},
365 {"ifnotdef", s_ifdef, 1},
366 {"incbin", s_incbin, 0},
367 {"include", s_include, 0},
373 {"lcomm", s_lcomm, 0},
374 {"lflags", s_ignore, 0}, /* Listing flags. */
375 {"linefile", s_app_line, 0},
376 {"linkonce", s_linkonce, 0},
377 {"list", listing_list, 1}, /* Turn listing on. */
378 {"llen", listing_psize, 1},
381 {"macro", s_macro, 0},
382 {"mexit", s_mexit, 0},
384 {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */
385 {"name", s_ignore, 0},
386 {"noaltmacro", s_altmacro, 0},
387 {"noformat", s_ignore, 0},
388 {"nolist", listing_list, 0}, /* Turn listing off. */
389 {"nopage", listing_nopage, 0},
391 {"offset", s_struct, 0},
393 {"p2align", s_align_ptwo, 0},
394 {"p2alignw", s_align_ptwo, -2},
395 {"p2alignl", s_align_ptwo, -4},
396 {"page", listing_eject, 0},
397 {"plen", listing_psize, 0},
398 {"print", s_print, 0},
399 {"psize", listing_psize, 0}, /* Set paper size. */
400 {"purgem", s_purgem, 0},
402 {"reloc", s_reloc, 0},
406 {"sbttl", listing_title, 1}, /* Subtitle of listing. */
411 {"single", float_cons, 'f'},
413 {"space", s_space, 0},
414 {"skip", s_space, 0},
415 {"sleb128", s_leb128, 1},
416 {"spc", s_ignore, 0},
417 {"stabd", s_stab, 'd'},
418 {"stabn", s_stab, 'n'},
419 {"stabs", s_stab, 's'},
420 {"string", stringer, 8+1},
421 {"string8", stringer, 8+1},
422 {"string16", stringer, 16+1},
423 {"string32", stringer, 32+1},
424 {"string64", stringer, 64+1},
425 {"struct", s_struct, 0},
429 /* This is for gcc to use. It's only just been added (2/94), so gcc
430 won't be able to use it for a while -- probably a year or more.
431 But once this has been released, check with gcc maintainers
432 before deleting it or even changing the spelling. */
433 {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
434 /* If we're folding case -- done for some targets, not necessarily
435 all -- the above string in an input file will be converted to
436 this one. Match it either way... */
437 {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
439 {"title", listing_title, 0}, /* Listing title. */
440 {"ttl", listing_title, 0},
442 {"uleb128", s_leb128, 0},
446 {"xdef", s_globl, 0},
447 {"xref", s_ignore, 0},
448 {"xstabs", s_xstab, 's'},
449 {"warning", s_errwarn, 0},
450 {"weakref", s_weakref, 0},
452 {"zero", s_space, 0},
453 {NULL, NULL, 0} /* End sentinel. */
457 get_absolute_expr (expressionS *exp)
459 expression_and_evaluate (exp);
460 if (exp->X_op != O_constant)
462 if (exp->X_op != O_absent)
463 as_bad (_("bad or irreducible absolute expression"));
464 exp->X_add_number = 0;
466 return exp->X_add_number;
470 get_absolute_expression (void)
474 return get_absolute_expr (&exp);
477 static int pop_override_ok = 0;
478 static const char *pop_table_name;
481 pop_insert (const pseudo_typeS *table)
484 const pseudo_typeS *pop;
485 for (pop = table; pop->poc_name; pop++)
487 errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
488 if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
489 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
494 #ifndef md_pop_insert
495 #define md_pop_insert() pop_insert(md_pseudo_table)
498 #ifndef obj_pop_insert
499 #define obj_pop_insert() pop_insert(obj_pseudo_table)
502 #ifndef cfi_pop_insert
503 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
509 po_hash = hash_new ();
511 /* Do the target-specific pseudo ops. */
512 pop_table_name = "md";
515 /* Now object specific. Skip any that were in the target table. */
516 pop_table_name = "obj";
520 /* Now portable ones. Skip any that we've seen already. */
521 pop_table_name = "standard";
522 pop_insert (potable);
524 #ifdef TARGET_USE_CFIPOP
525 pop_table_name = "cfi";
531 #define HANDLE_CONDITIONAL_ASSEMBLY() \
532 if (ignore_input ()) \
534 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
535 input_line_pointer = (input_line_pointer <= buffer_limit \
536 && eol >= buffer_limit) \
542 /* This function is used when scrubbing the characters between #APP
545 static char *scrub_string;
546 static char *scrub_string_end;
549 scrub_from_string (char *buf, int buflen)
553 copy = scrub_string_end - scrub_string;
556 memcpy (buf, scrub_string, copy);
557 scrub_string += copy;
561 /* Helper function of read_a_source_file, which tries to expand a macro. */
563 try_macro (char term, const char *line)
569 if (check_macro (line, &out, &err, ¯o))
573 *input_line_pointer++ = term;
574 input_scrub_include_sb (&out,
575 input_line_pointer, 1);
578 input_scrub_next_buffer (&input_line_pointer);
580 md_macro_info (macro);
587 /* We read the file, putting things into a web that represents what we
588 have been reading. */
590 read_a_source_file (char *name)
593 char *s; /* String of symbol, '\0' appended. */
601 buffer = input_scrub_new_file (name);
604 listing_newline (NULL);
605 register_dependency (name);
607 /* Generate debugging information before we've read anything in to denote
608 this file as the "main" source file and not a subordinate one
609 (e.g. N_SO vs N_SOL in stabs). */
610 generate_file_debug ();
612 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
613 { /* We have another line to parse. */
615 /* In order to avoid listing macro expansion lines with labels
616 multiple times, keep track of which line was last issued. */
617 static char *last_eol;
621 while (input_line_pointer < buffer_limit)
623 bfd_boolean was_new_line;
624 /* We have more of this buffer to parse. */
626 /* We now have input_line_pointer->1st char of next line.
627 If input_line_pointer [-1] == '\n' then we just
628 scanned another line: so bump line counters. */
629 was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
632 symbol_set_value_now (&dot_symbol);
633 #ifdef md_start_line_hook
634 md_start_line_hook ();
636 if (input_line_pointer[-1] == '\n')
637 bump_line_counters ();
641 /* If listing is on, and we are expanding a macro, then give
642 the listing code the contents of the expanded line. */
645 if ((listing & LISTING_MACEXP) && macro_nest > 0)
647 /* Find the end of the current expanded macro line. */
648 s = find_end_of_line (input_line_pointer, flag_m68k_mri);
656 /* Copy it for safe keeping. Also give an indication of
657 how much macro nesting is involved at this point. */
658 len = s - input_line_pointer;
659 copy = (char *) xmalloc (len + macro_nest + 2);
660 memset (copy, '>', macro_nest);
661 copy[macro_nest] = ' ';
662 memcpy (copy + macro_nest + 1, input_line_pointer, len);
663 copy[macro_nest + 1 + len] = '\0';
665 /* Install the line with the listing facility. */
666 listing_newline (copy);
670 listing_newline (NULL);
677 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
679 /* Text at the start of a line must be a label, we
680 run down and stick a colon in. */
681 if (is_name_beginner (*input_line_pointer))
683 char *line_start = input_line_pointer;
686 HANDLE_CONDITIONAL_ASSEMBLY ();
688 c = get_symbol_end ();
690 /* In MRI mode, the EQU and MACRO pseudoops must
691 be handled specially. */
695 char *rest = input_line_pointer + 1;
699 if (*rest == ' ' || *rest == '\t')
701 if ((strncasecmp (rest, "EQU", 3) == 0
702 || strncasecmp (rest, "SET", 3) == 0)
703 && (rest[3] == ' ' || rest[3] == '\t'))
705 input_line_pointer = rest + 3;
707 strncasecmp (rest, "SET", 3) == 0);
710 if (strncasecmp (rest, "MACRO", 5) == 0
713 || is_end_of_line[(unsigned char) rest[5]]))
717 /* In MRI mode, we need to handle the MACRO
718 pseudo-op specially: we don't want to put the
719 symbol in the symbol table. */
721 #ifdef TC_START_LABEL_WITHOUT_COLON
722 && TC_START_LABEL_WITHOUT_COLON(c,
726 line_label = colon (line_start);
728 line_label = symbol_create (line_start,
733 *input_line_pointer = c;
735 input_line_pointer++;
740 /* We are at the beginning of a line, or similar place.
741 We expect a well-formed assembler statement.
742 A "symbol-name:" is a statement.
744 Depending on what compiler is used, the order of these tests
745 may vary to catch most common case 1st.
746 Each test is independent of all other tests at the (top)
749 c = *input_line_pointer++;
750 while (c == '\t' || c == ' ' || c == '\f');
752 /* C is the 1st significant character.
753 Input_line_pointer points after that character. */
754 if (is_name_beginner (c))
756 /* Want user-defined label or pseudo/opcode. */
757 HANDLE_CONDITIONAL_ASSEMBLY ();
759 s = --input_line_pointer;
760 c = get_symbol_end (); /* name's delimiter. */
762 /* C is character after symbol.
763 That character's place in the input line is now '\0'.
764 S points to the beginning of the symbol.
765 [In case of pseudo-op, s->'.'.]
766 Input_line_pointer->'\0' where c was. */
767 if (TC_START_LABEL (c, s, input_line_pointer))
771 char *rest = input_line_pointer + 1;
773 /* In MRI mode, \tsym: set 0 is permitted. */
777 if (*rest == ' ' || *rest == '\t')
780 if ((strncasecmp (rest, "EQU", 3) == 0
781 || strncasecmp (rest, "SET", 3) == 0)
782 && (rest[3] == ' ' || rest[3] == '\t'))
784 input_line_pointer = rest + 3;
790 line_label = colon (s); /* User-defined label. */
791 /* Put ':' back for error messages' sake. */
792 *input_line_pointer++ = ':';
793 #ifdef tc_check_label
794 tc_check_label (line_label);
796 /* Input_line_pointer->after ':'. */
799 else if ((c == '=' && input_line_pointer[1] == '=')
800 || ((c == ' ' || c == '\t')
801 && input_line_pointer[1] == '='
802 && input_line_pointer[2] == '='))
805 demand_empty_rest_of_line ();
808 || ((c == ' ' || c == '\t')
809 && input_line_pointer[1] == '='))
810 #ifdef TC_EQUAL_IN_INSN
811 && !TC_EQUAL_IN_INSN (c, s)
816 demand_empty_rest_of_line ();
820 /* Expect pseudo-op or machine instruction. */
823 #ifndef TC_CASE_SENSITIVE
827 strncpy (original_case_string, s2, sizeof (original_case_string));
828 original_case_string[sizeof (original_case_string) - 1] = 0;
837 if (NO_PSEUDO_DOT || flag_m68k_mri)
839 /* The MRI assembler uses pseudo-ops without
841 pop = (pseudo_typeS *) hash_find (po_hash, s);
842 if (pop != NULL && pop->poc_handler == NULL)
847 || (!flag_m68k_mri && *s == '.'))
851 WARNING: c has next char, which may be end-of-line.
852 We lookup the pseudo-op table with s+1 because we
853 already know that the pseudo-op begins with a '.'. */
856 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
857 if (pop && !pop->poc_handler)
860 /* In MRI mode, we may need to insert an
861 automatic alignment directive. What a hack
863 if (mri_pending_align
865 || !((pop->poc_handler == cons
866 && pop->poc_val == 1)
867 || (pop->poc_handler == s_space
868 && pop->poc_val == 1)
869 #ifdef tc_conditional_pseudoop
870 || tc_conditional_pseudoop (pop)
872 || pop->poc_handler == s_if
873 || pop->poc_handler == s_ifdef
874 || pop->poc_handler == s_ifc
875 || pop->poc_handler == s_ifeqs
876 || pop->poc_handler == s_else
877 || pop->poc_handler == s_endif
878 || pop->poc_handler == s_globl
879 || pop->poc_handler == s_ignore)))
881 do_align (1, (char *) NULL, 0, 0);
882 mri_pending_align = 0;
884 if (line_label != NULL)
886 symbol_set_frag (line_label, frag_now);
887 S_SET_VALUE (line_label, frag_now_fix ());
891 /* Print the error msg now, while we still can. */
894 char *end = input_line_pointer;
896 *input_line_pointer = c;
898 c = *--input_line_pointer;
899 *input_line_pointer = '\0';
900 if (! macro_defined || ! try_macro (c, s))
903 as_bad (_("unknown pseudo-op: `%s'"), s);
904 *input_line_pointer++ = c;
909 /* Put it back for error messages etc. */
910 *input_line_pointer = c;
911 /* The following skip of whitespace is compulsory.
912 A well shaped space is sometimes all that separates
913 keyword from operands. */
914 if (c == ' ' || c == '\t')
915 input_line_pointer++;
917 /* Input_line is restored.
918 Input_line_pointer->1st non-blank char
919 after pseudo-operation. */
920 (*pop->poc_handler) (pop->poc_val);
922 /* If that was .end, just get out now. */
923 if (pop->poc_handler == s_end)
928 /* WARNING: c has char, which may be end-of-line. */
929 /* Also: input_line_pointer->`\0` where c was. */
930 *input_line_pointer = c;
931 input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
932 c = *input_line_pointer;
933 *input_line_pointer = '\0';
935 generate_lineno_debug ();
937 if (macro_defined && try_macro (c, s))
940 if (mri_pending_align)
942 do_align (1, (char *) NULL, 0, 0);
943 mri_pending_align = 0;
944 if (line_label != NULL)
946 symbol_set_frag (line_label, frag_now);
947 S_SET_VALUE (line_label, frag_now_fix ());
951 md_assemble (s); /* Assemble 1 instruction. */
953 *input_line_pointer++ = c;
955 /* We resume loop AFTER the end-of-line from
962 /* Empty statement? */
963 if (is_end_of_line[(unsigned char) c])
966 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
968 /* local label ("4:") */
969 char *backup = input_line_pointer;
971 HANDLE_CONDITIONAL_ASSEMBLY ();
975 /* Read the whole number. */
976 while (ISDIGIT (*input_line_pointer))
978 temp = (temp * 10) + *input_line_pointer - '0';
979 ++input_line_pointer;
982 if (LOCAL_LABELS_DOLLAR
983 && *input_line_pointer == '$'
984 && *(input_line_pointer + 1) == ':')
986 input_line_pointer += 2;
988 if (dollar_label_defined (temp))
990 as_fatal (_("label \"%d$\" redefined"), temp);
993 define_dollar_label (temp);
994 colon (dollar_label_name (temp, 0));
999 && *input_line_pointer++ == ':')
1001 fb_label_instance_inc (temp);
1002 colon (fb_label_name (temp, 0));
1006 input_line_pointer = backup;
1007 } /* local label ("4:") */
1009 if (c && strchr (line_comment_chars, c))
1010 { /* Its a comment. Better say APP or NO_APP. */
1015 unsigned int new_length;
1018 s = input_line_pointer;
1019 if (strncmp (s, "APP\n", 4))
1022 ignore_rest_of_line ();
1025 bump_line_counters ();
1029 ends = strstr (s, "#NO_APP\n");
1033 unsigned int tmp_len;
1036 /* The end of the #APP wasn't in this buffer. We
1037 keep reading in buffers until we find the #NO_APP
1038 that goes with this #APP There is one. The specs
1040 tmp_len = buffer_limit - s;
1041 tmp_buf = (char *) xmalloc (tmp_len + 1);
1042 memcpy (tmp_buf, s, tmp_len);
1045 new_tmp = input_scrub_next_buffer (&buffer);
1049 buffer_limit = new_tmp;
1050 input_line_pointer = buffer;
1051 ends = strstr (buffer, "#NO_APP\n");
1053 num = ends - buffer;
1055 num = buffer_limit - buffer;
1057 tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
1058 memcpy (tmp_buf + tmp_len, buffer, num);
1063 input_line_pointer = ends ? ends + 8 : NULL;
1071 input_line_pointer = ends + 8;
1075 scrub_string_end = ends;
1077 new_length = ends - s;
1078 new_buf = (char *) xmalloc (new_length);
1085 space = (new_buf + new_length) - new_tmp;
1086 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1094 new_buf = (char *) xrealloc (new_buf, new_length + 100);
1095 new_tmp = new_buf + new_length;
1102 /* We've "scrubbed" input to the preferred format. In the
1103 process we may have consumed the whole of the remaining
1104 file (and included files). We handle this formatted
1105 input similar to that of macro expansion, letting
1106 actual macro expansion (possibly nested) and other
1107 input expansion work. Beware that in messages, line
1108 numbers and possibly file names will be incorrect. */
1109 sb_add_string (&sbuf, new_buf);
1110 input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1112 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1117 HANDLE_CONDITIONAL_ASSEMBLY ();
1119 #ifdef tc_unrecognized_line
1120 if (tc_unrecognized_line (c))
1123 input_line_pointer--;
1124 /* Report unknown char as error. */
1125 demand_empty_rest_of_line ();
1130 symbol_set_value_now (&dot_symbol);
1135 /* Close the input file. */
1136 input_scrub_close ();
1137 #ifdef WARN_COMMENTS
1139 if (warn_comment && found_comment)
1140 as_warn_where (found_comment_file, found_comment,
1141 "first comment found here");
1146 /* Convert O_constant expression EXP into the equivalent O_big representation.
1147 Take the sign of the number from X_unsigned rather than X_add_number. */
1150 convert_to_bignum (expressionS *exp)
1155 value = exp->X_add_number;
1156 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1158 generic_bignum[i] = value & LITTLENUM_MASK;
1159 value >>= LITTLENUM_NUMBER_OF_BITS;
1161 /* Add a sequence of sign bits if the top bit of X_add_number is not
1162 the sign of the original value. */
1163 if ((exp->X_add_number < 0) != !exp->X_unsigned)
1164 generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1166 exp->X_add_number = i;
1169 /* For most MRI pseudo-ops, the line actually ends at the first
1170 nonquoted space. This function looks for that point, stuffs a null
1171 in, and sets *STOPCP to the character that used to be there, and
1172 returns the location.
1174 Until I hear otherwise, I am going to assume that this is only true
1175 for the m68k MRI assembler. */
1178 mri_comment_field (char *stopcp)
1184 know (flag_m68k_mri);
1186 for (s = input_line_pointer;
1187 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1195 for (s = input_line_pointer;
1196 !is_end_of_line[(unsigned char) *s];
1206 /* Skip to the end of an MRI comment field. */
1209 mri_comment_end (char *stop, int stopc)
1213 input_line_pointer = stop;
1215 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1216 ++input_line_pointer;
1220 s_abort (int ignore ATTRIBUTE_UNUSED)
1222 as_fatal (_(".abort detected. Abandoning ship."));
1225 /* Guts of .align directive. N is the power of two to which to align.
1226 FILL may be NULL, or it may point to the bytes of the fill pattern.
1227 LEN is the length of whatever FILL points to, if anything. MAX is
1228 the maximum number of characters to skip when doing the alignment,
1229 or 0 if there is no maximum. */
1232 do_align (int n, char *fill, int len, int max)
1234 if (now_seg == absolute_section)
1238 if (*fill++ != '\0')
1240 as_warn (_("ignoring fill value in absolute section"));
1247 #ifdef md_flush_pending_output
1248 md_flush_pending_output ();
1251 md_do_align (n, fill, len, max, just_record_alignment);
1254 /* Only make a frag if we HAVE to... */
1255 if (n != 0 && !need_pass_2)
1259 if (subseg_text_p (now_seg))
1260 frag_align_code (n, max);
1262 frag_align (n, 0, max);
1265 frag_align (n, *fill, max);
1267 frag_align_pattern (n, fill, len, max);
1271 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1274 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1277 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1278 (in bytes). A negative ARG is the negative of the length of the
1279 fill pattern. BYTES_P is non-zero if the alignment value should be
1280 interpreted as the byte boundary, rather than the power of 2. */
1281 #ifndef TC_ALIGN_LIMIT
1282 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1286 s_align (int arg, int bytes_p)
1288 unsigned int align_limit = TC_ALIGN_LIMIT;
1297 stop = mri_comment_field (&stopc);
1299 if (is_end_of_line[(unsigned char) *input_line_pointer])
1304 align = arg; /* Default value from pseudo-op table. */
1308 align = get_absolute_expression ();
1314 /* Convert to a power of 2. */
1319 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1322 as_bad (_("alignment not a power of 2"));
1328 if (align > align_limit)
1330 align = align_limit;
1331 as_warn (_("alignment too large: %u assumed"), align);
1334 if (*input_line_pointer != ',')
1341 ++input_line_pointer;
1342 if (*input_line_pointer == ',')
1346 fill = get_absolute_expression ();
1351 if (*input_line_pointer != ',')
1355 ++input_line_pointer;
1356 max = get_absolute_expression ();
1363 as_warn (_("expected fill pattern missing"));
1364 do_align (align, (char *) NULL, 0, max);
1379 do_align (align, &fill_char, fill_len, max);
1385 if ((size_t) fill_len > sizeof ab)
1387 md_number_to_chars (ab, fill, fill_len);
1388 do_align (align, ab, fill_len, max);
1392 demand_empty_rest_of_line ();
1395 mri_comment_end (stop, stopc);
1398 /* Handle the .align pseudo-op on machines where ".align 4" means
1399 align to a 4 byte boundary. */
1402 s_align_bytes (int arg)
1407 /* Handle the .align pseudo-op on machines where ".align 4" means align
1408 to a 2**4 boundary. */
1411 s_align_ptwo (int arg)
1416 /* Switch in and out of alternate macro mode. */
1421 demand_empty_rest_of_line ();
1422 macro_set_alternate (on);
1426 s_comm_internal (int param,
1427 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1433 symbolS *symbolP = NULL;
1439 stop = mri_comment_field (&stopc);
1441 name = input_line_pointer;
1442 c = get_symbol_end ();
1443 /* Just after name is now '\0'. */
1444 p = input_line_pointer;
1449 as_bad (_("expected symbol name"));
1450 ignore_rest_of_line ();
1456 /* Accept an optional comma after the name. The comma used to be
1457 required, but Irix 5 cc does not generate it for .lcomm. */
1458 if (*input_line_pointer == ',')
1459 input_line_pointer++;
1461 temp = get_absolute_expr (&exp);
1463 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1464 if (exp.X_op == O_absent)
1466 as_bad (_("missing size expression"));
1467 ignore_rest_of_line ();
1470 else if (temp != size || !exp.X_unsigned)
1472 as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1473 ignore_rest_of_line ();
1478 symbolP = symbol_find_or_make (name);
1479 if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
1480 && !S_IS_COMMON (symbolP))
1482 if (!S_IS_VOLATILE (symbolP))
1485 as_bad (_("symbol `%s' is already defined"), name);
1487 ignore_rest_of_line ();
1490 symbolP = symbol_clone (symbolP, 1);
1491 S_SET_SEGMENT (symbolP, undefined_section);
1492 S_SET_VALUE (symbolP, 0);
1493 symbol_set_frag (symbolP, &zero_address_frag);
1494 S_CLEAR_VOLATILE (symbolP);
1497 size = S_GET_VALUE (symbolP);
1500 else if (size != temp)
1501 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1502 name, (long) size, (long) temp);
1505 if (comm_parse_extra != NULL)
1506 symbolP = (*comm_parse_extra) (param, symbolP, size);
1509 S_SET_VALUE (symbolP, (valueT) size);
1510 S_SET_EXTERNAL (symbolP);
1511 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
1514 extern int flag_one;
1515 if (size == 0 || !flag_one)
1516 S_GET_OTHER (symbolP) = const_flag;
1521 demand_empty_rest_of_line ();
1524 mri_comment_end (stop, stopc);
1531 s_comm_internal (ignore, NULL);
1534 /* The MRI COMMON pseudo-op. We handle this by creating a common
1535 symbol with the appropriate name. We make s_space do the right
1536 thing by increasing the size. */
1539 s_mri_common (int small ATTRIBUTE_UNUSED)
1555 stop = mri_comment_field (&stopc);
1559 name = input_line_pointer;
1560 if (!ISDIGIT (*name))
1561 c = get_symbol_end ();
1566 ++input_line_pointer;
1568 while (ISDIGIT (*input_line_pointer));
1570 c = *input_line_pointer;
1571 *input_line_pointer = '\0';
1573 if (line_label != NULL)
1575 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1576 + (input_line_pointer - name)
1578 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1583 sym = symbol_find_or_make (name);
1584 *input_line_pointer = c;
1588 if (*input_line_pointer != ',')
1592 ++input_line_pointer;
1593 align = get_absolute_expression ();
1596 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1598 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1599 ignore_rest_of_line ();
1600 mri_comment_end (stop, stopc);
1604 S_SET_EXTERNAL (sym);
1605 S_SET_SEGMENT (sym, bfd_com_section_ptr);
1606 mri_common_symbol = sym;
1610 S_SET_ALIGN (sym, align);
1615 if (line_label != NULL)
1618 exp.X_op = O_symbol;
1619 exp.X_add_symbol = sym;
1620 exp.X_add_number = 0;
1621 symbol_set_value_expression (line_label, &exp);
1622 symbol_set_frag (line_label, &zero_address_frag);
1623 S_SET_SEGMENT (line_label, expr_section);
1626 /* FIXME: We just ignore the small argument, which distinguishes
1627 COMMON and COMMON.S. I don't know what we can do about it. */
1629 /* Ignore the type and hptype. */
1630 if (*input_line_pointer == ',')
1631 input_line_pointer += 2;
1632 if (*input_line_pointer == ',')
1633 input_line_pointer += 2;
1635 demand_empty_rest_of_line ();
1637 mri_comment_end (stop, stopc);
1641 s_data (int ignore ATTRIBUTE_UNUSED)
1646 temp = get_absolute_expression ();
1647 if (flag_readonly_data_in_text)
1649 section = text_section;
1653 section = data_section;
1655 subseg_set (section, (subsegT) temp);
1660 demand_empty_rest_of_line ();
1663 /* Handle the .appfile pseudo-op. This is automatically generated by
1664 do_scrub_chars when a preprocessor # line comment is seen with a
1665 file name. This default definition may be overridden by the object
1666 or CPU specific pseudo-ops. This function is also the default
1667 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1671 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1675 listing_source_file (file);
1677 register_dependency (file);
1679 obj_app_file (file, appfile);
1684 s_app_file (int appfile)
1689 /* Some assemblers tolerate immediately following '"'. */
1690 if ((s = demand_copy_string (&length)) != 0)
1693 = (!new_logical_line_flags (s, -1, 1) && appfile);
1695 /* In MRI mode, the preprocessor may have inserted an extraneous
1698 && *input_line_pointer == '\''
1699 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1700 ++input_line_pointer;
1702 demand_empty_rest_of_line ();
1704 s_app_file_string (s, appfile);
1709 get_linefile_number (int *flag)
1713 if (*input_line_pointer < '0' || *input_line_pointer > '9')
1716 *flag = get_absolute_expression ();
1721 /* Handle the .appline pseudo-op. This is automatically generated by
1722 do_scrub_chars when a preprocessor # line comment is seen. This
1723 default definition may be overridden by the object or CPU specific
1727 s_app_line (int appline)
1732 /* The given number is that of the next line. */
1734 l = get_absolute_expression ();
1735 else if (!get_linefile_number (&l))
1737 ignore_rest_of_line ();
1744 /* Some of the back ends can't deal with non-positive line numbers.
1745 Besides, it's silly. GCC however will generate a line number of
1746 zero when it is pre-processing builtins for assembler-with-cpp files:
1750 We do not want to barf on this, especially since such files are used
1751 in the GCC and GDB testsuites. So we check for negative line numbers
1752 rather than non-positive line numbers. */
1753 as_warn (_("line numbers must be positive; line number %d rejected"),
1764 if (*input_line_pointer == '"')
1765 file = demand_copy_string (&length);
1771 while (get_linefile_number (&this_flag))
1774 /* From GCC's cpp documentation:
1775 1: start of a new file.
1776 2: returning to a file after having included
1778 3: following text comes from a system header file.
1779 4: following text should be treated as extern "C".
1781 4 is nonsensical for the assembler; 3, we don't
1782 care about, so we ignore it just in case a
1783 system header file is included while
1784 preprocessing assembly. So 1 and 2 are all we
1785 care about, and they are mutually incompatible.
1786 new_logical_line_flags() demands this. */
1789 if (flags && flags != (1 << this_flag))
1790 as_warn (_("incompatible flag %i in line directive"),
1793 flags |= 1 << this_flag;
1798 /* We ignore these. */
1802 as_warn (_("unsupported flag %i in line directive"),
1807 if (!is_end_of_line[(unsigned char)*input_line_pointer])
1812 if (appline || file)
1814 new_logical_line_flags (file, l, flags);
1817 listing_source_line (l);
1821 if (appline || file)
1822 demand_empty_rest_of_line ();
1824 ignore_rest_of_line ();
1827 /* Handle the .end pseudo-op. Actually, the real work is done in
1828 read_a_source_file. */
1831 s_end (int ignore ATTRIBUTE_UNUSED)
1835 /* The MRI assembler permits the start symbol to follow .end,
1836 but we don't support that. */
1838 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1839 && *input_line_pointer != '*'
1840 && *input_line_pointer != '!')
1841 as_warn (_("start address not supported"));
1845 /* Handle the .err pseudo-op. */
1848 s_err (int ignore ATTRIBUTE_UNUSED)
1850 as_bad (_(".err encountered"));
1851 demand_empty_rest_of_line ();
1854 /* Handle the .error and .warning pseudo-ops. */
1860 /* The purpose for the conditional assignment is not to
1861 internationalize the directive itself, but that we need a
1862 self-contained message, one that can be passed like the
1863 demand_copy_C_string return value, and with no assumption on the
1864 location of the name of the directive within the message. */
1866 = (err ? _(".error directive invoked in source file")
1867 : _(".warning directive invoked in source file"));
1869 if (!is_it_end_of_statement ())
1871 if (*input_line_pointer != '\"')
1873 as_bad (_("%s argument must be a string"),
1874 err ? ".error" : ".warning");
1875 ignore_rest_of_line ();
1879 msg = demand_copy_C_string (&len);
1887 as_warn ("%s", msg);
1888 demand_empty_rest_of_line ();
1891 /* Handle the MRI fail pseudo-op. */
1894 s_fail (int ignore ATTRIBUTE_UNUSED)
1901 stop = mri_comment_field (&stopc);
1903 temp = get_absolute_expression ();
1905 as_warn (_(".fail %ld encountered"), (long) temp);
1907 as_bad (_(".fail %ld encountered"), (long) temp);
1909 demand_empty_rest_of_line ();
1912 mri_comment_end (stop, stopc);
1916 s_fill (int ignore ATTRIBUTE_UNUSED)
1918 expressionS rep_exp;
1923 #ifdef md_flush_pending_output
1924 md_flush_pending_output ();
1927 #ifdef md_cons_align
1931 get_known_segmented_expression (&rep_exp);
1932 if (*input_line_pointer == ',')
1934 input_line_pointer++;
1935 size = get_absolute_expression ();
1936 if (*input_line_pointer == ',')
1938 input_line_pointer++;
1939 fill = get_absolute_expression ();
1943 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1944 #define BSD_FILL_SIZE_CROCK_8 (8)
1945 if (size > BSD_FILL_SIZE_CROCK_8)
1947 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1948 size = BSD_FILL_SIZE_CROCK_8;
1952 as_warn (_("size negative; .fill ignored"));
1955 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1957 if (rep_exp.X_add_number < 0)
1958 as_warn (_("repeat < 0; .fill ignored"));
1962 if (size && !need_pass_2)
1964 if (rep_exp.X_op == O_constant)
1966 p = frag_var (rs_fill, (int) size, (int) size,
1967 (relax_substateT) 0, (symbolS *) 0,
1968 (offsetT) rep_exp.X_add_number,
1973 /* We don't have a constant repeat count, so we can't use
1974 rs_fill. We can get the same results out of rs_space,
1975 but its argument is in bytes, so we must multiply the
1976 repeat count by size. */
1979 rep_sym = make_expr_symbol (&rep_exp);
1982 expressionS size_exp;
1983 size_exp.X_op = O_constant;
1984 size_exp.X_add_number = size;
1986 rep_exp.X_op = O_multiply;
1987 rep_exp.X_add_symbol = rep_sym;
1988 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1989 rep_exp.X_add_number = 0;
1990 rep_sym = make_expr_symbol (&rep_exp);
1993 p = frag_var (rs_space, (int) size, (int) size,
1994 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1997 memset (p, 0, (unsigned int) size);
1999 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2000 flavoured AS. The following bizarre behaviour is to be
2001 compatible with above. I guess they tried to take up to 8
2002 bytes from a 4-byte expression and they forgot to sign
2004 #define BSD_FILL_SIZE_CROCK_4 (4)
2005 md_number_to_chars (p, (valueT) fill,
2006 (size > BSD_FILL_SIZE_CROCK_4
2007 ? BSD_FILL_SIZE_CROCK_4
2009 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2010 but emits no error message because it seems a legal thing to do.
2011 It is a degenerate case of .fill but could be emitted by a
2014 demand_empty_rest_of_line ();
2018 s_globl (int ignore ATTRIBUTE_UNUSED)
2027 stop = mri_comment_field (&stopc);
2031 name = input_line_pointer;
2032 c = get_symbol_end ();
2033 symbolP = symbol_find_or_make (name);
2034 S_SET_EXTERNAL (symbolP);
2036 *input_line_pointer = c;
2038 c = *input_line_pointer;
2041 input_line_pointer++;
2043 if (is_end_of_line[(unsigned char) *input_line_pointer])
2049 demand_empty_rest_of_line ();
2052 mri_comment_end (stop, stopc);
2056 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
2059 skip_past_char (char ** str, char c)
2069 #define skip_past_comma(str) skip_past_char (str, ',')
2071 /* Parse an attribute directive for VENDOR.
2072 Returns the attribute number read, or zero on error. */
2074 s_vendor_attribute (int vendor)
2082 /* Read the first number or name. */
2083 skip_whitespace (input_line_pointer);
2084 s = input_line_pointer;
2085 if (ISDIGIT (*input_line_pointer))
2088 if (exp.X_op != O_constant)
2090 tag = exp.X_add_number;
2096 /* A name may contain '_', but no other punctuation. */
2097 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2098 ++input_line_pointer)
2103 name = (char *) alloca (i + 1);
2104 memcpy (name, s, i);
2107 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2108 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2111 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2114 as_bad (_("Attribute name not recognised: %s"), name);
2115 ignore_rest_of_line ();
2120 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2122 if (skip_past_comma (&input_line_pointer) == -1)
2127 if (exp.X_op != O_constant)
2129 as_bad (_("expected numeric constant"));
2130 ignore_rest_of_line ();
2133 i = exp.X_add_number;
2136 && skip_past_comma (&input_line_pointer) == -1)
2138 as_bad (_("expected comma"));
2139 ignore_rest_of_line ();
2146 skip_whitespace (input_line_pointer);
2147 if (*input_line_pointer != '"')
2149 s = demand_copy_C_string (&len);
2155 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2158 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2161 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2167 demand_empty_rest_of_line ();
2170 as_bad (_("bad string constant"));
2171 ignore_rest_of_line ();
2174 as_bad (_("expected <tag> , <value>"));
2175 ignore_rest_of_line ();
2179 /* Parse a .gnu_attribute directive. */
2182 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2184 s_vendor_attribute (OBJ_ATTR_GNU);
2186 #endif /* OBJ_ELF */
2188 /* Handle the MRI IRP and IRPC pseudo-ops. */
2199 as_where (&file, &line);
2202 eol = find_end_of_line (input_line_pointer, 0);
2203 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2204 input_line_pointer = eol;
2208 err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2210 as_bad_where (file, line, "%s", err);
2214 input_scrub_include_sb (&out, input_line_pointer, 1);
2216 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2219 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2220 the section to only be linked once. However, this is not supported
2221 by most object file formats. This takes an optional argument,
2222 which is what to do about duplicates. */
2225 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2227 enum linkonce_type type;
2231 type = LINKONCE_DISCARD;
2233 if (!is_end_of_line[(unsigned char) *input_line_pointer])
2238 s = input_line_pointer;
2239 c = get_symbol_end ();
2240 if (strcasecmp (s, "discard") == 0)
2241 type = LINKONCE_DISCARD;
2242 else if (strcasecmp (s, "one_only") == 0)
2243 type = LINKONCE_ONE_ONLY;
2244 else if (strcasecmp (s, "same_size") == 0)
2245 type = LINKONCE_SAME_SIZE;
2246 else if (strcasecmp (s, "same_contents") == 0)
2247 type = LINKONCE_SAME_CONTENTS;
2249 as_warn (_("unrecognized .linkonce type `%s'"), s);
2251 *input_line_pointer = c;
2254 #ifdef obj_handle_link_once
2255 obj_handle_link_once (type);
2256 #else /* ! defined (obj_handle_link_once) */
2260 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2261 as_warn (_(".linkonce is not supported for this object file format"));
2263 flags = bfd_get_section_flags (stdoutput, now_seg);
2264 flags |= SEC_LINK_ONCE;
2269 case LINKONCE_DISCARD:
2270 flags |= SEC_LINK_DUPLICATES_DISCARD;
2272 case LINKONCE_ONE_ONLY:
2273 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2275 case LINKONCE_SAME_SIZE:
2276 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2278 case LINKONCE_SAME_CONTENTS:
2279 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2282 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2283 as_bad (_("bfd_set_section_flags: %s"),
2284 bfd_errmsg (bfd_get_error ()));
2286 #endif /* ! defined (obj_handle_link_once) */
2288 demand_empty_rest_of_line ();
2292 bss_alloc (symbolS *symbolP, addressT size, int align)
2295 segT current_seg = now_seg;
2296 subsegT current_subseg = now_subseg;
2297 segT bss_seg = bss_section;
2299 #if defined (TC_MIPS) || defined (TC_ALPHA)
2300 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2301 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2303 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2304 if (size <= bfd_get_gp_size (stdoutput))
2306 bss_seg = subseg_new (".sbss", 1);
2307 seg_info (bss_seg)->bss = 1;
2308 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2309 as_warn (_("error setting flags for \".sbss\": %s"),
2310 bfd_errmsg (bfd_get_error ()));
2314 subseg_set (bss_seg, 1);
2318 record_alignment (bss_seg, align);
2319 frag_align (align, 0, 0);
2322 /* Detach from old frag. */
2323 if (S_GET_SEGMENT (symbolP) == bss_seg)
2324 symbol_get_frag (symbolP)->fr_symbol = NULL;
2326 symbol_set_frag (symbolP, frag_now);
2327 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2331 S_SET_SIZE (symbolP, size);
2333 S_SET_SEGMENT (symbolP, bss_seg);
2336 /* The symbol may already have been created with a preceding
2337 ".globl" directive -- be careful not to step on storage class
2338 in that case. Otherwise, set it to static. */
2339 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2340 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2341 #endif /* OBJ_COFF */
2343 subseg_set (current_seg, current_subseg);
2347 parse_align (int align_bytes)
2353 if (*input_line_pointer != ',')
2356 as_bad (_("expected alignment after size"));
2357 ignore_rest_of_line ();
2361 input_line_pointer++;
2364 align = get_absolute_expr (&exp);
2365 if (exp.X_op == O_absent)
2368 if (!exp.X_unsigned)
2370 as_warn (_("alignment negative; 0 assumed"));
2374 if (align_bytes && align != 0)
2376 /* convert to a power of 2 alignment */
2377 unsigned int alignp2 = 0;
2378 while ((align & 1) == 0)
2379 align >>= 1, ++alignp2;
2382 as_bad (_("alignment not a power of 2"));
2383 ignore_rest_of_line ();
2391 /* Called from s_comm_internal after symbol name and size have been
2392 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2393 1 if this was a ".bss" directive which has a 3rd argument
2394 (alignment as a power of 2), or 2 if this was a ".bss" directive
2395 with alignment in bytes. */
2398 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2404 align = parse_align (needs_align - 1);
2405 if (align == (addressT) -1)
2409 /* Assume some objects may require alignment on some systems. */
2410 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2412 bss_alloc (symbolP, size, align);
2417 s_lcomm (int needs_align)
2419 s_comm_internal (needs_align, s_lcomm_internal);
2423 s_lcomm_bytes (int needs_align)
2425 s_comm_internal (needs_align * 2, s_lcomm_internal);
2429 s_lsym (int ignore ATTRIBUTE_UNUSED)
2437 /* We permit ANY defined expression: BSD4.2 demands constants. */
2438 name = input_line_pointer;
2439 c = get_symbol_end ();
2440 p = input_line_pointer;
2445 as_bad (_("expected symbol name"));
2446 ignore_rest_of_line ();
2452 if (*input_line_pointer != ',')
2455 as_bad (_("expected comma after \"%s\""), name);
2457 ignore_rest_of_line ();
2461 input_line_pointer++;
2462 expression_and_evaluate (&exp);
2464 if (exp.X_op != O_constant
2465 && exp.X_op != O_register)
2467 as_bad (_("bad expression"));
2468 ignore_rest_of_line ();
2473 symbolP = symbol_find_or_make (name);
2475 if (S_GET_SEGMENT (symbolP) == undefined_section)
2477 /* The name might be an undefined .global symbol; be sure to
2478 keep the "external" bit. */
2479 S_SET_SEGMENT (symbolP,
2480 (exp.X_op == O_constant
2483 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2487 as_bad (_("symbol `%s' is already defined"), name);
2491 demand_empty_rest_of_line ();
2494 /* Read a line into an sb. Returns the character that ended the line
2495 or zero if there are no more lines. */
2498 get_line_sb (sb *line, int in_macro)
2502 if (input_line_pointer[-1] == '\n')
2503 bump_line_counters ();
2505 if (input_line_pointer >= buffer_limit)
2507 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2508 if (buffer_limit == 0)
2512 eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2513 sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2514 input_line_pointer = eol;
2516 /* Don't skip multiple end-of-line characters, because that breaks support
2517 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2518 characters but isn't. Instead just skip one end of line character and
2519 return the character skipped so that the caller can re-insert it if
2521 return *input_line_pointer++;
2525 get_non_macro_line_sb (sb *line)
2527 return get_line_sb (line, 0);
2531 get_macro_line_sb (sb *line)
2533 return get_line_sb (line, 1);
2536 /* Define a macro. This is an interface to macro.c. */
2539 s_macro (int ignore ATTRIBUTE_UNUSED)
2547 as_where (&file, &line);
2550 eol = find_end_of_line (input_line_pointer, 0);
2551 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2552 input_line_pointer = eol;
2554 if (line_label != NULL)
2559 sb_add_string (&label, S_GET_NAME (line_label));
2560 err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2564 err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2566 as_bad_where (file, line, err, name);
2569 if (line_label != NULL)
2571 S_SET_SEGMENT (line_label, absolute_section);
2572 S_SET_VALUE (line_label, 0);
2573 symbol_set_frag (line_label, &zero_address_frag);
2576 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2577 && hash_find (po_hash, name) != NULL)
2580 && hash_find (po_hash, name + 1) != NULL))
2581 as_warn_where (file,
2583 _("attempt to redefine pseudo-op `%s' ignored"),
2590 /* Handle the .mexit pseudo-op, which immediately exits a macro
2594 s_mexit (int ignore ATTRIBUTE_UNUSED)
2598 cond_exit_macro (macro_nest);
2599 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2602 as_warn (_("ignoring macro exit outside a macro definition."));
2605 /* Switch in and out of MRI mode. */
2608 s_mri (int ignore ATTRIBUTE_UNUSED)
2611 #ifdef MRI_MODE_CHANGE
2615 on = get_absolute_expression ();
2616 #ifdef MRI_MODE_CHANGE
2617 old_flag = flag_mri;
2636 /* Operator precedence changes in m68k MRI mode, so we need to
2637 update the operator rankings. */
2638 expr_set_precedence ();
2640 #ifdef MRI_MODE_CHANGE
2642 MRI_MODE_CHANGE (on);
2645 demand_empty_rest_of_line ();
2648 /* Handle changing the location counter. */
2651 do_org (segT segment, expressionS *exp, int fill)
2653 if (segment != now_seg
2654 && segment != absolute_section
2655 && segment != expr_section)
2656 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2658 if (now_seg == absolute_section)
2661 as_warn (_("ignoring fill value in absolute section"));
2662 if (exp->X_op != O_constant)
2664 as_bad (_("only constant offsets supported in absolute section"));
2665 exp->X_add_number = 0;
2667 abs_section_offset = exp->X_add_number;
2672 symbolS *sym = exp->X_add_symbol;
2673 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2675 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2677 /* Handle complex expressions. */
2678 sym = make_expr_symbol (exp);
2682 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2688 s_org (int ignore ATTRIBUTE_UNUSED)
2694 #ifdef md_flush_pending_output
2695 md_flush_pending_output ();
2698 /* The m68k MRI assembler has a different meaning for .org. It
2699 means to create an absolute section at a given address. We can't
2700 support that--use a linker script instead. */
2703 as_bad (_("MRI style ORG pseudo-op not supported"));
2704 ignore_rest_of_line ();
2708 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2709 thing as a sub-segment-relative origin. Any absolute origin is
2710 given a warning, then assumed to be segment-relative. Any
2711 segmented origin expression ("foo+42") had better be in the right
2712 segment or the .org is ignored.
2714 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2715 we never know sub-segment sizes when we are reading code. BSD
2716 will crash trying to emit negative numbers of filler bytes in
2717 certain .orgs. We don't crash, but see as-write for that code.
2719 Don't make frag if need_pass_2==1. */
2720 segment = get_known_segmented_expression (&exp);
2721 if (*input_line_pointer == ',')
2723 input_line_pointer++;
2724 temp_fill = get_absolute_expression ();
2730 do_org (segment, &exp, temp_fill);
2732 demand_empty_rest_of_line ();
2735 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2736 called by the obj-format routine which handles section changing
2737 when in MRI mode. It will create a new section, and return it. It
2738 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2739 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2742 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2752 name = input_line_pointer;
2753 if (!ISDIGIT (*name))
2754 c = get_symbol_end ();
2759 ++input_line_pointer;
2761 while (ISDIGIT (*input_line_pointer));
2763 c = *input_line_pointer;
2764 *input_line_pointer = '\0';
2767 name = xstrdup (name);
2769 *input_line_pointer = c;
2771 seg = subseg_new (name, 0);
2773 if (*input_line_pointer == ',')
2777 ++input_line_pointer;
2778 align = get_absolute_expression ();
2779 record_alignment (seg, align);
2783 if (*input_line_pointer == ',')
2785 c = *++input_line_pointer;
2787 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2790 as_bad (_("unrecognized section type"));
2791 ++input_line_pointer;
2796 flags = SEC_NO_FLAGS;
2798 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2799 else if (*type == 'D' || *type == 'M')
2800 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2801 else if (*type == 'R')
2802 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2803 if (flags != SEC_NO_FLAGS)
2805 if (!bfd_set_section_flags (stdoutput, seg, flags))
2806 as_warn (_("error setting flags for \"%s\": %s"),
2807 bfd_section_name (stdoutput, seg),
2808 bfd_errmsg (bfd_get_error ()));
2813 /* Ignore the HP type. */
2814 if (*input_line_pointer == ',')
2815 input_line_pointer += 2;
2817 demand_empty_rest_of_line ();
2819 #else /* ! TC_M68K */
2828 name = input_line_pointer;
2829 c = get_symbol_end ();
2831 name = xstrdup (name);
2833 *input_line_pointer = c;
2835 seg = subseg_new (name, 0);
2837 if (*input_line_pointer != ',')
2843 ++input_line_pointer;
2845 sectype = input_line_pointer;
2846 c = get_symbol_end ();
2847 if (*sectype == '\0')
2849 else if (strcasecmp (sectype, "text") == 0)
2851 else if (strcasecmp (sectype, "data") == 0)
2853 else if (strcasecmp (sectype, "romdata") == 0)
2856 as_warn (_("unrecognized section type `%s'"), sectype);
2857 *input_line_pointer = c;
2860 if (*input_line_pointer == ',')
2864 ++input_line_pointer;
2866 seccmd = input_line_pointer;
2867 c = get_symbol_end ();
2868 if (strcasecmp (seccmd, "absolute") == 0)
2870 as_bad (_("absolute sections are not supported"));
2871 *input_line_pointer = c;
2872 ignore_rest_of_line ();
2875 else if (strcasecmp (seccmd, "align") == 0)
2879 *input_line_pointer = c;
2880 align = get_absolute_expression ();
2881 record_alignment (seg, align);
2885 as_warn (_("unrecognized section command `%s'"), seccmd);
2886 *input_line_pointer = c;
2890 demand_empty_rest_of_line ();
2892 #else /* ! TC_I960 */
2893 /* The MRI assembler seems to use different forms of .sect for
2894 different targets. */
2895 as_bad ("MRI mode not supported for this target");
2896 ignore_rest_of_line ();
2897 #endif /* ! TC_I960 */
2898 #endif /* ! TC_M68K */
2901 /* Handle the .print pseudo-op. */
2904 s_print (int ignore ATTRIBUTE_UNUSED)
2909 s = demand_copy_C_string (&len);
2912 demand_empty_rest_of_line ();
2915 /* Handle the .purgem pseudo-op. */
2918 s_purgem (int ignore ATTRIBUTE_UNUSED)
2920 if (is_it_end_of_statement ())
2922 demand_empty_rest_of_line ();
2932 name = input_line_pointer;
2933 c = get_symbol_end ();
2934 delete_macro (name);
2935 *input_line_pointer = c;
2938 while (*input_line_pointer++ == ',');
2940 --input_line_pointer;
2941 demand_empty_rest_of_line ();
2944 /* Handle the .endm/.endr pseudo-ops. */
2947 s_bad_end (int endr)
2949 as_warn (_(".end%c encountered without preceeding %s"),
2951 endr ? ".rept, .irp, or .irpc" : ".macro");
2952 demand_empty_rest_of_line ();
2955 /* Handle the .rept pseudo-op. */
2958 s_rept (int ignore ATTRIBUTE_UNUSED)
2962 count = get_absolute_expression ();
2964 do_repeat (count, "REPT", "ENDR");
2967 /* This function provides a generic repeat block implementation. It allows
2968 different directives to be used as the start/end keys. */
2971 do_repeat (int count, const char *start, const char *end)
2977 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2979 as_bad (_("%s without %s"), start, end);
2985 sb_add_sb (&many, &one);
2989 input_scrub_include_sb (&many, input_line_pointer, 1);
2991 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2994 /* Like do_repeat except that any text matching EXPANDER in the
2995 block is replaced by the itteration count. */
2998 do_repeat_with_expander (int count,
3001 const char * expander)
3007 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3009 as_bad (_("%s without %s"), start, end);
3015 if (expander != NULL && strstr (one.ptr, expander) != NULL)
3017 while (count -- > 0)
3023 sb_new (& processed);
3024 sb_add_sb (& processed, & one);
3025 sub = strstr (processed.ptr, expander);
3026 len = sprintf (sub, "%d", count);
3027 gas_assert (len < 8);
3028 strcpy (sub + len, sub + 8);
3029 processed.len -= (8 - len);
3030 sb_add_sb (& many, & processed);
3031 sb_kill (& processed);
3036 sb_add_sb (&many, &one);
3040 input_scrub_include_sb (&many, input_line_pointer, 1);
3042 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3045 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3046 input buffers to skip. Assumes that conditionals preceding the loop end
3047 are properly nested.
3049 This function makes it easier to implement a premature "break" out of the
3050 loop. The EXTRA arg accounts for other buffers we might have inserted,
3051 such as line substitutions. */
3054 end_repeat (int extra)
3056 cond_exit_macro (macro_nest);
3057 while (extra-- >= 0)
3058 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3062 assign_symbol (char *name, int mode)
3066 if (name[0] == '.' && name[1] == '\0')
3068 /* Turn '. = mumble' into a .org mumble. */
3072 segment = get_known_segmented_expression (&exp);
3075 do_org (segment, &exp, 0);
3080 if ((symbolP = symbol_find (name)) == NULL
3081 && (symbolP = md_undefined_symbol (name)) == NULL)
3083 symbolP = symbol_find_or_make (name);
3085 /* When doing symbol listings, play games with dummy fragments living
3086 outside the normal fragment chain to record the file and line info
3088 if (listing & LISTING_SYMBOLS)
3090 extern struct list_info_struct *listing_tail;
3091 fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3092 dummy_frag->line = listing_tail;
3093 dummy_frag->fr_symbol = symbolP;
3094 symbol_set_frag (symbolP, dummy_frag);
3098 /* "set" symbols are local unless otherwise specified. */
3099 SF_SET_LOCAL (symbolP);
3103 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3105 /* Permit register names to be redefined. */
3106 if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3107 && S_GET_SEGMENT (symbolP) != reg_section)
3109 as_bad (_("symbol `%s' is already defined"), name);
3110 symbolP = symbol_clone (symbolP, 0);
3112 /* If the symbol is volatile, copy the symbol and replace the
3113 original with the copy, so that previous uses of the symbol will
3114 retain the value of the symbol at the point of use. */
3115 else if (S_IS_VOLATILE (symbolP))
3116 symbolP = symbol_clone (symbolP, 1);
3120 S_SET_VOLATILE (symbolP);
3122 S_SET_FORWARD_REF (symbolP);
3124 pseudo_set (symbolP);
3127 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3128 then this is .equiv, and it is an error if the symbol is already
3129 defined. If EQUIV is -1, the symbol additionally is a forward
3139 /* Especial apologies for the random logic:
3140 this just grew, and could be parsed much more simply!
3142 name = input_line_pointer;
3143 delim = get_symbol_end ();
3144 end_name = input_line_pointer;
3147 if (name == end_name)
3149 as_bad (_("expected symbol name"));
3150 ignore_rest_of_line ();
3156 if (*input_line_pointer != ',')
3159 as_bad (_("expected comma after \"%s\""), name);
3161 ignore_rest_of_line ();
3165 input_line_pointer++;
3168 assign_symbol (name, equiv);
3171 demand_empty_rest_of_line ();
3184 #ifdef md_flush_pending_output
3185 md_flush_pending_output ();
3188 #ifdef md_cons_align
3193 stop = mri_comment_field (&stopc);
3195 /* In m68k MRI mode, we need to align to a word boundary, unless
3197 if (flag_m68k_mri && mult > 1)
3199 if (now_seg == absolute_section)
3201 abs_section_offset += abs_section_offset & 1;
3202 if (line_label != NULL)
3203 S_SET_VALUE (line_label, abs_section_offset);
3205 else if (mri_common_symbol != NULL)
3209 mri_val = S_GET_VALUE (mri_common_symbol);
3210 if ((mri_val & 1) != 0)
3212 S_SET_VALUE (mri_common_symbol, mri_val + 1);
3213 if (line_label != NULL)
3215 expressionS *symexp;
3217 symexp = symbol_get_value_expression (line_label);
3218 know (symexp->X_op == O_symbol);
3219 know (symexp->X_add_symbol == mri_common_symbol);
3220 symexp->X_add_number += 1;
3226 do_align (1, (char *) NULL, 0, 0);
3227 if (line_label != NULL)
3229 symbol_set_frag (line_label, frag_now);
3230 S_SET_VALUE (line_label, frag_now_fix ());
3240 if (*input_line_pointer == ',')
3242 ++input_line_pointer;
3247 val.X_op = O_constant;
3248 val.X_add_number = 0;
3251 if (val.X_op != O_constant
3252 || val.X_add_number < - 0x80
3253 || val.X_add_number > 0xff
3254 || (mult != 0 && mult != 1 && val.X_add_number != 0))
3256 resolve_expression (&exp);
3257 if (exp.X_op != O_constant)
3258 as_bad (_("unsupported variable size or fill value"));
3265 bytes = mult * exp.X_add_number;
3266 for (i = 0; i < exp.X_add_number; i++)
3267 emit_expr (&val, mult);
3272 if (now_seg == absolute_section || mri_common_symbol != NULL)
3273 resolve_expression (&exp);
3275 if (exp.X_op == O_constant)
3279 repeat = exp.X_add_number;
3286 as_warn (_(".space repeat count is zero, ignored"));
3287 else if (repeat < 0)
3288 as_warn (_(".space repeat count is negative, ignored"));
3292 /* If we are in the absolute section, just bump the offset. */
3293 if (now_seg == absolute_section)
3295 abs_section_offset += repeat;
3299 /* If we are secretly in an MRI common section, then
3300 creating space just increases the size of the common
3302 if (mri_common_symbol != NULL)
3304 S_SET_VALUE (mri_common_symbol,
3305 S_GET_VALUE (mri_common_symbol) + repeat);
3310 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3311 (offsetT) repeat, (char *) 0);
3315 if (now_seg == absolute_section)
3317 as_bad (_("space allocation too complex in absolute section"));
3318 subseg_set (text_section, 0);
3321 if (mri_common_symbol != NULL)
3323 as_bad (_("space allocation too complex in common section"));
3324 mri_common_symbol = NULL;
3328 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3329 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3333 *p = val.X_add_number;
3338 /* In MRI mode, after an odd number of bytes, we must align to an
3339 even word boundary, unless the next instruction is a dc.b, ds.b
3341 if (flag_mri && (bytes & 1) != 0)
3342 mri_pending_align = 1;
3344 demand_empty_rest_of_line ();
3347 mri_comment_end (stop, stopc);
3350 /* This is like s_space, but the value is a floating point number with
3351 the given precision. This is for the MRI dcb.s pseudo-op and
3355 s_float_space (int float_type)
3359 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3363 #ifdef md_cons_align
3368 stop = mri_comment_field (&stopc);
3370 count = get_absolute_expression ();
3373 if (*input_line_pointer != ',')
3375 as_bad (_("missing value"));
3376 ignore_rest_of_line ();
3378 mri_comment_end (stop, stopc);
3382 ++input_line_pointer;
3386 /* Skip any 0{letter} that may be present. Don't even check if the
3387 * letter is legal. */
3388 if (input_line_pointer[0] == '0'
3389 && ISALPHA (input_line_pointer[1]))
3390 input_line_pointer += 2;
3392 /* Accept :xxxx, where the x's are hex digits, for a floating point
3393 with the exact digits specified. */
3394 if (input_line_pointer[0] == ':')
3396 flen = hex_float (float_type, temp);
3399 ignore_rest_of_line ();
3401 mri_comment_end (stop, stopc);
3409 err = md_atof (float_type, temp, &flen);
3410 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3411 know (err != NULL || flen > 0);
3414 as_bad (_("bad floating literal: %s"), err);
3415 ignore_rest_of_line ();
3417 mri_comment_end (stop, stopc);
3422 while (--count >= 0)
3426 p = frag_more (flen);
3427 memcpy (p, temp, (unsigned int) flen);
3430 demand_empty_rest_of_line ();
3433 mri_comment_end (stop, stopc);
3436 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3439 s_struct (int ignore ATTRIBUTE_UNUSED)
3445 stop = mri_comment_field (&stopc);
3446 abs_section_offset = get_absolute_expression ();
3447 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3448 /* The ELF backend needs to know that we are changing sections, so
3449 that .previous works correctly. */
3451 obj_elf_section_change_hook ();
3453 subseg_set (absolute_section, 0);
3454 demand_empty_rest_of_line ();
3456 mri_comment_end (stop, stopc);
3460 s_text (int ignore ATTRIBUTE_UNUSED)
3464 temp = get_absolute_expression ();
3465 subseg_set (text_section, (subsegT) temp);
3466 demand_empty_rest_of_line ();
3468 const_flag &= ~IN_DEFAULT_SECTION;
3472 /* .weakref x, y sets x as an alias to y that, as long as y is not
3473 referenced directly, will cause y to become a weak symbol. */
3475 s_weakref (int ignore ATTRIBUTE_UNUSED)
3484 name = input_line_pointer;
3485 delim = get_symbol_end ();
3486 end_name = input_line_pointer;
3488 if (name == end_name)
3490 as_bad (_("expected symbol name"));
3492 ignore_rest_of_line ();
3496 symbolP = symbol_find_or_make (name);
3498 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3500 if (!S_IS_VOLATILE (symbolP))
3502 as_bad (_("symbol `%s' is already defined"), name);
3504 ignore_rest_of_line ();
3507 symbolP = symbol_clone (symbolP, 1);
3508 S_CLEAR_VOLATILE (symbolP);
3515 if (*input_line_pointer != ',')
3518 as_bad (_("expected comma after \"%s\""), name);
3520 ignore_rest_of_line ();
3524 input_line_pointer++;
3528 name = input_line_pointer;
3529 delim = get_symbol_end ();
3530 end_name = input_line_pointer;
3532 if (name == end_name)
3534 as_bad (_("expected symbol name"));
3535 ignore_rest_of_line ();
3539 if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3540 && (symbolP2 = md_undefined_symbol (name)) == NULL)
3542 symbolP2 = symbol_find_or_make (name);
3543 S_SET_WEAKREFD (symbolP2);
3547 symbolS *symp = symbolP2;
3549 while (S_IS_WEAKREFR (symp) && symp != symbolP)
3551 expressionS *expP = symbol_get_value_expression (symp);
3553 gas_assert (expP->X_op == O_symbol
3554 && expP->X_add_number == 0);
3555 symp = expP->X_add_symbol;
3557 if (symp == symbolP)
3561 loop = concat (S_GET_NAME (symbolP),
3562 " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3565 while (symp != symbolP)
3567 char *old_loop = loop;
3568 symp = symbol_get_value_expression (symp)->X_add_symbol;
3569 loop = concat (loop, " => ", S_GET_NAME (symp),
3570 (const char *) NULL);
3574 as_bad (_("%s: would close weakref loop: %s"),
3575 S_GET_NAME (symbolP), loop);
3580 ignore_rest_of_line ();
3584 /* Short-circuiting instead of just checking here might speed
3585 things up a tiny little bit, but loop error messages would
3586 miss intermediate links. */
3587 /* symbolP2 = symp; */
3592 memset (&exp, 0, sizeof (exp));
3593 exp.X_op = O_symbol;
3594 exp.X_add_symbol = symbolP2;
3596 S_SET_SEGMENT (symbolP, undefined_section);
3597 symbol_set_value_expression (symbolP, &exp);
3598 symbol_set_frag (symbolP, &zero_address_frag);
3599 S_SET_WEAKREFR (symbolP);
3601 demand_empty_rest_of_line ();
3605 /* Verify that we are at the end of a line. If not, issue an error and
3609 demand_empty_rest_of_line (void)
3612 if (is_end_of_line[(unsigned char) *input_line_pointer])
3613 input_line_pointer++;
3616 if (ISPRINT (*input_line_pointer))
3617 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3618 *input_line_pointer);
3620 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3621 *input_line_pointer);
3622 ignore_rest_of_line ();
3625 /* Return pointing just after end-of-line. */
3626 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3629 /* Silently advance to the end of line. Use this after already having
3630 issued an error about something bad. */
3633 ignore_rest_of_line (void)
3635 while (input_line_pointer < buffer_limit
3636 && !is_end_of_line[(unsigned char) *input_line_pointer])
3637 input_line_pointer++;
3639 input_line_pointer++;
3641 /* Return pointing just after end-of-line. */
3642 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3645 /* Sets frag for given symbol to zero_address_frag, except when the
3646 symbol frag is already set to a dummy listing frag. */
3649 set_zero_frag (symbolS *symbolP)
3651 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3652 symbol_set_frag (symbolP, &zero_address_frag);
3655 /* In: Pointer to a symbol.
3656 Input_line_pointer->expression.
3658 Out: Input_line_pointer->just after any whitespace after expression.
3659 Tried to set symbol to value of expression.
3660 Will change symbols type, value, and frag; */
3663 pseudo_set (symbolS *symbolP)
3668 know (symbolP); /* NULL pointer is logic error. */
3670 if (!S_IS_FORWARD_REF (symbolP))
3671 (void) expression (&exp);
3673 (void) deferred_expression (&exp);
3675 if (exp.X_op == O_illegal)
3676 as_bad (_("illegal expression"));
3677 else if (exp.X_op == O_absent)
3678 as_bad (_("missing expression"));
3679 else if (exp.X_op == O_big)
3681 if (exp.X_add_number > 0)
3682 as_bad (_("bignum invalid"));
3684 as_bad (_("floating point number invalid"));
3686 else if (exp.X_op == O_subtract
3687 && !S_IS_FORWARD_REF (symbolP)
3688 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3689 && (symbol_get_frag (exp.X_add_symbol)
3690 == symbol_get_frag (exp.X_op_symbol)))
3692 exp.X_op = O_constant;
3693 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3694 - S_GET_VALUE (exp.X_op_symbol));
3697 if (symbol_section_p (symbolP))
3699 as_bad ("attempt to set value of section symbol");
3708 exp.X_add_number = 0;
3711 S_SET_SEGMENT (symbolP, absolute_section);
3712 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3713 set_zero_frag (symbolP);
3717 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3718 if (S_IS_EXTERNAL (symbolP))
3720 as_bad ("can't equate global symbol `%s' with register name",
3721 S_GET_NAME (symbolP));
3725 S_SET_SEGMENT (symbolP, reg_section);
3726 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3727 set_zero_frag (symbolP);
3728 symbol_get_value_expression (symbolP)->X_op = O_register;
3732 seg = S_GET_SEGMENT (exp.X_add_symbol);
3733 /* For x=undef+const, create an expression symbol.
3734 For x=x+const, just update x except when x is an undefined symbol
3735 For x=defined+const, evaluate x. */
3736 if (symbolP == exp.X_add_symbol
3737 && (seg != undefined_section
3738 || !symbol_constant_p (symbolP)))
3740 *symbol_X_add_number (symbolP) += exp.X_add_number;
3743 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3745 symbolS *s = exp.X_add_symbol;
3747 if (S_IS_COMMON (s))
3748 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3749 S_GET_NAME (symbolP), S_GET_NAME (s));
3751 S_SET_SEGMENT (symbolP, seg);
3752 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3753 symbol_set_frag (symbolP, symbol_get_frag (s));
3754 copy_symbol_attributes (symbolP, s);
3757 S_SET_SEGMENT (symbolP, undefined_section);
3758 symbol_set_value_expression (symbolP, &exp);
3759 copy_symbol_attributes (symbolP, exp.X_add_symbol);
3760 set_zero_frag (symbolP);
3764 /* The value is some complex expression. */
3765 S_SET_SEGMENT (symbolP, expr_section);
3766 symbol_set_value_expression (symbolP, &exp);
3767 set_zero_frag (symbolP);
3774 CONStruct more frag of .bytes, or .words etc.
3775 Should need_pass_2 be 1 then emit no frag(s).
3776 This understands EXPRESSIONS.
3780 This has a split personality. We use expression() to read the
3781 value. We can detect if the value won't fit in a byte or word.
3782 But we can't detect if expression() discarded significant digits
3783 in the case of a long. Not worth the crocks required to fix it. */
3785 /* Select a parser for cons expressions. */
3787 /* Some targets need to parse the expression in various fancy ways.
3788 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3789 (for example, the HPPA does this). Otherwise, you can define
3790 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3791 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3792 are defined, which is the normal case, then only simple expressions
3797 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3800 #ifndef TC_PARSE_CONS_EXPRESSION
3801 #ifdef BITFIELD_CONS_EXPRESSIONS
3802 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3804 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3806 #ifdef REPEAT_CONS_EXPRESSIONS
3807 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3809 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3812 /* If we haven't gotten one yet, just call expression. */
3813 #ifndef TC_PARSE_CONS_EXPRESSION
3814 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3819 do_parse_cons_expression (expressionS *exp,
3820 int nbytes ATTRIBUTE_UNUSED)
3822 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3826 /* Worker to do .byte etc statements.
3827 Clobbers input_line_pointer and checks end-of-line. */
3830 cons_worker (int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3838 #ifdef md_flush_pending_output
3839 md_flush_pending_output ();
3843 stop = mri_comment_field (&stopc);
3845 if (is_it_end_of_statement ())
3847 demand_empty_rest_of_line ();
3849 mri_comment_end (stop, stopc);
3853 #ifdef TC_ADDRESS_BYTES
3855 nbytes = TC_ADDRESS_BYTES ();
3858 #ifdef md_cons_align
3859 md_cons_align (nbytes);
3867 parse_mri_cons (&exp, (unsigned int) nbytes);
3871 if (*input_line_pointer == '"')
3873 as_bad (_("unexpected `\"' in expression"));
3874 ignore_rest_of_line ();
3877 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3882 if (exp.X_op == O_symbol)
3883 exp.X_op = O_symbol_rva;
3885 as_fatal (_("rva without symbol"));
3887 emit_expr (&exp, (unsigned int) nbytes);
3890 while (*input_line_pointer++ == ',');
3892 /* In MRI mode, after an odd number of bytes, we must align to an
3893 even word boundary, unless the next instruction is a dc.b, ds.b
3895 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3896 mri_pending_align = 1;
3898 input_line_pointer--; /* Put terminator back into stream. */
3900 demand_empty_rest_of_line ();
3903 mri_comment_end (stop, stopc);
3909 cons_worker (size, 0);
3915 cons_worker (size, 1);
3918 /* .reloc offset, reloc_name, symbol+addend. */
3921 s_reloc (int ignore ATTRIBUTE_UNUSED)
3928 struct reloc_list *reloc;
3930 reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
3933 stop = mri_comment_field (&stopc);
3942 as_bad (_("missing or bad offset expression"));
3945 exp.X_add_symbol = section_symbol (now_seg);
3946 exp.X_op = O_symbol;
3949 if (exp.X_add_number == 0)
3951 reloc->u.a.offset_sym = exp.X_add_symbol;
3956 reloc->u.a.offset_sym = make_expr_symbol (&exp);
3961 if (*input_line_pointer != ',')
3963 as_bad (_("missing reloc type"));
3967 ++input_line_pointer;
3969 r_name = input_line_pointer;
3970 c = get_symbol_end ();
3971 reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3972 *input_line_pointer = c;
3973 if (reloc->u.a.howto == NULL)
3975 as_bad (_("unrecognized reloc type"));
3979 exp.X_op = O_absent;
3981 if (*input_line_pointer == ',')
3983 ++input_line_pointer;
3991 as_bad (_("bad reloc expression"));
3993 ignore_rest_of_line ();
3996 mri_comment_end (stop, stopc);
3999 reloc->u.a.sym = NULL;
4000 reloc->u.a.addend = 0;
4003 reloc->u.a.sym = NULL;
4004 reloc->u.a.addend = exp.X_add_number;
4007 reloc->u.a.sym = exp.X_add_symbol;
4008 reloc->u.a.addend = exp.X_add_number;
4011 reloc->u.a.sym = make_expr_symbol (&exp);
4012 reloc->u.a.addend = 0;
4016 as_where (&reloc->file, &reloc->line);
4017 reloc->next = reloc_list;
4020 demand_empty_rest_of_line ();
4022 mri_comment_end (stop, stopc);
4025 /* Put the contents of expression EXP into the object file using
4026 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4029 emit_expr (expressionS *exp, unsigned int nbytes)
4033 valueT extra_digit = 0;
4035 /* Don't do anything if we are going to make another pass. */
4039 /* Grow the current frag now so that dot_value does not get invalidated
4040 if the frag were to fill up in the frag_more() call below. */
4042 dot_value = frag_now_fix ();
4046 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4047 appear as a four byte positive constant in the .line section,
4048 followed by a 2 byte 0xffff. Look for that case here. */
4050 static int dwarf_line = -1;
4052 if (strcmp (segment_name (now_seg), ".line") != 0)
4054 else if (dwarf_line >= 0
4056 && exp->X_op == O_constant
4057 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4058 listing_source_line ((unsigned int) dwarf_line);
4059 else if (nbytes == 4
4060 && exp->X_op == O_constant
4061 && exp->X_add_number >= 0)
4062 dwarf_line = exp->X_add_number;
4067 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4068 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4069 AT_sibling (0x12) followed by a four byte address of the sibling
4070 followed by a 2 byte AT_name (0x38) followed by the name of the
4071 file. We look for that case here. */
4073 static int dwarf_file = 0;
4075 if (strcmp (segment_name (now_seg), ".debug") != 0)
4077 else if (dwarf_file == 0
4079 && exp->X_op == O_constant
4080 && exp->X_add_number == 0x11)
4082 else if (dwarf_file == 1
4084 && exp->X_op == O_constant
4085 && exp->X_add_number == 0x12)
4087 else if (dwarf_file == 2
4090 else if (dwarf_file == 3
4092 && exp->X_op == O_constant
4093 && exp->X_add_number == 0x38)
4098 /* The variable dwarf_file_string tells stringer that the string
4099 may be the name of the source file. */
4100 if (dwarf_file == 4)
4101 dwarf_file_string = 1;
4103 dwarf_file_string = 0;
4108 if (check_eh_frame (exp, &nbytes))
4113 /* Allow `.word 0' in the absolute section. */
4114 if (now_seg == absolute_section)
4116 if (op != O_constant || exp->X_add_number != 0)
4117 as_bad (_("attempt to store value in absolute section"));
4118 abs_section_offset += nbytes;
4122 /* Handle a negative bignum. */
4124 && exp->X_add_number == 0
4125 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4126 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4129 unsigned long carry;
4131 exp = symbol_get_value_expression (exp->X_add_symbol);
4133 /* Negate the bignum: one's complement each digit and add 1. */
4135 for (i = 0; i < exp->X_add_number; i++)
4139 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4142 generic_bignum[i] = next & LITTLENUM_MASK;
4143 carry = next >> LITTLENUM_NUMBER_OF_BITS;
4146 /* We can ignore any carry out, because it will be handled by
4147 extra_digit if it is needed. */
4149 extra_digit = (valueT) -1;
4153 if (op == O_absent || op == O_illegal)
4155 as_warn (_("zero assumed for missing expression"));
4156 exp->X_add_number = 0;
4159 else if (op == O_big && exp->X_add_number <= 0)
4161 as_bad (_("floating point number invalid"));
4162 exp->X_add_number = 0;
4165 else if (op == O_register)
4167 as_warn (_("register value used as expression"));
4171 p = frag_more ((int) nbytes);
4173 #ifndef WORKING_DOT_WORD
4174 /* If we have the difference of two symbols in a word, save it on
4175 the broken_words list. See the code in write.c. */
4176 if (op == O_subtract && nbytes == 2)
4178 struct broken_word *x;
4180 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4181 x->next_broken_word = broken_words;
4184 x->subseg = now_subseg;
4186 x->word_goes_here = p;
4188 x->add = exp->X_add_symbol;
4189 x->sub = exp->X_op_symbol;
4190 x->addnum = exp->X_add_number;
4198 /* If we have an integer, but the number of bytes is too large to
4199 pass to md_number_to_chars, handle it as a bignum. */
4200 if (op == O_constant && nbytes > sizeof (valueT))
4202 extra_digit = exp->X_unsigned ? 0 : -1;
4203 convert_to_bignum (exp);
4207 if (op == O_constant)
4215 /* JF << of >= number of bits in the object is undefined. In
4216 particular SPARC (Sun 4) has problems. */
4217 if (nbytes >= sizeof (valueT))
4220 if (nbytes > sizeof (valueT))
4223 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4227 /* Don't store these bits. */
4228 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4229 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4232 unmask = ~mask; /* Do store these bits. */
4235 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4236 mask = ~(unmask >> 1); /* Includes sign bit now. */
4239 get = exp->X_add_number;
4241 if ((get & mask) != 0
4242 && ((get & mask) != mask
4243 || (get & hibit) == 0))
4244 { /* Leading bits contain both 0s & 1s. */
4245 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4247 as_warn (_("value 0x%llx truncated to 0x%llx"),
4248 (unsigned long long) get, (unsigned long long) use);
4250 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4251 (unsigned long long) get, (unsigned long long) use);
4254 as_warn (_("value 0x%lx truncated to 0x%lx"),
4255 (unsigned long) get, (unsigned long) use);
4258 /* Put bytes in right order. */
4259 md_number_to_chars (p, use, (int) nbytes);
4261 else if (op == O_big)
4264 LITTLENUM_TYPE *nums;
4266 size = exp->X_add_number * CHARS_PER_LITTLENUM;
4269 int i = nbytes / CHARS_PER_LITTLENUM;
4272 LITTLENUM_TYPE sign = 0;
4273 if ((generic_bignum[--i]
4274 & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
4275 sign = ~(LITTLENUM_TYPE) 0;
4276 while (++i < exp->X_add_number)
4277 if (generic_bignum[i] != sign)
4280 if (i < exp->X_add_number)
4281 as_warn (_("bignum truncated to %d bytes"), nbytes);
4287 md_number_to_chars (p, (valueT) generic_bignum[0], 1);
4290 know (nbytes % CHARS_PER_LITTLENUM == 0);
4292 if (target_big_endian)
4294 while (nbytes > size)
4296 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4297 nbytes -= CHARS_PER_LITTLENUM;
4298 p += CHARS_PER_LITTLENUM;
4301 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4302 while (size >= CHARS_PER_LITTLENUM)
4305 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4306 size -= CHARS_PER_LITTLENUM;
4307 p += CHARS_PER_LITTLENUM;
4312 nums = generic_bignum;
4313 while (size >= CHARS_PER_LITTLENUM)
4315 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4317 size -= CHARS_PER_LITTLENUM;
4318 p += CHARS_PER_LITTLENUM;
4319 nbytes -= CHARS_PER_LITTLENUM;
4322 while (nbytes >= CHARS_PER_LITTLENUM)
4324 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4325 nbytes -= CHARS_PER_LITTLENUM;
4326 p += CHARS_PER_LITTLENUM;
4331 emit_expr_fix (exp, nbytes, frag_now, p);
4335 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4337 memset (p, 0, nbytes);
4339 /* Generate a fixS to record the symbol value. */
4341 #ifdef TC_CONS_FIX_NEW
4342 TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4345 bfd_reloc_code_real_type r;
4365 as_bad (_("unsupported BFD relocation size %u"), nbytes);
4369 fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4375 #ifdef BITFIELD_CONS_EXPRESSIONS
4377 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4378 w:x,y:z, where w and y are bitwidths and x and y are values. They
4379 then pack them all together. We do a little better in that we allow
4380 them in words, longs, etc. and we'll pack them in target byte order
4383 The rules are: pack least significant bit first, if a field doesn't
4384 entirely fit, put it in the next unit. Overflowing the bitfield is
4385 explicitly *not* even a warning. The bitwidth should be considered
4388 To use this function the tc-XXX.h file should define
4389 BITFIELD_CONS_EXPRESSIONS. */
4392 parse_bitfield_cons (exp, nbytes)
4394 unsigned int nbytes;
4396 unsigned int bits_available = BITS_PER_CHAR * nbytes;
4397 char *hold = input_line_pointer;
4399 (void) expression (exp);
4401 if (*input_line_pointer == ':')
4408 unsigned long width;
4410 if (*input_line_pointer != ':')
4412 input_line_pointer = hold;
4414 } /* Next piece is not a bitfield. */
4416 /* In the general case, we can't allow
4417 full expressions with symbol
4418 differences and such. The relocation
4419 entries for symbols not defined in this
4420 assembly would require arbitrary field
4421 widths, positions, and masks which most
4422 of our current object formats don't
4425 In the specific case where a symbol
4426 *is* defined in this assembly, we
4427 *could* build fixups and track it, but
4428 this could lead to confusion for the
4429 backends. I'm lazy. I'll take any
4430 SEG_ABSOLUTE. I think that means that
4431 you can use a previous .set or
4432 .equ type symbol. xoxorich. */
4434 if (exp->X_op == O_absent)
4436 as_warn (_("using a bit field width of zero"));
4437 exp->X_add_number = 0;
4438 exp->X_op = O_constant;
4439 } /* Implied zero width bitfield. */
4441 if (exp->X_op != O_constant)
4443 *input_line_pointer = '\0';
4444 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4445 *input_line_pointer = ':';
4446 demand_empty_rest_of_line ();
4448 } /* Too complex. */
4450 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4452 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4453 width, nbytes, (BITS_PER_CHAR * nbytes));
4454 width = BITS_PER_CHAR * nbytes;
4457 if (width > bits_available)
4459 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4460 input_line_pointer = hold;
4461 exp->X_add_number = value;
4466 hold = ++input_line_pointer;
4468 (void) expression (exp);
4469 if (exp->X_op != O_constant)
4471 char cache = *input_line_pointer;
4473 *input_line_pointer = '\0';
4474 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4475 *input_line_pointer = cache;
4476 demand_empty_rest_of_line ();
4478 } /* Too complex. */
4480 value |= ((~(-1 << width) & exp->X_add_number)
4481 << ((BITS_PER_CHAR * nbytes) - bits_available));
4483 if ((bits_available -= width) == 0
4484 || is_it_end_of_statement ()
4485 || *input_line_pointer != ',')
4488 } /* All the bitfields we're gonna get. */
4490 hold = ++input_line_pointer;
4491 (void) expression (exp);
4494 exp->X_add_number = value;
4495 exp->X_op = O_constant;
4496 exp->X_unsigned = 1;
4500 #endif /* BITFIELD_CONS_EXPRESSIONS */
4502 /* Handle an MRI style string expression. */
4506 parse_mri_cons (exp, nbytes)
4508 unsigned int nbytes;
4510 if (*input_line_pointer != '\''
4511 && (input_line_pointer[1] != '\''
4512 || (*input_line_pointer != 'A'
4513 && *input_line_pointer != 'E')))
4514 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4518 unsigned int result = 0;
4520 /* An MRI style string. Cut into as many bytes as will fit into
4521 a nbyte chunk, left justify if necessary, and separate with
4522 commas so we can try again later. */
4523 if (*input_line_pointer == 'A')
4524 ++input_line_pointer;
4525 else if (*input_line_pointer == 'E')
4527 as_bad (_("EBCDIC constants are not supported"));
4528 ++input_line_pointer;
4531 input_line_pointer++;
4532 for (scan = 0; scan < nbytes; scan++)
4534 if (*input_line_pointer == '\'')
4536 if (input_line_pointer[1] == '\'')
4538 input_line_pointer++;
4543 result = (result << 8) | (*input_line_pointer++);
4547 while (scan < nbytes)
4553 /* Create correct expression. */
4554 exp->X_op = O_constant;
4555 exp->X_add_number = result;
4557 /* Fake it so that we can read the next char too. */
4558 if (input_line_pointer[0] != '\'' ||
4559 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4561 input_line_pointer -= 2;
4562 input_line_pointer[0] = ',';
4563 input_line_pointer[1] = '\'';
4566 input_line_pointer++;
4569 #endif /* TC_M68K */
4571 #ifdef REPEAT_CONS_EXPRESSIONS
4573 /* Parse a repeat expression for cons. This is used by the MIPS
4574 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4575 object file COUNT times.
4577 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4580 parse_repeat_cons (exp, nbytes)
4582 unsigned int nbytes;
4589 if (*input_line_pointer != ':')
4591 /* No repeat count. */
4595 ++input_line_pointer;
4596 expression (&count);
4597 if (count.X_op != O_constant
4598 || count.X_add_number <= 0)
4600 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4604 /* The cons function is going to output this expression once. So we
4605 output it count - 1 times. */
4606 for (i = count.X_add_number - 1; i > 0; i--)
4607 emit_expr (exp, nbytes);
4610 #endif /* REPEAT_CONS_EXPRESSIONS */
4612 /* Parse a floating point number represented as a hex constant. This
4613 permits users to specify the exact bits they want in the floating
4617 hex_float (int float_type, char *bytes)
4649 as_bad (_("unknown floating type type '%c'"), float_type);
4653 /* It would be nice if we could go through expression to parse the
4654 hex constant, but if we get a bignum it's a pain to sort it into
4655 the buffer correctly. */
4657 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4661 /* The MRI assembler accepts arbitrary underscores strewn about
4662 through the hex constant, so we ignore them as well. */
4663 if (*input_line_pointer == '_')
4665 ++input_line_pointer;
4671 as_warn (_("floating point constant too large"));
4674 d = hex_value (*input_line_pointer) << 4;
4675 ++input_line_pointer;
4676 while (*input_line_pointer == '_')
4677 ++input_line_pointer;
4678 if (hex_p (*input_line_pointer))
4680 d += hex_value (*input_line_pointer);
4681 ++input_line_pointer;
4683 if (target_big_endian)
4686 bytes[length - i - 1] = d;
4692 if (target_big_endian)
4693 memset (bytes + i, 0, length - i);
4695 memset (bytes, 0, length - i);
4703 CONStruct some more frag chars of .floats .ffloats etc.
4704 Makes 0 or more new frags.
4705 If need_pass_2 == 1, no frags are emitted.
4706 This understands only floating literals, not expressions. Sorry.
4708 A floating constant is defined by atof_generic(), except it is preceded
4709 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4710 reading, I decided to be incompatible. This always tries to give you
4711 rounded bits to the precision of the pseudo-op. Former AS did premature
4712 truncation, restored noisy bits instead of trailing 0s AND gave you
4713 a choice of 2 flavours of noise according to which of 2 floating-point
4714 scanners you directed AS to use.
4716 In: input_line_pointer->whitespace before, or '0' of flonum. */
4719 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4720 int float_type /* 'f':.ffloat ... 'F':.float ... */)
4723 int length; /* Number of chars in an object. */
4724 char *err; /* Error from scanning floating literal. */
4725 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4727 if (is_it_end_of_statement ())
4729 demand_empty_rest_of_line ();
4733 #ifdef md_flush_pending_output
4734 md_flush_pending_output ();
4737 #ifdef md_cons_align
4743 /* input_line_pointer->1st char of a flonum (we hope!). */
4746 /* Skip any 0{letter} that may be present. Don't even check if the
4747 letter is legal. Someone may invent a "z" format and this routine
4748 has no use for such information. Lusers beware: you get
4749 diagnostics if your input is ill-conditioned. */
4750 if (input_line_pointer[0] == '0'
4751 && ISALPHA (input_line_pointer[1]))
4752 input_line_pointer += 2;
4754 /* Accept :xxxx, where the x's are hex digits, for a floating
4755 point with the exact digits specified. */
4756 if (input_line_pointer[0] == ':')
4758 ++input_line_pointer;
4759 length = hex_float (float_type, temp);
4762 ignore_rest_of_line ();
4768 err = md_atof (float_type, temp, &length);
4769 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4770 know (err != NULL || length > 0);
4773 as_bad (_("bad floating literal: %s"), err);
4774 ignore_rest_of_line ();
4785 #ifdef REPEAT_CONS_EXPRESSIONS
4786 if (*input_line_pointer == ':')
4788 expressionS count_exp;
4790 ++input_line_pointer;
4791 expression (&count_exp);
4793 if (count_exp.X_op != O_constant
4794 || count_exp.X_add_number <= 0)
4795 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4797 count = count_exp.X_add_number;
4801 while (--count >= 0)
4803 p = frag_more (length);
4804 memcpy (p, temp, (unsigned int) length);
4809 while (*input_line_pointer++ == ',');
4811 /* Put terminator back into stream. */
4812 --input_line_pointer;
4813 demand_empty_rest_of_line ();
4816 /* Return the size of a LEB128 value. */
4819 sizeof_sleb128 (offsetT value)
4826 byte = (value & 0x7f);
4827 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4828 Fortunately, we can structure things so that the extra work reduces
4829 to a noop on systems that do things "properly". */
4830 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4833 while (!(((value == 0) && ((byte & 0x40) == 0))
4834 || ((value == -1) && ((byte & 0x40) != 0))));
4840 sizeof_uleb128 (valueT value)
4855 sizeof_leb128 (valueT value, int sign)
4858 return sizeof_sleb128 ((offsetT) value);
4860 return sizeof_uleb128 (value);
4863 /* Output a LEB128 value. */
4866 output_sleb128 (char *p, offsetT value)
4873 unsigned byte = (value & 0x7f);
4875 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4876 Fortunately, we can structure things so that the extra work reduces
4877 to a noop on systems that do things "properly". */
4878 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4880 more = !((((value == 0) && ((byte & 0x40) == 0))
4881 || ((value == -1) && ((byte & 0x40) != 0))));
4893 output_uleb128 (char *p, valueT value)
4899 unsigned byte = (value & 0x7f);
4902 /* More bytes to follow. */
4913 output_leb128 (char *p, valueT value, int sign)
4916 return output_sleb128 (p, (offsetT) value);
4918 return output_uleb128 (p, value);
4921 /* Do the same for bignums. We combine sizeof with output here in that
4922 we don't output for NULL values of P. It isn't really as critical as
4923 for "normal" values that this be streamlined. */
4926 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4933 /* Strip leading sign extensions off the bignum. */
4935 && bignum[size - 1] == LITTLENUM_MASK
4936 && bignum[size - 2] > LITTLENUM_MASK / 2)
4941 /* OR in the next part of the littlenum. */
4942 val |= (*bignum << loaded);
4943 loaded += LITTLENUM_NUMBER_OF_BITS;
4947 /* Add bytes until there are less than 7 bits left in VAL
4948 or until every non-sign bit has been written. */
4955 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4962 while ((byte & 0x80) != 0 && loaded >= 7);
4966 /* Mop up any left-over bits (of which there will be less than 7). */
4967 if ((byte & 0x80) != 0)
4969 /* Sign-extend VAL. */
4970 if (val & (1 << (loaded - 1)))
4971 val |= ~0 << loaded;
4981 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4988 /* Strip leading zeros off the bignum. */
4989 /* XXX: Is this needed? */
4990 while (size > 0 && bignum[size - 1] == 0)
4995 if (loaded < 7 && size > 0)
4997 val |= (*bignum << loaded);
4998 loaded += 8 * CHARS_PER_LITTLENUM;
5007 if (size > 0 || val)
5014 while (byte & 0x80);
5020 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
5023 return output_big_sleb128 (p, bignum, size);
5025 return output_big_uleb128 (p, bignum, size);
5028 /* Generate the appropriate fragments for a given expression to emit a
5032 emit_leb128_expr (expressionS *exp, int sign)
5034 operatorT op = exp->X_op;
5035 unsigned int nbytes;
5037 if (op == O_absent || op == O_illegal)
5039 as_warn (_("zero assumed for missing expression"));
5040 exp->X_add_number = 0;
5043 else if (op == O_big && exp->X_add_number <= 0)
5045 as_bad (_("floating point number invalid"));
5046 exp->X_add_number = 0;
5049 else if (op == O_register)
5051 as_warn (_("register value used as expression"));
5054 else if (op == O_constant
5056 && (exp->X_add_number < 0) != !exp->X_unsigned)
5058 /* We're outputting a signed leb128 and the sign of X_add_number
5059 doesn't reflect the sign of the original value. Convert EXP
5060 to a correctly-extended bignum instead. */
5061 convert_to_bignum (exp);
5065 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5066 a signal that this is leb128 data. It shouldn't optimize this away. */
5067 nbytes = (unsigned int) -1;
5068 if (check_eh_frame (exp, &nbytes))
5071 /* Let the backend know that subsequent data may be byte aligned. */
5072 #ifdef md_cons_align
5076 if (op == O_constant)
5078 /* If we've got a constant, emit the thing directly right now. */
5080 valueT value = exp->X_add_number;
5084 size = sizeof_leb128 (value, sign);
5085 p = frag_more (size);
5086 output_leb128 (p, value, sign);
5088 else if (op == O_big)
5090 /* O_big is a different sort of constant. */
5095 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5096 p = frag_more (size);
5097 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5101 /* Otherwise, we have to create a variable sized fragment and
5102 resolve things later. */
5104 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5105 make_expr_symbol (exp), 0, (char *) NULL);
5109 /* Parse the .sleb128 and .uleb128 pseudos. */
5116 #ifdef md_flush_pending_output
5117 md_flush_pending_output ();
5123 emit_leb128_expr (&exp, sign);
5125 while (*input_line_pointer++ == ',');
5127 input_line_pointer--;
5128 demand_empty_rest_of_line ();
5132 stringer_append_char (int c, int bitsize)
5134 if (!target_big_endian)
5135 FRAG_APPEND_1_CHAR (c);
5140 FRAG_APPEND_1_CHAR (0);
5141 FRAG_APPEND_1_CHAR (0);
5142 FRAG_APPEND_1_CHAR (0);
5143 FRAG_APPEND_1_CHAR (0);
5146 FRAG_APPEND_1_CHAR (0);
5147 FRAG_APPEND_1_CHAR (0);
5150 FRAG_APPEND_1_CHAR (0);
5155 /* Called with invalid bitsize argument. */
5159 if (target_big_endian)
5160 FRAG_APPEND_1_CHAR (c);
5163 /* Worker to do .ascii etc statements.
5164 Reads 0 or more ',' separated, double-quoted strings.
5165 Caller should have checked need_pass_2 is FALSE because we don't
5167 Checks for end-of-line.
5168 BITS_APPENDZERO says how many bits are in a target char.
5169 The bottom bit is set if a NUL char should be appended to the strings. */
5172 stringer (int bits_appendzero)
5174 const int bitsize = bits_appendzero & ~7;
5175 const int append_zero = bits_appendzero & 1;
5177 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5181 #ifdef md_flush_pending_output
5182 md_flush_pending_output ();
5185 #ifdef md_cons_align
5189 /* The following awkward logic is to parse ZERO or more strings,
5190 comma separated. Recall a string expression includes spaces
5191 before the opening '\"' and spaces after the closing '\"'.
5192 We fake a leading ',' if there is (supposed to be)
5193 a 1st, expression. We keep demanding expressions for each ','. */
5194 if (is_it_end_of_statement ())
5196 c = 0; /* Skip loop. */
5197 ++input_line_pointer; /* Compensate for end of loop. */
5201 c = ','; /* Do loop. */
5203 /* If we have been switched into the abs_section then we
5204 will not have an obstack onto which we can hang strings. */
5205 if (now_seg == absolute_section)
5207 as_bad (_("strings must be placed into a section"));
5209 ignore_rest_of_line ();
5212 while (c == ',' || c == '<' || c == '"')
5215 switch (*input_line_pointer)
5218 ++input_line_pointer; /*->1st char of string. */
5219 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5220 start = input_line_pointer;
5223 while (is_a_char (c = next_char_of_string ()))
5224 stringer_append_char (c, bitsize);
5227 stringer_append_char (0, bitsize);
5229 know (input_line_pointer[-1] == '\"');
5231 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5232 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5233 will emit .string with a filename in the .debug section
5234 after a sequence of constants. See the comment in
5235 emit_expr for the sequence. emit_expr will set
5236 dwarf_file_string to non-zero if this string might be a
5237 source file name. */
5238 if (strcmp (segment_name (now_seg), ".debug") != 0)
5239 dwarf_file_string = 0;
5240 else if (dwarf_file_string)
5242 c = input_line_pointer[-1];
5243 input_line_pointer[-1] = '\0';
5244 listing_source_file (start);
5245 input_line_pointer[-1] = c;
5251 input_line_pointer++;
5252 c = get_single_number ();
5253 stringer_append_char (c, bitsize);
5254 if (*input_line_pointer != '>')
5255 as_bad (_("expected <nn>"));
5257 input_line_pointer++;
5260 input_line_pointer++;
5264 c = *input_line_pointer;
5267 demand_empty_rest_of_line ();
5270 /* FIXME-SOMEDAY: I had trouble here on characters with the
5271 high bits set. We'll probably also have trouble with
5272 multibyte chars, wide chars, etc. Also be careful about
5273 returning values bigger than 1 byte. xoxorich. */
5276 next_char_of_string (void)
5280 c = *input_line_pointer++ & CHAR_MASK;
5288 as_warn (_("unterminated string; newline inserted"));
5289 bump_line_counters ();
5292 #ifndef NO_STRING_ESCAPES
5294 switch (c = *input_line_pointer++)
5322 break; /* As itself. */
5338 for (i = 0, number = 0;
5339 ISDIGIT (c) && i < 3;
5340 c = *input_line_pointer++, i++)
5342 number = number * 8 + c - '0';
5347 --input_line_pointer;
5356 c = *input_line_pointer++;
5357 while (ISXDIGIT (c))
5360 number = number * 16 + c - '0';
5361 else if (ISUPPER (c))
5362 number = number * 16 + c - 'A' + 10;
5364 number = number * 16 + c - 'a' + 10;
5365 c = *input_line_pointer++;
5368 --input_line_pointer;
5373 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5374 as_warn (_("unterminated string; newline inserted"));
5376 bump_line_counters ();
5381 #ifdef ONLY_STANDARD_ESCAPES
5382 as_bad (_("bad escaped character in string"));
5384 #endif /* ONLY_STANDARD_ESCAPES */
5389 #endif /* ! defined (NO_STRING_ESCAPES) */
5398 get_segmented_expression (expressionS *expP)
5402 retval = expression (expP);
5403 if (expP->X_op == O_illegal
5404 || expP->X_op == O_absent
5405 || expP->X_op == O_big)
5407 as_bad (_("expected address expression"));
5408 expP->X_op = O_constant;
5409 expP->X_add_number = 0;
5410 retval = absolute_section;
5416 get_known_segmented_expression (expressionS *expP)
5418 segT retval = get_segmented_expression (expP);
5420 if (retval == undefined_section)
5422 /* There is no easy way to extract the undefined symbol from the
5424 if (expP->X_add_symbol != NULL
5425 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5426 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5427 S_GET_NAME (expP->X_add_symbol));
5429 as_warn (_("some symbol undefined; zero assumed"));
5430 retval = absolute_section;
5431 expP->X_op = O_constant;
5432 expP->X_add_number = 0;
5437 char /* Return terminator. */
5438 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
5440 /* FIXME: val_pointer should probably be offsetT *. */
5441 *val_pointer = (long) get_absolute_expression ();
5442 return (*input_line_pointer++);
5445 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5446 Give a warning if that happens. */
5449 demand_copy_C_string (int *len_pointer)
5453 if ((s = demand_copy_string (len_pointer)) != 0)
5457 for (len = *len_pointer; len > 0; len--)
5464 as_bad (_("this string may not contain \'\\0\'"));
5472 /* Demand string, but return a safe (=private) copy of the string.
5473 Return NULL if we can't read a string here. */
5476 demand_copy_string (int *lenP)
5484 if (*input_line_pointer == '\"')
5486 input_line_pointer++; /* Skip opening quote. */
5488 while (is_a_char (c = next_char_of_string ()))
5490 obstack_1grow (¬es, c);
5493 /* JF this next line is so demand_copy_C_string will return a
5494 null terminated string. */
5495 obstack_1grow (¬es, '\0');
5496 retval = (char *) obstack_finish (¬es);
5500 as_bad (_("missing string"));
5502 ignore_rest_of_line ();
5508 /* In: Input_line_pointer->next character.
5510 Do: Skip input_line_pointer over all whitespace.
5512 Out: 1 if input_line_pointer->end-of-line. */
5515 is_it_end_of_statement (void)
5518 return (is_end_of_line[(unsigned char) *input_line_pointer]);
5522 equals (char *sym_name, int reassign)
5527 input_line_pointer++;
5528 if (*input_line_pointer == '=')
5529 input_line_pointer++;
5530 if (reassign < 0 && *input_line_pointer == '=')
5531 input_line_pointer++;
5533 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5534 input_line_pointer++;
5537 stop = mri_comment_field (&stopc);
5539 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5543 demand_empty_rest_of_line ();
5544 mri_comment_end (stop, stopc);
5548 /* .incbin -- include a file verbatim at the current location. */
5551 s_incbin (int x ATTRIBUTE_UNUSED)
5562 #ifdef md_flush_pending_output
5563 md_flush_pending_output ();
5566 #ifdef md_cons_align
5571 filename = demand_copy_string (& len);
5572 if (filename == NULL)
5577 /* Look for optional skip and count. */
5578 if (* input_line_pointer == ',')
5580 ++ input_line_pointer;
5581 skip = get_absolute_expression ();
5585 if (* input_line_pointer == ',')
5587 ++ input_line_pointer;
5589 count = get_absolute_expression ();
5591 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5597 demand_empty_rest_of_line ();
5599 /* Try opening absolute path first, then try include dirs. */
5600 binfile = fopen (filename, FOPEN_RB);
5601 if (binfile == NULL)
5605 path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5607 for (i = 0; i < include_dir_count; i++)
5609 sprintf (path, "%s/%s", include_dirs[i], filename);
5611 binfile = fopen (path, FOPEN_RB);
5612 if (binfile != NULL)
5616 if (binfile == NULL)
5617 as_bad (_("file not found: %s"), filename);
5620 path = xstrdup (filename);
5626 register_dependency (path);
5628 /* Compute the length of the file. */
5629 if (fseek (binfile, 0, SEEK_END) != 0)
5631 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5634 file_len = ftell (binfile);
5636 /* If a count was not specified use the remainder of the file. */
5638 count = file_len - skip;
5640 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5642 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5643 skip, count, file_len);
5647 if (fseek (binfile, skip, SEEK_SET) != 0)
5649 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5653 /* Allocate frag space and store file contents in it. */
5654 binfrag = frag_more (count);
5656 bytes = fread (binfrag, 1, count, binfile);
5658 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5659 path, bytes, count);
5662 if (binfile != NULL)
5668 /* .include -- include a file at this point. */
5671 s_include (int arg ATTRIBUTE_UNUSED)
5680 filename = demand_copy_string (&i);
5681 if (filename == NULL)
5683 /* demand_copy_string has already printed an error and
5684 called ignore_rest_of_line. */
5692 while (!is_end_of_line[(unsigned char) *input_line_pointer]
5693 && *input_line_pointer != ' '
5694 && *input_line_pointer != '\t')
5696 obstack_1grow (¬es, *input_line_pointer);
5697 ++input_line_pointer;
5701 obstack_1grow (¬es, '\0');
5702 filename = (char *) obstack_finish (¬es);
5703 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5704 ++input_line_pointer;
5707 demand_empty_rest_of_line ();
5708 path = (char *) xmalloc ((unsigned long) i
5709 + include_dir_maxlen + 5 /* slop */ );
5711 for (i = 0; i < include_dir_count; i++)
5713 strcpy (path, include_dirs[i]);
5715 strcat (path, filename);
5716 if (0 != (try_file = fopen (path, FOPEN_RT)))
5726 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5727 register_dependency (path);
5728 input_scrub_insert_file (path);
5732 add_include_dir (char *path)
5736 if (include_dir_count == 0)
5738 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5739 include_dirs[0] = "."; /* Current dir. */
5740 include_dir_count = 2;
5744 include_dir_count++;
5746 (char **) realloc (include_dirs,
5747 include_dir_count * sizeof (*include_dirs));
5750 include_dirs[include_dir_count - 1] = path; /* New one. */
5753 if (i > include_dir_maxlen)
5754 include_dir_maxlen = i;
5757 /* Output debugging information to denote the source file. */
5760 generate_file_debug (void)
5762 if (debug_type == DEBUG_STABS)
5763 stabs_generate_asm_file ();
5766 /* Output line number debugging information for the current source line. */
5769 generate_lineno_debug (void)
5773 case DEBUG_UNSPECIFIED:
5778 stabs_generate_asm_lineno ();
5781 ecoff_generate_asm_lineno ();
5784 /* ??? We could here indicate to dwarf2dbg.c that something
5785 has changed. However, since there is additional backend
5786 support that is required (calling dwarf2_emit_insn), we
5787 let dwarf2dbg.c call as_where on its own. */
5792 /* Output debugging information to mark a function entry point or end point.
5793 END_P is zero for .func, and non-zero for .endfunc. */
5798 do_s_func (end_p, NULL);
5801 /* Subroutine of s_func so targets can choose a different default prefix.
5802 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5805 do_s_func (int end_p, const char *default_prefix)
5807 /* Record the current function so that we can issue an error message for
5808 misplaced .func,.endfunc, and also so that .endfunc needs no
5810 static char *current_name;
5811 static char *current_label;
5815 if (current_name == NULL)
5817 as_bad (_("missing .func"));
5818 ignore_rest_of_line ();
5822 if (debug_type == DEBUG_STABS)
5823 stabs_generate_asm_endfunc (current_name, current_label);
5825 current_name = current_label = NULL;
5830 char delim1, delim2;
5832 if (current_name != NULL)
5834 as_bad (_(".endfunc missing for previous .func"));
5835 ignore_rest_of_line ();
5839 name = input_line_pointer;
5840 delim1 = get_symbol_end ();
5841 name = xstrdup (name);
5842 *input_line_pointer = delim1;
5844 if (*input_line_pointer != ',')
5848 if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5849 as_fatal ("%s", xstrerror (errno));
5853 char leading_char = bfd_get_symbol_leading_char (stdoutput);
5854 /* Missing entry point, use function's name with the leading
5858 if (asprintf (&label, "%c%s", leading_char, name) == -1)
5859 as_fatal ("%s", xstrerror (errno));
5867 ++input_line_pointer;
5869 label = input_line_pointer;
5870 delim2 = get_symbol_end ();
5871 label = xstrdup (label);
5872 *input_line_pointer = delim2;
5875 if (debug_type == DEBUG_STABS)
5876 stabs_generate_asm_func (name, label);
5878 current_name = name;
5879 current_label = label;
5882 demand_empty_rest_of_line ();
5886 s_ignore (int arg ATTRIBUTE_UNUSED)
5888 ignore_rest_of_line ();
5892 read_print_statistics (FILE *file)
5894 hash_print_statistics (file, "pseudo-op table", po_hash);
5897 /* Inserts the given line into the input stream.
5899 This call avoids macro/conditionals nesting checking, since the contents of
5900 the line are assumed to replace the contents of a line already scanned.
5902 An appropriate use of this function would be substitution of input lines when
5903 called by md_start_line_hook(). The given line is assumed to already be
5904 properly scrubbed. */
5907 input_scrub_insert_line (const char *line)
5911 sb_add_string (&newline, line);
5912 input_scrub_include_sb (&newline, input_line_pointer, 0);
5914 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5917 /* Insert a file into the input stream; the path must resolve to an actual
5918 file; no include path searching or dependency registering is performed. */
5921 input_scrub_insert_file (char *path)
5923 input_scrub_include_file (path, input_line_pointer);
5924 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5927 /* Find the end of a line, considering quotation and escaping of quotes. */
5929 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5930 # define TC_SINGLE_QUOTE_STRINGS 1
5934 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5937 char inquote = '\0';
5940 while (!is_end_of_line[(unsigned char) *s]
5941 || (inquote && !ISCNTRL (*s))
5942 || (inquote == '\'' && flag_mri)
5943 #ifdef TC_EOL_IN_INSN
5944 || (insn && TC_EOL_IN_INSN (s))
5946 /* PR 6926: When we are parsing the body of a macro the sequence
5947 \@ is special - it refers to the invocation count. If the @
5948 character happens to be registered as a line-separator character
5949 by the target, then the is_end_of_line[] test above will have
5950 returned true, but we need to ignore the line separating
5951 semantics in this particular case. */
5952 || (in_macro && inescape && *s == '@')
5955 if (mri_string && *s == '\'')
5959 else if (*s == '\\')
5963 #ifdef TC_SINGLE_QUOTE_STRINGS
5964 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5971 as_warn (_("missing closing `%c'"), inquote);
5973 as_warn (_("stray `\\'"));
5978 find_end_of_line (char *s, int mri_string)
5980 return _find_end_of_line (s, mri_string, 0, 0);