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
)
2047 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2050 expression_and_evaluate (&exp
);
2051 if (exp
.X_op
!= O_constant
)
2054 #if defined (BFD64) || LONG_MAX > INT_MAX
2055 if (exp
.X_add_number
< INT_MIN
|| exp
.X_add_number
> INT_MAX
)
2059 *flag
= exp
.X_add_number
;
2064 /* Handle the .linefile pseudo-op. This is automatically generated by
2065 do_scrub_chars when a preprocessor # line comment is seen. This
2066 default definition may be overridden by the object or CPU specific
2070 s_linefile (int ignore ATTRIBUTE_UNUSED
)
2073 int linenum
, flags
= 0;
2075 /* The given number is that of the next line. */
2076 if (!get_linefile_number (&linenum
))
2078 ignore_rest_of_line ();
2083 /* Some of the back ends can't deal with non-positive line numbers.
2084 Besides, it's silly. GCC however will generate a line number of
2085 zero when it is pre-processing builtins for assembler-with-cpp files:
2089 We do not want to barf on this, especially since such files are used
2090 in the GCC and GDB testsuites. So we check for negative line numbers
2091 rather than non-positive line numbers. */
2092 as_warn (_("line numbers must be positive; line number %d rejected"),
2100 if (*input_line_pointer
== '"')
2101 file
= demand_copy_string (&length
);
2102 else if (*input_line_pointer
== '.')
2104 /* buffer_and_nest() may insert this form. */
2105 ++input_line_pointer
;
2113 while (get_linefile_number (&this_flag
))
2116 /* From GCC's cpp documentation:
2117 1: start of a new file.
2118 2: returning to a file after having included another file.
2119 3: following text comes from a system header file.
2120 4: following text should be treated as extern "C".
2122 4 is nonsensical for the assembler; 3, we don't care about,
2123 so we ignore it just in case a system header file is
2124 included while preprocessing assembly. So 1 and 2 are all
2125 we care about, and they are mutually incompatible.
2126 new_logical_line_flags() demands this. */
2129 if (flags
&& flags
!= (1 << this_flag
))
2130 as_warn (_("incompatible flag %i in line directive"),
2133 flags
|= 1 << this_flag
;
2138 /* We ignore these. */
2142 as_warn (_("unsupported flag %i in line directive"),
2147 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2154 new_logical_line_flags (file
, linenum
, flags
);
2157 listing_source_line (linenum
);
2162 demand_empty_rest_of_line ();
2164 ignore_rest_of_line ();
2167 /* Handle the .end pseudo-op. Actually, the real work is done in
2168 read_a_source_file. */
2171 s_end (int ignore ATTRIBUTE_UNUSED
)
2175 /* The MRI assembler permits the start symbol to follow .end,
2176 but we don't support that. */
2178 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2179 && *input_line_pointer
!= '*'
2180 && *input_line_pointer
!= '!')
2181 as_warn (_("start address not supported"));
2185 /* Handle the .err pseudo-op. */
2188 s_err (int ignore ATTRIBUTE_UNUSED
)
2190 as_bad (_(".err encountered"));
2191 demand_empty_rest_of_line ();
2194 /* Handle the .error and .warning pseudo-ops. */
2200 /* The purpose for the conditional assignment is not to
2201 internationalize the directive itself, but that we need a
2202 self-contained message, one that can be passed like the
2203 demand_copy_C_string return value, and with no assumption on the
2204 location of the name of the directive within the message. */
2206 = (err
? _(".error directive invoked in source file")
2207 : _(".warning directive invoked in source file"));
2209 if (!is_it_end_of_statement ())
2211 if (*input_line_pointer
!= '\"')
2213 as_bad (_("%s argument must be a string"),
2214 err
? ".error" : ".warning");
2215 ignore_rest_of_line ();
2219 msg
= demand_copy_C_string (&len
);
2227 as_warn ("%s", msg
);
2228 demand_empty_rest_of_line ();
2231 /* Handle the MRI fail pseudo-op. */
2234 s_fail (int ignore ATTRIBUTE_UNUSED
)
2241 stop
= mri_comment_field (&stopc
);
2243 temp
= get_absolute_expression ();
2245 as_warn (_(".fail %ld encountered"), (long) temp
);
2247 as_bad (_(".fail %ld encountered"), (long) temp
);
2249 demand_empty_rest_of_line ();
2252 mri_comment_end (stop
, stopc
);
2256 s_fill (int ignore ATTRIBUTE_UNUSED
)
2258 expressionS rep_exp
;
2263 #ifdef md_flush_pending_output
2264 md_flush_pending_output ();
2267 #ifdef md_cons_align
2271 expression (&rep_exp
);
2272 if (*input_line_pointer
== ',')
2274 input_line_pointer
++;
2275 size
= get_absolute_expression ();
2276 if (*input_line_pointer
== ',')
2278 input_line_pointer
++;
2279 fill
= get_absolute_expression ();
2283 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2284 #define BSD_FILL_SIZE_CROCK_8 (8)
2285 if (size
> BSD_FILL_SIZE_CROCK_8
)
2287 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2288 size
= BSD_FILL_SIZE_CROCK_8
;
2292 as_warn (_("size negative; .fill ignored"));
2295 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2297 if (rep_exp
.X_add_number
< 0)
2298 as_warn (_("repeat < 0; .fill ignored"));
2302 if (size
&& !need_pass_2
)
2304 if (now_seg
== absolute_section
)
2306 if (rep_exp
.X_op
!= O_constant
)
2307 as_bad (_("non-constant fill count for absolute section"));
2308 else if (fill
&& rep_exp
.X_add_number
!= 0)
2309 as_bad (_("attempt to fill absolute section with non-zero value"));
2310 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2313 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2315 as_bad (_("attempt to fill section `%s' with non-zero value"),
2316 segment_name (now_seg
));
2318 if (rep_exp
.X_op
== O_constant
)
2320 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2321 (relax_substateT
) 0, (symbolS
*) 0,
2322 (offsetT
) rep_exp
.X_add_number
,
2327 /* We don't have a constant repeat count, so we can't use
2328 rs_fill. We can get the same results out of rs_space,
2329 but its argument is in bytes, so we must multiply the
2330 repeat count by size. */
2333 rep_sym
= make_expr_symbol (&rep_exp
);
2336 expressionS size_exp
;
2337 size_exp
.X_op
= O_constant
;
2338 size_exp
.X_add_number
= size
;
2340 rep_exp
.X_op
= O_multiply
;
2341 rep_exp
.X_add_symbol
= rep_sym
;
2342 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2343 rep_exp
.X_add_number
= 0;
2344 rep_sym
= make_expr_symbol (&rep_exp
);
2347 p
= frag_var (rs_space
, (int) size
, (int) size
,
2348 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2351 memset (p
, 0, (unsigned int) size
);
2353 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2354 flavoured AS. The following bizarre behaviour is to be
2355 compatible with above. I guess they tried to take up to 8
2356 bytes from a 4-byte expression and they forgot to sign
2358 #define BSD_FILL_SIZE_CROCK_4 (4)
2359 md_number_to_chars (p
, (valueT
) fill
,
2360 (size
> BSD_FILL_SIZE_CROCK_4
2361 ? BSD_FILL_SIZE_CROCK_4
2363 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2364 but emits no error message because it seems a legal thing to do.
2365 It is a degenerate case of .fill but could be emitted by a
2368 demand_empty_rest_of_line ();
2372 s_globl (int ignore ATTRIBUTE_UNUSED
)
2381 stop
= mri_comment_field (&stopc
);
2385 if ((name
= read_symbol_name ()) == NULL
)
2388 symbolP
= symbol_find_or_make (name
);
2389 S_SET_EXTERNAL (symbolP
);
2392 c
= *input_line_pointer
;
2395 input_line_pointer
++;
2397 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2405 demand_empty_rest_of_line ();
2408 mri_comment_end (stop
, stopc
);
2411 /* Handle the MRI IRP and IRPC pseudo-ops. */
2423 file
= as_where (&line
);
2425 eol
= find_end_of_line (input_line_pointer
, 0);
2426 sb_build (&s
, eol
- input_line_pointer
);
2427 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2428 input_line_pointer
= eol
;
2432 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2434 as_bad_where (file
, line
, "%s", err
);
2438 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2440 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2443 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2444 the section to only be linked once. However, this is not supported
2445 by most object file formats. This takes an optional argument,
2446 which is what to do about duplicates. */
2449 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2451 enum linkonce_type type
;
2455 type
= LINKONCE_DISCARD
;
2457 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2462 c
= get_symbol_name (& s
);
2463 if (strcasecmp (s
, "discard") == 0)
2464 type
= LINKONCE_DISCARD
;
2465 else if (strcasecmp (s
, "one_only") == 0)
2466 type
= LINKONCE_ONE_ONLY
;
2467 else if (strcasecmp (s
, "same_size") == 0)
2468 type
= LINKONCE_SAME_SIZE
;
2469 else if (strcasecmp (s
, "same_contents") == 0)
2470 type
= LINKONCE_SAME_CONTENTS
;
2472 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2474 (void) restore_line_pointer (c
);
2477 #ifdef obj_handle_link_once
2478 obj_handle_link_once (type
);
2479 #else /* ! defined (obj_handle_link_once) */
2483 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2484 as_warn (_(".linkonce is not supported for this object file format"));
2486 flags
= bfd_section_flags (now_seg
);
2487 flags
|= SEC_LINK_ONCE
;
2492 case LINKONCE_DISCARD
:
2493 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2495 case LINKONCE_ONE_ONLY
:
2496 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2498 case LINKONCE_SAME_SIZE
:
2499 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2501 case LINKONCE_SAME_CONTENTS
:
2502 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2505 if (!bfd_set_section_flags (now_seg
, flags
))
2506 as_bad (_("bfd_set_section_flags: %s"),
2507 bfd_errmsg (bfd_get_error ()));
2509 #endif /* ! defined (obj_handle_link_once) */
2511 demand_empty_rest_of_line ();
2515 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2518 segT current_seg
= now_seg
;
2519 subsegT current_subseg
= now_subseg
;
2520 segT bss_seg
= bss_section
;
2522 #if defined (TC_MIPS) || defined (TC_ALPHA)
2523 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2524 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2526 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2527 if (size
<= bfd_get_gp_size (stdoutput
))
2529 bss_seg
= subseg_new (".sbss", 1);
2530 seg_info (bss_seg
)->bss
= 1;
2531 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2532 as_warn (_("error setting flags for \".sbss\": %s"),
2533 bfd_errmsg (bfd_get_error ()));
2537 subseg_set (bss_seg
, 1);
2539 if (align
> OCTETS_PER_BYTE_POWER
)
2541 record_alignment (bss_seg
, align
);
2542 frag_align (align
, 0, 0);
2545 /* Detach from old frag. */
2546 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2547 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2549 symbol_set_frag (symbolP
, frag_now
);
2550 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2554 S_SET_SIZE (symbolP
, size
);
2556 S_SET_SEGMENT (symbolP
, bss_seg
);
2559 /* The symbol may already have been created with a preceding
2560 ".globl" directive -- be careful not to step on storage class
2561 in that case. Otherwise, set it to static. */
2562 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2563 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2564 #endif /* OBJ_COFF */
2566 subseg_set (current_seg
, current_subseg
);
2570 parse_align (int align_bytes
)
2576 if (*input_line_pointer
!= ',')
2579 as_bad (_("expected alignment after size"));
2580 ignore_rest_of_line ();
2584 input_line_pointer
++;
2587 align
= get_absolute_expr (&exp
);
2588 if (exp
.X_op
== O_absent
)
2591 if (!exp
.X_unsigned
)
2593 as_warn (_("alignment negative; 0 assumed"));
2597 if (align_bytes
&& align
!= 0)
2599 /* convert to a power of 2 alignment */
2600 unsigned int alignp2
= 0;
2601 while ((align
& 1) == 0)
2602 align
>>= 1, ++alignp2
;
2605 as_bad (_("alignment not a power of 2"));
2606 ignore_rest_of_line ();
2614 /* Called from s_comm_internal after symbol name and size have been
2615 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2616 1 if this was a ".bss" directive which has a 3rd argument
2617 (alignment as a power of 2), or 2 if this was a ".bss" directive
2618 with alignment in bytes. */
2621 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2627 align
= parse_align (needs_align
- 1);
2628 if (align
== (addressT
) -1)
2632 /* Assume some objects may require alignment on some systems. */
2633 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2635 bss_alloc (symbolP
, size
, align
);
2640 s_lcomm (int needs_align
)
2642 s_comm_internal (needs_align
, s_lcomm_internal
);
2646 s_lcomm_bytes (int needs_align
)
2648 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2652 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2658 /* We permit ANY defined expression: BSD4.2 demands constants. */
2659 if ((name
= read_symbol_name ()) == NULL
)
2662 if (*input_line_pointer
!= ',')
2664 as_bad (_("expected comma after \"%s\""), name
);
2668 input_line_pointer
++;
2669 expression_and_evaluate (&exp
);
2671 if (exp
.X_op
!= O_constant
2672 && exp
.X_op
!= O_register
)
2674 as_bad (_("bad expression"));
2678 symbolP
= symbol_find_or_make (name
);
2680 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2682 /* The name might be an undefined .global symbol; be sure to
2683 keep the "external" bit. */
2684 S_SET_SEGMENT (symbolP
,
2685 (exp
.X_op
== O_constant
2688 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2692 as_bad (_("symbol `%s' is already defined"), name
);
2695 demand_empty_rest_of_line ();
2700 ignore_rest_of_line ();
2705 /* Read a line into an sb. Returns the character that ended the line
2706 or zero if there are no more lines. */
2709 get_line_sb (sb
*line
, int in_macro
)
2713 if (input_line_pointer
[-1] == '\n')
2714 bump_line_counters ();
2716 if (input_line_pointer
>= buffer_limit
)
2718 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2719 if (buffer_limit
== 0)
2723 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2724 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2725 input_line_pointer
= eol
;
2727 /* Don't skip multiple end-of-line characters, because that breaks support
2728 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2729 characters but isn't. Instead just skip one end of line character and
2730 return the character skipped so that the caller can re-insert it if
2732 return *input_line_pointer
++;
2736 get_non_macro_line_sb (sb
*line
)
2738 return get_line_sb (line
, 0);
2742 get_macro_line_sb (sb
*line
)
2744 return get_line_sb (line
, 1);
2747 /* Define a macro. This is an interface to macro.c. */
2750 s_macro (int ignore ATTRIBUTE_UNUSED
)
2759 file
= as_where (&line
);
2761 eol
= find_end_of_line (input_line_pointer
, 0);
2762 sb_build (&s
, eol
- input_line_pointer
);
2763 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2764 input_line_pointer
= eol
;
2766 if (line_label
!= NULL
)
2771 name
= S_GET_NAME (line_label
);
2772 len
= strlen (name
);
2773 sb_build (&label
, len
);
2774 sb_add_buffer (&label
, name
, len
);
2775 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2779 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2781 as_bad_where (file
, line
, err
, name
);
2784 if (line_label
!= NULL
)
2786 S_SET_SEGMENT (line_label
, absolute_section
);
2787 S_SET_VALUE (line_label
, 0);
2788 symbol_set_frag (line_label
, &zero_address_frag
);
2791 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2792 && po_entry_find (po_hash
, name
) != NULL
)
2795 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2796 as_warn_where (file
,
2798 _("attempt to redefine pseudo-op `%s' ignored"),
2805 /* Handle the .mexit pseudo-op, which immediately exits a macro
2809 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2813 cond_exit_macro (macro_nest
);
2814 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2817 as_warn (_("ignoring macro exit outside a macro definition."));
2820 /* Switch in and out of MRI mode. */
2823 s_mri (int ignore ATTRIBUTE_UNUSED
)
2826 #ifdef MRI_MODE_CHANGE
2830 on
= get_absolute_expression ();
2831 #ifdef MRI_MODE_CHANGE
2832 old_flag
= flag_mri
;
2851 /* Operator precedence changes in m68k MRI mode, so we need to
2852 update the operator rankings. */
2853 expr_set_precedence ();
2855 #ifdef MRI_MODE_CHANGE
2857 MRI_MODE_CHANGE (on
);
2860 demand_empty_rest_of_line ();
2863 /* Handle changing the location counter. */
2866 do_org (segT segment
, expressionS
*exp
, int fill
)
2868 if (segment
!= now_seg
2869 && segment
!= absolute_section
2870 && segment
!= expr_section
)
2871 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2873 if (now_seg
== absolute_section
)
2876 as_warn (_("ignoring fill value in absolute section"));
2877 if (exp
->X_op
!= O_constant
)
2879 as_bad (_("only constant offsets supported in absolute section"));
2880 exp
->X_add_number
= 0;
2882 abs_section_offset
= exp
->X_add_number
;
2887 symbolS
*sym
= exp
->X_add_symbol
;
2888 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2890 if (fill
&& in_bss ())
2891 as_warn (_("ignoring fill value in section `%s'"),
2892 segment_name (now_seg
));
2894 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2896 /* Handle complex expressions. */
2897 sym
= make_expr_symbol (exp
);
2901 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2907 s_org (int ignore ATTRIBUTE_UNUSED
)
2913 #ifdef md_flush_pending_output
2914 md_flush_pending_output ();
2917 /* The m68k MRI assembler has a different meaning for .org. It
2918 means to create an absolute section at a given address. We can't
2919 support that--use a linker script instead. */
2922 as_bad (_("MRI style ORG pseudo-op not supported"));
2923 ignore_rest_of_line ();
2927 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2928 thing as a sub-segment-relative origin. Any absolute origin is
2929 given a warning, then assumed to be segment-relative. Any
2930 segmented origin expression ("foo+42") had better be in the right
2931 segment or the .org is ignored.
2933 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2934 we never know sub-segment sizes when we are reading code. BSD
2935 will crash trying to emit negative numbers of filler bytes in
2936 certain .orgs. We don't crash, but see as-write for that code.
2938 Don't make frag if need_pass_2==1. */
2939 segment
= get_known_segmented_expression (&exp
);
2940 if (*input_line_pointer
== ',')
2942 input_line_pointer
++;
2943 temp_fill
= get_absolute_expression ();
2949 do_org (segment
, &exp
, temp_fill
);
2951 demand_empty_rest_of_line ();
2954 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2955 called by the obj-format routine which handles section changing
2956 when in MRI mode. It will create a new section, and return it. It
2957 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2958 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2961 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2971 name
= input_line_pointer
;
2972 if (!ISDIGIT (*name
))
2973 c
= get_symbol_name (& name
);
2978 ++input_line_pointer
;
2980 while (ISDIGIT (*input_line_pointer
));
2982 c
= *input_line_pointer
;
2983 *input_line_pointer
= '\0';
2986 name
= xstrdup (name
);
2988 c
= restore_line_pointer (c
);
2990 seg
= subseg_new (name
, 0);
2996 ++input_line_pointer
;
2997 align
= get_absolute_expression ();
2998 record_alignment (seg
, align
);
3002 if (*input_line_pointer
== ',')
3004 c
= *++input_line_pointer
;
3006 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3009 as_bad (_("unrecognized section type"));
3010 ++input_line_pointer
;
3015 flags
= SEC_NO_FLAGS
;
3017 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3018 else if (*type
== 'D' || *type
== 'M')
3019 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3020 else if (*type
== 'R')
3021 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3022 if (flags
!= SEC_NO_FLAGS
)
3024 if (!bfd_set_section_flags (seg
, flags
))
3025 as_warn (_("error setting flags for \"%s\": %s"),
3026 bfd_section_name (seg
),
3027 bfd_errmsg (bfd_get_error ()));
3032 /* Ignore the HP type. */
3033 if (*input_line_pointer
== ',')
3034 input_line_pointer
+= 2;
3036 demand_empty_rest_of_line ();
3038 #else /* ! TC_M68K */
3039 /* The MRI assembler seems to use different forms of .sect for
3040 different targets. */
3041 as_bad ("MRI mode not supported for this target");
3042 ignore_rest_of_line ();
3043 #endif /* ! TC_M68K */
3046 /* Handle the .print pseudo-op. */
3049 s_print (int ignore ATTRIBUTE_UNUSED
)
3054 s
= demand_copy_C_string (&len
);
3057 demand_empty_rest_of_line ();
3060 /* Handle the .purgem pseudo-op. */
3063 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3065 if (is_it_end_of_statement ())
3067 demand_empty_rest_of_line ();
3077 c
= get_symbol_name (& name
);
3078 delete_macro (name
);
3079 *input_line_pointer
= c
;
3080 SKIP_WHITESPACE_AFTER_NAME ();
3082 while (*input_line_pointer
++ == ',');
3084 --input_line_pointer
;
3085 demand_empty_rest_of_line ();
3088 /* Handle the .endm/.endr pseudo-ops. */
3091 s_bad_end (int endr
)
3093 as_warn (_(".end%c encountered without preceding %s"),
3095 endr
? ".rept, .irp, or .irpc" : ".macro");
3096 demand_empty_rest_of_line ();
3099 /* Handle the .rept pseudo-op. */
3102 s_rept (int ignore ATTRIBUTE_UNUSED
)
3106 count
= (size_t) get_absolute_expression ();
3108 do_repeat (count
, "REPT", "ENDR", NULL
);
3111 /* This function provides a generic repeat block implementation. It allows
3112 different directives to be used as the start/end keys. Any text matching
3113 the optional EXPANDER in the block is replaced by the remaining iteration
3117 do_repeat (size_t count
, const char *start
, const char *end
,
3118 const char *expander
)
3123 if (((ssize_t
) count
) < 0)
3125 as_bad (_("negative count for %s - ignored"), start
);
3130 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3132 as_bad (_("%s without %s"), start
, end
);
3136 if (expander
== NULL
|| strstr (one
.ptr
, expander
) == NULL
)
3138 sb_build (&many
, count
* one
.len
);
3140 sb_add_sb (&many
, &one
);
3146 while (count
-- > 0)
3152 sb_build (& processed
, one
.len
);
3153 sb_add_sb (& processed
, & one
);
3154 sub
= strstr (processed
.ptr
, expander
);
3155 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3156 gas_assert (len
< 8);
3157 memmove (sub
+ len
, sub
+ 8,
3158 processed
.ptr
+ processed
.len
- (sub
+ 8));
3159 processed
.len
-= (8 - len
);
3160 sb_add_sb (& many
, & processed
);
3161 sb_kill (& processed
);
3167 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3169 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3172 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3173 input buffers to skip. Assumes that conditionals preceding the loop end
3174 are properly nested.
3176 This function makes it easier to implement a premature "break" out of the
3177 loop. The EXTRA arg accounts for other buffers we might have inserted,
3178 such as line substitutions. */
3181 end_repeat (int extra
)
3183 cond_exit_macro (macro_nest
);
3184 while (extra
-- >= 0)
3185 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3189 assign_symbol (char *name
, int mode
)
3193 if (name
[0] == '.' && name
[1] == '\0')
3195 /* Turn '. = mumble' into a .org mumble. */
3199 segment
= get_known_segmented_expression (&exp
);
3202 do_org (segment
, &exp
, 0);
3207 if ((symbolP
= symbol_find (name
)) == NULL
3208 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3210 symbolP
= symbol_find_or_make (name
);
3212 /* When doing symbol listings, play games with dummy fragments living
3213 outside the normal fragment chain to record the file and line info
3215 if (listing
& LISTING_SYMBOLS
)
3217 extern struct list_info_struct
*listing_tail
;
3218 fragS
*dummy_frag
= XCNEW (fragS
);
3219 dummy_frag
->line
= listing_tail
;
3220 dummy_frag
->fr_symbol
= symbolP
;
3221 symbol_set_frag (symbolP
, dummy_frag
);
3224 #if defined (OBJ_COFF) && !defined (TE_PE)
3225 /* "set" symbols are local unless otherwise specified. */
3226 SF_SET_LOCAL (symbolP
);
3230 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3232 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3233 && !S_CAN_BE_REDEFINED (symbolP
))
3235 as_bad (_("symbol `%s' is already defined"), name
);
3236 ignore_rest_of_line ();
3237 input_line_pointer
--;
3240 /* If the symbol is volatile, copy the symbol and replace the
3241 original with the copy, so that previous uses of the symbol will
3242 retain the value of the symbol at the point of use. */
3243 else if (S_IS_VOLATILE (symbolP
))
3244 symbolP
= symbol_clone (symbolP
, 1);
3248 S_SET_VOLATILE (symbolP
);
3250 S_SET_FORWARD_REF (symbolP
);
3252 pseudo_set (symbolP
);
3255 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3256 then this is .equiv, and it is an error if the symbol is already
3257 defined. If EQUIV is -1, the symbol additionally is a forward
3265 /* Especial apologies for the random logic:
3266 this just grew, and could be parsed much more simply!
3268 if ((name
= read_symbol_name ()) == NULL
)
3271 if (*input_line_pointer
!= ',')
3273 as_bad (_("expected comma after \"%s\""), name
);
3274 ignore_rest_of_line ();
3279 input_line_pointer
++;
3280 assign_symbol (name
, equiv
);
3281 demand_empty_rest_of_line ();
3295 #ifdef md_flush_pending_output
3296 md_flush_pending_output ();
3303 # ifndef P_PRECISION
3304 # define P_PRECISION X_PRECISION
3305 # define P_PRECISION_PAD X_PRECISION_PAD
3307 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3315 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3322 #ifdef md_cons_align
3327 stop
= mri_comment_field (&stopc
);
3329 /* In m68k MRI mode, we need to align to a word boundary, unless
3331 if (flag_m68k_mri
&& mult
> 1)
3333 if (now_seg
== absolute_section
)
3335 abs_section_offset
+= abs_section_offset
& 1;
3336 if (line_label
!= NULL
)
3337 S_SET_VALUE (line_label
, abs_section_offset
);
3339 else if (mri_common_symbol
!= NULL
)
3343 mri_val
= S_GET_VALUE (mri_common_symbol
);
3344 if ((mri_val
& 1) != 0)
3346 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3347 if (line_label
!= NULL
)
3349 expressionS
*symexp
;
3351 symexp
= symbol_get_value_expression (line_label
);
3352 know (symexp
->X_op
== O_symbol
);
3353 know (symexp
->X_add_symbol
== mri_common_symbol
);
3354 symexp
->X_add_number
+= 1;
3360 do_align (1, (char *) NULL
, 0, 0);
3361 if (line_label
!= NULL
)
3363 symbol_set_frag (line_label
, frag_now
);
3364 S_SET_VALUE (line_label
, frag_now_fix ());
3374 if (*input_line_pointer
== ',')
3376 ++input_line_pointer
;
3381 val
.X_op
= O_constant
;
3382 val
.X_add_number
= 0;
3385 if ((val
.X_op
!= O_constant
3386 || val
.X_add_number
< - 0x80
3387 || val
.X_add_number
> 0xff
3388 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3389 && (now_seg
!= absolute_section
&& !in_bss ()))
3391 resolve_expression (&exp
);
3392 if (exp
.X_op
!= O_constant
)
3393 as_bad (_("unsupported variable size or fill value"));
3398 /* PR 20901: Check for excessive values.
3399 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3400 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3401 as_bad (_("size value for space directive too large: %lx"),
3402 (long) exp
.X_add_number
);
3407 bytes
= mult
* exp
.X_add_number
;
3409 for (i
= 0; i
< exp
.X_add_number
; i
++)
3410 emit_expr (&val
, mult
);
3416 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3417 resolve_expression (&exp
);
3419 if (exp
.X_op
== O_constant
)
3423 repeat
= exp
.X_add_number
;
3430 as_warn (_(".space repeat count is zero, ignored"));
3431 else if (repeat
< 0)
3432 as_warn (_(".space repeat count is negative, ignored"));
3436 /* If we are in the absolute section, just bump the offset. */
3437 if (now_seg
== absolute_section
)
3439 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3440 as_warn (_("ignoring fill value in absolute section"));
3441 abs_section_offset
+= repeat
;
3445 /* If we are secretly in an MRI common section, then
3446 creating space just increases the size of the common
3448 if (mri_common_symbol
!= NULL
)
3450 S_SET_VALUE (mri_common_symbol
,
3451 S_GET_VALUE (mri_common_symbol
) + repeat
);
3456 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3457 (offsetT
) repeat
, (char *) 0);
3461 if (now_seg
== absolute_section
)
3463 as_bad (_("space allocation too complex in absolute section"));
3464 subseg_set (text_section
, 0);
3467 if (mri_common_symbol
!= NULL
)
3469 as_bad (_("space allocation too complex in common section"));
3470 mri_common_symbol
= NULL
;
3474 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3475 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3478 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3479 as_warn (_("ignoring fill value in section `%s'"),
3480 segment_name (now_seg
));
3482 *p
= val
.X_add_number
;
3487 /* In MRI mode, after an odd number of bytes, we must align to an
3488 even word boundary, unless the next instruction is a dc.b, ds.b
3490 if (flag_mri
&& (bytes
& 1) != 0)
3491 mri_pending_align
= 1;
3493 demand_empty_rest_of_line ();
3496 mri_comment_end (stop
, stopc
);
3500 s_nop (int ignore ATTRIBUTE_UNUSED
)
3507 #ifdef md_flush_pending_output
3508 md_flush_pending_output ();
3511 #ifdef md_cons_align
3517 demand_empty_rest_of_line ();
3520 start_off
= frag_now_fix ();
3523 #ifdef md_emit_single_noop
3524 md_emit_single_noop
;
3528 #ifndef md_single_noop_insn
3529 #define md_single_noop_insn "nop"
3531 /* md_assemble might modify its argument, so
3532 we must pass it a string that is writable. */
3533 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3534 as_fatal ("%s", xstrerror (errno
));
3536 /* Some targets assume that they can update input_line_pointer
3537 inside md_assemble, and, worse, that they can leave it
3538 assigned to the string pointer that was provided as an
3539 argument. So preserve ilp here. */
3540 char *saved_ilp
= input_line_pointer
;
3542 input_line_pointer
= saved_ilp
;
3545 #ifdef md_flush_pending_output
3546 md_flush_pending_output ();
3548 } while (exp
.X_op
== O_constant
3549 && exp
.X_add_number
> 0
3550 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3551 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3555 s_nops (int ignore ATTRIBUTE_UNUSED
)
3560 #ifdef md_flush_pending_output
3561 md_flush_pending_output ();
3564 #ifdef md_cons_align
3570 /* Note - this expression is tested for an absolute value in
3571 write.c:relax_segment(). */
3574 if (*input_line_pointer
== ',')
3576 ++input_line_pointer
;
3581 val
.X_op
= O_constant
;
3582 val
.X_add_number
= 0;
3585 if (val
.X_op
!= O_constant
)
3587 as_bad (_("unsupported variable nop control in .nops directive"));
3588 val
.X_op
= O_constant
;
3589 val
.X_add_number
= 0;
3591 else if (val
.X_add_number
< 0)
3593 as_warn (_("negative nop control byte, ignored"));
3594 val
.X_add_number
= 0;
3597 demand_empty_rest_of_line ();
3600 /* Ignore this directive if we are going to perform a second pass. */
3603 /* Store the no-op instruction control byte in the first byte of frag. */
3605 symbolS
*sym
= make_expr_symbol (&exp
);
3606 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3607 sym
, (offsetT
) 0, (char *) 0);
3608 *p
= val
.X_add_number
;
3611 /* Obtain the size of a floating point number, given a type. */
3614 float_length (int float_type
, int *pad_p
)
3616 int length
, pad
= 0;
3644 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3645 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3654 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3655 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3662 as_bad (_("unknown floating type '%c'"), float_type
);
3674 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3680 /* Skip any 0{letter} that may be present. Don't even check if the
3681 letter is legal. Someone may invent a "z" format and this routine
3682 has no use for such information. Lusers beware: you get
3683 diagnostics if your input is ill-conditioned. */
3684 if (input_line_pointer
[0] == '0'
3685 && ISALPHA (input_line_pointer
[1]))
3686 input_line_pointer
+= 2;
3688 /* Accept :xxxx, where the x's are hex digits, for a floating point
3689 with the exact digits specified. */
3690 if (input_line_pointer
[0] == ':')
3692 ++input_line_pointer
;
3693 length
= hex_float (float_type
, temp
);
3696 ignore_rest_of_line ();
3704 err
= md_atof (float_type
, temp
, &length
);
3705 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3706 know (err
!= NULL
|| length
> 0);
3709 as_bad (_("bad floating literal: %s"), err
);
3710 ignore_rest_of_line ();
3718 /* This is like s_space, but the value is a floating point number with
3719 the given precision. This is for the MRI dcb.s pseudo-op and
3723 s_float_space (int float_type
)
3727 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3731 #ifdef md_cons_align
3736 stop
= mri_comment_field (&stopc
);
3738 count
= get_absolute_expression ();
3741 if (*input_line_pointer
!= ',')
3745 flen
= float_length (float_type
, &pad
);
3747 memset (temp
, 0, flen
+= pad
);
3751 ++input_line_pointer
;
3753 flen
= parse_one_float (float_type
, temp
);
3759 mri_comment_end (stop
, stopc
);
3763 while (--count
>= 0)
3767 p
= frag_more (flen
);
3768 memcpy (p
, temp
, (unsigned int) flen
);
3771 demand_empty_rest_of_line ();
3774 mri_comment_end (stop
, stopc
);
3777 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3780 s_struct (int ignore ATTRIBUTE_UNUSED
)
3786 stop
= mri_comment_field (&stopc
);
3787 abs_section_offset
= get_absolute_expression ();
3788 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3789 /* The ELF backend needs to know that we are changing sections, so
3790 that .previous works correctly. */
3792 obj_elf_section_change_hook ();
3794 subseg_set (absolute_section
, 0);
3795 demand_empty_rest_of_line ();
3797 mri_comment_end (stop
, stopc
);
3801 s_text (int ignore ATTRIBUTE_UNUSED
)
3805 temp
= get_absolute_expression ();
3806 subseg_set (text_section
, (subsegT
) temp
);
3807 demand_empty_rest_of_line ();
3810 /* .weakref x, y sets x as an alias to y that, as long as y is not
3811 referenced directly, will cause y to become a weak symbol. */
3813 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3820 if ((name
= read_symbol_name ()) == NULL
)
3823 symbolP
= symbol_find_or_make (name
);
3825 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3827 if (!S_IS_VOLATILE (symbolP
))
3829 as_bad (_("symbol `%s' is already defined"), name
);
3832 symbolP
= symbol_clone (symbolP
, 1);
3833 S_CLEAR_VOLATILE (symbolP
);
3838 if (*input_line_pointer
!= ',')
3840 as_bad (_("expected comma after \"%s\""), name
);
3844 input_line_pointer
++;
3849 if ((name
= read_symbol_name ()) == NULL
)
3852 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3853 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3855 symbolP2
= symbol_find_or_make (name
);
3856 S_SET_WEAKREFD (symbolP2
);
3860 symbolS
*symp
= symbolP2
;
3862 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3864 expressionS
*expP
= symbol_get_value_expression (symp
);
3866 gas_assert (expP
->X_op
== O_symbol
3867 && expP
->X_add_number
== 0);
3868 symp
= expP
->X_add_symbol
;
3870 if (symp
== symbolP
)
3874 loop
= concat (S_GET_NAME (symbolP
),
3875 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3878 while (symp
!= symbolP
)
3880 char *old_loop
= loop
;
3882 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3883 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3884 (const char *) NULL
);
3888 as_bad (_("%s: would close weakref loop: %s"),
3889 S_GET_NAME (symbolP
), loop
);
3893 ignore_rest_of_line ();
3897 /* Short-circuiting instead of just checking here might speed
3898 things up a tiny little bit, but loop error messages would
3899 miss intermediate links. */
3900 /* symbolP2 = symp; */
3903 memset (&exp
, 0, sizeof (exp
));
3904 exp
.X_op
= O_symbol
;
3905 exp
.X_add_symbol
= symbolP2
;
3907 S_SET_SEGMENT (symbolP
, undefined_section
);
3908 symbol_set_value_expression (symbolP
, &exp
);
3909 symbol_set_frag (symbolP
, &zero_address_frag
);
3910 S_SET_WEAKREFR (symbolP
);
3912 demand_empty_rest_of_line ();
3917 ignore_rest_of_line ();
3923 /* Verify that we are at the end of a line. If not, issue an error and
3924 skip to EOL. This function may leave input_line_pointer one past
3925 buffer_limit, so should not be called from places that may
3926 dereference input_line_pointer unconditionally. Note that when the
3927 gas parser is switched to handling a string (where buffer_limit
3928 should be the size of the string excluding the NUL terminator) this
3929 will be one past the NUL; is_end_of_line(0) returns true. */
3932 demand_empty_rest_of_line (void)
3935 if (input_line_pointer
> buffer_limit
)
3937 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3938 input_line_pointer
++;
3941 if (ISPRINT (*input_line_pointer
))
3942 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3943 *input_line_pointer
);
3945 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3946 *input_line_pointer
);
3947 ignore_rest_of_line ();
3949 /* Return pointing just after end-of-line. */
3952 /* Silently advance to the end of line. Use this after already having
3953 issued an error about something bad. Like demand_empty_rest_of_line,
3954 this function may leave input_line_pointer one after buffer_limit;
3955 Don't call it from within expression parsing code in an attempt to
3956 silence further errors. */
3959 ignore_rest_of_line (void)
3961 while (input_line_pointer
<= buffer_limit
)
3962 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3964 /* Return pointing just after end-of-line. */
3967 /* Sets frag for given symbol to zero_address_frag, except when the
3968 symbol frag is already set to a dummy listing frag. */
3971 set_zero_frag (symbolS
*symbolP
)
3973 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3974 symbol_set_frag (symbolP
, &zero_address_frag
);
3977 /* In: Pointer to a symbol.
3978 Input_line_pointer->expression.
3980 Out: Input_line_pointer->just after any whitespace after expression.
3981 Tried to set symbol to value of expression.
3982 Will change symbols type, value, and frag; */
3985 pseudo_set (symbolS
*symbolP
)
3990 know (symbolP
); /* NULL pointer is logic error. */
3992 if (!S_IS_FORWARD_REF (symbolP
))
3993 (void) expression (&exp
);
3995 (void) deferred_expression (&exp
);
3997 if (exp
.X_op
== O_illegal
)
3998 as_bad (_("illegal expression"));
3999 else if (exp
.X_op
== O_absent
)
4000 as_bad (_("missing expression"));
4001 else if (exp
.X_op
== O_big
)
4003 if (exp
.X_add_number
> 0)
4004 as_bad (_("bignum invalid"));
4006 as_bad (_("floating point number invalid"));
4008 else if (exp
.X_op
== O_subtract
4009 && !S_IS_FORWARD_REF (symbolP
)
4010 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
4011 && (symbol_get_frag (exp
.X_add_symbol
)
4012 == symbol_get_frag (exp
.X_op_symbol
)))
4014 exp
.X_op
= O_constant
;
4015 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
4016 - S_GET_VALUE (exp
.X_op_symbol
));
4019 if (symbol_section_p (symbolP
))
4021 as_bad ("attempt to set value of section symbol");
4030 exp
.X_add_number
= 0;
4033 S_SET_SEGMENT (symbolP
, absolute_section
);
4034 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4035 set_zero_frag (symbolP
);
4039 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
4040 if (S_IS_EXTERNAL (symbolP
))
4042 as_bad ("can't equate global symbol `%s' with register name",
4043 S_GET_NAME (symbolP
));
4047 S_SET_SEGMENT (symbolP
, reg_section
);
4048 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4049 set_zero_frag (symbolP
);
4050 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
4054 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4055 /* For x=undef+const, create an expression symbol.
4056 For x=x+const, just update x except when x is an undefined symbol
4057 For x=defined+const, evaluate x. */
4058 if (symbolP
== exp
.X_add_symbol
4059 && (seg
!= undefined_section
4060 || !symbol_constant_p (symbolP
)))
4062 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4065 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4067 symbolS
*s
= exp
.X_add_symbol
;
4069 if (S_IS_COMMON (s
))
4070 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4071 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4073 S_SET_SEGMENT (symbolP
, seg
);
4074 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4075 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4076 copy_symbol_attributes (symbolP
, s
);
4079 S_SET_SEGMENT (symbolP
, undefined_section
);
4080 symbol_set_value_expression (symbolP
, &exp
);
4081 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4082 set_zero_frag (symbolP
);
4086 /* The value is some complex expression. */
4087 S_SET_SEGMENT (symbolP
, expr_section
);
4088 symbol_set_value_expression (symbolP
, &exp
);
4089 set_zero_frag (symbolP
);
4096 CONStruct more frag of .bytes, or .words etc.
4097 Should need_pass_2 be 1 then emit no frag(s).
4098 This understands EXPRESSIONS.
4102 This has a split personality. We use expression() to read the
4103 value. We can detect if the value won't fit in a byte or word.
4104 But we can't detect if expression() discarded significant digits
4105 in the case of a long. Not worth the crocks required to fix it. */
4107 /* Select a parser for cons expressions. */
4109 /* Some targets need to parse the expression in various fancy ways.
4110 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4111 (for example, the HPPA does this). Otherwise, you can define
4112 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4113 are defined, which is the normal case, then only simple expressions
4118 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4121 #ifndef TC_PARSE_CONS_EXPRESSION
4122 #ifdef REPEAT_CONS_EXPRESSIONS
4123 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4124 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4126 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4129 /* If we haven't gotten one yet, just call expression. */
4130 #ifndef TC_PARSE_CONS_EXPRESSION
4131 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4132 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4137 do_parse_cons_expression (expressionS
*exp
,
4138 int nbytes ATTRIBUTE_UNUSED
)
4140 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4144 /* Worker to do .byte etc statements.
4145 Clobbers input_line_pointer and checks end-of-line. */
4148 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4156 #ifdef md_flush_pending_output
4157 md_flush_pending_output ();
4161 stop
= mri_comment_field (&stopc
);
4163 if (is_it_end_of_statement ())
4165 demand_empty_rest_of_line ();
4167 mri_comment_end (stop
, stopc
);
4172 nbytes
= TC_ADDRESS_BYTES ();
4174 #ifdef md_cons_align
4175 md_cons_align (nbytes
);
4181 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4182 #ifdef TC_CONS_FIX_CHECK
4183 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4185 if (*cur_fix
!= NULL
)
4186 cur_fix
= &(*cur_fix
)->fx_next
;
4191 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4196 if (*input_line_pointer
== '"')
4198 as_bad (_("unexpected `\"' in expression"));
4199 ignore_rest_of_line ();
4203 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4208 if (exp
.X_op
== O_symbol
)
4209 exp
.X_op
= O_symbol_rva
;
4211 as_fatal (_("rva without symbol"));
4213 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4214 #ifdef TC_CONS_FIX_CHECK
4215 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4219 while (*input_line_pointer
++ == ',');
4221 /* In MRI mode, after an odd number of bytes, we must align to an
4222 even word boundary, unless the next instruction is a dc.b, ds.b
4224 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4225 mri_pending_align
= 1;
4227 input_line_pointer
--; /* Put terminator back into stream. */
4229 demand_empty_rest_of_line ();
4232 mri_comment_end (stop
, stopc
);
4238 cons_worker (size
, 0);
4244 cons_worker (size
, 1);
4247 /* .reloc offset, reloc_name, symbol+addend. */
4250 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4257 struct reloc_list
*reloc
;
4258 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4259 static struct _bfd_rel bfd_relocs
[] =
4261 { "NONE", BFD_RELOC_NONE
},
4262 { "8", BFD_RELOC_8
},
4263 { "16", BFD_RELOC_16
},
4264 { "32", BFD_RELOC_32
},
4265 { "64", BFD_RELOC_64
}
4268 reloc
= XNEW (struct reloc_list
);
4271 stop
= mri_comment_field (&stopc
);
4280 as_bad (_("missing or bad offset expression"));
4283 exp
.X_add_symbol
= section_symbol (now_seg
);
4284 /* Mark the section symbol used in relocation so that it will be
4285 included in the symbol table. */
4286 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4287 exp
.X_op
= O_symbol
;
4290 if (exp
.X_add_number
== 0)
4292 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4297 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4302 if (*input_line_pointer
!= ',')
4304 as_bad (_("missing reloc type"));
4308 ++input_line_pointer
;
4310 c
= get_symbol_name (& r_name
);
4311 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4315 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4316 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4318 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4319 bfd_relocs
[i
].code
);
4324 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4325 *input_line_pointer
= c
;
4326 if (reloc
->u
.a
.howto
== NULL
)
4328 as_bad (_("unrecognized reloc type"));
4332 exp
.X_op
= O_absent
;
4333 SKIP_WHITESPACE_AFTER_NAME ();
4334 if (*input_line_pointer
== ',')
4336 ++input_line_pointer
;
4344 as_bad (_("bad reloc expression"));
4346 ignore_rest_of_line ();
4349 mri_comment_end (stop
, stopc
);
4352 reloc
->u
.a
.sym
= NULL
;
4353 reloc
->u
.a
.addend
= 0;
4356 reloc
->u
.a
.sym
= NULL
;
4357 reloc
->u
.a
.addend
= exp
.X_add_number
;
4360 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4361 reloc
->u
.a
.addend
= exp
.X_add_number
;
4364 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4365 reloc
->u
.a
.addend
= 0;
4369 reloc
->file
= as_where (&reloc
->line
);
4370 reloc
->next
= reloc_list
;
4373 demand_empty_rest_of_line ();
4375 mri_comment_end (stop
, stopc
);
4378 /* Put the contents of expression EXP into the object file using
4379 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4382 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4384 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4388 emit_expr_with_reloc (expressionS
*exp
,
4389 unsigned int nbytes
,
4390 TC_PARSE_CONS_RETURN_TYPE reloc
)
4394 valueT extra_digit
= 0;
4396 /* Don't do anything if we are going to make another pass. */
4401 dot_value
= frag_now_fix ();
4402 dot_frag
= frag_now
;
4406 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4407 appear as a four byte positive constant in the .line section,
4408 followed by a 2 byte 0xffff. Look for that case here. */
4410 static int dwarf_line
= -1;
4412 if (strcmp (segment_name (now_seg
), ".line") != 0)
4414 else if (dwarf_line
>= 0
4416 && exp
->X_op
== O_constant
4417 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4418 listing_source_line ((unsigned int) dwarf_line
);
4419 else if (nbytes
== 4
4420 && exp
->X_op
== O_constant
4421 && exp
->X_add_number
>= 0)
4422 dwarf_line
= exp
->X_add_number
;
4427 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4428 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4429 AT_sibling (0x12) followed by a four byte address of the sibling
4430 followed by a 2 byte AT_name (0x38) followed by the name of the
4431 file. We look for that case here. */
4433 static int dwarf_file
= 0;
4435 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4437 else if (dwarf_file
== 0
4439 && exp
->X_op
== O_constant
4440 && exp
->X_add_number
== 0x11)
4442 else if (dwarf_file
== 1
4444 && exp
->X_op
== O_constant
4445 && exp
->X_add_number
== 0x12)
4447 else if (dwarf_file
== 2
4450 else if (dwarf_file
== 3
4452 && exp
->X_op
== O_constant
4453 && exp
->X_add_number
== 0x38)
4458 /* The variable dwarf_file_string tells stringer that the string
4459 may be the name of the source file. */
4460 if (dwarf_file
== 4)
4461 dwarf_file_string
= 1;
4463 dwarf_file_string
= 0;
4468 if (check_eh_frame (exp
, &nbytes
))
4473 /* Handle a negative bignum. */
4475 && exp
->X_add_number
== 0
4476 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4477 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4480 unsigned long carry
;
4482 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4484 /* Negate the bignum: one's complement each digit and add 1. */
4486 for (i
= 0; i
< exp
->X_add_number
; i
++)
4490 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4493 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4494 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4497 /* We can ignore any carry out, because it will be handled by
4498 extra_digit if it is needed. */
4500 extra_digit
= (valueT
) -1;
4504 if (op
== O_absent
|| op
== O_illegal
)
4506 as_warn (_("zero assumed for missing expression"));
4507 exp
->X_add_number
= 0;
4510 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4512 as_bad (_("floating point number invalid"));
4513 exp
->X_add_number
= 0;
4516 else if (op
== O_register
)
4518 as_warn (_("register value used as expression"));
4522 /* Allow `.word 0' in the absolute section. */
4523 if (now_seg
== absolute_section
)
4525 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4526 as_bad (_("attempt to store value in absolute section"));
4527 abs_section_offset
+= nbytes
;
4531 /* Allow `.word 0' in BSS style sections. */
4532 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4533 as_bad (_("attempt to store non-zero value in section `%s'"),
4534 segment_name (now_seg
));
4536 p
= frag_more ((int) nbytes
);
4538 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4540 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4544 #ifndef WORKING_DOT_WORD
4545 /* If we have the difference of two symbols in a word, save it on
4546 the broken_words list. See the code in write.c. */
4547 if (op
== O_subtract
&& nbytes
== 2)
4549 struct broken_word
*x
;
4551 x
= XNEW (struct broken_word
);
4552 x
->next_broken_word
= broken_words
;
4555 x
->subseg
= now_subseg
;
4557 x
->word_goes_here
= p
;
4559 x
->add
= exp
->X_add_symbol
;
4560 x
->sub
= exp
->X_op_symbol
;
4561 x
->addnum
= exp
->X_add_number
;
4569 /* If we have an integer, but the number of bytes is too large to
4570 pass to md_number_to_chars, handle it as a bignum. */
4571 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4573 extra_digit
= exp
->X_unsigned
? 0 : -1;
4574 convert_to_bignum (exp
, !exp
->X_unsigned
);
4578 if (op
== O_constant
)
4585 /* JF << of >= number of bits in the object is undefined. In
4586 particular SPARC (Sun 4) has problems. */
4587 if (nbytes
>= sizeof (valueT
))
4589 know (nbytes
== sizeof (valueT
));
4594 /* Don't store these bits. */
4595 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4598 unmask
= ~mask
; /* Do store these bits. */
4601 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4602 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4605 get
= exp
->X_add_number
;
4607 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4612 /* These buffers help to ease the translation of the warning message. */
4613 sprintf_vma (get_buf
, get
);
4614 sprintf_vma (use_buf
, use
);
4615 /* Leading bits contain both 0s & 1s. */
4616 as_warn (_("value 0x%s truncated to 0x%s"), get_buf
, use_buf
);
4618 /* Put bytes in right order. */
4619 md_number_to_chars (p
, use
, (int) nbytes
);
4621 else if (op
== O_big
)
4624 LITTLENUM_TYPE
*nums
;
4626 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4629 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4633 LITTLENUM_TYPE sign
= 0;
4634 if ((generic_bignum
[--i
]
4635 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4636 sign
= ~(LITTLENUM_TYPE
) 0;
4638 while (++i
< exp
->X_add_number
)
4639 if (generic_bignum
[i
] != sign
)
4642 else if (nbytes
== 1)
4644 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4645 Check that bits 8.. of generic_bignum[0] match bit 7
4646 and that they match all of generic_bignum[1..exp->X_add_number]. */
4647 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4648 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4650 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4652 while (++i
< exp
->X_add_number
)
4653 if (generic_bignum
[i
] != sign
)
4658 if (i
< exp
->X_add_number
)
4659 as_warn (ngettext ("bignum truncated to %d byte",
4660 "bignum truncated to %d bytes",
4668 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4671 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4673 if (target_big_endian
)
4675 while (nbytes
> size
)
4677 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4678 nbytes
-= CHARS_PER_LITTLENUM
;
4679 p
+= CHARS_PER_LITTLENUM
;
4682 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4683 while (size
>= CHARS_PER_LITTLENUM
)
4686 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4687 size
-= CHARS_PER_LITTLENUM
;
4688 p
+= CHARS_PER_LITTLENUM
;
4693 nums
= generic_bignum
;
4694 while (size
>= CHARS_PER_LITTLENUM
)
4696 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4698 size
-= CHARS_PER_LITTLENUM
;
4699 p
+= CHARS_PER_LITTLENUM
;
4700 nbytes
-= CHARS_PER_LITTLENUM
;
4703 while (nbytes
>= CHARS_PER_LITTLENUM
)
4705 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4706 nbytes
-= CHARS_PER_LITTLENUM
;
4707 p
+= CHARS_PER_LITTLENUM
;
4712 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4716 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4717 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4720 unsigned int size
= nbytes
;
4722 memset (p
, 0, size
);
4724 /* Generate a fixS to record the symbol value. */
4726 #ifdef TC_CONS_FIX_NEW
4727 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4729 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4731 reloc_howto_type
*reloc_howto
;
4733 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4734 size
= bfd_get_reloc_size (reloc_howto
);
4738 as_bad (ngettext ("%s relocations do not fit in %u byte",
4739 "%s relocations do not fit in %u bytes",
4741 reloc_howto
->name
, nbytes
);
4744 else if (target_big_endian
)
4745 offset
= nbytes
- size
;
4766 as_bad (_("unsupported BFD relocation size %u"), size
);
4769 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4774 /* Handle an MRI style string expression. */
4778 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4780 if (*input_line_pointer
!= '\''
4781 && (input_line_pointer
[1] != '\''
4782 || (*input_line_pointer
!= 'A'
4783 && *input_line_pointer
!= 'E')))
4784 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4788 unsigned int result
= 0;
4790 /* An MRI style string. Cut into as many bytes as will fit into
4791 a nbyte chunk, left justify if necessary, and separate with
4792 commas so we can try again later. */
4793 if (*input_line_pointer
== 'A')
4794 ++input_line_pointer
;
4795 else if (*input_line_pointer
== 'E')
4797 as_bad (_("EBCDIC constants are not supported"));
4798 ++input_line_pointer
;
4801 input_line_pointer
++;
4802 for (scan
= 0; scan
< nbytes
; scan
++)
4804 if (*input_line_pointer
== '\'')
4806 if (input_line_pointer
[1] == '\'')
4808 input_line_pointer
++;
4813 result
= (result
<< 8) | (*input_line_pointer
++);
4817 while (scan
< nbytes
)
4823 /* Create correct expression. */
4824 exp
->X_op
= O_constant
;
4825 exp
->X_add_number
= result
;
4827 /* Fake it so that we can read the next char too. */
4828 if (input_line_pointer
[0] != '\'' ||
4829 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4831 input_line_pointer
-= 2;
4832 input_line_pointer
[0] = ',';
4833 input_line_pointer
[1] = '\'';
4836 input_line_pointer
++;
4839 #endif /* TC_M68K */
4841 #ifdef REPEAT_CONS_EXPRESSIONS
4843 /* Parse a repeat expression for cons. This is used by the MIPS
4844 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4845 object file COUNT times.
4847 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4850 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4857 if (*input_line_pointer
!= ':')
4859 /* No repeat count. */
4863 ++input_line_pointer
;
4864 expression (&count
);
4865 if (count
.X_op
!= O_constant
4866 || count
.X_add_number
<= 0)
4868 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4872 /* The cons function is going to output this expression once. So we
4873 output it count - 1 times. */
4874 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4875 emit_expr (exp
, nbytes
);
4878 #endif /* REPEAT_CONS_EXPRESSIONS */
4880 /* Parse a floating point number represented as a hex constant. This
4881 permits users to specify the exact bits they want in the floating
4885 hex_float (int float_type
, char *bytes
)
4887 int pad
, length
= float_length (float_type
, &pad
);
4893 /* It would be nice if we could go through expression to parse the
4894 hex constant, but if we get a bignum it's a pain to sort it into
4895 the buffer correctly. */
4897 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4901 /* The MRI assembler accepts arbitrary underscores strewn about
4902 through the hex constant, so we ignore them as well. */
4903 if (*input_line_pointer
== '_')
4905 ++input_line_pointer
;
4911 as_warn (_("floating point constant too large"));
4914 d
= hex_value (*input_line_pointer
) << 4;
4915 ++input_line_pointer
;
4916 while (*input_line_pointer
== '_')
4917 ++input_line_pointer
;
4918 if (hex_p (*input_line_pointer
))
4920 d
+= hex_value (*input_line_pointer
);
4921 ++input_line_pointer
;
4923 if (target_big_endian
)
4926 bytes
[length
- i
- 1] = d
;
4932 if (target_big_endian
)
4933 memset (bytes
+ i
, 0, length
- i
);
4935 memset (bytes
, 0, length
- i
);
4938 memset (bytes
+ length
, 0, pad
);
4940 return length
+ pad
;
4945 CONStruct some more frag chars of .floats .ffloats etc.
4946 Makes 0 or more new frags.
4947 If need_pass_2 == 1, no frags are emitted.
4948 This understands only floating literals, not expressions. Sorry.
4950 A floating constant is defined by atof_generic(), except it is preceded
4951 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4952 reading, I decided to be incompatible. This always tries to give you
4953 rounded bits to the precision of the pseudo-op. Former AS did premature
4954 truncation, restored noisy bits instead of trailing 0s AND gave you
4955 a choice of 2 flavours of noise according to which of 2 floating-point
4956 scanners you directed AS to use.
4958 In: input_line_pointer->whitespace before, or '0' of flonum. */
4961 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4962 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4965 int length
; /* Number of chars in an object. */
4966 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4968 if (is_it_end_of_statement ())
4970 demand_empty_rest_of_line ();
4974 if (now_seg
== absolute_section
)
4976 as_bad (_("attempt to store float in absolute section"));
4977 ignore_rest_of_line ();
4983 as_bad (_("attempt to store float in section `%s'"),
4984 segment_name (now_seg
));
4985 ignore_rest_of_line ();
4989 #ifdef md_flush_pending_output
4990 md_flush_pending_output ();
4993 #ifdef md_cons_align
4999 length
= parse_one_float (float_type
, temp
);
5009 #ifdef REPEAT_CONS_EXPRESSIONS
5010 if (*input_line_pointer
== ':')
5012 expressionS count_exp
;
5014 ++input_line_pointer
;
5015 expression (&count_exp
);
5017 if (count_exp
.X_op
!= O_constant
5018 || count_exp
.X_add_number
<= 0)
5019 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5021 count
= count_exp
.X_add_number
;
5025 while (--count
>= 0)
5027 p
= frag_more (length
);
5028 memcpy (p
, temp
, (unsigned int) length
);
5033 while (*input_line_pointer
++ == ',');
5035 /* Put terminator back into stream. */
5036 --input_line_pointer
;
5037 demand_empty_rest_of_line ();
5042 Note - we are using the DWARF standard's definition of LEB128 encoding
5043 where each 7-bit value is a stored in a byte, *not* an octet. This
5044 means that on targets where a byte contains multiple octets there is
5045 a *huge waste of space*. (This also means that we do not have to
5046 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5049 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5050 we would then have to consider whether multiple, successive LEB128
5051 values should be packed into the bytes without padding (bad idea) or
5052 whether each LEB128 number is padded out to a whole number of bytes.
5053 Plus you have to decide on the endianness of packing octets into a
5056 /* Return the size of a LEB128 value in bytes. */
5058 static inline unsigned int
5059 sizeof_sleb128 (offsetT value
)
5066 byte
= (value
& 0x7f);
5067 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5068 Fortunately, we can structure things so that the extra work reduces
5069 to a noop on systems that do things "properly". */
5070 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5073 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5074 || ((value
== -1) && ((byte
& 0x40) != 0))));
5079 static inline unsigned int
5080 sizeof_uleb128 (valueT value
)
5095 sizeof_leb128 (valueT value
, int sign
)
5098 return sizeof_sleb128 ((offsetT
) value
);
5100 return sizeof_uleb128 (value
);
5103 /* Output a LEB128 value. Returns the number of bytes used. */
5105 static inline unsigned int
5106 output_sleb128 (char *p
, offsetT value
)
5113 unsigned byte
= (value
& 0x7f);
5115 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5116 Fortunately, we can structure things so that the extra work reduces
5117 to a noop on systems that do things "properly". */
5118 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5120 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5121 || ((value
== -1) && ((byte
& 0x40) != 0))));
5132 static inline unsigned int
5133 output_uleb128 (char *p
, valueT value
)
5139 unsigned byte
= (value
& 0x7f);
5143 /* More bytes to follow. */
5154 output_leb128 (char *p
, valueT value
, int sign
)
5157 return output_sleb128 (p
, (offsetT
) value
);
5159 return output_uleb128 (p
, value
);
5162 /* Do the same for bignums. We combine sizeof with output here in that
5163 we don't output for NULL values of P. It isn't really as critical as
5164 for "normal" values that this be streamlined. Returns the number of
5167 static inline unsigned int
5168 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5175 /* Strip leading sign extensions off the bignum. */
5177 && bignum
[size
- 1] == LITTLENUM_MASK
5178 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5183 /* OR in the next part of the littlenum. */
5184 val
|= (*bignum
<< loaded
);
5185 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5189 /* Add bytes until there are less than 7 bits left in VAL
5190 or until every non-sign bit has been written. */
5197 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5204 while ((byte
& 0x80) != 0 && loaded
>= 7);
5208 /* Mop up any left-over bits (of which there will be less than 7). */
5209 if ((byte
& 0x80) != 0)
5211 /* Sign-extend VAL. */
5212 if (val
& (1 << (loaded
- 1)))
5213 val
|= ~0U << loaded
;
5222 static inline unsigned int
5223 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5230 /* Strip leading zeros off the bignum. */
5231 /* XXX: Is this needed? */
5232 while (size
> 0 && bignum
[size
- 1] == 0)
5237 if (loaded
< 7 && size
> 0)
5239 val
|= (*bignum
<< loaded
);
5240 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5249 if (size
> 0 || val
)
5256 while (byte
& 0x80);
5262 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5265 return output_big_sleb128 (p
, bignum
, size
);
5267 return output_big_uleb128 (p
, bignum
, size
);
5270 /* Generate the appropriate fragments for a given expression to emit a
5271 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5274 emit_leb128_expr (expressionS
*exp
, int sign
)
5276 operatorT op
= exp
->X_op
;
5277 unsigned int nbytes
;
5279 if (op
== O_absent
|| op
== O_illegal
)
5281 as_warn (_("zero assumed for missing expression"));
5282 exp
->X_add_number
= 0;
5285 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5287 as_bad (_("floating point number invalid"));
5288 exp
->X_add_number
= 0;
5291 else if (op
== O_register
)
5293 as_warn (_("register value used as expression"));
5296 else if (op
== O_constant
5298 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5300 /* We're outputting a signed leb128 and the sign of X_add_number
5301 doesn't reflect the sign of the original value. Convert EXP
5302 to a correctly-extended bignum instead. */
5303 convert_to_bignum (exp
, exp
->X_extrabit
);
5307 if (now_seg
== absolute_section
)
5309 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5310 as_bad (_("attempt to store value in absolute section"));
5311 abs_section_offset
++;
5315 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5316 as_bad (_("attempt to store non-zero value in section `%s'"),
5317 segment_name (now_seg
));
5319 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5320 a signal that this is leb128 data. It shouldn't optimize this away. */
5321 nbytes
= (unsigned int) -1;
5322 if (check_eh_frame (exp
, &nbytes
))
5325 /* Let the backend know that subsequent data may be byte aligned. */
5326 #ifdef md_cons_align
5330 if (op
== O_constant
)
5332 /* If we've got a constant, emit the thing directly right now. */
5334 valueT value
= exp
->X_add_number
;
5338 size
= sizeof_leb128 (value
, sign
);
5339 p
= frag_more (size
);
5340 if (output_leb128 (p
, value
, sign
) > size
)
5343 else if (op
== O_big
)
5345 /* O_big is a different sort of constant. */
5346 int nbr_digits
= exp
->X_add_number
;
5350 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5351 a signed number. Unary operators like - or ~ always extend the
5352 bignum to its largest size. */
5354 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5355 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5356 generic_bignum
[nbr_digits
++] = 0;
5358 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5359 p
= frag_more (size
);
5360 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5365 /* Otherwise, we have to create a variable sized fragment and
5366 resolve things later. */
5368 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5369 make_expr_symbol (exp
), 0, (char *) NULL
);
5373 /* Parse the .sleb128 and .uleb128 pseudos. */
5380 #ifdef md_flush_pending_output
5381 md_flush_pending_output ();
5387 emit_leb128_expr (&exp
, sign
);
5389 while (*input_line_pointer
++ == ',');
5391 input_line_pointer
--;
5392 demand_empty_rest_of_line ();
5396 stringer_append_char (int c
, int bitsize
)
5399 as_bad (_("attempt to store non-empty string in section `%s'"),
5400 segment_name (now_seg
));
5402 if (!target_big_endian
)
5403 FRAG_APPEND_1_CHAR (c
);
5408 FRAG_APPEND_1_CHAR (0);
5409 FRAG_APPEND_1_CHAR (0);
5410 FRAG_APPEND_1_CHAR (0);
5411 FRAG_APPEND_1_CHAR (0);
5414 FRAG_APPEND_1_CHAR (0);
5415 FRAG_APPEND_1_CHAR (0);
5418 FRAG_APPEND_1_CHAR (0);
5423 /* Called with invalid bitsize argument. */
5427 if (target_big_endian
)
5428 FRAG_APPEND_1_CHAR (c
);
5431 /* Worker to do .ascii etc statements.
5432 Reads 0 or more ',' separated, double-quoted strings.
5433 Caller should have checked need_pass_2 is FALSE because we don't
5435 Checks for end-of-line.
5436 BITS_APPENDZERO says how many bits are in a target char.
5437 The bottom bit is set if a NUL char should be appended to the strings. */
5440 stringer (int bits_appendzero
)
5442 const int bitsize
= bits_appendzero
& ~7;
5443 const int append_zero
= bits_appendzero
& 1;
5445 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5449 #ifdef md_flush_pending_output
5450 md_flush_pending_output ();
5453 #ifdef md_cons_align
5457 /* If we have been switched into the abs_section then we
5458 will not have an obstack onto which we can hang strings. */
5459 if (now_seg
== absolute_section
)
5461 as_bad (_("strings must be placed into a section"));
5462 ignore_rest_of_line ();
5466 /* The following awkward logic is to parse ZERO or more strings,
5467 comma separated. Recall a string expression includes spaces
5468 before the opening '\"' and spaces after the closing '\"'.
5469 We fake a leading ',' if there is (supposed to be)
5470 a 1st, expression. We keep demanding expressions for each ','. */
5471 if (is_it_end_of_statement ())
5473 c
= 0; /* Skip loop. */
5474 ++input_line_pointer
; /* Compensate for end of loop. */
5478 c
= ','; /* Do loop. */
5481 while (c
== ',' || c
== '<' || c
== '"')
5484 switch (*input_line_pointer
)
5487 ++input_line_pointer
; /*->1st char of string. */
5488 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5489 start
= input_line_pointer
;
5492 while (is_a_char (c
= next_char_of_string ()))
5493 stringer_append_char (c
, bitsize
);
5495 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5496 SKIP_ALL_WHITESPACE ();
5497 if (*input_line_pointer
== '"')
5501 stringer_append_char (0, bitsize
);
5503 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5504 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5505 will emit .string with a filename in the .debug section
5506 after a sequence of constants. See the comment in
5507 emit_expr for the sequence. emit_expr will set
5508 dwarf_file_string to non-zero if this string might be a
5509 source file name. */
5510 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5511 dwarf_file_string
= 0;
5512 else if (dwarf_file_string
)
5514 c
= input_line_pointer
[-1];
5515 input_line_pointer
[-1] = '\0';
5516 listing_source_file (start
);
5517 input_line_pointer
[-1] = c
;
5523 input_line_pointer
++;
5524 c
= get_single_number ();
5525 stringer_append_char (c
, bitsize
);
5526 if (*input_line_pointer
!= '>')
5528 as_bad (_("expected <nn>"));
5529 ignore_rest_of_line ();
5532 input_line_pointer
++;
5535 input_line_pointer
++;
5539 c
= *input_line_pointer
;
5542 demand_empty_rest_of_line ();
5545 /* FIXME-SOMEDAY: I had trouble here on characters with the
5546 high bits set. We'll probably also have trouble with
5547 multibyte chars, wide chars, etc. Also be careful about
5548 returning values bigger than 1 byte. xoxorich. */
5551 next_char_of_string (void)
5555 c
= *input_line_pointer
++ & CHAR_MASK
;
5559 /* PR 20902: Do not advance past the end of the buffer. */
5560 -- input_line_pointer
;
5569 as_warn (_("unterminated string; newline inserted"));
5570 bump_line_counters ();
5574 if (!TC_STRING_ESCAPES
)
5576 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5604 break; /* As itself. */
5620 for (i
= 0, number
= 0;
5621 ISDIGIT (c
) && i
< 3;
5622 c
= *input_line_pointer
++, i
++)
5624 number
= number
* 8 + c
- '0';
5627 c
= number
& CHAR_MASK
;
5629 --input_line_pointer
;
5638 c
= *input_line_pointer
++;
5639 while (ISXDIGIT (c
))
5642 number
= number
* 16 + c
- '0';
5643 else if (ISUPPER (c
))
5644 number
= number
* 16 + c
- 'A' + 10;
5646 number
= number
* 16 + c
- 'a' + 10;
5647 c
= *input_line_pointer
++;
5649 c
= number
& CHAR_MASK
;
5650 --input_line_pointer
;
5655 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5656 as_warn (_("unterminated string; newline inserted"));
5658 bump_line_counters ();
5662 /* Do not advance past the end of the buffer. */
5663 -- input_line_pointer
;
5669 #ifdef ONLY_STANDARD_ESCAPES
5670 as_bad (_("bad escaped character in string"));
5672 #endif /* ONLY_STANDARD_ESCAPES */
5685 get_segmented_expression (expressionS
*expP
)
5689 retval
= expression (expP
);
5690 if (expP
->X_op
== O_illegal
5691 || expP
->X_op
== O_absent
5692 || expP
->X_op
== O_big
)
5694 as_bad (_("expected address expression"));
5695 expP
->X_op
= O_constant
;
5696 expP
->X_add_number
= 0;
5697 retval
= absolute_section
;
5703 get_known_segmented_expression (expressionS
*expP
)
5705 segT retval
= get_segmented_expression (expP
);
5707 if (retval
== undefined_section
)
5709 /* There is no easy way to extract the undefined symbol from the
5711 if (expP
->X_add_symbol
!= NULL
5712 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5713 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5714 S_GET_NAME (expP
->X_add_symbol
));
5716 as_warn (_("some symbol undefined; zero assumed"));
5717 retval
= absolute_section
;
5718 expP
->X_op
= O_constant
;
5719 expP
->X_add_number
= 0;
5724 char /* Return terminator. */
5725 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5727 /* FIXME: val_pointer should probably be offsetT *. */
5728 *val_pointer
= (long) get_absolute_expression ();
5729 return (*input_line_pointer
++);
5732 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5733 Give a warning if that happens. */
5736 demand_copy_C_string (int *len_pointer
)
5740 if ((s
= demand_copy_string (len_pointer
)) != 0)
5744 for (len
= *len_pointer
; len
> 0; len
--)
5746 if (s
[len
- 1] == 0)
5750 as_bad (_("this string may not contain \'\\0\'"));
5759 /* Demand string, but return a safe (=private) copy of the string.
5760 Return NULL if we can't read a string here. */
5763 demand_copy_string (int *lenP
)
5771 if (*input_line_pointer
== '\"')
5773 input_line_pointer
++; /* Skip opening quote. */
5775 while (is_a_char (c
= next_char_of_string ()))
5777 obstack_1grow (¬es
, c
);
5780 /* JF this next line is so demand_copy_C_string will return a
5781 null terminated string. */
5782 obstack_1grow (¬es
, '\0');
5783 retval
= (char *) obstack_finish (¬es
);
5787 as_bad (_("missing string"));
5789 ignore_rest_of_line ();
5795 /* In: Input_line_pointer->next character.
5797 Do: Skip input_line_pointer over all whitespace.
5799 Out: 1 if input_line_pointer->end-of-line. */
5802 is_it_end_of_statement (void)
5805 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5809 equals (char *sym_name
, int reassign
)
5814 input_line_pointer
++;
5815 if (*input_line_pointer
== '=')
5816 input_line_pointer
++;
5817 if (reassign
< 0 && *input_line_pointer
== '=')
5818 input_line_pointer
++;
5820 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5821 input_line_pointer
++;
5824 stop
= mri_comment_field (&stopc
);
5826 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5830 demand_empty_rest_of_line ();
5831 mri_comment_end (stop
, stopc
);
5835 /* .incbin -- include a file verbatim at the current location. */
5838 s_incbin (int x ATTRIBUTE_UNUSED
)
5849 #ifdef md_flush_pending_output
5850 md_flush_pending_output ();
5853 #ifdef md_cons_align
5858 filename
= demand_copy_string (& len
);
5859 if (filename
== NULL
)
5864 /* Look for optional skip and count. */
5865 if (* input_line_pointer
== ',')
5867 ++ input_line_pointer
;
5868 skip
= get_absolute_expression ();
5872 if (* input_line_pointer
== ',')
5874 ++ input_line_pointer
;
5876 count
= get_absolute_expression ();
5878 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5884 demand_empty_rest_of_line ();
5886 /* Try opening absolute path first, then try include dirs. */
5887 binfile
= fopen (filename
, FOPEN_RB
);
5888 if (binfile
== NULL
)
5892 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5894 for (i
= 0; i
< include_dir_count
; i
++)
5896 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5898 binfile
= fopen (path
, FOPEN_RB
);
5899 if (binfile
!= NULL
)
5903 if (binfile
== NULL
)
5904 as_bad (_("file not found: %s"), filename
);
5907 path
= xstrdup (filename
);
5912 struct stat filestat
;
5914 if (fstat (fileno (binfile
), &filestat
) != 0
5915 || ! S_ISREG (filestat
.st_mode
)
5916 || S_ISDIR (filestat
.st_mode
))
5918 as_bad (_("unable to include `%s'"), path
);
5922 register_dependency (path
);
5924 /* Compute the length of the file. */
5925 if (fseek (binfile
, 0, SEEK_END
) != 0)
5927 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5930 file_len
= ftell (binfile
);
5932 /* If a count was not specified use the remainder of the file. */
5934 count
= file_len
- skip
;
5936 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5938 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5939 skip
, count
, file_len
);
5943 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5945 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5949 /* Allocate frag space and store file contents in it. */
5950 binfrag
= frag_more (count
);
5952 bytes
= fread (binfrag
, 1, count
, binfile
);
5954 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5955 path
, bytes
, count
);
5958 if (binfile
!= NULL
)
5963 /* .include -- include a file at this point. */
5966 s_include (int arg ATTRIBUTE_UNUSED
)
5975 filename
= demand_copy_string (&i
);
5976 if (filename
== NULL
)
5978 /* demand_copy_string has already printed an error and
5979 called ignore_rest_of_line. */
5987 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5988 && *input_line_pointer
!= ' '
5989 && *input_line_pointer
!= '\t')
5991 obstack_1grow (¬es
, *input_line_pointer
);
5992 ++input_line_pointer
;
5996 obstack_1grow (¬es
, '\0');
5997 filename
= (char *) obstack_finish (¬es
);
5998 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5999 ++input_line_pointer
;
6002 demand_empty_rest_of_line ();
6003 path
= XNEWVEC (char, (unsigned long) i
6004 + include_dir_maxlen
+ 5 /* slop */ );
6006 for (i
= 0; i
< include_dir_count
; i
++)
6008 strcpy (path
, include_dirs
[i
]);
6010 strcat (path
, filename
);
6011 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
6021 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
6022 register_dependency (path
);
6023 input_scrub_insert_file (path
);
6027 add_include_dir (char *path
)
6031 if (include_dir_count
== 0)
6033 include_dirs
= XNEWVEC (const char *, 2);
6034 include_dirs
[0] = "."; /* Current dir. */
6035 include_dir_count
= 2;
6039 include_dir_count
++;
6040 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6044 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6047 if (i
> include_dir_maxlen
)
6048 include_dir_maxlen
= i
;
6051 /* Output debugging information to denote the source file. */
6054 generate_file_debug (void)
6056 if (debug_type
== DEBUG_STABS
)
6057 stabs_generate_asm_file ();
6060 /* Output line number debugging information for the current source line. */
6063 generate_lineno_debug (void)
6067 case DEBUG_UNSPECIFIED
:
6072 stabs_generate_asm_lineno ();
6075 ecoff_generate_asm_lineno ();
6078 /* ??? We could here indicate to dwarf2dbg.c that something
6079 has changed. However, since there is additional backend
6080 support that is required (calling dwarf2_emit_insn), we
6081 let dwarf2dbg.c call as_where on its own. */
6086 /* Output debugging information to mark a function entry point or end point.
6087 END_P is zero for .func, and non-zero for .endfunc. */
6092 do_s_func (end_p
, NULL
);
6095 /* Subroutine of s_func so targets can choose a different default prefix.
6096 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6099 do_s_func (int end_p
, const char *default_prefix
)
6101 /* Record the current function so that we can issue an error message for
6102 misplaced .func,.endfunc, and also so that .endfunc needs no
6104 static char *current_name
;
6105 static char *current_label
;
6109 if (current_name
== NULL
)
6111 as_bad (_("missing .func"));
6112 ignore_rest_of_line ();
6116 if (debug_type
== DEBUG_STABS
)
6117 stabs_generate_asm_endfunc (current_name
, current_label
);
6119 current_name
= current_label
= NULL
;
6124 char delim1
, delim2
;
6126 if (current_name
!= NULL
)
6128 as_bad (_(".endfunc missing for previous .func"));
6129 ignore_rest_of_line ();
6133 delim1
= get_symbol_name (& name
);
6134 name
= xstrdup (name
);
6135 *input_line_pointer
= delim1
;
6136 SKIP_WHITESPACE_AFTER_NAME ();
6137 if (*input_line_pointer
!= ',')
6141 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6142 as_fatal ("%s", xstrerror (errno
));
6146 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6147 /* Missing entry point, use function's name with the leading
6151 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6152 as_fatal ("%s", xstrerror (errno
));
6160 ++input_line_pointer
;
6162 delim2
= get_symbol_name (& label
);
6163 label
= xstrdup (label
);
6164 restore_line_pointer (delim2
);
6167 if (debug_type
== DEBUG_STABS
)
6168 stabs_generate_asm_func (name
, label
);
6170 current_name
= name
;
6171 current_label
= label
;
6174 demand_empty_rest_of_line ();
6177 #ifdef HANDLE_BUNDLE
6180 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6182 unsigned int align
= get_absolute_expression ();
6184 demand_empty_rest_of_line ();
6186 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6187 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6188 (unsigned int) TC_ALIGN_LIMIT
);
6190 if (bundle_lock_frag
!= NULL
)
6192 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6196 bundle_align_p2
= align
;
6200 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6202 demand_empty_rest_of_line ();
6204 if (bundle_align_p2
== 0)
6206 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6210 if (bundle_lock_depth
== 0)
6212 bundle_lock_frchain
= frchain_now
;
6213 bundle_lock_frag
= start_bundle ();
6215 ++bundle_lock_depth
;
6219 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6223 demand_empty_rest_of_line ();
6225 if (bundle_lock_frag
== NULL
)
6227 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6231 gas_assert (bundle_align_p2
> 0);
6233 gas_assert (bundle_lock_depth
> 0);
6234 if (--bundle_lock_depth
> 0)
6237 size
= pending_bundle_size (bundle_lock_frag
);
6239 if (size
> 1U << bundle_align_p2
)
6240 as_bad (_(".bundle_lock sequence is %u bytes, "
6241 "but bundle size is only %u bytes"),
6242 size
, 1u << bundle_align_p2
);
6244 finish_bundle (bundle_lock_frag
, size
);
6246 bundle_lock_frag
= NULL
;
6247 bundle_lock_frchain
= NULL
;
6250 #endif /* HANDLE_BUNDLE */
6253 s_ignore (int arg ATTRIBUTE_UNUSED
)
6255 ignore_rest_of_line ();
6259 read_print_statistics (FILE *file
)
6261 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6264 /* Inserts the given line into the input stream.
6266 This call avoids macro/conditionals nesting checking, since the contents of
6267 the line are assumed to replace the contents of a line already scanned.
6269 An appropriate use of this function would be substitution of input lines when
6270 called by md_start_line_hook(). The given line is assumed to already be
6271 properly scrubbed. */
6274 input_scrub_insert_line (const char *line
)
6277 size_t len
= strlen (line
);
6278 sb_build (&newline
, len
);
6279 sb_add_buffer (&newline
, line
, len
);
6280 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6282 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6285 /* Insert a file into the input stream; the path must resolve to an actual
6286 file; no include path searching or dependency registering is performed. */
6289 input_scrub_insert_file (char *path
)
6291 input_scrub_include_file (path
, input_line_pointer
);
6292 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6295 /* Find the end of a line, considering quotation and escaping of quotes. */
6297 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6298 # define TC_SINGLE_QUOTE_STRINGS 1
6302 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6305 char inquote
= '\0';
6308 while (!is_end_of_line
[(unsigned char) *s
]
6309 || (inquote
&& !ISCNTRL (*s
))
6310 || (inquote
== '\'' && flag_mri
)
6311 #ifdef TC_EOL_IN_INSN
6312 || (insn
&& TC_EOL_IN_INSN (s
))
6314 /* PR 6926: When we are parsing the body of a macro the sequence
6315 \@ is special - it refers to the invocation count. If the @
6316 character happens to be registered as a line-separator character
6317 by the target, then the is_end_of_line[] test above will have
6318 returned true, but we need to ignore the line separating
6319 semantics in this particular case. */
6320 || (in_macro
&& inescape
&& *s
== '@')
6323 if (mri_string
&& *s
== '\'')
6327 else if (*s
== '\\')
6331 #ifdef TC_SINGLE_QUOTE_STRINGS
6332 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6339 as_warn (_("missing closing `%c'"), inquote
);
6340 if (inescape
&& !ignore_input ())
6341 as_warn (_("stray `\\'"));
6346 find_end_of_line (char *s
, int mri_string
)
6348 return _find_end_of_line (s
, mri_string
, 0, 0);
6351 static char *saved_ilp
= NULL
;
6352 static char *saved_limit
;
6354 /* Use BUF as a temporary input pointer for calling other functions in this
6355 file. BUF must be a C string, so that its end can be found by strlen.
6356 Also sets the buffer_limit variable (local to this file) so that buffer
6357 overruns should not occur. Saves the current input line pointer so that
6358 it can be restored by calling restore_ilp().
6360 Does not support recursion. */
6363 temp_ilp (char *buf
)
6365 gas_assert (saved_ilp
== NULL
);
6366 gas_assert (buf
!= NULL
);
6368 saved_ilp
= input_line_pointer
;
6369 saved_limit
= buffer_limit
;
6370 /* Prevent the assert in restore_ilp from triggering if
6371 the input_line_pointer has not yet been initialised. */
6372 if (saved_ilp
== NULL
)
6373 saved_limit
= saved_ilp
= (char *) "";
6375 input_line_pointer
= buf
;
6376 buffer_limit
= buf
+ strlen (buf
);
6377 input_from_string
= true;
6380 /* Restore a saved input line pointer. */
6385 gas_assert (saved_ilp
!= NULL
);
6387 input_line_pointer
= saved_ilp
;
6388 buffer_limit
= saved_limit
;
6389 input_from_string
= false;