1 /* read.c - read a source file -
2 Copyright (C) 1986-2020 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 bfd_boolean 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},
367 #ifdef TC_ADDRESS_BYTES
371 {"dc.d", float_cons
, 'd'},
373 {"dc.s", float_cons
, 'f'},
375 {"dc.x", float_cons
, 'x'},
377 {"dcb.b", s_space
, 1},
378 {"dcb.d", s_float_space
, 'd'},
379 {"dcb.l", s_space
, 4},
380 {"dcb.s", s_float_space
, 'f'},
381 {"dcb.w", s_space
, 2},
382 {"dcb.x", s_float_space
, 'x'},
384 {"ds.b", s_space
, 1},
385 {"ds.d", s_space
, 8},
386 {"ds.l", s_space
, 4},
387 {"ds.p", s_space
, 12},
388 {"ds.s", s_space
, 4},
389 {"ds.w", s_space
, 2},
390 {"ds.x", s_space
, 12},
391 {"debug", s_ignore
, 0},
396 {"double", float_cons
, 'd'},
398 {"eject", listing_eject
, 0}, /* Formfeed listing. */
400 {"elsec", s_else
, 0},
401 {"elseif", s_elseif
, (int) O_ne
},
403 {"endc", s_endif
, 0},
404 {"endfunc", s_func
, 1},
405 {"endif", s_endif
, 0},
406 {"endm", s_bad_end
, 0},
407 {"endr", s_bad_end
, 1},
413 {"error", s_errwarn
, 1},
414 {"exitm", s_mexit
, 0},
416 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
417 {"appfile", s_app_file
, 1},
418 {"appline", s_app_line
, 1},
420 {"file", s_app_file
, 0},
422 {"float", float_cons
, 'f'},
423 {"format", s_ignore
, 0},
425 {"global", s_globl
, 0},
426 {"globl", s_globl
, 0},
428 {"if", s_if
, (int) O_ne
},
431 {"ifdef", s_ifdef
, 0},
432 {"ifeq", s_if
, (int) O_eq
},
433 {"ifeqs", s_ifeqs
, 0},
434 {"ifge", s_if
, (int) O_ge
},
435 {"ifgt", s_if
, (int) O_gt
},
436 {"ifle", s_if
, (int) O_le
},
437 {"iflt", s_if
, (int) O_lt
},
440 {"ifndef", s_ifdef
, 1},
441 {"ifne", s_if
, (int) O_ne
},
442 {"ifnes", s_ifeqs
, 1},
443 {"ifnotdef", s_ifdef
, 1},
444 {"incbin", s_incbin
, 0},
445 {"include", s_include
, 0},
451 {"lcomm", s_lcomm
, 0},
452 {"lflags", s_ignore
, 0}, /* Listing flags. */
453 {"linefile", s_app_line
, 0},
454 {"linkonce", s_linkonce
, 0},
455 {"list", listing_list
, 1}, /* Turn listing on. */
456 {"llen", listing_psize
, 1},
459 {"macro", s_macro
, 0},
460 {"mexit", s_mexit
, 0},
462 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
463 {"name", s_ignore
, 0},
464 {"noaltmacro", s_altmacro
, 0},
465 {"noformat", s_ignore
, 0},
466 {"nolist", listing_list
, 0}, /* Turn listing off. */
467 {"nopage", listing_nopage
, 0},
470 {"offset", s_struct
, 0},
472 {"p2align", s_align_ptwo
, 0},
473 {"p2alignw", s_align_ptwo
, -2},
474 {"p2alignl", s_align_ptwo
, -4},
475 {"page", listing_eject
, 0},
476 {"plen", listing_psize
, 0},
477 {"print", s_print
, 0},
478 {"psize", listing_psize
, 0}, /* Set paper size. */
479 {"purgem", s_purgem
, 0},
481 {"reloc", s_reloc
, 0},
485 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
490 {"single", float_cons
, 'f'},
492 {"space", s_space
, 0},
493 {"skip", s_space
, 0},
494 {"sleb128", s_leb128
, 1},
495 {"spc", s_ignore
, 0},
496 {"stabd", s_stab
, 'd'},
497 {"stabn", s_stab
, 'n'},
498 {"stabs", s_stab
, 's'},
499 {"string", stringer
, 8+1},
500 {"string8", stringer
, 8+1},
501 {"string16", stringer
, 16+1},
502 {"string32", stringer
, 32+1},
503 {"string64", stringer
, 64+1},
504 {"struct", s_struct
, 0},
508 /* This is for gcc to use. It's only just been added (2/94), so gcc
509 won't be able to use it for a while -- probably a year or more.
510 But once this has been released, check with gcc maintainers
511 before deleting it or even changing the spelling. */
512 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
513 /* If we're folding case -- done for some targets, not necessarily
514 all -- the above string in an input file will be converted to
515 this one. Match it either way... */
516 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
518 {"title", listing_title
, 0}, /* Listing title. */
519 {"ttl", listing_title
, 0},
521 {"uleb128", s_leb128
, 0},
525 {"xdef", s_globl
, 0},
526 {"xref", s_ignore
, 0},
527 {"xstabs", s_xstab
, 's'},
528 {"warning", s_errwarn
, 0},
529 {"weakref", s_weakref
, 0},
531 {"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
, 1);
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
)
900 bfd_boolean was_new_line
;
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
> (LONG_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 (strncmp (s
, "APP\n", 4))
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
);
1395 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1396 new_tmp
= new_buf
+ new_length
;
1402 /* We've "scrubbed" input to the preferred format. In the
1403 process we may have consumed the whole of the remaining
1404 file (and included files). We handle this formatted
1405 input similar to that of macro expansion, letting
1406 actual macro expansion (possibly nested) and other
1407 input expansion work. Beware that in messages, line
1408 numbers and possibly file names will be incorrect. */
1409 new_length
= strlen (new_buf
);
1410 sb_build (&sbuf
, new_length
);
1411 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1412 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
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
);
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 ignore_rest_of_line ();
1942 mri_comment_end (stop
, stopc
);
1946 S_SET_EXTERNAL (sym
);
1947 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1948 mri_common_symbol
= sym
;
1952 S_SET_ALIGN (sym
, align
);
1957 if (line_label
!= NULL
)
1960 exp
.X_op
= O_symbol
;
1961 exp
.X_add_symbol
= sym
;
1962 exp
.X_add_number
= 0;
1963 symbol_set_value_expression (line_label
, &exp
);
1964 symbol_set_frag (line_label
, &zero_address_frag
);
1965 S_SET_SEGMENT (line_label
, expr_section
);
1968 /* FIXME: We just ignore the small argument, which distinguishes
1969 COMMON and COMMON.S. I don't know what we can do about it. */
1971 /* Ignore the type and hptype. */
1972 if (*input_line_pointer
== ',')
1973 input_line_pointer
+= 2;
1974 if (*input_line_pointer
== ',')
1975 input_line_pointer
+= 2;
1977 demand_empty_rest_of_line ();
1979 mri_comment_end (stop
, stopc
);
1983 s_data (int ignore ATTRIBUTE_UNUSED
)
1988 temp
= get_absolute_expression ();
1989 if (flag_readonly_data_in_text
)
1991 section
= text_section
;
1995 section
= data_section
;
1997 subseg_set (section
, (subsegT
) temp
);
1999 demand_empty_rest_of_line ();
2002 /* Handle the .appfile pseudo-op. This is automatically generated by
2003 do_scrub_chars when a preprocessor # line comment is seen with a
2004 file name. This default definition may be overridden by the object
2005 or CPU specific pseudo-ops. This function is also the default
2006 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
2010 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
2014 listing_source_file (file
);
2016 register_dependency (file
);
2018 obj_app_file (file
, appfile
);
2023 s_app_file (int appfile
)
2028 /* Some assemblers tolerate immediately following '"'. */
2029 if ((s
= demand_copy_string (&length
)) != 0)
2032 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
2034 /* In MRI mode, the preprocessor may have inserted an extraneous
2037 && *input_line_pointer
== '\''
2038 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2039 ++input_line_pointer
;
2041 demand_empty_rest_of_line ();
2043 s_app_file_string (s
, appfile
);
2048 get_linefile_number (int *flag
)
2052 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2055 *flag
= get_absolute_expression ();
2060 /* Handle the .appline pseudo-op. This is automatically generated by
2061 do_scrub_chars when a preprocessor # line comment is seen. This
2062 default definition may be overridden by the object or CPU specific
2066 s_app_line (int appline
)
2071 /* The given number is that of the next line. */
2073 l
= get_absolute_expression ();
2074 else if (!get_linefile_number (&l
))
2076 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"),
2103 if (*input_line_pointer
== '"')
2104 file
= demand_copy_string (&length
);
2110 while (get_linefile_number (&this_flag
))
2113 /* From GCC's cpp documentation:
2114 1: start of a new file.
2115 2: returning to a file after having included
2117 3: following text comes from a system header file.
2118 4: following text should be treated as extern "C".
2120 4 is nonsensical for the assembler; 3, we don't
2121 care about, so we ignore it just in case a
2122 system header file is included while
2123 preprocessing assembly. So 1 and 2 are all we
2124 care about, and they are mutually incompatible.
2125 new_logical_line_flags() demands this. */
2128 if (flags
&& flags
!= (1 << this_flag
))
2129 as_warn (_("incompatible flag %i in line directive"),
2132 flags
|= 1 << this_flag
;
2137 /* We ignore these. */
2141 as_warn (_("unsupported flag %i in line directive"),
2146 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2151 if (appline
|| file
)
2153 new_logical_line_flags (file
, l
, flags
);
2156 listing_source_line (l
);
2160 if (appline
|| file
)
2161 demand_empty_rest_of_line ();
2163 ignore_rest_of_line ();
2166 /* Handle the .end pseudo-op. Actually, the real work is done in
2167 read_a_source_file. */
2170 s_end (int ignore ATTRIBUTE_UNUSED
)
2174 /* The MRI assembler permits the start symbol to follow .end,
2175 but we don't support that. */
2177 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2178 && *input_line_pointer
!= '*'
2179 && *input_line_pointer
!= '!')
2180 as_warn (_("start address not supported"));
2184 /* Handle the .err pseudo-op. */
2187 s_err (int ignore ATTRIBUTE_UNUSED
)
2189 as_bad (_(".err encountered"));
2190 demand_empty_rest_of_line ();
2193 /* Handle the .error and .warning pseudo-ops. */
2199 /* The purpose for the conditional assignment is not to
2200 internationalize the directive itself, but that we need a
2201 self-contained message, one that can be passed like the
2202 demand_copy_C_string return value, and with no assumption on the
2203 location of the name of the directive within the message. */
2205 = (err
? _(".error directive invoked in source file")
2206 : _(".warning directive invoked in source file"));
2208 if (!is_it_end_of_statement ())
2210 if (*input_line_pointer
!= '\"')
2212 as_bad (_("%s argument must be a string"),
2213 err
? ".error" : ".warning");
2214 ignore_rest_of_line ();
2218 msg
= demand_copy_C_string (&len
);
2226 as_warn ("%s", msg
);
2227 demand_empty_rest_of_line ();
2230 /* Handle the MRI fail pseudo-op. */
2233 s_fail (int ignore ATTRIBUTE_UNUSED
)
2240 stop
= mri_comment_field (&stopc
);
2242 temp
= get_absolute_expression ();
2244 as_warn (_(".fail %ld encountered"), (long) temp
);
2246 as_bad (_(".fail %ld encountered"), (long) temp
);
2248 demand_empty_rest_of_line ();
2251 mri_comment_end (stop
, stopc
);
2255 s_fill (int ignore ATTRIBUTE_UNUSED
)
2257 expressionS rep_exp
;
2262 #ifdef md_flush_pending_output
2263 md_flush_pending_output ();
2266 #ifdef md_cons_align
2270 expression (&rep_exp
);
2271 if (*input_line_pointer
== ',')
2273 input_line_pointer
++;
2274 size
= get_absolute_expression ();
2275 if (*input_line_pointer
== ',')
2277 input_line_pointer
++;
2278 fill
= get_absolute_expression ();
2282 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2283 #define BSD_FILL_SIZE_CROCK_8 (8)
2284 if (size
> BSD_FILL_SIZE_CROCK_8
)
2286 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2287 size
= BSD_FILL_SIZE_CROCK_8
;
2291 as_warn (_("size negative; .fill ignored"));
2294 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2296 if (rep_exp
.X_add_number
< 0)
2297 as_warn (_("repeat < 0; .fill ignored"));
2301 if (size
&& !need_pass_2
)
2303 if (now_seg
== absolute_section
)
2305 if (rep_exp
.X_op
!= O_constant
)
2306 as_bad (_("non-constant fill count for absolute section"));
2307 else if (fill
&& rep_exp
.X_add_number
!= 0)
2308 as_bad (_("attempt to fill absolute section with non-zero value"));
2309 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2312 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2314 as_bad (_("attempt to fill section `%s' with non-zero value"),
2315 segment_name (now_seg
));
2317 if (rep_exp
.X_op
== O_constant
)
2319 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2320 (relax_substateT
) 0, (symbolS
*) 0,
2321 (offsetT
) rep_exp
.X_add_number
,
2326 /* We don't have a constant repeat count, so we can't use
2327 rs_fill. We can get the same results out of rs_space,
2328 but its argument is in bytes, so we must multiply the
2329 repeat count by size. */
2332 rep_sym
= make_expr_symbol (&rep_exp
);
2335 expressionS size_exp
;
2336 size_exp
.X_op
= O_constant
;
2337 size_exp
.X_add_number
= size
;
2339 rep_exp
.X_op
= O_multiply
;
2340 rep_exp
.X_add_symbol
= rep_sym
;
2341 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2342 rep_exp
.X_add_number
= 0;
2343 rep_sym
= make_expr_symbol (&rep_exp
);
2346 p
= frag_var (rs_space
, (int) size
, (int) size
,
2347 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2350 memset (p
, 0, (unsigned int) size
);
2352 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2353 flavoured AS. The following bizarre behaviour is to be
2354 compatible with above. I guess they tried to take up to 8
2355 bytes from a 4-byte expression and they forgot to sign
2357 #define BSD_FILL_SIZE_CROCK_4 (4)
2358 md_number_to_chars (p
, (valueT
) fill
,
2359 (size
> BSD_FILL_SIZE_CROCK_4
2360 ? BSD_FILL_SIZE_CROCK_4
2362 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2363 but emits no error message because it seems a legal thing to do.
2364 It is a degenerate case of .fill but could be emitted by a
2367 demand_empty_rest_of_line ();
2371 s_globl (int ignore ATTRIBUTE_UNUSED
)
2380 stop
= mri_comment_field (&stopc
);
2384 if ((name
= read_symbol_name ()) == NULL
)
2387 symbolP
= symbol_find_or_make (name
);
2388 S_SET_EXTERNAL (symbolP
);
2391 c
= *input_line_pointer
;
2394 input_line_pointer
++;
2396 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2404 demand_empty_rest_of_line ();
2407 mri_comment_end (stop
, stopc
);
2410 /* Handle the MRI IRP and IRPC pseudo-ops. */
2422 file
= as_where (&line
);
2424 eol
= find_end_of_line (input_line_pointer
, 0);
2425 sb_build (&s
, eol
- input_line_pointer
);
2426 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2427 input_line_pointer
= eol
;
2431 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2433 as_bad_where (file
, line
, "%s", err
);
2437 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2439 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2442 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2443 the section to only be linked once. However, this is not supported
2444 by most object file formats. This takes an optional argument,
2445 which is what to do about duplicates. */
2448 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2450 enum linkonce_type type
;
2454 type
= LINKONCE_DISCARD
;
2456 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2461 c
= get_symbol_name (& s
);
2462 if (strcasecmp (s
, "discard") == 0)
2463 type
= LINKONCE_DISCARD
;
2464 else if (strcasecmp (s
, "one_only") == 0)
2465 type
= LINKONCE_ONE_ONLY
;
2466 else if (strcasecmp (s
, "same_size") == 0)
2467 type
= LINKONCE_SAME_SIZE
;
2468 else if (strcasecmp (s
, "same_contents") == 0)
2469 type
= LINKONCE_SAME_CONTENTS
;
2471 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2473 (void) restore_line_pointer (c
);
2476 #ifdef obj_handle_link_once
2477 obj_handle_link_once (type
);
2478 #else /* ! defined (obj_handle_link_once) */
2482 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2483 as_warn (_(".linkonce is not supported for this object file format"));
2485 flags
= bfd_section_flags (now_seg
);
2486 flags
|= SEC_LINK_ONCE
;
2491 case LINKONCE_DISCARD
:
2492 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2494 case LINKONCE_ONE_ONLY
:
2495 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2497 case LINKONCE_SAME_SIZE
:
2498 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2500 case LINKONCE_SAME_CONTENTS
:
2501 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2504 if (!bfd_set_section_flags (now_seg
, flags
))
2505 as_bad (_("bfd_set_section_flags: %s"),
2506 bfd_errmsg (bfd_get_error ()));
2508 #endif /* ! defined (obj_handle_link_once) */
2510 demand_empty_rest_of_line ();
2514 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2517 segT current_seg
= now_seg
;
2518 subsegT current_subseg
= now_subseg
;
2519 segT bss_seg
= bss_section
;
2521 #if defined (TC_MIPS) || defined (TC_ALPHA)
2522 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2523 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2525 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2526 if (size
<= bfd_get_gp_size (stdoutput
))
2528 bss_seg
= subseg_new (".sbss", 1);
2529 seg_info (bss_seg
)->bss
= 1;
2530 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2531 as_warn (_("error setting flags for \".sbss\": %s"),
2532 bfd_errmsg (bfd_get_error ()));
2536 subseg_set (bss_seg
, 1);
2538 if (align
> OCTETS_PER_BYTE_POWER
)
2540 record_alignment (bss_seg
, align
);
2541 frag_align (align
, 0, 0);
2544 /* Detach from old frag. */
2545 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2546 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2548 symbol_set_frag (symbolP
, frag_now
);
2549 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2553 S_SET_SIZE (symbolP
, size
);
2555 S_SET_SEGMENT (symbolP
, bss_seg
);
2558 /* The symbol may already have been created with a preceding
2559 ".globl" directive -- be careful not to step on storage class
2560 in that case. Otherwise, set it to static. */
2561 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2562 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2563 #endif /* OBJ_COFF */
2565 subseg_set (current_seg
, current_subseg
);
2569 parse_align (int align_bytes
)
2575 if (*input_line_pointer
!= ',')
2578 as_bad (_("expected alignment after size"));
2579 ignore_rest_of_line ();
2583 input_line_pointer
++;
2586 align
= get_absolute_expr (&exp
);
2587 if (exp
.X_op
== O_absent
)
2590 if (!exp
.X_unsigned
)
2592 as_warn (_("alignment negative; 0 assumed"));
2596 if (align_bytes
&& align
!= 0)
2598 /* convert to a power of 2 alignment */
2599 unsigned int alignp2
= 0;
2600 while ((align
& 1) == 0)
2601 align
>>= 1, ++alignp2
;
2604 as_bad (_("alignment not a power of 2"));
2605 ignore_rest_of_line ();
2613 /* Called from s_comm_internal after symbol name and size have been
2614 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2615 1 if this was a ".bss" directive which has a 3rd argument
2616 (alignment as a power of 2), or 2 if this was a ".bss" directive
2617 with alignment in bytes. */
2620 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2626 align
= parse_align (needs_align
- 1);
2627 if (align
== (addressT
) -1)
2631 /* Assume some objects may require alignment on some systems. */
2632 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2634 bss_alloc (symbolP
, size
, align
);
2639 s_lcomm (int needs_align
)
2641 s_comm_internal (needs_align
, s_lcomm_internal
);
2645 s_lcomm_bytes (int needs_align
)
2647 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2651 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2657 /* We permit ANY defined expression: BSD4.2 demands constants. */
2658 if ((name
= read_symbol_name ()) == NULL
)
2661 if (*input_line_pointer
!= ',')
2663 as_bad (_("expected comma after \"%s\""), name
);
2667 input_line_pointer
++;
2668 expression_and_evaluate (&exp
);
2670 if (exp
.X_op
!= O_constant
2671 && exp
.X_op
!= O_register
)
2673 as_bad (_("bad expression"));
2677 symbolP
= symbol_find_or_make (name
);
2679 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2681 /* The name might be an undefined .global symbol; be sure to
2682 keep the "external" bit. */
2683 S_SET_SEGMENT (symbolP
,
2684 (exp
.X_op
== O_constant
2687 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2691 as_bad (_("symbol `%s' is already defined"), name
);
2694 demand_empty_rest_of_line ();
2699 ignore_rest_of_line ();
2704 /* Read a line into an sb. Returns the character that ended the line
2705 or zero if there are no more lines. */
2708 get_line_sb (sb
*line
, int in_macro
)
2712 if (input_line_pointer
[-1] == '\n')
2713 bump_line_counters ();
2715 if (input_line_pointer
>= buffer_limit
)
2717 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2718 if (buffer_limit
== 0)
2722 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2723 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2724 input_line_pointer
= eol
;
2726 /* Don't skip multiple end-of-line characters, because that breaks support
2727 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2728 characters but isn't. Instead just skip one end of line character and
2729 return the character skipped so that the caller can re-insert it if
2731 return *input_line_pointer
++;
2735 get_non_macro_line_sb (sb
*line
)
2737 return get_line_sb (line
, 0);
2741 get_macro_line_sb (sb
*line
)
2743 return get_line_sb (line
, 1);
2746 /* Define a macro. This is an interface to macro.c. */
2749 s_macro (int ignore ATTRIBUTE_UNUSED
)
2758 file
= as_where (&line
);
2760 eol
= find_end_of_line (input_line_pointer
, 0);
2761 sb_build (&s
, eol
- input_line_pointer
);
2762 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2763 input_line_pointer
= eol
;
2765 if (line_label
!= NULL
)
2770 name
= S_GET_NAME (line_label
);
2771 len
= strlen (name
);
2772 sb_build (&label
, len
);
2773 sb_add_buffer (&label
, name
, len
);
2774 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2778 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2780 as_bad_where (file
, line
, err
, name
);
2783 if (line_label
!= NULL
)
2785 S_SET_SEGMENT (line_label
, absolute_section
);
2786 S_SET_VALUE (line_label
, 0);
2787 symbol_set_frag (line_label
, &zero_address_frag
);
2790 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2791 && po_entry_find (po_hash
, name
) != NULL
)
2794 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2795 as_warn_where (file
,
2797 _("attempt to redefine pseudo-op `%s' ignored"),
2804 /* Handle the .mexit pseudo-op, which immediately exits a macro
2808 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2812 cond_exit_macro (macro_nest
);
2813 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2816 as_warn (_("ignoring macro exit outside a macro definition."));
2819 /* Switch in and out of MRI mode. */
2822 s_mri (int ignore ATTRIBUTE_UNUSED
)
2825 #ifdef MRI_MODE_CHANGE
2829 on
= get_absolute_expression ();
2830 #ifdef MRI_MODE_CHANGE
2831 old_flag
= flag_mri
;
2850 /* Operator precedence changes in m68k MRI mode, so we need to
2851 update the operator rankings. */
2852 expr_set_precedence ();
2854 #ifdef MRI_MODE_CHANGE
2856 MRI_MODE_CHANGE (on
);
2859 demand_empty_rest_of_line ();
2862 /* Handle changing the location counter. */
2865 do_org (segT segment
, expressionS
*exp
, int fill
)
2867 if (segment
!= now_seg
2868 && segment
!= absolute_section
2869 && segment
!= expr_section
)
2870 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2872 if (now_seg
== absolute_section
)
2875 as_warn (_("ignoring fill value in absolute section"));
2876 if (exp
->X_op
!= O_constant
)
2878 as_bad (_("only constant offsets supported in absolute section"));
2879 exp
->X_add_number
= 0;
2881 abs_section_offset
= exp
->X_add_number
;
2886 symbolS
*sym
= exp
->X_add_symbol
;
2887 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2889 if (fill
&& in_bss ())
2890 as_warn (_("ignoring fill value in section `%s'"),
2891 segment_name (now_seg
));
2893 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2895 /* Handle complex expressions. */
2896 sym
= make_expr_symbol (exp
);
2900 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2906 s_org (int ignore ATTRIBUTE_UNUSED
)
2912 #ifdef md_flush_pending_output
2913 md_flush_pending_output ();
2916 /* The m68k MRI assembler has a different meaning for .org. It
2917 means to create an absolute section at a given address. We can't
2918 support that--use a linker script instead. */
2921 as_bad (_("MRI style ORG pseudo-op not supported"));
2922 ignore_rest_of_line ();
2926 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2927 thing as a sub-segment-relative origin. Any absolute origin is
2928 given a warning, then assumed to be segment-relative. Any
2929 segmented origin expression ("foo+42") had better be in the right
2930 segment or the .org is ignored.
2932 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2933 we never know sub-segment sizes when we are reading code. BSD
2934 will crash trying to emit negative numbers of filler bytes in
2935 certain .orgs. We don't crash, but see as-write for that code.
2937 Don't make frag if need_pass_2==1. */
2938 segment
= get_known_segmented_expression (&exp
);
2939 if (*input_line_pointer
== ',')
2941 input_line_pointer
++;
2942 temp_fill
= get_absolute_expression ();
2948 do_org (segment
, &exp
, temp_fill
);
2950 demand_empty_rest_of_line ();
2953 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2954 called by the obj-format routine which handles section changing
2955 when in MRI mode. It will create a new section, and return it. It
2956 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2957 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2960 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2970 name
= input_line_pointer
;
2971 if (!ISDIGIT (*name
))
2972 c
= get_symbol_name (& name
);
2977 ++input_line_pointer
;
2979 while (ISDIGIT (*input_line_pointer
));
2981 c
= *input_line_pointer
;
2982 *input_line_pointer
= '\0';
2985 name
= xstrdup (name
);
2987 c
= restore_line_pointer (c
);
2989 seg
= subseg_new (name
, 0);
2995 ++input_line_pointer
;
2996 align
= get_absolute_expression ();
2997 record_alignment (seg
, align
);
3001 if (*input_line_pointer
== ',')
3003 c
= *++input_line_pointer
;
3005 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3008 as_bad (_("unrecognized section type"));
3009 ++input_line_pointer
;
3014 flags
= SEC_NO_FLAGS
;
3016 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3017 else if (*type
== 'D' || *type
== 'M')
3018 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3019 else if (*type
== 'R')
3020 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3021 if (flags
!= SEC_NO_FLAGS
)
3023 if (!bfd_set_section_flags (seg
, flags
))
3024 as_warn (_("error setting flags for \"%s\": %s"),
3025 bfd_section_name (seg
),
3026 bfd_errmsg (bfd_get_error ()));
3031 /* Ignore the HP type. */
3032 if (*input_line_pointer
== ',')
3033 input_line_pointer
+= 2;
3035 demand_empty_rest_of_line ();
3037 #else /* ! TC_M68K */
3038 /* The MRI assembler seems to use different forms of .sect for
3039 different targets. */
3040 as_bad ("MRI mode not supported for this target");
3041 ignore_rest_of_line ();
3042 #endif /* ! TC_M68K */
3045 /* Handle the .print pseudo-op. */
3048 s_print (int ignore ATTRIBUTE_UNUSED
)
3053 s
= demand_copy_C_string (&len
);
3056 demand_empty_rest_of_line ();
3059 /* Handle the .purgem pseudo-op. */
3062 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3064 if (is_it_end_of_statement ())
3066 demand_empty_rest_of_line ();
3076 c
= get_symbol_name (& name
);
3077 delete_macro (name
);
3078 *input_line_pointer
= c
;
3079 SKIP_WHITESPACE_AFTER_NAME ();
3081 while (*input_line_pointer
++ == ',');
3083 --input_line_pointer
;
3084 demand_empty_rest_of_line ();
3087 /* Handle the .endm/.endr pseudo-ops. */
3090 s_bad_end (int endr
)
3092 as_warn (_(".end%c encountered without preceding %s"),
3094 endr
? ".rept, .irp, or .irpc" : ".macro");
3095 demand_empty_rest_of_line ();
3098 /* Handle the .rept pseudo-op. */
3101 s_rept (int ignore ATTRIBUTE_UNUSED
)
3105 count
= (size_t) get_absolute_expression ();
3107 do_repeat (count
, "REPT", "ENDR");
3110 /* This function provides a generic repeat block implementation. It allows
3111 different directives to be used as the start/end keys. */
3114 do_repeat (size_t count
, const char *start
, const char *end
)
3119 if (((ssize_t
) count
) < 0)
3121 as_bad (_("negative count for %s - ignored"), start
);
3126 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3128 as_bad (_("%s without %s"), start
, end
);
3132 sb_build (&many
, count
* one
.len
);
3134 sb_add_sb (&many
, &one
);
3138 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3140 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3143 /* Like do_repeat except that any text matching EXPANDER in the
3144 block is replaced by the iteration count. */
3147 do_repeat_with_expander (size_t count
,
3150 const char * expander
)
3155 if (((ssize_t
) count
) < 0)
3157 as_bad (_("negative count for %s - ignored"), start
);
3162 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3164 as_bad (_("%s without %s"), start
, end
);
3170 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3172 while (count
-- > 0)
3178 sb_build (& processed
, one
.len
);
3179 sb_add_sb (& processed
, & one
);
3180 sub
= strstr (processed
.ptr
, expander
);
3181 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3182 gas_assert (len
< 8);
3183 memmove (sub
+ len
, sub
+ 8,
3184 processed
.ptr
+ processed
.len
- (sub
+ 8));
3185 processed
.len
-= (8 - len
);
3186 sb_add_sb (& many
, & processed
);
3187 sb_kill (& processed
);
3192 sb_add_sb (&many
, &one
);
3196 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3198 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3201 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3202 input buffers to skip. Assumes that conditionals preceding the loop end
3203 are properly nested.
3205 This function makes it easier to implement a premature "break" out of the
3206 loop. The EXTRA arg accounts for other buffers we might have inserted,
3207 such as line substitutions. */
3210 end_repeat (int extra
)
3212 cond_exit_macro (macro_nest
);
3213 while (extra
-- >= 0)
3214 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3218 assign_symbol (char *name
, int mode
)
3222 if (name
[0] == '.' && name
[1] == '\0')
3224 /* Turn '. = mumble' into a .org mumble. */
3228 segment
= get_known_segmented_expression (&exp
);
3231 do_org (segment
, &exp
, 0);
3236 if ((symbolP
= symbol_find (name
)) == NULL
3237 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3239 symbolP
= symbol_find_or_make (name
);
3241 /* When doing symbol listings, play games with dummy fragments living
3242 outside the normal fragment chain to record the file and line info
3244 if (listing
& LISTING_SYMBOLS
)
3246 extern struct list_info_struct
*listing_tail
;
3247 fragS
*dummy_frag
= XCNEW (fragS
);
3248 dummy_frag
->line
= listing_tail
;
3249 dummy_frag
->fr_symbol
= symbolP
;
3250 symbol_set_frag (symbolP
, dummy_frag
);
3253 #if defined (OBJ_COFF) && !defined (TE_PE)
3254 /* "set" symbols are local unless otherwise specified. */
3255 SF_SET_LOCAL (symbolP
);
3259 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3261 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3262 && !S_CAN_BE_REDEFINED (symbolP
))
3264 as_bad (_("symbol `%s' is already defined"), name
);
3265 ignore_rest_of_line ();
3266 input_line_pointer
--;
3269 /* If the symbol is volatile, copy the symbol and replace the
3270 original with the copy, so that previous uses of the symbol will
3271 retain the value of the symbol at the point of use. */
3272 else if (S_IS_VOLATILE (symbolP
))
3273 symbolP
= symbol_clone (symbolP
, 1);
3277 S_SET_VOLATILE (symbolP
);
3279 S_SET_FORWARD_REF (symbolP
);
3281 pseudo_set (symbolP
);
3284 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3285 then this is .equiv, and it is an error if the symbol is already
3286 defined. If EQUIV is -1, the symbol additionally is a forward
3294 /* Especial apologies for the random logic:
3295 this just grew, and could be parsed much more simply!
3297 if ((name
= read_symbol_name ()) == NULL
)
3300 if (*input_line_pointer
!= ',')
3302 as_bad (_("expected comma after \"%s\""), name
);
3303 ignore_rest_of_line ();
3308 input_line_pointer
++;
3309 assign_symbol (name
, equiv
);
3310 demand_empty_rest_of_line ();
3324 #ifdef md_flush_pending_output
3325 md_flush_pending_output ();
3328 #ifdef md_cons_align
3333 stop
= mri_comment_field (&stopc
);
3335 /* In m68k MRI mode, we need to align to a word boundary, unless
3337 if (flag_m68k_mri
&& mult
> 1)
3339 if (now_seg
== absolute_section
)
3341 abs_section_offset
+= abs_section_offset
& 1;
3342 if (line_label
!= NULL
)
3343 S_SET_VALUE (line_label
, abs_section_offset
);
3345 else if (mri_common_symbol
!= NULL
)
3349 mri_val
= S_GET_VALUE (mri_common_symbol
);
3350 if ((mri_val
& 1) != 0)
3352 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3353 if (line_label
!= NULL
)
3355 expressionS
*symexp
;
3357 symexp
= symbol_get_value_expression (line_label
);
3358 know (symexp
->X_op
== O_symbol
);
3359 know (symexp
->X_add_symbol
== mri_common_symbol
);
3360 symexp
->X_add_number
+= 1;
3366 do_align (1, (char *) NULL
, 0, 0);
3367 if (line_label
!= NULL
)
3369 symbol_set_frag (line_label
, frag_now
);
3370 S_SET_VALUE (line_label
, frag_now_fix ());
3380 if (*input_line_pointer
== ',')
3382 ++input_line_pointer
;
3387 val
.X_op
= O_constant
;
3388 val
.X_add_number
= 0;
3391 if ((val
.X_op
!= O_constant
3392 || val
.X_add_number
< - 0x80
3393 || val
.X_add_number
> 0xff
3394 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3395 && (now_seg
!= absolute_section
&& !in_bss ()))
3397 resolve_expression (&exp
);
3398 if (exp
.X_op
!= O_constant
)
3399 as_bad (_("unsupported variable size or fill value"));
3404 /* PR 20901: Check for excessive values.
3405 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3406 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3407 as_bad (_("size value for space directive too large: %lx"),
3408 (long) exp
.X_add_number
);
3413 bytes
= mult
* exp
.X_add_number
;
3415 for (i
= 0; i
< exp
.X_add_number
; i
++)
3416 emit_expr (&val
, mult
);
3422 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3423 resolve_expression (&exp
);
3425 if (exp
.X_op
== O_constant
)
3429 repeat
= exp
.X_add_number
;
3436 as_warn (_(".space repeat count is zero, ignored"));
3437 else if (repeat
< 0)
3438 as_warn (_(".space repeat count is negative, ignored"));
3442 /* If we are in the absolute section, just bump the offset. */
3443 if (now_seg
== absolute_section
)
3445 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3446 as_warn (_("ignoring fill value in absolute section"));
3447 abs_section_offset
+= repeat
;
3451 /* If we are secretly in an MRI common section, then
3452 creating space just increases the size of the common
3454 if (mri_common_symbol
!= NULL
)
3456 S_SET_VALUE (mri_common_symbol
,
3457 S_GET_VALUE (mri_common_symbol
) + repeat
);
3462 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3463 (offsetT
) repeat
, (char *) 0);
3467 if (now_seg
== absolute_section
)
3469 as_bad (_("space allocation too complex in absolute section"));
3470 subseg_set (text_section
, 0);
3473 if (mri_common_symbol
!= NULL
)
3475 as_bad (_("space allocation too complex in common section"));
3476 mri_common_symbol
= NULL
;
3480 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3481 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3484 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3485 as_warn (_("ignoring fill value in section `%s'"),
3486 segment_name (now_seg
));
3488 *p
= val
.X_add_number
;
3493 /* In MRI mode, after an odd number of bytes, we must align to an
3494 even word boundary, unless the next instruction is a dc.b, ds.b
3496 if (flag_mri
&& (bytes
& 1) != 0)
3497 mri_pending_align
= 1;
3499 demand_empty_rest_of_line ();
3502 mri_comment_end (stop
, stopc
);
3506 s_nops (int ignore ATTRIBUTE_UNUSED
)
3511 #ifdef md_flush_pending_output
3512 md_flush_pending_output ();
3515 #ifdef md_cons_align
3521 if (*input_line_pointer
== ',')
3523 ++input_line_pointer
;
3528 val
.X_op
= O_constant
;
3529 val
.X_add_number
= 0;
3532 if (val
.X_op
== O_constant
)
3534 if (val
.X_add_number
< 0)
3536 as_warn (_("negative nop control byte, ignored"));
3537 val
.X_add_number
= 0;
3542 /* Store the no-op instruction control byte in the first byte
3545 symbolS
*sym
= make_expr_symbol (&exp
);
3546 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3547 sym
, (offsetT
) 0, (char *) 0);
3548 *p
= val
.X_add_number
;
3552 as_bad (_("unsupported variable nop control in .nops directive"));
3554 demand_empty_rest_of_line ();
3557 /* This is like s_space, but the value is a floating point number with
3558 the given precision. This is for the MRI dcb.s pseudo-op and
3562 s_float_space (int float_type
)
3566 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3570 #ifdef md_cons_align
3575 stop
= mri_comment_field (&stopc
);
3577 count
= get_absolute_expression ();
3580 if (*input_line_pointer
!= ',')
3582 as_bad (_("missing value"));
3583 ignore_rest_of_line ();
3585 mri_comment_end (stop
, stopc
);
3589 ++input_line_pointer
;
3593 /* Skip any 0{letter} that may be present. Don't even check if the
3594 * letter is legal. */
3595 if (input_line_pointer
[0] == '0'
3596 && ISALPHA (input_line_pointer
[1]))
3597 input_line_pointer
+= 2;
3599 /* Accept :xxxx, where the x's are hex digits, for a floating point
3600 with the exact digits specified. */
3601 if (input_line_pointer
[0] == ':')
3603 flen
= hex_float (float_type
, temp
);
3606 ignore_rest_of_line ();
3608 mri_comment_end (stop
, stopc
);
3616 err
= md_atof (float_type
, temp
, &flen
);
3617 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3618 know (err
!= NULL
|| flen
> 0);
3621 as_bad (_("bad floating literal: %s"), err
);
3622 ignore_rest_of_line ();
3624 mri_comment_end (stop
, stopc
);
3629 while (--count
>= 0)
3633 p
= frag_more (flen
);
3634 memcpy (p
, temp
, (unsigned int) flen
);
3637 demand_empty_rest_of_line ();
3640 mri_comment_end (stop
, stopc
);
3643 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3646 s_struct (int ignore ATTRIBUTE_UNUSED
)
3652 stop
= mri_comment_field (&stopc
);
3653 abs_section_offset
= get_absolute_expression ();
3654 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3655 /* The ELF backend needs to know that we are changing sections, so
3656 that .previous works correctly. */
3658 obj_elf_section_change_hook ();
3660 subseg_set (absolute_section
, 0);
3661 demand_empty_rest_of_line ();
3663 mri_comment_end (stop
, stopc
);
3667 s_text (int ignore ATTRIBUTE_UNUSED
)
3671 temp
= get_absolute_expression ();
3672 subseg_set (text_section
, (subsegT
) temp
);
3673 demand_empty_rest_of_line ();
3676 /* .weakref x, y sets x as an alias to y that, as long as y is not
3677 referenced directly, will cause y to become a weak symbol. */
3679 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3686 if ((name
= read_symbol_name ()) == NULL
)
3689 symbolP
= symbol_find_or_make (name
);
3691 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3693 if (!S_IS_VOLATILE (symbolP
))
3695 as_bad (_("symbol `%s' is already defined"), name
);
3698 symbolP
= symbol_clone (symbolP
, 1);
3699 S_CLEAR_VOLATILE (symbolP
);
3704 if (*input_line_pointer
!= ',')
3706 as_bad (_("expected comma after \"%s\""), name
);
3710 input_line_pointer
++;
3715 if ((name
= read_symbol_name ()) == NULL
)
3718 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3719 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3721 symbolP2
= symbol_find_or_make (name
);
3722 S_SET_WEAKREFD (symbolP2
);
3726 symbolS
*symp
= symbolP2
;
3728 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3730 expressionS
*expP
= symbol_get_value_expression (symp
);
3732 gas_assert (expP
->X_op
== O_symbol
3733 && expP
->X_add_number
== 0);
3734 symp
= expP
->X_add_symbol
;
3736 if (symp
== symbolP
)
3740 loop
= concat (S_GET_NAME (symbolP
),
3741 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3744 while (symp
!= symbolP
)
3746 char *old_loop
= loop
;
3748 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3749 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3750 (const char *) NULL
);
3754 as_bad (_("%s: would close weakref loop: %s"),
3755 S_GET_NAME (symbolP
), loop
);
3759 ignore_rest_of_line ();
3763 /* Short-circuiting instead of just checking here might speed
3764 things up a tiny little bit, but loop error messages would
3765 miss intermediate links. */
3766 /* symbolP2 = symp; */
3769 memset (&exp
, 0, sizeof (exp
));
3770 exp
.X_op
= O_symbol
;
3771 exp
.X_add_symbol
= symbolP2
;
3773 S_SET_SEGMENT (symbolP
, undefined_section
);
3774 symbol_set_value_expression (symbolP
, &exp
);
3775 symbol_set_frag (symbolP
, &zero_address_frag
);
3776 S_SET_WEAKREFR (symbolP
);
3778 demand_empty_rest_of_line ();
3783 ignore_rest_of_line ();
3789 /* Verify that we are at the end of a line. If not, issue an error and
3793 demand_empty_rest_of_line (void)
3796 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3797 input_line_pointer
++;
3800 if (ISPRINT (*input_line_pointer
))
3801 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3802 *input_line_pointer
);
3804 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3805 *input_line_pointer
);
3806 ignore_rest_of_line ();
3809 /* Return pointing just after end-of-line. */
3810 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3813 /* Silently advance to the end of line. Use this after already having
3814 issued an error about something bad. */
3817 ignore_rest_of_line (void)
3819 while (input_line_pointer
< buffer_limit
3820 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3821 input_line_pointer
++;
3823 input_line_pointer
++;
3825 /* Return pointing just after end-of-line. */
3826 if (input_line_pointer
<= buffer_limit
)
3827 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3830 /* Sets frag for given symbol to zero_address_frag, except when the
3831 symbol frag is already set to a dummy listing frag. */
3834 set_zero_frag (symbolS
*symbolP
)
3836 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3837 symbol_set_frag (symbolP
, &zero_address_frag
);
3840 /* In: Pointer to a symbol.
3841 Input_line_pointer->expression.
3843 Out: Input_line_pointer->just after any whitespace after expression.
3844 Tried to set symbol to value of expression.
3845 Will change symbols type, value, and frag; */
3848 pseudo_set (symbolS
*symbolP
)
3853 know (symbolP
); /* NULL pointer is logic error. */
3855 if (!S_IS_FORWARD_REF (symbolP
))
3856 (void) expression (&exp
);
3858 (void) deferred_expression (&exp
);
3860 if (exp
.X_op
== O_illegal
)
3861 as_bad (_("illegal expression"));
3862 else if (exp
.X_op
== O_absent
)
3863 as_bad (_("missing expression"));
3864 else if (exp
.X_op
== O_big
)
3866 if (exp
.X_add_number
> 0)
3867 as_bad (_("bignum invalid"));
3869 as_bad (_("floating point number invalid"));
3871 else if (exp
.X_op
== O_subtract
3872 && !S_IS_FORWARD_REF (symbolP
)
3873 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3874 && (symbol_get_frag (exp
.X_add_symbol
)
3875 == symbol_get_frag (exp
.X_op_symbol
)))
3877 exp
.X_op
= O_constant
;
3878 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3879 - S_GET_VALUE (exp
.X_op_symbol
));
3882 if (symbol_section_p (symbolP
))
3884 as_bad ("attempt to set value of section symbol");
3893 exp
.X_add_number
= 0;
3896 S_SET_SEGMENT (symbolP
, absolute_section
);
3897 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3898 set_zero_frag (symbolP
);
3902 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3903 if (S_IS_EXTERNAL (symbolP
))
3905 as_bad ("can't equate global symbol `%s' with register name",
3906 S_GET_NAME (symbolP
));
3910 S_SET_SEGMENT (symbolP
, reg_section
);
3911 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3912 set_zero_frag (symbolP
);
3913 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3917 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3918 /* For x=undef+const, create an expression symbol.
3919 For x=x+const, just update x except when x is an undefined symbol
3920 For x=defined+const, evaluate x. */
3921 if (symbolP
== exp
.X_add_symbol
3922 && (seg
!= undefined_section
3923 || !symbol_constant_p (symbolP
)))
3925 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3928 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3930 symbolS
*s
= exp
.X_add_symbol
;
3932 if (S_IS_COMMON (s
))
3933 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3934 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3936 S_SET_SEGMENT (symbolP
, seg
);
3937 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3938 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3939 copy_symbol_attributes (symbolP
, s
);
3942 S_SET_SEGMENT (symbolP
, undefined_section
);
3943 symbol_set_value_expression (symbolP
, &exp
);
3944 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3945 set_zero_frag (symbolP
);
3949 /* The value is some complex expression. */
3950 S_SET_SEGMENT (symbolP
, expr_section
);
3951 symbol_set_value_expression (symbolP
, &exp
);
3952 set_zero_frag (symbolP
);
3959 CONStruct more frag of .bytes, or .words etc.
3960 Should need_pass_2 be 1 then emit no frag(s).
3961 This understands EXPRESSIONS.
3965 This has a split personality. We use expression() to read the
3966 value. We can detect if the value won't fit in a byte or word.
3967 But we can't detect if expression() discarded significant digits
3968 in the case of a long. Not worth the crocks required to fix it. */
3970 /* Select a parser for cons expressions. */
3972 /* Some targets need to parse the expression in various fancy ways.
3973 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3974 (for example, the HPPA does this). Otherwise, you can define
3975 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3976 are defined, which is the normal case, then only simple expressions
3981 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3984 #ifndef TC_PARSE_CONS_EXPRESSION
3985 #ifdef REPEAT_CONS_EXPRESSIONS
3986 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3987 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3989 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3992 /* If we haven't gotten one yet, just call expression. */
3993 #ifndef TC_PARSE_CONS_EXPRESSION
3994 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3995 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4000 do_parse_cons_expression (expressionS
*exp
,
4001 int nbytes ATTRIBUTE_UNUSED
)
4003 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4007 /* Worker to do .byte etc statements.
4008 Clobbers input_line_pointer and checks end-of-line. */
4011 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4019 #ifdef md_flush_pending_output
4020 md_flush_pending_output ();
4024 stop
= mri_comment_field (&stopc
);
4026 if (is_it_end_of_statement ())
4028 demand_empty_rest_of_line ();
4030 mri_comment_end (stop
, stopc
);
4034 #ifdef TC_ADDRESS_BYTES
4036 nbytes
= TC_ADDRESS_BYTES ();
4039 #ifdef md_cons_align
4040 md_cons_align (nbytes
);
4046 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4047 #ifdef TC_CONS_FIX_CHECK
4048 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4050 if (*cur_fix
!= NULL
)
4051 cur_fix
= &(*cur_fix
)->fx_next
;
4056 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4061 if (*input_line_pointer
== '"')
4063 as_bad (_("unexpected `\"' in expression"));
4064 ignore_rest_of_line ();
4068 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4073 if (exp
.X_op
== O_symbol
)
4074 exp
.X_op
= O_symbol_rva
;
4076 as_fatal (_("rva without symbol"));
4078 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4079 #ifdef TC_CONS_FIX_CHECK
4080 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4084 while (*input_line_pointer
++ == ',');
4086 /* In MRI mode, after an odd number of bytes, we must align to an
4087 even word boundary, unless the next instruction is a dc.b, ds.b
4089 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4090 mri_pending_align
= 1;
4092 input_line_pointer
--; /* Put terminator back into stream. */
4094 demand_empty_rest_of_line ();
4097 mri_comment_end (stop
, stopc
);
4103 cons_worker (size
, 0);
4109 cons_worker (size
, 1);
4112 /* .reloc offset, reloc_name, symbol+addend. */
4115 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4122 struct reloc_list
*reloc
;
4123 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4124 static struct _bfd_rel bfd_relocs
[] =
4126 { "NONE", BFD_RELOC_NONE
},
4127 { "8", BFD_RELOC_8
},
4128 { "16", BFD_RELOC_16
},
4129 { "32", BFD_RELOC_32
},
4130 { "64", BFD_RELOC_64
}
4133 reloc
= XNEW (struct reloc_list
);
4136 stop
= mri_comment_field (&stopc
);
4145 as_bad (_("missing or bad offset expression"));
4148 exp
.X_add_symbol
= section_symbol (now_seg
);
4149 exp
.X_op
= O_symbol
;
4152 if (exp
.X_add_number
== 0)
4154 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4159 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4164 if (*input_line_pointer
!= ',')
4166 as_bad (_("missing reloc type"));
4170 ++input_line_pointer
;
4172 c
= get_symbol_name (& r_name
);
4173 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4177 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4178 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4180 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4181 bfd_relocs
[i
].code
);
4186 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4187 *input_line_pointer
= c
;
4188 if (reloc
->u
.a
.howto
== NULL
)
4190 as_bad (_("unrecognized reloc type"));
4194 exp
.X_op
= O_absent
;
4195 SKIP_WHITESPACE_AFTER_NAME ();
4196 if (*input_line_pointer
== ',')
4198 ++input_line_pointer
;
4206 as_bad (_("bad reloc expression"));
4208 ignore_rest_of_line ();
4211 mri_comment_end (stop
, stopc
);
4214 reloc
->u
.a
.sym
= NULL
;
4215 reloc
->u
.a
.addend
= 0;
4218 reloc
->u
.a
.sym
= NULL
;
4219 reloc
->u
.a
.addend
= exp
.X_add_number
;
4222 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4223 reloc
->u
.a
.addend
= exp
.X_add_number
;
4226 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4227 reloc
->u
.a
.addend
= 0;
4231 reloc
->file
= as_where (&reloc
->line
);
4232 reloc
->next
= reloc_list
;
4235 demand_empty_rest_of_line ();
4237 mri_comment_end (stop
, stopc
);
4240 /* Put the contents of expression EXP into the object file using
4241 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4244 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4246 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4250 emit_expr_with_reloc (expressionS
*exp
,
4251 unsigned int nbytes
,
4252 TC_PARSE_CONS_RETURN_TYPE reloc
)
4256 valueT extra_digit
= 0;
4258 /* Don't do anything if we are going to make another pass. */
4263 dot_value
= frag_now_fix ();
4264 dot_frag
= frag_now
;
4268 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4269 appear as a four byte positive constant in the .line section,
4270 followed by a 2 byte 0xffff. Look for that case here. */
4272 static int dwarf_line
= -1;
4274 if (strcmp (segment_name (now_seg
), ".line") != 0)
4276 else if (dwarf_line
>= 0
4278 && exp
->X_op
== O_constant
4279 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4280 listing_source_line ((unsigned int) dwarf_line
);
4281 else if (nbytes
== 4
4282 && exp
->X_op
== O_constant
4283 && exp
->X_add_number
>= 0)
4284 dwarf_line
= exp
->X_add_number
;
4289 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4290 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4291 AT_sibling (0x12) followed by a four byte address of the sibling
4292 followed by a 2 byte AT_name (0x38) followed by the name of the
4293 file. We look for that case here. */
4295 static int dwarf_file
= 0;
4297 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4299 else if (dwarf_file
== 0
4301 && exp
->X_op
== O_constant
4302 && exp
->X_add_number
== 0x11)
4304 else if (dwarf_file
== 1
4306 && exp
->X_op
== O_constant
4307 && exp
->X_add_number
== 0x12)
4309 else if (dwarf_file
== 2
4312 else if (dwarf_file
== 3
4314 && exp
->X_op
== O_constant
4315 && exp
->X_add_number
== 0x38)
4320 /* The variable dwarf_file_string tells stringer that the string
4321 may be the name of the source file. */
4322 if (dwarf_file
== 4)
4323 dwarf_file_string
= 1;
4325 dwarf_file_string
= 0;
4330 if (check_eh_frame (exp
, &nbytes
))
4335 /* Handle a negative bignum. */
4337 && exp
->X_add_number
== 0
4338 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4339 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4342 unsigned long carry
;
4344 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4346 /* Negate the bignum: one's complement each digit and add 1. */
4348 for (i
= 0; i
< exp
->X_add_number
; i
++)
4352 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4355 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4356 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4359 /* We can ignore any carry out, because it will be handled by
4360 extra_digit if it is needed. */
4362 extra_digit
= (valueT
) -1;
4366 if (op
== O_absent
|| op
== O_illegal
)
4368 as_warn (_("zero assumed for missing expression"));
4369 exp
->X_add_number
= 0;
4372 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4374 as_bad (_("floating point number invalid"));
4375 exp
->X_add_number
= 0;
4378 else if (op
== O_register
)
4380 as_warn (_("register value used as expression"));
4384 /* Allow `.word 0' in the absolute section. */
4385 if (now_seg
== absolute_section
)
4387 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4388 as_bad (_("attempt to store value in absolute section"));
4389 abs_section_offset
+= nbytes
;
4393 /* Allow `.word 0' in BSS style sections. */
4394 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4395 as_bad (_("attempt to store non-zero value in section `%s'"),
4396 segment_name (now_seg
));
4398 p
= frag_more ((int) nbytes
);
4400 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4402 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4406 #ifndef WORKING_DOT_WORD
4407 /* If we have the difference of two symbols in a word, save it on
4408 the broken_words list. See the code in write.c. */
4409 if (op
== O_subtract
&& nbytes
== 2)
4411 struct broken_word
*x
;
4413 x
= XNEW (struct broken_word
);
4414 x
->next_broken_word
= broken_words
;
4417 x
->subseg
= now_subseg
;
4419 x
->word_goes_here
= p
;
4421 x
->add
= exp
->X_add_symbol
;
4422 x
->sub
= exp
->X_op_symbol
;
4423 x
->addnum
= exp
->X_add_number
;
4431 /* If we have an integer, but the number of bytes is too large to
4432 pass to md_number_to_chars, handle it as a bignum. */
4433 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4435 extra_digit
= exp
->X_unsigned
? 0 : -1;
4436 convert_to_bignum (exp
, !exp
->X_unsigned
);
4440 if (op
== O_constant
)
4448 /* JF << of >= number of bits in the object is undefined. In
4449 particular SPARC (Sun 4) has problems. */
4450 if (nbytes
>= sizeof (valueT
))
4453 if (nbytes
> sizeof (valueT
))
4456 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4460 /* Don't store these bits. */
4461 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4462 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4465 unmask
= ~mask
; /* Do store these bits. */
4468 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4469 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4472 get
= exp
->X_add_number
;
4474 if ((get
& mask
) != 0
4475 && ((get
& mask
) != mask
4476 || (get
& hibit
) == 0))
4478 /* Leading bits contain both 0s & 1s. */
4479 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4481 as_warn (_("value 0x%llx truncated to 0x%llx"),
4482 (unsigned long long) get
, (unsigned long long) use
);
4484 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4485 (unsigned long long) get
, (unsigned long long) use
);
4488 as_warn (_("value 0x%lx truncated to 0x%lx"),
4489 (unsigned long) get
, (unsigned long) use
);
4492 /* Put bytes in right order. */
4493 md_number_to_chars (p
, use
, (int) nbytes
);
4495 else if (op
== O_big
)
4498 LITTLENUM_TYPE
*nums
;
4500 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4503 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4507 LITTLENUM_TYPE sign
= 0;
4508 if ((generic_bignum
[--i
]
4509 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4510 sign
= ~(LITTLENUM_TYPE
) 0;
4512 while (++i
< exp
->X_add_number
)
4513 if (generic_bignum
[i
] != sign
)
4516 else if (nbytes
== 1)
4518 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4519 Check that bits 8.. of generic_bignum[0] match bit 7
4520 and that they match all of generic_bignum[1..exp->X_add_number]. */
4521 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4522 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4524 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4526 while (++i
< exp
->X_add_number
)
4527 if (generic_bignum
[i
] != sign
)
4532 if (i
< exp
->X_add_number
)
4533 as_warn (ngettext ("bignum truncated to %d byte",
4534 "bignum truncated to %d bytes",
4542 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4545 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4547 if (target_big_endian
)
4549 while (nbytes
> size
)
4551 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4552 nbytes
-= CHARS_PER_LITTLENUM
;
4553 p
+= CHARS_PER_LITTLENUM
;
4556 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4557 while (size
>= CHARS_PER_LITTLENUM
)
4560 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4561 size
-= CHARS_PER_LITTLENUM
;
4562 p
+= CHARS_PER_LITTLENUM
;
4567 nums
= generic_bignum
;
4568 while (size
>= CHARS_PER_LITTLENUM
)
4570 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4572 size
-= CHARS_PER_LITTLENUM
;
4573 p
+= CHARS_PER_LITTLENUM
;
4574 nbytes
-= CHARS_PER_LITTLENUM
;
4577 while (nbytes
>= CHARS_PER_LITTLENUM
)
4579 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4580 nbytes
-= CHARS_PER_LITTLENUM
;
4581 p
+= CHARS_PER_LITTLENUM
;
4586 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4590 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4591 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4594 unsigned int size
= nbytes
;
4596 memset (p
, 0, size
);
4598 /* Generate a fixS to record the symbol value. */
4600 #ifdef TC_CONS_FIX_NEW
4601 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4603 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4605 reloc_howto_type
*reloc_howto
;
4607 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4608 size
= bfd_get_reloc_size (reloc_howto
);
4612 as_bad (ngettext ("%s relocations do not fit in %u byte",
4613 "%s relocations do not fit in %u bytes",
4615 reloc_howto
->name
, nbytes
);
4618 else if (target_big_endian
)
4619 offset
= nbytes
- size
;
4640 as_bad (_("unsupported BFD relocation size %u"), size
);
4643 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4648 /* Handle an MRI style string expression. */
4652 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4654 if (*input_line_pointer
!= '\''
4655 && (input_line_pointer
[1] != '\''
4656 || (*input_line_pointer
!= 'A'
4657 && *input_line_pointer
!= 'E')))
4658 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4662 unsigned int result
= 0;
4664 /* An MRI style string. Cut into as many bytes as will fit into
4665 a nbyte chunk, left justify if necessary, and separate with
4666 commas so we can try again later. */
4667 if (*input_line_pointer
== 'A')
4668 ++input_line_pointer
;
4669 else if (*input_line_pointer
== 'E')
4671 as_bad (_("EBCDIC constants are not supported"));
4672 ++input_line_pointer
;
4675 input_line_pointer
++;
4676 for (scan
= 0; scan
< nbytes
; scan
++)
4678 if (*input_line_pointer
== '\'')
4680 if (input_line_pointer
[1] == '\'')
4682 input_line_pointer
++;
4687 result
= (result
<< 8) | (*input_line_pointer
++);
4691 while (scan
< nbytes
)
4697 /* Create correct expression. */
4698 exp
->X_op
= O_constant
;
4699 exp
->X_add_number
= result
;
4701 /* Fake it so that we can read the next char too. */
4702 if (input_line_pointer
[0] != '\'' ||
4703 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4705 input_line_pointer
-= 2;
4706 input_line_pointer
[0] = ',';
4707 input_line_pointer
[1] = '\'';
4710 input_line_pointer
++;
4713 #endif /* TC_M68K */
4715 #ifdef REPEAT_CONS_EXPRESSIONS
4717 /* Parse a repeat expression for cons. This is used by the MIPS
4718 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4719 object file COUNT times.
4721 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4724 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4731 if (*input_line_pointer
!= ':')
4733 /* No repeat count. */
4737 ++input_line_pointer
;
4738 expression (&count
);
4739 if (count
.X_op
!= O_constant
4740 || count
.X_add_number
<= 0)
4742 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4746 /* The cons function is going to output this expression once. So we
4747 output it count - 1 times. */
4748 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4749 emit_expr (exp
, nbytes
);
4752 #endif /* REPEAT_CONS_EXPRESSIONS */
4754 /* Parse a floating point number represented as a hex constant. This
4755 permits users to specify the exact bits they want in the floating
4759 hex_float (int float_type
, char *bytes
)
4791 as_bad (_("unknown floating type type '%c'"), float_type
);
4795 /* It would be nice if we could go through expression to parse the
4796 hex constant, but if we get a bignum it's a pain to sort it into
4797 the buffer correctly. */
4799 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4803 /* The MRI assembler accepts arbitrary underscores strewn about
4804 through the hex constant, so we ignore them as well. */
4805 if (*input_line_pointer
== '_')
4807 ++input_line_pointer
;
4813 as_warn (_("floating point constant too large"));
4816 d
= hex_value (*input_line_pointer
) << 4;
4817 ++input_line_pointer
;
4818 while (*input_line_pointer
== '_')
4819 ++input_line_pointer
;
4820 if (hex_p (*input_line_pointer
))
4822 d
+= hex_value (*input_line_pointer
);
4823 ++input_line_pointer
;
4825 if (target_big_endian
)
4828 bytes
[length
- i
- 1] = d
;
4834 if (target_big_endian
)
4835 memset (bytes
+ i
, 0, length
- i
);
4837 memset (bytes
, 0, length
- i
);
4845 CONStruct some more frag chars of .floats .ffloats etc.
4846 Makes 0 or more new frags.
4847 If need_pass_2 == 1, no frags are emitted.
4848 This understands only floating literals, not expressions. Sorry.
4850 A floating constant is defined by atof_generic(), except it is preceded
4851 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4852 reading, I decided to be incompatible. This always tries to give you
4853 rounded bits to the precision of the pseudo-op. Former AS did premature
4854 truncation, restored noisy bits instead of trailing 0s AND gave you
4855 a choice of 2 flavours of noise according to which of 2 floating-point
4856 scanners you directed AS to use.
4858 In: input_line_pointer->whitespace before, or '0' of flonum. */
4861 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4862 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4865 int length
; /* Number of chars in an object. */
4866 const char *err
; /* Error from scanning floating literal. */
4867 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4869 if (is_it_end_of_statement ())
4871 demand_empty_rest_of_line ();
4875 if (now_seg
== absolute_section
)
4877 as_bad (_("attempt to store float in absolute section"));
4878 ignore_rest_of_line ();
4884 as_bad (_("attempt to store float in section `%s'"),
4885 segment_name (now_seg
));
4886 ignore_rest_of_line ();
4890 #ifdef md_flush_pending_output
4891 md_flush_pending_output ();
4894 #ifdef md_cons_align
4900 /* input_line_pointer->1st char of a flonum (we hope!). */
4903 /* Skip any 0{letter} that may be present. Don't even check if the
4904 letter is legal. Someone may invent a "z" format and this routine
4905 has no use for such information. Lusers beware: you get
4906 diagnostics if your input is ill-conditioned. */
4907 if (input_line_pointer
[0] == '0'
4908 && ISALPHA (input_line_pointer
[1]))
4909 input_line_pointer
+= 2;
4911 /* Accept :xxxx, where the x's are hex digits, for a floating
4912 point with the exact digits specified. */
4913 if (input_line_pointer
[0] == ':')
4915 ++input_line_pointer
;
4916 length
= hex_float (float_type
, temp
);
4919 ignore_rest_of_line ();
4925 err
= md_atof (float_type
, temp
, &length
);
4926 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4927 know (err
!= NULL
|| length
> 0);
4930 as_bad (_("bad floating literal: %s"), err
);
4931 ignore_rest_of_line ();
4942 #ifdef REPEAT_CONS_EXPRESSIONS
4943 if (*input_line_pointer
== ':')
4945 expressionS count_exp
;
4947 ++input_line_pointer
;
4948 expression (&count_exp
);
4950 if (count_exp
.X_op
!= O_constant
4951 || count_exp
.X_add_number
<= 0)
4952 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4954 count
= count_exp
.X_add_number
;
4958 while (--count
>= 0)
4960 p
= frag_more (length
);
4961 memcpy (p
, temp
, (unsigned int) length
);
4966 while (*input_line_pointer
++ == ',');
4968 /* Put terminator back into stream. */
4969 --input_line_pointer
;
4970 demand_empty_rest_of_line ();
4975 Note - we are using the DWARF standard's definition of LEB128 encoding
4976 where each 7-bit value is a stored in a byte, *not* an octet. This
4977 means that on targets where a byte contains multiple octets there is
4978 a *huge waste of space*. (This also means that we do not have to
4979 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4982 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4983 we would then have to consider whether multiple, successive LEB128
4984 values should be packed into the bytes without padding (bad idea) or
4985 whether each LEB128 number is padded out to a whole number of bytes.
4986 Plus you have to decide on the endianness of packing octets into a
4989 /* Return the size of a LEB128 value in bytes. */
4991 static inline unsigned int
4992 sizeof_sleb128 (offsetT value
)
4999 byte
= (value
& 0x7f);
5000 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5001 Fortunately, we can structure things so that the extra work reduces
5002 to a noop on systems that do things "properly". */
5003 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5006 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5007 || ((value
== -1) && ((byte
& 0x40) != 0))));
5012 static inline unsigned int
5013 sizeof_uleb128 (valueT value
)
5028 sizeof_leb128 (valueT value
, int sign
)
5031 return sizeof_sleb128 ((offsetT
) value
);
5033 return sizeof_uleb128 (value
);
5036 /* Output a LEB128 value. Returns the number of bytes used. */
5038 static inline unsigned int
5039 output_sleb128 (char *p
, offsetT value
)
5046 unsigned byte
= (value
& 0x7f);
5048 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5049 Fortunately, we can structure things so that the extra work reduces
5050 to a noop on systems that do things "properly". */
5051 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5053 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5054 || ((value
== -1) && ((byte
& 0x40) != 0))));
5065 static inline unsigned int
5066 output_uleb128 (char *p
, valueT value
)
5072 unsigned byte
= (value
& 0x7f);
5076 /* More bytes to follow. */
5087 output_leb128 (char *p
, valueT value
, int sign
)
5090 return output_sleb128 (p
, (offsetT
) value
);
5092 return output_uleb128 (p
, value
);
5095 /* Do the same for bignums. We combine sizeof with output here in that
5096 we don't output for NULL values of P. It isn't really as critical as
5097 for "normal" values that this be streamlined. Returns the number of
5100 static inline unsigned int
5101 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5108 /* Strip leading sign extensions off the bignum. */
5110 && bignum
[size
- 1] == LITTLENUM_MASK
5111 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5116 /* OR in the next part of the littlenum. */
5117 val
|= (*bignum
<< loaded
);
5118 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5122 /* Add bytes until there are less than 7 bits left in VAL
5123 or until every non-sign bit has been written. */
5130 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5137 while ((byte
& 0x80) != 0 && loaded
>= 7);
5141 /* Mop up any left-over bits (of which there will be less than 7). */
5142 if ((byte
& 0x80) != 0)
5144 /* Sign-extend VAL. */
5145 if (val
& (1 << (loaded
- 1)))
5146 val
|= ~0U << loaded
;
5155 static inline unsigned int
5156 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5163 /* Strip leading zeros off the bignum. */
5164 /* XXX: Is this needed? */
5165 while (size
> 0 && bignum
[size
- 1] == 0)
5170 if (loaded
< 7 && size
> 0)
5172 val
|= (*bignum
<< loaded
);
5173 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5182 if (size
> 0 || val
)
5189 while (byte
& 0x80);
5195 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5198 return output_big_sleb128 (p
, bignum
, size
);
5200 return output_big_uleb128 (p
, bignum
, size
);
5203 /* Generate the appropriate fragments for a given expression to emit a
5204 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5207 emit_leb128_expr (expressionS
*exp
, int sign
)
5209 operatorT op
= exp
->X_op
;
5210 unsigned int nbytes
;
5212 if (op
== O_absent
|| op
== O_illegal
)
5214 as_warn (_("zero assumed for missing expression"));
5215 exp
->X_add_number
= 0;
5218 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5220 as_bad (_("floating point number invalid"));
5221 exp
->X_add_number
= 0;
5224 else if (op
== O_register
)
5226 as_warn (_("register value used as expression"));
5229 else if (op
== O_constant
5231 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5233 /* We're outputting a signed leb128 and the sign of X_add_number
5234 doesn't reflect the sign of the original value. Convert EXP
5235 to a correctly-extended bignum instead. */
5236 convert_to_bignum (exp
, exp
->X_extrabit
);
5240 if (now_seg
== absolute_section
)
5242 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5243 as_bad (_("attempt to store value in absolute section"));
5244 abs_section_offset
++;
5248 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5249 as_bad (_("attempt to store non-zero value in section `%s'"),
5250 segment_name (now_seg
));
5252 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5253 a signal that this is leb128 data. It shouldn't optimize this away. */
5254 nbytes
= (unsigned int) -1;
5255 if (check_eh_frame (exp
, &nbytes
))
5258 /* Let the backend know that subsequent data may be byte aligned. */
5259 #ifdef md_cons_align
5263 if (op
== O_constant
)
5265 /* If we've got a constant, emit the thing directly right now. */
5267 valueT value
= exp
->X_add_number
;
5271 size
= sizeof_leb128 (value
, sign
);
5272 p
= frag_more (size
);
5273 if (output_leb128 (p
, value
, sign
) > size
)
5276 else if (op
== O_big
)
5278 /* O_big is a different sort of constant. */
5279 int nbr_digits
= exp
->X_add_number
;
5283 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5284 a signed number. Unary operators like - or ~ always extend the
5285 bignum to its largest size. */
5287 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5288 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5289 generic_bignum
[nbr_digits
++] = 0;
5291 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5292 p
= frag_more (size
);
5293 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5298 /* Otherwise, we have to create a variable sized fragment and
5299 resolve things later. */
5301 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5302 make_expr_symbol (exp
), 0, (char *) NULL
);
5306 /* Parse the .sleb128 and .uleb128 pseudos. */
5313 #ifdef md_flush_pending_output
5314 md_flush_pending_output ();
5320 emit_leb128_expr (&exp
, sign
);
5322 while (*input_line_pointer
++ == ',');
5324 input_line_pointer
--;
5325 demand_empty_rest_of_line ();
5329 stringer_append_char (int c
, int bitsize
)
5332 as_bad (_("attempt to store non-empty string in section `%s'"),
5333 segment_name (now_seg
));
5335 if (!target_big_endian
)
5336 FRAG_APPEND_1_CHAR (c
);
5341 FRAG_APPEND_1_CHAR (0);
5342 FRAG_APPEND_1_CHAR (0);
5343 FRAG_APPEND_1_CHAR (0);
5344 FRAG_APPEND_1_CHAR (0);
5347 FRAG_APPEND_1_CHAR (0);
5348 FRAG_APPEND_1_CHAR (0);
5351 FRAG_APPEND_1_CHAR (0);
5356 /* Called with invalid bitsize argument. */
5360 if (target_big_endian
)
5361 FRAG_APPEND_1_CHAR (c
);
5364 /* Worker to do .ascii etc statements.
5365 Reads 0 or more ',' separated, double-quoted strings.
5366 Caller should have checked need_pass_2 is FALSE because we don't
5368 Checks for end-of-line.
5369 BITS_APPENDZERO says how many bits are in a target char.
5370 The bottom bit is set if a NUL char should be appended to the strings. */
5373 stringer (int bits_appendzero
)
5375 const int bitsize
= bits_appendzero
& ~7;
5376 const int append_zero
= bits_appendzero
& 1;
5378 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5382 #ifdef md_flush_pending_output
5383 md_flush_pending_output ();
5386 #ifdef md_cons_align
5390 /* If we have been switched into the abs_section then we
5391 will not have an obstack onto which we can hang strings. */
5392 if (now_seg
== absolute_section
)
5394 as_bad (_("strings must be placed into a section"));
5395 ignore_rest_of_line ();
5399 /* The following awkward logic is to parse ZERO or more strings,
5400 comma separated. Recall a string expression includes spaces
5401 before the opening '\"' and spaces after the closing '\"'.
5402 We fake a leading ',' if there is (supposed to be)
5403 a 1st, expression. We keep demanding expressions for each ','. */
5404 if (is_it_end_of_statement ())
5406 c
= 0; /* Skip loop. */
5407 ++input_line_pointer
; /* Compensate for end of loop. */
5411 c
= ','; /* Do loop. */
5414 while (c
== ',' || c
== '<' || c
== '"')
5417 switch (*input_line_pointer
)
5420 ++input_line_pointer
; /*->1st char of string. */
5421 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5422 start
= input_line_pointer
;
5425 while (is_a_char (c
= next_char_of_string ()))
5426 stringer_append_char (c
, bitsize
);
5429 stringer_append_char (0, bitsize
);
5431 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5432 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5433 will emit .string with a filename in the .debug section
5434 after a sequence of constants. See the comment in
5435 emit_expr for the sequence. emit_expr will set
5436 dwarf_file_string to non-zero if this string might be a
5437 source file name. */
5438 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5439 dwarf_file_string
= 0;
5440 else if (dwarf_file_string
)
5442 c
= input_line_pointer
[-1];
5443 input_line_pointer
[-1] = '\0';
5444 listing_source_file (start
);
5445 input_line_pointer
[-1] = c
;
5451 input_line_pointer
++;
5452 c
= get_single_number ();
5453 stringer_append_char (c
, bitsize
);
5454 if (*input_line_pointer
!= '>')
5456 as_bad (_("expected <nn>"));
5457 ignore_rest_of_line ();
5460 input_line_pointer
++;
5463 input_line_pointer
++;
5467 c
= *input_line_pointer
;
5470 demand_empty_rest_of_line ();
5473 /* FIXME-SOMEDAY: I had trouble here on characters with the
5474 high bits set. We'll probably also have trouble with
5475 multibyte chars, wide chars, etc. Also be careful about
5476 returning values bigger than 1 byte. xoxorich. */
5479 next_char_of_string (void)
5483 c
= *input_line_pointer
++ & CHAR_MASK
;
5487 /* PR 20902: Do not advance past the end of the buffer. */
5488 -- input_line_pointer
;
5497 as_warn (_("unterminated string; newline inserted"));
5498 bump_line_counters ();
5502 if (!TC_STRING_ESCAPES
)
5504 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5532 break; /* As itself. */
5548 for (i
= 0, number
= 0;
5549 ISDIGIT (c
) && i
< 3;
5550 c
= *input_line_pointer
++, i
++)
5552 number
= number
* 8 + c
- '0';
5555 c
= number
& CHAR_MASK
;
5557 --input_line_pointer
;
5566 c
= *input_line_pointer
++;
5567 while (ISXDIGIT (c
))
5570 number
= number
* 16 + c
- '0';
5571 else if (ISUPPER (c
))
5572 number
= number
* 16 + c
- 'A' + 10;
5574 number
= number
* 16 + c
- 'a' + 10;
5575 c
= *input_line_pointer
++;
5577 c
= number
& CHAR_MASK
;
5578 --input_line_pointer
;
5583 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5584 as_warn (_("unterminated string; newline inserted"));
5586 bump_line_counters ();
5590 /* Do not advance past the end of the buffer. */
5591 -- input_line_pointer
;
5597 #ifdef ONLY_STANDARD_ESCAPES
5598 as_bad (_("bad escaped character in string"));
5600 #endif /* ONLY_STANDARD_ESCAPES */
5613 get_segmented_expression (expressionS
*expP
)
5617 retval
= expression (expP
);
5618 if (expP
->X_op
== O_illegal
5619 || expP
->X_op
== O_absent
5620 || expP
->X_op
== O_big
)
5622 as_bad (_("expected address expression"));
5623 expP
->X_op
= O_constant
;
5624 expP
->X_add_number
= 0;
5625 retval
= absolute_section
;
5631 get_known_segmented_expression (expressionS
*expP
)
5633 segT retval
= get_segmented_expression (expP
);
5635 if (retval
== undefined_section
)
5637 /* There is no easy way to extract the undefined symbol from the
5639 if (expP
->X_add_symbol
!= NULL
5640 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5641 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5642 S_GET_NAME (expP
->X_add_symbol
));
5644 as_warn (_("some symbol undefined; zero assumed"));
5645 retval
= absolute_section
;
5646 expP
->X_op
= O_constant
;
5647 expP
->X_add_number
= 0;
5652 char /* Return terminator. */
5653 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5655 /* FIXME: val_pointer should probably be offsetT *. */
5656 *val_pointer
= (long) get_absolute_expression ();
5657 return (*input_line_pointer
++);
5660 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5661 Give a warning if that happens. */
5664 demand_copy_C_string (int *len_pointer
)
5668 if ((s
= demand_copy_string (len_pointer
)) != 0)
5672 for (len
= *len_pointer
; len
> 0; len
--)
5679 as_bad (_("this string may not contain \'\\0\'"));
5687 /* Demand string, but return a safe (=private) copy of the string.
5688 Return NULL if we can't read a string here. */
5691 demand_copy_string (int *lenP
)
5699 if (*input_line_pointer
== '\"')
5701 input_line_pointer
++; /* Skip opening quote. */
5703 while (is_a_char (c
= next_char_of_string ()))
5705 obstack_1grow (¬es
, c
);
5708 /* JF this next line is so demand_copy_C_string will return a
5709 null terminated string. */
5710 obstack_1grow (¬es
, '\0');
5711 retval
= (char *) obstack_finish (¬es
);
5715 as_bad (_("missing string"));
5717 ignore_rest_of_line ();
5723 /* In: Input_line_pointer->next character.
5725 Do: Skip input_line_pointer over all whitespace.
5727 Out: 1 if input_line_pointer->end-of-line. */
5730 is_it_end_of_statement (void)
5733 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5737 equals (char *sym_name
, int reassign
)
5742 input_line_pointer
++;
5743 if (*input_line_pointer
== '=')
5744 input_line_pointer
++;
5745 if (reassign
< 0 && *input_line_pointer
== '=')
5746 input_line_pointer
++;
5748 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5749 input_line_pointer
++;
5752 stop
= mri_comment_field (&stopc
);
5754 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5758 demand_empty_rest_of_line ();
5759 mri_comment_end (stop
, stopc
);
5763 /* .incbin -- include a file verbatim at the current location. */
5766 s_incbin (int x ATTRIBUTE_UNUSED
)
5777 #ifdef md_flush_pending_output
5778 md_flush_pending_output ();
5781 #ifdef md_cons_align
5786 filename
= demand_copy_string (& len
);
5787 if (filename
== NULL
)
5792 /* Look for optional skip and count. */
5793 if (* input_line_pointer
== ',')
5795 ++ input_line_pointer
;
5796 skip
= get_absolute_expression ();
5800 if (* input_line_pointer
== ',')
5802 ++ input_line_pointer
;
5804 count
= get_absolute_expression ();
5806 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5812 demand_empty_rest_of_line ();
5814 /* Try opening absolute path first, then try include dirs. */
5815 binfile
= fopen (filename
, FOPEN_RB
);
5816 if (binfile
== NULL
)
5820 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5822 for (i
= 0; i
< include_dir_count
; i
++)
5824 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5826 binfile
= fopen (path
, FOPEN_RB
);
5827 if (binfile
!= NULL
)
5831 if (binfile
== NULL
)
5832 as_bad (_("file not found: %s"), filename
);
5835 path
= xstrdup (filename
);
5841 register_dependency (path
);
5843 /* Compute the length of the file. */
5844 if (fseek (binfile
, 0, SEEK_END
) != 0)
5846 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5849 file_len
= ftell (binfile
);
5851 /* If a count was not specified use the remainder of the file. */
5853 count
= file_len
- skip
;
5855 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5857 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5858 skip
, count
, file_len
);
5862 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5864 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5868 /* Allocate frag space and store file contents in it. */
5869 binfrag
= frag_more (count
);
5871 bytes
= fread (binfrag
, 1, count
, binfile
);
5873 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5874 path
, bytes
, count
);
5877 if (binfile
!= NULL
)
5882 /* .include -- include a file at this point. */
5885 s_include (int arg ATTRIBUTE_UNUSED
)
5894 filename
= demand_copy_string (&i
);
5895 if (filename
== NULL
)
5897 /* demand_copy_string has already printed an error and
5898 called ignore_rest_of_line. */
5906 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5907 && *input_line_pointer
!= ' '
5908 && *input_line_pointer
!= '\t')
5910 obstack_1grow (¬es
, *input_line_pointer
);
5911 ++input_line_pointer
;
5915 obstack_1grow (¬es
, '\0');
5916 filename
= (char *) obstack_finish (¬es
);
5917 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5918 ++input_line_pointer
;
5921 demand_empty_rest_of_line ();
5922 path
= XNEWVEC (char, (unsigned long) i
5923 + include_dir_maxlen
+ 5 /* slop */ );
5925 for (i
= 0; i
< include_dir_count
; i
++)
5927 strcpy (path
, include_dirs
[i
]);
5929 strcat (path
, filename
);
5930 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5940 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5941 register_dependency (path
);
5942 input_scrub_insert_file (path
);
5946 add_include_dir (char *path
)
5950 if (include_dir_count
== 0)
5952 include_dirs
= XNEWVEC (const char *, 2);
5953 include_dirs
[0] = "."; /* Current dir. */
5954 include_dir_count
= 2;
5958 include_dir_count
++;
5959 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5963 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5966 if (i
> include_dir_maxlen
)
5967 include_dir_maxlen
= i
;
5970 /* Output debugging information to denote the source file. */
5973 generate_file_debug (void)
5975 if (debug_type
== DEBUG_STABS
)
5976 stabs_generate_asm_file ();
5979 /* Output line number debugging information for the current source line. */
5982 generate_lineno_debug (void)
5986 case DEBUG_UNSPECIFIED
:
5991 stabs_generate_asm_lineno ();
5994 ecoff_generate_asm_lineno ();
5997 /* ??? We could here indicate to dwarf2dbg.c that something
5998 has changed. However, since there is additional backend
5999 support that is required (calling dwarf2_emit_insn), we
6000 let dwarf2dbg.c call as_where on its own. */
6005 /* Output debugging information to mark a function entry point or end point.
6006 END_P is zero for .func, and non-zero for .endfunc. */
6011 do_s_func (end_p
, NULL
);
6014 /* Subroutine of s_func so targets can choose a different default prefix.
6015 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6018 do_s_func (int end_p
, const char *default_prefix
)
6020 /* Record the current function so that we can issue an error message for
6021 misplaced .func,.endfunc, and also so that .endfunc needs no
6023 static char *current_name
;
6024 static char *current_label
;
6028 if (current_name
== NULL
)
6030 as_bad (_("missing .func"));
6031 ignore_rest_of_line ();
6035 if (debug_type
== DEBUG_STABS
)
6036 stabs_generate_asm_endfunc (current_name
, current_label
);
6038 current_name
= current_label
= NULL
;
6043 char delim1
, delim2
;
6045 if (current_name
!= NULL
)
6047 as_bad (_(".endfunc missing for previous .func"));
6048 ignore_rest_of_line ();
6052 delim1
= get_symbol_name (& name
);
6053 name
= xstrdup (name
);
6054 *input_line_pointer
= delim1
;
6055 SKIP_WHITESPACE_AFTER_NAME ();
6056 if (*input_line_pointer
!= ',')
6060 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6061 as_fatal ("%s", xstrerror (errno
));
6065 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6066 /* Missing entry point, use function's name with the leading
6070 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6071 as_fatal ("%s", xstrerror (errno
));
6079 ++input_line_pointer
;
6081 delim2
= get_symbol_name (& label
);
6082 label
= xstrdup (label
);
6083 restore_line_pointer (delim2
);
6086 if (debug_type
== DEBUG_STABS
)
6087 stabs_generate_asm_func (name
, label
);
6089 current_name
= name
;
6090 current_label
= label
;
6093 demand_empty_rest_of_line ();
6096 #ifdef HANDLE_BUNDLE
6099 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6101 unsigned int align
= get_absolute_expression ();
6103 demand_empty_rest_of_line ();
6105 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6106 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6107 (unsigned int) TC_ALIGN_LIMIT
);
6109 if (bundle_lock_frag
!= NULL
)
6111 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6115 bundle_align_p2
= align
;
6119 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6121 demand_empty_rest_of_line ();
6123 if (bundle_align_p2
== 0)
6125 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6129 if (bundle_lock_depth
== 0)
6131 bundle_lock_frchain
= frchain_now
;
6132 bundle_lock_frag
= start_bundle ();
6134 ++bundle_lock_depth
;
6138 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6142 demand_empty_rest_of_line ();
6144 if (bundle_lock_frag
== NULL
)
6146 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6150 gas_assert (bundle_align_p2
> 0);
6152 gas_assert (bundle_lock_depth
> 0);
6153 if (--bundle_lock_depth
> 0)
6156 size
= pending_bundle_size (bundle_lock_frag
);
6158 if (size
> 1U << bundle_align_p2
)
6159 as_bad (_(".bundle_lock sequence is %u bytes, "
6160 "but bundle size is only %u bytes"),
6161 size
, 1u << bundle_align_p2
);
6163 finish_bundle (bundle_lock_frag
, size
);
6165 bundle_lock_frag
= NULL
;
6166 bundle_lock_frchain
= NULL
;
6169 #endif /* HANDLE_BUNDLE */
6172 s_ignore (int arg ATTRIBUTE_UNUSED
)
6174 ignore_rest_of_line ();
6178 read_print_statistics (FILE *file
)
6180 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6183 /* Inserts the given line into the input stream.
6185 This call avoids macro/conditionals nesting checking, since the contents of
6186 the line are assumed to replace the contents of a line already scanned.
6188 An appropriate use of this function would be substitution of input lines when
6189 called by md_start_line_hook(). The given line is assumed to already be
6190 properly scrubbed. */
6193 input_scrub_insert_line (const char *line
)
6196 size_t len
= strlen (line
);
6197 sb_build (&newline
, len
);
6198 sb_add_buffer (&newline
, line
, len
);
6199 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6201 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6204 /* Insert a file into the input stream; the path must resolve to an actual
6205 file; no include path searching or dependency registering is performed. */
6208 input_scrub_insert_file (char *path
)
6210 input_scrub_include_file (path
, input_line_pointer
);
6211 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6214 /* Find the end of a line, considering quotation and escaping of quotes. */
6216 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6217 # define TC_SINGLE_QUOTE_STRINGS 1
6221 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6224 char inquote
= '\0';
6227 while (!is_end_of_line
[(unsigned char) *s
]
6228 || (inquote
&& !ISCNTRL (*s
))
6229 || (inquote
== '\'' && flag_mri
)
6230 #ifdef TC_EOL_IN_INSN
6231 || (insn
&& TC_EOL_IN_INSN (s
))
6233 /* PR 6926: When we are parsing the body of a macro the sequence
6234 \@ is special - it refers to the invocation count. If the @
6235 character happens to be registered as a line-separator character
6236 by the target, then the is_end_of_line[] test above will have
6237 returned true, but we need to ignore the line separating
6238 semantics in this particular case. */
6239 || (in_macro
&& inescape
&& *s
== '@')
6242 if (mri_string
&& *s
== '\'')
6246 else if (*s
== '\\')
6250 #ifdef TC_SINGLE_QUOTE_STRINGS
6251 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6258 as_warn (_("missing closing `%c'"), inquote
);
6259 if (inescape
&& !ignore_input ())
6260 as_warn (_("stray `\\'"));
6265 find_end_of_line (char *s
, int mri_string
)
6267 return _find_end_of_line (s
, mri_string
, 0, 0);
6270 static char *saved_ilp
= NULL
;
6271 static char *saved_limit
;
6273 /* Use BUF as a temporary input pointer for calling other functions in this
6274 file. BUF must be a C string, so that its end can be found by strlen.
6275 Also sets the buffer_limit variable (local to this file) so that buffer
6276 overruns should not occur. Saves the current input line pointer so that
6277 it can be restored by calling restore_ilp().
6279 Does not support recursion. */
6282 temp_ilp (char *buf
)
6284 gas_assert (saved_ilp
== NULL
);
6285 gas_assert (buf
!= NULL
);
6287 saved_ilp
= input_line_pointer
;
6288 saved_limit
= buffer_limit
;
6289 /* Prevent the assert in restore_ilp from triggering if
6290 the input_line_pointer has not yet been initialised. */
6291 if (saved_ilp
== NULL
)
6292 saved_limit
= saved_ilp
= (char *) "";
6294 input_line_pointer
= buf
;
6295 buffer_limit
= buf
+ strlen (buf
);
6296 input_from_string
= TRUE
;
6299 /* Restore a saved input line pointer. */
6304 gas_assert (saved_ilp
!= NULL
);
6306 input_line_pointer
= saved_ilp
;
6307 buffer_limit
= saved_limit
;
6308 input_from_string
= FALSE
;