1 /* read.c - read a source file -
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer
; /*->next char of source file to parse. */
67 bfd_boolean input_from_string
= FALSE
;
69 #if BITS_PER_CHAR != 8
70 /* The following table is indexed by[(char)] and will break if
71 a char does not have exactly 256 states (hopefully 0:255!)! */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The Delta 68k assembler permits ~ at start of label names. */
109 /* Used by is_... macros. our ctype[]. */
110 char lex_type
[256] = {
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
113 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
115 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
117 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
130 Out: 1 if this character ends a line.
131 2 if this character is a line separator. */
132 char is_end_of_line
[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string
[128];
159 /* Functions private to this file. */
161 static char *buffer
; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit
; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
172 const char **include_dirs
;
174 /* How many are in the table. */
175 int include_dir_count
;
177 /* Length of longest in table. */
178 int include_dir_maxlen
= 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string
;
214 /* If the target defines the md_frag_max_var hook then we know
215 enough to implement the .bundle_align_mode features. */
216 #ifdef md_frag_max_var
217 # define HANDLE_BUNDLE
221 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
222 it's the exponent of the bundle size, and aligned instruction bundle
223 mode is in effect. */
224 static unsigned int bundle_align_p2
;
226 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
227 bundle_lock_frag to frag_now and then starts a new frag with
228 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
229 so that .bundle_unlock can verify that we didn't change segments.
230 .bundle_unlock resets both to NULL. If we detect a bundling violation,
231 then we reset bundle_lock_frchain to NULL as an indicator that we've
232 already diagnosed the error with as_bad and don't need a cascade of
233 redundant errors, but bundle_lock_frag remains set to indicate that
234 we are expecting to see .bundle_unlock. */
235 static fragS
*bundle_lock_frag
;
236 static frchainS
*bundle_lock_frchain
;
238 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
240 static unsigned int bundle_lock_depth
;
243 static void do_s_func (int end_p
, const char *default_prefix
);
244 static void s_align (int, int);
245 static void s_altmacro (int);
246 static void s_bad_end (int);
247 static void s_reloc (int);
248 static int hex_float (int, char *);
249 static segT
get_known_segmented_expression (expressionS
* expP
);
250 static void pobegin (void);
251 static size_t get_non_macro_line_sb (sb
*);
252 static void generate_file_debug (void);
253 static char *_find_end_of_line (char *, int, int, int);
261 obj_read_begin_hook ();
263 /* Something close -- but not too close -- to a multiple of 1024.
264 The debugging malloc I'm using has 24 bytes of overhead. */
265 obstack_begin (¬es
, chunksize
);
266 obstack_begin (&cond_obstack
, chunksize
);
268 #ifndef tc_line_separator_chars
269 #define tc_line_separator_chars line_separator_chars
271 /* Use machine dependent syntax. */
272 for (p
= tc_line_separator_chars
; *p
; p
++)
273 is_end_of_line
[(unsigned char) *p
] = 2;
274 /* Use more. FIXME-SOMEDAY. */
280 #ifndef TC_ADDRESS_BYTES
281 #define TC_ADDRESS_BYTES address_bytes
286 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
287 contain an address. */
288 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
296 /* Set up pseudo-op tables. */
300 const char *poc_name
;
302 const pseudo_typeS
*pop
;
305 typedef struct po_entry po_entry_t
;
307 /* Hash function for a po_entry. */
310 hash_po_entry (const void *e
)
312 const po_entry_t
*entry
= (const po_entry_t
*) e
;
313 return htab_hash_string (entry
->poc_name
);
316 /* Equality function for a po_entry. */
319 eq_po_entry (const void *a
, const void *b
)
321 const po_entry_t
*ea
= (const po_entry_t
*) a
;
322 const po_entry_t
*eb
= (const po_entry_t
*) b
;
324 return strcmp (ea
->poc_name
, eb
->poc_name
) == 0;
328 po_entry_alloc (const char *poc_name
, const pseudo_typeS
*pop
)
330 po_entry_t
*entry
= XNEW (po_entry_t
);
331 entry
->poc_name
= poc_name
;
336 static const pseudo_typeS
*
337 po_entry_find (htab_t table
, const char *poc_name
)
339 po_entry_t needle
= { poc_name
, NULL
};
340 po_entry_t
*entry
= htab_find (table
, &needle
);
341 return entry
!= NULL
? entry
->pop
: NULL
;
344 static struct htab
*po_hash
;
346 static const pseudo_typeS potable
[] = {
347 {"abort", s_abort
, 0},
348 {"align", s_align_ptwo
, 0},
349 {"altmacro", s_altmacro
, 1},
350 {"ascii", stringer
, 8+0},
351 {"asciz", stringer
, 8+1},
352 {"balign", s_align_bytes
, 0},
353 {"balignw", s_align_bytes
, -2},
354 {"balignl", s_align_bytes
, -4},
357 {"bundle_align_mode", s_bundle_align_mode
, 0},
358 {"bundle_lock", s_bundle_lock
, 0},
359 {"bundle_unlock", s_bundle_unlock
, 0},
363 {"common", s_mri_common
, 0},
364 {"common.s", s_mri_common
, 1},
367 #ifdef TC_ADDRESS_BYTES
371 {"dc.d", float_cons
, 'd'},
373 {"dc.s", float_cons
, 'f'},
375 {"dc.x", float_cons
, 'x'},
377 {"dcb.b", s_space
, 1},
378 {"dcb.d", s_float_space
, 'd'},
379 {"dcb.l", s_space
, 4},
380 {"dcb.s", s_float_space
, 'f'},
381 {"dcb.w", s_space
, 2},
382 {"dcb.x", s_float_space
, 'x'},
384 {"ds.b", s_space
, 1},
385 {"ds.d", s_space
, 8},
386 {"ds.l", s_space
, 4},
387 {"ds.p", s_space
, 12},
388 {"ds.s", s_space
, 4},
389 {"ds.w", s_space
, 2},
390 {"ds.x", s_space
, 12},
391 {"debug", s_ignore
, 0},
396 {"double", float_cons
, 'd'},
398 {"eject", listing_eject
, 0}, /* Formfeed listing. */
400 {"elsec", s_else
, 0},
401 {"elseif", s_elseif
, (int) O_ne
},
403 {"endc", s_endif
, 0},
404 {"endfunc", s_func
, 1},
405 {"endif", s_endif
, 0},
406 {"endm", s_bad_end
, 0},
407 {"endr", s_bad_end
, 1},
413 {"error", s_errwarn
, 1},
414 {"exitm", s_mexit
, 0},
416 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
417 {"appfile", s_app_file
, 1},
418 {"appline", s_app_line
, 1},
420 {"file", s_app_file
, 0},
422 {"float", float_cons
, 'f'},
423 {"format", s_ignore
, 0},
425 {"global", s_globl
, 0},
426 {"globl", s_globl
, 0},
428 {"if", s_if
, (int) O_ne
},
431 {"ifdef", s_ifdef
, 0},
432 {"ifeq", s_if
, (int) O_eq
},
433 {"ifeqs", s_ifeqs
, 0},
434 {"ifge", s_if
, (int) O_ge
},
435 {"ifgt", s_if
, (int) O_gt
},
436 {"ifle", s_if
, (int) O_le
},
437 {"iflt", s_if
, (int) O_lt
},
440 {"ifndef", s_ifdef
, 1},
441 {"ifne", s_if
, (int) O_ne
},
442 {"ifnes", s_ifeqs
, 1},
443 {"ifnotdef", s_ifdef
, 1},
444 {"incbin", s_incbin
, 0},
445 {"include", s_include
, 0},
451 {"lcomm", s_lcomm
, 0},
452 {"lflags", s_ignore
, 0}, /* Listing flags. */
453 {"linefile", s_app_line
, 0},
454 {"linkonce", s_linkonce
, 0},
455 {"list", listing_list
, 1}, /* Turn listing on. */
456 {"llen", listing_psize
, 1},
459 {"macro", s_macro
, 0},
460 {"mexit", s_mexit
, 0},
462 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
463 {"name", s_ignore
, 0},
464 {"noaltmacro", s_altmacro
, 0},
465 {"noformat", s_ignore
, 0},
466 {"nolist", listing_list
, 0}, /* Turn listing off. */
467 {"nopage", listing_nopage
, 0},
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},
533 {NULL
, NULL
, 0} /* End sentinel. */
537 get_absolute_expr (expressionS
*exp
)
539 expression_and_evaluate (exp
);
541 if (exp
->X_op
!= O_constant
)
543 if (exp
->X_op
!= O_absent
)
544 as_bad (_("bad or irreducible absolute expression"));
545 exp
->X_add_number
= 0;
547 return exp
->X_add_number
;
551 get_absolute_expression (void)
555 return get_absolute_expr (&exp
);
558 static int pop_override_ok
= 0;
559 static const char *pop_table_name
;
562 pop_insert (const pseudo_typeS
*table
)
564 const pseudo_typeS
*pop
;
565 for (pop
= table
; pop
->poc_name
; pop
++)
567 po_entry_t
*elt
= po_entry_alloc (pop
->poc_name
, pop
);
568 if (htab_insert (po_hash
, elt
, 0) != NULL
)
571 if (!pop_override_ok
)
572 as_fatal (_("error constructing %s pseudo-op table"),
578 #ifndef md_pop_insert
579 #define md_pop_insert() pop_insert(md_pseudo_table)
582 #ifndef obj_pop_insert
583 #define obj_pop_insert() pop_insert(obj_pseudo_table)
586 #ifndef cfi_pop_insert
587 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
593 po_hash
= htab_create_alloc (16, hash_po_entry
, eq_po_entry
, NULL
,
596 /* Do the target-specific pseudo ops. */
597 pop_table_name
= "md";
600 /* Now object specific. Skip any that were in the target table. */
601 pop_table_name
= "obj";
605 /* Now portable ones. Skip any that we've seen already. */
606 pop_table_name
= "standard";
607 pop_insert (potable
);
610 pop_table_name
= "cfi";
615 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
616 if (ignore_input ()) \
618 char *eol = find_end_of_line (input_line_pointer - (num_read), \
620 input_line_pointer = (input_line_pointer <= buffer_limit \
621 && eol >= buffer_limit) \
627 /* This function is used when scrubbing the characters between #APP
630 static char *scrub_string
;
631 static char *scrub_string_end
;
634 scrub_from_string (char *buf
, size_t buflen
)
638 copy
= scrub_string_end
- scrub_string
;
641 memcpy (buf
, scrub_string
, copy
);
642 scrub_string
+= copy
;
646 /* Helper function of read_a_source_file, which tries to expand a macro. */
648 try_macro (char term
, const char *line
)
654 if (check_macro (line
, &out
, &err
, ¯o
))
658 *input_line_pointer
++ = term
;
659 input_scrub_include_sb (&out
,
660 input_line_pointer
, 1);
663 input_scrub_next_buffer (&input_line_pointer
);
665 md_macro_info (macro
);
673 /* Start a new instruction bundle. Returns the rs_align_code frag that
674 will be used to align the new bundle. */
678 fragS
*frag
= frag_now
;
680 frag_align_code (0, 0);
682 while (frag
->fr_type
!= rs_align_code
)
683 frag
= frag
->fr_next
;
685 gas_assert (frag
!= frag_now
);
690 /* Calculate the maximum size after relaxation of the region starting
691 at the given frag and extending through frag_now (which is unfinished). */
693 pending_bundle_size (fragS
*frag
)
695 unsigned int offset
= frag
->fr_fix
;
696 unsigned int size
= 0;
698 gas_assert (frag
!= frag_now
);
699 gas_assert (frag
->fr_type
== rs_align_code
);
701 while (frag
!= frag_now
)
703 /* This should only happen in what will later become an error case. */
707 size
+= frag
->fr_fix
;
708 if (frag
->fr_type
== rs_machine_dependent
)
709 size
+= md_frag_max_var (frag
);
711 frag
= frag
->fr_next
;
714 gas_assert (frag
== frag_now
);
715 size
+= frag_now_fix ();
716 if (frag
->fr_type
== rs_machine_dependent
)
717 size
+= md_frag_max_var (frag
);
719 gas_assert (size
>= offset
);
721 return size
- offset
;
724 /* Finish off the frag created to ensure bundle alignment. */
726 finish_bundle (fragS
*frag
, unsigned int size
)
728 gas_assert (bundle_align_p2
> 0);
729 gas_assert (frag
->fr_type
== rs_align_code
);
733 /* If there is more than a single byte, then we need to set up the
734 alignment frag. Otherwise we leave it at its initial state from
735 calling frag_align_code (0, 0), so that it does nothing. */
736 frag
->fr_offset
= bundle_align_p2
;
737 frag
->fr_subtype
= size
- 1;
740 /* We do this every time rather than just in s_bundle_align_mode
741 so that we catch any affected section without needing hooks all
742 over for all paths that do section changes. It's cheap enough. */
743 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
744 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
747 /* Assemble one instruction. This takes care of the bundle features
748 around calling md_assemble. */
750 assemble_one (char *line
)
752 fragS
*insn_start_frag
= NULL
;
754 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
756 as_bad (_("cannot change section or subsection inside .bundle_lock"));
757 /* Clearing this serves as a marker that we have already complained. */
758 bundle_lock_frchain
= NULL
;
761 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
762 insn_start_frag
= start_bundle ();
766 if (bundle_lock_frchain
!= NULL
)
768 /* Make sure this hasn't pushed the locked sequence
769 past the bundle size. */
770 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
771 if (bundle_size
> 1U << bundle_align_p2
)
772 as_bad (_ (".bundle_lock sequence at %u bytes, "
773 "but .bundle_align_mode limit is %u bytes"),
774 bundle_size
, 1U << bundle_align_p2
);
776 else if (bundle_align_p2
> 0)
778 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
780 if (insn_size
> 1U << bundle_align_p2
)
781 as_bad (_("single instruction is %u bytes long, "
782 "but .bundle_align_mode limit is %u bytes"),
783 insn_size
, 1U << bundle_align_p2
);
785 finish_bundle (insn_start_frag
, insn_size
);
789 #else /* !HANDLE_BUNDLE */
791 # define assemble_one(line) md_assemble(line)
793 #endif /* HANDLE_BUNDLE */
798 flagword flags
= bfd_section_flags (now_seg
);
800 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
803 /* Guts of .align directive:
804 N is the power of two to which to align. A value of zero is accepted but
805 ignored: the default alignment of the section will be at least this.
806 FILL may be NULL, or it may point to the bytes of the fill pattern.
807 LEN is the length of whatever FILL points to, if anything. If LEN is zero
808 but FILL is not NULL then LEN is treated as if it were one.
809 MAX is the maximum number of characters to skip when doing the alignment,
810 or 0 if there is no maximum. */
813 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
815 if (now_seg
== absolute_section
|| in_bss ())
821 if (now_seg
== absolute_section
)
822 as_warn (_("ignoring fill value in absolute section"));
824 as_warn (_("ignoring fill value in section `%s'"),
825 segment_name (now_seg
));
832 #ifdef md_flush_pending_output
833 md_flush_pending_output ();
837 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
840 /* Only make a frag if we HAVE to... */
841 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
845 if (subseg_text_p (now_seg
))
846 frag_align_code (n
, max
);
848 frag_align (n
, 0, max
);
851 frag_align (n
, *fill
, max
);
853 frag_align_pattern (n
, fill
, len
, max
);
857 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
860 if (n
> OCTETS_PER_BYTE_POWER
)
861 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
864 /* We read the file, putting things into a web that represents what we
865 have been reading. */
867 read_a_source_file (const char *name
)
871 char *s
; /* String of symbol, '\0' appended. */
873 const pseudo_typeS
*pop
;
879 buffer
= input_scrub_new_file (name
);
882 listing_newline (NULL
);
883 register_dependency (name
);
885 /* Generate debugging information before we've read anything in to denote
886 this file as the "main" source file and not a subordinate one
887 (e.g. N_SO vs N_SOL in stabs). */
888 generate_file_debug ();
890 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
891 { /* We have another line to parse. */
893 /* In order to avoid listing macro expansion lines with labels
894 multiple times, keep track of which line was last issued. */
895 static char *last_eol
;
899 while (input_line_pointer
< buffer_limit
)
901 bfd_boolean was_new_line
;
902 /* We have more of this buffer to parse. */
904 /* We now have input_line_pointer->1st char of next line.
905 If input_line_pointer [-1] == '\n' then we just
906 scanned another line: so bump line counters. */
907 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
910 symbol_set_value_now (&dot_symbol
);
911 #ifdef md_start_line_hook
912 md_start_line_hook ();
914 if (input_line_pointer
[-1] == '\n')
915 bump_line_counters ();
919 /* If listing is on, and we are expanding a macro, then give
920 the listing code the contents of the expanded line. */
923 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
925 /* Find the end of the current expanded macro line. */
926 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
934 /* Copy it for safe keeping. Also give an indication of
935 how much macro nesting is involved at this point. */
936 len
= s
- input_line_pointer
;
937 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
938 memset (copy
, '>', macro_nest
);
939 copy
[macro_nest
] = ' ';
940 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
941 copy
[macro_nest
+ 1 + len
] = '\0';
943 /* Install the line with the listing facility. */
944 listing_newline (copy
);
948 listing_newline (NULL
);
955 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
957 next_char
= * input_line_pointer
;
958 /* Text at the start of a line must be a label, we
959 run down and stick a colon in. */
960 if (is_name_beginner (next_char
) || next_char
== '"')
965 HANDLE_CONDITIONAL_ASSEMBLY (0);
967 nul_char
= get_symbol_name (& line_start
);
968 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
970 /* In MRI mode, the EQU and MACRO pseudoops must
971 be handled specially. */
975 char *rest
= input_line_pointer
+ 1;
979 if (*rest
== ' ' || *rest
== '\t')
981 if ((strncasecmp (rest
, "EQU", 3) == 0
982 || strncasecmp (rest
, "SET", 3) == 0)
983 && (rest
[3] == ' ' || rest
[3] == '\t'))
985 input_line_pointer
= rest
+ 3;
987 strncasecmp (rest
, "SET", 3) == 0);
990 if (strncasecmp (rest
, "MACRO", 5) == 0
993 || is_end_of_line
[(unsigned char) rest
[5]]))
997 /* In MRI mode, we need to handle the MACRO
998 pseudo-op specially: we don't want to put the
999 symbol in the symbol table. */
1001 #ifdef TC_START_LABEL_WITHOUT_COLON
1002 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1005 line_label
= colon (line_start
);
1007 line_label
= symbol_create (line_start
,
1009 &zero_address_frag
, 0);
1011 next_char
= restore_line_pointer (nul_char
);
1012 if (next_char
== ':')
1013 input_line_pointer
++;
1018 /* We are at the beginning of a line, or similar place.
1019 We expect a well-formed assembler statement.
1020 A "symbol-name:" is a statement.
1022 Depending on what compiler is used, the order of these tests
1023 may vary to catch most common case 1st.
1024 Each test is independent of all other tests at the (top)
1027 nul_char
= next_char
= *input_line_pointer
++;
1028 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1030 /* C is the 1st significant character.
1031 Input_line_pointer points after that character. */
1032 if (is_name_beginner (next_char
) || next_char
== '"')
1036 /* Want user-defined label or pseudo/opcode. */
1037 HANDLE_CONDITIONAL_ASSEMBLY (1);
1039 --input_line_pointer
;
1040 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1041 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1042 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1044 /* NEXT_CHAR is character after symbol.
1045 The end of symbol in the input line is now '\0'.
1046 S points to the beginning of the symbol.
1047 [In case of pseudo-op, s->'.'.]
1048 Input_line_pointer->'\0' where NUL_CHAR was. */
1049 if (TC_START_LABEL (s
, nul_char
, next_char
))
1053 /* In MRI mode, \tsym: set 0 is permitted. */
1057 if (*rest
== ' ' || *rest
== '\t')
1060 if ((strncasecmp (rest
, "EQU", 3) == 0
1061 || strncasecmp (rest
, "SET", 3) == 0)
1062 && (rest
[3] == ' ' || rest
[3] == '\t'))
1064 input_line_pointer
= rest
+ 3;
1070 line_label
= colon (s
); /* User-defined label. */
1071 restore_line_pointer (nul_char
);
1072 ++ input_line_pointer
;
1073 #ifdef tc_check_label
1074 tc_check_label (line_label
);
1076 /* Input_line_pointer->after ':'. */
1079 else if ((next_char
== '=' && *rest
== '=')
1080 || ((next_char
== ' ' || next_char
== '\t')
1085 demand_empty_rest_of_line ();
1087 else if ((next_char
== '='
1088 || ((next_char
== ' ' || next_char
== '\t')
1090 #ifdef TC_EQUAL_IN_INSN
1091 && !TC_EQUAL_IN_INSN (next_char
, s
)
1096 demand_empty_rest_of_line ();
1100 /* Expect pseudo-op or machine instruction. */
1103 #ifndef TC_CASE_SENSITIVE
1107 strncpy (original_case_string
, s2
,
1108 sizeof (original_case_string
) - 1);
1109 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1113 *s2
= TOLOWER (*s2
);
1118 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1120 /* The MRI assembler uses pseudo-ops without
1122 pop
= po_entry_find (po_hash
, s
);
1123 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1128 || (!flag_m68k_mri
&& *s
== '.'))
1132 WARNING: next_char may be end-of-line.
1133 We lookup the pseudo-op table with s+1 because we
1134 already know that the pseudo-op begins with a '.'. */
1137 pop
= po_entry_find (po_hash
, s
+ 1);
1138 if (pop
&& !pop
->poc_handler
)
1141 /* In MRI mode, we may need to insert an
1142 automatic alignment directive. What a hack
1144 if (mri_pending_align
1146 || !((pop
->poc_handler
== cons
1147 && pop
->poc_val
== 1)
1148 || (pop
->poc_handler
== s_space
1149 && pop
->poc_val
== 1)
1150 #ifdef tc_conditional_pseudoop
1151 || tc_conditional_pseudoop (pop
)
1153 || pop
->poc_handler
== s_if
1154 || pop
->poc_handler
== s_ifdef
1155 || pop
->poc_handler
== s_ifc
1156 || pop
->poc_handler
== s_ifeqs
1157 || pop
->poc_handler
== s_else
1158 || pop
->poc_handler
== s_endif
1159 || pop
->poc_handler
== s_globl
1160 || pop
->poc_handler
== s_ignore
)))
1162 do_align (1, (char *) NULL
, 0, 0);
1163 mri_pending_align
= 0;
1165 if (line_label
!= NULL
)
1167 symbol_set_frag (line_label
, frag_now
);
1168 S_SET_VALUE (line_label
, frag_now_fix ());
1172 /* Print the error msg now, while we still can. */
1175 char *end
= input_line_pointer
;
1177 (void) restore_line_pointer (nul_char
);
1179 nul_char
= next_char
= *--input_line_pointer
;
1180 *input_line_pointer
= '\0';
1181 if (! macro_defined
|| ! try_macro (next_char
, s
))
1184 as_bad (_("unknown pseudo-op: `%s'"), s
);
1185 *input_line_pointer
++ = nul_char
;
1190 /* Put it back for error messages etc. */
1191 next_char
= restore_line_pointer (nul_char
);
1192 /* The following skip of whitespace is compulsory.
1193 A well shaped space is sometimes all that separates
1194 keyword from operands. */
1195 if (next_char
== ' ' || next_char
== '\t')
1196 input_line_pointer
++;
1198 /* Input_line is restored.
1199 Input_line_pointer->1st non-blank char
1200 after pseudo-operation. */
1201 (*pop
->poc_handler
) (pop
->poc_val
);
1203 /* If that was .end, just get out now. */
1204 if (pop
->poc_handler
== s_end
)
1209 /* WARNING: next_char may be end-of-line. */
1210 /* Also: input_line_pointer->`\0` where nul_char was. */
1211 (void) restore_line_pointer (nul_char
);
1212 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1213 next_char
= nul_char
= *input_line_pointer
;
1214 *input_line_pointer
= '\0';
1216 generate_lineno_debug ();
1218 if (macro_defined
&& try_macro (next_char
, s
))
1221 if (mri_pending_align
)
1223 do_align (1, (char *) NULL
, 0, 0);
1224 mri_pending_align
= 0;
1225 if (line_label
!= NULL
)
1227 symbol_set_frag (line_label
, frag_now
);
1228 S_SET_VALUE (line_label
, frag_now_fix ());
1232 assemble_one (s
); /* Assemble 1 instruction. */
1234 /* PR 19630: The backend may have set ilp to NULL
1235 if it encountered a catastrophic failure. */
1236 if (input_line_pointer
== NULL
)
1237 as_fatal (_("unable to continue with assembly."));
1239 *input_line_pointer
++ = nul_char
;
1241 /* We resume loop AFTER the end-of-line from
1242 this instruction. */
1248 /* Empty statement? */
1249 if (is_end_of_line
[(unsigned char) next_char
])
1252 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1254 /* local label ("4:") */
1255 char *backup
= input_line_pointer
;
1257 HANDLE_CONDITIONAL_ASSEMBLY (1);
1259 temp
= next_char
- '0';
1261 if (nul_char
== '"')
1262 ++ input_line_pointer
;
1264 /* Read the whole number. */
1265 while (ISDIGIT (*input_line_pointer
))
1267 const long digit
= *input_line_pointer
- '0';
1268 if (temp
> (LONG_MAX
- digit
) / 10)
1270 as_bad (_("local label too large near %s"), backup
);
1274 temp
= temp
* 10 + digit
;
1275 ++input_line_pointer
;
1278 /* Overflow: stop processing the label. */
1281 ignore_rest_of_line ();
1285 if (LOCAL_LABELS_DOLLAR
1286 && *input_line_pointer
== '$'
1287 && *(input_line_pointer
+ 1) == ':')
1289 input_line_pointer
+= 2;
1291 if (dollar_label_defined (temp
))
1293 as_fatal (_("label \"%ld$\" redefined"), temp
);
1296 define_dollar_label (temp
);
1297 colon (dollar_label_name (temp
, 0));
1302 && *input_line_pointer
++ == ':')
1304 fb_label_instance_inc (temp
);
1305 colon (fb_label_name (temp
, 0));
1309 input_line_pointer
= backup
;
1312 if (next_char
&& strchr (line_comment_chars
, next_char
))
1313 { /* Its a comment. Better say APP or NO_APP. */
1318 unsigned int new_length
;
1321 s
= input_line_pointer
;
1322 if (strncmp (s
, "APP\n", 4))
1325 ignore_rest_of_line ();
1328 bump_line_counters ();
1331 ends
= strstr (s
, "#NO_APP\n");
1335 unsigned int tmp_len
;
1338 /* The end of the #APP wasn't in this buffer. We
1339 keep reading in buffers until we find the #NO_APP
1340 that goes with this #APP There is one. The specs
1342 tmp_len
= buffer_limit
- s
;
1343 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1344 memcpy (tmp_buf
, s
, tmp_len
);
1347 new_tmp
= input_scrub_next_buffer (&buffer
);
1351 buffer_limit
= new_tmp
;
1352 input_line_pointer
= buffer
;
1353 ends
= strstr (buffer
, "#NO_APP\n");
1355 num
= ends
- buffer
;
1357 num
= buffer_limit
- buffer
;
1359 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1360 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1365 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1373 input_line_pointer
= ends
+ 8;
1377 scrub_string_end
= ends
;
1379 new_length
= ends
- s
;
1380 new_buf
= XNEWVEC (char, new_length
);
1387 space
= (new_buf
+ new_length
) - new_tmp
;
1388 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1396 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1397 new_tmp
= new_buf
+ new_length
;
1403 /* We've "scrubbed" input to the preferred format. In the
1404 process we may have consumed the whole of the remaining
1405 file (and included files). We handle this formatted
1406 input similar to that of macro expansion, letting
1407 actual macro expansion (possibly nested) and other
1408 input expansion work. Beware that in messages, line
1409 numbers and possibly file names will be incorrect. */
1410 new_length
= strlen (new_buf
);
1411 sb_build (&sbuf
, new_length
);
1412 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1413 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1415 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1420 HANDLE_CONDITIONAL_ASSEMBLY (1);
1422 #ifdef tc_unrecognized_line
1423 if (tc_unrecognized_line (next_char
))
1426 input_line_pointer
--;
1427 /* Report unknown char as error. */
1428 demand_empty_rest_of_line ();
1433 symbol_set_value_now (&dot_symbol
);
1435 #ifdef HANDLE_BUNDLE
1436 if (bundle_lock_frag
!= NULL
)
1438 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1439 _(".bundle_lock with no matching .bundle_unlock"));
1440 bundle_lock_frag
= NULL
;
1441 bundle_lock_frchain
= NULL
;
1442 bundle_lock_depth
= 0;
1449 /* Close the input file. */
1450 input_scrub_close ();
1451 #ifdef WARN_COMMENTS
1453 if (warn_comment
&& found_comment
)
1454 as_warn_where (found_comment_file
, found_comment
,
1455 "first comment found here");
1460 /* Convert O_constant expression EXP into the equivalent O_big representation.
1461 Take the sign of the number from SIGN rather than X_add_number. */
1464 convert_to_bignum (expressionS
*exp
, int sign
)
1469 value
= exp
->X_add_number
;
1470 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1472 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1473 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1475 /* Add a sequence of sign bits if the top bit of X_add_number is not
1476 the sign of the original value. */
1477 if ((exp
->X_add_number
< 0) == !sign
)
1478 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1480 exp
->X_add_number
= i
;
1483 /* For most MRI pseudo-ops, the line actually ends at the first
1484 nonquoted space. This function looks for that point, stuffs a null
1485 in, and sets *STOPCP to the character that used to be there, and
1486 returns the location.
1488 Until I hear otherwise, I am going to assume that this is only true
1489 for the m68k MRI assembler. */
1492 mri_comment_field (char *stopcp
)
1498 know (flag_m68k_mri
);
1500 for (s
= input_line_pointer
;
1501 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1509 for (s
= input_line_pointer
;
1510 !is_end_of_line
[(unsigned char) *s
];
1520 /* Skip to the end of an MRI comment field. */
1523 mri_comment_end (char *stop
, int stopc
)
1527 input_line_pointer
= stop
;
1529 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1530 ++input_line_pointer
;
1534 s_abort (int ignore ATTRIBUTE_UNUSED
)
1536 as_fatal (_(".abort detected. Abandoning ship."));
1539 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1540 (in bytes). A negative ARG is the negative of the length of the
1541 fill pattern. BYTES_P is non-zero if the alignment value should be
1542 interpreted as the byte boundary, rather than the power of 2. */
1543 #ifndef TC_ALIGN_LIMIT
1544 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1548 s_align (signed int arg
, int bytes_p
)
1550 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1559 stop
= mri_comment_field (&stopc
);
1561 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1566 align
= arg
; /* Default value from pseudo-op table. */
1570 align
= get_absolute_expression ();
1573 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1574 if (arg
> 0 && align
== 0)
1581 /* Convert to a power of 2. */
1586 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1589 as_bad (_("alignment not a power of 2"));
1595 if (align
> align_limit
)
1597 align
= align_limit
;
1598 as_warn (_("alignment too large: %u assumed"), align
);
1601 if (*input_line_pointer
!= ',')
1608 ++input_line_pointer
;
1609 if (*input_line_pointer
== ',')
1613 fill
= get_absolute_expression ();
1618 if (*input_line_pointer
!= ',')
1622 ++input_line_pointer
;
1623 max
= get_absolute_expression ();
1630 as_warn (_("expected fill pattern missing"));
1631 do_align (align
, (char *) NULL
, 0, max
);
1635 unsigned int fill_len
;
1647 do_align (align
, &fill_char
, fill_len
, max
);
1653 if ((size_t) fill_len
> sizeof ab
)
1655 as_warn (_("fill pattern too long, truncating to %u"),
1656 (unsigned) sizeof ab
);
1657 fill_len
= sizeof ab
;
1660 md_number_to_chars (ab
, fill
, fill_len
);
1661 do_align (align
, ab
, fill_len
, max
);
1665 demand_empty_rest_of_line ();
1668 mri_comment_end (stop
, stopc
);
1671 /* Handle the .align pseudo-op on machines where ".align 4" means
1672 align to a 4 byte boundary. */
1675 s_align_bytes (int arg
)
1680 /* Handle the .align pseudo-op on machines where ".align 4" means align
1681 to a 2**4 boundary. */
1684 s_align_ptwo (int arg
)
1689 /* Switch in and out of alternate macro mode. */
1694 demand_empty_rest_of_line ();
1695 macro_set_alternate (on
);
1698 /* Read a symbol name from input_line_pointer.
1700 Stores the symbol name in a buffer and returns a pointer to this buffer.
1701 The buffer is xalloc'ed. It is the caller's responsibility to free
1704 The name is not left in the i_l_p buffer as it may need processing
1705 to handle escape characters.
1707 Advances i_l_p to the next non-whitespace character.
1709 If a symbol name could not be read, the routine issues an error
1710 messages, skips to the end of the line and returns NULL. */
1713 read_symbol_name (void)
1719 c
= *input_line_pointer
++;
1723 #define SYM_NAME_CHUNK_LEN 128
1724 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1728 start
= name
= XNEWVEC (char, len
+ 1);
1730 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1732 while (is_a_char (C
= next_char_of_string ()))
1734 if (name
>= name_end
)
1738 sofar
= name
- start
;
1739 len
+= SYM_NAME_CHUNK_LEN
;
1740 start
= XRESIZEVEC (char, start
, len
+ 1);
1741 name_end
= start
+ len
;
1742 name
= start
+ sofar
;
1749 /* Since quoted symbol names can contain non-ASCII characters,
1750 check the string and warn if it cannot be recognised by the
1751 current character set. */
1752 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1753 as_warn (_("symbol name not recognised in the current locale"));
1755 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1759 name
= input_line_pointer
- 1;
1761 /* We accept FAKE_LABEL_CHAR in a name in case this is
1762 being called with a constructed string. */
1763 while (is_part_of_name (c
= *input_line_pointer
++)
1764 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1767 len
= (input_line_pointer
- name
) - 1;
1768 start
= XNEWVEC (char, len
+ 1);
1770 memcpy (start
, name
, len
);
1773 /* Skip a name ender char if one is present. */
1774 if (! is_name_ender (c
))
1775 --input_line_pointer
;
1778 name
= start
= NULL
;
1782 as_bad (_("expected symbol name"));
1783 ignore_rest_of_line ();
1794 s_comm_internal (int param
,
1795 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1799 symbolS
*symbolP
= NULL
;
1805 stop
= mri_comment_field (&stopc
);
1807 if ((name
= read_symbol_name ()) == NULL
)
1810 /* Accept an optional comma after the name. The comma used to be
1811 required, but Irix 5 cc does not generate it for .lcomm. */
1812 if (*input_line_pointer
== ',')
1813 input_line_pointer
++;
1815 temp
= get_absolute_expr (&exp
);
1817 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1818 if (exp
.X_op
== O_absent
)
1820 as_bad (_("missing size expression"));
1821 ignore_rest_of_line ();
1824 else if (temp
!= size
|| !exp
.X_unsigned
)
1826 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1827 ignore_rest_of_line ();
1831 symbolP
= symbol_find_or_make (name
);
1832 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1833 && !S_IS_COMMON (symbolP
))
1835 if (!S_IS_VOLATILE (symbolP
))
1838 as_bad (_("symbol `%s' is already defined"), name
);
1839 ignore_rest_of_line ();
1842 symbolP
= symbol_clone (symbolP
, 1);
1843 S_SET_SEGMENT (symbolP
, undefined_section
);
1844 S_SET_VALUE (symbolP
, 0);
1845 symbol_set_frag (symbolP
, &zero_address_frag
);
1846 S_CLEAR_VOLATILE (symbolP
);
1849 size
= S_GET_VALUE (symbolP
);
1852 else if (size
!= temp
)
1853 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1854 name
, (long) size
, (long) temp
);
1856 if (comm_parse_extra
!= NULL
)
1857 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1860 S_SET_VALUE (symbolP
, (valueT
) size
);
1861 S_SET_EXTERNAL (symbolP
);
1862 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1865 demand_empty_rest_of_line ();
1868 mri_comment_end (stop
, stopc
);
1876 s_comm_internal (ignore
, NULL
);
1879 /* The MRI COMMON pseudo-op. We handle this by creating a common
1880 symbol with the appropriate name. We make s_space do the right
1881 thing by increasing the size. */
1884 s_mri_common (int small ATTRIBUTE_UNUSED
)
1900 stop
= mri_comment_field (&stopc
);
1904 name
= input_line_pointer
;
1905 if (!ISDIGIT (*name
))
1906 c
= get_symbol_name (& name
);
1911 ++input_line_pointer
;
1913 while (ISDIGIT (*input_line_pointer
));
1915 c
= *input_line_pointer
;
1916 *input_line_pointer
= '\0';
1918 if (line_label
!= NULL
)
1920 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1921 + (input_line_pointer
- name
) + 1);
1922 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1927 sym
= symbol_find_or_make (name
);
1928 c
= restore_line_pointer (c
);
1931 if (*input_line_pointer
!= ',')
1935 ++input_line_pointer
;
1936 align
= get_absolute_expression ();
1939 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1941 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1942 ignore_rest_of_line ();
1943 mri_comment_end (stop
, stopc
);
1947 S_SET_EXTERNAL (sym
);
1948 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1949 mri_common_symbol
= sym
;
1953 S_SET_ALIGN (sym
, align
);
1958 if (line_label
!= NULL
)
1961 exp
.X_op
= O_symbol
;
1962 exp
.X_add_symbol
= sym
;
1963 exp
.X_add_number
= 0;
1964 symbol_set_value_expression (line_label
, &exp
);
1965 symbol_set_frag (line_label
, &zero_address_frag
);
1966 S_SET_SEGMENT (line_label
, expr_section
);
1969 /* FIXME: We just ignore the small argument, which distinguishes
1970 COMMON and COMMON.S. I don't know what we can do about it. */
1972 /* Ignore the type and hptype. */
1973 if (*input_line_pointer
== ',')
1974 input_line_pointer
+= 2;
1975 if (*input_line_pointer
== ',')
1976 input_line_pointer
+= 2;
1978 demand_empty_rest_of_line ();
1980 mri_comment_end (stop
, stopc
);
1984 s_data (int ignore ATTRIBUTE_UNUSED
)
1989 temp
= get_absolute_expression ();
1990 if (flag_readonly_data_in_text
)
1992 section
= text_section
;
1996 section
= data_section
;
1998 subseg_set (section
, (subsegT
) temp
);
2000 demand_empty_rest_of_line ();
2003 /* Handle the .appfile pseudo-op. This is automatically generated by
2004 do_scrub_chars when a preprocessor # line comment is seen with a
2005 file name. This default definition may be overridden by the object
2006 or CPU specific pseudo-ops. This function is also the default
2007 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
2011 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
2015 listing_source_file (file
);
2017 register_dependency (file
);
2019 obj_app_file (file
, appfile
);
2024 s_app_file (int appfile
)
2029 /* Some assemblers tolerate immediately following '"'. */
2030 if ((s
= demand_copy_string (&length
)) != 0)
2033 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
2035 /* In MRI mode, the preprocessor may have inserted an extraneous
2038 && *input_line_pointer
== '\''
2039 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2040 ++input_line_pointer
;
2042 demand_empty_rest_of_line ();
2044 s_app_file_string (s
, appfile
);
2049 get_linefile_number (int *flag
)
2053 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2056 *flag
= get_absolute_expression ();
2061 /* Handle the .appline pseudo-op. This is automatically generated by
2062 do_scrub_chars when a preprocessor # line comment is seen. This
2063 default definition may be overridden by the object or CPU specific
2067 s_app_line (int appline
)
2072 /* The given number is that of the next line. */
2074 l
= get_absolute_expression ();
2075 else if (!get_linefile_number (&l
))
2077 ignore_rest_of_line ();
2084 /* Some of the back ends can't deal with non-positive line numbers.
2085 Besides, it's silly. GCC however will generate a line number of
2086 zero when it is pre-processing builtins for assembler-with-cpp files:
2090 We do not want to barf on this, especially since such files are used
2091 in the GCC and GDB testsuites. So we check for negative line numbers
2092 rather than non-positive line numbers. */
2093 as_warn (_("line numbers must be positive; line number %d rejected"),
2104 if (*input_line_pointer
== '"')
2105 file
= demand_copy_string (&length
);
2111 while (get_linefile_number (&this_flag
))
2114 /* From GCC's cpp documentation:
2115 1: start of a new file.
2116 2: returning to a file after having included
2118 3: following text comes from a system header file.
2119 4: following text should be treated as extern "C".
2121 4 is nonsensical for the assembler; 3, we don't
2122 care about, so we ignore it just in case a
2123 system header file is included while
2124 preprocessing assembly. So 1 and 2 are all we
2125 care about, and they are mutually incompatible.
2126 new_logical_line_flags() demands this. */
2129 if (flags
&& flags
!= (1 << this_flag
))
2130 as_warn (_("incompatible flag %i in line directive"),
2133 flags
|= 1 << this_flag
;
2138 /* We ignore these. */
2142 as_warn (_("unsupported flag %i in line directive"),
2147 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2152 if (appline
|| file
)
2154 new_logical_line_flags (file
, l
, flags
);
2157 listing_source_line (l
);
2161 if (appline
|| file
)
2162 demand_empty_rest_of_line ();
2164 ignore_rest_of_line ();
2167 /* Handle the .end pseudo-op. Actually, the real work is done in
2168 read_a_source_file. */
2171 s_end (int ignore ATTRIBUTE_UNUSED
)
2175 /* The MRI assembler permits the start symbol to follow .end,
2176 but we don't support that. */
2178 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2179 && *input_line_pointer
!= '*'
2180 && *input_line_pointer
!= '!')
2181 as_warn (_("start address not supported"));
2185 /* Handle the .err pseudo-op. */
2188 s_err (int ignore ATTRIBUTE_UNUSED
)
2190 as_bad (_(".err encountered"));
2191 demand_empty_rest_of_line ();
2194 /* Handle the .error and .warning pseudo-ops. */
2200 /* The purpose for the conditional assignment is not to
2201 internationalize the directive itself, but that we need a
2202 self-contained message, one that can be passed like the
2203 demand_copy_C_string return value, and with no assumption on the
2204 location of the name of the directive within the message. */
2206 = (err
? _(".error directive invoked in source file")
2207 : _(".warning directive invoked in source file"));
2209 if (!is_it_end_of_statement ())
2211 if (*input_line_pointer
!= '\"')
2213 as_bad (_("%s argument must be a string"),
2214 err
? ".error" : ".warning");
2215 ignore_rest_of_line ();
2219 msg
= demand_copy_C_string (&len
);
2227 as_warn ("%s", msg
);
2228 demand_empty_rest_of_line ();
2231 /* Handle the MRI fail pseudo-op. */
2234 s_fail (int ignore ATTRIBUTE_UNUSED
)
2241 stop
= mri_comment_field (&stopc
);
2243 temp
= get_absolute_expression ();
2245 as_warn (_(".fail %ld encountered"), (long) temp
);
2247 as_bad (_(".fail %ld encountered"), (long) temp
);
2249 demand_empty_rest_of_line ();
2252 mri_comment_end (stop
, stopc
);
2256 s_fill (int ignore ATTRIBUTE_UNUSED
)
2258 expressionS rep_exp
;
2263 #ifdef md_flush_pending_output
2264 md_flush_pending_output ();
2267 #ifdef md_cons_align
2271 expression (&rep_exp
);
2272 if (*input_line_pointer
== ',')
2274 input_line_pointer
++;
2275 size
= get_absolute_expression ();
2276 if (*input_line_pointer
== ',')
2278 input_line_pointer
++;
2279 fill
= get_absolute_expression ();
2283 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2284 #define BSD_FILL_SIZE_CROCK_8 (8)
2285 if (size
> BSD_FILL_SIZE_CROCK_8
)
2287 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2288 size
= BSD_FILL_SIZE_CROCK_8
;
2292 as_warn (_("size negative; .fill ignored"));
2295 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2297 if (rep_exp
.X_add_number
< 0)
2298 as_warn (_("repeat < 0; .fill ignored"));
2302 if (size
&& !need_pass_2
)
2304 if (now_seg
== absolute_section
)
2306 if (rep_exp
.X_op
!= O_constant
)
2307 as_bad (_("non-constant fill count for absolute section"));
2308 else if (fill
&& rep_exp
.X_add_number
!= 0)
2309 as_bad (_("attempt to fill absolute section with non-zero value"));
2310 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2313 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2315 as_bad (_("attempt to fill section `%s' with non-zero value"),
2316 segment_name (now_seg
));
2318 if (rep_exp
.X_op
== O_constant
)
2320 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2321 (relax_substateT
) 0, (symbolS
*) 0,
2322 (offsetT
) rep_exp
.X_add_number
,
2327 /* We don't have a constant repeat count, so we can't use
2328 rs_fill. We can get the same results out of rs_space,
2329 but its argument is in bytes, so we must multiply the
2330 repeat count by size. */
2333 rep_sym
= make_expr_symbol (&rep_exp
);
2336 expressionS size_exp
;
2337 size_exp
.X_op
= O_constant
;
2338 size_exp
.X_add_number
= size
;
2340 rep_exp
.X_op
= O_multiply
;
2341 rep_exp
.X_add_symbol
= rep_sym
;
2342 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2343 rep_exp
.X_add_number
= 0;
2344 rep_sym
= make_expr_symbol (&rep_exp
);
2347 p
= frag_var (rs_space
, (int) size
, (int) size
,
2348 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2351 memset (p
, 0, (unsigned int) size
);
2353 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2354 flavoured AS. The following bizarre behaviour is to be
2355 compatible with above. I guess they tried to take up to 8
2356 bytes from a 4-byte expression and they forgot to sign
2358 #define BSD_FILL_SIZE_CROCK_4 (4)
2359 md_number_to_chars (p
, (valueT
) fill
,
2360 (size
> BSD_FILL_SIZE_CROCK_4
2361 ? BSD_FILL_SIZE_CROCK_4
2363 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2364 but emits no error message because it seems a legal thing to do.
2365 It is a degenerate case of .fill but could be emitted by a
2368 demand_empty_rest_of_line ();
2372 s_globl (int ignore ATTRIBUTE_UNUSED
)
2381 stop
= mri_comment_field (&stopc
);
2385 if ((name
= read_symbol_name ()) == NULL
)
2388 symbolP
= symbol_find_or_make (name
);
2389 S_SET_EXTERNAL (symbolP
);
2392 c
= *input_line_pointer
;
2395 input_line_pointer
++;
2397 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2405 demand_empty_rest_of_line ();
2408 mri_comment_end (stop
, stopc
);
2411 /* Handle the MRI IRP and IRPC pseudo-ops. */
2423 file
= as_where (&line
);
2425 eol
= find_end_of_line (input_line_pointer
, 0);
2426 sb_build (&s
, eol
- input_line_pointer
);
2427 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2428 input_line_pointer
= eol
;
2432 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2434 as_bad_where (file
, line
, "%s", err
);
2438 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2440 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2443 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2444 the section to only be linked once. However, this is not supported
2445 by most object file formats. This takes an optional argument,
2446 which is what to do about duplicates. */
2449 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2451 enum linkonce_type type
;
2455 type
= LINKONCE_DISCARD
;
2457 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2462 c
= get_symbol_name (& s
);
2463 if (strcasecmp (s
, "discard") == 0)
2464 type
= LINKONCE_DISCARD
;
2465 else if (strcasecmp (s
, "one_only") == 0)
2466 type
= LINKONCE_ONE_ONLY
;
2467 else if (strcasecmp (s
, "same_size") == 0)
2468 type
= LINKONCE_SAME_SIZE
;
2469 else if (strcasecmp (s
, "same_contents") == 0)
2470 type
= LINKONCE_SAME_CONTENTS
;
2472 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2474 (void) restore_line_pointer (c
);
2477 #ifdef obj_handle_link_once
2478 obj_handle_link_once (type
);
2479 #else /* ! defined (obj_handle_link_once) */
2483 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2484 as_warn (_(".linkonce is not supported for this object file format"));
2486 flags
= bfd_section_flags (now_seg
);
2487 flags
|= SEC_LINK_ONCE
;
2492 case LINKONCE_DISCARD
:
2493 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2495 case LINKONCE_ONE_ONLY
:
2496 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2498 case LINKONCE_SAME_SIZE
:
2499 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2501 case LINKONCE_SAME_CONTENTS
:
2502 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2505 if (!bfd_set_section_flags (now_seg
, flags
))
2506 as_bad (_("bfd_set_section_flags: %s"),
2507 bfd_errmsg (bfd_get_error ()));
2509 #endif /* ! defined (obj_handle_link_once) */
2511 demand_empty_rest_of_line ();
2515 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2518 segT current_seg
= now_seg
;
2519 subsegT current_subseg
= now_subseg
;
2520 segT bss_seg
= bss_section
;
2522 #if defined (TC_MIPS) || defined (TC_ALPHA)
2523 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2524 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2526 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2527 if (size
<= bfd_get_gp_size (stdoutput
))
2529 bss_seg
= subseg_new (".sbss", 1);
2530 seg_info (bss_seg
)->bss
= 1;
2531 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2532 as_warn (_("error setting flags for \".sbss\": %s"),
2533 bfd_errmsg (bfd_get_error ()));
2537 subseg_set (bss_seg
, 1);
2539 if (align
> OCTETS_PER_BYTE_POWER
)
2541 record_alignment (bss_seg
, align
);
2542 frag_align (align
, 0, 0);
2545 /* Detach from old frag. */
2546 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2547 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2549 symbol_set_frag (symbolP
, frag_now
);
2550 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2554 S_SET_SIZE (symbolP
, size
);
2556 S_SET_SEGMENT (symbolP
, bss_seg
);
2559 /* The symbol may already have been created with a preceding
2560 ".globl" directive -- be careful not to step on storage class
2561 in that case. Otherwise, set it to static. */
2562 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2563 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2564 #endif /* OBJ_COFF */
2566 subseg_set (current_seg
, current_subseg
);
2570 parse_align (int align_bytes
)
2576 if (*input_line_pointer
!= ',')
2579 as_bad (_("expected alignment after size"));
2580 ignore_rest_of_line ();
2584 input_line_pointer
++;
2587 align
= get_absolute_expr (&exp
);
2588 if (exp
.X_op
== O_absent
)
2591 if (!exp
.X_unsigned
)
2593 as_warn (_("alignment negative; 0 assumed"));
2597 if (align_bytes
&& align
!= 0)
2599 /* convert to a power of 2 alignment */
2600 unsigned int alignp2
= 0;
2601 while ((align
& 1) == 0)
2602 align
>>= 1, ++alignp2
;
2605 as_bad (_("alignment not a power of 2"));
2606 ignore_rest_of_line ();
2614 /* Called from s_comm_internal after symbol name and size have been
2615 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2616 1 if this was a ".bss" directive which has a 3rd argument
2617 (alignment as a power of 2), or 2 if this was a ".bss" directive
2618 with alignment in bytes. */
2621 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2627 align
= parse_align (needs_align
- 1);
2628 if (align
== (addressT
) -1)
2632 /* Assume some objects may require alignment on some systems. */
2633 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2635 bss_alloc (symbolP
, size
, align
);
2640 s_lcomm (int needs_align
)
2642 s_comm_internal (needs_align
, s_lcomm_internal
);
2646 s_lcomm_bytes (int needs_align
)
2648 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2652 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2658 /* We permit ANY defined expression: BSD4.2 demands constants. */
2659 if ((name
= read_symbol_name ()) == NULL
)
2662 if (*input_line_pointer
!= ',')
2664 as_bad (_("expected comma after \"%s\""), name
);
2668 input_line_pointer
++;
2669 expression_and_evaluate (&exp
);
2671 if (exp
.X_op
!= O_constant
2672 && exp
.X_op
!= O_register
)
2674 as_bad (_("bad expression"));
2678 symbolP
= symbol_find_or_make (name
);
2680 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2682 /* The name might be an undefined .global symbol; be sure to
2683 keep the "external" bit. */
2684 S_SET_SEGMENT (symbolP
,
2685 (exp
.X_op
== O_constant
2688 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2692 as_bad (_("symbol `%s' is already defined"), name
);
2695 demand_empty_rest_of_line ();
2700 ignore_rest_of_line ();
2705 /* Read a line into an sb. Returns the character that ended the line
2706 or zero if there are no more lines. */
2709 get_line_sb (sb
*line
, int in_macro
)
2713 if (input_line_pointer
[-1] == '\n')
2714 bump_line_counters ();
2716 if (input_line_pointer
>= buffer_limit
)
2718 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2719 if (buffer_limit
== 0)
2723 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2724 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2725 input_line_pointer
= eol
;
2727 /* Don't skip multiple end-of-line characters, because that breaks support
2728 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2729 characters but isn't. Instead just skip one end of line character and
2730 return the character skipped so that the caller can re-insert it if
2732 return *input_line_pointer
++;
2736 get_non_macro_line_sb (sb
*line
)
2738 return get_line_sb (line
, 0);
2742 get_macro_line_sb (sb
*line
)
2744 return get_line_sb (line
, 1);
2747 /* Define a macro. This is an interface to macro.c. */
2750 s_macro (int ignore ATTRIBUTE_UNUSED
)
2759 file
= as_where (&line
);
2761 eol
= find_end_of_line (input_line_pointer
, 0);
2762 sb_build (&s
, eol
- input_line_pointer
);
2763 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2764 input_line_pointer
= eol
;
2766 if (line_label
!= NULL
)
2771 name
= S_GET_NAME (line_label
);
2772 len
= strlen (name
);
2773 sb_build (&label
, len
);
2774 sb_add_buffer (&label
, name
, len
);
2775 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2779 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2781 as_bad_where (file
, line
, err
, name
);
2784 if (line_label
!= NULL
)
2786 S_SET_SEGMENT (line_label
, absolute_section
);
2787 S_SET_VALUE (line_label
, 0);
2788 symbol_set_frag (line_label
, &zero_address_frag
);
2791 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2792 && po_entry_find (po_hash
, name
) != NULL
)
2795 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2796 as_warn_where (file
,
2798 _("attempt to redefine pseudo-op `%s' ignored"),
2805 /* Handle the .mexit pseudo-op, which immediately exits a macro
2809 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2813 cond_exit_macro (macro_nest
);
2814 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2817 as_warn (_("ignoring macro exit outside a macro definition."));
2820 /* Switch in and out of MRI mode. */
2823 s_mri (int ignore ATTRIBUTE_UNUSED
)
2826 #ifdef MRI_MODE_CHANGE
2830 on
= get_absolute_expression ();
2831 #ifdef MRI_MODE_CHANGE
2832 old_flag
= flag_mri
;
2851 /* Operator precedence changes in m68k MRI mode, so we need to
2852 update the operator rankings. */
2853 expr_set_precedence ();
2855 #ifdef MRI_MODE_CHANGE
2857 MRI_MODE_CHANGE (on
);
2860 demand_empty_rest_of_line ();
2863 /* Handle changing the location counter. */
2866 do_org (segT segment
, expressionS
*exp
, int fill
)
2868 if (segment
!= now_seg
2869 && segment
!= absolute_section
2870 && segment
!= expr_section
)
2871 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2873 if (now_seg
== absolute_section
)
2876 as_warn (_("ignoring fill value in absolute section"));
2877 if (exp
->X_op
!= O_constant
)
2879 as_bad (_("only constant offsets supported in absolute section"));
2880 exp
->X_add_number
= 0;
2882 abs_section_offset
= exp
->X_add_number
;
2887 symbolS
*sym
= exp
->X_add_symbol
;
2888 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2890 if (fill
&& in_bss ())
2891 as_warn (_("ignoring fill value in section `%s'"),
2892 segment_name (now_seg
));
2894 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2896 /* Handle complex expressions. */
2897 sym
= make_expr_symbol (exp
);
2901 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2907 s_org (int ignore ATTRIBUTE_UNUSED
)
2913 #ifdef md_flush_pending_output
2914 md_flush_pending_output ();
2917 /* The m68k MRI assembler has a different meaning for .org. It
2918 means to create an absolute section at a given address. We can't
2919 support that--use a linker script instead. */
2922 as_bad (_("MRI style ORG pseudo-op not supported"));
2923 ignore_rest_of_line ();
2927 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2928 thing as a sub-segment-relative origin. Any absolute origin is
2929 given a warning, then assumed to be segment-relative. Any
2930 segmented origin expression ("foo+42") had better be in the right
2931 segment or the .org is ignored.
2933 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2934 we never know sub-segment sizes when we are reading code. BSD
2935 will crash trying to emit negative numbers of filler bytes in
2936 certain .orgs. We don't crash, but see as-write for that code.
2938 Don't make frag if need_pass_2==1. */
2939 segment
= get_known_segmented_expression (&exp
);
2940 if (*input_line_pointer
== ',')
2942 input_line_pointer
++;
2943 temp_fill
= get_absolute_expression ();
2949 do_org (segment
, &exp
, temp_fill
);
2951 demand_empty_rest_of_line ();
2954 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2955 called by the obj-format routine which handles section changing
2956 when in MRI mode. It will create a new section, and return it. It
2957 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2958 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2961 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2971 name
= input_line_pointer
;
2972 if (!ISDIGIT (*name
))
2973 c
= get_symbol_name (& name
);
2978 ++input_line_pointer
;
2980 while (ISDIGIT (*input_line_pointer
));
2982 c
= *input_line_pointer
;
2983 *input_line_pointer
= '\0';
2986 name
= xstrdup (name
);
2988 c
= restore_line_pointer (c
);
2990 seg
= subseg_new (name
, 0);
2996 ++input_line_pointer
;
2997 align
= get_absolute_expression ();
2998 record_alignment (seg
, align
);
3002 if (*input_line_pointer
== ',')
3004 c
= *++input_line_pointer
;
3006 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3009 as_bad (_("unrecognized section type"));
3010 ++input_line_pointer
;
3015 flags
= SEC_NO_FLAGS
;
3017 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3018 else if (*type
== 'D' || *type
== 'M')
3019 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3020 else if (*type
== 'R')
3021 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3022 if (flags
!= SEC_NO_FLAGS
)
3024 if (!bfd_set_section_flags (seg
, flags
))
3025 as_warn (_("error setting flags for \"%s\": %s"),
3026 bfd_section_name (seg
),
3027 bfd_errmsg (bfd_get_error ()));
3032 /* Ignore the HP type. */
3033 if (*input_line_pointer
== ',')
3034 input_line_pointer
+= 2;
3036 demand_empty_rest_of_line ();
3038 #else /* ! TC_M68K */
3039 /* The MRI assembler seems to use different forms of .sect for
3040 different targets. */
3041 as_bad ("MRI mode not supported for this target");
3042 ignore_rest_of_line ();
3043 #endif /* ! TC_M68K */
3046 /* Handle the .print pseudo-op. */
3049 s_print (int ignore ATTRIBUTE_UNUSED
)
3054 s
= demand_copy_C_string (&len
);
3057 demand_empty_rest_of_line ();
3060 /* Handle the .purgem pseudo-op. */
3063 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3065 if (is_it_end_of_statement ())
3067 demand_empty_rest_of_line ();
3077 c
= get_symbol_name (& name
);
3078 delete_macro (name
);
3079 *input_line_pointer
= c
;
3080 SKIP_WHITESPACE_AFTER_NAME ();
3082 while (*input_line_pointer
++ == ',');
3084 --input_line_pointer
;
3085 demand_empty_rest_of_line ();
3088 /* Handle the .endm/.endr pseudo-ops. */
3091 s_bad_end (int endr
)
3093 as_warn (_(".end%c encountered without preceding %s"),
3095 endr
? ".rept, .irp, or .irpc" : ".macro");
3096 demand_empty_rest_of_line ();
3099 /* Handle the .rept pseudo-op. */
3102 s_rept (int ignore ATTRIBUTE_UNUSED
)
3106 count
= (size_t) get_absolute_expression ();
3108 do_repeat (count
, "REPT", "ENDR");
3111 /* This function provides a generic repeat block implementation. It allows
3112 different directives to be used as the start/end keys. */
3115 do_repeat (size_t count
, const char *start
, const char *end
)
3120 if (((ssize_t
) count
) < 0)
3122 as_bad (_("negative count for %s - ignored"), start
);
3127 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3129 as_bad (_("%s without %s"), start
, end
);
3133 sb_build (&many
, count
* one
.len
);
3135 sb_add_sb (&many
, &one
);
3139 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3141 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3144 /* Like do_repeat except that any text matching EXPANDER in the
3145 block is replaced by the iteration count. */
3148 do_repeat_with_expander (size_t count
,
3151 const char * expander
)
3156 if (((ssize_t
) count
) < 0)
3158 as_bad (_("negative count for %s - ignored"), start
);
3163 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3165 as_bad (_("%s without %s"), start
, end
);
3171 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3173 while (count
-- > 0)
3179 sb_build (& processed
, one
.len
);
3180 sb_add_sb (& processed
, & one
);
3181 sub
= strstr (processed
.ptr
, expander
);
3182 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3183 gas_assert (len
< 8);
3184 memmove (sub
+ len
, sub
+ 8,
3185 processed
.ptr
+ processed
.len
- (sub
+ 8));
3186 processed
.len
-= (8 - len
);
3187 sb_add_sb (& many
, & processed
);
3188 sb_kill (& processed
);
3193 sb_add_sb (&many
, &one
);
3197 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3199 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3202 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3203 input buffers to skip. Assumes that conditionals preceding the loop end
3204 are properly nested.
3206 This function makes it easier to implement a premature "break" out of the
3207 loop. The EXTRA arg accounts for other buffers we might have inserted,
3208 such as line substitutions. */
3211 end_repeat (int extra
)
3213 cond_exit_macro (macro_nest
);
3214 while (extra
-- >= 0)
3215 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3219 assign_symbol (char *name
, int mode
)
3223 if (name
[0] == '.' && name
[1] == '\0')
3225 /* Turn '. = mumble' into a .org mumble. */
3229 segment
= get_known_segmented_expression (&exp
);
3232 do_org (segment
, &exp
, 0);
3237 if ((symbolP
= symbol_find (name
)) == NULL
3238 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3240 symbolP
= symbol_find_or_make (name
);
3242 /* When doing symbol listings, play games with dummy fragments living
3243 outside the normal fragment chain to record the file and line info
3245 if (listing
& LISTING_SYMBOLS
)
3247 extern struct list_info_struct
*listing_tail
;
3248 fragS
*dummy_frag
= XCNEW (fragS
);
3249 dummy_frag
->line
= listing_tail
;
3250 dummy_frag
->fr_symbol
= symbolP
;
3251 symbol_set_frag (symbolP
, dummy_frag
);
3254 #if defined (OBJ_COFF) && !defined (TE_PE)
3255 /* "set" symbols are local unless otherwise specified. */
3256 SF_SET_LOCAL (symbolP
);
3260 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3262 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3263 && !S_CAN_BE_REDEFINED (symbolP
))
3265 as_bad (_("symbol `%s' is already defined"), name
);
3266 ignore_rest_of_line ();
3267 input_line_pointer
--;
3270 /* If the symbol is volatile, copy the symbol and replace the
3271 original with the copy, so that previous uses of the symbol will
3272 retain the value of the symbol at the point of use. */
3273 else if (S_IS_VOLATILE (symbolP
))
3274 symbolP
= symbol_clone (symbolP
, 1);
3278 S_SET_VOLATILE (symbolP
);
3280 S_SET_FORWARD_REF (symbolP
);
3282 pseudo_set (symbolP
);
3285 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3286 then this is .equiv, and it is an error if the symbol is already
3287 defined. If EQUIV is -1, the symbol additionally is a forward
3295 /* Especial apologies for the random logic:
3296 this just grew, and could be parsed much more simply!
3298 if ((name
= read_symbol_name ()) == NULL
)
3301 if (*input_line_pointer
!= ',')
3303 as_bad (_("expected comma after \"%s\""), name
);
3304 ignore_rest_of_line ();
3309 input_line_pointer
++;
3310 assign_symbol (name
, equiv
);
3311 demand_empty_rest_of_line ();
3325 #ifdef md_flush_pending_output
3326 md_flush_pending_output ();
3329 #ifdef md_cons_align
3334 stop
= mri_comment_field (&stopc
);
3336 /* In m68k MRI mode, we need to align to a word boundary, unless
3338 if (flag_m68k_mri
&& mult
> 1)
3340 if (now_seg
== absolute_section
)
3342 abs_section_offset
+= abs_section_offset
& 1;
3343 if (line_label
!= NULL
)
3344 S_SET_VALUE (line_label
, abs_section_offset
);
3346 else if (mri_common_symbol
!= NULL
)
3350 mri_val
= S_GET_VALUE (mri_common_symbol
);
3351 if ((mri_val
& 1) != 0)
3353 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3354 if (line_label
!= NULL
)
3356 expressionS
*symexp
;
3358 symexp
= symbol_get_value_expression (line_label
);
3359 know (symexp
->X_op
== O_symbol
);
3360 know (symexp
->X_add_symbol
== mri_common_symbol
);
3361 symexp
->X_add_number
+= 1;
3367 do_align (1, (char *) NULL
, 0, 0);
3368 if (line_label
!= NULL
)
3370 symbol_set_frag (line_label
, frag_now
);
3371 S_SET_VALUE (line_label
, frag_now_fix ());
3381 if (*input_line_pointer
== ',')
3383 ++input_line_pointer
;
3388 val
.X_op
= O_constant
;
3389 val
.X_add_number
= 0;
3392 if ((val
.X_op
!= O_constant
3393 || val
.X_add_number
< - 0x80
3394 || val
.X_add_number
> 0xff
3395 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3396 && (now_seg
!= absolute_section
&& !in_bss ()))
3398 resolve_expression (&exp
);
3399 if (exp
.X_op
!= O_constant
)
3400 as_bad (_("unsupported variable size or fill value"));
3405 /* PR 20901: Check for excessive values.
3406 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3407 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3408 as_bad (_("size value for space directive too large: %lx"),
3409 (long) exp
.X_add_number
);
3414 bytes
= mult
* exp
.X_add_number
;
3416 for (i
= 0; i
< exp
.X_add_number
; i
++)
3417 emit_expr (&val
, mult
);
3423 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3424 resolve_expression (&exp
);
3426 if (exp
.X_op
== O_constant
)
3430 repeat
= exp
.X_add_number
;
3437 as_warn (_(".space repeat count is zero, ignored"));
3438 else if (repeat
< 0)
3439 as_warn (_(".space repeat count is negative, ignored"));
3443 /* If we are in the absolute section, just bump the offset. */
3444 if (now_seg
== absolute_section
)
3446 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3447 as_warn (_("ignoring fill value in absolute section"));
3448 abs_section_offset
+= repeat
;
3452 /* If we are secretly in an MRI common section, then
3453 creating space just increases the size of the common
3455 if (mri_common_symbol
!= NULL
)
3457 S_SET_VALUE (mri_common_symbol
,
3458 S_GET_VALUE (mri_common_symbol
) + repeat
);
3463 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3464 (offsetT
) repeat
, (char *) 0);
3468 if (now_seg
== absolute_section
)
3470 as_bad (_("space allocation too complex in absolute section"));
3471 subseg_set (text_section
, 0);
3474 if (mri_common_symbol
!= NULL
)
3476 as_bad (_("space allocation too complex in common section"));
3477 mri_common_symbol
= NULL
;
3481 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3482 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3485 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3486 as_warn (_("ignoring fill value in section `%s'"),
3487 segment_name (now_seg
));
3489 *p
= val
.X_add_number
;
3494 /* In MRI mode, after an odd number of bytes, we must align to an
3495 even word boundary, unless the next instruction is a dc.b, ds.b
3497 if (flag_mri
&& (bytes
& 1) != 0)
3498 mri_pending_align
= 1;
3500 demand_empty_rest_of_line ();
3503 mri_comment_end (stop
, stopc
);
3507 s_nop (int ignore ATTRIBUTE_UNUSED
)
3509 #ifdef md_flush_pending_output
3510 md_flush_pending_output ();
3513 #ifdef md_cons_align
3518 demand_empty_rest_of_line ();
3520 #ifdef md_emit_single_noop
3521 md_emit_single_noop
;
3525 #ifndef md_single_noop_insn
3526 #define md_single_noop_insn "nop"
3528 /* md_assemble might modify its argument, so
3529 we must pass it a string that is writeable. */
3530 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3531 as_fatal ("%s", xstrerror (errno
));
3539 s_nops (int ignore ATTRIBUTE_UNUSED
)
3544 #ifdef md_flush_pending_output
3545 md_flush_pending_output ();
3548 #ifdef md_cons_align
3554 /* Note - this expression is tested for an absolute value in
3555 write.c:relax_segment(). */
3558 if (*input_line_pointer
== ',')
3560 ++input_line_pointer
;
3565 val
.X_op
= O_constant
;
3566 val
.X_add_number
= 0;
3569 if (val
.X_op
!= O_constant
)
3571 as_bad (_("unsupported variable nop control in .nops directive"));
3572 val
.X_op
= O_constant
;
3573 val
.X_add_number
= 0;
3575 else if (val
.X_add_number
< 0)
3577 as_warn (_("negative nop control byte, ignored"));
3578 val
.X_add_number
= 0;
3581 demand_empty_rest_of_line ();
3584 /* Ignore this directive if we are going to perform a second pass. */
3587 /* Store the no-op instruction control byte in the first byte of frag. */
3589 symbolS
*sym
= make_expr_symbol (&exp
);
3590 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3591 sym
, (offsetT
) 0, (char *) 0);
3592 *p
= val
.X_add_number
;
3595 /* This is like s_space, but the value is a floating point number with
3596 the given precision. This is for the MRI dcb.s pseudo-op and
3600 s_float_space (int float_type
)
3604 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3608 #ifdef md_cons_align
3613 stop
= mri_comment_field (&stopc
);
3615 count
= get_absolute_expression ();
3618 if (*input_line_pointer
!= ',')
3620 as_bad (_("missing value"));
3621 ignore_rest_of_line ();
3623 mri_comment_end (stop
, stopc
);
3627 ++input_line_pointer
;
3631 /* Skip any 0{letter} that may be present. Don't even check if the
3632 * letter is legal. */
3633 if (input_line_pointer
[0] == '0'
3634 && ISALPHA (input_line_pointer
[1]))
3635 input_line_pointer
+= 2;
3637 /* Accept :xxxx, where the x's are hex digits, for a floating point
3638 with the exact digits specified. */
3639 if (input_line_pointer
[0] == ':')
3641 flen
= hex_float (float_type
, temp
);
3644 ignore_rest_of_line ();
3646 mri_comment_end (stop
, stopc
);
3654 err
= md_atof (float_type
, temp
, &flen
);
3655 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3656 know (err
!= NULL
|| flen
> 0);
3659 as_bad (_("bad floating literal: %s"), err
);
3660 ignore_rest_of_line ();
3662 mri_comment_end (stop
, stopc
);
3667 while (--count
>= 0)
3671 p
= frag_more (flen
);
3672 memcpy (p
, temp
, (unsigned int) flen
);
3675 demand_empty_rest_of_line ();
3678 mri_comment_end (stop
, stopc
);
3681 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3684 s_struct (int ignore ATTRIBUTE_UNUSED
)
3690 stop
= mri_comment_field (&stopc
);
3691 abs_section_offset
= get_absolute_expression ();
3692 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3693 /* The ELF backend needs to know that we are changing sections, so
3694 that .previous works correctly. */
3696 obj_elf_section_change_hook ();
3698 subseg_set (absolute_section
, 0);
3699 demand_empty_rest_of_line ();
3701 mri_comment_end (stop
, stopc
);
3705 s_text (int ignore ATTRIBUTE_UNUSED
)
3709 temp
= get_absolute_expression ();
3710 subseg_set (text_section
, (subsegT
) temp
);
3711 demand_empty_rest_of_line ();
3714 /* .weakref x, y sets x as an alias to y that, as long as y is not
3715 referenced directly, will cause y to become a weak symbol. */
3717 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3724 if ((name
= read_symbol_name ()) == NULL
)
3727 symbolP
= symbol_find_or_make (name
);
3729 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3731 if (!S_IS_VOLATILE (symbolP
))
3733 as_bad (_("symbol `%s' is already defined"), name
);
3736 symbolP
= symbol_clone (symbolP
, 1);
3737 S_CLEAR_VOLATILE (symbolP
);
3742 if (*input_line_pointer
!= ',')
3744 as_bad (_("expected comma after \"%s\""), name
);
3748 input_line_pointer
++;
3753 if ((name
= read_symbol_name ()) == NULL
)
3756 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3757 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3759 symbolP2
= symbol_find_or_make (name
);
3760 S_SET_WEAKREFD (symbolP2
);
3764 symbolS
*symp
= symbolP2
;
3766 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3768 expressionS
*expP
= symbol_get_value_expression (symp
);
3770 gas_assert (expP
->X_op
== O_symbol
3771 && expP
->X_add_number
== 0);
3772 symp
= expP
->X_add_symbol
;
3774 if (symp
== symbolP
)
3778 loop
= concat (S_GET_NAME (symbolP
),
3779 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3782 while (symp
!= symbolP
)
3784 char *old_loop
= loop
;
3786 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3787 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3788 (const char *) NULL
);
3792 as_bad (_("%s: would close weakref loop: %s"),
3793 S_GET_NAME (symbolP
), loop
);
3797 ignore_rest_of_line ();
3801 /* Short-circuiting instead of just checking here might speed
3802 things up a tiny little bit, but loop error messages would
3803 miss intermediate links. */
3804 /* symbolP2 = symp; */
3807 memset (&exp
, 0, sizeof (exp
));
3808 exp
.X_op
= O_symbol
;
3809 exp
.X_add_symbol
= symbolP2
;
3811 S_SET_SEGMENT (symbolP
, undefined_section
);
3812 symbol_set_value_expression (symbolP
, &exp
);
3813 symbol_set_frag (symbolP
, &zero_address_frag
);
3814 S_SET_WEAKREFR (symbolP
);
3816 demand_empty_rest_of_line ();
3821 ignore_rest_of_line ();
3827 /* Verify that we are at the end of a line. If not, issue an error and
3831 demand_empty_rest_of_line (void)
3834 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3835 input_line_pointer
++;
3838 if (ISPRINT (*input_line_pointer
))
3839 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3840 *input_line_pointer
);
3842 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3843 *input_line_pointer
);
3844 ignore_rest_of_line ();
3847 /* Return pointing just after end-of-line. */
3848 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3851 /* Silently advance to the end of line. Use this after already having
3852 issued an error about something bad. */
3855 ignore_rest_of_line (void)
3857 while (input_line_pointer
< buffer_limit
3858 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3859 input_line_pointer
++;
3861 input_line_pointer
++;
3863 /* Return pointing just after end-of-line. */
3864 if (input_line_pointer
<= buffer_limit
)
3865 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3868 /* Sets frag for given symbol to zero_address_frag, except when the
3869 symbol frag is already set to a dummy listing frag. */
3872 set_zero_frag (symbolS
*symbolP
)
3874 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3875 symbol_set_frag (symbolP
, &zero_address_frag
);
3878 /* In: Pointer to a symbol.
3879 Input_line_pointer->expression.
3881 Out: Input_line_pointer->just after any whitespace after expression.
3882 Tried to set symbol to value of expression.
3883 Will change symbols type, value, and frag; */
3886 pseudo_set (symbolS
*symbolP
)
3891 know (symbolP
); /* NULL pointer is logic error. */
3893 if (!S_IS_FORWARD_REF (symbolP
))
3894 (void) expression (&exp
);
3896 (void) deferred_expression (&exp
);
3898 if (exp
.X_op
== O_illegal
)
3899 as_bad (_("illegal expression"));
3900 else if (exp
.X_op
== O_absent
)
3901 as_bad (_("missing expression"));
3902 else if (exp
.X_op
== O_big
)
3904 if (exp
.X_add_number
> 0)
3905 as_bad (_("bignum invalid"));
3907 as_bad (_("floating point number invalid"));
3909 else if (exp
.X_op
== O_subtract
3910 && !S_IS_FORWARD_REF (symbolP
)
3911 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3912 && (symbol_get_frag (exp
.X_add_symbol
)
3913 == symbol_get_frag (exp
.X_op_symbol
)))
3915 exp
.X_op
= O_constant
;
3916 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3917 - S_GET_VALUE (exp
.X_op_symbol
));
3920 if (symbol_section_p (symbolP
))
3922 as_bad ("attempt to set value of section symbol");
3931 exp
.X_add_number
= 0;
3934 S_SET_SEGMENT (symbolP
, absolute_section
);
3935 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3936 set_zero_frag (symbolP
);
3940 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3941 if (S_IS_EXTERNAL (symbolP
))
3943 as_bad ("can't equate global symbol `%s' with register name",
3944 S_GET_NAME (symbolP
));
3948 S_SET_SEGMENT (symbolP
, reg_section
);
3949 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3950 set_zero_frag (symbolP
);
3951 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3955 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3956 /* For x=undef+const, create an expression symbol.
3957 For x=x+const, just update x except when x is an undefined symbol
3958 For x=defined+const, evaluate x. */
3959 if (symbolP
== exp
.X_add_symbol
3960 && (seg
!= undefined_section
3961 || !symbol_constant_p (symbolP
)))
3963 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3966 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3968 symbolS
*s
= exp
.X_add_symbol
;
3970 if (S_IS_COMMON (s
))
3971 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3972 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3974 S_SET_SEGMENT (symbolP
, seg
);
3975 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3976 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3977 copy_symbol_attributes (symbolP
, s
);
3980 S_SET_SEGMENT (symbolP
, undefined_section
);
3981 symbol_set_value_expression (symbolP
, &exp
);
3982 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3983 set_zero_frag (symbolP
);
3987 /* The value is some complex expression. */
3988 S_SET_SEGMENT (symbolP
, expr_section
);
3989 symbol_set_value_expression (symbolP
, &exp
);
3990 set_zero_frag (symbolP
);
3997 CONStruct more frag of .bytes, or .words etc.
3998 Should need_pass_2 be 1 then emit no frag(s).
3999 This understands EXPRESSIONS.
4003 This has a split personality. We use expression() to read the
4004 value. We can detect if the value won't fit in a byte or word.
4005 But we can't detect if expression() discarded significant digits
4006 in the case of a long. Not worth the crocks required to fix it. */
4008 /* Select a parser for cons expressions. */
4010 /* Some targets need to parse the expression in various fancy ways.
4011 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4012 (for example, the HPPA does this). Otherwise, you can define
4013 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4014 are defined, which is the normal case, then only simple expressions
4019 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4022 #ifndef TC_PARSE_CONS_EXPRESSION
4023 #ifdef REPEAT_CONS_EXPRESSIONS
4024 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4025 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4027 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4030 /* If we haven't gotten one yet, just call expression. */
4031 #ifndef TC_PARSE_CONS_EXPRESSION
4032 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4033 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4038 do_parse_cons_expression (expressionS
*exp
,
4039 int nbytes ATTRIBUTE_UNUSED
)
4041 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4045 /* Worker to do .byte etc statements.
4046 Clobbers input_line_pointer and checks end-of-line. */
4049 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4057 #ifdef md_flush_pending_output
4058 md_flush_pending_output ();
4062 stop
= mri_comment_field (&stopc
);
4064 if (is_it_end_of_statement ())
4066 demand_empty_rest_of_line ();
4068 mri_comment_end (stop
, stopc
);
4072 #ifdef TC_ADDRESS_BYTES
4074 nbytes
= TC_ADDRESS_BYTES ();
4077 #ifdef md_cons_align
4078 md_cons_align (nbytes
);
4084 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4085 #ifdef TC_CONS_FIX_CHECK
4086 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4088 if (*cur_fix
!= NULL
)
4089 cur_fix
= &(*cur_fix
)->fx_next
;
4094 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4099 if (*input_line_pointer
== '"')
4101 as_bad (_("unexpected `\"' in expression"));
4102 ignore_rest_of_line ();
4106 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4111 if (exp
.X_op
== O_symbol
)
4112 exp
.X_op
= O_symbol_rva
;
4114 as_fatal (_("rva without symbol"));
4116 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4117 #ifdef TC_CONS_FIX_CHECK
4118 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4122 while (*input_line_pointer
++ == ',');
4124 /* In MRI mode, after an odd number of bytes, we must align to an
4125 even word boundary, unless the next instruction is a dc.b, ds.b
4127 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4128 mri_pending_align
= 1;
4130 input_line_pointer
--; /* Put terminator back into stream. */
4132 demand_empty_rest_of_line ();
4135 mri_comment_end (stop
, stopc
);
4141 cons_worker (size
, 0);
4147 cons_worker (size
, 1);
4150 /* .reloc offset, reloc_name, symbol+addend. */
4153 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4160 struct reloc_list
*reloc
;
4161 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4162 static struct _bfd_rel bfd_relocs
[] =
4164 { "NONE", BFD_RELOC_NONE
},
4165 { "8", BFD_RELOC_8
},
4166 { "16", BFD_RELOC_16
},
4167 { "32", BFD_RELOC_32
},
4168 { "64", BFD_RELOC_64
}
4171 reloc
= XNEW (struct reloc_list
);
4174 stop
= mri_comment_field (&stopc
);
4183 as_bad (_("missing or bad offset expression"));
4186 exp
.X_add_symbol
= section_symbol (now_seg
);
4187 exp
.X_op
= O_symbol
;
4190 if (exp
.X_add_number
== 0)
4192 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4197 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4202 if (*input_line_pointer
!= ',')
4204 as_bad (_("missing reloc type"));
4208 ++input_line_pointer
;
4210 c
= get_symbol_name (& r_name
);
4211 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4215 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4216 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4218 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4219 bfd_relocs
[i
].code
);
4224 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4225 *input_line_pointer
= c
;
4226 if (reloc
->u
.a
.howto
== NULL
)
4228 as_bad (_("unrecognized reloc type"));
4232 exp
.X_op
= O_absent
;
4233 SKIP_WHITESPACE_AFTER_NAME ();
4234 if (*input_line_pointer
== ',')
4236 ++input_line_pointer
;
4244 as_bad (_("bad reloc expression"));
4246 ignore_rest_of_line ();
4249 mri_comment_end (stop
, stopc
);
4252 reloc
->u
.a
.sym
= NULL
;
4253 reloc
->u
.a
.addend
= 0;
4256 reloc
->u
.a
.sym
= NULL
;
4257 reloc
->u
.a
.addend
= exp
.X_add_number
;
4260 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4261 reloc
->u
.a
.addend
= exp
.X_add_number
;
4264 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4265 reloc
->u
.a
.addend
= 0;
4269 reloc
->file
= as_where (&reloc
->line
);
4270 reloc
->next
= reloc_list
;
4273 demand_empty_rest_of_line ();
4275 mri_comment_end (stop
, stopc
);
4278 /* Put the contents of expression EXP into the object file using
4279 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4282 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4284 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4288 emit_expr_with_reloc (expressionS
*exp
,
4289 unsigned int nbytes
,
4290 TC_PARSE_CONS_RETURN_TYPE reloc
)
4294 valueT extra_digit
= 0;
4296 /* Don't do anything if we are going to make another pass. */
4301 dot_value
= frag_now_fix ();
4302 dot_frag
= frag_now
;
4306 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4307 appear as a four byte positive constant in the .line section,
4308 followed by a 2 byte 0xffff. Look for that case here. */
4310 static int dwarf_line
= -1;
4312 if (strcmp (segment_name (now_seg
), ".line") != 0)
4314 else if (dwarf_line
>= 0
4316 && exp
->X_op
== O_constant
4317 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4318 listing_source_line ((unsigned int) dwarf_line
);
4319 else if (nbytes
== 4
4320 && exp
->X_op
== O_constant
4321 && exp
->X_add_number
>= 0)
4322 dwarf_line
= exp
->X_add_number
;
4327 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4328 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4329 AT_sibling (0x12) followed by a four byte address of the sibling
4330 followed by a 2 byte AT_name (0x38) followed by the name of the
4331 file. We look for that case here. */
4333 static int dwarf_file
= 0;
4335 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4337 else if (dwarf_file
== 0
4339 && exp
->X_op
== O_constant
4340 && exp
->X_add_number
== 0x11)
4342 else if (dwarf_file
== 1
4344 && exp
->X_op
== O_constant
4345 && exp
->X_add_number
== 0x12)
4347 else if (dwarf_file
== 2
4350 else if (dwarf_file
== 3
4352 && exp
->X_op
== O_constant
4353 && exp
->X_add_number
== 0x38)
4358 /* The variable dwarf_file_string tells stringer that the string
4359 may be the name of the source file. */
4360 if (dwarf_file
== 4)
4361 dwarf_file_string
= 1;
4363 dwarf_file_string
= 0;
4368 if (check_eh_frame (exp
, &nbytes
))
4373 /* Handle a negative bignum. */
4375 && exp
->X_add_number
== 0
4376 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4377 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4380 unsigned long carry
;
4382 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4384 /* Negate the bignum: one's complement each digit and add 1. */
4386 for (i
= 0; i
< exp
->X_add_number
; i
++)
4390 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4393 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4394 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4397 /* We can ignore any carry out, because it will be handled by
4398 extra_digit if it is needed. */
4400 extra_digit
= (valueT
) -1;
4404 if (op
== O_absent
|| op
== O_illegal
)
4406 as_warn (_("zero assumed for missing expression"));
4407 exp
->X_add_number
= 0;
4410 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4412 as_bad (_("floating point number invalid"));
4413 exp
->X_add_number
= 0;
4416 else if (op
== O_register
)
4418 as_warn (_("register value used as expression"));
4422 /* Allow `.word 0' in the absolute section. */
4423 if (now_seg
== absolute_section
)
4425 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4426 as_bad (_("attempt to store value in absolute section"));
4427 abs_section_offset
+= nbytes
;
4431 /* Allow `.word 0' in BSS style sections. */
4432 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4433 as_bad (_("attempt to store non-zero value in section `%s'"),
4434 segment_name (now_seg
));
4436 p
= frag_more ((int) nbytes
);
4438 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4440 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4444 #ifndef WORKING_DOT_WORD
4445 /* If we have the difference of two symbols in a word, save it on
4446 the broken_words list. See the code in write.c. */
4447 if (op
== O_subtract
&& nbytes
== 2)
4449 struct broken_word
*x
;
4451 x
= XNEW (struct broken_word
);
4452 x
->next_broken_word
= broken_words
;
4455 x
->subseg
= now_subseg
;
4457 x
->word_goes_here
= p
;
4459 x
->add
= exp
->X_add_symbol
;
4460 x
->sub
= exp
->X_op_symbol
;
4461 x
->addnum
= exp
->X_add_number
;
4469 /* If we have an integer, but the number of bytes is too large to
4470 pass to md_number_to_chars, handle it as a bignum. */
4471 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4473 extra_digit
= exp
->X_unsigned
? 0 : -1;
4474 convert_to_bignum (exp
, !exp
->X_unsigned
);
4478 if (op
== O_constant
)
4486 /* JF << of >= number of bits in the object is undefined. In
4487 particular SPARC (Sun 4) has problems. */
4488 if (nbytes
>= sizeof (valueT
))
4491 if (nbytes
> sizeof (valueT
))
4494 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4498 /* Don't store these bits. */
4499 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4500 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4503 unmask
= ~mask
; /* Do store these bits. */
4506 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4507 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4510 get
= exp
->X_add_number
;
4512 if ((get
& mask
) != 0
4513 && ((get
& mask
) != mask
4514 || (get
& hibit
) == 0))
4516 /* Leading bits contain both 0s & 1s. */
4517 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4519 as_warn (_("value 0x%llx truncated to 0x%llx"),
4520 (unsigned long long) get
, (unsigned long long) use
);
4522 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4523 (unsigned long long) get
, (unsigned long long) use
);
4526 as_warn (_("value 0x%lx truncated to 0x%lx"),
4527 (unsigned long) get
, (unsigned long) use
);
4530 /* Put bytes in right order. */
4531 md_number_to_chars (p
, use
, (int) nbytes
);
4533 else if (op
== O_big
)
4536 LITTLENUM_TYPE
*nums
;
4538 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4541 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4545 LITTLENUM_TYPE sign
= 0;
4546 if ((generic_bignum
[--i
]
4547 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4548 sign
= ~(LITTLENUM_TYPE
) 0;
4550 while (++i
< exp
->X_add_number
)
4551 if (generic_bignum
[i
] != sign
)
4554 else if (nbytes
== 1)
4556 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4557 Check that bits 8.. of generic_bignum[0] match bit 7
4558 and that they match all of generic_bignum[1..exp->X_add_number]. */
4559 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4560 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4562 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4564 while (++i
< exp
->X_add_number
)
4565 if (generic_bignum
[i
] != sign
)
4570 if (i
< exp
->X_add_number
)
4571 as_warn (ngettext ("bignum truncated to %d byte",
4572 "bignum truncated to %d bytes",
4580 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4583 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4585 if (target_big_endian
)
4587 while (nbytes
> size
)
4589 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4590 nbytes
-= CHARS_PER_LITTLENUM
;
4591 p
+= CHARS_PER_LITTLENUM
;
4594 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4595 while (size
>= CHARS_PER_LITTLENUM
)
4598 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4599 size
-= CHARS_PER_LITTLENUM
;
4600 p
+= CHARS_PER_LITTLENUM
;
4605 nums
= generic_bignum
;
4606 while (size
>= CHARS_PER_LITTLENUM
)
4608 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4610 size
-= CHARS_PER_LITTLENUM
;
4611 p
+= CHARS_PER_LITTLENUM
;
4612 nbytes
-= CHARS_PER_LITTLENUM
;
4615 while (nbytes
>= CHARS_PER_LITTLENUM
)
4617 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4618 nbytes
-= CHARS_PER_LITTLENUM
;
4619 p
+= CHARS_PER_LITTLENUM
;
4624 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4628 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4629 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4632 unsigned int size
= nbytes
;
4634 memset (p
, 0, size
);
4636 /* Generate a fixS to record the symbol value. */
4638 #ifdef TC_CONS_FIX_NEW
4639 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4641 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4643 reloc_howto_type
*reloc_howto
;
4645 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4646 size
= bfd_get_reloc_size (reloc_howto
);
4650 as_bad (ngettext ("%s relocations do not fit in %u byte",
4651 "%s relocations do not fit in %u bytes",
4653 reloc_howto
->name
, nbytes
);
4656 else if (target_big_endian
)
4657 offset
= nbytes
- size
;
4678 as_bad (_("unsupported BFD relocation size %u"), size
);
4681 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4686 /* Handle an MRI style string expression. */
4690 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4692 if (*input_line_pointer
!= '\''
4693 && (input_line_pointer
[1] != '\''
4694 || (*input_line_pointer
!= 'A'
4695 && *input_line_pointer
!= 'E')))
4696 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4700 unsigned int result
= 0;
4702 /* An MRI style string. Cut into as many bytes as will fit into
4703 a nbyte chunk, left justify if necessary, and separate with
4704 commas so we can try again later. */
4705 if (*input_line_pointer
== 'A')
4706 ++input_line_pointer
;
4707 else if (*input_line_pointer
== 'E')
4709 as_bad (_("EBCDIC constants are not supported"));
4710 ++input_line_pointer
;
4713 input_line_pointer
++;
4714 for (scan
= 0; scan
< nbytes
; scan
++)
4716 if (*input_line_pointer
== '\'')
4718 if (input_line_pointer
[1] == '\'')
4720 input_line_pointer
++;
4725 result
= (result
<< 8) | (*input_line_pointer
++);
4729 while (scan
< nbytes
)
4735 /* Create correct expression. */
4736 exp
->X_op
= O_constant
;
4737 exp
->X_add_number
= result
;
4739 /* Fake it so that we can read the next char too. */
4740 if (input_line_pointer
[0] != '\'' ||
4741 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4743 input_line_pointer
-= 2;
4744 input_line_pointer
[0] = ',';
4745 input_line_pointer
[1] = '\'';
4748 input_line_pointer
++;
4751 #endif /* TC_M68K */
4753 #ifdef REPEAT_CONS_EXPRESSIONS
4755 /* Parse a repeat expression for cons. This is used by the MIPS
4756 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4757 object file COUNT times.
4759 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4762 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4769 if (*input_line_pointer
!= ':')
4771 /* No repeat count. */
4775 ++input_line_pointer
;
4776 expression (&count
);
4777 if (count
.X_op
!= O_constant
4778 || count
.X_add_number
<= 0)
4780 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4784 /* The cons function is going to output this expression once. So we
4785 output it count - 1 times. */
4786 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4787 emit_expr (exp
, nbytes
);
4790 #endif /* REPEAT_CONS_EXPRESSIONS */
4792 /* Parse a floating point number represented as a hex constant. This
4793 permits users to specify the exact bits they want in the floating
4797 hex_float (int float_type
, char *bytes
)
4829 as_bad (_("unknown floating type type '%c'"), float_type
);
4833 /* It would be nice if we could go through expression to parse the
4834 hex constant, but if we get a bignum it's a pain to sort it into
4835 the buffer correctly. */
4837 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4841 /* The MRI assembler accepts arbitrary underscores strewn about
4842 through the hex constant, so we ignore them as well. */
4843 if (*input_line_pointer
== '_')
4845 ++input_line_pointer
;
4851 as_warn (_("floating point constant too large"));
4854 d
= hex_value (*input_line_pointer
) << 4;
4855 ++input_line_pointer
;
4856 while (*input_line_pointer
== '_')
4857 ++input_line_pointer
;
4858 if (hex_p (*input_line_pointer
))
4860 d
+= hex_value (*input_line_pointer
);
4861 ++input_line_pointer
;
4863 if (target_big_endian
)
4866 bytes
[length
- i
- 1] = d
;
4872 if (target_big_endian
)
4873 memset (bytes
+ i
, 0, length
- i
);
4875 memset (bytes
, 0, length
- i
);
4883 CONStruct some more frag chars of .floats .ffloats etc.
4884 Makes 0 or more new frags.
4885 If need_pass_2 == 1, no frags are emitted.
4886 This understands only floating literals, not expressions. Sorry.
4888 A floating constant is defined by atof_generic(), except it is preceded
4889 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4890 reading, I decided to be incompatible. This always tries to give you
4891 rounded bits to the precision of the pseudo-op. Former AS did premature
4892 truncation, restored noisy bits instead of trailing 0s AND gave you
4893 a choice of 2 flavours of noise according to which of 2 floating-point
4894 scanners you directed AS to use.
4896 In: input_line_pointer->whitespace before, or '0' of flonum. */
4899 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4900 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4903 int length
; /* Number of chars in an object. */
4904 const char *err
; /* Error from scanning floating literal. */
4905 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4907 if (is_it_end_of_statement ())
4909 demand_empty_rest_of_line ();
4913 if (now_seg
== absolute_section
)
4915 as_bad (_("attempt to store float in absolute section"));
4916 ignore_rest_of_line ();
4922 as_bad (_("attempt to store float in section `%s'"),
4923 segment_name (now_seg
));
4924 ignore_rest_of_line ();
4928 #ifdef md_flush_pending_output
4929 md_flush_pending_output ();
4932 #ifdef md_cons_align
4938 /* input_line_pointer->1st char of a flonum (we hope!). */
4941 /* Skip any 0{letter} that may be present. Don't even check if the
4942 letter is legal. Someone may invent a "z" format and this routine
4943 has no use for such information. Lusers beware: you get
4944 diagnostics if your input is ill-conditioned. */
4945 if (input_line_pointer
[0] == '0'
4946 && ISALPHA (input_line_pointer
[1]))
4947 input_line_pointer
+= 2;
4949 /* Accept :xxxx, where the x's are hex digits, for a floating
4950 point with the exact digits specified. */
4951 if (input_line_pointer
[0] == ':')
4953 ++input_line_pointer
;
4954 length
= hex_float (float_type
, temp
);
4957 ignore_rest_of_line ();
4963 err
= md_atof (float_type
, temp
, &length
);
4964 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4965 know (err
!= NULL
|| length
> 0);
4968 as_bad (_("bad floating literal: %s"), err
);
4969 ignore_rest_of_line ();
4980 #ifdef REPEAT_CONS_EXPRESSIONS
4981 if (*input_line_pointer
== ':')
4983 expressionS count_exp
;
4985 ++input_line_pointer
;
4986 expression (&count_exp
);
4988 if (count_exp
.X_op
!= O_constant
4989 || count_exp
.X_add_number
<= 0)
4990 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4992 count
= count_exp
.X_add_number
;
4996 while (--count
>= 0)
4998 p
= frag_more (length
);
4999 memcpy (p
, temp
, (unsigned int) length
);
5004 while (*input_line_pointer
++ == ',');
5006 /* Put terminator back into stream. */
5007 --input_line_pointer
;
5008 demand_empty_rest_of_line ();
5013 Note - we are using the DWARF standard's definition of LEB128 encoding
5014 where each 7-bit value is a stored in a byte, *not* an octet. This
5015 means that on targets where a byte contains multiple octets there is
5016 a *huge waste of space*. (This also means that we do not have to
5017 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5020 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5021 we would then have to consider whether multiple, successive LEB128
5022 values should be packed into the bytes without padding (bad idea) or
5023 whether each LEB128 number is padded out to a whole number of bytes.
5024 Plus you have to decide on the endianness of packing octets into a
5027 /* Return the size of a LEB128 value in bytes. */
5029 static inline unsigned int
5030 sizeof_sleb128 (offsetT value
)
5037 byte
= (value
& 0x7f);
5038 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5039 Fortunately, we can structure things so that the extra work reduces
5040 to a noop on systems that do things "properly". */
5041 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5044 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5045 || ((value
== -1) && ((byte
& 0x40) != 0))));
5050 static inline unsigned int
5051 sizeof_uleb128 (valueT value
)
5066 sizeof_leb128 (valueT value
, int sign
)
5069 return sizeof_sleb128 ((offsetT
) value
);
5071 return sizeof_uleb128 (value
);
5074 /* Output a LEB128 value. Returns the number of bytes used. */
5076 static inline unsigned int
5077 output_sleb128 (char *p
, offsetT value
)
5084 unsigned byte
= (value
& 0x7f);
5086 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5087 Fortunately, we can structure things so that the extra work reduces
5088 to a noop on systems that do things "properly". */
5089 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5091 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5092 || ((value
== -1) && ((byte
& 0x40) != 0))));
5103 static inline unsigned int
5104 output_uleb128 (char *p
, valueT value
)
5110 unsigned byte
= (value
& 0x7f);
5114 /* More bytes to follow. */
5125 output_leb128 (char *p
, valueT value
, int sign
)
5128 return output_sleb128 (p
, (offsetT
) value
);
5130 return output_uleb128 (p
, value
);
5133 /* Do the same for bignums. We combine sizeof with output here in that
5134 we don't output for NULL values of P. It isn't really as critical as
5135 for "normal" values that this be streamlined. Returns the number of
5138 static inline unsigned int
5139 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5146 /* Strip leading sign extensions off the bignum. */
5148 && bignum
[size
- 1] == LITTLENUM_MASK
5149 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5154 /* OR in the next part of the littlenum. */
5155 val
|= (*bignum
<< loaded
);
5156 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5160 /* Add bytes until there are less than 7 bits left in VAL
5161 or until every non-sign bit has been written. */
5168 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5175 while ((byte
& 0x80) != 0 && loaded
>= 7);
5179 /* Mop up any left-over bits (of which there will be less than 7). */
5180 if ((byte
& 0x80) != 0)
5182 /* Sign-extend VAL. */
5183 if (val
& (1 << (loaded
- 1)))
5184 val
|= ~0U << loaded
;
5193 static inline unsigned int
5194 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5201 /* Strip leading zeros off the bignum. */
5202 /* XXX: Is this needed? */
5203 while (size
> 0 && bignum
[size
- 1] == 0)
5208 if (loaded
< 7 && size
> 0)
5210 val
|= (*bignum
<< loaded
);
5211 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5220 if (size
> 0 || val
)
5227 while (byte
& 0x80);
5233 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5236 return output_big_sleb128 (p
, bignum
, size
);
5238 return output_big_uleb128 (p
, bignum
, size
);
5241 /* Generate the appropriate fragments for a given expression to emit a
5242 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5245 emit_leb128_expr (expressionS
*exp
, int sign
)
5247 operatorT op
= exp
->X_op
;
5248 unsigned int nbytes
;
5250 if (op
== O_absent
|| op
== O_illegal
)
5252 as_warn (_("zero assumed for missing expression"));
5253 exp
->X_add_number
= 0;
5256 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5258 as_bad (_("floating point number invalid"));
5259 exp
->X_add_number
= 0;
5262 else if (op
== O_register
)
5264 as_warn (_("register value used as expression"));
5267 else if (op
== O_constant
5269 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5271 /* We're outputting a signed leb128 and the sign of X_add_number
5272 doesn't reflect the sign of the original value. Convert EXP
5273 to a correctly-extended bignum instead. */
5274 convert_to_bignum (exp
, exp
->X_extrabit
);
5278 if (now_seg
== absolute_section
)
5280 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5281 as_bad (_("attempt to store value in absolute section"));
5282 abs_section_offset
++;
5286 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5287 as_bad (_("attempt to store non-zero value in section `%s'"),
5288 segment_name (now_seg
));
5290 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5291 a signal that this is leb128 data. It shouldn't optimize this away. */
5292 nbytes
= (unsigned int) -1;
5293 if (check_eh_frame (exp
, &nbytes
))
5296 /* Let the backend know that subsequent data may be byte aligned. */
5297 #ifdef md_cons_align
5301 if (op
== O_constant
)
5303 /* If we've got a constant, emit the thing directly right now. */
5305 valueT value
= exp
->X_add_number
;
5309 size
= sizeof_leb128 (value
, sign
);
5310 p
= frag_more (size
);
5311 if (output_leb128 (p
, value
, sign
) > size
)
5314 else if (op
== O_big
)
5316 /* O_big is a different sort of constant. */
5317 int nbr_digits
= exp
->X_add_number
;
5321 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5322 a signed number. Unary operators like - or ~ always extend the
5323 bignum to its largest size. */
5325 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5326 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5327 generic_bignum
[nbr_digits
++] = 0;
5329 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5330 p
= frag_more (size
);
5331 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5336 /* Otherwise, we have to create a variable sized fragment and
5337 resolve things later. */
5339 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5340 make_expr_symbol (exp
), 0, (char *) NULL
);
5344 /* Parse the .sleb128 and .uleb128 pseudos. */
5351 #ifdef md_flush_pending_output
5352 md_flush_pending_output ();
5358 emit_leb128_expr (&exp
, sign
);
5360 while (*input_line_pointer
++ == ',');
5362 input_line_pointer
--;
5363 demand_empty_rest_of_line ();
5367 stringer_append_char (int c
, int bitsize
)
5370 as_bad (_("attempt to store non-empty string in section `%s'"),
5371 segment_name (now_seg
));
5373 if (!target_big_endian
)
5374 FRAG_APPEND_1_CHAR (c
);
5379 FRAG_APPEND_1_CHAR (0);
5380 FRAG_APPEND_1_CHAR (0);
5381 FRAG_APPEND_1_CHAR (0);
5382 FRAG_APPEND_1_CHAR (0);
5385 FRAG_APPEND_1_CHAR (0);
5386 FRAG_APPEND_1_CHAR (0);
5389 FRAG_APPEND_1_CHAR (0);
5394 /* Called with invalid bitsize argument. */
5398 if (target_big_endian
)
5399 FRAG_APPEND_1_CHAR (c
);
5402 /* Worker to do .ascii etc statements.
5403 Reads 0 or more ',' separated, double-quoted strings.
5404 Caller should have checked need_pass_2 is FALSE because we don't
5406 Checks for end-of-line.
5407 BITS_APPENDZERO says how many bits are in a target char.
5408 The bottom bit is set if a NUL char should be appended to the strings. */
5411 stringer (int bits_appendzero
)
5413 const int bitsize
= bits_appendzero
& ~7;
5414 const int append_zero
= bits_appendzero
& 1;
5416 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5420 #ifdef md_flush_pending_output
5421 md_flush_pending_output ();
5424 #ifdef md_cons_align
5428 /* If we have been switched into the abs_section then we
5429 will not have an obstack onto which we can hang strings. */
5430 if (now_seg
== absolute_section
)
5432 as_bad (_("strings must be placed into a section"));
5433 ignore_rest_of_line ();
5437 /* The following awkward logic is to parse ZERO or more strings,
5438 comma separated. Recall a string expression includes spaces
5439 before the opening '\"' and spaces after the closing '\"'.
5440 We fake a leading ',' if there is (supposed to be)
5441 a 1st, expression. We keep demanding expressions for each ','. */
5442 if (is_it_end_of_statement ())
5444 c
= 0; /* Skip loop. */
5445 ++input_line_pointer
; /* Compensate for end of loop. */
5449 c
= ','; /* Do loop. */
5452 while (c
== ',' || c
== '<' || c
== '"')
5455 switch (*input_line_pointer
)
5458 ++input_line_pointer
; /*->1st char of string. */
5459 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5460 start
= input_line_pointer
;
5463 while (is_a_char (c
= next_char_of_string ()))
5464 stringer_append_char (c
, bitsize
);
5467 stringer_append_char (0, bitsize
);
5469 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5470 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5471 will emit .string with a filename in the .debug section
5472 after a sequence of constants. See the comment in
5473 emit_expr for the sequence. emit_expr will set
5474 dwarf_file_string to non-zero if this string might be a
5475 source file name. */
5476 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5477 dwarf_file_string
= 0;
5478 else if (dwarf_file_string
)
5480 c
= input_line_pointer
[-1];
5481 input_line_pointer
[-1] = '\0';
5482 listing_source_file (start
);
5483 input_line_pointer
[-1] = c
;
5489 input_line_pointer
++;
5490 c
= get_single_number ();
5491 stringer_append_char (c
, bitsize
);
5492 if (*input_line_pointer
!= '>')
5494 as_bad (_("expected <nn>"));
5495 ignore_rest_of_line ();
5498 input_line_pointer
++;
5501 input_line_pointer
++;
5505 c
= *input_line_pointer
;
5508 demand_empty_rest_of_line ();
5511 /* FIXME-SOMEDAY: I had trouble here on characters with the
5512 high bits set. We'll probably also have trouble with
5513 multibyte chars, wide chars, etc. Also be careful about
5514 returning values bigger than 1 byte. xoxorich. */
5517 next_char_of_string (void)
5521 c
= *input_line_pointer
++ & CHAR_MASK
;
5525 /* PR 20902: Do not advance past the end of the buffer. */
5526 -- input_line_pointer
;
5535 as_warn (_("unterminated string; newline inserted"));
5536 bump_line_counters ();
5540 if (!TC_STRING_ESCAPES
)
5542 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5570 break; /* As itself. */
5586 for (i
= 0, number
= 0;
5587 ISDIGIT (c
) && i
< 3;
5588 c
= *input_line_pointer
++, i
++)
5590 number
= number
* 8 + c
- '0';
5593 c
= number
& CHAR_MASK
;
5595 --input_line_pointer
;
5604 c
= *input_line_pointer
++;
5605 while (ISXDIGIT (c
))
5608 number
= number
* 16 + c
- '0';
5609 else if (ISUPPER (c
))
5610 number
= number
* 16 + c
- 'A' + 10;
5612 number
= number
* 16 + c
- 'a' + 10;
5613 c
= *input_line_pointer
++;
5615 c
= number
& CHAR_MASK
;
5616 --input_line_pointer
;
5621 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5622 as_warn (_("unterminated string; newline inserted"));
5624 bump_line_counters ();
5628 /* Do not advance past the end of the buffer. */
5629 -- input_line_pointer
;
5635 #ifdef ONLY_STANDARD_ESCAPES
5636 as_bad (_("bad escaped character in string"));
5638 #endif /* ONLY_STANDARD_ESCAPES */
5651 get_segmented_expression (expressionS
*expP
)
5655 retval
= expression (expP
);
5656 if (expP
->X_op
== O_illegal
5657 || expP
->X_op
== O_absent
5658 || expP
->X_op
== O_big
)
5660 as_bad (_("expected address expression"));
5661 expP
->X_op
= O_constant
;
5662 expP
->X_add_number
= 0;
5663 retval
= absolute_section
;
5669 get_known_segmented_expression (expressionS
*expP
)
5671 segT retval
= get_segmented_expression (expP
);
5673 if (retval
== undefined_section
)
5675 /* There is no easy way to extract the undefined symbol from the
5677 if (expP
->X_add_symbol
!= NULL
5678 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5679 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5680 S_GET_NAME (expP
->X_add_symbol
));
5682 as_warn (_("some symbol undefined; zero assumed"));
5683 retval
= absolute_section
;
5684 expP
->X_op
= O_constant
;
5685 expP
->X_add_number
= 0;
5690 char /* Return terminator. */
5691 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5693 /* FIXME: val_pointer should probably be offsetT *. */
5694 *val_pointer
= (long) get_absolute_expression ();
5695 return (*input_line_pointer
++);
5698 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5699 Give a warning if that happens. */
5702 demand_copy_C_string (int *len_pointer
)
5706 if ((s
= demand_copy_string (len_pointer
)) != 0)
5710 for (len
= *len_pointer
; len
> 0; len
--)
5717 as_bad (_("this string may not contain \'\\0\'"));
5725 /* Demand string, but return a safe (=private) copy of the string.
5726 Return NULL if we can't read a string here. */
5729 demand_copy_string (int *lenP
)
5737 if (*input_line_pointer
== '\"')
5739 input_line_pointer
++; /* Skip opening quote. */
5741 while (is_a_char (c
= next_char_of_string ()))
5743 obstack_1grow (¬es
, c
);
5746 /* JF this next line is so demand_copy_C_string will return a
5747 null terminated string. */
5748 obstack_1grow (¬es
, '\0');
5749 retval
= (char *) obstack_finish (¬es
);
5753 as_bad (_("missing string"));
5755 ignore_rest_of_line ();
5761 /* In: Input_line_pointer->next character.
5763 Do: Skip input_line_pointer over all whitespace.
5765 Out: 1 if input_line_pointer->end-of-line. */
5768 is_it_end_of_statement (void)
5771 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5775 equals (char *sym_name
, int reassign
)
5780 input_line_pointer
++;
5781 if (*input_line_pointer
== '=')
5782 input_line_pointer
++;
5783 if (reassign
< 0 && *input_line_pointer
== '=')
5784 input_line_pointer
++;
5786 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5787 input_line_pointer
++;
5790 stop
= mri_comment_field (&stopc
);
5792 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5796 demand_empty_rest_of_line ();
5797 mri_comment_end (stop
, stopc
);
5801 /* .incbin -- include a file verbatim at the current location. */
5804 s_incbin (int x ATTRIBUTE_UNUSED
)
5815 #ifdef md_flush_pending_output
5816 md_flush_pending_output ();
5819 #ifdef md_cons_align
5824 filename
= demand_copy_string (& len
);
5825 if (filename
== NULL
)
5830 /* Look for optional skip and count. */
5831 if (* input_line_pointer
== ',')
5833 ++ input_line_pointer
;
5834 skip
= get_absolute_expression ();
5838 if (* input_line_pointer
== ',')
5840 ++ input_line_pointer
;
5842 count
= get_absolute_expression ();
5844 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5850 demand_empty_rest_of_line ();
5852 /* Try opening absolute path first, then try include dirs. */
5853 binfile
= fopen (filename
, FOPEN_RB
);
5854 if (binfile
== NULL
)
5858 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5860 for (i
= 0; i
< include_dir_count
; i
++)
5862 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5864 binfile
= fopen (path
, FOPEN_RB
);
5865 if (binfile
!= NULL
)
5869 if (binfile
== NULL
)
5870 as_bad (_("file not found: %s"), filename
);
5873 path
= xstrdup (filename
);
5879 register_dependency (path
);
5881 /* Compute the length of the file. */
5882 if (fseek (binfile
, 0, SEEK_END
) != 0)
5884 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5887 file_len
= ftell (binfile
);
5889 /* If a count was not specified use the remainder of the file. */
5891 count
= file_len
- skip
;
5893 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5895 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5896 skip
, count
, file_len
);
5900 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5902 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5906 /* Allocate frag space and store file contents in it. */
5907 binfrag
= frag_more (count
);
5909 bytes
= fread (binfrag
, 1, count
, binfile
);
5911 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5912 path
, bytes
, count
);
5915 if (binfile
!= NULL
)
5920 /* .include -- include a file at this point. */
5923 s_include (int arg ATTRIBUTE_UNUSED
)
5932 filename
= demand_copy_string (&i
);
5933 if (filename
== NULL
)
5935 /* demand_copy_string has already printed an error and
5936 called ignore_rest_of_line. */
5944 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5945 && *input_line_pointer
!= ' '
5946 && *input_line_pointer
!= '\t')
5948 obstack_1grow (¬es
, *input_line_pointer
);
5949 ++input_line_pointer
;
5953 obstack_1grow (¬es
, '\0');
5954 filename
= (char *) obstack_finish (¬es
);
5955 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5956 ++input_line_pointer
;
5959 demand_empty_rest_of_line ();
5960 path
= XNEWVEC (char, (unsigned long) i
5961 + include_dir_maxlen
+ 5 /* slop */ );
5963 for (i
= 0; i
< include_dir_count
; i
++)
5965 strcpy (path
, include_dirs
[i
]);
5967 strcat (path
, filename
);
5968 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5978 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5979 register_dependency (path
);
5980 input_scrub_insert_file (path
);
5984 add_include_dir (char *path
)
5988 if (include_dir_count
== 0)
5990 include_dirs
= XNEWVEC (const char *, 2);
5991 include_dirs
[0] = "."; /* Current dir. */
5992 include_dir_count
= 2;
5996 include_dir_count
++;
5997 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6001 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6004 if (i
> include_dir_maxlen
)
6005 include_dir_maxlen
= i
;
6008 /* Output debugging information to denote the source file. */
6011 generate_file_debug (void)
6013 if (debug_type
== DEBUG_STABS
)
6014 stabs_generate_asm_file ();
6017 /* Output line number debugging information for the current source line. */
6020 generate_lineno_debug (void)
6024 case DEBUG_UNSPECIFIED
:
6029 stabs_generate_asm_lineno ();
6032 ecoff_generate_asm_lineno ();
6035 /* ??? We could here indicate to dwarf2dbg.c that something
6036 has changed. However, since there is additional backend
6037 support that is required (calling dwarf2_emit_insn), we
6038 let dwarf2dbg.c call as_where on its own. */
6043 /* Output debugging information to mark a function entry point or end point.
6044 END_P is zero for .func, and non-zero for .endfunc. */
6049 do_s_func (end_p
, NULL
);
6052 /* Subroutine of s_func so targets can choose a different default prefix.
6053 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6056 do_s_func (int end_p
, const char *default_prefix
)
6058 /* Record the current function so that we can issue an error message for
6059 misplaced .func,.endfunc, and also so that .endfunc needs no
6061 static char *current_name
;
6062 static char *current_label
;
6066 if (current_name
== NULL
)
6068 as_bad (_("missing .func"));
6069 ignore_rest_of_line ();
6073 if (debug_type
== DEBUG_STABS
)
6074 stabs_generate_asm_endfunc (current_name
, current_label
);
6076 current_name
= current_label
= NULL
;
6081 char delim1
, delim2
;
6083 if (current_name
!= NULL
)
6085 as_bad (_(".endfunc missing for previous .func"));
6086 ignore_rest_of_line ();
6090 delim1
= get_symbol_name (& name
);
6091 name
= xstrdup (name
);
6092 *input_line_pointer
= delim1
;
6093 SKIP_WHITESPACE_AFTER_NAME ();
6094 if (*input_line_pointer
!= ',')
6098 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6099 as_fatal ("%s", xstrerror (errno
));
6103 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6104 /* Missing entry point, use function's name with the leading
6108 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6109 as_fatal ("%s", xstrerror (errno
));
6117 ++input_line_pointer
;
6119 delim2
= get_symbol_name (& label
);
6120 label
= xstrdup (label
);
6121 restore_line_pointer (delim2
);
6124 if (debug_type
== DEBUG_STABS
)
6125 stabs_generate_asm_func (name
, label
);
6127 current_name
= name
;
6128 current_label
= label
;
6131 demand_empty_rest_of_line ();
6134 #ifdef HANDLE_BUNDLE
6137 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6139 unsigned int align
= get_absolute_expression ();
6141 demand_empty_rest_of_line ();
6143 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6144 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6145 (unsigned int) TC_ALIGN_LIMIT
);
6147 if (bundle_lock_frag
!= NULL
)
6149 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6153 bundle_align_p2
= align
;
6157 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6159 demand_empty_rest_of_line ();
6161 if (bundle_align_p2
== 0)
6163 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6167 if (bundle_lock_depth
== 0)
6169 bundle_lock_frchain
= frchain_now
;
6170 bundle_lock_frag
= start_bundle ();
6172 ++bundle_lock_depth
;
6176 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6180 demand_empty_rest_of_line ();
6182 if (bundle_lock_frag
== NULL
)
6184 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6188 gas_assert (bundle_align_p2
> 0);
6190 gas_assert (bundle_lock_depth
> 0);
6191 if (--bundle_lock_depth
> 0)
6194 size
= pending_bundle_size (bundle_lock_frag
);
6196 if (size
> 1U << bundle_align_p2
)
6197 as_bad (_(".bundle_lock sequence is %u bytes, "
6198 "but bundle size is only %u bytes"),
6199 size
, 1u << bundle_align_p2
);
6201 finish_bundle (bundle_lock_frag
, size
);
6203 bundle_lock_frag
= NULL
;
6204 bundle_lock_frchain
= NULL
;
6207 #endif /* HANDLE_BUNDLE */
6210 s_ignore (int arg ATTRIBUTE_UNUSED
)
6212 ignore_rest_of_line ();
6216 read_print_statistics (FILE *file
)
6218 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6221 /* Inserts the given line into the input stream.
6223 This call avoids macro/conditionals nesting checking, since the contents of
6224 the line are assumed to replace the contents of a line already scanned.
6226 An appropriate use of this function would be substitution of input lines when
6227 called by md_start_line_hook(). The given line is assumed to already be
6228 properly scrubbed. */
6231 input_scrub_insert_line (const char *line
)
6234 size_t len
= strlen (line
);
6235 sb_build (&newline
, len
);
6236 sb_add_buffer (&newline
, line
, len
);
6237 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6239 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6242 /* Insert a file into the input stream; the path must resolve to an actual
6243 file; no include path searching or dependency registering is performed. */
6246 input_scrub_insert_file (char *path
)
6248 input_scrub_include_file (path
, input_line_pointer
);
6249 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6252 /* Find the end of a line, considering quotation and escaping of quotes. */
6254 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6255 # define TC_SINGLE_QUOTE_STRINGS 1
6259 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6262 char inquote
= '\0';
6265 while (!is_end_of_line
[(unsigned char) *s
]
6266 || (inquote
&& !ISCNTRL (*s
))
6267 || (inquote
== '\'' && flag_mri
)
6268 #ifdef TC_EOL_IN_INSN
6269 || (insn
&& TC_EOL_IN_INSN (s
))
6271 /* PR 6926: When we are parsing the body of a macro the sequence
6272 \@ is special - it refers to the invocation count. If the @
6273 character happens to be registered as a line-separator character
6274 by the target, then the is_end_of_line[] test above will have
6275 returned true, but we need to ignore the line separating
6276 semantics in this particular case. */
6277 || (in_macro
&& inescape
&& *s
== '@')
6280 if (mri_string
&& *s
== '\'')
6284 else if (*s
== '\\')
6288 #ifdef TC_SINGLE_QUOTE_STRINGS
6289 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6296 as_warn (_("missing closing `%c'"), inquote
);
6297 if (inescape
&& !ignore_input ())
6298 as_warn (_("stray `\\'"));
6303 find_end_of_line (char *s
, int mri_string
)
6305 return _find_end_of_line (s
, mri_string
, 0, 0);
6308 static char *saved_ilp
= NULL
;
6309 static char *saved_limit
;
6311 /* Use BUF as a temporary input pointer for calling other functions in this
6312 file. BUF must be a C string, so that its end can be found by strlen.
6313 Also sets the buffer_limit variable (local to this file) so that buffer
6314 overruns should not occur. Saves the current input line pointer so that
6315 it can be restored by calling restore_ilp().
6317 Does not support recursion. */
6320 temp_ilp (char *buf
)
6322 gas_assert (saved_ilp
== NULL
);
6323 gas_assert (buf
!= NULL
);
6325 saved_ilp
= input_line_pointer
;
6326 saved_limit
= buffer_limit
;
6327 /* Prevent the assert in restore_ilp from triggering if
6328 the input_line_pointer has not yet been initialised. */
6329 if (saved_ilp
== NULL
)
6330 saved_limit
= saved_ilp
= (char *) "";
6332 input_line_pointer
= buf
;
6333 buffer_limit
= buf
+ strlen (buf
);
6334 input_from_string
= TRUE
;
6337 /* Restore a saved input line pointer. */
6342 gas_assert (saved_ilp
!= NULL
);
6344 input_line_pointer
= saved_ilp
;
6345 buffer_limit
= saved_limit
;
6346 input_from_string
= FALSE
;