1 /* read.c - read a source file -
2 Copyright (C) 1986-2021 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},
471 {"offset", s_struct
, 0},
473 {"p2align", s_align_ptwo
, 0},
474 {"p2alignw", s_align_ptwo
, -2},
475 {"p2alignl", s_align_ptwo
, -4},
476 {"page", listing_eject
, 0},
477 {"plen", listing_psize
, 0},
478 {"print", s_print
, 0},
479 {"psize", listing_psize
, 0}, /* Set paper size. */
480 {"purgem", s_purgem
, 0},
482 {"reloc", s_reloc
, 0},
486 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
491 {"single", float_cons
, 'f'},
493 {"space", s_space
, 0},
494 {"skip", s_space
, 0},
495 {"sleb128", s_leb128
, 1},
496 {"spc", s_ignore
, 0},
497 {"stabd", s_stab
, 'd'},
498 {"stabn", s_stab
, 'n'},
499 {"stabs", s_stab
, 's'},
500 {"string", stringer
, 8+1},
501 {"string8", stringer
, 8+1},
502 {"string16", stringer
, 16+1},
503 {"string32", stringer
, 32+1},
504 {"string64", stringer
, 64+1},
505 {"struct", s_struct
, 0},
509 /* This is for gcc to use. It's only just been added (2/94), so gcc
510 won't be able to use it for a while -- probably a year or more.
511 But once this has been released, check with gcc maintainers
512 before deleting it or even changing the spelling. */
513 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
514 /* If we're folding case -- done for some targets, not necessarily
515 all -- the above string in an input file will be converted to
516 this one. Match it either way... */
517 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
519 {"title", listing_title
, 0}, /* Listing title. */
520 {"ttl", listing_title
, 0},
522 {"uleb128", s_leb128
, 0},
526 {"xdef", s_globl
, 0},
527 {"xref", s_ignore
, 0},
528 {"xstabs", s_xstab
, 's'},
529 {"warning", s_errwarn
, 0},
530 {"weakref", s_weakref
, 0},
532 {"zero", s_space
, 0},
536 {NULL
, NULL
, 0} /* End sentinel. */
540 get_absolute_expr (expressionS
*exp
)
542 expression_and_evaluate (exp
);
544 if (exp
->X_op
!= O_constant
)
546 if (exp
->X_op
!= O_absent
)
547 as_bad (_("bad or irreducible absolute expression"));
548 exp
->X_add_number
= 0;
550 return exp
->X_add_number
;
554 get_absolute_expression (void)
558 return get_absolute_expr (&exp
);
561 static int pop_override_ok
= 0;
562 static const char *pop_table_name
;
565 pop_insert (const pseudo_typeS
*table
)
567 const pseudo_typeS
*pop
;
568 for (pop
= table
; pop
->poc_name
; pop
++)
570 po_entry_t
*elt
= po_entry_alloc (pop
->poc_name
, pop
);
571 if (htab_insert (po_hash
, elt
, 0) != NULL
)
574 if (!pop_override_ok
)
575 as_fatal (_("error constructing %s pseudo-op table"),
581 #ifndef md_pop_insert
582 #define md_pop_insert() pop_insert(md_pseudo_table)
585 #ifndef obj_pop_insert
586 #define obj_pop_insert() pop_insert(obj_pseudo_table)
589 #ifndef cfi_pop_insert
590 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
596 po_hash
= htab_create_alloc (16, hash_po_entry
, eq_po_entry
, NULL
,
599 /* Do the target-specific pseudo ops. */
600 pop_table_name
= "md";
603 /* Now object specific. Skip any that were in the target table. */
604 pop_table_name
= "obj";
608 /* Now portable ones. Skip any that we've seen already. */
609 pop_table_name
= "standard";
610 pop_insert (potable
);
613 pop_table_name
= "cfi";
618 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
619 if (ignore_input ()) \
621 char *eol = find_end_of_line (input_line_pointer - (num_read), \
623 input_line_pointer = (input_line_pointer <= buffer_limit \
624 && eol >= buffer_limit) \
630 /* This function is used when scrubbing the characters between #APP
633 static char *scrub_string
;
634 static char *scrub_string_end
;
637 scrub_from_string (char *buf
, size_t buflen
)
641 copy
= scrub_string_end
- scrub_string
;
644 memcpy (buf
, scrub_string
, copy
);
645 scrub_string
+= copy
;
649 /* Helper function of read_a_source_file, which tries to expand a macro. */
651 try_macro (char term
, const char *line
)
657 if (check_macro (line
, &out
, &err
, ¯o
))
661 *input_line_pointer
++ = term
;
662 input_scrub_include_sb (&out
,
663 input_line_pointer
, 1);
666 input_scrub_next_buffer (&input_line_pointer
);
668 md_macro_info (macro
);
676 /* Start a new instruction bundle. Returns the rs_align_code frag that
677 will be used to align the new bundle. */
681 fragS
*frag
= frag_now
;
683 frag_align_code (0, 0);
685 while (frag
->fr_type
!= rs_align_code
)
686 frag
= frag
->fr_next
;
688 gas_assert (frag
!= frag_now
);
693 /* Calculate the maximum size after relaxation of the region starting
694 at the given frag and extending through frag_now (which is unfinished). */
696 pending_bundle_size (fragS
*frag
)
698 unsigned int offset
= frag
->fr_fix
;
699 unsigned int size
= 0;
701 gas_assert (frag
!= frag_now
);
702 gas_assert (frag
->fr_type
== rs_align_code
);
704 while (frag
!= frag_now
)
706 /* This should only happen in what will later become an error case. */
710 size
+= frag
->fr_fix
;
711 if (frag
->fr_type
== rs_machine_dependent
)
712 size
+= md_frag_max_var (frag
);
714 frag
= frag
->fr_next
;
717 gas_assert (frag
== frag_now
);
718 size
+= frag_now_fix ();
719 if (frag
->fr_type
== rs_machine_dependent
)
720 size
+= md_frag_max_var (frag
);
722 gas_assert (size
>= offset
);
724 return size
- offset
;
727 /* Finish off the frag created to ensure bundle alignment. */
729 finish_bundle (fragS
*frag
, unsigned int size
)
731 gas_assert (bundle_align_p2
> 0);
732 gas_assert (frag
->fr_type
== rs_align_code
);
736 /* If there is more than a single byte, then we need to set up the
737 alignment frag. Otherwise we leave it at its initial state from
738 calling frag_align_code (0, 0), so that it does nothing. */
739 frag
->fr_offset
= bundle_align_p2
;
740 frag
->fr_subtype
= size
- 1;
743 /* We do this every time rather than just in s_bundle_align_mode
744 so that we catch any affected section without needing hooks all
745 over for all paths that do section changes. It's cheap enough. */
746 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
747 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
750 /* Assemble one instruction. This takes care of the bundle features
751 around calling md_assemble. */
753 assemble_one (char *line
)
755 fragS
*insn_start_frag
= NULL
;
757 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
759 as_bad (_("cannot change section or subsection inside .bundle_lock"));
760 /* Clearing this serves as a marker that we have already complained. */
761 bundle_lock_frchain
= NULL
;
764 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
765 insn_start_frag
= start_bundle ();
769 if (bundle_lock_frchain
!= NULL
)
771 /* Make sure this hasn't pushed the locked sequence
772 past the bundle size. */
773 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
774 if (bundle_size
> 1U << bundle_align_p2
)
775 as_bad (_ (".bundle_lock sequence at %u bytes, "
776 "but .bundle_align_mode limit is %u bytes"),
777 bundle_size
, 1U << bundle_align_p2
);
779 else if (bundle_align_p2
> 0)
781 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
783 if (insn_size
> 1U << bundle_align_p2
)
784 as_bad (_("single instruction is %u bytes long, "
785 "but .bundle_align_mode limit is %u bytes"),
786 insn_size
, 1U << bundle_align_p2
);
788 finish_bundle (insn_start_frag
, insn_size
);
792 #else /* !HANDLE_BUNDLE */
794 # define assemble_one(line) md_assemble(line)
796 #endif /* HANDLE_BUNDLE */
801 flagword flags
= bfd_section_flags (now_seg
);
803 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
806 /* Guts of .align directive:
807 N is the power of two to which to align. A value of zero is accepted but
808 ignored: the default alignment of the section will be at least this.
809 FILL may be NULL, or it may point to the bytes of the fill pattern.
810 LEN is the length of whatever FILL points to, if anything. If LEN is zero
811 but FILL is not NULL then LEN is treated as if it were one.
812 MAX is the maximum number of characters to skip when doing the alignment,
813 or 0 if there is no maximum. */
816 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
818 if (now_seg
== absolute_section
|| in_bss ())
824 if (now_seg
== absolute_section
)
825 as_warn (_("ignoring fill value in absolute section"));
827 as_warn (_("ignoring fill value in section `%s'"),
828 segment_name (now_seg
));
835 #ifdef md_flush_pending_output
836 md_flush_pending_output ();
840 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
843 /* Only make a frag if we HAVE to... */
844 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
848 if (subseg_text_p (now_seg
))
849 frag_align_code (n
, max
);
851 frag_align (n
, 0, max
);
854 frag_align (n
, *fill
, max
);
856 frag_align_pattern (n
, fill
, len
, max
);
860 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
863 if (n
> OCTETS_PER_BYTE_POWER
)
864 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
867 /* We read the file, putting things into a web that represents what we
868 have been reading. */
870 read_a_source_file (const char *name
)
874 char *s
; /* String of symbol, '\0' appended. */
876 const pseudo_typeS
*pop
;
882 buffer
= input_scrub_new_file (name
);
885 listing_newline (NULL
);
886 register_dependency (name
);
888 /* Generate debugging information before we've read anything in to denote
889 this file as the "main" source file and not a subordinate one
890 (e.g. N_SO vs N_SOL in stabs). */
891 generate_file_debug ();
893 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
894 { /* We have another line to parse. */
896 /* In order to avoid listing macro expansion lines with labels
897 multiple times, keep track of which line was last issued. */
898 static char *last_eol
;
902 while (input_line_pointer
< buffer_limit
)
904 bfd_boolean was_new_line
;
905 /* We have more of this buffer to parse. */
907 /* We now have input_line_pointer->1st char of next line.
908 If input_line_pointer [-1] == '\n' then we just
909 scanned another line: so bump line counters. */
910 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
913 symbol_set_value_now (&dot_symbol
);
914 #ifdef md_start_line_hook
915 md_start_line_hook ();
917 if (input_line_pointer
[-1] == '\n')
918 bump_line_counters ();
922 /* If listing is on, and we are expanding a macro, then give
923 the listing code the contents of the expanded line. */
926 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
928 /* Find the end of the current expanded macro line. */
929 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
937 /* Copy it for safe keeping. Also give an indication of
938 how much macro nesting is involved at this point. */
939 len
= s
- input_line_pointer
;
940 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
941 memset (copy
, '>', macro_nest
);
942 copy
[macro_nest
] = ' ';
943 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
944 copy
[macro_nest
+ 1 + len
] = '\0';
946 /* Install the line with the listing facility. */
947 listing_newline (copy
);
951 listing_newline (NULL
);
958 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
960 next_char
= * input_line_pointer
;
961 /* Text at the start of a line must be a label, we
962 run down and stick a colon in. */
963 if (is_name_beginner (next_char
) || next_char
== '"')
968 HANDLE_CONDITIONAL_ASSEMBLY (0);
970 nul_char
= get_symbol_name (& line_start
);
971 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
973 /* In MRI mode, the EQU and MACRO pseudoops must
974 be handled specially. */
978 char *rest
= input_line_pointer
+ 1;
982 if (*rest
== ' ' || *rest
== '\t')
984 if ((strncasecmp (rest
, "EQU", 3) == 0
985 || strncasecmp (rest
, "SET", 3) == 0)
986 && (rest
[3] == ' ' || rest
[3] == '\t'))
988 input_line_pointer
= rest
+ 3;
990 strncasecmp (rest
, "SET", 3) == 0);
993 if (strncasecmp (rest
, "MACRO", 5) == 0
996 || is_end_of_line
[(unsigned char) rest
[5]]))
1000 /* In MRI mode, we need to handle the MACRO
1001 pseudo-op specially: we don't want to put the
1002 symbol in the symbol table. */
1004 #ifdef TC_START_LABEL_WITHOUT_COLON
1005 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1008 line_label
= colon (line_start
);
1010 line_label
= symbol_create (line_start
,
1012 &zero_address_frag
, 0);
1014 next_char
= restore_line_pointer (nul_char
);
1015 if (next_char
== ':')
1016 input_line_pointer
++;
1021 /* We are at the beginning of a line, or similar place.
1022 We expect a well-formed assembler statement.
1023 A "symbol-name:" is a statement.
1025 Depending on what compiler is used, the order of these tests
1026 may vary to catch most common case 1st.
1027 Each test is independent of all other tests at the (top)
1030 nul_char
= next_char
= *input_line_pointer
++;
1031 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1033 /* C is the 1st significant character.
1034 Input_line_pointer points after that character. */
1035 if (is_name_beginner (next_char
) || next_char
== '"')
1039 /* Want user-defined label or pseudo/opcode. */
1040 HANDLE_CONDITIONAL_ASSEMBLY (1);
1042 --input_line_pointer
;
1043 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1044 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1045 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1047 /* NEXT_CHAR is character after symbol.
1048 The end of symbol in the input line is now '\0'.
1049 S points to the beginning of the symbol.
1050 [In case of pseudo-op, s->'.'.]
1051 Input_line_pointer->'\0' where NUL_CHAR was. */
1052 if (TC_START_LABEL (s
, nul_char
, next_char
))
1056 /* In MRI mode, \tsym: set 0 is permitted. */
1060 if (*rest
== ' ' || *rest
== '\t')
1063 if ((strncasecmp (rest
, "EQU", 3) == 0
1064 || strncasecmp (rest
, "SET", 3) == 0)
1065 && (rest
[3] == ' ' || rest
[3] == '\t'))
1067 input_line_pointer
= rest
+ 3;
1073 line_label
= colon (s
); /* User-defined label. */
1074 restore_line_pointer (nul_char
);
1075 ++ input_line_pointer
;
1076 #ifdef tc_check_label
1077 tc_check_label (line_label
);
1079 /* Input_line_pointer->after ':'. */
1082 else if ((next_char
== '=' && *rest
== '=')
1083 || ((next_char
== ' ' || next_char
== '\t')
1088 demand_empty_rest_of_line ();
1090 else if ((next_char
== '='
1091 || ((next_char
== ' ' || next_char
== '\t')
1093 #ifdef TC_EQUAL_IN_INSN
1094 && !TC_EQUAL_IN_INSN (next_char
, s
)
1099 demand_empty_rest_of_line ();
1103 /* Expect pseudo-op or machine instruction. */
1106 #ifndef TC_CASE_SENSITIVE
1110 strncpy (original_case_string
, s2
,
1111 sizeof (original_case_string
) - 1);
1112 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1116 *s2
= TOLOWER (*s2
);
1121 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1123 /* The MRI assembler uses pseudo-ops without
1125 pop
= po_entry_find (po_hash
, s
);
1126 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1131 || (!flag_m68k_mri
&& *s
== '.'))
1135 WARNING: next_char may be end-of-line.
1136 We lookup the pseudo-op table with s+1 because we
1137 already know that the pseudo-op begins with a '.'. */
1140 pop
= po_entry_find (po_hash
, s
+ 1);
1141 if (pop
&& !pop
->poc_handler
)
1144 /* In MRI mode, we may need to insert an
1145 automatic alignment directive. What a hack
1147 if (mri_pending_align
1149 || !((pop
->poc_handler
== cons
1150 && pop
->poc_val
== 1)
1151 || (pop
->poc_handler
== s_space
1152 && pop
->poc_val
== 1)
1153 #ifdef tc_conditional_pseudoop
1154 || tc_conditional_pseudoop (pop
)
1156 || pop
->poc_handler
== s_if
1157 || pop
->poc_handler
== s_ifdef
1158 || pop
->poc_handler
== s_ifc
1159 || pop
->poc_handler
== s_ifeqs
1160 || pop
->poc_handler
== s_else
1161 || pop
->poc_handler
== s_endif
1162 || pop
->poc_handler
== s_globl
1163 || pop
->poc_handler
== s_ignore
)))
1165 do_align (1, (char *) NULL
, 0, 0);
1166 mri_pending_align
= 0;
1168 if (line_label
!= NULL
)
1170 symbol_set_frag (line_label
, frag_now
);
1171 S_SET_VALUE (line_label
, frag_now_fix ());
1175 /* Print the error msg now, while we still can. */
1178 char *end
= input_line_pointer
;
1180 (void) restore_line_pointer (nul_char
);
1182 nul_char
= next_char
= *--input_line_pointer
;
1183 *input_line_pointer
= '\0';
1184 if (! macro_defined
|| ! try_macro (next_char
, s
))
1187 as_bad (_("unknown pseudo-op: `%s'"), s
);
1188 *input_line_pointer
++ = nul_char
;
1193 /* Put it back for error messages etc. */
1194 next_char
= restore_line_pointer (nul_char
);
1195 /* The following skip of whitespace is compulsory.
1196 A well shaped space is sometimes all that separates
1197 keyword from operands. */
1198 if (next_char
== ' ' || next_char
== '\t')
1199 input_line_pointer
++;
1201 /* Input_line is restored.
1202 Input_line_pointer->1st non-blank char
1203 after pseudo-operation. */
1204 (*pop
->poc_handler
) (pop
->poc_val
);
1206 /* If that was .end, just get out now. */
1207 if (pop
->poc_handler
== s_end
)
1212 /* WARNING: next_char may be end-of-line. */
1213 /* Also: input_line_pointer->`\0` where nul_char was. */
1214 (void) restore_line_pointer (nul_char
);
1215 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1216 next_char
= nul_char
= *input_line_pointer
;
1217 *input_line_pointer
= '\0';
1219 generate_lineno_debug ();
1221 if (macro_defined
&& try_macro (next_char
, s
))
1224 if (mri_pending_align
)
1226 do_align (1, (char *) NULL
, 0, 0);
1227 mri_pending_align
= 0;
1228 if (line_label
!= NULL
)
1230 symbol_set_frag (line_label
, frag_now
);
1231 S_SET_VALUE (line_label
, frag_now_fix ());
1235 assemble_one (s
); /* Assemble 1 instruction. */
1237 /* PR 19630: The backend may have set ilp to NULL
1238 if it encountered a catastrophic failure. */
1239 if (input_line_pointer
== NULL
)
1240 as_fatal (_("unable to continue with assembly."));
1242 *input_line_pointer
++ = nul_char
;
1244 /* We resume loop AFTER the end-of-line from
1245 this instruction. */
1251 /* Empty statement? */
1252 if (is_end_of_line
[(unsigned char) next_char
])
1255 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1257 /* local label ("4:") */
1258 char *backup
= input_line_pointer
;
1260 HANDLE_CONDITIONAL_ASSEMBLY (1);
1262 temp
= next_char
- '0';
1264 if (nul_char
== '"')
1265 ++ input_line_pointer
;
1267 /* Read the whole number. */
1268 while (ISDIGIT (*input_line_pointer
))
1270 const long digit
= *input_line_pointer
- '0';
1271 if (temp
> (LONG_MAX
- digit
) / 10)
1273 as_bad (_("local label too large near %s"), backup
);
1277 temp
= temp
* 10 + digit
;
1278 ++input_line_pointer
;
1281 /* Overflow: stop processing the label. */
1284 ignore_rest_of_line ();
1288 if (LOCAL_LABELS_DOLLAR
1289 && *input_line_pointer
== '$'
1290 && *(input_line_pointer
+ 1) == ':')
1292 input_line_pointer
+= 2;
1294 if (dollar_label_defined (temp
))
1296 as_fatal (_("label \"%ld$\" redefined"), temp
);
1299 define_dollar_label (temp
);
1300 colon (dollar_label_name (temp
, 0));
1305 && *input_line_pointer
++ == ':')
1307 fb_label_instance_inc (temp
);
1308 colon (fb_label_name (temp
, 0));
1312 input_line_pointer
= backup
;
1315 if (next_char
&& strchr (line_comment_chars
, next_char
))
1316 { /* Its a comment. Better say APP or NO_APP. */
1321 unsigned int new_length
;
1324 s
= input_line_pointer
;
1325 if (strncmp (s
, "APP\n", 4))
1328 ignore_rest_of_line ();
1331 bump_line_counters ();
1334 ends
= strstr (s
, "#NO_APP\n");
1338 unsigned int tmp_len
;
1341 /* The end of the #APP wasn't in this buffer. We
1342 keep reading in buffers until we find the #NO_APP
1343 that goes with this #APP There is one. The specs
1345 tmp_len
= buffer_limit
- s
;
1346 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1347 memcpy (tmp_buf
, s
, tmp_len
);
1350 new_tmp
= input_scrub_next_buffer (&buffer
);
1354 buffer_limit
= new_tmp
;
1355 input_line_pointer
= buffer
;
1356 ends
= strstr (buffer
, "#NO_APP\n");
1358 num
= ends
- buffer
;
1360 num
= buffer_limit
- buffer
;
1362 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1363 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1368 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1376 input_line_pointer
= ends
+ 8;
1380 scrub_string_end
= ends
;
1382 new_length
= ends
- s
;
1383 new_buf
= XNEWVEC (char, new_length
);
1390 space
= (new_buf
+ new_length
) - new_tmp
;
1391 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1399 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1400 new_tmp
= new_buf
+ new_length
;
1406 /* We've "scrubbed" input to the preferred format. In the
1407 process we may have consumed the whole of the remaining
1408 file (and included files). We handle this formatted
1409 input similar to that of macro expansion, letting
1410 actual macro expansion (possibly nested) and other
1411 input expansion work. Beware that in messages, line
1412 numbers and possibly file names will be incorrect. */
1413 new_length
= strlen (new_buf
);
1414 sb_build (&sbuf
, new_length
);
1415 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1416 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1418 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1423 HANDLE_CONDITIONAL_ASSEMBLY (1);
1425 #ifdef tc_unrecognized_line
1426 if (tc_unrecognized_line (next_char
))
1429 input_line_pointer
--;
1430 /* Report unknown char as error. */
1431 demand_empty_rest_of_line ();
1436 symbol_set_value_now (&dot_symbol
);
1438 #ifdef HANDLE_BUNDLE
1439 if (bundle_lock_frag
!= NULL
)
1441 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1442 _(".bundle_lock with no matching .bundle_unlock"));
1443 bundle_lock_frag
= NULL
;
1444 bundle_lock_frchain
= NULL
;
1445 bundle_lock_depth
= 0;
1452 /* Close the input file. */
1453 input_scrub_close ();
1454 #ifdef WARN_COMMENTS
1456 if (warn_comment
&& found_comment
)
1457 as_warn_where (found_comment_file
, found_comment
,
1458 "first comment found here");
1463 /* Convert O_constant expression EXP into the equivalent O_big representation.
1464 Take the sign of the number from SIGN rather than X_add_number. */
1467 convert_to_bignum (expressionS
*exp
, int sign
)
1472 value
= exp
->X_add_number
;
1473 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1475 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1476 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1478 /* Add a sequence of sign bits if the top bit of X_add_number is not
1479 the sign of the original value. */
1480 if ((exp
->X_add_number
< 0) == !sign
)
1481 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1483 exp
->X_add_number
= i
;
1486 /* For most MRI pseudo-ops, the line actually ends at the first
1487 nonquoted space. This function looks for that point, stuffs a null
1488 in, and sets *STOPCP to the character that used to be there, and
1489 returns the location.
1491 Until I hear otherwise, I am going to assume that this is only true
1492 for the m68k MRI assembler. */
1495 mri_comment_field (char *stopcp
)
1501 know (flag_m68k_mri
);
1503 for (s
= input_line_pointer
;
1504 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1512 for (s
= input_line_pointer
;
1513 !is_end_of_line
[(unsigned char) *s
];
1523 /* Skip to the end of an MRI comment field. */
1526 mri_comment_end (char *stop
, int stopc
)
1530 input_line_pointer
= stop
;
1532 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1533 ++input_line_pointer
;
1537 s_abort (int ignore ATTRIBUTE_UNUSED
)
1539 as_fatal (_(".abort detected. Abandoning ship."));
1542 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1543 (in bytes). A negative ARG is the negative of the length of the
1544 fill pattern. BYTES_P is non-zero if the alignment value should be
1545 interpreted as the byte boundary, rather than the power of 2. */
1546 #ifndef TC_ALIGN_LIMIT
1547 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1551 s_align (signed int arg
, int bytes_p
)
1553 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1562 stop
= mri_comment_field (&stopc
);
1564 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1569 align
= arg
; /* Default value from pseudo-op table. */
1573 align
= get_absolute_expression ();
1576 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1577 if (arg
> 0 && align
== 0)
1584 /* Convert to a power of 2. */
1589 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1592 as_bad (_("alignment not a power of 2"));
1598 if (align
> align_limit
)
1600 align
= align_limit
;
1601 as_warn (_("alignment too large: %u assumed"), align_limit
);
1604 if (*input_line_pointer
!= ',')
1611 ++input_line_pointer
;
1612 if (*input_line_pointer
== ',')
1616 fill
= get_absolute_expression ();
1621 if (*input_line_pointer
!= ',')
1625 ++input_line_pointer
;
1626 max
= get_absolute_expression ();
1633 as_warn (_("expected fill pattern missing"));
1634 do_align (align
, (char *) NULL
, 0, max
);
1638 unsigned int fill_len
;
1650 do_align (align
, &fill_char
, fill_len
, max
);
1656 if ((size_t) fill_len
> sizeof ab
)
1658 as_warn (_("fill pattern too long, truncating to %u"),
1659 (unsigned) sizeof ab
);
1660 fill_len
= sizeof ab
;
1663 md_number_to_chars (ab
, fill
, fill_len
);
1664 do_align (align
, ab
, fill_len
, max
);
1668 demand_empty_rest_of_line ();
1671 mri_comment_end (stop
, stopc
);
1674 /* Handle the .align pseudo-op on machines where ".align 4" means
1675 align to a 4 byte boundary. */
1678 s_align_bytes (int arg
)
1683 /* Handle the .align pseudo-op on machines where ".align 4" means align
1684 to a 2**4 boundary. */
1687 s_align_ptwo (int arg
)
1692 /* Switch in and out of alternate macro mode. */
1697 demand_empty_rest_of_line ();
1698 macro_set_alternate (on
);
1701 /* Read a symbol name from input_line_pointer.
1703 Stores the symbol name in a buffer and returns a pointer to this buffer.
1704 The buffer is xalloc'ed. It is the caller's responsibility to free
1707 The name is not left in the i_l_p buffer as it may need processing
1708 to handle escape characters.
1710 Advances i_l_p to the next non-whitespace character.
1712 If a symbol name could not be read, the routine issues an error
1713 messages, skips to the end of the line and returns NULL. */
1716 read_symbol_name (void)
1722 c
= *input_line_pointer
++;
1726 #define SYM_NAME_CHUNK_LEN 128
1727 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1731 start
= name
= XNEWVEC (char, len
+ 1);
1733 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1735 while (is_a_char (C
= next_char_of_string ()))
1737 if (name
>= name_end
)
1741 sofar
= name
- start
;
1742 len
+= SYM_NAME_CHUNK_LEN
;
1743 start
= XRESIZEVEC (char, start
, len
+ 1);
1744 name_end
= start
+ len
;
1745 name
= start
+ sofar
;
1752 /* Since quoted symbol names can contain non-ASCII characters,
1753 check the string and warn if it cannot be recognised by the
1754 current character set. */
1755 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1756 as_warn (_("symbol name not recognised in the current locale"));
1758 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1762 name
= input_line_pointer
- 1;
1764 /* We accept FAKE_LABEL_CHAR in a name in case this is
1765 being called with a constructed string. */
1766 while (is_part_of_name (c
= *input_line_pointer
++)
1767 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1770 len
= (input_line_pointer
- name
) - 1;
1771 start
= XNEWVEC (char, len
+ 1);
1773 memcpy (start
, name
, len
);
1776 /* Skip a name ender char if one is present. */
1777 if (! is_name_ender (c
))
1778 --input_line_pointer
;
1781 name
= start
= NULL
;
1785 as_bad (_("expected symbol name"));
1786 ignore_rest_of_line ();
1797 s_comm_internal (int param
,
1798 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1802 symbolS
*symbolP
= NULL
;
1808 stop
= mri_comment_field (&stopc
);
1810 if ((name
= read_symbol_name ()) == NULL
)
1813 /* Accept an optional comma after the name. The comma used to be
1814 required, but Irix 5 cc does not generate it for .lcomm. */
1815 if (*input_line_pointer
== ',')
1816 input_line_pointer
++;
1818 temp
= get_absolute_expr (&exp
);
1820 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1821 if (exp
.X_op
== O_absent
)
1823 as_bad (_("missing size expression"));
1824 ignore_rest_of_line ();
1827 else if (temp
!= size
|| !exp
.X_unsigned
)
1829 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1830 ignore_rest_of_line ();
1834 symbolP
= symbol_find_or_make (name
);
1835 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1836 && !S_IS_COMMON (symbolP
))
1838 if (!S_IS_VOLATILE (symbolP
))
1841 as_bad (_("symbol `%s' is already defined"), name
);
1842 ignore_rest_of_line ();
1845 symbolP
= symbol_clone (symbolP
, 1);
1846 S_SET_SEGMENT (symbolP
, undefined_section
);
1847 S_SET_VALUE (symbolP
, 0);
1848 symbol_set_frag (symbolP
, &zero_address_frag
);
1849 S_CLEAR_VOLATILE (symbolP
);
1852 size
= S_GET_VALUE (symbolP
);
1855 else if (size
!= temp
)
1856 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1857 name
, (long) size
, (long) temp
);
1859 if (comm_parse_extra
!= NULL
)
1860 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1863 S_SET_VALUE (symbolP
, (valueT
) size
);
1864 S_SET_EXTERNAL (symbolP
);
1865 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1868 demand_empty_rest_of_line ();
1871 mri_comment_end (stop
, stopc
);
1879 s_comm_internal (ignore
, NULL
);
1882 /* The MRI COMMON pseudo-op. We handle this by creating a common
1883 symbol with the appropriate name. We make s_space do the right
1884 thing by increasing the size. */
1887 s_mri_common (int small ATTRIBUTE_UNUSED
)
1903 stop
= mri_comment_field (&stopc
);
1907 name
= input_line_pointer
;
1908 if (!ISDIGIT (*name
))
1909 c
= get_symbol_name (& name
);
1914 ++input_line_pointer
;
1916 while (ISDIGIT (*input_line_pointer
));
1918 c
= *input_line_pointer
;
1919 *input_line_pointer
= '\0';
1921 if (line_label
!= NULL
)
1923 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1924 + (input_line_pointer
- name
) + 1);
1925 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1930 sym
= symbol_find_or_make (name
);
1931 c
= restore_line_pointer (c
);
1934 if (*input_line_pointer
!= ',')
1938 ++input_line_pointer
;
1939 align
= get_absolute_expression ();
1942 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1944 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1945 ignore_rest_of_line ();
1946 mri_comment_end (stop
, stopc
);
1950 S_SET_EXTERNAL (sym
);
1951 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1952 mri_common_symbol
= sym
;
1956 S_SET_ALIGN (sym
, align
);
1961 if (line_label
!= NULL
)
1964 exp
.X_op
= O_symbol
;
1965 exp
.X_add_symbol
= sym
;
1966 exp
.X_add_number
= 0;
1967 symbol_set_value_expression (line_label
, &exp
);
1968 symbol_set_frag (line_label
, &zero_address_frag
);
1969 S_SET_SEGMENT (line_label
, expr_section
);
1972 /* FIXME: We just ignore the small argument, which distinguishes
1973 COMMON and COMMON.S. I don't know what we can do about it. */
1975 /* Ignore the type and hptype. */
1976 if (*input_line_pointer
== ',')
1977 input_line_pointer
+= 2;
1978 if (*input_line_pointer
== ',')
1979 input_line_pointer
+= 2;
1981 demand_empty_rest_of_line ();
1983 mri_comment_end (stop
, stopc
);
1987 s_data (int ignore ATTRIBUTE_UNUSED
)
1992 temp
= get_absolute_expression ();
1993 if (flag_readonly_data_in_text
)
1995 section
= text_section
;
1999 section
= data_section
;
2001 subseg_set (section
, (subsegT
) temp
);
2003 demand_empty_rest_of_line ();
2006 /* Handle the .appfile pseudo-op. This is automatically generated by
2007 do_scrub_chars when a preprocessor # line comment is seen with a
2008 file name. This default definition may be overridden by the object
2009 or CPU specific pseudo-ops. This function is also the default
2010 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
2014 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
2018 listing_source_file (file
);
2020 register_dependency (file
);
2022 obj_app_file (file
, appfile
);
2027 s_app_file (int appfile
)
2032 /* Some assemblers tolerate immediately following '"'. */
2033 if ((s
= demand_copy_string (&length
)) != 0)
2036 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
2038 /* In MRI mode, the preprocessor may have inserted an extraneous
2041 && *input_line_pointer
== '\''
2042 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2043 ++input_line_pointer
;
2045 demand_empty_rest_of_line ();
2047 s_app_file_string (s
, appfile
);
2052 get_linefile_number (int *flag
)
2056 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2059 *flag
= get_absolute_expression ();
2064 /* Handle the .appline pseudo-op. This is automatically generated by
2065 do_scrub_chars when a preprocessor # line comment is seen. This
2066 default definition may be overridden by the object or CPU specific
2070 s_app_line (int appline
)
2075 /* The given number is that of the next line. */
2077 l
= get_absolute_expression ();
2078 else if (!get_linefile_number (&l
))
2080 ignore_rest_of_line ();
2087 /* Some of the back ends can't deal with non-positive line numbers.
2088 Besides, it's silly. GCC however will generate a line number of
2089 zero when it is pre-processing builtins for assembler-with-cpp files:
2093 We do not want to barf on this, especially since such files are used
2094 in the GCC and GDB testsuites. So we check for negative line numbers
2095 rather than non-positive line numbers. */
2096 as_warn (_("line numbers must be positive; line number %d rejected"),
2107 if (*input_line_pointer
== '"')
2108 file
= demand_copy_string (&length
);
2114 while (get_linefile_number (&this_flag
))
2117 /* From GCC's cpp documentation:
2118 1: start of a new file.
2119 2: returning to a file after having included
2121 3: following text comes from a system header file.
2122 4: following text should be treated as extern "C".
2124 4 is nonsensical for the assembler; 3, we don't
2125 care about, so we ignore it just in case a
2126 system header file is included while
2127 preprocessing assembly. So 1 and 2 are all we
2128 care about, and they are mutually incompatible.
2129 new_logical_line_flags() demands this. */
2132 if (flags
&& flags
!= (1 << this_flag
))
2133 as_warn (_("incompatible flag %i in line directive"),
2136 flags
|= 1 << this_flag
;
2141 /* We ignore these. */
2145 as_warn (_("unsupported flag %i in line directive"),
2150 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2155 if (appline
|| file
)
2157 new_logical_line_flags (file
, l
, flags
);
2160 listing_source_line (l
);
2164 if (appline
|| file
)
2165 demand_empty_rest_of_line ();
2167 ignore_rest_of_line ();
2170 /* Handle the .end pseudo-op. Actually, the real work is done in
2171 read_a_source_file. */
2174 s_end (int ignore ATTRIBUTE_UNUSED
)
2178 /* The MRI assembler permits the start symbol to follow .end,
2179 but we don't support that. */
2181 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2182 && *input_line_pointer
!= '*'
2183 && *input_line_pointer
!= '!')
2184 as_warn (_("start address not supported"));
2188 /* Handle the .err pseudo-op. */
2191 s_err (int ignore ATTRIBUTE_UNUSED
)
2193 as_bad (_(".err encountered"));
2194 demand_empty_rest_of_line ();
2197 /* Handle the .error and .warning pseudo-ops. */
2203 /* The purpose for the conditional assignment is not to
2204 internationalize the directive itself, but that we need a
2205 self-contained message, one that can be passed like the
2206 demand_copy_C_string return value, and with no assumption on the
2207 location of the name of the directive within the message. */
2209 = (err
? _(".error directive invoked in source file")
2210 : _(".warning directive invoked in source file"));
2212 if (!is_it_end_of_statement ())
2214 if (*input_line_pointer
!= '\"')
2216 as_bad (_("%s argument must be a string"),
2217 err
? ".error" : ".warning");
2218 ignore_rest_of_line ();
2222 msg
= demand_copy_C_string (&len
);
2230 as_warn ("%s", msg
);
2231 demand_empty_rest_of_line ();
2234 /* Handle the MRI fail pseudo-op. */
2237 s_fail (int ignore ATTRIBUTE_UNUSED
)
2244 stop
= mri_comment_field (&stopc
);
2246 temp
= get_absolute_expression ();
2248 as_warn (_(".fail %ld encountered"), (long) temp
);
2250 as_bad (_(".fail %ld encountered"), (long) temp
);
2252 demand_empty_rest_of_line ();
2255 mri_comment_end (stop
, stopc
);
2259 s_fill (int ignore ATTRIBUTE_UNUSED
)
2261 expressionS rep_exp
;
2266 #ifdef md_flush_pending_output
2267 md_flush_pending_output ();
2270 #ifdef md_cons_align
2274 expression (&rep_exp
);
2275 if (*input_line_pointer
== ',')
2277 input_line_pointer
++;
2278 size
= get_absolute_expression ();
2279 if (*input_line_pointer
== ',')
2281 input_line_pointer
++;
2282 fill
= get_absolute_expression ();
2286 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2287 #define BSD_FILL_SIZE_CROCK_8 (8)
2288 if (size
> BSD_FILL_SIZE_CROCK_8
)
2290 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2291 size
= BSD_FILL_SIZE_CROCK_8
;
2295 as_warn (_("size negative; .fill ignored"));
2298 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2300 if (rep_exp
.X_add_number
< 0)
2301 as_warn (_("repeat < 0; .fill ignored"));
2305 if (size
&& !need_pass_2
)
2307 if (now_seg
== absolute_section
)
2309 if (rep_exp
.X_op
!= O_constant
)
2310 as_bad (_("non-constant fill count for absolute section"));
2311 else if (fill
&& rep_exp
.X_add_number
!= 0)
2312 as_bad (_("attempt to fill absolute section with non-zero value"));
2313 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2316 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2318 as_bad (_("attempt to fill section `%s' with non-zero value"),
2319 segment_name (now_seg
));
2321 if (rep_exp
.X_op
== O_constant
)
2323 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2324 (relax_substateT
) 0, (symbolS
*) 0,
2325 (offsetT
) rep_exp
.X_add_number
,
2330 /* We don't have a constant repeat count, so we can't use
2331 rs_fill. We can get the same results out of rs_space,
2332 but its argument is in bytes, so we must multiply the
2333 repeat count by size. */
2336 rep_sym
= make_expr_symbol (&rep_exp
);
2339 expressionS size_exp
;
2340 size_exp
.X_op
= O_constant
;
2341 size_exp
.X_add_number
= size
;
2343 rep_exp
.X_op
= O_multiply
;
2344 rep_exp
.X_add_symbol
= rep_sym
;
2345 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2346 rep_exp
.X_add_number
= 0;
2347 rep_sym
= make_expr_symbol (&rep_exp
);
2350 p
= frag_var (rs_space
, (int) size
, (int) size
,
2351 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2354 memset (p
, 0, (unsigned int) size
);
2356 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2357 flavoured AS. The following bizarre behaviour is to be
2358 compatible with above. I guess they tried to take up to 8
2359 bytes from a 4-byte expression and they forgot to sign
2361 #define BSD_FILL_SIZE_CROCK_4 (4)
2362 md_number_to_chars (p
, (valueT
) fill
,
2363 (size
> BSD_FILL_SIZE_CROCK_4
2364 ? BSD_FILL_SIZE_CROCK_4
2366 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2367 but emits no error message because it seems a legal thing to do.
2368 It is a degenerate case of .fill but could be emitted by a
2371 demand_empty_rest_of_line ();
2375 s_globl (int ignore ATTRIBUTE_UNUSED
)
2384 stop
= mri_comment_field (&stopc
);
2388 if ((name
= read_symbol_name ()) == NULL
)
2391 symbolP
= symbol_find_or_make (name
);
2392 S_SET_EXTERNAL (symbolP
);
2395 c
= *input_line_pointer
;
2398 input_line_pointer
++;
2400 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2408 demand_empty_rest_of_line ();
2411 mri_comment_end (stop
, stopc
);
2414 /* Handle the MRI IRP and IRPC pseudo-ops. */
2426 file
= as_where (&line
);
2428 eol
= find_end_of_line (input_line_pointer
, 0);
2429 sb_build (&s
, eol
- input_line_pointer
);
2430 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2431 input_line_pointer
= eol
;
2435 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2437 as_bad_where (file
, line
, "%s", err
);
2441 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2443 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2446 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2447 the section to only be linked once. However, this is not supported
2448 by most object file formats. This takes an optional argument,
2449 which is what to do about duplicates. */
2452 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2454 enum linkonce_type type
;
2458 type
= LINKONCE_DISCARD
;
2460 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2465 c
= get_symbol_name (& s
);
2466 if (strcasecmp (s
, "discard") == 0)
2467 type
= LINKONCE_DISCARD
;
2468 else if (strcasecmp (s
, "one_only") == 0)
2469 type
= LINKONCE_ONE_ONLY
;
2470 else if (strcasecmp (s
, "same_size") == 0)
2471 type
= LINKONCE_SAME_SIZE
;
2472 else if (strcasecmp (s
, "same_contents") == 0)
2473 type
= LINKONCE_SAME_CONTENTS
;
2475 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2477 (void) restore_line_pointer (c
);
2480 #ifdef obj_handle_link_once
2481 obj_handle_link_once (type
);
2482 #else /* ! defined (obj_handle_link_once) */
2486 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2487 as_warn (_(".linkonce is not supported for this object file format"));
2489 flags
= bfd_section_flags (now_seg
);
2490 flags
|= SEC_LINK_ONCE
;
2495 case LINKONCE_DISCARD
:
2496 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2498 case LINKONCE_ONE_ONLY
:
2499 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2501 case LINKONCE_SAME_SIZE
:
2502 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2504 case LINKONCE_SAME_CONTENTS
:
2505 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2508 if (!bfd_set_section_flags (now_seg
, flags
))
2509 as_bad (_("bfd_set_section_flags: %s"),
2510 bfd_errmsg (bfd_get_error ()));
2512 #endif /* ! defined (obj_handle_link_once) */
2514 demand_empty_rest_of_line ();
2518 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2521 segT current_seg
= now_seg
;
2522 subsegT current_subseg
= now_subseg
;
2523 segT bss_seg
= bss_section
;
2525 #if defined (TC_MIPS) || defined (TC_ALPHA)
2526 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2527 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2529 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2530 if (size
<= bfd_get_gp_size (stdoutput
))
2532 bss_seg
= subseg_new (".sbss", 1);
2533 seg_info (bss_seg
)->bss
= 1;
2534 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2535 as_warn (_("error setting flags for \".sbss\": %s"),
2536 bfd_errmsg (bfd_get_error ()));
2540 subseg_set (bss_seg
, 1);
2542 if (align
> OCTETS_PER_BYTE_POWER
)
2544 record_alignment (bss_seg
, align
);
2545 frag_align (align
, 0, 0);
2548 /* Detach from old frag. */
2549 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2550 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2552 symbol_set_frag (symbolP
, frag_now
);
2553 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2557 S_SET_SIZE (symbolP
, size
);
2559 S_SET_SEGMENT (symbolP
, bss_seg
);
2562 /* The symbol may already have been created with a preceding
2563 ".globl" directive -- be careful not to step on storage class
2564 in that case. Otherwise, set it to static. */
2565 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2566 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2567 #endif /* OBJ_COFF */
2569 subseg_set (current_seg
, current_subseg
);
2573 parse_align (int align_bytes
)
2579 if (*input_line_pointer
!= ',')
2582 as_bad (_("expected alignment after size"));
2583 ignore_rest_of_line ();
2587 input_line_pointer
++;
2590 align
= get_absolute_expr (&exp
);
2591 if (exp
.X_op
== O_absent
)
2594 if (!exp
.X_unsigned
)
2596 as_warn (_("alignment negative; 0 assumed"));
2600 if (align_bytes
&& align
!= 0)
2602 /* convert to a power of 2 alignment */
2603 unsigned int alignp2
= 0;
2604 while ((align
& 1) == 0)
2605 align
>>= 1, ++alignp2
;
2608 as_bad (_("alignment not a power of 2"));
2609 ignore_rest_of_line ();
2617 /* Called from s_comm_internal after symbol name and size have been
2618 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2619 1 if this was a ".bss" directive which has a 3rd argument
2620 (alignment as a power of 2), or 2 if this was a ".bss" directive
2621 with alignment in bytes. */
2624 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2630 align
= parse_align (needs_align
- 1);
2631 if (align
== (addressT
) -1)
2635 /* Assume some objects may require alignment on some systems. */
2636 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2638 bss_alloc (symbolP
, size
, align
);
2643 s_lcomm (int needs_align
)
2645 s_comm_internal (needs_align
, s_lcomm_internal
);
2649 s_lcomm_bytes (int needs_align
)
2651 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2655 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2661 /* We permit ANY defined expression: BSD4.2 demands constants. */
2662 if ((name
= read_symbol_name ()) == NULL
)
2665 if (*input_line_pointer
!= ',')
2667 as_bad (_("expected comma after \"%s\""), name
);
2671 input_line_pointer
++;
2672 expression_and_evaluate (&exp
);
2674 if (exp
.X_op
!= O_constant
2675 && exp
.X_op
!= O_register
)
2677 as_bad (_("bad expression"));
2681 symbolP
= symbol_find_or_make (name
);
2683 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2685 /* The name might be an undefined .global symbol; be sure to
2686 keep the "external" bit. */
2687 S_SET_SEGMENT (symbolP
,
2688 (exp
.X_op
== O_constant
2691 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2695 as_bad (_("symbol `%s' is already defined"), name
);
2698 demand_empty_rest_of_line ();
2703 ignore_rest_of_line ();
2708 /* Read a line into an sb. Returns the character that ended the line
2709 or zero if there are no more lines. */
2712 get_line_sb (sb
*line
, int in_macro
)
2716 if (input_line_pointer
[-1] == '\n')
2717 bump_line_counters ();
2719 if (input_line_pointer
>= buffer_limit
)
2721 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2722 if (buffer_limit
== 0)
2726 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2727 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2728 input_line_pointer
= eol
;
2730 /* Don't skip multiple end-of-line characters, because that breaks support
2731 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2732 characters but isn't. Instead just skip one end of line character and
2733 return the character skipped so that the caller can re-insert it if
2735 return *input_line_pointer
++;
2739 get_non_macro_line_sb (sb
*line
)
2741 return get_line_sb (line
, 0);
2745 get_macro_line_sb (sb
*line
)
2747 return get_line_sb (line
, 1);
2750 /* Define a macro. This is an interface to macro.c. */
2753 s_macro (int ignore ATTRIBUTE_UNUSED
)
2762 file
= as_where (&line
);
2764 eol
= find_end_of_line (input_line_pointer
, 0);
2765 sb_build (&s
, eol
- input_line_pointer
);
2766 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2767 input_line_pointer
= eol
;
2769 if (line_label
!= NULL
)
2774 name
= S_GET_NAME (line_label
);
2775 len
= strlen (name
);
2776 sb_build (&label
, len
);
2777 sb_add_buffer (&label
, name
, len
);
2778 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2782 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2784 as_bad_where (file
, line
, err
, name
);
2787 if (line_label
!= NULL
)
2789 S_SET_SEGMENT (line_label
, absolute_section
);
2790 S_SET_VALUE (line_label
, 0);
2791 symbol_set_frag (line_label
, &zero_address_frag
);
2794 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2795 && po_entry_find (po_hash
, name
) != NULL
)
2798 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2799 as_warn_where (file
,
2801 _("attempt to redefine pseudo-op `%s' ignored"),
2808 /* Handle the .mexit pseudo-op, which immediately exits a macro
2812 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2816 cond_exit_macro (macro_nest
);
2817 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2820 as_warn (_("ignoring macro exit outside a macro definition."));
2823 /* Switch in and out of MRI mode. */
2826 s_mri (int ignore ATTRIBUTE_UNUSED
)
2829 #ifdef MRI_MODE_CHANGE
2833 on
= get_absolute_expression ();
2834 #ifdef MRI_MODE_CHANGE
2835 old_flag
= flag_mri
;
2854 /* Operator precedence changes in m68k MRI mode, so we need to
2855 update the operator rankings. */
2856 expr_set_precedence ();
2858 #ifdef MRI_MODE_CHANGE
2860 MRI_MODE_CHANGE (on
);
2863 demand_empty_rest_of_line ();
2866 /* Handle changing the location counter. */
2869 do_org (segT segment
, expressionS
*exp
, int fill
)
2871 if (segment
!= now_seg
2872 && segment
!= absolute_section
2873 && segment
!= expr_section
)
2874 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2876 if (now_seg
== absolute_section
)
2879 as_warn (_("ignoring fill value in absolute section"));
2880 if (exp
->X_op
!= O_constant
)
2882 as_bad (_("only constant offsets supported in absolute section"));
2883 exp
->X_add_number
= 0;
2885 abs_section_offset
= exp
->X_add_number
;
2890 symbolS
*sym
= exp
->X_add_symbol
;
2891 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2893 if (fill
&& in_bss ())
2894 as_warn (_("ignoring fill value in section `%s'"),
2895 segment_name (now_seg
));
2897 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2899 /* Handle complex expressions. */
2900 sym
= make_expr_symbol (exp
);
2904 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2910 s_org (int ignore ATTRIBUTE_UNUSED
)
2916 #ifdef md_flush_pending_output
2917 md_flush_pending_output ();
2920 /* The m68k MRI assembler has a different meaning for .org. It
2921 means to create an absolute section at a given address. We can't
2922 support that--use a linker script instead. */
2925 as_bad (_("MRI style ORG pseudo-op not supported"));
2926 ignore_rest_of_line ();
2930 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2931 thing as a sub-segment-relative origin. Any absolute origin is
2932 given a warning, then assumed to be segment-relative. Any
2933 segmented origin expression ("foo+42") had better be in the right
2934 segment or the .org is ignored.
2936 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2937 we never know sub-segment sizes when we are reading code. BSD
2938 will crash trying to emit negative numbers of filler bytes in
2939 certain .orgs. We don't crash, but see as-write for that code.
2941 Don't make frag if need_pass_2==1. */
2942 segment
= get_known_segmented_expression (&exp
);
2943 if (*input_line_pointer
== ',')
2945 input_line_pointer
++;
2946 temp_fill
= get_absolute_expression ();
2952 do_org (segment
, &exp
, temp_fill
);
2954 demand_empty_rest_of_line ();
2957 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2958 called by the obj-format routine which handles section changing
2959 when in MRI mode. It will create a new section, and return it. It
2960 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2961 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2964 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2974 name
= input_line_pointer
;
2975 if (!ISDIGIT (*name
))
2976 c
= get_symbol_name (& name
);
2981 ++input_line_pointer
;
2983 while (ISDIGIT (*input_line_pointer
));
2985 c
= *input_line_pointer
;
2986 *input_line_pointer
= '\0';
2989 name
= xstrdup (name
);
2991 c
= restore_line_pointer (c
);
2993 seg
= subseg_new (name
, 0);
2999 ++input_line_pointer
;
3000 align
= get_absolute_expression ();
3001 record_alignment (seg
, align
);
3005 if (*input_line_pointer
== ',')
3007 c
= *++input_line_pointer
;
3009 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3012 as_bad (_("unrecognized section type"));
3013 ++input_line_pointer
;
3018 flags
= SEC_NO_FLAGS
;
3020 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3021 else if (*type
== 'D' || *type
== 'M')
3022 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3023 else if (*type
== 'R')
3024 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3025 if (flags
!= SEC_NO_FLAGS
)
3027 if (!bfd_set_section_flags (seg
, flags
))
3028 as_warn (_("error setting flags for \"%s\": %s"),
3029 bfd_section_name (seg
),
3030 bfd_errmsg (bfd_get_error ()));
3035 /* Ignore the HP type. */
3036 if (*input_line_pointer
== ',')
3037 input_line_pointer
+= 2;
3039 demand_empty_rest_of_line ();
3041 #else /* ! TC_M68K */
3042 /* The MRI assembler seems to use different forms of .sect for
3043 different targets. */
3044 as_bad ("MRI mode not supported for this target");
3045 ignore_rest_of_line ();
3046 #endif /* ! TC_M68K */
3049 /* Handle the .print pseudo-op. */
3052 s_print (int ignore ATTRIBUTE_UNUSED
)
3057 s
= demand_copy_C_string (&len
);
3060 demand_empty_rest_of_line ();
3063 /* Handle the .purgem pseudo-op. */
3066 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3068 if (is_it_end_of_statement ())
3070 demand_empty_rest_of_line ();
3080 c
= get_symbol_name (& name
);
3081 delete_macro (name
);
3082 *input_line_pointer
= c
;
3083 SKIP_WHITESPACE_AFTER_NAME ();
3085 while (*input_line_pointer
++ == ',');
3087 --input_line_pointer
;
3088 demand_empty_rest_of_line ();
3091 /* Handle the .endm/.endr pseudo-ops. */
3094 s_bad_end (int endr
)
3096 as_warn (_(".end%c encountered without preceding %s"),
3098 endr
? ".rept, .irp, or .irpc" : ".macro");
3099 demand_empty_rest_of_line ();
3102 /* Handle the .rept pseudo-op. */
3105 s_rept (int ignore ATTRIBUTE_UNUSED
)
3109 count
= (size_t) get_absolute_expression ();
3111 do_repeat (count
, "REPT", "ENDR");
3114 /* This function provides a generic repeat block implementation. It allows
3115 different directives to be used as the start/end keys. */
3118 do_repeat (size_t count
, const char *start
, const char *end
)
3123 if (((ssize_t
) count
) < 0)
3125 as_bad (_("negative count for %s - ignored"), start
);
3130 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3132 as_bad (_("%s without %s"), start
, end
);
3136 sb_build (&many
, count
* one
.len
);
3138 sb_add_sb (&many
, &one
);
3142 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3144 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3147 /* Like do_repeat except that any text matching EXPANDER in the
3148 block is replaced by the iteration count. */
3151 do_repeat_with_expander (size_t count
,
3154 const char * expander
)
3159 if (((ssize_t
) count
) < 0)
3161 as_bad (_("negative count for %s - ignored"), start
);
3166 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3168 as_bad (_("%s without %s"), start
, end
);
3174 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3176 while (count
-- > 0)
3182 sb_build (& processed
, one
.len
);
3183 sb_add_sb (& processed
, & one
);
3184 sub
= strstr (processed
.ptr
, expander
);
3185 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3186 gas_assert (len
< 8);
3187 memmove (sub
+ len
, sub
+ 8,
3188 processed
.ptr
+ processed
.len
- (sub
+ 8));
3189 processed
.len
-= (8 - len
);
3190 sb_add_sb (& many
, & processed
);
3191 sb_kill (& processed
);
3196 sb_add_sb (&many
, &one
);
3200 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3202 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3205 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3206 input buffers to skip. Assumes that conditionals preceding the loop end
3207 are properly nested.
3209 This function makes it easier to implement a premature "break" out of the
3210 loop. The EXTRA arg accounts for other buffers we might have inserted,
3211 such as line substitutions. */
3214 end_repeat (int extra
)
3216 cond_exit_macro (macro_nest
);
3217 while (extra
-- >= 0)
3218 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3222 assign_symbol (char *name
, int mode
)
3226 if (name
[0] == '.' && name
[1] == '\0')
3228 /* Turn '. = mumble' into a .org mumble. */
3232 segment
= get_known_segmented_expression (&exp
);
3235 do_org (segment
, &exp
, 0);
3240 if ((symbolP
= symbol_find (name
)) == NULL
3241 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3243 symbolP
= symbol_find_or_make (name
);
3245 /* When doing symbol listings, play games with dummy fragments living
3246 outside the normal fragment chain to record the file and line info
3248 if (listing
& LISTING_SYMBOLS
)
3250 extern struct list_info_struct
*listing_tail
;
3251 fragS
*dummy_frag
= XCNEW (fragS
);
3252 dummy_frag
->line
= listing_tail
;
3253 dummy_frag
->fr_symbol
= symbolP
;
3254 symbol_set_frag (symbolP
, dummy_frag
);
3257 #if defined (OBJ_COFF) && !defined (TE_PE)
3258 /* "set" symbols are local unless otherwise specified. */
3259 SF_SET_LOCAL (symbolP
);
3263 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3265 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3266 && !S_CAN_BE_REDEFINED (symbolP
))
3268 as_bad (_("symbol `%s' is already defined"), name
);
3269 ignore_rest_of_line ();
3270 input_line_pointer
--;
3273 /* If the symbol is volatile, copy the symbol and replace the
3274 original with the copy, so that previous uses of the symbol will
3275 retain the value of the symbol at the point of use. */
3276 else if (S_IS_VOLATILE (symbolP
))
3277 symbolP
= symbol_clone (symbolP
, 1);
3281 S_SET_VOLATILE (symbolP
);
3283 S_SET_FORWARD_REF (symbolP
);
3285 pseudo_set (symbolP
);
3288 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3289 then this is .equiv, and it is an error if the symbol is already
3290 defined. If EQUIV is -1, the symbol additionally is a forward
3298 /* Especial apologies for the random logic:
3299 this just grew, and could be parsed much more simply!
3301 if ((name
= read_symbol_name ()) == NULL
)
3304 if (*input_line_pointer
!= ',')
3306 as_bad (_("expected comma after \"%s\""), name
);
3307 ignore_rest_of_line ();
3312 input_line_pointer
++;
3313 assign_symbol (name
, equiv
);
3314 demand_empty_rest_of_line ();
3328 #ifdef md_flush_pending_output
3329 md_flush_pending_output ();
3332 #ifdef md_cons_align
3337 stop
= mri_comment_field (&stopc
);
3339 /* In m68k MRI mode, we need to align to a word boundary, unless
3341 if (flag_m68k_mri
&& mult
> 1)
3343 if (now_seg
== absolute_section
)
3345 abs_section_offset
+= abs_section_offset
& 1;
3346 if (line_label
!= NULL
)
3347 S_SET_VALUE (line_label
, abs_section_offset
);
3349 else if (mri_common_symbol
!= NULL
)
3353 mri_val
= S_GET_VALUE (mri_common_symbol
);
3354 if ((mri_val
& 1) != 0)
3356 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3357 if (line_label
!= NULL
)
3359 expressionS
*symexp
;
3361 symexp
= symbol_get_value_expression (line_label
);
3362 know (symexp
->X_op
== O_symbol
);
3363 know (symexp
->X_add_symbol
== mri_common_symbol
);
3364 symexp
->X_add_number
+= 1;
3370 do_align (1, (char *) NULL
, 0, 0);
3371 if (line_label
!= NULL
)
3373 symbol_set_frag (line_label
, frag_now
);
3374 S_SET_VALUE (line_label
, frag_now_fix ());
3384 if (*input_line_pointer
== ',')
3386 ++input_line_pointer
;
3391 val
.X_op
= O_constant
;
3392 val
.X_add_number
= 0;
3395 if ((val
.X_op
!= O_constant
3396 || val
.X_add_number
< - 0x80
3397 || val
.X_add_number
> 0xff
3398 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3399 && (now_seg
!= absolute_section
&& !in_bss ()))
3401 resolve_expression (&exp
);
3402 if (exp
.X_op
!= O_constant
)
3403 as_bad (_("unsupported variable size or fill value"));
3408 /* PR 20901: Check for excessive values.
3409 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3410 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3411 as_bad (_("size value for space directive too large: %lx"),
3412 (long) exp
.X_add_number
);
3417 bytes
= mult
* exp
.X_add_number
;
3419 for (i
= 0; i
< exp
.X_add_number
; i
++)
3420 emit_expr (&val
, mult
);
3426 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3427 resolve_expression (&exp
);
3429 if (exp
.X_op
== O_constant
)
3433 repeat
= exp
.X_add_number
;
3440 as_warn (_(".space repeat count is zero, ignored"));
3441 else if (repeat
< 0)
3442 as_warn (_(".space repeat count is negative, ignored"));
3446 /* If we are in the absolute section, just bump the offset. */
3447 if (now_seg
== absolute_section
)
3449 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3450 as_warn (_("ignoring fill value in absolute section"));
3451 abs_section_offset
+= repeat
;
3455 /* If we are secretly in an MRI common section, then
3456 creating space just increases the size of the common
3458 if (mri_common_symbol
!= NULL
)
3460 S_SET_VALUE (mri_common_symbol
,
3461 S_GET_VALUE (mri_common_symbol
) + repeat
);
3466 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3467 (offsetT
) repeat
, (char *) 0);
3471 if (now_seg
== absolute_section
)
3473 as_bad (_("space allocation too complex in absolute section"));
3474 subseg_set (text_section
, 0);
3477 if (mri_common_symbol
!= NULL
)
3479 as_bad (_("space allocation too complex in common section"));
3480 mri_common_symbol
= NULL
;
3484 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3485 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3488 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3489 as_warn (_("ignoring fill value in section `%s'"),
3490 segment_name (now_seg
));
3492 *p
= val
.X_add_number
;
3497 /* In MRI mode, after an odd number of bytes, we must align to an
3498 even word boundary, unless the next instruction is a dc.b, ds.b
3500 if (flag_mri
&& (bytes
& 1) != 0)
3501 mri_pending_align
= 1;
3503 demand_empty_rest_of_line ();
3506 mri_comment_end (stop
, stopc
);
3510 s_nop (int ignore ATTRIBUTE_UNUSED
)
3517 #ifdef md_flush_pending_output
3518 md_flush_pending_output ();
3521 #ifdef md_cons_align
3527 demand_empty_rest_of_line ();
3530 start_off
= frag_now_fix ();
3533 #ifdef md_emit_single_noop
3534 md_emit_single_noop
;
3538 #ifndef md_single_noop_insn
3539 #define md_single_noop_insn "nop"
3541 /* md_assemble might modify its argument, so
3542 we must pass it a string that is writable. */
3543 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3544 as_fatal ("%s", xstrerror (errno
));
3546 /* Some targets assume that they can update input_line_pointer
3547 inside md_assemble, and, worse, that they can leave it
3548 assigned to the string pointer that was provided as an
3549 argument. So preserve ilp here. */
3550 char *saved_ilp
= input_line_pointer
;
3552 input_line_pointer
= saved_ilp
;
3555 #ifdef md_flush_pending_output
3556 md_flush_pending_output ();
3558 } while (exp
.X_op
== O_constant
3559 && exp
.X_add_number
> 0
3560 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3561 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3565 s_nops (int ignore ATTRIBUTE_UNUSED
)
3570 #ifdef md_flush_pending_output
3571 md_flush_pending_output ();
3574 #ifdef md_cons_align
3580 /* Note - this expression is tested for an absolute value in
3581 write.c:relax_segment(). */
3584 if (*input_line_pointer
== ',')
3586 ++input_line_pointer
;
3591 val
.X_op
= O_constant
;
3592 val
.X_add_number
= 0;
3595 if (val
.X_op
!= O_constant
)
3597 as_bad (_("unsupported variable nop control in .nops directive"));
3598 val
.X_op
= O_constant
;
3599 val
.X_add_number
= 0;
3601 else if (val
.X_add_number
< 0)
3603 as_warn (_("negative nop control byte, ignored"));
3604 val
.X_add_number
= 0;
3607 demand_empty_rest_of_line ();
3610 /* Ignore this directive if we are going to perform a second pass. */
3613 /* Store the no-op instruction control byte in the first byte of frag. */
3615 symbolS
*sym
= make_expr_symbol (&exp
);
3616 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3617 sym
, (offsetT
) 0, (char *) 0);
3618 *p
= val
.X_add_number
;
3621 /* This is like s_space, but the value is a floating point number with
3622 the given precision. This is for the MRI dcb.s pseudo-op and
3626 s_float_space (int float_type
)
3630 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3634 #ifdef md_cons_align
3639 stop
= mri_comment_field (&stopc
);
3641 count
= get_absolute_expression ();
3644 if (*input_line_pointer
!= ',')
3646 as_bad (_("missing value"));
3647 ignore_rest_of_line ();
3649 mri_comment_end (stop
, stopc
);
3653 ++input_line_pointer
;
3657 /* Skip any 0{letter} that may be present. Don't even check if the
3658 * letter is legal. */
3659 if (input_line_pointer
[0] == '0'
3660 && ISALPHA (input_line_pointer
[1]))
3661 input_line_pointer
+= 2;
3663 /* Accept :xxxx, where the x's are hex digits, for a floating point
3664 with the exact digits specified. */
3665 if (input_line_pointer
[0] == ':')
3667 flen
= hex_float (float_type
, temp
);
3670 ignore_rest_of_line ();
3672 mri_comment_end (stop
, stopc
);
3680 err
= md_atof (float_type
, temp
, &flen
);
3681 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3682 know (err
!= NULL
|| flen
> 0);
3685 as_bad (_("bad floating literal: %s"), err
);
3686 ignore_rest_of_line ();
3688 mri_comment_end (stop
, stopc
);
3693 while (--count
>= 0)
3697 p
= frag_more (flen
);
3698 memcpy (p
, temp
, (unsigned int) flen
);
3701 demand_empty_rest_of_line ();
3704 mri_comment_end (stop
, stopc
);
3707 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3710 s_struct (int ignore ATTRIBUTE_UNUSED
)
3716 stop
= mri_comment_field (&stopc
);
3717 abs_section_offset
= get_absolute_expression ();
3718 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3719 /* The ELF backend needs to know that we are changing sections, so
3720 that .previous works correctly. */
3722 obj_elf_section_change_hook ();
3724 subseg_set (absolute_section
, 0);
3725 demand_empty_rest_of_line ();
3727 mri_comment_end (stop
, stopc
);
3731 s_text (int ignore ATTRIBUTE_UNUSED
)
3735 temp
= get_absolute_expression ();
3736 subseg_set (text_section
, (subsegT
) temp
);
3737 demand_empty_rest_of_line ();
3740 /* .weakref x, y sets x as an alias to y that, as long as y is not
3741 referenced directly, will cause y to become a weak symbol. */
3743 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3750 if ((name
= read_symbol_name ()) == NULL
)
3753 symbolP
= symbol_find_or_make (name
);
3755 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3757 if (!S_IS_VOLATILE (symbolP
))
3759 as_bad (_("symbol `%s' is already defined"), name
);
3762 symbolP
= symbol_clone (symbolP
, 1);
3763 S_CLEAR_VOLATILE (symbolP
);
3768 if (*input_line_pointer
!= ',')
3770 as_bad (_("expected comma after \"%s\""), name
);
3774 input_line_pointer
++;
3779 if ((name
= read_symbol_name ()) == NULL
)
3782 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3783 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3785 symbolP2
= symbol_find_or_make (name
);
3786 S_SET_WEAKREFD (symbolP2
);
3790 symbolS
*symp
= symbolP2
;
3792 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3794 expressionS
*expP
= symbol_get_value_expression (symp
);
3796 gas_assert (expP
->X_op
== O_symbol
3797 && expP
->X_add_number
== 0);
3798 symp
= expP
->X_add_symbol
;
3800 if (symp
== symbolP
)
3804 loop
= concat (S_GET_NAME (symbolP
),
3805 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3808 while (symp
!= symbolP
)
3810 char *old_loop
= loop
;
3812 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3813 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3814 (const char *) NULL
);
3818 as_bad (_("%s: would close weakref loop: %s"),
3819 S_GET_NAME (symbolP
), loop
);
3823 ignore_rest_of_line ();
3827 /* Short-circuiting instead of just checking here might speed
3828 things up a tiny little bit, but loop error messages would
3829 miss intermediate links. */
3830 /* symbolP2 = symp; */
3833 memset (&exp
, 0, sizeof (exp
));
3834 exp
.X_op
= O_symbol
;
3835 exp
.X_add_symbol
= symbolP2
;
3837 S_SET_SEGMENT (symbolP
, undefined_section
);
3838 symbol_set_value_expression (symbolP
, &exp
);
3839 symbol_set_frag (symbolP
, &zero_address_frag
);
3840 S_SET_WEAKREFR (symbolP
);
3842 demand_empty_rest_of_line ();
3847 ignore_rest_of_line ();
3853 /* Verify that we are at the end of a line. If not, issue an error and
3857 demand_empty_rest_of_line (void)
3860 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3861 input_line_pointer
++;
3864 if (ISPRINT (*input_line_pointer
))
3865 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3866 *input_line_pointer
);
3868 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3869 *input_line_pointer
);
3870 ignore_rest_of_line ();
3873 /* Return pointing just after end-of-line. */
3874 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3877 /* Silently advance to the end of line. Use this after already having
3878 issued an error about something bad. */
3881 ignore_rest_of_line (void)
3883 while (input_line_pointer
< buffer_limit
3884 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3885 input_line_pointer
++;
3887 input_line_pointer
++;
3889 /* Return pointing just after end-of-line. */
3890 if (input_line_pointer
<= buffer_limit
)
3891 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3894 /* Sets frag for given symbol to zero_address_frag, except when the
3895 symbol frag is already set to a dummy listing frag. */
3898 set_zero_frag (symbolS
*symbolP
)
3900 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3901 symbol_set_frag (symbolP
, &zero_address_frag
);
3904 /* In: Pointer to a symbol.
3905 Input_line_pointer->expression.
3907 Out: Input_line_pointer->just after any whitespace after expression.
3908 Tried to set symbol to value of expression.
3909 Will change symbols type, value, and frag; */
3912 pseudo_set (symbolS
*symbolP
)
3917 know (symbolP
); /* NULL pointer is logic error. */
3919 if (!S_IS_FORWARD_REF (symbolP
))
3920 (void) expression (&exp
);
3922 (void) deferred_expression (&exp
);
3924 if (exp
.X_op
== O_illegal
)
3925 as_bad (_("illegal expression"));
3926 else if (exp
.X_op
== O_absent
)
3927 as_bad (_("missing expression"));
3928 else if (exp
.X_op
== O_big
)
3930 if (exp
.X_add_number
> 0)
3931 as_bad (_("bignum invalid"));
3933 as_bad (_("floating point number invalid"));
3935 else if (exp
.X_op
== O_subtract
3936 && !S_IS_FORWARD_REF (symbolP
)
3937 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3938 && (symbol_get_frag (exp
.X_add_symbol
)
3939 == symbol_get_frag (exp
.X_op_symbol
)))
3941 exp
.X_op
= O_constant
;
3942 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3943 - S_GET_VALUE (exp
.X_op_symbol
));
3946 if (symbol_section_p (symbolP
))
3948 as_bad ("attempt to set value of section symbol");
3957 exp
.X_add_number
= 0;
3960 S_SET_SEGMENT (symbolP
, absolute_section
);
3961 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3962 set_zero_frag (symbolP
);
3966 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3967 if (S_IS_EXTERNAL (symbolP
))
3969 as_bad ("can't equate global symbol `%s' with register name",
3970 S_GET_NAME (symbolP
));
3974 S_SET_SEGMENT (symbolP
, reg_section
);
3975 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3976 set_zero_frag (symbolP
);
3977 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3981 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3982 /* For x=undef+const, create an expression symbol.
3983 For x=x+const, just update x except when x is an undefined symbol
3984 For x=defined+const, evaluate x. */
3985 if (symbolP
== exp
.X_add_symbol
3986 && (seg
!= undefined_section
3987 || !symbol_constant_p (symbolP
)))
3989 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3992 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3994 symbolS
*s
= exp
.X_add_symbol
;
3996 if (S_IS_COMMON (s
))
3997 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3998 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4000 S_SET_SEGMENT (symbolP
, seg
);
4001 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4002 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4003 copy_symbol_attributes (symbolP
, s
);
4006 S_SET_SEGMENT (symbolP
, undefined_section
);
4007 symbol_set_value_expression (symbolP
, &exp
);
4008 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4009 set_zero_frag (symbolP
);
4013 /* The value is some complex expression. */
4014 S_SET_SEGMENT (symbolP
, expr_section
);
4015 symbol_set_value_expression (symbolP
, &exp
);
4016 set_zero_frag (symbolP
);
4023 CONStruct more frag of .bytes, or .words etc.
4024 Should need_pass_2 be 1 then emit no frag(s).
4025 This understands EXPRESSIONS.
4029 This has a split personality. We use expression() to read the
4030 value. We can detect if the value won't fit in a byte or word.
4031 But we can't detect if expression() discarded significant digits
4032 in the case of a long. Not worth the crocks required to fix it. */
4034 /* Select a parser for cons expressions. */
4036 /* Some targets need to parse the expression in various fancy ways.
4037 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4038 (for example, the HPPA does this). Otherwise, you can define
4039 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4040 are defined, which is the normal case, then only simple expressions
4045 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4048 #ifndef TC_PARSE_CONS_EXPRESSION
4049 #ifdef REPEAT_CONS_EXPRESSIONS
4050 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4051 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4053 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4056 /* If we haven't gotten one yet, just call expression. */
4057 #ifndef TC_PARSE_CONS_EXPRESSION
4058 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4059 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4064 do_parse_cons_expression (expressionS
*exp
,
4065 int nbytes ATTRIBUTE_UNUSED
)
4067 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4071 /* Worker to do .byte etc statements.
4072 Clobbers input_line_pointer and checks end-of-line. */
4075 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4083 #ifdef md_flush_pending_output
4084 md_flush_pending_output ();
4088 stop
= mri_comment_field (&stopc
);
4090 if (is_it_end_of_statement ())
4092 demand_empty_rest_of_line ();
4094 mri_comment_end (stop
, stopc
);
4098 #ifdef TC_ADDRESS_BYTES
4100 nbytes
= TC_ADDRESS_BYTES ();
4103 #ifdef md_cons_align
4104 md_cons_align (nbytes
);
4110 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4111 #ifdef TC_CONS_FIX_CHECK
4112 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4114 if (*cur_fix
!= NULL
)
4115 cur_fix
= &(*cur_fix
)->fx_next
;
4120 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4125 if (*input_line_pointer
== '"')
4127 as_bad (_("unexpected `\"' in expression"));
4128 ignore_rest_of_line ();
4132 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4137 if (exp
.X_op
== O_symbol
)
4138 exp
.X_op
= O_symbol_rva
;
4140 as_fatal (_("rva without symbol"));
4142 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4143 #ifdef TC_CONS_FIX_CHECK
4144 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4148 while (*input_line_pointer
++ == ',');
4150 /* In MRI mode, after an odd number of bytes, we must align to an
4151 even word boundary, unless the next instruction is a dc.b, ds.b
4153 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4154 mri_pending_align
= 1;
4156 input_line_pointer
--; /* Put terminator back into stream. */
4158 demand_empty_rest_of_line ();
4161 mri_comment_end (stop
, stopc
);
4167 cons_worker (size
, 0);
4173 cons_worker (size
, 1);
4176 /* .reloc offset, reloc_name, symbol+addend. */
4179 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4186 struct reloc_list
*reloc
;
4187 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4188 static struct _bfd_rel bfd_relocs
[] =
4190 { "NONE", BFD_RELOC_NONE
},
4191 { "8", BFD_RELOC_8
},
4192 { "16", BFD_RELOC_16
},
4193 { "32", BFD_RELOC_32
},
4194 { "64", BFD_RELOC_64
}
4197 reloc
= XNEW (struct reloc_list
);
4200 stop
= mri_comment_field (&stopc
);
4209 as_bad (_("missing or bad offset expression"));
4212 exp
.X_add_symbol
= section_symbol (now_seg
);
4213 /* Mark the section symbol used in relocation so that it will be
4214 included in the symbol table. */
4215 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4216 exp
.X_op
= O_symbol
;
4219 if (exp
.X_add_number
== 0)
4221 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4226 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4231 if (*input_line_pointer
!= ',')
4233 as_bad (_("missing reloc type"));
4237 ++input_line_pointer
;
4239 c
= get_symbol_name (& r_name
);
4240 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4244 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4245 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4247 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4248 bfd_relocs
[i
].code
);
4253 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4254 *input_line_pointer
= c
;
4255 if (reloc
->u
.a
.howto
== NULL
)
4257 as_bad (_("unrecognized reloc type"));
4261 exp
.X_op
= O_absent
;
4262 SKIP_WHITESPACE_AFTER_NAME ();
4263 if (*input_line_pointer
== ',')
4265 ++input_line_pointer
;
4273 as_bad (_("bad reloc expression"));
4275 ignore_rest_of_line ();
4278 mri_comment_end (stop
, stopc
);
4281 reloc
->u
.a
.sym
= NULL
;
4282 reloc
->u
.a
.addend
= 0;
4285 reloc
->u
.a
.sym
= NULL
;
4286 reloc
->u
.a
.addend
= exp
.X_add_number
;
4289 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4290 reloc
->u
.a
.addend
= exp
.X_add_number
;
4293 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4294 reloc
->u
.a
.addend
= 0;
4298 reloc
->file
= as_where (&reloc
->line
);
4299 reloc
->next
= reloc_list
;
4302 demand_empty_rest_of_line ();
4304 mri_comment_end (stop
, stopc
);
4307 /* Put the contents of expression EXP into the object file using
4308 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4311 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4313 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4317 emit_expr_with_reloc (expressionS
*exp
,
4318 unsigned int nbytes
,
4319 TC_PARSE_CONS_RETURN_TYPE reloc
)
4323 valueT extra_digit
= 0;
4325 /* Don't do anything if we are going to make another pass. */
4330 dot_value
= frag_now_fix ();
4331 dot_frag
= frag_now
;
4335 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4336 appear as a four byte positive constant in the .line section,
4337 followed by a 2 byte 0xffff. Look for that case here. */
4339 static int dwarf_line
= -1;
4341 if (strcmp (segment_name (now_seg
), ".line") != 0)
4343 else if (dwarf_line
>= 0
4345 && exp
->X_op
== O_constant
4346 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4347 listing_source_line ((unsigned int) dwarf_line
);
4348 else if (nbytes
== 4
4349 && exp
->X_op
== O_constant
4350 && exp
->X_add_number
>= 0)
4351 dwarf_line
= exp
->X_add_number
;
4356 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4357 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4358 AT_sibling (0x12) followed by a four byte address of the sibling
4359 followed by a 2 byte AT_name (0x38) followed by the name of the
4360 file. We look for that case here. */
4362 static int dwarf_file
= 0;
4364 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4366 else if (dwarf_file
== 0
4368 && exp
->X_op
== O_constant
4369 && exp
->X_add_number
== 0x11)
4371 else if (dwarf_file
== 1
4373 && exp
->X_op
== O_constant
4374 && exp
->X_add_number
== 0x12)
4376 else if (dwarf_file
== 2
4379 else if (dwarf_file
== 3
4381 && exp
->X_op
== O_constant
4382 && exp
->X_add_number
== 0x38)
4387 /* The variable dwarf_file_string tells stringer that the string
4388 may be the name of the source file. */
4389 if (dwarf_file
== 4)
4390 dwarf_file_string
= 1;
4392 dwarf_file_string
= 0;
4397 if (check_eh_frame (exp
, &nbytes
))
4402 /* Handle a negative bignum. */
4404 && exp
->X_add_number
== 0
4405 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4406 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4409 unsigned long carry
;
4411 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4413 /* Negate the bignum: one's complement each digit and add 1. */
4415 for (i
= 0; i
< exp
->X_add_number
; i
++)
4419 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4422 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4423 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4426 /* We can ignore any carry out, because it will be handled by
4427 extra_digit if it is needed. */
4429 extra_digit
= (valueT
) -1;
4433 if (op
== O_absent
|| op
== O_illegal
)
4435 as_warn (_("zero assumed for missing expression"));
4436 exp
->X_add_number
= 0;
4439 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4441 as_bad (_("floating point number invalid"));
4442 exp
->X_add_number
= 0;
4445 else if (op
== O_register
)
4447 as_warn (_("register value used as expression"));
4451 /* Allow `.word 0' in the absolute section. */
4452 if (now_seg
== absolute_section
)
4454 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4455 as_bad (_("attempt to store value in absolute section"));
4456 abs_section_offset
+= nbytes
;
4460 /* Allow `.word 0' in BSS style sections. */
4461 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4462 as_bad (_("attempt to store non-zero value in section `%s'"),
4463 segment_name (now_seg
));
4465 p
= frag_more ((int) nbytes
);
4467 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4469 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4473 #ifndef WORKING_DOT_WORD
4474 /* If we have the difference of two symbols in a word, save it on
4475 the broken_words list. See the code in write.c. */
4476 if (op
== O_subtract
&& nbytes
== 2)
4478 struct broken_word
*x
;
4480 x
= XNEW (struct broken_word
);
4481 x
->next_broken_word
= broken_words
;
4484 x
->subseg
= now_subseg
;
4486 x
->word_goes_here
= p
;
4488 x
->add
= exp
->X_add_symbol
;
4489 x
->sub
= exp
->X_op_symbol
;
4490 x
->addnum
= exp
->X_add_number
;
4498 /* If we have an integer, but the number of bytes is too large to
4499 pass to md_number_to_chars, handle it as a bignum. */
4500 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4502 extra_digit
= exp
->X_unsigned
? 0 : -1;
4503 convert_to_bignum (exp
, !exp
->X_unsigned
);
4507 if (op
== O_constant
)
4515 /* JF << of >= number of bits in the object is undefined. In
4516 particular SPARC (Sun 4) has problems. */
4517 if (nbytes
>= sizeof (valueT
))
4520 if (nbytes
> sizeof (valueT
))
4523 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4527 /* Don't store these bits. */
4528 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4529 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4532 unmask
= ~mask
; /* Do store these bits. */
4535 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4536 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4539 get
= exp
->X_add_number
;
4541 if ((get
& mask
) != 0
4542 && ((get
& mask
) != mask
4543 || (get
& hibit
) == 0))
4545 /* Leading bits contain both 0s & 1s. */
4546 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4548 as_warn (_("value 0x%llx truncated to 0x%llx"),
4549 (unsigned long long) get
, (unsigned long long) use
);
4551 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4552 (unsigned long long) get
, (unsigned long long) use
);
4555 as_warn (_("value 0x%lx truncated to 0x%lx"),
4556 (unsigned long) get
, (unsigned long) use
);
4559 /* Put bytes in right order. */
4560 md_number_to_chars (p
, use
, (int) nbytes
);
4562 else if (op
== O_big
)
4565 LITTLENUM_TYPE
*nums
;
4567 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4570 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4574 LITTLENUM_TYPE sign
= 0;
4575 if ((generic_bignum
[--i
]
4576 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4577 sign
= ~(LITTLENUM_TYPE
) 0;
4579 while (++i
< exp
->X_add_number
)
4580 if (generic_bignum
[i
] != sign
)
4583 else if (nbytes
== 1)
4585 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4586 Check that bits 8.. of generic_bignum[0] match bit 7
4587 and that they match all of generic_bignum[1..exp->X_add_number]. */
4588 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4589 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4591 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4593 while (++i
< exp
->X_add_number
)
4594 if (generic_bignum
[i
] != sign
)
4599 if (i
< exp
->X_add_number
)
4600 as_warn (ngettext ("bignum truncated to %d byte",
4601 "bignum truncated to %d bytes",
4609 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4612 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4614 if (target_big_endian
)
4616 while (nbytes
> size
)
4618 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4619 nbytes
-= CHARS_PER_LITTLENUM
;
4620 p
+= CHARS_PER_LITTLENUM
;
4623 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4624 while (size
>= CHARS_PER_LITTLENUM
)
4627 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4628 size
-= CHARS_PER_LITTLENUM
;
4629 p
+= CHARS_PER_LITTLENUM
;
4634 nums
= generic_bignum
;
4635 while (size
>= CHARS_PER_LITTLENUM
)
4637 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4639 size
-= CHARS_PER_LITTLENUM
;
4640 p
+= CHARS_PER_LITTLENUM
;
4641 nbytes
-= CHARS_PER_LITTLENUM
;
4644 while (nbytes
>= CHARS_PER_LITTLENUM
)
4646 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4647 nbytes
-= CHARS_PER_LITTLENUM
;
4648 p
+= CHARS_PER_LITTLENUM
;
4653 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4657 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4658 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4661 unsigned int size
= nbytes
;
4663 memset (p
, 0, size
);
4665 /* Generate a fixS to record the symbol value. */
4667 #ifdef TC_CONS_FIX_NEW
4668 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4670 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4672 reloc_howto_type
*reloc_howto
;
4674 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4675 size
= bfd_get_reloc_size (reloc_howto
);
4679 as_bad (ngettext ("%s relocations do not fit in %u byte",
4680 "%s relocations do not fit in %u bytes",
4682 reloc_howto
->name
, nbytes
);
4685 else if (target_big_endian
)
4686 offset
= nbytes
- size
;
4707 as_bad (_("unsupported BFD relocation size %u"), size
);
4710 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4715 /* Handle an MRI style string expression. */
4719 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4721 if (*input_line_pointer
!= '\''
4722 && (input_line_pointer
[1] != '\''
4723 || (*input_line_pointer
!= 'A'
4724 && *input_line_pointer
!= 'E')))
4725 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4729 unsigned int result
= 0;
4731 /* An MRI style string. Cut into as many bytes as will fit into
4732 a nbyte chunk, left justify if necessary, and separate with
4733 commas so we can try again later. */
4734 if (*input_line_pointer
== 'A')
4735 ++input_line_pointer
;
4736 else if (*input_line_pointer
== 'E')
4738 as_bad (_("EBCDIC constants are not supported"));
4739 ++input_line_pointer
;
4742 input_line_pointer
++;
4743 for (scan
= 0; scan
< nbytes
; scan
++)
4745 if (*input_line_pointer
== '\'')
4747 if (input_line_pointer
[1] == '\'')
4749 input_line_pointer
++;
4754 result
= (result
<< 8) | (*input_line_pointer
++);
4758 while (scan
< nbytes
)
4764 /* Create correct expression. */
4765 exp
->X_op
= O_constant
;
4766 exp
->X_add_number
= result
;
4768 /* Fake it so that we can read the next char too. */
4769 if (input_line_pointer
[0] != '\'' ||
4770 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4772 input_line_pointer
-= 2;
4773 input_line_pointer
[0] = ',';
4774 input_line_pointer
[1] = '\'';
4777 input_line_pointer
++;
4780 #endif /* TC_M68K */
4782 #ifdef REPEAT_CONS_EXPRESSIONS
4784 /* Parse a repeat expression for cons. This is used by the MIPS
4785 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4786 object file COUNT times.
4788 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4791 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4798 if (*input_line_pointer
!= ':')
4800 /* No repeat count. */
4804 ++input_line_pointer
;
4805 expression (&count
);
4806 if (count
.X_op
!= O_constant
4807 || count
.X_add_number
<= 0)
4809 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4813 /* The cons function is going to output this expression once. So we
4814 output it count - 1 times. */
4815 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4816 emit_expr (exp
, nbytes
);
4819 #endif /* REPEAT_CONS_EXPRESSIONS */
4821 /* Parse a floating point number represented as a hex constant. This
4822 permits users to specify the exact bits they want in the floating
4826 hex_float (int float_type
, char *bytes
)
4858 as_bad (_("unknown floating type type '%c'"), float_type
);
4862 /* It would be nice if we could go through expression to parse the
4863 hex constant, but if we get a bignum it's a pain to sort it into
4864 the buffer correctly. */
4866 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4870 /* The MRI assembler accepts arbitrary underscores strewn about
4871 through the hex constant, so we ignore them as well. */
4872 if (*input_line_pointer
== '_')
4874 ++input_line_pointer
;
4880 as_warn (_("floating point constant too large"));
4883 d
= hex_value (*input_line_pointer
) << 4;
4884 ++input_line_pointer
;
4885 while (*input_line_pointer
== '_')
4886 ++input_line_pointer
;
4887 if (hex_p (*input_line_pointer
))
4889 d
+= hex_value (*input_line_pointer
);
4890 ++input_line_pointer
;
4892 if (target_big_endian
)
4895 bytes
[length
- i
- 1] = d
;
4901 if (target_big_endian
)
4902 memset (bytes
+ i
, 0, length
- i
);
4904 memset (bytes
, 0, length
- i
);
4912 CONStruct some more frag chars of .floats .ffloats etc.
4913 Makes 0 or more new frags.
4914 If need_pass_2 == 1, no frags are emitted.
4915 This understands only floating literals, not expressions. Sorry.
4917 A floating constant is defined by atof_generic(), except it is preceded
4918 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4919 reading, I decided to be incompatible. This always tries to give you
4920 rounded bits to the precision of the pseudo-op. Former AS did premature
4921 truncation, restored noisy bits instead of trailing 0s AND gave you
4922 a choice of 2 flavours of noise according to which of 2 floating-point
4923 scanners you directed AS to use.
4925 In: input_line_pointer->whitespace before, or '0' of flonum. */
4928 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4929 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4932 int length
; /* Number of chars in an object. */
4933 const char *err
; /* Error from scanning floating literal. */
4934 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4936 if (is_it_end_of_statement ())
4938 demand_empty_rest_of_line ();
4942 if (now_seg
== absolute_section
)
4944 as_bad (_("attempt to store float in absolute section"));
4945 ignore_rest_of_line ();
4951 as_bad (_("attempt to store float in section `%s'"),
4952 segment_name (now_seg
));
4953 ignore_rest_of_line ();
4957 #ifdef md_flush_pending_output
4958 md_flush_pending_output ();
4961 #ifdef md_cons_align
4967 /* input_line_pointer->1st char of a flonum (we hope!). */
4970 /* Skip any 0{letter} that may be present. Don't even check if the
4971 letter is legal. Someone may invent a "z" format and this routine
4972 has no use for such information. Lusers beware: you get
4973 diagnostics if your input is ill-conditioned. */
4974 if (input_line_pointer
[0] == '0'
4975 && ISALPHA (input_line_pointer
[1]))
4976 input_line_pointer
+= 2;
4978 /* Accept :xxxx, where the x's are hex digits, for a floating
4979 point with the exact digits specified. */
4980 if (input_line_pointer
[0] == ':')
4982 ++input_line_pointer
;
4983 length
= hex_float (float_type
, temp
);
4986 ignore_rest_of_line ();
4992 err
= md_atof (float_type
, temp
, &length
);
4993 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4994 know (err
!= NULL
|| length
> 0);
4997 as_bad (_("bad floating literal: %s"), err
);
4998 ignore_rest_of_line ();
5009 #ifdef REPEAT_CONS_EXPRESSIONS
5010 if (*input_line_pointer
== ':')
5012 expressionS count_exp
;
5014 ++input_line_pointer
;
5015 expression (&count_exp
);
5017 if (count_exp
.X_op
!= O_constant
5018 || count_exp
.X_add_number
<= 0)
5019 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5021 count
= count_exp
.X_add_number
;
5025 while (--count
>= 0)
5027 p
= frag_more (length
);
5028 memcpy (p
, temp
, (unsigned int) length
);
5033 while (*input_line_pointer
++ == ',');
5035 /* Put terminator back into stream. */
5036 --input_line_pointer
;
5037 demand_empty_rest_of_line ();
5042 Note - we are using the DWARF standard's definition of LEB128 encoding
5043 where each 7-bit value is a stored in a byte, *not* an octet. This
5044 means that on targets where a byte contains multiple octets there is
5045 a *huge waste of space*. (This also means that we do not have to
5046 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5049 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5050 we would then have to consider whether multiple, successive LEB128
5051 values should be packed into the bytes without padding (bad idea) or
5052 whether each LEB128 number is padded out to a whole number of bytes.
5053 Plus you have to decide on the endianness of packing octets into a
5056 /* Return the size of a LEB128 value in bytes. */
5058 static inline unsigned int
5059 sizeof_sleb128 (offsetT value
)
5066 byte
= (value
& 0x7f);
5067 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5068 Fortunately, we can structure things so that the extra work reduces
5069 to a noop on systems that do things "properly". */
5070 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5073 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5074 || ((value
== -1) && ((byte
& 0x40) != 0))));
5079 static inline unsigned int
5080 sizeof_uleb128 (valueT value
)
5095 sizeof_leb128 (valueT value
, int sign
)
5098 return sizeof_sleb128 ((offsetT
) value
);
5100 return sizeof_uleb128 (value
);
5103 /* Output a LEB128 value. Returns the number of bytes used. */
5105 static inline unsigned int
5106 output_sleb128 (char *p
, offsetT value
)
5113 unsigned byte
= (value
& 0x7f);
5115 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5116 Fortunately, we can structure things so that the extra work reduces
5117 to a noop on systems that do things "properly". */
5118 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5120 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5121 || ((value
== -1) && ((byte
& 0x40) != 0))));
5132 static inline unsigned int
5133 output_uleb128 (char *p
, valueT value
)
5139 unsigned byte
= (value
& 0x7f);
5143 /* More bytes to follow. */
5154 output_leb128 (char *p
, valueT value
, int sign
)
5157 return output_sleb128 (p
, (offsetT
) value
);
5159 return output_uleb128 (p
, value
);
5162 /* Do the same for bignums. We combine sizeof with output here in that
5163 we don't output for NULL values of P. It isn't really as critical as
5164 for "normal" values that this be streamlined. Returns the number of
5167 static inline unsigned int
5168 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5175 /* Strip leading sign extensions off the bignum. */
5177 && bignum
[size
- 1] == LITTLENUM_MASK
5178 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5183 /* OR in the next part of the littlenum. */
5184 val
|= (*bignum
<< loaded
);
5185 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5189 /* Add bytes until there are less than 7 bits left in VAL
5190 or until every non-sign bit has been written. */
5197 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5204 while ((byte
& 0x80) != 0 && loaded
>= 7);
5208 /* Mop up any left-over bits (of which there will be less than 7). */
5209 if ((byte
& 0x80) != 0)
5211 /* Sign-extend VAL. */
5212 if (val
& (1 << (loaded
- 1)))
5213 val
|= ~0U << loaded
;
5222 static inline unsigned int
5223 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5230 /* Strip leading zeros off the bignum. */
5231 /* XXX: Is this needed? */
5232 while (size
> 0 && bignum
[size
- 1] == 0)
5237 if (loaded
< 7 && size
> 0)
5239 val
|= (*bignum
<< loaded
);
5240 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5249 if (size
> 0 || val
)
5256 while (byte
& 0x80);
5262 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5265 return output_big_sleb128 (p
, bignum
, size
);
5267 return output_big_uleb128 (p
, bignum
, size
);
5270 /* Generate the appropriate fragments for a given expression to emit a
5271 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5274 emit_leb128_expr (expressionS
*exp
, int sign
)
5276 operatorT op
= exp
->X_op
;
5277 unsigned int nbytes
;
5279 if (op
== O_absent
|| op
== O_illegal
)
5281 as_warn (_("zero assumed for missing expression"));
5282 exp
->X_add_number
= 0;
5285 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5287 as_bad (_("floating point number invalid"));
5288 exp
->X_add_number
= 0;
5291 else if (op
== O_register
)
5293 as_warn (_("register value used as expression"));
5296 else if (op
== O_constant
5298 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5300 /* We're outputting a signed leb128 and the sign of X_add_number
5301 doesn't reflect the sign of the original value. Convert EXP
5302 to a correctly-extended bignum instead. */
5303 convert_to_bignum (exp
, exp
->X_extrabit
);
5307 if (now_seg
== absolute_section
)
5309 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5310 as_bad (_("attempt to store value in absolute section"));
5311 abs_section_offset
++;
5315 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5316 as_bad (_("attempt to store non-zero value in section `%s'"),
5317 segment_name (now_seg
));
5319 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5320 a signal that this is leb128 data. It shouldn't optimize this away. */
5321 nbytes
= (unsigned int) -1;
5322 if (check_eh_frame (exp
, &nbytes
))
5325 /* Let the backend know that subsequent data may be byte aligned. */
5326 #ifdef md_cons_align
5330 if (op
== O_constant
)
5332 /* If we've got a constant, emit the thing directly right now. */
5334 valueT value
= exp
->X_add_number
;
5338 size
= sizeof_leb128 (value
, sign
);
5339 p
= frag_more (size
);
5340 if (output_leb128 (p
, value
, sign
) > size
)
5343 else if (op
== O_big
)
5345 /* O_big is a different sort of constant. */
5346 int nbr_digits
= exp
->X_add_number
;
5350 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5351 a signed number. Unary operators like - or ~ always extend the
5352 bignum to its largest size. */
5354 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5355 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5356 generic_bignum
[nbr_digits
++] = 0;
5358 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5359 p
= frag_more (size
);
5360 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5365 /* Otherwise, we have to create a variable sized fragment and
5366 resolve things later. */
5368 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5369 make_expr_symbol (exp
), 0, (char *) NULL
);
5373 /* Parse the .sleb128 and .uleb128 pseudos. */
5380 #ifdef md_flush_pending_output
5381 md_flush_pending_output ();
5387 emit_leb128_expr (&exp
, sign
);
5389 while (*input_line_pointer
++ == ',');
5391 input_line_pointer
--;
5392 demand_empty_rest_of_line ();
5396 stringer_append_char (int c
, int bitsize
)
5399 as_bad (_("attempt to store non-empty string in section `%s'"),
5400 segment_name (now_seg
));
5402 if (!target_big_endian
)
5403 FRAG_APPEND_1_CHAR (c
);
5408 FRAG_APPEND_1_CHAR (0);
5409 FRAG_APPEND_1_CHAR (0);
5410 FRAG_APPEND_1_CHAR (0);
5411 FRAG_APPEND_1_CHAR (0);
5414 FRAG_APPEND_1_CHAR (0);
5415 FRAG_APPEND_1_CHAR (0);
5418 FRAG_APPEND_1_CHAR (0);
5423 /* Called with invalid bitsize argument. */
5427 if (target_big_endian
)
5428 FRAG_APPEND_1_CHAR (c
);
5431 /* Worker to do .ascii etc statements.
5432 Reads 0 or more ',' separated, double-quoted strings.
5433 Caller should have checked need_pass_2 is FALSE because we don't
5435 Checks for end-of-line.
5436 BITS_APPENDZERO says how many bits are in a target char.
5437 The bottom bit is set if a NUL char should be appended to the strings. */
5440 stringer (int bits_appendzero
)
5442 const int bitsize
= bits_appendzero
& ~7;
5443 const int append_zero
= bits_appendzero
& 1;
5445 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5449 #ifdef md_flush_pending_output
5450 md_flush_pending_output ();
5453 #ifdef md_cons_align
5457 /* If we have been switched into the abs_section then we
5458 will not have an obstack onto which we can hang strings. */
5459 if (now_seg
== absolute_section
)
5461 as_bad (_("strings must be placed into a section"));
5462 ignore_rest_of_line ();
5466 /* The following awkward logic is to parse ZERO or more strings,
5467 comma separated. Recall a string expression includes spaces
5468 before the opening '\"' and spaces after the closing '\"'.
5469 We fake a leading ',' if there is (supposed to be)
5470 a 1st, expression. We keep demanding expressions for each ','. */
5471 if (is_it_end_of_statement ())
5473 c
= 0; /* Skip loop. */
5474 ++input_line_pointer
; /* Compensate for end of loop. */
5478 c
= ','; /* Do loop. */
5481 while (c
== ',' || c
== '<' || c
== '"')
5484 switch (*input_line_pointer
)
5487 ++input_line_pointer
; /*->1st char of string. */
5488 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5489 start
= input_line_pointer
;
5492 while (is_a_char (c
= next_char_of_string ()))
5493 stringer_append_char (c
, bitsize
);
5495 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5496 SKIP_ALL_WHITESPACE ();
5497 if (*input_line_pointer
== '"')
5501 stringer_append_char (0, bitsize
);
5503 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5504 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5505 will emit .string with a filename in the .debug section
5506 after a sequence of constants. See the comment in
5507 emit_expr for the sequence. emit_expr will set
5508 dwarf_file_string to non-zero if this string might be a
5509 source file name. */
5510 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5511 dwarf_file_string
= 0;
5512 else if (dwarf_file_string
)
5514 c
= input_line_pointer
[-1];
5515 input_line_pointer
[-1] = '\0';
5516 listing_source_file (start
);
5517 input_line_pointer
[-1] = c
;
5523 input_line_pointer
++;
5524 c
= get_single_number ();
5525 stringer_append_char (c
, bitsize
);
5526 if (*input_line_pointer
!= '>')
5528 as_bad (_("expected <nn>"));
5529 ignore_rest_of_line ();
5532 input_line_pointer
++;
5535 input_line_pointer
++;
5539 c
= *input_line_pointer
;
5542 demand_empty_rest_of_line ();
5545 /* FIXME-SOMEDAY: I had trouble here on characters with the
5546 high bits set. We'll probably also have trouble with
5547 multibyte chars, wide chars, etc. Also be careful about
5548 returning values bigger than 1 byte. xoxorich. */
5551 next_char_of_string (void)
5555 c
= *input_line_pointer
++ & CHAR_MASK
;
5559 /* PR 20902: Do not advance past the end of the buffer. */
5560 -- input_line_pointer
;
5569 as_warn (_("unterminated string; newline inserted"));
5570 bump_line_counters ();
5574 if (!TC_STRING_ESCAPES
)
5576 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5604 break; /* As itself. */
5620 for (i
= 0, number
= 0;
5621 ISDIGIT (c
) && i
< 3;
5622 c
= *input_line_pointer
++, i
++)
5624 number
= number
* 8 + c
- '0';
5627 c
= number
& CHAR_MASK
;
5629 --input_line_pointer
;
5638 c
= *input_line_pointer
++;
5639 while (ISXDIGIT (c
))
5642 number
= number
* 16 + c
- '0';
5643 else if (ISUPPER (c
))
5644 number
= number
* 16 + c
- 'A' + 10;
5646 number
= number
* 16 + c
- 'a' + 10;
5647 c
= *input_line_pointer
++;
5649 c
= number
& CHAR_MASK
;
5650 --input_line_pointer
;
5655 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5656 as_warn (_("unterminated string; newline inserted"));
5658 bump_line_counters ();
5662 /* Do not advance past the end of the buffer. */
5663 -- input_line_pointer
;
5669 #ifdef ONLY_STANDARD_ESCAPES
5670 as_bad (_("bad escaped character in string"));
5672 #endif /* ONLY_STANDARD_ESCAPES */
5685 get_segmented_expression (expressionS
*expP
)
5689 retval
= expression (expP
);
5690 if (expP
->X_op
== O_illegal
5691 || expP
->X_op
== O_absent
5692 || expP
->X_op
== O_big
)
5694 as_bad (_("expected address expression"));
5695 expP
->X_op
= O_constant
;
5696 expP
->X_add_number
= 0;
5697 retval
= absolute_section
;
5703 get_known_segmented_expression (expressionS
*expP
)
5705 segT retval
= get_segmented_expression (expP
);
5707 if (retval
== undefined_section
)
5709 /* There is no easy way to extract the undefined symbol from the
5711 if (expP
->X_add_symbol
!= NULL
5712 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5713 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5714 S_GET_NAME (expP
->X_add_symbol
));
5716 as_warn (_("some symbol undefined; zero assumed"));
5717 retval
= absolute_section
;
5718 expP
->X_op
= O_constant
;
5719 expP
->X_add_number
= 0;
5724 char /* Return terminator. */
5725 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5727 /* FIXME: val_pointer should probably be offsetT *. */
5728 *val_pointer
= (long) get_absolute_expression ();
5729 return (*input_line_pointer
++);
5732 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5733 Give a warning if that happens. */
5736 demand_copy_C_string (int *len_pointer
)
5740 if ((s
= demand_copy_string (len_pointer
)) != 0)
5744 for (len
= *len_pointer
; len
> 0; len
--)
5746 if (s
[len
- 1] == 0)
5750 as_bad (_("this string may not contain \'\\0\'"));
5759 /* Demand string, but return a safe (=private) copy of the string.
5760 Return NULL if we can't read a string here. */
5763 demand_copy_string (int *lenP
)
5771 if (*input_line_pointer
== '\"')
5773 input_line_pointer
++; /* Skip opening quote. */
5775 while (is_a_char (c
= next_char_of_string ()))
5777 obstack_1grow (¬es
, c
);
5780 /* JF this next line is so demand_copy_C_string will return a
5781 null terminated string. */
5782 obstack_1grow (¬es
, '\0');
5783 retval
= (char *) obstack_finish (¬es
);
5787 as_bad (_("missing string"));
5789 ignore_rest_of_line ();
5795 /* In: Input_line_pointer->next character.
5797 Do: Skip input_line_pointer over all whitespace.
5799 Out: 1 if input_line_pointer->end-of-line. */
5802 is_it_end_of_statement (void)
5805 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5809 equals (char *sym_name
, int reassign
)
5814 input_line_pointer
++;
5815 if (*input_line_pointer
== '=')
5816 input_line_pointer
++;
5817 if (reassign
< 0 && *input_line_pointer
== '=')
5818 input_line_pointer
++;
5820 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5821 input_line_pointer
++;
5824 stop
= mri_comment_field (&stopc
);
5826 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5830 demand_empty_rest_of_line ();
5831 mri_comment_end (stop
, stopc
);
5835 /* .incbin -- include a file verbatim at the current location. */
5838 s_incbin (int x ATTRIBUTE_UNUSED
)
5849 #ifdef md_flush_pending_output
5850 md_flush_pending_output ();
5853 #ifdef md_cons_align
5858 filename
= demand_copy_string (& len
);
5859 if (filename
== NULL
)
5864 /* Look for optional skip and count. */
5865 if (* input_line_pointer
== ',')
5867 ++ input_line_pointer
;
5868 skip
= get_absolute_expression ();
5872 if (* input_line_pointer
== ',')
5874 ++ input_line_pointer
;
5876 count
= get_absolute_expression ();
5878 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5884 demand_empty_rest_of_line ();
5886 /* Try opening absolute path first, then try include dirs. */
5887 binfile
= fopen (filename
, FOPEN_RB
);
5888 if (binfile
== NULL
)
5892 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5894 for (i
= 0; i
< include_dir_count
; i
++)
5896 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5898 binfile
= fopen (path
, FOPEN_RB
);
5899 if (binfile
!= NULL
)
5903 if (binfile
== NULL
)
5904 as_bad (_("file not found: %s"), filename
);
5907 path
= xstrdup (filename
);
5912 struct stat filestat
;
5914 if (fstat (fileno (binfile
), &filestat
) != 0
5915 || ! S_ISREG (filestat
.st_mode
)
5916 || S_ISDIR (filestat
.st_mode
))
5918 as_bad (_("unable to include `%s'"), path
);
5922 register_dependency (path
);
5924 /* Compute the length of the file. */
5925 if (fseek (binfile
, 0, SEEK_END
) != 0)
5927 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5930 file_len
= ftell (binfile
);
5932 /* If a count was not specified use the remainder of the file. */
5934 count
= file_len
- skip
;
5936 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5938 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5939 skip
, count
, file_len
);
5943 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5945 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5949 /* Allocate frag space and store file contents in it. */
5950 binfrag
= frag_more (count
);
5952 bytes
= fread (binfrag
, 1, count
, binfile
);
5954 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5955 path
, bytes
, count
);
5958 if (binfile
!= NULL
)
5963 /* .include -- include a file at this point. */
5966 s_include (int arg ATTRIBUTE_UNUSED
)
5975 filename
= demand_copy_string (&i
);
5976 if (filename
== NULL
)
5978 /* demand_copy_string has already printed an error and
5979 called ignore_rest_of_line. */
5987 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5988 && *input_line_pointer
!= ' '
5989 && *input_line_pointer
!= '\t')
5991 obstack_1grow (¬es
, *input_line_pointer
);
5992 ++input_line_pointer
;
5996 obstack_1grow (¬es
, '\0');
5997 filename
= (char *) obstack_finish (¬es
);
5998 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5999 ++input_line_pointer
;
6002 demand_empty_rest_of_line ();
6003 path
= XNEWVEC (char, (unsigned long) i
6004 + include_dir_maxlen
+ 5 /* slop */ );
6006 for (i
= 0; i
< include_dir_count
; i
++)
6008 strcpy (path
, include_dirs
[i
]);
6010 strcat (path
, filename
);
6011 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
6021 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
6022 register_dependency (path
);
6023 input_scrub_insert_file (path
);
6027 add_include_dir (char *path
)
6031 if (include_dir_count
== 0)
6033 include_dirs
= XNEWVEC (const char *, 2);
6034 include_dirs
[0] = "."; /* Current dir. */
6035 include_dir_count
= 2;
6039 include_dir_count
++;
6040 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6044 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6047 if (i
> include_dir_maxlen
)
6048 include_dir_maxlen
= i
;
6051 /* Output debugging information to denote the source file. */
6054 generate_file_debug (void)
6056 if (debug_type
== DEBUG_STABS
)
6057 stabs_generate_asm_file ();
6060 /* Output line number debugging information for the current source line. */
6063 generate_lineno_debug (void)
6067 case DEBUG_UNSPECIFIED
:
6072 stabs_generate_asm_lineno ();
6075 ecoff_generate_asm_lineno ();
6078 /* ??? We could here indicate to dwarf2dbg.c that something
6079 has changed. However, since there is additional backend
6080 support that is required (calling dwarf2_emit_insn), we
6081 let dwarf2dbg.c call as_where on its own. */
6086 /* Output debugging information to mark a function entry point or end point.
6087 END_P is zero for .func, and non-zero for .endfunc. */
6092 do_s_func (end_p
, NULL
);
6095 /* Subroutine of s_func so targets can choose a different default prefix.
6096 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6099 do_s_func (int end_p
, const char *default_prefix
)
6101 /* Record the current function so that we can issue an error message for
6102 misplaced .func,.endfunc, and also so that .endfunc needs no
6104 static char *current_name
;
6105 static char *current_label
;
6109 if (current_name
== NULL
)
6111 as_bad (_("missing .func"));
6112 ignore_rest_of_line ();
6116 if (debug_type
== DEBUG_STABS
)
6117 stabs_generate_asm_endfunc (current_name
, current_label
);
6119 current_name
= current_label
= NULL
;
6124 char delim1
, delim2
;
6126 if (current_name
!= NULL
)
6128 as_bad (_(".endfunc missing for previous .func"));
6129 ignore_rest_of_line ();
6133 delim1
= get_symbol_name (& name
);
6134 name
= xstrdup (name
);
6135 *input_line_pointer
= delim1
;
6136 SKIP_WHITESPACE_AFTER_NAME ();
6137 if (*input_line_pointer
!= ',')
6141 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6142 as_fatal ("%s", xstrerror (errno
));
6146 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6147 /* Missing entry point, use function's name with the leading
6151 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6152 as_fatal ("%s", xstrerror (errno
));
6160 ++input_line_pointer
;
6162 delim2
= get_symbol_name (& label
);
6163 label
= xstrdup (label
);
6164 restore_line_pointer (delim2
);
6167 if (debug_type
== DEBUG_STABS
)
6168 stabs_generate_asm_func (name
, label
);
6170 current_name
= name
;
6171 current_label
= label
;
6174 demand_empty_rest_of_line ();
6177 #ifdef HANDLE_BUNDLE
6180 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6182 unsigned int align
= get_absolute_expression ();
6184 demand_empty_rest_of_line ();
6186 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6187 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6188 (unsigned int) TC_ALIGN_LIMIT
);
6190 if (bundle_lock_frag
!= NULL
)
6192 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6196 bundle_align_p2
= align
;
6200 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6202 demand_empty_rest_of_line ();
6204 if (bundle_align_p2
== 0)
6206 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6210 if (bundle_lock_depth
== 0)
6212 bundle_lock_frchain
= frchain_now
;
6213 bundle_lock_frag
= start_bundle ();
6215 ++bundle_lock_depth
;
6219 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6223 demand_empty_rest_of_line ();
6225 if (bundle_lock_frag
== NULL
)
6227 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6231 gas_assert (bundle_align_p2
> 0);
6233 gas_assert (bundle_lock_depth
> 0);
6234 if (--bundle_lock_depth
> 0)
6237 size
= pending_bundle_size (bundle_lock_frag
);
6239 if (size
> 1U << bundle_align_p2
)
6240 as_bad (_(".bundle_lock sequence is %u bytes, "
6241 "but bundle size is only %u bytes"),
6242 size
, 1u << bundle_align_p2
);
6244 finish_bundle (bundle_lock_frag
, size
);
6246 bundle_lock_frag
= NULL
;
6247 bundle_lock_frchain
= NULL
;
6250 #endif /* HANDLE_BUNDLE */
6253 s_ignore (int arg ATTRIBUTE_UNUSED
)
6255 ignore_rest_of_line ();
6259 read_print_statistics (FILE *file
)
6261 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6264 /* Inserts the given line into the input stream.
6266 This call avoids macro/conditionals nesting checking, since the contents of
6267 the line are assumed to replace the contents of a line already scanned.
6269 An appropriate use of this function would be substitution of input lines when
6270 called by md_start_line_hook(). The given line is assumed to already be
6271 properly scrubbed. */
6274 input_scrub_insert_line (const char *line
)
6277 size_t len
= strlen (line
);
6278 sb_build (&newline
, len
);
6279 sb_add_buffer (&newline
, line
, len
);
6280 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6282 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6285 /* Insert a file into the input stream; the path must resolve to an actual
6286 file; no include path searching or dependency registering is performed. */
6289 input_scrub_insert_file (char *path
)
6291 input_scrub_include_file (path
, input_line_pointer
);
6292 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6295 /* Find the end of a line, considering quotation and escaping of quotes. */
6297 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6298 # define TC_SINGLE_QUOTE_STRINGS 1
6302 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6305 char inquote
= '\0';
6308 while (!is_end_of_line
[(unsigned char) *s
]
6309 || (inquote
&& !ISCNTRL (*s
))
6310 || (inquote
== '\'' && flag_mri
)
6311 #ifdef TC_EOL_IN_INSN
6312 || (insn
&& TC_EOL_IN_INSN (s
))
6314 /* PR 6926: When we are parsing the body of a macro the sequence
6315 \@ is special - it refers to the invocation count. If the @
6316 character happens to be registered as a line-separator character
6317 by the target, then the is_end_of_line[] test above will have
6318 returned true, but we need to ignore the line separating
6319 semantics in this particular case. */
6320 || (in_macro
&& inescape
&& *s
== '@')
6323 if (mri_string
&& *s
== '\'')
6327 else if (*s
== '\\')
6331 #ifdef TC_SINGLE_QUOTE_STRINGS
6332 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6339 as_warn (_("missing closing `%c'"), inquote
);
6340 if (inescape
&& !ignore_input ())
6341 as_warn (_("stray `\\'"));
6346 find_end_of_line (char *s
, int mri_string
)
6348 return _find_end_of_line (s
, mri_string
, 0, 0);
6351 static char *saved_ilp
= NULL
;
6352 static char *saved_limit
;
6354 /* Use BUF as a temporary input pointer for calling other functions in this
6355 file. BUF must be a C string, so that its end can be found by strlen.
6356 Also sets the buffer_limit variable (local to this file) so that buffer
6357 overruns should not occur. Saves the current input line pointer so that
6358 it can be restored by calling restore_ilp().
6360 Does not support recursion. */
6363 temp_ilp (char *buf
)
6365 gas_assert (saved_ilp
== NULL
);
6366 gas_assert (buf
!= NULL
);
6368 saved_ilp
= input_line_pointer
;
6369 saved_limit
= buffer_limit
;
6370 /* Prevent the assert in restore_ilp from triggering if
6371 the input_line_pointer has not yet been initialised. */
6372 if (saved_ilp
== NULL
)
6373 saved_limit
= saved_ilp
= (char *) "";
6375 input_line_pointer
= buf
;
6376 buffer_limit
= buf
+ strlen (buf
);
6377 input_from_string
= TRUE
;
6380 /* Restore a saved input line pointer. */
6385 gas_assert (saved_ilp
!= NULL
);
6387 input_line_pointer
= saved_ilp
;
6388 buffer_limit
= saved_limit
;
6389 input_from_string
= FALSE
;