1 /* read.c - read a source file -
2 Copyright (C) 1986-2022 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer
; /*->next char of source file to parse. */
67 bool input_from_string
= false;
69 #if BITS_PER_CHAR != 8
70 /* The following table is indexed by[(char)] and will break if
71 a char does not have exactly 256 states (hopefully 0:255!)! */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The Delta 68k assembler permits ~ at start of label names. */
109 /* Used by is_... macros. our ctype[]. */
110 char lex_type
[256] = {
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
113 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
115 LEX_AT
, 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
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
117 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
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,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
130 Out: 1 if this character ends a line.
131 2 if this character is a line separator. */
132 char is_end_of_line
[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string
[128];
159 /* Functions private to this file. */
161 static char *buffer
; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit
; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
172 const char **include_dirs
;
174 /* How many are in the table. */
175 int include_dir_count
;
177 /* Length of longest in table. */
178 int include_dir_maxlen
= 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string
;
214 /* If the target defines the md_frag_max_var hook then we know
215 enough to implement the .bundle_align_mode features. */
216 #ifdef md_frag_max_var
217 # define HANDLE_BUNDLE
221 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
222 it's the exponent of the bundle size, and aligned instruction bundle
223 mode is in effect. */
224 static unsigned int bundle_align_p2
;
226 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
227 bundle_lock_frag to frag_now and then starts a new frag with
228 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
229 so that .bundle_unlock can verify that we didn't change segments.
230 .bundle_unlock resets both to NULL. If we detect a bundling violation,
231 then we reset bundle_lock_frchain to NULL as an indicator that we've
232 already diagnosed the error with as_bad and don't need a cascade of
233 redundant errors, but bundle_lock_frag remains set to indicate that
234 we are expecting to see .bundle_unlock. */
235 static fragS
*bundle_lock_frag
;
236 static frchainS
*bundle_lock_frchain
;
238 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
240 static unsigned int bundle_lock_depth
;
243 static void do_s_func (int end_p
, const char *default_prefix
);
244 static void s_align (int, int);
245 static void s_altmacro (int);
246 static void s_bad_end (int);
247 static void s_reloc (int);
248 static int hex_float (int, char *);
249 static segT
get_known_segmented_expression (expressionS
* expP
);
250 static void pobegin (void);
251 static size_t get_non_macro_line_sb (sb
*);
252 static void generate_file_debug (void);
253 static char *_find_end_of_line (char *, int, int, int);
261 obj_read_begin_hook ();
263 /* Something close -- but not too close -- to a multiple of 1024.
264 The debugging malloc I'm using has 24 bytes of overhead. */
265 obstack_begin (¬es
, chunksize
);
266 obstack_begin (&cond_obstack
, chunksize
);
268 #ifndef tc_line_separator_chars
269 #define tc_line_separator_chars line_separator_chars
271 /* Use machine dependent syntax. */
272 for (p
= tc_line_separator_chars
; *p
; p
++)
273 is_end_of_line
[(unsigned char) *p
] = 2;
274 /* Use more. FIXME-SOMEDAY. */
280 #ifndef TC_ADDRESS_BYTES
281 #define TC_ADDRESS_BYTES address_bytes
286 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
287 contain an address. */
288 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
296 /* Set up pseudo-op tables. */
300 const char *poc_name
;
302 const pseudo_typeS
*pop
;
305 typedef struct po_entry po_entry_t
;
307 /* Hash function for a po_entry. */
310 hash_po_entry (const void *e
)
312 const po_entry_t
*entry
= (const po_entry_t
*) e
;
313 return htab_hash_string (entry
->poc_name
);
316 /* Equality function for a po_entry. */
319 eq_po_entry (const void *a
, const void *b
)
321 const po_entry_t
*ea
= (const po_entry_t
*) a
;
322 const po_entry_t
*eb
= (const po_entry_t
*) b
;
324 return strcmp (ea
->poc_name
, eb
->poc_name
) == 0;
328 po_entry_alloc (const char *poc_name
, const pseudo_typeS
*pop
)
330 po_entry_t
*entry
= XNEW (po_entry_t
);
331 entry
->poc_name
= poc_name
;
336 static const pseudo_typeS
*
337 po_entry_find (htab_t table
, const char *poc_name
)
339 po_entry_t needle
= { poc_name
, NULL
};
340 po_entry_t
*entry
= htab_find (table
, &needle
);
341 return entry
!= NULL
? entry
->pop
: NULL
;
344 static struct htab
*po_hash
;
346 static const pseudo_typeS potable
[] = {
347 {"abort", s_abort
, 0},
348 {"align", s_align_ptwo
, 0},
349 {"altmacro", s_altmacro
, 1},
350 {"ascii", stringer
, 8+0},
351 {"asciz", stringer
, 8+1},
352 {"balign", s_align_bytes
, 0},
353 {"balignw", s_align_bytes
, -2},
354 {"balignl", s_align_bytes
, -4},
357 {"bundle_align_mode", s_bundle_align_mode
, 0},
358 {"bundle_lock", s_bundle_lock
, 0},
359 {"bundle_unlock", s_bundle_unlock
, 0},
363 {"common", s_mri_common
, 0},
364 {"common.s", s_mri_common
, 1},
369 {"dc.d", float_cons
, 'd'},
371 {"dc.s", float_cons
, 'f'},
373 {"dc.x", float_cons
, 'x'},
375 {"dcb.b", s_space
, 1},
376 {"dcb.d", s_float_space
, 'd'},
377 {"dcb.l", s_space
, 4},
378 {"dcb.s", s_float_space
, 'f'},
379 {"dcb.w", s_space
, 2},
380 {"dcb.x", s_float_space
, 'x'},
382 {"ds.b", s_space
, 1},
383 {"ds.d", s_space
, 8},
384 {"ds.l", s_space
, 4},
385 {"ds.p", s_space
, 'p'},
386 {"ds.s", s_space
, 4},
387 {"ds.w", s_space
, 2},
388 {"ds.x", s_space
, 'x'},
389 {"debug", s_ignore
, 0},
394 {"double", float_cons
, 'd'},
396 {"eject", listing_eject
, 0}, /* Formfeed listing. */
398 {"elsec", s_else
, 0},
399 {"elseif", s_elseif
, (int) O_ne
},
401 {"endc", s_endif
, 0},
402 {"endfunc", s_func
, 1},
403 {"endif", s_endif
, 0},
404 {"endm", s_bad_end
, 0},
405 {"endr", s_bad_end
, 1},
411 {"error", s_errwarn
, 1},
412 {"exitm", s_mexit
, 0},
414 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
418 {"float", float_cons
, 'f'},
419 {"format", s_ignore
, 0},
421 {"global", s_globl
, 0},
422 {"globl", s_globl
, 0},
424 {"if", s_if
, (int) O_ne
},
427 {"ifdef", s_ifdef
, 0},
428 {"ifeq", s_if
, (int) O_eq
},
429 {"ifeqs", s_ifeqs
, 0},
430 {"ifge", s_if
, (int) O_ge
},
431 {"ifgt", s_if
, (int) O_gt
},
432 {"ifle", s_if
, (int) O_le
},
433 {"iflt", s_if
, (int) O_lt
},
436 {"ifndef", s_ifdef
, 1},
437 {"ifne", s_if
, (int) O_ne
},
438 {"ifnes", s_ifeqs
, 1},
439 {"ifnotdef", s_ifdef
, 1},
440 {"incbin", s_incbin
, 0},
441 {"include", s_include
, 0},
447 {"lcomm", s_lcomm
, 0},
448 {"lflags", s_ignore
, 0}, /* Listing flags. */
449 {"linefile", s_linefile
, 0},
450 {"linkonce", s_linkonce
, 0},
451 {"list", listing_list
, 1}, /* Turn listing on. */
452 {"llen", listing_psize
, 1},
455 {"macro", s_macro
, 0},
456 {"mexit", s_mexit
, 0},
458 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
459 {"name", s_ignore
, 0},
460 {"noaltmacro", s_altmacro
, 0},
461 {"noformat", s_ignore
, 0},
462 {"nolist", listing_list
, 0}, /* Turn listing off. */
463 {"nopage", listing_nopage
, 0},
467 {"offset", s_struct
, 0},
469 {"p2align", s_align_ptwo
, 0},
470 {"p2alignw", s_align_ptwo
, -2},
471 {"p2alignl", s_align_ptwo
, -4},
472 {"page", listing_eject
, 0},
473 {"plen", listing_psize
, 0},
474 {"print", s_print
, 0},
475 {"psize", listing_psize
, 0}, /* Set paper size. */
476 {"purgem", s_purgem
, 0},
478 {"reloc", s_reloc
, 0},
482 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
487 {"single", float_cons
, 'f'},
489 {"space", s_space
, 0},
490 {"skip", s_space
, 0},
491 {"sleb128", s_leb128
, 1},
492 {"spc", s_ignore
, 0},
493 {"stabd", s_stab
, 'd'},
494 {"stabn", s_stab
, 'n'},
495 {"stabs", s_stab
, 's'},
496 {"string", stringer
, 8+1},
497 {"string8", stringer
, 8+1},
498 {"string16", stringer
, 16+1},
499 {"string32", stringer
, 32+1},
500 {"string64", stringer
, 64+1},
501 {"struct", s_struct
, 0},
505 /* This is for gcc to use. It's only just been added (2/94), so gcc
506 won't be able to use it for a while -- probably a year or more.
507 But once this has been released, check with gcc maintainers
508 before deleting it or even changing the spelling. */
509 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
510 /* If we're folding case -- done for some targets, not necessarily
511 all -- the above string in an input file will be converted to
512 this one. Match it either way... */
513 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
515 {"title", listing_title
, 0}, /* Listing title. */
516 {"ttl", listing_title
, 0},
518 {"uleb128", s_leb128
, 0},
522 {"xdef", s_globl
, 0},
523 {"xref", s_ignore
, 0},
524 {"xstabs", s_xstab
, 's'},
525 {"warning", s_errwarn
, 0},
526 {"weakref", s_weakref
, 0},
528 {"zero", s_space
, 0},
532 {NULL
, NULL
, 0} /* End sentinel. */
536 get_absolute_expr (expressionS
*exp
)
538 expression_and_evaluate (exp
);
540 if (exp
->X_op
!= O_constant
)
542 if (exp
->X_op
!= O_absent
)
543 as_bad (_("bad or irreducible absolute expression"));
544 exp
->X_add_number
= 0;
546 return exp
->X_add_number
;
550 get_absolute_expression (void)
554 return get_absolute_expr (&exp
);
557 static int pop_override_ok
= 0;
558 static const char *pop_table_name
;
561 pop_insert (const pseudo_typeS
*table
)
563 const pseudo_typeS
*pop
;
564 for (pop
= table
; pop
->poc_name
; pop
++)
566 po_entry_t
*elt
= po_entry_alloc (pop
->poc_name
, pop
);
567 if (htab_insert (po_hash
, elt
, 0) != NULL
)
570 if (!pop_override_ok
)
571 as_fatal (_("error constructing %s pseudo-op table"),
577 #ifndef md_pop_insert
578 #define md_pop_insert() pop_insert(md_pseudo_table)
581 #ifndef obj_pop_insert
582 #define obj_pop_insert() pop_insert(obj_pseudo_table)
585 #ifndef cfi_pop_insert
586 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
592 po_hash
= htab_create_alloc (16, hash_po_entry
, eq_po_entry
, NULL
,
595 /* Do the target-specific pseudo ops. */
596 pop_table_name
= "md";
599 /* Now object specific. Skip any that were in the target table. */
600 pop_table_name
= "obj";
604 /* Now portable ones. Skip any that we've seen already. */
605 pop_table_name
= "standard";
606 pop_insert (potable
);
609 pop_table_name
= "cfi";
614 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
615 if (ignore_input ()) \
617 char *eol = find_end_of_line (input_line_pointer - (num_read), \
619 input_line_pointer = (input_line_pointer <= buffer_limit \
620 && eol >= buffer_limit) \
626 /* This function is used when scrubbing the characters between #APP
629 static char *scrub_string
;
630 static char *scrub_string_end
;
633 scrub_from_string (char *buf
, size_t buflen
)
637 copy
= scrub_string_end
- scrub_string
;
640 memcpy (buf
, scrub_string
, copy
);
641 scrub_string
+= copy
;
645 /* Helper function of read_a_source_file, which tries to expand a macro. */
647 try_macro (char term
, const char *line
)
653 if (check_macro (line
, &out
, &err
, ¯o
))
657 *input_line_pointer
++ = term
;
658 input_scrub_include_sb (&out
,
659 input_line_pointer
, expanding_macro
);
662 input_scrub_next_buffer (&input_line_pointer
);
664 md_macro_info (macro
);
672 /* Start a new instruction bundle. Returns the rs_align_code frag that
673 will be used to align the new bundle. */
677 fragS
*frag
= frag_now
;
679 frag_align_code (0, 0);
681 while (frag
->fr_type
!= rs_align_code
)
682 frag
= frag
->fr_next
;
684 gas_assert (frag
!= frag_now
);
689 /* Calculate the maximum size after relaxation of the region starting
690 at the given frag and extending through frag_now (which is unfinished). */
692 pending_bundle_size (fragS
*frag
)
694 unsigned int offset
= frag
->fr_fix
;
695 unsigned int size
= 0;
697 gas_assert (frag
!= frag_now
);
698 gas_assert (frag
->fr_type
== rs_align_code
);
700 while (frag
!= frag_now
)
702 /* This should only happen in what will later become an error case. */
706 size
+= frag
->fr_fix
;
707 if (frag
->fr_type
== rs_machine_dependent
)
708 size
+= md_frag_max_var (frag
);
710 frag
= frag
->fr_next
;
713 gas_assert (frag
== frag_now
);
714 size
+= frag_now_fix ();
715 if (frag
->fr_type
== rs_machine_dependent
)
716 size
+= md_frag_max_var (frag
);
718 gas_assert (size
>= offset
);
720 return size
- offset
;
723 /* Finish off the frag created to ensure bundle alignment. */
725 finish_bundle (fragS
*frag
, unsigned int size
)
727 gas_assert (bundle_align_p2
> 0);
728 gas_assert (frag
->fr_type
== rs_align_code
);
732 /* If there is more than a single byte, then we need to set up the
733 alignment frag. Otherwise we leave it at its initial state from
734 calling frag_align_code (0, 0), so that it does nothing. */
735 frag
->fr_offset
= bundle_align_p2
;
736 frag
->fr_subtype
= size
- 1;
739 /* We do this every time rather than just in s_bundle_align_mode
740 so that we catch any affected section without needing hooks all
741 over for all paths that do section changes. It's cheap enough. */
742 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
743 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
746 /* Assemble one instruction. This takes care of the bundle features
747 around calling md_assemble. */
749 assemble_one (char *line
)
751 fragS
*insn_start_frag
= NULL
;
753 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
755 as_bad (_("cannot change section or subsection inside .bundle_lock"));
756 /* Clearing this serves as a marker that we have already complained. */
757 bundle_lock_frchain
= NULL
;
760 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
761 insn_start_frag
= start_bundle ();
765 if (bundle_lock_frchain
!= NULL
)
767 /* Make sure this hasn't pushed the locked sequence
768 past the bundle size. */
769 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
770 if (bundle_size
> 1U << bundle_align_p2
)
771 as_bad (_ (".bundle_lock sequence at %u bytes, "
772 "but .bundle_align_mode limit is %u bytes"),
773 bundle_size
, 1U << bundle_align_p2
);
775 else if (bundle_align_p2
> 0)
777 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
779 if (insn_size
> 1U << bundle_align_p2
)
780 as_bad (_("single instruction is %u bytes long, "
781 "but .bundle_align_mode limit is %u bytes"),
782 insn_size
, 1U << bundle_align_p2
);
784 finish_bundle (insn_start_frag
, insn_size
);
788 #else /* !HANDLE_BUNDLE */
790 # define assemble_one(line) md_assemble(line)
792 #endif /* HANDLE_BUNDLE */
797 flagword flags
= bfd_section_flags (now_seg
);
799 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
802 /* Guts of .align directive:
803 N is the power of two to which to align. A value of zero is accepted but
804 ignored: the default alignment of the section will be at least this.
805 FILL may be NULL, or it may point to the bytes of the fill pattern.
806 LEN is the length of whatever FILL points to, if anything. If LEN is zero
807 but FILL is not NULL then LEN is treated as if it were one.
808 MAX is the maximum number of characters to skip when doing the alignment,
809 or 0 if there is no maximum. */
812 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
814 if (now_seg
== absolute_section
|| in_bss ())
820 if (now_seg
== absolute_section
)
821 as_warn (_("ignoring fill value in absolute section"));
823 as_warn (_("ignoring fill value in section `%s'"),
824 segment_name (now_seg
));
831 #ifdef md_flush_pending_output
832 md_flush_pending_output ();
836 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
839 /* Only make a frag if we HAVE to... */
840 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
844 if (subseg_text_p (now_seg
))
845 frag_align_code (n
, max
);
847 frag_align (n
, 0, max
);
850 frag_align (n
, *fill
, max
);
852 frag_align_pattern (n
, fill
, len
, max
);
856 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
859 if (n
> OCTETS_PER_BYTE_POWER
)
860 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
863 /* We read the file, putting things into a web that represents what we
864 have been reading. */
866 read_a_source_file (const char *name
)
870 char *s
; /* String of symbol, '\0' appended. */
872 const pseudo_typeS
*pop
;
878 buffer
= input_scrub_new_file (name
);
881 listing_newline (NULL
);
882 register_dependency (name
);
884 /* Generate debugging information before we've read anything in to denote
885 this file as the "main" source file and not a subordinate one
886 (e.g. N_SO vs N_SOL in stabs). */
887 generate_file_debug ();
889 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
890 { /* We have another line to parse. */
892 /* In order to avoid listing macro expansion lines with labels
893 multiple times, keep track of which line was last issued. */
894 static char *last_eol
;
898 while (input_line_pointer
< buffer_limit
)
901 /* We have more of this buffer to parse. */
903 /* We now have input_line_pointer->1st char of next line.
904 If input_line_pointer [-1] == '\n' then we just
905 scanned another line: so bump line counters. */
906 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
909 symbol_set_value_now (&dot_symbol
);
910 #ifdef md_start_line_hook
911 md_start_line_hook ();
913 if (input_line_pointer
[-1] == '\n')
914 bump_line_counters ();
918 /* If listing is on, and we are expanding a macro, then give
919 the listing code the contents of the expanded line. */
922 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
924 /* Find the end of the current expanded macro line. */
925 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
933 /* Copy it for safe keeping. Also give an indication of
934 how much macro nesting is involved at this point. */
935 len
= s
- input_line_pointer
;
936 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
937 memset (copy
, '>', macro_nest
);
938 copy
[macro_nest
] = ' ';
939 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
940 copy
[macro_nest
+ 1 + len
] = '\0';
942 /* Install the line with the listing facility. */
943 listing_newline (copy
);
947 listing_newline (NULL
);
954 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
956 next_char
= * input_line_pointer
;
957 /* Text at the start of a line must be a label, we
958 run down and stick a colon in. */
959 if (is_name_beginner (next_char
) || next_char
== '"')
964 HANDLE_CONDITIONAL_ASSEMBLY (0);
966 nul_char
= get_symbol_name (& line_start
);
967 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
969 /* In MRI mode, the EQU and MACRO pseudoops must
970 be handled specially. */
974 char *rest
= input_line_pointer
+ 1;
978 if (*rest
== ' ' || *rest
== '\t')
980 if ((strncasecmp (rest
, "EQU", 3) == 0
981 || strncasecmp (rest
, "SET", 3) == 0)
982 && (rest
[3] == ' ' || rest
[3] == '\t'))
984 input_line_pointer
= rest
+ 3;
986 strncasecmp (rest
, "SET", 3) == 0);
989 if (strncasecmp (rest
, "MACRO", 5) == 0
992 || is_end_of_line
[(unsigned char) rest
[5]]))
996 /* In MRI mode, we need to handle the MACRO
997 pseudo-op specially: we don't want to put the
998 symbol in the symbol table. */
1000 #ifdef TC_START_LABEL_WITHOUT_COLON
1001 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1004 line_label
= colon (line_start
);
1006 line_label
= symbol_create (line_start
,
1008 &zero_address_frag
, 0);
1010 next_char
= restore_line_pointer (nul_char
);
1011 if (next_char
== ':')
1012 input_line_pointer
++;
1017 /* We are at the beginning of a line, or similar place.
1018 We expect a well-formed assembler statement.
1019 A "symbol-name:" is a statement.
1021 Depending on what compiler is used, the order of these tests
1022 may vary to catch most common case 1st.
1023 Each test is independent of all other tests at the (top)
1026 nul_char
= next_char
= *input_line_pointer
++;
1027 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1029 /* C is the 1st significant character.
1030 Input_line_pointer points after that character. */
1031 if (is_name_beginner (next_char
) || next_char
== '"')
1035 /* Want user-defined label or pseudo/opcode. */
1036 HANDLE_CONDITIONAL_ASSEMBLY (1);
1038 --input_line_pointer
;
1039 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1040 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1041 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1043 /* NEXT_CHAR is character after symbol.
1044 The end of symbol in the input line is now '\0'.
1045 S points to the beginning of the symbol.
1046 [In case of pseudo-op, s->'.'.]
1047 Input_line_pointer->'\0' where NUL_CHAR was. */
1048 if (TC_START_LABEL (s
, nul_char
, next_char
))
1052 /* In MRI mode, \tsym: set 0 is permitted. */
1056 if (*rest
== ' ' || *rest
== '\t')
1059 if ((strncasecmp (rest
, "EQU", 3) == 0
1060 || strncasecmp (rest
, "SET", 3) == 0)
1061 && (rest
[3] == ' ' || rest
[3] == '\t'))
1063 input_line_pointer
= rest
+ 3;
1069 line_label
= colon (s
); /* User-defined label. */
1070 restore_line_pointer (nul_char
);
1071 ++ input_line_pointer
;
1072 #ifdef tc_check_label
1073 tc_check_label (line_label
);
1075 /* Input_line_pointer->after ':'. */
1078 else if ((next_char
== '=' && *rest
== '=')
1079 || ((next_char
== ' ' || next_char
== '\t')
1084 demand_empty_rest_of_line ();
1086 else if ((next_char
== '='
1087 || ((next_char
== ' ' || next_char
== '\t')
1089 #ifdef TC_EQUAL_IN_INSN
1090 && !TC_EQUAL_IN_INSN (next_char
, s
)
1095 demand_empty_rest_of_line ();
1099 /* Expect pseudo-op or machine instruction. */
1102 #ifndef TC_CASE_SENSITIVE
1106 strncpy (original_case_string
, s2
,
1107 sizeof (original_case_string
) - 1);
1108 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1112 *s2
= TOLOWER (*s2
);
1117 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1119 /* The MRI assembler uses pseudo-ops without
1121 pop
= po_entry_find (po_hash
, s
);
1122 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1127 || (!flag_m68k_mri
&& *s
== '.'))
1131 WARNING: next_char may be end-of-line.
1132 We lookup the pseudo-op table with s+1 because we
1133 already know that the pseudo-op begins with a '.'. */
1136 pop
= po_entry_find (po_hash
, s
+ 1);
1137 if (pop
&& !pop
->poc_handler
)
1140 /* In MRI mode, we may need to insert an
1141 automatic alignment directive. What a hack
1143 if (mri_pending_align
1145 || !((pop
->poc_handler
== cons
1146 && pop
->poc_val
== 1)
1147 || (pop
->poc_handler
== s_space
1148 && pop
->poc_val
== 1)
1149 #ifdef tc_conditional_pseudoop
1150 || tc_conditional_pseudoop (pop
)
1152 || pop
->poc_handler
== s_if
1153 || pop
->poc_handler
== s_ifdef
1154 || pop
->poc_handler
== s_ifc
1155 || pop
->poc_handler
== s_ifeqs
1156 || pop
->poc_handler
== s_else
1157 || pop
->poc_handler
== s_endif
1158 || pop
->poc_handler
== s_globl
1159 || pop
->poc_handler
== s_ignore
)))
1161 do_align (1, (char *) NULL
, 0, 0);
1162 mri_pending_align
= 0;
1164 if (line_label
!= NULL
)
1166 symbol_set_frag (line_label
, frag_now
);
1167 S_SET_VALUE (line_label
, frag_now_fix ());
1171 /* Print the error msg now, while we still can. */
1174 char *end
= input_line_pointer
;
1176 (void) restore_line_pointer (nul_char
);
1178 nul_char
= next_char
= *--input_line_pointer
;
1179 *input_line_pointer
= '\0';
1180 if (! macro_defined
|| ! try_macro (next_char
, s
))
1183 as_bad (_("unknown pseudo-op: `%s'"), s
);
1184 *input_line_pointer
++ = nul_char
;
1189 /* Put it back for error messages etc. */
1190 next_char
= restore_line_pointer (nul_char
);
1191 /* The following skip of whitespace is compulsory.
1192 A well shaped space is sometimes all that separates
1193 keyword from operands. */
1194 if (next_char
== ' ' || next_char
== '\t')
1195 input_line_pointer
++;
1197 /* Input_line is restored.
1198 Input_line_pointer->1st non-blank char
1199 after pseudo-operation. */
1200 (*pop
->poc_handler
) (pop
->poc_val
);
1202 /* If that was .end, just get out now. */
1203 if (pop
->poc_handler
== s_end
)
1208 /* WARNING: next_char may be end-of-line. */
1209 /* Also: input_line_pointer->`\0` where nul_char was. */
1210 (void) restore_line_pointer (nul_char
);
1211 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1212 next_char
= nul_char
= *input_line_pointer
;
1213 *input_line_pointer
= '\0';
1215 generate_lineno_debug ();
1217 if (macro_defined
&& try_macro (next_char
, s
))
1220 if (mri_pending_align
)
1222 do_align (1, (char *) NULL
, 0, 0);
1223 mri_pending_align
= 0;
1224 if (line_label
!= NULL
)
1226 symbol_set_frag (line_label
, frag_now
);
1227 S_SET_VALUE (line_label
, frag_now_fix ());
1231 assemble_one (s
); /* Assemble 1 instruction. */
1233 /* PR 19630: The backend may have set ilp to NULL
1234 if it encountered a catastrophic failure. */
1235 if (input_line_pointer
== NULL
)
1236 as_fatal (_("unable to continue with assembly."));
1238 *input_line_pointer
++ = nul_char
;
1240 /* We resume loop AFTER the end-of-line from
1241 this instruction. */
1247 /* Empty statement? */
1248 if (is_end_of_line
[(unsigned char) next_char
])
1251 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1253 /* local label ("4:") */
1254 char *backup
= input_line_pointer
;
1256 HANDLE_CONDITIONAL_ASSEMBLY (1);
1258 temp
= next_char
- '0';
1260 if (nul_char
== '"')
1261 ++ input_line_pointer
;
1263 /* Read the whole number. */
1264 while (ISDIGIT (*input_line_pointer
))
1266 const long digit
= *input_line_pointer
- '0';
1267 if (temp
> (INT_MAX
- digit
) / 10)
1269 as_bad (_("local label too large near %s"), backup
);
1273 temp
= temp
* 10 + digit
;
1274 ++input_line_pointer
;
1277 /* Overflow: stop processing the label. */
1280 ignore_rest_of_line ();
1284 if (LOCAL_LABELS_DOLLAR
1285 && *input_line_pointer
== '$'
1286 && *(input_line_pointer
+ 1) == ':')
1288 input_line_pointer
+= 2;
1290 if (dollar_label_defined (temp
))
1292 as_fatal (_("label \"%ld$\" redefined"), temp
);
1295 define_dollar_label (temp
);
1296 colon (dollar_label_name (temp
, 0));
1301 && *input_line_pointer
++ == ':')
1303 fb_label_instance_inc (temp
);
1304 colon (fb_label_name (temp
, 0));
1308 input_line_pointer
= backup
;
1311 if (next_char
&& strchr (line_comment_chars
, next_char
))
1312 { /* Its a comment. Better say APP or NO_APP. */
1317 unsigned int new_length
;
1320 s
= input_line_pointer
;
1321 if (!startswith (s
, "APP\n"))
1324 ignore_rest_of_line ();
1327 bump_line_counters ();
1330 ends
= strstr (s
, "#NO_APP\n");
1334 unsigned int tmp_len
;
1337 /* The end of the #APP wasn't in this buffer. We
1338 keep reading in buffers until we find the #NO_APP
1339 that goes with this #APP There is one. The specs
1341 tmp_len
= buffer_limit
- s
;
1342 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1343 memcpy (tmp_buf
, s
, tmp_len
);
1346 new_tmp
= input_scrub_next_buffer (&buffer
);
1350 buffer_limit
= new_tmp
;
1351 input_line_pointer
= buffer
;
1352 ends
= strstr (buffer
, "#NO_APP\n");
1354 num
= ends
- buffer
;
1356 num
= buffer_limit
- buffer
;
1358 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1359 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1364 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1372 input_line_pointer
= ends
+ 8;
1376 scrub_string_end
= ends
;
1378 new_length
= ends
- s
;
1379 new_buf
= XNEWVEC (char, new_length
);
1386 space
= (new_buf
+ new_length
) - new_tmp
;
1387 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1392 new_length
= new_tmp
+ size
- new_buf
;
1396 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1397 new_tmp
= new_buf
+ new_length
;
1403 /* We've "scrubbed" input to the preferred format. In the
1404 process we may have consumed the whole of the remaining
1405 file (and included files). We handle this formatted
1406 input similar to that of macro expansion, letting
1407 actual macro expansion (possibly nested) and other
1408 input expansion work. Beware that in messages, line
1409 numbers and possibly file names will be incorrect. */
1410 sb_build (&sbuf
, new_length
);
1411 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1412 input_scrub_include_sb (&sbuf
, input_line_pointer
, expanding_none
);
1414 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1419 HANDLE_CONDITIONAL_ASSEMBLY (1);
1421 #ifdef tc_unrecognized_line
1422 if (tc_unrecognized_line (next_char
))
1425 input_line_pointer
--;
1426 /* Report unknown char as error. */
1427 demand_empty_rest_of_line ();
1432 symbol_set_value_now (&dot_symbol
);
1434 #ifdef HANDLE_BUNDLE
1435 if (bundle_lock_frag
!= NULL
)
1437 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1438 _(".bundle_lock with no matching .bundle_unlock"));
1439 bundle_lock_frag
= NULL
;
1440 bundle_lock_frchain
= NULL
;
1441 bundle_lock_depth
= 0;
1448 /* Close the input file. */
1449 input_scrub_close ();
1450 #ifdef WARN_COMMENTS
1452 if (warn_comment
&& found_comment
)
1453 as_warn_where (found_comment_file
, found_comment
,
1454 "first comment found here");
1459 /* Convert O_constant expression EXP into the equivalent O_big representation.
1460 Take the sign of the number from SIGN rather than X_add_number. */
1463 convert_to_bignum (expressionS
*exp
, int sign
)
1468 value
= exp
->X_add_number
;
1469 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1471 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1472 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1474 /* Add a sequence of sign bits if the top bit of X_add_number is not
1475 the sign of the original value. */
1476 if ((exp
->X_add_number
< 0) == !sign
)
1477 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1479 exp
->X_add_number
= i
;
1482 /* For most MRI pseudo-ops, the line actually ends at the first
1483 nonquoted space. This function looks for that point, stuffs a null
1484 in, and sets *STOPCP to the character that used to be there, and
1485 returns the location.
1487 Until I hear otherwise, I am going to assume that this is only true
1488 for the m68k MRI assembler. */
1491 mri_comment_field (char *stopcp
)
1497 know (flag_m68k_mri
);
1499 for (s
= input_line_pointer
;
1500 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1508 for (s
= input_line_pointer
;
1509 !is_end_of_line
[(unsigned char) *s
];
1519 /* Skip to the end of an MRI comment field. */
1522 mri_comment_end (char *stop
, int stopc
)
1526 input_line_pointer
= stop
;
1528 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1529 ++input_line_pointer
;
1533 s_abort (int ignore ATTRIBUTE_UNUSED
)
1535 as_fatal (_(".abort detected. Abandoning ship."));
1538 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1539 (in bytes). A negative ARG is the negative of the length of the
1540 fill pattern. BYTES_P is non-zero if the alignment value should be
1541 interpreted as the byte boundary, rather than the power of 2. */
1542 #ifndef TC_ALIGN_LIMIT
1543 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1547 s_align (signed int arg
, int bytes_p
)
1549 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1558 stop
= mri_comment_field (&stopc
);
1560 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1565 align
= arg
; /* Default value from pseudo-op table. */
1569 align
= get_absolute_expression ();
1572 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1573 if (arg
> 0 && align
== 0)
1580 /* Convert to a power of 2. */
1585 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1588 as_bad (_("alignment not a power of 2"));
1594 if (align
> align_limit
)
1596 align
= align_limit
;
1597 as_warn (_("alignment too large: %u assumed"), align_limit
);
1600 if (*input_line_pointer
!= ',')
1607 ++input_line_pointer
;
1608 if (*input_line_pointer
== ',')
1612 fill
= get_absolute_expression ();
1617 if (*input_line_pointer
!= ',')
1621 ++input_line_pointer
;
1622 max
= get_absolute_expression ();
1629 as_warn (_("expected fill pattern missing"));
1630 do_align (align
, (char *) NULL
, 0, max
);
1634 unsigned int fill_len
;
1646 do_align (align
, &fill_char
, fill_len
, max
);
1652 if ((size_t) fill_len
> sizeof ab
)
1654 as_warn (_("fill pattern too long, truncating to %u"),
1655 (unsigned) sizeof ab
);
1656 fill_len
= sizeof ab
;
1659 md_number_to_chars (ab
, fill
, fill_len
);
1660 do_align (align
, ab
, fill_len
, max
);
1664 demand_empty_rest_of_line ();
1667 mri_comment_end (stop
, stopc
);
1670 /* Handle the .align pseudo-op on machines where ".align 4" means
1671 align to a 4 byte boundary. */
1674 s_align_bytes (int arg
)
1679 /* Handle the .align pseudo-op on machines where ".align 4" means align
1680 to a 2**4 boundary. */
1683 s_align_ptwo (int arg
)
1688 /* Switch in and out of alternate macro mode. */
1693 demand_empty_rest_of_line ();
1694 macro_set_alternate (on
);
1697 /* Read a symbol name from input_line_pointer.
1699 Stores the symbol name in a buffer and returns a pointer to this buffer.
1700 The buffer is xalloc'ed. It is the caller's responsibility to free
1703 The name is not left in the i_l_p buffer as it may need processing
1704 to handle escape characters.
1706 Advances i_l_p to the next non-whitespace character.
1708 If a symbol name could not be read, the routine issues an error
1709 messages, skips to the end of the line and returns NULL. */
1712 read_symbol_name (void)
1718 c
= *input_line_pointer
++;
1722 #define SYM_NAME_CHUNK_LEN 128
1723 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1727 start
= name
= XNEWVEC (char, len
+ 1);
1729 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1731 while (is_a_char (C
= next_char_of_string ()))
1733 if (name
>= name_end
)
1737 sofar
= name
- start
;
1738 len
+= SYM_NAME_CHUNK_LEN
;
1739 start
= XRESIZEVEC (char, start
, len
+ 1);
1740 name_end
= start
+ len
;
1741 name
= start
+ sofar
;
1748 /* Since quoted symbol names can contain non-ASCII characters,
1749 check the string and warn if it cannot be recognised by the
1750 current character set. */
1751 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1752 as_warn (_("symbol name not recognised in the current locale"));
1754 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1758 name
= input_line_pointer
- 1;
1760 /* We accept FAKE_LABEL_CHAR in a name in case this is
1761 being called with a constructed string. */
1762 while (is_part_of_name (c
= *input_line_pointer
++)
1763 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1766 len
= (input_line_pointer
- name
) - 1;
1767 start
= XNEWVEC (char, len
+ 1);
1769 memcpy (start
, name
, len
);
1772 /* Skip a name ender char if one is present. */
1773 if (! is_name_ender (c
))
1774 --input_line_pointer
;
1777 name
= start
= NULL
;
1781 as_bad (_("expected symbol name"));
1782 ignore_rest_of_line ();
1793 s_comm_internal (int param
,
1794 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1798 symbolS
*symbolP
= NULL
;
1804 stop
= mri_comment_field (&stopc
);
1806 if ((name
= read_symbol_name ()) == NULL
)
1809 /* Accept an optional comma after the name. The comma used to be
1810 required, but Irix 5 cc does not generate it for .lcomm. */
1811 if (*input_line_pointer
== ',')
1812 input_line_pointer
++;
1814 temp
= get_absolute_expr (&exp
);
1816 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1817 if (exp
.X_op
== O_absent
)
1819 as_bad (_("missing size expression"));
1820 ignore_rest_of_line ();
1823 else if (temp
!= size
|| !exp
.X_unsigned
)
1825 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1826 ignore_rest_of_line ();
1830 symbolP
= symbol_find_or_make (name
);
1831 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1832 && !S_IS_COMMON (symbolP
))
1834 if (!S_IS_VOLATILE (symbolP
))
1837 as_bad (_("symbol `%s' is already defined"), name
);
1838 ignore_rest_of_line ();
1841 symbolP
= symbol_clone (symbolP
, 1);
1842 S_SET_SEGMENT (symbolP
, undefined_section
);
1843 S_SET_VALUE (symbolP
, 0);
1844 symbol_set_frag (symbolP
, &zero_address_frag
);
1845 S_CLEAR_VOLATILE (symbolP
);
1848 size
= S_GET_VALUE (symbolP
);
1851 else if (size
!= temp
)
1852 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1853 name
, (long) size
, (long) temp
);
1855 if (comm_parse_extra
!= NULL
)
1856 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1859 S_SET_VALUE (symbolP
, (valueT
) size
);
1860 S_SET_EXTERNAL (symbolP
);
1861 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1864 demand_empty_rest_of_line ();
1867 mri_comment_end (stop
, stopc
);
1875 s_comm_internal (ignore
, NULL
);
1878 /* The MRI COMMON pseudo-op. We handle this by creating a common
1879 symbol with the appropriate name. We make s_space do the right
1880 thing by increasing the size. */
1883 s_mri_common (int small ATTRIBUTE_UNUSED
)
1899 stop
= mri_comment_field (&stopc
);
1903 name
= input_line_pointer
;
1904 if (!ISDIGIT (*name
))
1905 c
= get_symbol_name (& name
);
1910 ++input_line_pointer
;
1912 while (ISDIGIT (*input_line_pointer
));
1914 c
= *input_line_pointer
;
1915 *input_line_pointer
= '\0';
1917 if (line_label
!= NULL
)
1919 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1920 + (input_line_pointer
- name
) + 1);
1921 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1926 sym
= symbol_find_or_make (name
);
1927 c
= restore_line_pointer (c
);
1930 if (*input_line_pointer
!= ',')
1934 ++input_line_pointer
;
1935 align
= get_absolute_expression ();
1938 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1940 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1941 mri_comment_end (stop
, stopc
);
1945 S_SET_EXTERNAL (sym
);
1946 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1947 mri_common_symbol
= sym
;
1951 S_SET_ALIGN (sym
, align
);
1956 if (line_label
!= NULL
)
1959 exp
.X_op
= O_symbol
;
1960 exp
.X_add_symbol
= sym
;
1961 exp
.X_add_number
= 0;
1962 symbol_set_value_expression (line_label
, &exp
);
1963 symbol_set_frag (line_label
, &zero_address_frag
);
1964 S_SET_SEGMENT (line_label
, expr_section
);
1967 /* FIXME: We just ignore the small argument, which distinguishes
1968 COMMON and COMMON.S. I don't know what we can do about it. */
1970 /* Ignore the type and hptype. */
1971 if (*input_line_pointer
== ',')
1972 input_line_pointer
+= 2;
1973 if (*input_line_pointer
== ',')
1974 input_line_pointer
+= 2;
1976 demand_empty_rest_of_line ();
1978 mri_comment_end (stop
, stopc
);
1982 s_data (int ignore ATTRIBUTE_UNUSED
)
1987 temp
= get_absolute_expression ();
1988 if (flag_readonly_data_in_text
)
1990 section
= text_section
;
1994 section
= data_section
;
1996 subseg_set (section
, (subsegT
) temp
);
1998 demand_empty_rest_of_line ();
2001 /* Handle the .file pseudo-op. This default definition may be overridden by
2002 the object or CPU specific pseudo-ops. */
2005 s_file_string (char *file
)
2009 listing_source_file (file
);
2011 register_dependency (file
);
2013 obj_app_file (file
);
2018 s_file (int ignore ATTRIBUTE_UNUSED
)
2023 /* Some assemblers tolerate immediately following '"'. */
2024 if ((s
= demand_copy_string (&length
)) != 0)
2026 new_logical_line_flags (s
, -1, 1);
2028 /* In MRI mode, the preprocessor may have inserted an extraneous
2031 && *input_line_pointer
== '\''
2032 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2033 ++input_line_pointer
;
2035 demand_empty_rest_of_line ();
2041 get_linefile_number (int *flag
)
2045 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2048 *flag
= get_absolute_expression ();
2053 /* Handle the .linefile pseudo-op. This is automatically generated by
2054 do_scrub_chars when a preprocessor # line comment is seen. This
2055 default definition may be overridden by the object or CPU specific
2059 s_linefile (int ignore ATTRIBUTE_UNUSED
)
2062 int linenum
, flags
= 0;
2064 /* The given number is that of the next line. */
2065 if (!get_linefile_number (&linenum
))
2067 ignore_rest_of_line ();
2072 /* Some of the back ends can't deal with non-positive line numbers.
2073 Besides, it's silly. GCC however will generate a line number of
2074 zero when it is pre-processing builtins for assembler-with-cpp files:
2078 We do not want to barf on this, especially since such files are used
2079 in the GCC and GDB testsuites. So we check for negative line numbers
2080 rather than non-positive line numbers. */
2081 as_warn (_("line numbers must be positive; line number %d rejected"),
2089 if (*input_line_pointer
== '"')
2090 file
= demand_copy_string (&length
);
2091 else if (*input_line_pointer
== '.')
2093 /* buffer_and_nest() may insert this form. */
2094 ++input_line_pointer
;
2102 while (get_linefile_number (&this_flag
))
2105 /* From GCC's cpp documentation:
2106 1: start of a new file.
2107 2: returning to a file after having included another file.
2108 3: following text comes from a system header file.
2109 4: following text should be treated as extern "C".
2111 4 is nonsensical for the assembler; 3, we don't care about,
2112 so we ignore it just in case a system header file is
2113 included while preprocessing assembly. So 1 and 2 are all
2114 we care about, and they are mutually incompatible.
2115 new_logical_line_flags() demands this. */
2118 if (flags
&& flags
!= (1 << this_flag
))
2119 as_warn (_("incompatible flag %i in line directive"),
2122 flags
|= 1 << this_flag
;
2127 /* We ignore these. */
2131 as_warn (_("unsupported flag %i in line directive"),
2136 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2143 new_logical_line_flags (file
, linenum
, flags
);
2146 listing_source_line (linenum
);
2151 demand_empty_rest_of_line ();
2153 ignore_rest_of_line ();
2156 /* Handle the .end pseudo-op. Actually, the real work is done in
2157 read_a_source_file. */
2160 s_end (int ignore ATTRIBUTE_UNUSED
)
2164 /* The MRI assembler permits the start symbol to follow .end,
2165 but we don't support that. */
2167 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2168 && *input_line_pointer
!= '*'
2169 && *input_line_pointer
!= '!')
2170 as_warn (_("start address not supported"));
2174 /* Handle the .err pseudo-op. */
2177 s_err (int ignore ATTRIBUTE_UNUSED
)
2179 as_bad (_(".err encountered"));
2180 demand_empty_rest_of_line ();
2183 /* Handle the .error and .warning pseudo-ops. */
2189 /* The purpose for the conditional assignment is not to
2190 internationalize the directive itself, but that we need a
2191 self-contained message, one that can be passed like the
2192 demand_copy_C_string return value, and with no assumption on the
2193 location of the name of the directive within the message. */
2195 = (err
? _(".error directive invoked in source file")
2196 : _(".warning directive invoked in source file"));
2198 if (!is_it_end_of_statement ())
2200 if (*input_line_pointer
!= '\"')
2202 as_bad (_("%s argument must be a string"),
2203 err
? ".error" : ".warning");
2204 ignore_rest_of_line ();
2208 msg
= demand_copy_C_string (&len
);
2216 as_warn ("%s", msg
);
2217 demand_empty_rest_of_line ();
2220 /* Handle the MRI fail pseudo-op. */
2223 s_fail (int ignore ATTRIBUTE_UNUSED
)
2230 stop
= mri_comment_field (&stopc
);
2232 temp
= get_absolute_expression ();
2234 as_warn (_(".fail %ld encountered"), (long) temp
);
2236 as_bad (_(".fail %ld encountered"), (long) temp
);
2238 demand_empty_rest_of_line ();
2241 mri_comment_end (stop
, stopc
);
2245 s_fill (int ignore ATTRIBUTE_UNUSED
)
2247 expressionS rep_exp
;
2252 #ifdef md_flush_pending_output
2253 md_flush_pending_output ();
2256 #ifdef md_cons_align
2260 expression (&rep_exp
);
2261 if (*input_line_pointer
== ',')
2263 input_line_pointer
++;
2264 size
= get_absolute_expression ();
2265 if (*input_line_pointer
== ',')
2267 input_line_pointer
++;
2268 fill
= get_absolute_expression ();
2272 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2273 #define BSD_FILL_SIZE_CROCK_8 (8)
2274 if (size
> BSD_FILL_SIZE_CROCK_8
)
2276 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2277 size
= BSD_FILL_SIZE_CROCK_8
;
2281 as_warn (_("size negative; .fill ignored"));
2284 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2286 if (rep_exp
.X_add_number
< 0)
2287 as_warn (_("repeat < 0; .fill ignored"));
2291 if (size
&& !need_pass_2
)
2293 if (now_seg
== absolute_section
)
2295 if (rep_exp
.X_op
!= O_constant
)
2296 as_bad (_("non-constant fill count for absolute section"));
2297 else if (fill
&& rep_exp
.X_add_number
!= 0)
2298 as_bad (_("attempt to fill absolute section with non-zero value"));
2299 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2302 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2304 as_bad (_("attempt to fill section `%s' with non-zero value"),
2305 segment_name (now_seg
));
2307 if (rep_exp
.X_op
== O_constant
)
2309 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2310 (relax_substateT
) 0, (symbolS
*) 0,
2311 (offsetT
) rep_exp
.X_add_number
,
2316 /* We don't have a constant repeat count, so we can't use
2317 rs_fill. We can get the same results out of rs_space,
2318 but its argument is in bytes, so we must multiply the
2319 repeat count by size. */
2322 rep_sym
= make_expr_symbol (&rep_exp
);
2325 expressionS size_exp
;
2326 size_exp
.X_op
= O_constant
;
2327 size_exp
.X_add_number
= size
;
2329 rep_exp
.X_op
= O_multiply
;
2330 rep_exp
.X_add_symbol
= rep_sym
;
2331 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2332 rep_exp
.X_add_number
= 0;
2333 rep_sym
= make_expr_symbol (&rep_exp
);
2336 p
= frag_var (rs_space
, (int) size
, (int) size
,
2337 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2340 memset (p
, 0, (unsigned int) size
);
2342 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2343 flavoured AS. The following bizarre behaviour is to be
2344 compatible with above. I guess they tried to take up to 8
2345 bytes from a 4-byte expression and they forgot to sign
2347 #define BSD_FILL_SIZE_CROCK_4 (4)
2348 md_number_to_chars (p
, (valueT
) fill
,
2349 (size
> BSD_FILL_SIZE_CROCK_4
2350 ? BSD_FILL_SIZE_CROCK_4
2352 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2353 but emits no error message because it seems a legal thing to do.
2354 It is a degenerate case of .fill but could be emitted by a
2357 demand_empty_rest_of_line ();
2361 s_globl (int ignore ATTRIBUTE_UNUSED
)
2370 stop
= mri_comment_field (&stopc
);
2374 if ((name
= read_symbol_name ()) == NULL
)
2377 symbolP
= symbol_find_or_make (name
);
2378 S_SET_EXTERNAL (symbolP
);
2381 c
= *input_line_pointer
;
2384 input_line_pointer
++;
2386 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2394 demand_empty_rest_of_line ();
2397 mri_comment_end (stop
, stopc
);
2400 /* Handle the MRI IRP and IRPC pseudo-ops. */
2412 file
= as_where (&line
);
2414 eol
= find_end_of_line (input_line_pointer
, 0);
2415 sb_build (&s
, eol
- input_line_pointer
);
2416 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2417 input_line_pointer
= eol
;
2421 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2423 as_bad_where (file
, line
, "%s", err
);
2427 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2429 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2432 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2433 the section to only be linked once. However, this is not supported
2434 by most object file formats. This takes an optional argument,
2435 which is what to do about duplicates. */
2438 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2440 enum linkonce_type type
;
2444 type
= LINKONCE_DISCARD
;
2446 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2451 c
= get_symbol_name (& s
);
2452 if (strcasecmp (s
, "discard") == 0)
2453 type
= LINKONCE_DISCARD
;
2454 else if (strcasecmp (s
, "one_only") == 0)
2455 type
= LINKONCE_ONE_ONLY
;
2456 else if (strcasecmp (s
, "same_size") == 0)
2457 type
= LINKONCE_SAME_SIZE
;
2458 else if (strcasecmp (s
, "same_contents") == 0)
2459 type
= LINKONCE_SAME_CONTENTS
;
2461 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2463 (void) restore_line_pointer (c
);
2466 #ifdef obj_handle_link_once
2467 obj_handle_link_once (type
);
2468 #else /* ! defined (obj_handle_link_once) */
2472 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2473 as_warn (_(".linkonce is not supported for this object file format"));
2475 flags
= bfd_section_flags (now_seg
);
2476 flags
|= SEC_LINK_ONCE
;
2481 case LINKONCE_DISCARD
:
2482 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2484 case LINKONCE_ONE_ONLY
:
2485 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2487 case LINKONCE_SAME_SIZE
:
2488 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2490 case LINKONCE_SAME_CONTENTS
:
2491 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2494 if (!bfd_set_section_flags (now_seg
, flags
))
2495 as_bad (_("bfd_set_section_flags: %s"),
2496 bfd_errmsg (bfd_get_error ()));
2498 #endif /* ! defined (obj_handle_link_once) */
2500 demand_empty_rest_of_line ();
2504 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2507 segT current_seg
= now_seg
;
2508 subsegT current_subseg
= now_subseg
;
2509 segT bss_seg
= bss_section
;
2511 #if defined (TC_MIPS) || defined (TC_ALPHA)
2512 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2513 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2515 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2516 if (size
<= bfd_get_gp_size (stdoutput
))
2518 bss_seg
= subseg_new (".sbss", 1);
2519 seg_info (bss_seg
)->bss
= 1;
2520 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2521 as_warn (_("error setting flags for \".sbss\": %s"),
2522 bfd_errmsg (bfd_get_error ()));
2526 subseg_set (bss_seg
, 1);
2528 if (align
> OCTETS_PER_BYTE_POWER
)
2530 record_alignment (bss_seg
, align
);
2531 frag_align (align
, 0, 0);
2534 /* Detach from old frag. */
2535 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2536 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2538 symbol_set_frag (symbolP
, frag_now
);
2539 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2543 S_SET_SIZE (symbolP
, size
);
2545 S_SET_SEGMENT (symbolP
, bss_seg
);
2548 /* The symbol may already have been created with a preceding
2549 ".globl" directive -- be careful not to step on storage class
2550 in that case. Otherwise, set it to static. */
2551 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2552 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2553 #endif /* OBJ_COFF */
2555 subseg_set (current_seg
, current_subseg
);
2559 parse_align (int align_bytes
)
2565 if (*input_line_pointer
!= ',')
2568 as_bad (_("expected alignment after size"));
2569 ignore_rest_of_line ();
2573 input_line_pointer
++;
2576 align
= get_absolute_expr (&exp
);
2577 if (exp
.X_op
== O_absent
)
2580 if (!exp
.X_unsigned
)
2582 as_warn (_("alignment negative; 0 assumed"));
2586 if (align_bytes
&& align
!= 0)
2588 /* convert to a power of 2 alignment */
2589 unsigned int alignp2
= 0;
2590 while ((align
& 1) == 0)
2591 align
>>= 1, ++alignp2
;
2594 as_bad (_("alignment not a power of 2"));
2595 ignore_rest_of_line ();
2603 /* Called from s_comm_internal after symbol name and size have been
2604 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2605 1 if this was a ".bss" directive which has a 3rd argument
2606 (alignment as a power of 2), or 2 if this was a ".bss" directive
2607 with alignment in bytes. */
2610 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2616 align
= parse_align (needs_align
- 1);
2617 if (align
== (addressT
) -1)
2621 /* Assume some objects may require alignment on some systems. */
2622 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2624 bss_alloc (symbolP
, size
, align
);
2629 s_lcomm (int needs_align
)
2631 s_comm_internal (needs_align
, s_lcomm_internal
);
2635 s_lcomm_bytes (int needs_align
)
2637 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2641 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2647 /* We permit ANY defined expression: BSD4.2 demands constants. */
2648 if ((name
= read_symbol_name ()) == NULL
)
2651 if (*input_line_pointer
!= ',')
2653 as_bad (_("expected comma after \"%s\""), name
);
2657 input_line_pointer
++;
2658 expression_and_evaluate (&exp
);
2660 if (exp
.X_op
!= O_constant
2661 && exp
.X_op
!= O_register
)
2663 as_bad (_("bad expression"));
2667 symbolP
= symbol_find_or_make (name
);
2669 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2671 /* The name might be an undefined .global symbol; be sure to
2672 keep the "external" bit. */
2673 S_SET_SEGMENT (symbolP
,
2674 (exp
.X_op
== O_constant
2677 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2681 as_bad (_("symbol `%s' is already defined"), name
);
2684 demand_empty_rest_of_line ();
2689 ignore_rest_of_line ();
2694 /* Read a line into an sb. Returns the character that ended the line
2695 or zero if there are no more lines. */
2698 get_line_sb (sb
*line
, int in_macro
)
2702 if (input_line_pointer
[-1] == '\n')
2703 bump_line_counters ();
2705 if (input_line_pointer
>= buffer_limit
)
2707 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2708 if (buffer_limit
== 0)
2712 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2713 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2714 input_line_pointer
= eol
;
2716 /* Don't skip multiple end-of-line characters, because that breaks support
2717 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2718 characters but isn't. Instead just skip one end of line character and
2719 return the character skipped so that the caller can re-insert it if
2721 return *input_line_pointer
++;
2725 get_non_macro_line_sb (sb
*line
)
2727 return get_line_sb (line
, 0);
2731 get_macro_line_sb (sb
*line
)
2733 return get_line_sb (line
, 1);
2736 /* Define a macro. This is an interface to macro.c. */
2739 s_macro (int ignore ATTRIBUTE_UNUSED
)
2748 file
= as_where (&line
);
2750 eol
= find_end_of_line (input_line_pointer
, 0);
2751 sb_build (&s
, eol
- input_line_pointer
);
2752 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2753 input_line_pointer
= eol
;
2755 if (line_label
!= NULL
)
2760 name
= S_GET_NAME (line_label
);
2761 len
= strlen (name
);
2762 sb_build (&label
, len
);
2763 sb_add_buffer (&label
, name
, len
);
2764 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2768 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2770 as_bad_where (file
, line
, err
, name
);
2773 if (line_label
!= NULL
)
2775 S_SET_SEGMENT (line_label
, absolute_section
);
2776 S_SET_VALUE (line_label
, 0);
2777 symbol_set_frag (line_label
, &zero_address_frag
);
2780 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2781 && po_entry_find (po_hash
, name
) != NULL
)
2784 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2785 as_warn_where (file
,
2787 _("attempt to redefine pseudo-op `%s' ignored"),
2794 /* Handle the .mexit pseudo-op, which immediately exits a macro
2798 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2802 cond_exit_macro (macro_nest
);
2803 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2806 as_warn (_("ignoring macro exit outside a macro definition."));
2809 /* Switch in and out of MRI mode. */
2812 s_mri (int ignore ATTRIBUTE_UNUSED
)
2815 #ifdef MRI_MODE_CHANGE
2819 on
= get_absolute_expression ();
2820 #ifdef MRI_MODE_CHANGE
2821 old_flag
= flag_mri
;
2840 /* Operator precedence changes in m68k MRI mode, so we need to
2841 update the operator rankings. */
2842 expr_set_precedence ();
2844 #ifdef MRI_MODE_CHANGE
2846 MRI_MODE_CHANGE (on
);
2849 demand_empty_rest_of_line ();
2852 /* Handle changing the location counter. */
2855 do_org (segT segment
, expressionS
*exp
, int fill
)
2857 if (segment
!= now_seg
2858 && segment
!= absolute_section
2859 && segment
!= expr_section
)
2860 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2862 if (now_seg
== absolute_section
)
2865 as_warn (_("ignoring fill value in absolute section"));
2866 if (exp
->X_op
!= O_constant
)
2868 as_bad (_("only constant offsets supported in absolute section"));
2869 exp
->X_add_number
= 0;
2871 abs_section_offset
= exp
->X_add_number
;
2876 symbolS
*sym
= exp
->X_add_symbol
;
2877 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2879 if (fill
&& in_bss ())
2880 as_warn (_("ignoring fill value in section `%s'"),
2881 segment_name (now_seg
));
2883 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2885 /* Handle complex expressions. */
2886 sym
= make_expr_symbol (exp
);
2890 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2896 s_org (int ignore ATTRIBUTE_UNUSED
)
2902 #ifdef md_flush_pending_output
2903 md_flush_pending_output ();
2906 /* The m68k MRI assembler has a different meaning for .org. It
2907 means to create an absolute section at a given address. We can't
2908 support that--use a linker script instead. */
2911 as_bad (_("MRI style ORG pseudo-op not supported"));
2912 ignore_rest_of_line ();
2916 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2917 thing as a sub-segment-relative origin. Any absolute origin is
2918 given a warning, then assumed to be segment-relative. Any
2919 segmented origin expression ("foo+42") had better be in the right
2920 segment or the .org is ignored.
2922 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2923 we never know sub-segment sizes when we are reading code. BSD
2924 will crash trying to emit negative numbers of filler bytes in
2925 certain .orgs. We don't crash, but see as-write for that code.
2927 Don't make frag if need_pass_2==1. */
2928 segment
= get_known_segmented_expression (&exp
);
2929 if (*input_line_pointer
== ',')
2931 input_line_pointer
++;
2932 temp_fill
= get_absolute_expression ();
2938 do_org (segment
, &exp
, temp_fill
);
2940 demand_empty_rest_of_line ();
2943 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2944 called by the obj-format routine which handles section changing
2945 when in MRI mode. It will create a new section, and return it. It
2946 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2947 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2950 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2960 name
= input_line_pointer
;
2961 if (!ISDIGIT (*name
))
2962 c
= get_symbol_name (& name
);
2967 ++input_line_pointer
;
2969 while (ISDIGIT (*input_line_pointer
));
2971 c
= *input_line_pointer
;
2972 *input_line_pointer
= '\0';
2975 name
= xstrdup (name
);
2977 c
= restore_line_pointer (c
);
2979 seg
= subseg_new (name
, 0);
2985 ++input_line_pointer
;
2986 align
= get_absolute_expression ();
2987 record_alignment (seg
, align
);
2991 if (*input_line_pointer
== ',')
2993 c
= *++input_line_pointer
;
2995 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2998 as_bad (_("unrecognized section type"));
2999 ++input_line_pointer
;
3004 flags
= SEC_NO_FLAGS
;
3006 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3007 else if (*type
== 'D' || *type
== 'M')
3008 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3009 else if (*type
== 'R')
3010 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3011 if (flags
!= SEC_NO_FLAGS
)
3013 if (!bfd_set_section_flags (seg
, flags
))
3014 as_warn (_("error setting flags for \"%s\": %s"),
3015 bfd_section_name (seg
),
3016 bfd_errmsg (bfd_get_error ()));
3021 /* Ignore the HP type. */
3022 if (*input_line_pointer
== ',')
3023 input_line_pointer
+= 2;
3025 demand_empty_rest_of_line ();
3027 #else /* ! TC_M68K */
3028 /* The MRI assembler seems to use different forms of .sect for
3029 different targets. */
3030 as_bad ("MRI mode not supported for this target");
3031 ignore_rest_of_line ();
3032 #endif /* ! TC_M68K */
3035 /* Handle the .print pseudo-op. */
3038 s_print (int ignore ATTRIBUTE_UNUSED
)
3043 s
= demand_copy_C_string (&len
);
3046 demand_empty_rest_of_line ();
3049 /* Handle the .purgem pseudo-op. */
3052 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3054 if (is_it_end_of_statement ())
3056 demand_empty_rest_of_line ();
3066 c
= get_symbol_name (& name
);
3067 delete_macro (name
);
3068 *input_line_pointer
= c
;
3069 SKIP_WHITESPACE_AFTER_NAME ();
3071 while (*input_line_pointer
++ == ',');
3073 --input_line_pointer
;
3074 demand_empty_rest_of_line ();
3077 /* Handle the .endm/.endr pseudo-ops. */
3080 s_bad_end (int endr
)
3082 as_warn (_(".end%c encountered without preceding %s"),
3084 endr
? ".rept, .irp, or .irpc" : ".macro");
3085 demand_empty_rest_of_line ();
3088 /* Handle the .rept pseudo-op. */
3091 s_rept (int ignore ATTRIBUTE_UNUSED
)
3095 count
= (size_t) get_absolute_expression ();
3097 do_repeat (count
, "REPT", "ENDR");
3100 /* This function provides a generic repeat block implementation. It allows
3101 different directives to be used as the start/end keys. */
3104 do_repeat (size_t count
, const char *start
, const char *end
)
3109 if (((ssize_t
) count
) < 0)
3111 as_bad (_("negative count for %s - ignored"), start
);
3116 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3118 as_bad (_("%s without %s"), start
, end
);
3122 sb_build (&many
, count
* one
.len
);
3124 sb_add_sb (&many
, &one
);
3128 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3130 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3133 /* Like do_repeat except that any text matching EXPANDER in the
3134 block is replaced by the iteration count. */
3137 do_repeat_with_expander (size_t count
,
3140 const char * expander
)
3145 if (((ssize_t
) count
) < 0)
3147 as_bad (_("negative count for %s - ignored"), start
);
3152 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3154 as_bad (_("%s without %s"), start
, end
);
3160 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3162 while (count
-- > 0)
3168 sb_build (& processed
, one
.len
);
3169 sb_add_sb (& processed
, & one
);
3170 sub
= strstr (processed
.ptr
, expander
);
3171 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3172 gas_assert (len
< 8);
3173 memmove (sub
+ len
, sub
+ 8,
3174 processed
.ptr
+ processed
.len
- (sub
+ 8));
3175 processed
.len
-= (8 - len
);
3176 sb_add_sb (& many
, & processed
);
3177 sb_kill (& processed
);
3182 sb_add_sb (&many
, &one
);
3186 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3188 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3191 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3192 input buffers to skip. Assumes that conditionals preceding the loop end
3193 are properly nested.
3195 This function makes it easier to implement a premature "break" out of the
3196 loop. The EXTRA arg accounts for other buffers we might have inserted,
3197 such as line substitutions. */
3200 end_repeat (int extra
)
3202 cond_exit_macro (macro_nest
);
3203 while (extra
-- >= 0)
3204 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3208 assign_symbol (char *name
, int mode
)
3212 if (name
[0] == '.' && name
[1] == '\0')
3214 /* Turn '. = mumble' into a .org mumble. */
3218 segment
= get_known_segmented_expression (&exp
);
3221 do_org (segment
, &exp
, 0);
3226 if ((symbolP
= symbol_find (name
)) == NULL
3227 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3229 symbolP
= symbol_find_or_make (name
);
3231 /* When doing symbol listings, play games with dummy fragments living
3232 outside the normal fragment chain to record the file and line info
3234 if (listing
& LISTING_SYMBOLS
)
3236 extern struct list_info_struct
*listing_tail
;
3237 fragS
*dummy_frag
= XCNEW (fragS
);
3238 dummy_frag
->line
= listing_tail
;
3239 dummy_frag
->fr_symbol
= symbolP
;
3240 symbol_set_frag (symbolP
, dummy_frag
);
3243 #if defined (OBJ_COFF) && !defined (TE_PE)
3244 /* "set" symbols are local unless otherwise specified. */
3245 SF_SET_LOCAL (symbolP
);
3249 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3251 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3252 && !S_CAN_BE_REDEFINED (symbolP
))
3254 as_bad (_("symbol `%s' is already defined"), name
);
3255 ignore_rest_of_line ();
3256 input_line_pointer
--;
3259 /* If the symbol is volatile, copy the symbol and replace the
3260 original with the copy, so that previous uses of the symbol will
3261 retain the value of the symbol at the point of use. */
3262 else if (S_IS_VOLATILE (symbolP
))
3263 symbolP
= symbol_clone (symbolP
, 1);
3267 S_SET_VOLATILE (symbolP
);
3269 S_SET_FORWARD_REF (symbolP
);
3271 pseudo_set (symbolP
);
3274 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3275 then this is .equiv, and it is an error if the symbol is already
3276 defined. If EQUIV is -1, the symbol additionally is a forward
3284 /* Especial apologies for the random logic:
3285 this just grew, and could be parsed much more simply!
3287 if ((name
= read_symbol_name ()) == NULL
)
3290 if (*input_line_pointer
!= ',')
3292 as_bad (_("expected comma after \"%s\""), name
);
3293 ignore_rest_of_line ();
3298 input_line_pointer
++;
3299 assign_symbol (name
, equiv
);
3300 demand_empty_rest_of_line ();
3314 #ifdef md_flush_pending_output
3315 md_flush_pending_output ();
3322 # ifndef P_PRECISION
3323 # define P_PRECISION X_PRECISION
3324 # define P_PRECISION_PAD X_PRECISION_PAD
3326 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3334 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3341 #ifdef md_cons_align
3346 stop
= mri_comment_field (&stopc
);
3348 /* In m68k MRI mode, we need to align to a word boundary, unless
3350 if (flag_m68k_mri
&& mult
> 1)
3352 if (now_seg
== absolute_section
)
3354 abs_section_offset
+= abs_section_offset
& 1;
3355 if (line_label
!= NULL
)
3356 S_SET_VALUE (line_label
, abs_section_offset
);
3358 else if (mri_common_symbol
!= NULL
)
3362 mri_val
= S_GET_VALUE (mri_common_symbol
);
3363 if ((mri_val
& 1) != 0)
3365 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3366 if (line_label
!= NULL
)
3368 expressionS
*symexp
;
3370 symexp
= symbol_get_value_expression (line_label
);
3371 know (symexp
->X_op
== O_symbol
);
3372 know (symexp
->X_add_symbol
== mri_common_symbol
);
3373 symexp
->X_add_number
+= 1;
3379 do_align (1, (char *) NULL
, 0, 0);
3380 if (line_label
!= NULL
)
3382 symbol_set_frag (line_label
, frag_now
);
3383 S_SET_VALUE (line_label
, frag_now_fix ());
3393 if (*input_line_pointer
== ',')
3395 ++input_line_pointer
;
3400 val
.X_op
= O_constant
;
3401 val
.X_add_number
= 0;
3404 if ((val
.X_op
!= O_constant
3405 || val
.X_add_number
< - 0x80
3406 || val
.X_add_number
> 0xff
3407 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3408 && (now_seg
!= absolute_section
&& !in_bss ()))
3410 resolve_expression (&exp
);
3411 if (exp
.X_op
!= O_constant
)
3412 as_bad (_("unsupported variable size or fill value"));
3417 /* PR 20901: Check for excessive values.
3418 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3419 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3420 as_bad (_("size value for space directive too large: %lx"),
3421 (long) exp
.X_add_number
);
3426 bytes
= mult
* exp
.X_add_number
;
3428 for (i
= 0; i
< exp
.X_add_number
; i
++)
3429 emit_expr (&val
, mult
);
3435 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3436 resolve_expression (&exp
);
3438 if (exp
.X_op
== O_constant
)
3442 repeat
= exp
.X_add_number
;
3449 as_warn (_(".space repeat count is zero, ignored"));
3450 else if (repeat
< 0)
3451 as_warn (_(".space repeat count is negative, ignored"));
3455 /* If we are in the absolute section, just bump the offset. */
3456 if (now_seg
== absolute_section
)
3458 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3459 as_warn (_("ignoring fill value in absolute section"));
3460 abs_section_offset
+= repeat
;
3464 /* If we are secretly in an MRI common section, then
3465 creating space just increases the size of the common
3467 if (mri_common_symbol
!= NULL
)
3469 S_SET_VALUE (mri_common_symbol
,
3470 S_GET_VALUE (mri_common_symbol
) + repeat
);
3475 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3476 (offsetT
) repeat
, (char *) 0);
3480 if (now_seg
== absolute_section
)
3482 as_bad (_("space allocation too complex in absolute section"));
3483 subseg_set (text_section
, 0);
3486 if (mri_common_symbol
!= NULL
)
3488 as_bad (_("space allocation too complex in common section"));
3489 mri_common_symbol
= NULL
;
3493 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3494 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3497 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3498 as_warn (_("ignoring fill value in section `%s'"),
3499 segment_name (now_seg
));
3501 *p
= val
.X_add_number
;
3506 /* In MRI mode, after an odd number of bytes, we must align to an
3507 even word boundary, unless the next instruction is a dc.b, ds.b
3509 if (flag_mri
&& (bytes
& 1) != 0)
3510 mri_pending_align
= 1;
3512 demand_empty_rest_of_line ();
3515 mri_comment_end (stop
, stopc
);
3519 s_nop (int ignore ATTRIBUTE_UNUSED
)
3526 #ifdef md_flush_pending_output
3527 md_flush_pending_output ();
3530 #ifdef md_cons_align
3536 demand_empty_rest_of_line ();
3539 start_off
= frag_now_fix ();
3542 #ifdef md_emit_single_noop
3543 md_emit_single_noop
;
3547 #ifndef md_single_noop_insn
3548 #define md_single_noop_insn "nop"
3550 /* md_assemble might modify its argument, so
3551 we must pass it a string that is writable. */
3552 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3553 as_fatal ("%s", xstrerror (errno
));
3555 /* Some targets assume that they can update input_line_pointer
3556 inside md_assemble, and, worse, that they can leave it
3557 assigned to the string pointer that was provided as an
3558 argument. So preserve ilp here. */
3559 char *saved_ilp
= input_line_pointer
;
3561 input_line_pointer
= saved_ilp
;
3564 #ifdef md_flush_pending_output
3565 md_flush_pending_output ();
3567 } while (exp
.X_op
== O_constant
3568 && exp
.X_add_number
> 0
3569 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3570 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3574 s_nops (int ignore ATTRIBUTE_UNUSED
)
3579 #ifdef md_flush_pending_output
3580 md_flush_pending_output ();
3583 #ifdef md_cons_align
3589 /* Note - this expression is tested for an absolute value in
3590 write.c:relax_segment(). */
3593 if (*input_line_pointer
== ',')
3595 ++input_line_pointer
;
3600 val
.X_op
= O_constant
;
3601 val
.X_add_number
= 0;
3604 if (val
.X_op
!= O_constant
)
3606 as_bad (_("unsupported variable nop control in .nops directive"));
3607 val
.X_op
= O_constant
;
3608 val
.X_add_number
= 0;
3610 else if (val
.X_add_number
< 0)
3612 as_warn (_("negative nop control byte, ignored"));
3613 val
.X_add_number
= 0;
3616 demand_empty_rest_of_line ();
3619 /* Ignore this directive if we are going to perform a second pass. */
3622 /* Store the no-op instruction control byte in the first byte of frag. */
3624 symbolS
*sym
= make_expr_symbol (&exp
);
3625 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3626 sym
, (offsetT
) 0, (char *) 0);
3627 *p
= val
.X_add_number
;
3630 /* Obtain the size of a floating point number, given a type. */
3633 float_length (int float_type
, int *pad_p
)
3635 int length
, pad
= 0;
3663 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3664 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3673 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3674 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3681 as_bad (_("unknown floating type '%c'"), float_type
);
3693 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3699 /* Skip any 0{letter} that may be present. Don't even check if the
3700 letter is legal. Someone may invent a "z" format and this routine
3701 has no use for such information. Lusers beware: you get
3702 diagnostics if your input is ill-conditioned. */
3703 if (input_line_pointer
[0] == '0'
3704 && ISALPHA (input_line_pointer
[1]))
3705 input_line_pointer
+= 2;
3707 /* Accept :xxxx, where the x's are hex digits, for a floating point
3708 with the exact digits specified. */
3709 if (input_line_pointer
[0] == ':')
3711 ++input_line_pointer
;
3712 length
= hex_float (float_type
, temp
);
3715 ignore_rest_of_line ();
3723 err
= md_atof (float_type
, temp
, &length
);
3724 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3725 know (err
!= NULL
|| length
> 0);
3728 as_bad (_("bad floating literal: %s"), err
);
3729 ignore_rest_of_line ();
3737 /* This is like s_space, but the value is a floating point number with
3738 the given precision. This is for the MRI dcb.s pseudo-op and
3742 s_float_space (int float_type
)
3746 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3750 #ifdef md_cons_align
3755 stop
= mri_comment_field (&stopc
);
3757 count
= get_absolute_expression ();
3760 if (*input_line_pointer
!= ',')
3764 flen
= float_length (float_type
, &pad
);
3766 memset (temp
, 0, flen
+= pad
);
3770 ++input_line_pointer
;
3772 flen
= parse_one_float (float_type
, temp
);
3778 mri_comment_end (stop
, stopc
);
3782 while (--count
>= 0)
3786 p
= frag_more (flen
);
3787 memcpy (p
, temp
, (unsigned int) flen
);
3790 demand_empty_rest_of_line ();
3793 mri_comment_end (stop
, stopc
);
3796 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3799 s_struct (int ignore ATTRIBUTE_UNUSED
)
3805 stop
= mri_comment_field (&stopc
);
3806 abs_section_offset
= get_absolute_expression ();
3807 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3808 /* The ELF backend needs to know that we are changing sections, so
3809 that .previous works correctly. */
3811 obj_elf_section_change_hook ();
3813 subseg_set (absolute_section
, 0);
3814 demand_empty_rest_of_line ();
3816 mri_comment_end (stop
, stopc
);
3820 s_text (int ignore ATTRIBUTE_UNUSED
)
3824 temp
= get_absolute_expression ();
3825 subseg_set (text_section
, (subsegT
) temp
);
3826 demand_empty_rest_of_line ();
3829 /* .weakref x, y sets x as an alias to y that, as long as y is not
3830 referenced directly, will cause y to become a weak symbol. */
3832 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3839 if ((name
= read_symbol_name ()) == NULL
)
3842 symbolP
= symbol_find_or_make (name
);
3844 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3846 if (!S_IS_VOLATILE (symbolP
))
3848 as_bad (_("symbol `%s' is already defined"), name
);
3851 symbolP
= symbol_clone (symbolP
, 1);
3852 S_CLEAR_VOLATILE (symbolP
);
3857 if (*input_line_pointer
!= ',')
3859 as_bad (_("expected comma after \"%s\""), name
);
3863 input_line_pointer
++;
3868 if ((name
= read_symbol_name ()) == NULL
)
3871 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3872 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3874 symbolP2
= symbol_find_or_make (name
);
3875 S_SET_WEAKREFD (symbolP2
);
3879 symbolS
*symp
= symbolP2
;
3881 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3883 expressionS
*expP
= symbol_get_value_expression (symp
);
3885 gas_assert (expP
->X_op
== O_symbol
3886 && expP
->X_add_number
== 0);
3887 symp
= expP
->X_add_symbol
;
3889 if (symp
== symbolP
)
3893 loop
= concat (S_GET_NAME (symbolP
),
3894 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3897 while (symp
!= symbolP
)
3899 char *old_loop
= loop
;
3901 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3902 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3903 (const char *) NULL
);
3907 as_bad (_("%s: would close weakref loop: %s"),
3908 S_GET_NAME (symbolP
), loop
);
3912 ignore_rest_of_line ();
3916 /* Short-circuiting instead of just checking here might speed
3917 things up a tiny little bit, but loop error messages would
3918 miss intermediate links. */
3919 /* symbolP2 = symp; */
3922 memset (&exp
, 0, sizeof (exp
));
3923 exp
.X_op
= O_symbol
;
3924 exp
.X_add_symbol
= symbolP2
;
3926 S_SET_SEGMENT (symbolP
, undefined_section
);
3927 symbol_set_value_expression (symbolP
, &exp
);
3928 symbol_set_frag (symbolP
, &zero_address_frag
);
3929 S_SET_WEAKREFR (symbolP
);
3931 demand_empty_rest_of_line ();
3936 ignore_rest_of_line ();
3942 /* Verify that we are at the end of a line. If not, issue an error and
3943 skip to EOL. This function may leave input_line_pointer one past
3944 buffer_limit, so should not be called from places that may
3945 dereference input_line_pointer unconditionally. Note that when the
3946 gas parser is switched to handling a string (where buffer_limit
3947 should be the size of the string excluding the NUL terminator) this
3948 will be one past the NUL; is_end_of_line(0) returns true. */
3951 demand_empty_rest_of_line (void)
3954 if (input_line_pointer
> buffer_limit
)
3956 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3957 input_line_pointer
++;
3960 if (ISPRINT (*input_line_pointer
))
3961 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3962 *input_line_pointer
);
3964 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3965 *input_line_pointer
);
3966 ignore_rest_of_line ();
3968 /* Return pointing just after end-of-line. */
3971 /* Silently advance to the end of line. Use this after already having
3972 issued an error about something bad. Like demand_empty_rest_of_line,
3973 this function may leave input_line_pointer one after buffer_limit;
3974 Don't call it from within expression parsing code in an attempt to
3975 silence further errors. */
3978 ignore_rest_of_line (void)
3980 while (input_line_pointer
<= buffer_limit
)
3981 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3983 /* Return pointing just after end-of-line. */
3986 /* Sets frag for given symbol to zero_address_frag, except when the
3987 symbol frag is already set to a dummy listing frag. */
3990 set_zero_frag (symbolS
*symbolP
)
3992 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3993 symbol_set_frag (symbolP
, &zero_address_frag
);
3996 /* In: Pointer to a symbol.
3997 Input_line_pointer->expression.
3999 Out: Input_line_pointer->just after any whitespace after expression.
4000 Tried to set symbol to value of expression.
4001 Will change symbols type, value, and frag; */
4004 pseudo_set (symbolS
*symbolP
)
4009 know (symbolP
); /* NULL pointer is logic error. */
4011 if (!S_IS_FORWARD_REF (symbolP
))
4012 (void) expression (&exp
);
4014 (void) deferred_expression (&exp
);
4016 if (exp
.X_op
== O_illegal
)
4017 as_bad (_("illegal expression"));
4018 else if (exp
.X_op
== O_absent
)
4019 as_bad (_("missing expression"));
4020 else if (exp
.X_op
== O_big
)
4022 if (exp
.X_add_number
> 0)
4023 as_bad (_("bignum invalid"));
4025 as_bad (_("floating point number invalid"));
4027 else if (exp
.X_op
== O_subtract
4028 && !S_IS_FORWARD_REF (symbolP
)
4029 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
4030 && (symbol_get_frag (exp
.X_add_symbol
)
4031 == symbol_get_frag (exp
.X_op_symbol
)))
4033 exp
.X_op
= O_constant
;
4034 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
4035 - S_GET_VALUE (exp
.X_op_symbol
));
4038 if (symbol_section_p (symbolP
))
4040 as_bad ("attempt to set value of section symbol");
4049 exp
.X_add_number
= 0;
4052 S_SET_SEGMENT (symbolP
, absolute_section
);
4053 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4054 set_zero_frag (symbolP
);
4058 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
4059 if (S_IS_EXTERNAL (symbolP
))
4061 as_bad ("can't equate global symbol `%s' with register name",
4062 S_GET_NAME (symbolP
));
4066 S_SET_SEGMENT (symbolP
, reg_section
);
4067 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4068 set_zero_frag (symbolP
);
4069 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
4073 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4074 /* For x=undef+const, create an expression symbol.
4075 For x=x+const, just update x except when x is an undefined symbol
4076 For x=defined+const, evaluate x. */
4077 if (symbolP
== exp
.X_add_symbol
4078 && (seg
!= undefined_section
4079 || !symbol_constant_p (symbolP
)))
4081 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4084 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4086 symbolS
*s
= exp
.X_add_symbol
;
4088 if (S_IS_COMMON (s
))
4089 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4090 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4092 S_SET_SEGMENT (symbolP
, seg
);
4093 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4094 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4095 copy_symbol_attributes (symbolP
, s
);
4098 S_SET_SEGMENT (symbolP
, undefined_section
);
4099 symbol_set_value_expression (symbolP
, &exp
);
4100 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4101 set_zero_frag (symbolP
);
4105 /* The value is some complex expression. */
4106 S_SET_SEGMENT (symbolP
, expr_section
);
4107 symbol_set_value_expression (symbolP
, &exp
);
4108 set_zero_frag (symbolP
);
4115 CONStruct more frag of .bytes, or .words etc.
4116 Should need_pass_2 be 1 then emit no frag(s).
4117 This understands EXPRESSIONS.
4121 This has a split personality. We use expression() to read the
4122 value. We can detect if the value won't fit in a byte or word.
4123 But we can't detect if expression() discarded significant digits
4124 in the case of a long. Not worth the crocks required to fix it. */
4126 /* Select a parser for cons expressions. */
4128 /* Some targets need to parse the expression in various fancy ways.
4129 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4130 (for example, the HPPA does this). Otherwise, you can define
4131 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4132 are defined, which is the normal case, then only simple expressions
4137 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4140 #ifndef TC_PARSE_CONS_EXPRESSION
4141 #ifdef REPEAT_CONS_EXPRESSIONS
4142 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4143 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4145 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4148 /* If we haven't gotten one yet, just call expression. */
4149 #ifndef TC_PARSE_CONS_EXPRESSION
4150 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4151 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4156 do_parse_cons_expression (expressionS
*exp
,
4157 int nbytes ATTRIBUTE_UNUSED
)
4159 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4163 /* Worker to do .byte etc statements.
4164 Clobbers input_line_pointer and checks end-of-line. */
4167 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4175 #ifdef md_flush_pending_output
4176 md_flush_pending_output ();
4180 stop
= mri_comment_field (&stopc
);
4182 if (is_it_end_of_statement ())
4184 demand_empty_rest_of_line ();
4186 mri_comment_end (stop
, stopc
);
4191 nbytes
= TC_ADDRESS_BYTES ();
4193 #ifdef md_cons_align
4194 md_cons_align (nbytes
);
4200 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4201 #ifdef TC_CONS_FIX_CHECK
4202 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4204 if (*cur_fix
!= NULL
)
4205 cur_fix
= &(*cur_fix
)->fx_next
;
4210 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4215 if (*input_line_pointer
== '"')
4217 as_bad (_("unexpected `\"' in expression"));
4218 ignore_rest_of_line ();
4222 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4227 if (exp
.X_op
== O_symbol
)
4228 exp
.X_op
= O_symbol_rva
;
4230 as_fatal (_("rva without symbol"));
4232 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4233 #ifdef TC_CONS_FIX_CHECK
4234 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4238 while (*input_line_pointer
++ == ',');
4240 /* In MRI mode, after an odd number of bytes, we must align to an
4241 even word boundary, unless the next instruction is a dc.b, ds.b
4243 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4244 mri_pending_align
= 1;
4246 input_line_pointer
--; /* Put terminator back into stream. */
4248 demand_empty_rest_of_line ();
4251 mri_comment_end (stop
, stopc
);
4257 cons_worker (size
, 0);
4263 cons_worker (size
, 1);
4266 /* .reloc offset, reloc_name, symbol+addend. */
4269 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4276 struct reloc_list
*reloc
;
4277 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4278 static struct _bfd_rel bfd_relocs
[] =
4280 { "NONE", BFD_RELOC_NONE
},
4281 { "8", BFD_RELOC_8
},
4282 { "16", BFD_RELOC_16
},
4283 { "32", BFD_RELOC_32
},
4284 { "64", BFD_RELOC_64
}
4287 reloc
= XNEW (struct reloc_list
);
4290 stop
= mri_comment_field (&stopc
);
4299 as_bad (_("missing or bad offset expression"));
4302 exp
.X_add_symbol
= section_symbol (now_seg
);
4303 /* Mark the section symbol used in relocation so that it will be
4304 included in the symbol table. */
4305 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4306 exp
.X_op
= O_symbol
;
4309 if (exp
.X_add_number
== 0)
4311 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4316 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4321 if (*input_line_pointer
!= ',')
4323 as_bad (_("missing reloc type"));
4327 ++input_line_pointer
;
4329 c
= get_symbol_name (& r_name
);
4330 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4334 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4335 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4337 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4338 bfd_relocs
[i
].code
);
4343 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4344 *input_line_pointer
= c
;
4345 if (reloc
->u
.a
.howto
== NULL
)
4347 as_bad (_("unrecognized reloc type"));
4351 exp
.X_op
= O_absent
;
4352 SKIP_WHITESPACE_AFTER_NAME ();
4353 if (*input_line_pointer
== ',')
4355 ++input_line_pointer
;
4363 as_bad (_("bad reloc expression"));
4365 ignore_rest_of_line ();
4368 mri_comment_end (stop
, stopc
);
4371 reloc
->u
.a
.sym
= NULL
;
4372 reloc
->u
.a
.addend
= 0;
4375 reloc
->u
.a
.sym
= NULL
;
4376 reloc
->u
.a
.addend
= exp
.X_add_number
;
4379 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4380 reloc
->u
.a
.addend
= exp
.X_add_number
;
4383 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4384 reloc
->u
.a
.addend
= 0;
4388 reloc
->file
= as_where (&reloc
->line
);
4389 reloc
->next
= reloc_list
;
4392 demand_empty_rest_of_line ();
4394 mri_comment_end (stop
, stopc
);
4397 /* Put the contents of expression EXP into the object file using
4398 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4401 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4403 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4407 emit_expr_with_reloc (expressionS
*exp
,
4408 unsigned int nbytes
,
4409 TC_PARSE_CONS_RETURN_TYPE reloc
)
4413 valueT extra_digit
= 0;
4415 /* Don't do anything if we are going to make another pass. */
4420 dot_value
= frag_now_fix ();
4421 dot_frag
= frag_now
;
4425 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4426 appear as a four byte positive constant in the .line section,
4427 followed by a 2 byte 0xffff. Look for that case here. */
4429 static int dwarf_line
= -1;
4431 if (strcmp (segment_name (now_seg
), ".line") != 0)
4433 else if (dwarf_line
>= 0
4435 && exp
->X_op
== O_constant
4436 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4437 listing_source_line ((unsigned int) dwarf_line
);
4438 else if (nbytes
== 4
4439 && exp
->X_op
== O_constant
4440 && exp
->X_add_number
>= 0)
4441 dwarf_line
= exp
->X_add_number
;
4446 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4447 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4448 AT_sibling (0x12) followed by a four byte address of the sibling
4449 followed by a 2 byte AT_name (0x38) followed by the name of the
4450 file. We look for that case here. */
4452 static int dwarf_file
= 0;
4454 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4456 else if (dwarf_file
== 0
4458 && exp
->X_op
== O_constant
4459 && exp
->X_add_number
== 0x11)
4461 else if (dwarf_file
== 1
4463 && exp
->X_op
== O_constant
4464 && exp
->X_add_number
== 0x12)
4466 else if (dwarf_file
== 2
4469 else if (dwarf_file
== 3
4471 && exp
->X_op
== O_constant
4472 && exp
->X_add_number
== 0x38)
4477 /* The variable dwarf_file_string tells stringer that the string
4478 may be the name of the source file. */
4479 if (dwarf_file
== 4)
4480 dwarf_file_string
= 1;
4482 dwarf_file_string
= 0;
4487 if (check_eh_frame (exp
, &nbytes
))
4492 /* Handle a negative bignum. */
4494 && exp
->X_add_number
== 0
4495 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4496 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4499 unsigned long carry
;
4501 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4503 /* Negate the bignum: one's complement each digit and add 1. */
4505 for (i
= 0; i
< exp
->X_add_number
; i
++)
4509 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4512 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4513 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4516 /* We can ignore any carry out, because it will be handled by
4517 extra_digit if it is needed. */
4519 extra_digit
= (valueT
) -1;
4523 if (op
== O_absent
|| op
== O_illegal
)
4525 as_warn (_("zero assumed for missing expression"));
4526 exp
->X_add_number
= 0;
4529 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4531 as_bad (_("floating point number invalid"));
4532 exp
->X_add_number
= 0;
4535 else if (op
== O_register
)
4537 as_warn (_("register value used as expression"));
4541 /* Allow `.word 0' in the absolute section. */
4542 if (now_seg
== absolute_section
)
4544 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4545 as_bad (_("attempt to store value in absolute section"));
4546 abs_section_offset
+= nbytes
;
4550 /* Allow `.word 0' in BSS style sections. */
4551 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4552 as_bad (_("attempt to store non-zero value in section `%s'"),
4553 segment_name (now_seg
));
4555 p
= frag_more ((int) nbytes
);
4557 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4559 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4563 #ifndef WORKING_DOT_WORD
4564 /* If we have the difference of two symbols in a word, save it on
4565 the broken_words list. See the code in write.c. */
4566 if (op
== O_subtract
&& nbytes
== 2)
4568 struct broken_word
*x
;
4570 x
= XNEW (struct broken_word
);
4571 x
->next_broken_word
= broken_words
;
4574 x
->subseg
= now_subseg
;
4576 x
->word_goes_here
= p
;
4578 x
->add
= exp
->X_add_symbol
;
4579 x
->sub
= exp
->X_op_symbol
;
4580 x
->addnum
= exp
->X_add_number
;
4588 /* If we have an integer, but the number of bytes is too large to
4589 pass to md_number_to_chars, handle it as a bignum. */
4590 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4592 extra_digit
= exp
->X_unsigned
? 0 : -1;
4593 convert_to_bignum (exp
, !exp
->X_unsigned
);
4597 if (op
== O_constant
)
4604 /* JF << of >= number of bits in the object is undefined. In
4605 particular SPARC (Sun 4) has problems. */
4606 if (nbytes
>= sizeof (valueT
))
4608 know (nbytes
== sizeof (valueT
));
4613 /* Don't store these bits. */
4614 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4617 unmask
= ~mask
; /* Do store these bits. */
4620 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4621 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4624 get
= exp
->X_add_number
;
4626 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4631 /* These buffers help to ease the translation of the warning message. */
4632 sprintf_vma (get_buf
, get
);
4633 sprintf_vma (use_buf
, use
);
4634 /* Leading bits contain both 0s & 1s. */
4635 as_warn (_("value 0x%s truncated to 0x%s"), get_buf
, use_buf
);
4637 /* Put bytes in right order. */
4638 md_number_to_chars (p
, use
, (int) nbytes
);
4640 else if (op
== O_big
)
4643 LITTLENUM_TYPE
*nums
;
4645 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4648 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4652 LITTLENUM_TYPE sign
= 0;
4653 if ((generic_bignum
[--i
]
4654 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4655 sign
= ~(LITTLENUM_TYPE
) 0;
4657 while (++i
< exp
->X_add_number
)
4658 if (generic_bignum
[i
] != sign
)
4661 else if (nbytes
== 1)
4663 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4664 Check that bits 8.. of generic_bignum[0] match bit 7
4665 and that they match all of generic_bignum[1..exp->X_add_number]. */
4666 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4667 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4669 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4671 while (++i
< exp
->X_add_number
)
4672 if (generic_bignum
[i
] != sign
)
4677 if (i
< exp
->X_add_number
)
4678 as_warn (ngettext ("bignum truncated to %d byte",
4679 "bignum truncated to %d bytes",
4687 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4690 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4692 if (target_big_endian
)
4694 while (nbytes
> size
)
4696 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4697 nbytes
-= CHARS_PER_LITTLENUM
;
4698 p
+= CHARS_PER_LITTLENUM
;
4701 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4702 while (size
>= CHARS_PER_LITTLENUM
)
4705 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4706 size
-= CHARS_PER_LITTLENUM
;
4707 p
+= CHARS_PER_LITTLENUM
;
4712 nums
= generic_bignum
;
4713 while (size
>= CHARS_PER_LITTLENUM
)
4715 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4717 size
-= CHARS_PER_LITTLENUM
;
4718 p
+= CHARS_PER_LITTLENUM
;
4719 nbytes
-= CHARS_PER_LITTLENUM
;
4722 while (nbytes
>= CHARS_PER_LITTLENUM
)
4724 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4725 nbytes
-= CHARS_PER_LITTLENUM
;
4726 p
+= CHARS_PER_LITTLENUM
;
4731 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4735 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4736 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4739 unsigned int size
= nbytes
;
4741 memset (p
, 0, size
);
4743 /* Generate a fixS to record the symbol value. */
4745 #ifdef TC_CONS_FIX_NEW
4746 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4748 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4750 reloc_howto_type
*reloc_howto
;
4752 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4753 size
= bfd_get_reloc_size (reloc_howto
);
4757 as_bad (ngettext ("%s relocations do not fit in %u byte",
4758 "%s relocations do not fit in %u bytes",
4760 reloc_howto
->name
, nbytes
);
4763 else if (target_big_endian
)
4764 offset
= nbytes
- size
;
4785 as_bad (_("unsupported BFD relocation size %u"), size
);
4788 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4793 /* Handle an MRI style string expression. */
4797 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4799 if (*input_line_pointer
!= '\''
4800 && (input_line_pointer
[1] != '\''
4801 || (*input_line_pointer
!= 'A'
4802 && *input_line_pointer
!= 'E')))
4803 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4807 unsigned int result
= 0;
4809 /* An MRI style string. Cut into as many bytes as will fit into
4810 a nbyte chunk, left justify if necessary, and separate with
4811 commas so we can try again later. */
4812 if (*input_line_pointer
== 'A')
4813 ++input_line_pointer
;
4814 else if (*input_line_pointer
== 'E')
4816 as_bad (_("EBCDIC constants are not supported"));
4817 ++input_line_pointer
;
4820 input_line_pointer
++;
4821 for (scan
= 0; scan
< nbytes
; scan
++)
4823 if (*input_line_pointer
== '\'')
4825 if (input_line_pointer
[1] == '\'')
4827 input_line_pointer
++;
4832 result
= (result
<< 8) | (*input_line_pointer
++);
4836 while (scan
< nbytes
)
4842 /* Create correct expression. */
4843 exp
->X_op
= O_constant
;
4844 exp
->X_add_number
= result
;
4846 /* Fake it so that we can read the next char too. */
4847 if (input_line_pointer
[0] != '\'' ||
4848 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4850 input_line_pointer
-= 2;
4851 input_line_pointer
[0] = ',';
4852 input_line_pointer
[1] = '\'';
4855 input_line_pointer
++;
4858 #endif /* TC_M68K */
4860 #ifdef REPEAT_CONS_EXPRESSIONS
4862 /* Parse a repeat expression for cons. This is used by the MIPS
4863 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4864 object file COUNT times.
4866 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4869 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4876 if (*input_line_pointer
!= ':')
4878 /* No repeat count. */
4882 ++input_line_pointer
;
4883 expression (&count
);
4884 if (count
.X_op
!= O_constant
4885 || count
.X_add_number
<= 0)
4887 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4891 /* The cons function is going to output this expression once. So we
4892 output it count - 1 times. */
4893 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4894 emit_expr (exp
, nbytes
);
4897 #endif /* REPEAT_CONS_EXPRESSIONS */
4899 /* Parse a floating point number represented as a hex constant. This
4900 permits users to specify the exact bits they want in the floating
4904 hex_float (int float_type
, char *bytes
)
4906 int pad
, length
= float_length (float_type
, &pad
);
4912 /* It would be nice if we could go through expression to parse the
4913 hex constant, but if we get a bignum it's a pain to sort it into
4914 the buffer correctly. */
4916 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4920 /* The MRI assembler accepts arbitrary underscores strewn about
4921 through the hex constant, so we ignore them as well. */
4922 if (*input_line_pointer
== '_')
4924 ++input_line_pointer
;
4930 as_warn (_("floating point constant too large"));
4933 d
= hex_value (*input_line_pointer
) << 4;
4934 ++input_line_pointer
;
4935 while (*input_line_pointer
== '_')
4936 ++input_line_pointer
;
4937 if (hex_p (*input_line_pointer
))
4939 d
+= hex_value (*input_line_pointer
);
4940 ++input_line_pointer
;
4942 if (target_big_endian
)
4945 bytes
[length
- i
- 1] = d
;
4951 if (target_big_endian
)
4952 memset (bytes
+ i
, 0, length
- i
);
4954 memset (bytes
, 0, length
- i
);
4957 memset (bytes
+ length
, 0, pad
);
4959 return length
+ pad
;
4964 CONStruct some more frag chars of .floats .ffloats etc.
4965 Makes 0 or more new frags.
4966 If need_pass_2 == 1, no frags are emitted.
4967 This understands only floating literals, not expressions. Sorry.
4969 A floating constant is defined by atof_generic(), except it is preceded
4970 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4971 reading, I decided to be incompatible. This always tries to give you
4972 rounded bits to the precision of the pseudo-op. Former AS did premature
4973 truncation, restored noisy bits instead of trailing 0s AND gave you
4974 a choice of 2 flavours of noise according to which of 2 floating-point
4975 scanners you directed AS to use.
4977 In: input_line_pointer->whitespace before, or '0' of flonum. */
4980 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4981 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4984 int length
; /* Number of chars in an object. */
4985 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4987 if (is_it_end_of_statement ())
4989 demand_empty_rest_of_line ();
4993 if (now_seg
== absolute_section
)
4995 as_bad (_("attempt to store float in absolute section"));
4996 ignore_rest_of_line ();
5002 as_bad (_("attempt to store float in section `%s'"),
5003 segment_name (now_seg
));
5004 ignore_rest_of_line ();
5008 #ifdef md_flush_pending_output
5009 md_flush_pending_output ();
5012 #ifdef md_cons_align
5018 length
= parse_one_float (float_type
, temp
);
5028 #ifdef REPEAT_CONS_EXPRESSIONS
5029 if (*input_line_pointer
== ':')
5031 expressionS count_exp
;
5033 ++input_line_pointer
;
5034 expression (&count_exp
);
5036 if (count_exp
.X_op
!= O_constant
5037 || count_exp
.X_add_number
<= 0)
5038 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5040 count
= count_exp
.X_add_number
;
5044 while (--count
>= 0)
5046 p
= frag_more (length
);
5047 memcpy (p
, temp
, (unsigned int) length
);
5052 while (*input_line_pointer
++ == ',');
5054 /* Put terminator back into stream. */
5055 --input_line_pointer
;
5056 demand_empty_rest_of_line ();
5061 Note - we are using the DWARF standard's definition of LEB128 encoding
5062 where each 7-bit value is a stored in a byte, *not* an octet. This
5063 means that on targets where a byte contains multiple octets there is
5064 a *huge waste of space*. (This also means that we do not have to
5065 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5068 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5069 we would then have to consider whether multiple, successive LEB128
5070 values should be packed into the bytes without padding (bad idea) or
5071 whether each LEB128 number is padded out to a whole number of bytes.
5072 Plus you have to decide on the endianness of packing octets into a
5075 /* Return the size of a LEB128 value in bytes. */
5077 static inline unsigned int
5078 sizeof_sleb128 (offsetT value
)
5085 byte
= (value
& 0x7f);
5086 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5087 Fortunately, we can structure things so that the extra work reduces
5088 to a noop on systems that do things "properly". */
5089 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5092 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5093 || ((value
== -1) && ((byte
& 0x40) != 0))));
5098 static inline unsigned int
5099 sizeof_uleb128 (valueT value
)
5114 sizeof_leb128 (valueT value
, int sign
)
5117 return sizeof_sleb128 ((offsetT
) value
);
5119 return sizeof_uleb128 (value
);
5122 /* Output a LEB128 value. Returns the number of bytes used. */
5124 static inline unsigned int
5125 output_sleb128 (char *p
, offsetT value
)
5132 unsigned byte
= (value
& 0x7f);
5134 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5135 Fortunately, we can structure things so that the extra work reduces
5136 to a noop on systems that do things "properly". */
5137 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5139 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5140 || ((value
== -1) && ((byte
& 0x40) != 0))));
5151 static inline unsigned int
5152 output_uleb128 (char *p
, valueT value
)
5158 unsigned byte
= (value
& 0x7f);
5162 /* More bytes to follow. */
5173 output_leb128 (char *p
, valueT value
, int sign
)
5176 return output_sleb128 (p
, (offsetT
) value
);
5178 return output_uleb128 (p
, value
);
5181 /* Do the same for bignums. We combine sizeof with output here in that
5182 we don't output for NULL values of P. It isn't really as critical as
5183 for "normal" values that this be streamlined. Returns the number of
5186 static inline unsigned int
5187 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5194 /* Strip leading sign extensions off the bignum. */
5196 && bignum
[size
- 1] == LITTLENUM_MASK
5197 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5202 /* OR in the next part of the littlenum. */
5203 val
|= (*bignum
<< loaded
);
5204 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5208 /* Add bytes until there are less than 7 bits left in VAL
5209 or until every non-sign bit has been written. */
5216 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5223 while ((byte
& 0x80) != 0 && loaded
>= 7);
5227 /* Mop up any left-over bits (of which there will be less than 7). */
5228 if ((byte
& 0x80) != 0)
5230 /* Sign-extend VAL. */
5231 if (val
& (1 << (loaded
- 1)))
5232 val
|= ~0U << loaded
;
5241 static inline unsigned int
5242 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5249 /* Strip leading zeros off the bignum. */
5250 /* XXX: Is this needed? */
5251 while (size
> 0 && bignum
[size
- 1] == 0)
5256 if (loaded
< 7 && size
> 0)
5258 val
|= (*bignum
<< loaded
);
5259 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5268 if (size
> 0 || val
)
5275 while (byte
& 0x80);
5281 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5284 return output_big_sleb128 (p
, bignum
, size
);
5286 return output_big_uleb128 (p
, bignum
, size
);
5289 /* Generate the appropriate fragments for a given expression to emit a
5290 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5293 emit_leb128_expr (expressionS
*exp
, int sign
)
5295 operatorT op
= exp
->X_op
;
5296 unsigned int nbytes
;
5298 if (op
== O_absent
|| op
== O_illegal
)
5300 as_warn (_("zero assumed for missing expression"));
5301 exp
->X_add_number
= 0;
5304 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5306 as_bad (_("floating point number invalid"));
5307 exp
->X_add_number
= 0;
5310 else if (op
== O_register
)
5312 as_warn (_("register value used as expression"));
5315 else if (op
== O_constant
5317 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5319 /* We're outputting a signed leb128 and the sign of X_add_number
5320 doesn't reflect the sign of the original value. Convert EXP
5321 to a correctly-extended bignum instead. */
5322 convert_to_bignum (exp
, exp
->X_extrabit
);
5326 if (now_seg
== absolute_section
)
5328 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5329 as_bad (_("attempt to store value in absolute section"));
5330 abs_section_offset
++;
5334 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5335 as_bad (_("attempt to store non-zero value in section `%s'"),
5336 segment_name (now_seg
));
5338 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5339 a signal that this is leb128 data. It shouldn't optimize this away. */
5340 nbytes
= (unsigned int) -1;
5341 if (check_eh_frame (exp
, &nbytes
))
5344 /* Let the backend know that subsequent data may be byte aligned. */
5345 #ifdef md_cons_align
5349 if (op
== O_constant
)
5351 /* If we've got a constant, emit the thing directly right now. */
5353 valueT value
= exp
->X_add_number
;
5357 size
= sizeof_leb128 (value
, sign
);
5358 p
= frag_more (size
);
5359 if (output_leb128 (p
, value
, sign
) > size
)
5362 else if (op
== O_big
)
5364 /* O_big is a different sort of constant. */
5365 int nbr_digits
= exp
->X_add_number
;
5369 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5370 a signed number. Unary operators like - or ~ always extend the
5371 bignum to its largest size. */
5373 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5374 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5375 generic_bignum
[nbr_digits
++] = 0;
5377 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5378 p
= frag_more (size
);
5379 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5384 /* Otherwise, we have to create a variable sized fragment and
5385 resolve things later. */
5387 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5388 make_expr_symbol (exp
), 0, (char *) NULL
);
5392 /* Parse the .sleb128 and .uleb128 pseudos. */
5399 #ifdef md_flush_pending_output
5400 md_flush_pending_output ();
5406 emit_leb128_expr (&exp
, sign
);
5408 while (*input_line_pointer
++ == ',');
5410 input_line_pointer
--;
5411 demand_empty_rest_of_line ();
5415 stringer_append_char (int c
, int bitsize
)
5418 as_bad (_("attempt to store non-empty string in section `%s'"),
5419 segment_name (now_seg
));
5421 if (!target_big_endian
)
5422 FRAG_APPEND_1_CHAR (c
);
5427 FRAG_APPEND_1_CHAR (0);
5428 FRAG_APPEND_1_CHAR (0);
5429 FRAG_APPEND_1_CHAR (0);
5430 FRAG_APPEND_1_CHAR (0);
5433 FRAG_APPEND_1_CHAR (0);
5434 FRAG_APPEND_1_CHAR (0);
5437 FRAG_APPEND_1_CHAR (0);
5442 /* Called with invalid bitsize argument. */
5446 if (target_big_endian
)
5447 FRAG_APPEND_1_CHAR (c
);
5450 /* Worker to do .ascii etc statements.
5451 Reads 0 or more ',' separated, double-quoted strings.
5452 Caller should have checked need_pass_2 is FALSE because we don't
5454 Checks for end-of-line.
5455 BITS_APPENDZERO says how many bits are in a target char.
5456 The bottom bit is set if a NUL char should be appended to the strings. */
5459 stringer (int bits_appendzero
)
5461 const int bitsize
= bits_appendzero
& ~7;
5462 const int append_zero
= bits_appendzero
& 1;
5464 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5468 #ifdef md_flush_pending_output
5469 md_flush_pending_output ();
5472 #ifdef md_cons_align
5476 /* If we have been switched into the abs_section then we
5477 will not have an obstack onto which we can hang strings. */
5478 if (now_seg
== absolute_section
)
5480 as_bad (_("strings must be placed into a section"));
5481 ignore_rest_of_line ();
5485 /* The following awkward logic is to parse ZERO or more strings,
5486 comma separated. Recall a string expression includes spaces
5487 before the opening '\"' and spaces after the closing '\"'.
5488 We fake a leading ',' if there is (supposed to be)
5489 a 1st, expression. We keep demanding expressions for each ','. */
5490 if (is_it_end_of_statement ())
5492 c
= 0; /* Skip loop. */
5493 ++input_line_pointer
; /* Compensate for end of loop. */
5497 c
= ','; /* Do loop. */
5500 while (c
== ',' || c
== '<' || c
== '"')
5503 switch (*input_line_pointer
)
5506 ++input_line_pointer
; /*->1st char of string. */
5507 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5508 start
= input_line_pointer
;
5511 while (is_a_char (c
= next_char_of_string ()))
5512 stringer_append_char (c
, bitsize
);
5514 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5515 SKIP_ALL_WHITESPACE ();
5516 if (*input_line_pointer
== '"')
5520 stringer_append_char (0, bitsize
);
5522 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5523 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5524 will emit .string with a filename in the .debug section
5525 after a sequence of constants. See the comment in
5526 emit_expr for the sequence. emit_expr will set
5527 dwarf_file_string to non-zero if this string might be a
5528 source file name. */
5529 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5530 dwarf_file_string
= 0;
5531 else if (dwarf_file_string
)
5533 c
= input_line_pointer
[-1];
5534 input_line_pointer
[-1] = '\0';
5535 listing_source_file (start
);
5536 input_line_pointer
[-1] = c
;
5542 input_line_pointer
++;
5543 c
= get_single_number ();
5544 stringer_append_char (c
, bitsize
);
5545 if (*input_line_pointer
!= '>')
5547 as_bad (_("expected <nn>"));
5548 ignore_rest_of_line ();
5551 input_line_pointer
++;
5554 input_line_pointer
++;
5558 c
= *input_line_pointer
;
5561 demand_empty_rest_of_line ();
5564 /* FIXME-SOMEDAY: I had trouble here on characters with the
5565 high bits set. We'll probably also have trouble with
5566 multibyte chars, wide chars, etc. Also be careful about
5567 returning values bigger than 1 byte. xoxorich. */
5570 next_char_of_string (void)
5574 c
= *input_line_pointer
++ & CHAR_MASK
;
5578 /* PR 20902: Do not advance past the end of the buffer. */
5579 -- input_line_pointer
;
5588 as_warn (_("unterminated string; newline inserted"));
5589 bump_line_counters ();
5593 if (!TC_STRING_ESCAPES
)
5595 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5623 break; /* As itself. */
5639 for (i
= 0, number
= 0;
5640 ISDIGIT (c
) && i
< 3;
5641 c
= *input_line_pointer
++, i
++)
5643 number
= number
* 8 + c
- '0';
5646 c
= number
& CHAR_MASK
;
5648 --input_line_pointer
;
5657 c
= *input_line_pointer
++;
5658 while (ISXDIGIT (c
))
5661 number
= number
* 16 + c
- '0';
5662 else if (ISUPPER (c
))
5663 number
= number
* 16 + c
- 'A' + 10;
5665 number
= number
* 16 + c
- 'a' + 10;
5666 c
= *input_line_pointer
++;
5668 c
= number
& CHAR_MASK
;
5669 --input_line_pointer
;
5674 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5675 as_warn (_("unterminated string; newline inserted"));
5677 bump_line_counters ();
5681 /* Do not advance past the end of the buffer. */
5682 -- input_line_pointer
;
5688 #ifdef ONLY_STANDARD_ESCAPES
5689 as_bad (_("bad escaped character in string"));
5691 #endif /* ONLY_STANDARD_ESCAPES */
5704 get_segmented_expression (expressionS
*expP
)
5708 retval
= expression (expP
);
5709 if (expP
->X_op
== O_illegal
5710 || expP
->X_op
== O_absent
5711 || expP
->X_op
== O_big
)
5713 as_bad (_("expected address expression"));
5714 expP
->X_op
= O_constant
;
5715 expP
->X_add_number
= 0;
5716 retval
= absolute_section
;
5722 get_known_segmented_expression (expressionS
*expP
)
5724 segT retval
= get_segmented_expression (expP
);
5726 if (retval
== undefined_section
)
5728 /* There is no easy way to extract the undefined symbol from the
5730 if (expP
->X_add_symbol
!= NULL
5731 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5732 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5733 S_GET_NAME (expP
->X_add_symbol
));
5735 as_warn (_("some symbol undefined; zero assumed"));
5736 retval
= absolute_section
;
5737 expP
->X_op
= O_constant
;
5738 expP
->X_add_number
= 0;
5743 char /* Return terminator. */
5744 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5746 /* FIXME: val_pointer should probably be offsetT *. */
5747 *val_pointer
= (long) get_absolute_expression ();
5748 return (*input_line_pointer
++);
5751 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5752 Give a warning if that happens. */
5755 demand_copy_C_string (int *len_pointer
)
5759 if ((s
= demand_copy_string (len_pointer
)) != 0)
5763 for (len
= *len_pointer
; len
> 0; len
--)
5765 if (s
[len
- 1] == 0)
5769 as_bad (_("this string may not contain \'\\0\'"));
5778 /* Demand string, but return a safe (=private) copy of the string.
5779 Return NULL if we can't read a string here. */
5782 demand_copy_string (int *lenP
)
5790 if (*input_line_pointer
== '\"')
5792 input_line_pointer
++; /* Skip opening quote. */
5794 while (is_a_char (c
= next_char_of_string ()))
5796 obstack_1grow (¬es
, c
);
5799 /* JF this next line is so demand_copy_C_string will return a
5800 null terminated string. */
5801 obstack_1grow (¬es
, '\0');
5802 retval
= (char *) obstack_finish (¬es
);
5806 as_bad (_("missing string"));
5808 ignore_rest_of_line ();
5814 /* In: Input_line_pointer->next character.
5816 Do: Skip input_line_pointer over all whitespace.
5818 Out: 1 if input_line_pointer->end-of-line. */
5821 is_it_end_of_statement (void)
5824 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5828 equals (char *sym_name
, int reassign
)
5833 input_line_pointer
++;
5834 if (*input_line_pointer
== '=')
5835 input_line_pointer
++;
5836 if (reassign
< 0 && *input_line_pointer
== '=')
5837 input_line_pointer
++;
5839 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5840 input_line_pointer
++;
5843 stop
= mri_comment_field (&stopc
);
5845 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5849 demand_empty_rest_of_line ();
5850 mri_comment_end (stop
, stopc
);
5854 /* .incbin -- include a file verbatim at the current location. */
5857 s_incbin (int x ATTRIBUTE_UNUSED
)
5868 #ifdef md_flush_pending_output
5869 md_flush_pending_output ();
5872 #ifdef md_cons_align
5877 filename
= demand_copy_string (& len
);
5878 if (filename
== NULL
)
5883 /* Look for optional skip and count. */
5884 if (* input_line_pointer
== ',')
5886 ++ input_line_pointer
;
5887 skip
= get_absolute_expression ();
5891 if (* input_line_pointer
== ',')
5893 ++ input_line_pointer
;
5895 count
= get_absolute_expression ();
5897 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5903 demand_empty_rest_of_line ();
5905 /* Try opening absolute path first, then try include dirs. */
5906 binfile
= fopen (filename
, FOPEN_RB
);
5907 if (binfile
== NULL
)
5911 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5913 for (i
= 0; i
< include_dir_count
; i
++)
5915 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5917 binfile
= fopen (path
, FOPEN_RB
);
5918 if (binfile
!= NULL
)
5922 if (binfile
== NULL
)
5923 as_bad (_("file not found: %s"), filename
);
5926 path
= xstrdup (filename
);
5931 struct stat filestat
;
5933 if (fstat (fileno (binfile
), &filestat
) != 0
5934 || ! S_ISREG (filestat
.st_mode
)
5935 || S_ISDIR (filestat
.st_mode
))
5937 as_bad (_("unable to include `%s'"), path
);
5941 register_dependency (path
);
5943 /* Compute the length of the file. */
5944 if (fseek (binfile
, 0, SEEK_END
) != 0)
5946 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5949 file_len
= ftell (binfile
);
5951 /* If a count was not specified use the remainder of the file. */
5953 count
= file_len
- skip
;
5955 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5957 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5958 skip
, count
, file_len
);
5962 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5964 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5968 /* Allocate frag space and store file contents in it. */
5969 binfrag
= frag_more (count
);
5971 bytes
= fread (binfrag
, 1, count
, binfile
);
5973 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5974 path
, bytes
, count
);
5977 if (binfile
!= NULL
)
5982 /* .include -- include a file at this point. */
5985 s_include (int arg ATTRIBUTE_UNUSED
)
5994 filename
= demand_copy_string (&i
);
5995 if (filename
== NULL
)
5997 /* demand_copy_string has already printed an error and
5998 called ignore_rest_of_line. */
6006 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
6007 && *input_line_pointer
!= ' '
6008 && *input_line_pointer
!= '\t')
6010 obstack_1grow (¬es
, *input_line_pointer
);
6011 ++input_line_pointer
;
6015 obstack_1grow (¬es
, '\0');
6016 filename
= (char *) obstack_finish (¬es
);
6017 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
6018 ++input_line_pointer
;
6021 demand_empty_rest_of_line ();
6022 path
= XNEWVEC (char, (unsigned long) i
6023 + include_dir_maxlen
+ 5 /* slop */ );
6025 for (i
= 0; i
< include_dir_count
; i
++)
6027 strcpy (path
, include_dirs
[i
]);
6029 strcat (path
, filename
);
6030 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
6040 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
6041 register_dependency (path
);
6042 input_scrub_insert_file (path
);
6046 add_include_dir (char *path
)
6050 if (include_dir_count
== 0)
6052 include_dirs
= XNEWVEC (const char *, 2);
6053 include_dirs
[0] = "."; /* Current dir. */
6054 include_dir_count
= 2;
6058 include_dir_count
++;
6059 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6063 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6066 if (i
> include_dir_maxlen
)
6067 include_dir_maxlen
= i
;
6070 /* Output debugging information to denote the source file. */
6073 generate_file_debug (void)
6075 if (debug_type
== DEBUG_STABS
)
6076 stabs_generate_asm_file ();
6079 /* Output line number debugging information for the current source line. */
6082 generate_lineno_debug (void)
6086 case DEBUG_UNSPECIFIED
:
6091 stabs_generate_asm_lineno ();
6094 ecoff_generate_asm_lineno ();
6097 /* ??? We could here indicate to dwarf2dbg.c that something
6098 has changed. However, since there is additional backend
6099 support that is required (calling dwarf2_emit_insn), we
6100 let dwarf2dbg.c call as_where on its own. */
6105 /* Output debugging information to mark a function entry point or end point.
6106 END_P is zero for .func, and non-zero for .endfunc. */
6111 do_s_func (end_p
, NULL
);
6114 /* Subroutine of s_func so targets can choose a different default prefix.
6115 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6118 do_s_func (int end_p
, const char *default_prefix
)
6120 /* Record the current function so that we can issue an error message for
6121 misplaced .func,.endfunc, and also so that .endfunc needs no
6123 static char *current_name
;
6124 static char *current_label
;
6128 if (current_name
== NULL
)
6130 as_bad (_("missing .func"));
6131 ignore_rest_of_line ();
6135 if (debug_type
== DEBUG_STABS
)
6136 stabs_generate_asm_endfunc (current_name
, current_label
);
6138 current_name
= current_label
= NULL
;
6143 char delim1
, delim2
;
6145 if (current_name
!= NULL
)
6147 as_bad (_(".endfunc missing for previous .func"));
6148 ignore_rest_of_line ();
6152 delim1
= get_symbol_name (& name
);
6153 name
= xstrdup (name
);
6154 *input_line_pointer
= delim1
;
6155 SKIP_WHITESPACE_AFTER_NAME ();
6156 if (*input_line_pointer
!= ',')
6160 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6161 as_fatal ("%s", xstrerror (errno
));
6165 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6166 /* Missing entry point, use function's name with the leading
6170 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6171 as_fatal ("%s", xstrerror (errno
));
6179 ++input_line_pointer
;
6181 delim2
= get_symbol_name (& label
);
6182 label
= xstrdup (label
);
6183 restore_line_pointer (delim2
);
6186 if (debug_type
== DEBUG_STABS
)
6187 stabs_generate_asm_func (name
, label
);
6189 current_name
= name
;
6190 current_label
= label
;
6193 demand_empty_rest_of_line ();
6196 #ifdef HANDLE_BUNDLE
6199 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6201 unsigned int align
= get_absolute_expression ();
6203 demand_empty_rest_of_line ();
6205 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6206 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6207 (unsigned int) TC_ALIGN_LIMIT
);
6209 if (bundle_lock_frag
!= NULL
)
6211 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6215 bundle_align_p2
= align
;
6219 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6221 demand_empty_rest_of_line ();
6223 if (bundle_align_p2
== 0)
6225 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6229 if (bundle_lock_depth
== 0)
6231 bundle_lock_frchain
= frchain_now
;
6232 bundle_lock_frag
= start_bundle ();
6234 ++bundle_lock_depth
;
6238 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6242 demand_empty_rest_of_line ();
6244 if (bundle_lock_frag
== NULL
)
6246 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6250 gas_assert (bundle_align_p2
> 0);
6252 gas_assert (bundle_lock_depth
> 0);
6253 if (--bundle_lock_depth
> 0)
6256 size
= pending_bundle_size (bundle_lock_frag
);
6258 if (size
> 1U << bundle_align_p2
)
6259 as_bad (_(".bundle_lock sequence is %u bytes, "
6260 "but bundle size is only %u bytes"),
6261 size
, 1u << bundle_align_p2
);
6263 finish_bundle (bundle_lock_frag
, size
);
6265 bundle_lock_frag
= NULL
;
6266 bundle_lock_frchain
= NULL
;
6269 #endif /* HANDLE_BUNDLE */
6272 s_ignore (int arg ATTRIBUTE_UNUSED
)
6274 ignore_rest_of_line ();
6278 read_print_statistics (FILE *file
)
6280 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6283 /* Inserts the given line into the input stream.
6285 This call avoids macro/conditionals nesting checking, since the contents of
6286 the line are assumed to replace the contents of a line already scanned.
6288 An appropriate use of this function would be substitution of input lines when
6289 called by md_start_line_hook(). The given line is assumed to already be
6290 properly scrubbed. */
6293 input_scrub_insert_line (const char *line
)
6296 size_t len
= strlen (line
);
6297 sb_build (&newline
, len
);
6298 sb_add_buffer (&newline
, line
, len
);
6299 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6301 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6304 /* Insert a file into the input stream; the path must resolve to an actual
6305 file; no include path searching or dependency registering is performed. */
6308 input_scrub_insert_file (char *path
)
6310 input_scrub_include_file (path
, input_line_pointer
);
6311 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6314 /* Find the end of a line, considering quotation and escaping of quotes. */
6316 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6317 # define TC_SINGLE_QUOTE_STRINGS 1
6321 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6324 char inquote
= '\0';
6327 while (!is_end_of_line
[(unsigned char) *s
]
6328 || (inquote
&& !ISCNTRL (*s
))
6329 || (inquote
== '\'' && flag_mri
)
6330 #ifdef TC_EOL_IN_INSN
6331 || (insn
&& TC_EOL_IN_INSN (s
))
6333 /* PR 6926: When we are parsing the body of a macro the sequence
6334 \@ is special - it refers to the invocation count. If the @
6335 character happens to be registered as a line-separator character
6336 by the target, then the is_end_of_line[] test above will have
6337 returned true, but we need to ignore the line separating
6338 semantics in this particular case. */
6339 || (in_macro
&& inescape
&& *s
== '@')
6342 if (mri_string
&& *s
== '\'')
6346 else if (*s
== '\\')
6350 #ifdef TC_SINGLE_QUOTE_STRINGS
6351 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6358 as_warn (_("missing closing `%c'"), inquote
);
6359 if (inescape
&& !ignore_input ())
6360 as_warn (_("stray `\\'"));
6365 find_end_of_line (char *s
, int mri_string
)
6367 return _find_end_of_line (s
, mri_string
, 0, 0);
6370 static char *saved_ilp
= NULL
;
6371 static char *saved_limit
;
6373 /* Use BUF as a temporary input pointer for calling other functions in this
6374 file. BUF must be a C string, so that its end can be found by strlen.
6375 Also sets the buffer_limit variable (local to this file) so that buffer
6376 overruns should not occur. Saves the current input line pointer so that
6377 it can be restored by calling restore_ilp().
6379 Does not support recursion. */
6382 temp_ilp (char *buf
)
6384 gas_assert (saved_ilp
== NULL
);
6385 gas_assert (buf
!= NULL
);
6387 saved_ilp
= input_line_pointer
;
6388 saved_limit
= buffer_limit
;
6389 /* Prevent the assert in restore_ilp from triggering if
6390 the input_line_pointer has not yet been initialised. */
6391 if (saved_ilp
== NULL
)
6392 saved_limit
= saved_ilp
= (char *) "";
6394 input_line_pointer
= buf
;
6395 buffer_limit
= buf
+ strlen (buf
);
6396 input_from_string
= true;
6399 /* Restore a saved input line pointer. */
6404 gas_assert (saved_ilp
!= NULL
);
6406 input_line_pointer
= saved_ilp
;
6407 buffer_limit
= saved_limit
;
6408 input_from_string
= false;