1 /* read.c - read a source file -
2 Copyright (C) 1986-2022 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer
; /*->next char of source file to parse. */
67 bool input_from_string
= false;
69 #if BITS_PER_CHAR != 8
70 /* The following table is indexed by[(char)] and will break if
71 a char does not have exactly 256 states (hopefully 0:255!)! */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The Delta 68k assembler permits ~ at start of label names. */
109 /* Used by is_... macros. our ctype[]. */
110 char lex_type
[256] = {
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
113 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
115 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
117 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
130 Out: 1 if this character ends a line.
131 2 if this character is a line separator. */
132 char is_end_of_line
[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string
[128];
159 /* Functions private to this file. */
161 static char *buffer
; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit
; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
172 const char **include_dirs
;
174 /* How many are in the table. */
175 int include_dir_count
;
177 /* Length of longest in table. */
178 int include_dir_maxlen
= 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string
;
214 /* If the target defines the md_frag_max_var hook then we know
215 enough to implement the .bundle_align_mode features. */
216 #ifdef md_frag_max_var
217 # define HANDLE_BUNDLE
221 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
222 it's the exponent of the bundle size, and aligned instruction bundle
223 mode is in effect. */
224 static unsigned int bundle_align_p2
;
226 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
227 bundle_lock_frag to frag_now and then starts a new frag with
228 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
229 so that .bundle_unlock can verify that we didn't change segments.
230 .bundle_unlock resets both to NULL. If we detect a bundling violation,
231 then we reset bundle_lock_frchain to NULL as an indicator that we've
232 already diagnosed the error with as_bad and don't need a cascade of
233 redundant errors, but bundle_lock_frag remains set to indicate that
234 we are expecting to see .bundle_unlock. */
235 static fragS
*bundle_lock_frag
;
236 static frchainS
*bundle_lock_frchain
;
238 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
240 static unsigned int bundle_lock_depth
;
243 static void do_s_func (int end_p
, const char *default_prefix
);
244 static void s_align (int, int);
245 static void s_altmacro (int);
246 static void s_bad_end (int);
247 static void s_reloc (int);
248 static int hex_float (int, char *);
249 static segT
get_known_segmented_expression (expressionS
* expP
);
250 static void pobegin (void);
251 static size_t get_non_macro_line_sb (sb
*);
252 static void generate_file_debug (void);
253 static char *_find_end_of_line (char *, int, int, int);
261 obj_read_begin_hook ();
263 /* Something close -- but not too close -- to a multiple of 1024.
264 The debugging malloc I'm using has 24 bytes of overhead. */
265 obstack_begin (¬es
, chunksize
);
266 obstack_begin (&cond_obstack
, chunksize
);
268 #ifndef tc_line_separator_chars
269 #define tc_line_separator_chars line_separator_chars
271 /* Use machine dependent syntax. */
272 for (p
= tc_line_separator_chars
; *p
; p
++)
273 is_end_of_line
[(unsigned char) *p
] = 2;
274 /* Use more. FIXME-SOMEDAY. */
280 #ifndef TC_ADDRESS_BYTES
281 #define TC_ADDRESS_BYTES address_bytes
286 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
287 contain an address. */
288 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
296 /* Set up pseudo-op tables. */
300 const char *poc_name
;
302 const pseudo_typeS
*pop
;
305 typedef struct po_entry po_entry_t
;
307 /* Hash function for a po_entry. */
310 hash_po_entry (const void *e
)
312 const po_entry_t
*entry
= (const po_entry_t
*) e
;
313 return htab_hash_string (entry
->poc_name
);
316 /* Equality function for a po_entry. */
319 eq_po_entry (const void *a
, const void *b
)
321 const po_entry_t
*ea
= (const po_entry_t
*) a
;
322 const po_entry_t
*eb
= (const po_entry_t
*) b
;
324 return strcmp (ea
->poc_name
, eb
->poc_name
) == 0;
328 po_entry_alloc (const char *poc_name
, const pseudo_typeS
*pop
)
330 po_entry_t
*entry
= XNEW (po_entry_t
);
331 entry
->poc_name
= poc_name
;
336 static const pseudo_typeS
*
337 po_entry_find (htab_t table
, const char *poc_name
)
339 po_entry_t needle
= { poc_name
, NULL
};
340 po_entry_t
*entry
= htab_find (table
, &needle
);
341 return entry
!= NULL
? entry
->pop
: NULL
;
344 static struct htab
*po_hash
;
346 static const pseudo_typeS potable
[] = {
347 {"abort", s_abort
, 0},
348 {"align", s_align_ptwo
, 0},
349 {"altmacro", s_altmacro
, 1},
350 {"ascii", stringer
, 8+0},
351 {"asciz", stringer
, 8+1},
352 {"balign", s_align_bytes
, 0},
353 {"balignw", s_align_bytes
, -2},
354 {"balignl", s_align_bytes
, -4},
357 {"bundle_align_mode", s_bundle_align_mode
, 0},
358 {"bundle_lock", s_bundle_lock
, 0},
359 {"bundle_unlock", s_bundle_unlock
, 0},
363 {"common", s_mri_common
, 0},
364 {"common.s", s_mri_common
, 1},
369 {"dc.d", float_cons
, 'd'},
371 {"dc.s", float_cons
, 'f'},
373 {"dc.x", float_cons
, 'x'},
375 {"dcb.b", s_space
, 1},
376 {"dcb.d", s_float_space
, 'd'},
377 {"dcb.l", s_space
, 4},
378 {"dcb.s", s_float_space
, 'f'},
379 {"dcb.w", s_space
, 2},
380 {"dcb.x", s_float_space
, 'x'},
382 {"ds.b", s_space
, 1},
383 {"ds.d", s_space
, 8},
384 {"ds.l", s_space
, 4},
385 {"ds.p", s_space
, 'p'},
386 {"ds.s", s_space
, 4},
387 {"ds.w", s_space
, 2},
388 {"ds.x", s_space
, 'x'},
389 {"debug", s_ignore
, 0},
394 {"double", float_cons
, 'd'},
396 {"eject", listing_eject
, 0}, /* Formfeed listing. */
398 {"elsec", s_else
, 0},
399 {"elseif", s_elseif
, (int) O_ne
},
401 {"endc", s_endif
, 0},
402 {"endfunc", s_func
, 1},
403 {"endif", s_endif
, 0},
404 {"endm", s_bad_end
, 0},
405 {"endr", s_bad_end
, 1},
411 {"error", s_errwarn
, 1},
412 {"exitm", s_mexit
, 0},
414 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
415 {"appfile", s_app_file
, 1},
416 {"appline", s_app_line
, 1},
418 {"file", s_app_file
, 0},
420 {"float", float_cons
, 'f'},
421 {"format", s_ignore
, 0},
423 {"global", s_globl
, 0},
424 {"globl", s_globl
, 0},
426 {"if", s_if
, (int) O_ne
},
429 {"ifdef", s_ifdef
, 0},
430 {"ifeq", s_if
, (int) O_eq
},
431 {"ifeqs", s_ifeqs
, 0},
432 {"ifge", s_if
, (int) O_ge
},
433 {"ifgt", s_if
, (int) O_gt
},
434 {"ifle", s_if
, (int) O_le
},
435 {"iflt", s_if
, (int) O_lt
},
438 {"ifndef", s_ifdef
, 1},
439 {"ifne", s_if
, (int) O_ne
},
440 {"ifnes", s_ifeqs
, 1},
441 {"ifnotdef", s_ifdef
, 1},
442 {"incbin", s_incbin
, 0},
443 {"include", s_include
, 0},
449 {"lcomm", s_lcomm
, 0},
450 {"lflags", s_ignore
, 0}, /* Listing flags. */
451 {"linefile", s_app_line
, 0},
452 {"linkonce", s_linkonce
, 0},
453 {"list", listing_list
, 1}, /* Turn listing on. */
454 {"llen", listing_psize
, 1},
457 {"macro", s_macro
, 0},
458 {"mexit", s_mexit
, 0},
460 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
461 {"name", s_ignore
, 0},
462 {"noaltmacro", s_altmacro
, 0},
463 {"noformat", s_ignore
, 0},
464 {"nolist", listing_list
, 0}, /* Turn listing off. */
465 {"nopage", listing_nopage
, 0},
469 {"offset", s_struct
, 0},
471 {"p2align", s_align_ptwo
, 0},
472 {"p2alignw", s_align_ptwo
, -2},
473 {"p2alignl", s_align_ptwo
, -4},
474 {"page", listing_eject
, 0},
475 {"plen", listing_psize
, 0},
476 {"print", s_print
, 0},
477 {"psize", listing_psize
, 0}, /* Set paper size. */
478 {"purgem", s_purgem
, 0},
480 {"reloc", s_reloc
, 0},
484 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
489 {"single", float_cons
, 'f'},
491 {"space", s_space
, 0},
492 {"skip", s_space
, 0},
493 {"sleb128", s_leb128
, 1},
494 {"spc", s_ignore
, 0},
495 {"stabd", s_stab
, 'd'},
496 {"stabn", s_stab
, 'n'},
497 {"stabs", s_stab
, 's'},
498 {"string", stringer
, 8+1},
499 {"string8", stringer
, 8+1},
500 {"string16", stringer
, 16+1},
501 {"string32", stringer
, 32+1},
502 {"string64", stringer
, 64+1},
503 {"struct", s_struct
, 0},
507 /* This is for gcc to use. It's only just been added (2/94), so gcc
508 won't be able to use it for a while -- probably a year or more.
509 But once this has been released, check with gcc maintainers
510 before deleting it or even changing the spelling. */
511 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
512 /* If we're folding case -- done for some targets, not necessarily
513 all -- the above string in an input file will be converted to
514 this one. Match it either way... */
515 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
517 {"title", listing_title
, 0}, /* Listing title. */
518 {"ttl", listing_title
, 0},
520 {"uleb128", s_leb128
, 0},
524 {"xdef", s_globl
, 0},
525 {"xref", s_ignore
, 0},
526 {"xstabs", s_xstab
, 's'},
527 {"warning", s_errwarn
, 0},
528 {"weakref", s_weakref
, 0},
530 {"zero", s_space
, 0},
534 {NULL
, NULL
, 0} /* End sentinel. */
538 get_absolute_expr (expressionS
*exp
)
540 expression_and_evaluate (exp
);
542 if (exp
->X_op
!= O_constant
)
544 if (exp
->X_op
!= O_absent
)
545 as_bad (_("bad or irreducible absolute expression"));
546 exp
->X_add_number
= 0;
548 return exp
->X_add_number
;
552 get_absolute_expression (void)
556 return get_absolute_expr (&exp
);
559 static int pop_override_ok
= 0;
560 static const char *pop_table_name
;
563 pop_insert (const pseudo_typeS
*table
)
565 const pseudo_typeS
*pop
;
566 for (pop
= table
; pop
->poc_name
; pop
++)
568 po_entry_t
*elt
= po_entry_alloc (pop
->poc_name
, pop
);
569 if (htab_insert (po_hash
, elt
, 0) != NULL
)
572 if (!pop_override_ok
)
573 as_fatal (_("error constructing %s pseudo-op table"),
579 #ifndef md_pop_insert
580 #define md_pop_insert() pop_insert(md_pseudo_table)
583 #ifndef obj_pop_insert
584 #define obj_pop_insert() pop_insert(obj_pseudo_table)
587 #ifndef cfi_pop_insert
588 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
594 po_hash
= htab_create_alloc (16, hash_po_entry
, eq_po_entry
, NULL
,
597 /* Do the target-specific pseudo ops. */
598 pop_table_name
= "md";
601 /* Now object specific. Skip any that were in the target table. */
602 pop_table_name
= "obj";
606 /* Now portable ones. Skip any that we've seen already. */
607 pop_table_name
= "standard";
608 pop_insert (potable
);
611 pop_table_name
= "cfi";
616 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
617 if (ignore_input ()) \
619 char *eol = find_end_of_line (input_line_pointer - (num_read), \
621 input_line_pointer = (input_line_pointer <= buffer_limit \
622 && eol >= buffer_limit) \
628 /* This function is used when scrubbing the characters between #APP
631 static char *scrub_string
;
632 static char *scrub_string_end
;
635 scrub_from_string (char *buf
, size_t buflen
)
639 copy
= scrub_string_end
- scrub_string
;
642 memcpy (buf
, scrub_string
, copy
);
643 scrub_string
+= copy
;
647 /* Helper function of read_a_source_file, which tries to expand a macro. */
649 try_macro (char term
, const char *line
)
655 if (check_macro (line
, &out
, &err
, ¯o
))
659 *input_line_pointer
++ = term
;
660 input_scrub_include_sb (&out
,
661 input_line_pointer
, 1);
664 input_scrub_next_buffer (&input_line_pointer
);
666 md_macro_info (macro
);
674 /* Start a new instruction bundle. Returns the rs_align_code frag that
675 will be used to align the new bundle. */
679 fragS
*frag
= frag_now
;
681 frag_align_code (0, 0);
683 while (frag
->fr_type
!= rs_align_code
)
684 frag
= frag
->fr_next
;
686 gas_assert (frag
!= frag_now
);
691 /* Calculate the maximum size after relaxation of the region starting
692 at the given frag and extending through frag_now (which is unfinished). */
694 pending_bundle_size (fragS
*frag
)
696 unsigned int offset
= frag
->fr_fix
;
697 unsigned int size
= 0;
699 gas_assert (frag
!= frag_now
);
700 gas_assert (frag
->fr_type
== rs_align_code
);
702 while (frag
!= frag_now
)
704 /* This should only happen in what will later become an error case. */
708 size
+= frag
->fr_fix
;
709 if (frag
->fr_type
== rs_machine_dependent
)
710 size
+= md_frag_max_var (frag
);
712 frag
= frag
->fr_next
;
715 gas_assert (frag
== frag_now
);
716 size
+= frag_now_fix ();
717 if (frag
->fr_type
== rs_machine_dependent
)
718 size
+= md_frag_max_var (frag
);
720 gas_assert (size
>= offset
);
722 return size
- offset
;
725 /* Finish off the frag created to ensure bundle alignment. */
727 finish_bundle (fragS
*frag
, unsigned int size
)
729 gas_assert (bundle_align_p2
> 0);
730 gas_assert (frag
->fr_type
== rs_align_code
);
734 /* If there is more than a single byte, then we need to set up the
735 alignment frag. Otherwise we leave it at its initial state from
736 calling frag_align_code (0, 0), so that it does nothing. */
737 frag
->fr_offset
= bundle_align_p2
;
738 frag
->fr_subtype
= size
- 1;
741 /* We do this every time rather than just in s_bundle_align_mode
742 so that we catch any affected section without needing hooks all
743 over for all paths that do section changes. It's cheap enough. */
744 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
745 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
748 /* Assemble one instruction. This takes care of the bundle features
749 around calling md_assemble. */
751 assemble_one (char *line
)
753 fragS
*insn_start_frag
= NULL
;
755 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
757 as_bad (_("cannot change section or subsection inside .bundle_lock"));
758 /* Clearing this serves as a marker that we have already complained. */
759 bundle_lock_frchain
= NULL
;
762 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
763 insn_start_frag
= start_bundle ();
767 if (bundle_lock_frchain
!= NULL
)
769 /* Make sure this hasn't pushed the locked sequence
770 past the bundle size. */
771 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
772 if (bundle_size
> 1U << bundle_align_p2
)
773 as_bad (_ (".bundle_lock sequence at %u bytes, "
774 "but .bundle_align_mode limit is %u bytes"),
775 bundle_size
, 1U << bundle_align_p2
);
777 else if (bundle_align_p2
> 0)
779 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
781 if (insn_size
> 1U << bundle_align_p2
)
782 as_bad (_("single instruction is %u bytes long, "
783 "but .bundle_align_mode limit is %u bytes"),
784 insn_size
, 1U << bundle_align_p2
);
786 finish_bundle (insn_start_frag
, insn_size
);
790 #else /* !HANDLE_BUNDLE */
792 # define assemble_one(line) md_assemble(line)
794 #endif /* HANDLE_BUNDLE */
799 flagword flags
= bfd_section_flags (now_seg
);
801 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
804 /* Guts of .align directive:
805 N is the power of two to which to align. A value of zero is accepted but
806 ignored: the default alignment of the section will be at least this.
807 FILL may be NULL, or it may point to the bytes of the fill pattern.
808 LEN is the length of whatever FILL points to, if anything. If LEN is zero
809 but FILL is not NULL then LEN is treated as if it were one.
810 MAX is the maximum number of characters to skip when doing the alignment,
811 or 0 if there is no maximum. */
814 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
816 if (now_seg
== absolute_section
|| in_bss ())
822 if (now_seg
== absolute_section
)
823 as_warn (_("ignoring fill value in absolute section"));
825 as_warn (_("ignoring fill value in section `%s'"),
826 segment_name (now_seg
));
833 #ifdef md_flush_pending_output
834 md_flush_pending_output ();
838 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
841 /* Only make a frag if we HAVE to... */
842 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
846 if (subseg_text_p (now_seg
))
847 frag_align_code (n
, max
);
849 frag_align (n
, 0, max
);
852 frag_align (n
, *fill
, max
);
854 frag_align_pattern (n
, fill
, len
, max
);
858 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
861 if (n
> OCTETS_PER_BYTE_POWER
)
862 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
865 /* We read the file, putting things into a web that represents what we
866 have been reading. */
868 read_a_source_file (const char *name
)
872 char *s
; /* String of symbol, '\0' appended. */
874 const pseudo_typeS
*pop
;
880 buffer
= input_scrub_new_file (name
);
883 listing_newline (NULL
);
884 register_dependency (name
);
886 /* Generate debugging information before we've read anything in to denote
887 this file as the "main" source file and not a subordinate one
888 (e.g. N_SO vs N_SOL in stabs). */
889 generate_file_debug ();
891 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
892 { /* We have another line to parse. */
894 /* In order to avoid listing macro expansion lines with labels
895 multiple times, keep track of which line was last issued. */
896 static char *last_eol
;
900 while (input_line_pointer
< buffer_limit
)
903 /* We have more of this buffer to parse. */
905 /* We now have input_line_pointer->1st char of next line.
906 If input_line_pointer [-1] == '\n' then we just
907 scanned another line: so bump line counters. */
908 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
911 symbol_set_value_now (&dot_symbol
);
912 #ifdef md_start_line_hook
913 md_start_line_hook ();
915 if (input_line_pointer
[-1] == '\n')
916 bump_line_counters ();
920 /* If listing is on, and we are expanding a macro, then give
921 the listing code the contents of the expanded line. */
924 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
926 /* Find the end of the current expanded macro line. */
927 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
935 /* Copy it for safe keeping. Also give an indication of
936 how much macro nesting is involved at this point. */
937 len
= s
- input_line_pointer
;
938 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
939 memset (copy
, '>', macro_nest
);
940 copy
[macro_nest
] = ' ';
941 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
942 copy
[macro_nest
+ 1 + len
] = '\0';
944 /* Install the line with the listing facility. */
945 listing_newline (copy
);
949 listing_newline (NULL
);
956 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
958 next_char
= * input_line_pointer
;
959 /* Text at the start of a line must be a label, we
960 run down and stick a colon in. */
961 if (is_name_beginner (next_char
) || next_char
== '"')
966 HANDLE_CONDITIONAL_ASSEMBLY (0);
968 nul_char
= get_symbol_name (& line_start
);
969 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
971 /* In MRI mode, the EQU and MACRO pseudoops must
972 be handled specially. */
976 char *rest
= input_line_pointer
+ 1;
980 if (*rest
== ' ' || *rest
== '\t')
982 if ((strncasecmp (rest
, "EQU", 3) == 0
983 || strncasecmp (rest
, "SET", 3) == 0)
984 && (rest
[3] == ' ' || rest
[3] == '\t'))
986 input_line_pointer
= rest
+ 3;
988 strncasecmp (rest
, "SET", 3) == 0);
991 if (strncasecmp (rest
, "MACRO", 5) == 0
994 || is_end_of_line
[(unsigned char) rest
[5]]))
998 /* In MRI mode, we need to handle the MACRO
999 pseudo-op specially: we don't want to put the
1000 symbol in the symbol table. */
1002 #ifdef TC_START_LABEL_WITHOUT_COLON
1003 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1006 line_label
= colon (line_start
);
1008 line_label
= symbol_create (line_start
,
1010 &zero_address_frag
, 0);
1012 next_char
= restore_line_pointer (nul_char
);
1013 if (next_char
== ':')
1014 input_line_pointer
++;
1019 /* We are at the beginning of a line, or similar place.
1020 We expect a well-formed assembler statement.
1021 A "symbol-name:" is a statement.
1023 Depending on what compiler is used, the order of these tests
1024 may vary to catch most common case 1st.
1025 Each test is independent of all other tests at the (top)
1028 nul_char
= next_char
= *input_line_pointer
++;
1029 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1031 /* C is the 1st significant character.
1032 Input_line_pointer points after that character. */
1033 if (is_name_beginner (next_char
) || next_char
== '"')
1037 /* Want user-defined label or pseudo/opcode. */
1038 HANDLE_CONDITIONAL_ASSEMBLY (1);
1040 --input_line_pointer
;
1041 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1042 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1043 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1045 /* NEXT_CHAR is character after symbol.
1046 The end of symbol in the input line is now '\0'.
1047 S points to the beginning of the symbol.
1048 [In case of pseudo-op, s->'.'.]
1049 Input_line_pointer->'\0' where NUL_CHAR was. */
1050 if (TC_START_LABEL (s
, nul_char
, next_char
))
1054 /* In MRI mode, \tsym: set 0 is permitted. */
1058 if (*rest
== ' ' || *rest
== '\t')
1061 if ((strncasecmp (rest
, "EQU", 3) == 0
1062 || strncasecmp (rest
, "SET", 3) == 0)
1063 && (rest
[3] == ' ' || rest
[3] == '\t'))
1065 input_line_pointer
= rest
+ 3;
1071 line_label
= colon (s
); /* User-defined label. */
1072 restore_line_pointer (nul_char
);
1073 ++ input_line_pointer
;
1074 #ifdef tc_check_label
1075 tc_check_label (line_label
);
1077 /* Input_line_pointer->after ':'. */
1080 else if ((next_char
== '=' && *rest
== '=')
1081 || ((next_char
== ' ' || next_char
== '\t')
1086 demand_empty_rest_of_line ();
1088 else if ((next_char
== '='
1089 || ((next_char
== ' ' || next_char
== '\t')
1091 #ifdef TC_EQUAL_IN_INSN
1092 && !TC_EQUAL_IN_INSN (next_char
, s
)
1097 demand_empty_rest_of_line ();
1101 /* Expect pseudo-op or machine instruction. */
1104 #ifndef TC_CASE_SENSITIVE
1108 strncpy (original_case_string
, s2
,
1109 sizeof (original_case_string
) - 1);
1110 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1114 *s2
= TOLOWER (*s2
);
1119 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1121 /* The MRI assembler uses pseudo-ops without
1123 pop
= po_entry_find (po_hash
, s
);
1124 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1129 || (!flag_m68k_mri
&& *s
== '.'))
1133 WARNING: next_char may be end-of-line.
1134 We lookup the pseudo-op table with s+1 because we
1135 already know that the pseudo-op begins with a '.'. */
1138 pop
= po_entry_find (po_hash
, s
+ 1);
1139 if (pop
&& !pop
->poc_handler
)
1142 /* In MRI mode, we may need to insert an
1143 automatic alignment directive. What a hack
1145 if (mri_pending_align
1147 || !((pop
->poc_handler
== cons
1148 && pop
->poc_val
== 1)
1149 || (pop
->poc_handler
== s_space
1150 && pop
->poc_val
== 1)
1151 #ifdef tc_conditional_pseudoop
1152 || tc_conditional_pseudoop (pop
)
1154 || pop
->poc_handler
== s_if
1155 || pop
->poc_handler
== s_ifdef
1156 || pop
->poc_handler
== s_ifc
1157 || pop
->poc_handler
== s_ifeqs
1158 || pop
->poc_handler
== s_else
1159 || pop
->poc_handler
== s_endif
1160 || pop
->poc_handler
== s_globl
1161 || pop
->poc_handler
== s_ignore
)))
1163 do_align (1, (char *) NULL
, 0, 0);
1164 mri_pending_align
= 0;
1166 if (line_label
!= NULL
)
1168 symbol_set_frag (line_label
, frag_now
);
1169 S_SET_VALUE (line_label
, frag_now_fix ());
1173 /* Print the error msg now, while we still can. */
1176 char *end
= input_line_pointer
;
1178 (void) restore_line_pointer (nul_char
);
1180 nul_char
= next_char
= *--input_line_pointer
;
1181 *input_line_pointer
= '\0';
1182 if (! macro_defined
|| ! try_macro (next_char
, s
))
1185 as_bad (_("unknown pseudo-op: `%s'"), s
);
1186 *input_line_pointer
++ = nul_char
;
1191 /* Put it back for error messages etc. */
1192 next_char
= restore_line_pointer (nul_char
);
1193 /* The following skip of whitespace is compulsory.
1194 A well shaped space is sometimes all that separates
1195 keyword from operands. */
1196 if (next_char
== ' ' || next_char
== '\t')
1197 input_line_pointer
++;
1199 /* Input_line is restored.
1200 Input_line_pointer->1st non-blank char
1201 after pseudo-operation. */
1202 (*pop
->poc_handler
) (pop
->poc_val
);
1204 /* If that was .end, just get out now. */
1205 if (pop
->poc_handler
== s_end
)
1210 /* WARNING: next_char may be end-of-line. */
1211 /* Also: input_line_pointer->`\0` where nul_char was. */
1212 (void) restore_line_pointer (nul_char
);
1213 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1214 next_char
= nul_char
= *input_line_pointer
;
1215 *input_line_pointer
= '\0';
1217 generate_lineno_debug ();
1219 if (macro_defined
&& try_macro (next_char
, s
))
1222 if (mri_pending_align
)
1224 do_align (1, (char *) NULL
, 0, 0);
1225 mri_pending_align
= 0;
1226 if (line_label
!= NULL
)
1228 symbol_set_frag (line_label
, frag_now
);
1229 S_SET_VALUE (line_label
, frag_now_fix ());
1233 assemble_one (s
); /* Assemble 1 instruction. */
1235 /* PR 19630: The backend may have set ilp to NULL
1236 if it encountered a catastrophic failure. */
1237 if (input_line_pointer
== NULL
)
1238 as_fatal (_("unable to continue with assembly."));
1240 *input_line_pointer
++ = nul_char
;
1242 /* We resume loop AFTER the end-of-line from
1243 this instruction. */
1249 /* Empty statement? */
1250 if (is_end_of_line
[(unsigned char) next_char
])
1253 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1255 /* local label ("4:") */
1256 char *backup
= input_line_pointer
;
1258 HANDLE_CONDITIONAL_ASSEMBLY (1);
1260 temp
= next_char
- '0';
1262 if (nul_char
== '"')
1263 ++ input_line_pointer
;
1265 /* Read the whole number. */
1266 while (ISDIGIT (*input_line_pointer
))
1268 const long digit
= *input_line_pointer
- '0';
1269 if (temp
> (INT_MAX
- digit
) / 10)
1271 as_bad (_("local label too large near %s"), backup
);
1275 temp
= temp
* 10 + digit
;
1276 ++input_line_pointer
;
1279 /* Overflow: stop processing the label. */
1282 ignore_rest_of_line ();
1286 if (LOCAL_LABELS_DOLLAR
1287 && *input_line_pointer
== '$'
1288 && *(input_line_pointer
+ 1) == ':')
1290 input_line_pointer
+= 2;
1292 if (dollar_label_defined (temp
))
1294 as_fatal (_("label \"%ld$\" redefined"), temp
);
1297 define_dollar_label (temp
);
1298 colon (dollar_label_name (temp
, 0));
1303 && *input_line_pointer
++ == ':')
1305 fb_label_instance_inc (temp
);
1306 colon (fb_label_name (temp
, 0));
1310 input_line_pointer
= backup
;
1313 if (next_char
&& strchr (line_comment_chars
, next_char
))
1314 { /* Its a comment. Better say APP or NO_APP. */
1319 unsigned int new_length
;
1322 s
= input_line_pointer
;
1323 if (!startswith (s
, "APP\n"))
1326 ignore_rest_of_line ();
1329 bump_line_counters ();
1332 ends
= strstr (s
, "#NO_APP\n");
1336 unsigned int tmp_len
;
1339 /* The end of the #APP wasn't in this buffer. We
1340 keep reading in buffers until we find the #NO_APP
1341 that goes with this #APP There is one. The specs
1343 tmp_len
= buffer_limit
- s
;
1344 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1345 memcpy (tmp_buf
, s
, tmp_len
);
1348 new_tmp
= input_scrub_next_buffer (&buffer
);
1352 buffer_limit
= new_tmp
;
1353 input_line_pointer
= buffer
;
1354 ends
= strstr (buffer
, "#NO_APP\n");
1356 num
= ends
- buffer
;
1358 num
= buffer_limit
- buffer
;
1360 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1361 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1366 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1374 input_line_pointer
= ends
+ 8;
1378 scrub_string_end
= ends
;
1380 new_length
= ends
- s
;
1381 new_buf
= XNEWVEC (char, new_length
);
1388 space
= (new_buf
+ new_length
) - new_tmp
;
1389 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1394 new_length
= new_tmp
+ size
- new_buf
;
1398 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1399 new_tmp
= new_buf
+ new_length
;
1405 /* We've "scrubbed" input to the preferred format. In the
1406 process we may have consumed the whole of the remaining
1407 file (and included files). We handle this formatted
1408 input similar to that of macro expansion, letting
1409 actual macro expansion (possibly nested) and other
1410 input expansion work. Beware that in messages, line
1411 numbers and possibly file names will be incorrect. */
1412 sb_build (&sbuf
, new_length
);
1413 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1414 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1416 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1421 HANDLE_CONDITIONAL_ASSEMBLY (1);
1423 #ifdef tc_unrecognized_line
1424 if (tc_unrecognized_line (next_char
))
1427 input_line_pointer
--;
1428 /* Report unknown char as error. */
1429 demand_empty_rest_of_line ();
1434 symbol_set_value_now (&dot_symbol
);
1436 #ifdef HANDLE_BUNDLE
1437 if (bundle_lock_frag
!= NULL
)
1439 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1440 _(".bundle_lock with no matching .bundle_unlock"));
1441 bundle_lock_frag
= NULL
;
1442 bundle_lock_frchain
= NULL
;
1443 bundle_lock_depth
= 0;
1450 /* Close the input file. */
1451 input_scrub_close ();
1452 #ifdef WARN_COMMENTS
1454 if (warn_comment
&& found_comment
)
1455 as_warn_where (found_comment_file
, found_comment
,
1456 "first comment found here");
1461 /* Convert O_constant expression EXP into the equivalent O_big representation.
1462 Take the sign of the number from SIGN rather than X_add_number. */
1465 convert_to_bignum (expressionS
*exp
, int sign
)
1470 value
= exp
->X_add_number
;
1471 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1473 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1474 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1476 /* Add a sequence of sign bits if the top bit of X_add_number is not
1477 the sign of the original value. */
1478 if ((exp
->X_add_number
< 0) == !sign
)
1479 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1481 exp
->X_add_number
= i
;
1484 /* For most MRI pseudo-ops, the line actually ends at the first
1485 nonquoted space. This function looks for that point, stuffs a null
1486 in, and sets *STOPCP to the character that used to be there, and
1487 returns the location.
1489 Until I hear otherwise, I am going to assume that this is only true
1490 for the m68k MRI assembler. */
1493 mri_comment_field (char *stopcp
)
1499 know (flag_m68k_mri
);
1501 for (s
= input_line_pointer
;
1502 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1510 for (s
= input_line_pointer
;
1511 !is_end_of_line
[(unsigned char) *s
];
1521 /* Skip to the end of an MRI comment field. */
1524 mri_comment_end (char *stop
, int stopc
)
1528 input_line_pointer
= stop
;
1530 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1531 ++input_line_pointer
;
1535 s_abort (int ignore ATTRIBUTE_UNUSED
)
1537 as_fatal (_(".abort detected. Abandoning ship."));
1540 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1541 (in bytes). A negative ARG is the negative of the length of the
1542 fill pattern. BYTES_P is non-zero if the alignment value should be
1543 interpreted as the byte boundary, rather than the power of 2. */
1544 #ifndef TC_ALIGN_LIMIT
1545 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1549 s_align (signed int arg
, int bytes_p
)
1551 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1560 stop
= mri_comment_field (&stopc
);
1562 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1567 align
= arg
; /* Default value from pseudo-op table. */
1571 align
= get_absolute_expression ();
1574 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1575 if (arg
> 0 && align
== 0)
1582 /* Convert to a power of 2. */
1587 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1590 as_bad (_("alignment not a power of 2"));
1596 if (align
> align_limit
)
1598 align
= align_limit
;
1599 as_warn (_("alignment too large: %u assumed"), align_limit
);
1602 if (*input_line_pointer
!= ',')
1609 ++input_line_pointer
;
1610 if (*input_line_pointer
== ',')
1614 fill
= get_absolute_expression ();
1619 if (*input_line_pointer
!= ',')
1623 ++input_line_pointer
;
1624 max
= get_absolute_expression ();
1631 as_warn (_("expected fill pattern missing"));
1632 do_align (align
, (char *) NULL
, 0, max
);
1636 unsigned int fill_len
;
1648 do_align (align
, &fill_char
, fill_len
, max
);
1654 if ((size_t) fill_len
> sizeof ab
)
1656 as_warn (_("fill pattern too long, truncating to %u"),
1657 (unsigned) sizeof ab
);
1658 fill_len
= sizeof ab
;
1661 md_number_to_chars (ab
, fill
, fill_len
);
1662 do_align (align
, ab
, fill_len
, max
);
1666 demand_empty_rest_of_line ();
1669 mri_comment_end (stop
, stopc
);
1672 /* Handle the .align pseudo-op on machines where ".align 4" means
1673 align to a 4 byte boundary. */
1676 s_align_bytes (int arg
)
1681 /* Handle the .align pseudo-op on machines where ".align 4" means align
1682 to a 2**4 boundary. */
1685 s_align_ptwo (int arg
)
1690 /* Switch in and out of alternate macro mode. */
1695 demand_empty_rest_of_line ();
1696 macro_set_alternate (on
);
1699 /* Read a symbol name from input_line_pointer.
1701 Stores the symbol name in a buffer and returns a pointer to this buffer.
1702 The buffer is xalloc'ed. It is the caller's responsibility to free
1705 The name is not left in the i_l_p buffer as it may need processing
1706 to handle escape characters.
1708 Advances i_l_p to the next non-whitespace character.
1710 If a symbol name could not be read, the routine issues an error
1711 messages, skips to the end of the line and returns NULL. */
1714 read_symbol_name (void)
1720 c
= *input_line_pointer
++;
1724 #define SYM_NAME_CHUNK_LEN 128
1725 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1729 start
= name
= XNEWVEC (char, len
+ 1);
1731 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1733 while (is_a_char (C
= next_char_of_string ()))
1735 if (name
>= name_end
)
1739 sofar
= name
- start
;
1740 len
+= SYM_NAME_CHUNK_LEN
;
1741 start
= XRESIZEVEC (char, start
, len
+ 1);
1742 name_end
= start
+ len
;
1743 name
= start
+ sofar
;
1750 /* Since quoted symbol names can contain non-ASCII characters,
1751 check the string and warn if it cannot be recognised by the
1752 current character set. */
1753 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1754 as_warn (_("symbol name not recognised in the current locale"));
1756 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1760 name
= input_line_pointer
- 1;
1762 /* We accept FAKE_LABEL_CHAR in a name in case this is
1763 being called with a constructed string. */
1764 while (is_part_of_name (c
= *input_line_pointer
++)
1765 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1768 len
= (input_line_pointer
- name
) - 1;
1769 start
= XNEWVEC (char, len
+ 1);
1771 memcpy (start
, name
, len
);
1774 /* Skip a name ender char if one is present. */
1775 if (! is_name_ender (c
))
1776 --input_line_pointer
;
1779 name
= start
= NULL
;
1783 as_bad (_("expected symbol name"));
1784 ignore_rest_of_line ();
1795 s_comm_internal (int param
,
1796 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1800 symbolS
*symbolP
= NULL
;
1806 stop
= mri_comment_field (&stopc
);
1808 if ((name
= read_symbol_name ()) == NULL
)
1811 /* Accept an optional comma after the name. The comma used to be
1812 required, but Irix 5 cc does not generate it for .lcomm. */
1813 if (*input_line_pointer
== ',')
1814 input_line_pointer
++;
1816 temp
= get_absolute_expr (&exp
);
1818 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1819 if (exp
.X_op
== O_absent
)
1821 as_bad (_("missing size expression"));
1822 ignore_rest_of_line ();
1825 else if (temp
!= size
|| !exp
.X_unsigned
)
1827 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1828 ignore_rest_of_line ();
1832 symbolP
= symbol_find_or_make (name
);
1833 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1834 && !S_IS_COMMON (symbolP
))
1836 if (!S_IS_VOLATILE (symbolP
))
1839 as_bad (_("symbol `%s' is already defined"), name
);
1840 ignore_rest_of_line ();
1843 symbolP
= symbol_clone (symbolP
, 1);
1844 S_SET_SEGMENT (symbolP
, undefined_section
);
1845 S_SET_VALUE (symbolP
, 0);
1846 symbol_set_frag (symbolP
, &zero_address_frag
);
1847 S_CLEAR_VOLATILE (symbolP
);
1850 size
= S_GET_VALUE (symbolP
);
1853 else if (size
!= temp
)
1854 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1855 name
, (long) size
, (long) temp
);
1857 if (comm_parse_extra
!= NULL
)
1858 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1861 S_SET_VALUE (symbolP
, (valueT
) size
);
1862 S_SET_EXTERNAL (symbolP
);
1863 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1866 demand_empty_rest_of_line ();
1869 mri_comment_end (stop
, stopc
);
1877 s_comm_internal (ignore
, NULL
);
1880 /* The MRI COMMON pseudo-op. We handle this by creating a common
1881 symbol with the appropriate name. We make s_space do the right
1882 thing by increasing the size. */
1885 s_mri_common (int small ATTRIBUTE_UNUSED
)
1901 stop
= mri_comment_field (&stopc
);
1905 name
= input_line_pointer
;
1906 if (!ISDIGIT (*name
))
1907 c
= get_symbol_name (& name
);
1912 ++input_line_pointer
;
1914 while (ISDIGIT (*input_line_pointer
));
1916 c
= *input_line_pointer
;
1917 *input_line_pointer
= '\0';
1919 if (line_label
!= NULL
)
1921 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1922 + (input_line_pointer
- name
) + 1);
1923 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1928 sym
= symbol_find_or_make (name
);
1929 c
= restore_line_pointer (c
);
1932 if (*input_line_pointer
!= ',')
1936 ++input_line_pointer
;
1937 align
= get_absolute_expression ();
1940 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1942 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
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 linenum
= get_absolute_expression ();
2075 else if (!get_linefile_number (&linenum
))
2077 ignore_rest_of_line ();
2082 /* Some of the back ends can't deal with non-positive line numbers.
2083 Besides, it's silly. GCC however will generate a line number of
2084 zero when it is pre-processing builtins for assembler-with-cpp files:
2088 We do not want to barf on this, especially since such files are used
2089 in the GCC and GDB testsuites. So we check for negative line numbers
2090 rather than non-positive line numbers. */
2091 as_warn (_("line numbers must be positive; line number %d rejected"),
2102 if (*input_line_pointer
== '"')
2103 file
= demand_copy_string (&length
);
2109 while (get_linefile_number (&this_flag
))
2112 /* From GCC's cpp documentation:
2113 1: start of a new file.
2114 2: returning to a file after having included
2116 3: following text comes from a system header file.
2117 4: following text should be treated as extern "C".
2119 4 is nonsensical for the assembler; 3, we don't
2120 care about, so we ignore it just in case a
2121 system header file is included while
2122 preprocessing assembly. So 1 and 2 are all we
2123 care about, and they are mutually incompatible.
2124 new_logical_line_flags() demands this. */
2127 if (flags
&& flags
!= (1 << this_flag
))
2128 as_warn (_("incompatible flag %i in line directive"),
2131 flags
|= 1 << this_flag
;
2136 /* We ignore these. */
2140 as_warn (_("unsupported flag %i in line directive"),
2145 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2150 if (appline
|| file
)
2153 new_logical_line_flags (file
, linenum
, flags
);
2156 listing_source_line (linenum
);
2160 if (appline
|| file
)
2161 demand_empty_rest_of_line ();
2163 ignore_rest_of_line ();
2166 /* Handle the .end pseudo-op. Actually, the real work is done in
2167 read_a_source_file. */
2170 s_end (int ignore ATTRIBUTE_UNUSED
)
2174 /* The MRI assembler permits the start symbol to follow .end,
2175 but we don't support that. */
2177 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2178 && *input_line_pointer
!= '*'
2179 && *input_line_pointer
!= '!')
2180 as_warn (_("start address not supported"));
2184 /* Handle the .err pseudo-op. */
2187 s_err (int ignore ATTRIBUTE_UNUSED
)
2189 as_bad (_(".err encountered"));
2190 demand_empty_rest_of_line ();
2193 /* Handle the .error and .warning pseudo-ops. */
2199 /* The purpose for the conditional assignment is not to
2200 internationalize the directive itself, but that we need a
2201 self-contained message, one that can be passed like the
2202 demand_copy_C_string return value, and with no assumption on the
2203 location of the name of the directive within the message. */
2205 = (err
? _(".error directive invoked in source file")
2206 : _(".warning directive invoked in source file"));
2208 if (!is_it_end_of_statement ())
2210 if (*input_line_pointer
!= '\"')
2212 as_bad (_("%s argument must be a string"),
2213 err
? ".error" : ".warning");
2214 ignore_rest_of_line ();
2218 msg
= demand_copy_C_string (&len
);
2226 as_warn ("%s", msg
);
2227 demand_empty_rest_of_line ();
2230 /* Handle the MRI fail pseudo-op. */
2233 s_fail (int ignore ATTRIBUTE_UNUSED
)
2240 stop
= mri_comment_field (&stopc
);
2242 temp
= get_absolute_expression ();
2244 as_warn (_(".fail %ld encountered"), (long) temp
);
2246 as_bad (_(".fail %ld encountered"), (long) temp
);
2248 demand_empty_rest_of_line ();
2251 mri_comment_end (stop
, stopc
);
2255 s_fill (int ignore ATTRIBUTE_UNUSED
)
2257 expressionS rep_exp
;
2262 #ifdef md_flush_pending_output
2263 md_flush_pending_output ();
2266 #ifdef md_cons_align
2270 expression (&rep_exp
);
2271 if (*input_line_pointer
== ',')
2273 input_line_pointer
++;
2274 size
= get_absolute_expression ();
2275 if (*input_line_pointer
== ',')
2277 input_line_pointer
++;
2278 fill
= get_absolute_expression ();
2282 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2283 #define BSD_FILL_SIZE_CROCK_8 (8)
2284 if (size
> BSD_FILL_SIZE_CROCK_8
)
2286 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2287 size
= BSD_FILL_SIZE_CROCK_8
;
2291 as_warn (_("size negative; .fill ignored"));
2294 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2296 if (rep_exp
.X_add_number
< 0)
2297 as_warn (_("repeat < 0; .fill ignored"));
2301 if (size
&& !need_pass_2
)
2303 if (now_seg
== absolute_section
)
2305 if (rep_exp
.X_op
!= O_constant
)
2306 as_bad (_("non-constant fill count for absolute section"));
2307 else if (fill
&& rep_exp
.X_add_number
!= 0)
2308 as_bad (_("attempt to fill absolute section with non-zero value"));
2309 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2312 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2314 as_bad (_("attempt to fill section `%s' with non-zero value"),
2315 segment_name (now_seg
));
2317 if (rep_exp
.X_op
== O_constant
)
2319 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2320 (relax_substateT
) 0, (symbolS
*) 0,
2321 (offsetT
) rep_exp
.X_add_number
,
2326 /* We don't have a constant repeat count, so we can't use
2327 rs_fill. We can get the same results out of rs_space,
2328 but its argument is in bytes, so we must multiply the
2329 repeat count by size. */
2332 rep_sym
= make_expr_symbol (&rep_exp
);
2335 expressionS size_exp
;
2336 size_exp
.X_op
= O_constant
;
2337 size_exp
.X_add_number
= size
;
2339 rep_exp
.X_op
= O_multiply
;
2340 rep_exp
.X_add_symbol
= rep_sym
;
2341 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2342 rep_exp
.X_add_number
= 0;
2343 rep_sym
= make_expr_symbol (&rep_exp
);
2346 p
= frag_var (rs_space
, (int) size
, (int) size
,
2347 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2350 memset (p
, 0, (unsigned int) size
);
2352 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2353 flavoured AS. The following bizarre behaviour is to be
2354 compatible with above. I guess they tried to take up to 8
2355 bytes from a 4-byte expression and they forgot to sign
2357 #define BSD_FILL_SIZE_CROCK_4 (4)
2358 md_number_to_chars (p
, (valueT
) fill
,
2359 (size
> BSD_FILL_SIZE_CROCK_4
2360 ? BSD_FILL_SIZE_CROCK_4
2362 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2363 but emits no error message because it seems a legal thing to do.
2364 It is a degenerate case of .fill but could be emitted by a
2367 demand_empty_rest_of_line ();
2371 s_globl (int ignore ATTRIBUTE_UNUSED
)
2380 stop
= mri_comment_field (&stopc
);
2384 if ((name
= read_symbol_name ()) == NULL
)
2387 symbolP
= symbol_find_or_make (name
);
2388 S_SET_EXTERNAL (symbolP
);
2391 c
= *input_line_pointer
;
2394 input_line_pointer
++;
2396 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2404 demand_empty_rest_of_line ();
2407 mri_comment_end (stop
, stopc
);
2410 /* Handle the MRI IRP and IRPC pseudo-ops. */
2422 file
= as_where (&line
);
2424 eol
= find_end_of_line (input_line_pointer
, 0);
2425 sb_build (&s
, eol
- input_line_pointer
);
2426 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2427 input_line_pointer
= eol
;
2431 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2433 as_bad_where (file
, line
, "%s", err
);
2437 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2439 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2442 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2443 the section to only be linked once. However, this is not supported
2444 by most object file formats. This takes an optional argument,
2445 which is what to do about duplicates. */
2448 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2450 enum linkonce_type type
;
2454 type
= LINKONCE_DISCARD
;
2456 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2461 c
= get_symbol_name (& s
);
2462 if (strcasecmp (s
, "discard") == 0)
2463 type
= LINKONCE_DISCARD
;
2464 else if (strcasecmp (s
, "one_only") == 0)
2465 type
= LINKONCE_ONE_ONLY
;
2466 else if (strcasecmp (s
, "same_size") == 0)
2467 type
= LINKONCE_SAME_SIZE
;
2468 else if (strcasecmp (s
, "same_contents") == 0)
2469 type
= LINKONCE_SAME_CONTENTS
;
2471 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2473 (void) restore_line_pointer (c
);
2476 #ifdef obj_handle_link_once
2477 obj_handle_link_once (type
);
2478 #else /* ! defined (obj_handle_link_once) */
2482 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2483 as_warn (_(".linkonce is not supported for this object file format"));
2485 flags
= bfd_section_flags (now_seg
);
2486 flags
|= SEC_LINK_ONCE
;
2491 case LINKONCE_DISCARD
:
2492 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2494 case LINKONCE_ONE_ONLY
:
2495 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2497 case LINKONCE_SAME_SIZE
:
2498 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2500 case LINKONCE_SAME_CONTENTS
:
2501 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2504 if (!bfd_set_section_flags (now_seg
, flags
))
2505 as_bad (_("bfd_set_section_flags: %s"),
2506 bfd_errmsg (bfd_get_error ()));
2508 #endif /* ! defined (obj_handle_link_once) */
2510 demand_empty_rest_of_line ();
2514 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2517 segT current_seg
= now_seg
;
2518 subsegT current_subseg
= now_subseg
;
2519 segT bss_seg
= bss_section
;
2521 #if defined (TC_MIPS) || defined (TC_ALPHA)
2522 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2523 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2525 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2526 if (size
<= bfd_get_gp_size (stdoutput
))
2528 bss_seg
= subseg_new (".sbss", 1);
2529 seg_info (bss_seg
)->bss
= 1;
2530 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2531 as_warn (_("error setting flags for \".sbss\": %s"),
2532 bfd_errmsg (bfd_get_error ()));
2536 subseg_set (bss_seg
, 1);
2538 if (align
> OCTETS_PER_BYTE_POWER
)
2540 record_alignment (bss_seg
, align
);
2541 frag_align (align
, 0, 0);
2544 /* Detach from old frag. */
2545 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2546 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2548 symbol_set_frag (symbolP
, frag_now
);
2549 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2553 S_SET_SIZE (symbolP
, size
);
2555 S_SET_SEGMENT (symbolP
, bss_seg
);
2558 /* The symbol may already have been created with a preceding
2559 ".globl" directive -- be careful not to step on storage class
2560 in that case. Otherwise, set it to static. */
2561 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2562 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2563 #endif /* OBJ_COFF */
2565 subseg_set (current_seg
, current_subseg
);
2569 parse_align (int align_bytes
)
2575 if (*input_line_pointer
!= ',')
2578 as_bad (_("expected alignment after size"));
2579 ignore_rest_of_line ();
2583 input_line_pointer
++;
2586 align
= get_absolute_expr (&exp
);
2587 if (exp
.X_op
== O_absent
)
2590 if (!exp
.X_unsigned
)
2592 as_warn (_("alignment negative; 0 assumed"));
2596 if (align_bytes
&& align
!= 0)
2598 /* convert to a power of 2 alignment */
2599 unsigned int alignp2
= 0;
2600 while ((align
& 1) == 0)
2601 align
>>= 1, ++alignp2
;
2604 as_bad (_("alignment not a power of 2"));
2605 ignore_rest_of_line ();
2613 /* Called from s_comm_internal after symbol name and size have been
2614 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2615 1 if this was a ".bss" directive which has a 3rd argument
2616 (alignment as a power of 2), or 2 if this was a ".bss" directive
2617 with alignment in bytes. */
2620 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2626 align
= parse_align (needs_align
- 1);
2627 if (align
== (addressT
) -1)
2631 /* Assume some objects may require alignment on some systems. */
2632 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2634 bss_alloc (symbolP
, size
, align
);
2639 s_lcomm (int needs_align
)
2641 s_comm_internal (needs_align
, s_lcomm_internal
);
2645 s_lcomm_bytes (int needs_align
)
2647 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2651 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2657 /* We permit ANY defined expression: BSD4.2 demands constants. */
2658 if ((name
= read_symbol_name ()) == NULL
)
2661 if (*input_line_pointer
!= ',')
2663 as_bad (_("expected comma after \"%s\""), name
);
2667 input_line_pointer
++;
2668 expression_and_evaluate (&exp
);
2670 if (exp
.X_op
!= O_constant
2671 && exp
.X_op
!= O_register
)
2673 as_bad (_("bad expression"));
2677 symbolP
= symbol_find_or_make (name
);
2679 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2681 /* The name might be an undefined .global symbol; be sure to
2682 keep the "external" bit. */
2683 S_SET_SEGMENT (symbolP
,
2684 (exp
.X_op
== O_constant
2687 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2691 as_bad (_("symbol `%s' is already defined"), name
);
2694 demand_empty_rest_of_line ();
2699 ignore_rest_of_line ();
2704 /* Read a line into an sb. Returns the character that ended the line
2705 or zero if there are no more lines. */
2708 get_line_sb (sb
*line
, int in_macro
)
2712 if (input_line_pointer
[-1] == '\n')
2713 bump_line_counters ();
2715 if (input_line_pointer
>= buffer_limit
)
2717 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2718 if (buffer_limit
== 0)
2722 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2723 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2724 input_line_pointer
= eol
;
2726 /* Don't skip multiple end-of-line characters, because that breaks support
2727 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2728 characters but isn't. Instead just skip one end of line character and
2729 return the character skipped so that the caller can re-insert it if
2731 return *input_line_pointer
++;
2735 get_non_macro_line_sb (sb
*line
)
2737 return get_line_sb (line
, 0);
2741 get_macro_line_sb (sb
*line
)
2743 return get_line_sb (line
, 1);
2746 /* Define a macro. This is an interface to macro.c. */
2749 s_macro (int ignore ATTRIBUTE_UNUSED
)
2758 file
= as_where (&line
);
2760 eol
= find_end_of_line (input_line_pointer
, 0);
2761 sb_build (&s
, eol
- input_line_pointer
);
2762 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2763 input_line_pointer
= eol
;
2765 if (line_label
!= NULL
)
2770 name
= S_GET_NAME (line_label
);
2771 len
= strlen (name
);
2772 sb_build (&label
, len
);
2773 sb_add_buffer (&label
, name
, len
);
2774 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2778 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2780 as_bad_where (file
, line
, err
, name
);
2783 if (line_label
!= NULL
)
2785 S_SET_SEGMENT (line_label
, absolute_section
);
2786 S_SET_VALUE (line_label
, 0);
2787 symbol_set_frag (line_label
, &zero_address_frag
);
2790 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2791 && po_entry_find (po_hash
, name
) != NULL
)
2794 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2795 as_warn_where (file
,
2797 _("attempt to redefine pseudo-op `%s' ignored"),
2804 /* Handle the .mexit pseudo-op, which immediately exits a macro
2808 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2812 cond_exit_macro (macro_nest
);
2813 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2816 as_warn (_("ignoring macro exit outside a macro definition."));
2819 /* Switch in and out of MRI mode. */
2822 s_mri (int ignore ATTRIBUTE_UNUSED
)
2825 #ifdef MRI_MODE_CHANGE
2829 on
= get_absolute_expression ();
2830 #ifdef MRI_MODE_CHANGE
2831 old_flag
= flag_mri
;
2850 /* Operator precedence changes in m68k MRI mode, so we need to
2851 update the operator rankings. */
2852 expr_set_precedence ();
2854 #ifdef MRI_MODE_CHANGE
2856 MRI_MODE_CHANGE (on
);
2859 demand_empty_rest_of_line ();
2862 /* Handle changing the location counter. */
2865 do_org (segT segment
, expressionS
*exp
, int fill
)
2867 if (segment
!= now_seg
2868 && segment
!= absolute_section
2869 && segment
!= expr_section
)
2870 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2872 if (now_seg
== absolute_section
)
2875 as_warn (_("ignoring fill value in absolute section"));
2876 if (exp
->X_op
!= O_constant
)
2878 as_bad (_("only constant offsets supported in absolute section"));
2879 exp
->X_add_number
= 0;
2881 abs_section_offset
= exp
->X_add_number
;
2886 symbolS
*sym
= exp
->X_add_symbol
;
2887 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2889 if (fill
&& in_bss ())
2890 as_warn (_("ignoring fill value in section `%s'"),
2891 segment_name (now_seg
));
2893 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2895 /* Handle complex expressions. */
2896 sym
= make_expr_symbol (exp
);
2900 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2906 s_org (int ignore ATTRIBUTE_UNUSED
)
2912 #ifdef md_flush_pending_output
2913 md_flush_pending_output ();
2916 /* The m68k MRI assembler has a different meaning for .org. It
2917 means to create an absolute section at a given address. We can't
2918 support that--use a linker script instead. */
2921 as_bad (_("MRI style ORG pseudo-op not supported"));
2922 ignore_rest_of_line ();
2926 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2927 thing as a sub-segment-relative origin. Any absolute origin is
2928 given a warning, then assumed to be segment-relative. Any
2929 segmented origin expression ("foo+42") had better be in the right
2930 segment or the .org is ignored.
2932 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2933 we never know sub-segment sizes when we are reading code. BSD
2934 will crash trying to emit negative numbers of filler bytes in
2935 certain .orgs. We don't crash, but see as-write for that code.
2937 Don't make frag if need_pass_2==1. */
2938 segment
= get_known_segmented_expression (&exp
);
2939 if (*input_line_pointer
== ',')
2941 input_line_pointer
++;
2942 temp_fill
= get_absolute_expression ();
2948 do_org (segment
, &exp
, temp_fill
);
2950 demand_empty_rest_of_line ();
2953 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2954 called by the obj-format routine which handles section changing
2955 when in MRI mode. It will create a new section, and return it. It
2956 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2957 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2960 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2970 name
= input_line_pointer
;
2971 if (!ISDIGIT (*name
))
2972 c
= get_symbol_name (& name
);
2977 ++input_line_pointer
;
2979 while (ISDIGIT (*input_line_pointer
));
2981 c
= *input_line_pointer
;
2982 *input_line_pointer
= '\0';
2985 name
= xstrdup (name
);
2987 c
= restore_line_pointer (c
);
2989 seg
= subseg_new (name
, 0);
2995 ++input_line_pointer
;
2996 align
= get_absolute_expression ();
2997 record_alignment (seg
, align
);
3001 if (*input_line_pointer
== ',')
3003 c
= *++input_line_pointer
;
3005 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3008 as_bad (_("unrecognized section type"));
3009 ++input_line_pointer
;
3014 flags
= SEC_NO_FLAGS
;
3016 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3017 else if (*type
== 'D' || *type
== 'M')
3018 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3019 else if (*type
== 'R')
3020 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3021 if (flags
!= SEC_NO_FLAGS
)
3023 if (!bfd_set_section_flags (seg
, flags
))
3024 as_warn (_("error setting flags for \"%s\": %s"),
3025 bfd_section_name (seg
),
3026 bfd_errmsg (bfd_get_error ()));
3031 /* Ignore the HP type. */
3032 if (*input_line_pointer
== ',')
3033 input_line_pointer
+= 2;
3035 demand_empty_rest_of_line ();
3037 #else /* ! TC_M68K */
3038 /* The MRI assembler seems to use different forms of .sect for
3039 different targets. */
3040 as_bad ("MRI mode not supported for this target");
3041 ignore_rest_of_line ();
3042 #endif /* ! TC_M68K */
3045 /* Handle the .print pseudo-op. */
3048 s_print (int ignore ATTRIBUTE_UNUSED
)
3053 s
= demand_copy_C_string (&len
);
3056 demand_empty_rest_of_line ();
3059 /* Handle the .purgem pseudo-op. */
3062 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3064 if (is_it_end_of_statement ())
3066 demand_empty_rest_of_line ();
3076 c
= get_symbol_name (& name
);
3077 delete_macro (name
);
3078 *input_line_pointer
= c
;
3079 SKIP_WHITESPACE_AFTER_NAME ();
3081 while (*input_line_pointer
++ == ',');
3083 --input_line_pointer
;
3084 demand_empty_rest_of_line ();
3087 /* Handle the .endm/.endr pseudo-ops. */
3090 s_bad_end (int endr
)
3092 as_warn (_(".end%c encountered without preceding %s"),
3094 endr
? ".rept, .irp, or .irpc" : ".macro");
3095 demand_empty_rest_of_line ();
3098 /* Handle the .rept pseudo-op. */
3101 s_rept (int ignore ATTRIBUTE_UNUSED
)
3105 count
= (size_t) get_absolute_expression ();
3107 do_repeat (count
, "REPT", "ENDR");
3110 /* This function provides a generic repeat block implementation. It allows
3111 different directives to be used as the start/end keys. */
3114 do_repeat (size_t count
, const char *start
, const char *end
)
3119 if (((ssize_t
) count
) < 0)
3121 as_bad (_("negative count for %s - ignored"), start
);
3126 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3128 as_bad (_("%s without %s"), start
, end
);
3132 sb_build (&many
, count
* one
.len
);
3134 sb_add_sb (&many
, &one
);
3138 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3140 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3143 /* Like do_repeat except that any text matching EXPANDER in the
3144 block is replaced by the iteration count. */
3147 do_repeat_with_expander (size_t count
,
3150 const char * expander
)
3155 if (((ssize_t
) count
) < 0)
3157 as_bad (_("negative count for %s - ignored"), start
);
3162 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3164 as_bad (_("%s without %s"), start
, end
);
3170 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3172 while (count
-- > 0)
3178 sb_build (& processed
, one
.len
);
3179 sb_add_sb (& processed
, & one
);
3180 sub
= strstr (processed
.ptr
, expander
);
3181 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3182 gas_assert (len
< 8);
3183 memmove (sub
+ len
, sub
+ 8,
3184 processed
.ptr
+ processed
.len
- (sub
+ 8));
3185 processed
.len
-= (8 - len
);
3186 sb_add_sb (& many
, & processed
);
3187 sb_kill (& processed
);
3192 sb_add_sb (&many
, &one
);
3196 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3198 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3201 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3202 input buffers to skip. Assumes that conditionals preceding the loop end
3203 are properly nested.
3205 This function makes it easier to implement a premature "break" out of the
3206 loop. The EXTRA arg accounts for other buffers we might have inserted,
3207 such as line substitutions. */
3210 end_repeat (int extra
)
3212 cond_exit_macro (macro_nest
);
3213 while (extra
-- >= 0)
3214 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3218 assign_symbol (char *name
, int mode
)
3222 if (name
[0] == '.' && name
[1] == '\0')
3224 /* Turn '. = mumble' into a .org mumble. */
3228 segment
= get_known_segmented_expression (&exp
);
3231 do_org (segment
, &exp
, 0);
3236 if ((symbolP
= symbol_find (name
)) == NULL
3237 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3239 symbolP
= symbol_find_or_make (name
);
3241 /* When doing symbol listings, play games with dummy fragments living
3242 outside the normal fragment chain to record the file and line info
3244 if (listing
& LISTING_SYMBOLS
)
3246 extern struct list_info_struct
*listing_tail
;
3247 fragS
*dummy_frag
= XCNEW (fragS
);
3248 dummy_frag
->line
= listing_tail
;
3249 dummy_frag
->fr_symbol
= symbolP
;
3250 symbol_set_frag (symbolP
, dummy_frag
);
3253 #if defined (OBJ_COFF) && !defined (TE_PE)
3254 /* "set" symbols are local unless otherwise specified. */
3255 SF_SET_LOCAL (symbolP
);
3259 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3261 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3262 && !S_CAN_BE_REDEFINED (symbolP
))
3264 as_bad (_("symbol `%s' is already defined"), name
);
3265 ignore_rest_of_line ();
3266 input_line_pointer
--;
3269 /* If the symbol is volatile, copy the symbol and replace the
3270 original with the copy, so that previous uses of the symbol will
3271 retain the value of the symbol at the point of use. */
3272 else if (S_IS_VOLATILE (symbolP
))
3273 symbolP
= symbol_clone (symbolP
, 1);
3277 S_SET_VOLATILE (symbolP
);
3279 S_SET_FORWARD_REF (symbolP
);
3281 pseudo_set (symbolP
);
3284 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3285 then this is .equiv, and it is an error if the symbol is already
3286 defined. If EQUIV is -1, the symbol additionally is a forward
3294 /* Especial apologies for the random logic:
3295 this just grew, and could be parsed much more simply!
3297 if ((name
= read_symbol_name ()) == NULL
)
3300 if (*input_line_pointer
!= ',')
3302 as_bad (_("expected comma after \"%s\""), name
);
3303 ignore_rest_of_line ();
3308 input_line_pointer
++;
3309 assign_symbol (name
, equiv
);
3310 demand_empty_rest_of_line ();
3324 #ifdef md_flush_pending_output
3325 md_flush_pending_output ();
3332 # ifndef P_PRECISION
3333 # define P_PRECISION X_PRECISION
3334 # define P_PRECISION_PAD X_PRECISION_PAD
3336 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3344 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3351 #ifdef md_cons_align
3356 stop
= mri_comment_field (&stopc
);
3358 /* In m68k MRI mode, we need to align to a word boundary, unless
3360 if (flag_m68k_mri
&& mult
> 1)
3362 if (now_seg
== absolute_section
)
3364 abs_section_offset
+= abs_section_offset
& 1;
3365 if (line_label
!= NULL
)
3366 S_SET_VALUE (line_label
, abs_section_offset
);
3368 else if (mri_common_symbol
!= NULL
)
3372 mri_val
= S_GET_VALUE (mri_common_symbol
);
3373 if ((mri_val
& 1) != 0)
3375 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3376 if (line_label
!= NULL
)
3378 expressionS
*symexp
;
3380 symexp
= symbol_get_value_expression (line_label
);
3381 know (symexp
->X_op
== O_symbol
);
3382 know (symexp
->X_add_symbol
== mri_common_symbol
);
3383 symexp
->X_add_number
+= 1;
3389 do_align (1, (char *) NULL
, 0, 0);
3390 if (line_label
!= NULL
)
3392 symbol_set_frag (line_label
, frag_now
);
3393 S_SET_VALUE (line_label
, frag_now_fix ());
3403 if (*input_line_pointer
== ',')
3405 ++input_line_pointer
;
3410 val
.X_op
= O_constant
;
3411 val
.X_add_number
= 0;
3414 if ((val
.X_op
!= O_constant
3415 || val
.X_add_number
< - 0x80
3416 || val
.X_add_number
> 0xff
3417 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3418 && (now_seg
!= absolute_section
&& !in_bss ()))
3420 resolve_expression (&exp
);
3421 if (exp
.X_op
!= O_constant
)
3422 as_bad (_("unsupported variable size or fill value"));
3427 /* PR 20901: Check for excessive values.
3428 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3429 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3430 as_bad (_("size value for space directive too large: %lx"),
3431 (long) exp
.X_add_number
);
3436 bytes
= mult
* exp
.X_add_number
;
3438 for (i
= 0; i
< exp
.X_add_number
; i
++)
3439 emit_expr (&val
, mult
);
3445 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3446 resolve_expression (&exp
);
3448 if (exp
.X_op
== O_constant
)
3452 repeat
= exp
.X_add_number
;
3459 as_warn (_(".space repeat count is zero, ignored"));
3460 else if (repeat
< 0)
3461 as_warn (_(".space repeat count is negative, ignored"));
3465 /* If we are in the absolute section, just bump the offset. */
3466 if (now_seg
== absolute_section
)
3468 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3469 as_warn (_("ignoring fill value in absolute section"));
3470 abs_section_offset
+= repeat
;
3474 /* If we are secretly in an MRI common section, then
3475 creating space just increases the size of the common
3477 if (mri_common_symbol
!= NULL
)
3479 S_SET_VALUE (mri_common_symbol
,
3480 S_GET_VALUE (mri_common_symbol
) + repeat
);
3485 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3486 (offsetT
) repeat
, (char *) 0);
3490 if (now_seg
== absolute_section
)
3492 as_bad (_("space allocation too complex in absolute section"));
3493 subseg_set (text_section
, 0);
3496 if (mri_common_symbol
!= NULL
)
3498 as_bad (_("space allocation too complex in common section"));
3499 mri_common_symbol
= NULL
;
3503 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3504 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3507 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3508 as_warn (_("ignoring fill value in section `%s'"),
3509 segment_name (now_seg
));
3511 *p
= val
.X_add_number
;
3516 /* In MRI mode, after an odd number of bytes, we must align to an
3517 even word boundary, unless the next instruction is a dc.b, ds.b
3519 if (flag_mri
&& (bytes
& 1) != 0)
3520 mri_pending_align
= 1;
3522 demand_empty_rest_of_line ();
3525 mri_comment_end (stop
, stopc
);
3529 s_nop (int ignore ATTRIBUTE_UNUSED
)
3536 #ifdef md_flush_pending_output
3537 md_flush_pending_output ();
3540 #ifdef md_cons_align
3546 demand_empty_rest_of_line ();
3549 start_off
= frag_now_fix ();
3552 #ifdef md_emit_single_noop
3553 md_emit_single_noop
;
3557 #ifndef md_single_noop_insn
3558 #define md_single_noop_insn "nop"
3560 /* md_assemble might modify its argument, so
3561 we must pass it a string that is writable. */
3562 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3563 as_fatal ("%s", xstrerror (errno
));
3565 /* Some targets assume that they can update input_line_pointer
3566 inside md_assemble, and, worse, that they can leave it
3567 assigned to the string pointer that was provided as an
3568 argument. So preserve ilp here. */
3569 char *saved_ilp
= input_line_pointer
;
3571 input_line_pointer
= saved_ilp
;
3574 #ifdef md_flush_pending_output
3575 md_flush_pending_output ();
3577 } while (exp
.X_op
== O_constant
3578 && exp
.X_add_number
> 0
3579 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3580 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3584 s_nops (int ignore ATTRIBUTE_UNUSED
)
3589 #ifdef md_flush_pending_output
3590 md_flush_pending_output ();
3593 #ifdef md_cons_align
3599 /* Note - this expression is tested for an absolute value in
3600 write.c:relax_segment(). */
3603 if (*input_line_pointer
== ',')
3605 ++input_line_pointer
;
3610 val
.X_op
= O_constant
;
3611 val
.X_add_number
= 0;
3614 if (val
.X_op
!= O_constant
)
3616 as_bad (_("unsupported variable nop control in .nops directive"));
3617 val
.X_op
= O_constant
;
3618 val
.X_add_number
= 0;
3620 else if (val
.X_add_number
< 0)
3622 as_warn (_("negative nop control byte, ignored"));
3623 val
.X_add_number
= 0;
3626 demand_empty_rest_of_line ();
3629 /* Ignore this directive if we are going to perform a second pass. */
3632 /* Store the no-op instruction control byte in the first byte of frag. */
3634 symbolS
*sym
= make_expr_symbol (&exp
);
3635 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3636 sym
, (offsetT
) 0, (char *) 0);
3637 *p
= val
.X_add_number
;
3640 /* Obtain the size of a floating point number, given a type. */
3643 float_length (int float_type
, int *pad_p
)
3645 int length
, pad
= 0;
3673 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3674 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3683 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3684 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3691 as_bad (_("unknown floating type '%c'"), float_type
);
3703 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3709 /* Skip any 0{letter} that may be present. Don't even check if the
3710 letter is legal. Someone may invent a "z" format and this routine
3711 has no use for such information. Lusers beware: you get
3712 diagnostics if your input is ill-conditioned. */
3713 if (input_line_pointer
[0] == '0'
3714 && ISALPHA (input_line_pointer
[1]))
3715 input_line_pointer
+= 2;
3717 /* Accept :xxxx, where the x's are hex digits, for a floating point
3718 with the exact digits specified. */
3719 if (input_line_pointer
[0] == ':')
3721 ++input_line_pointer
;
3722 length
= hex_float (float_type
, temp
);
3725 ignore_rest_of_line ();
3733 err
= md_atof (float_type
, temp
, &length
);
3734 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3735 know (err
!= NULL
|| length
> 0);
3738 as_bad (_("bad floating literal: %s"), err
);
3739 ignore_rest_of_line ();
3747 /* This is like s_space, but the value is a floating point number with
3748 the given precision. This is for the MRI dcb.s pseudo-op and
3752 s_float_space (int float_type
)
3756 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3760 #ifdef md_cons_align
3765 stop
= mri_comment_field (&stopc
);
3767 count
= get_absolute_expression ();
3770 if (*input_line_pointer
!= ',')
3774 flen
= float_length (float_type
, &pad
);
3776 memset (temp
, 0, flen
+= pad
);
3780 ++input_line_pointer
;
3782 flen
= parse_one_float (float_type
, temp
);
3788 mri_comment_end (stop
, stopc
);
3792 while (--count
>= 0)
3796 p
= frag_more (flen
);
3797 memcpy (p
, temp
, (unsigned int) flen
);
3800 demand_empty_rest_of_line ();
3803 mri_comment_end (stop
, stopc
);
3806 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3809 s_struct (int ignore ATTRIBUTE_UNUSED
)
3815 stop
= mri_comment_field (&stopc
);
3816 abs_section_offset
= get_absolute_expression ();
3817 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3818 /* The ELF backend needs to know that we are changing sections, so
3819 that .previous works correctly. */
3821 obj_elf_section_change_hook ();
3823 subseg_set (absolute_section
, 0);
3824 demand_empty_rest_of_line ();
3826 mri_comment_end (stop
, stopc
);
3830 s_text (int ignore ATTRIBUTE_UNUSED
)
3834 temp
= get_absolute_expression ();
3835 subseg_set (text_section
, (subsegT
) temp
);
3836 demand_empty_rest_of_line ();
3839 /* .weakref x, y sets x as an alias to y that, as long as y is not
3840 referenced directly, will cause y to become a weak symbol. */
3842 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3849 if ((name
= read_symbol_name ()) == NULL
)
3852 symbolP
= symbol_find_or_make (name
);
3854 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3856 if (!S_IS_VOLATILE (symbolP
))
3858 as_bad (_("symbol `%s' is already defined"), name
);
3861 symbolP
= symbol_clone (symbolP
, 1);
3862 S_CLEAR_VOLATILE (symbolP
);
3867 if (*input_line_pointer
!= ',')
3869 as_bad (_("expected comma after \"%s\""), name
);
3873 input_line_pointer
++;
3878 if ((name
= read_symbol_name ()) == NULL
)
3881 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3882 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3884 symbolP2
= symbol_find_or_make (name
);
3885 S_SET_WEAKREFD (symbolP2
);
3889 symbolS
*symp
= symbolP2
;
3891 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3893 expressionS
*expP
= symbol_get_value_expression (symp
);
3895 gas_assert (expP
->X_op
== O_symbol
3896 && expP
->X_add_number
== 0);
3897 symp
= expP
->X_add_symbol
;
3899 if (symp
== symbolP
)
3903 loop
= concat (S_GET_NAME (symbolP
),
3904 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3907 while (symp
!= symbolP
)
3909 char *old_loop
= loop
;
3911 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3912 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3913 (const char *) NULL
);
3917 as_bad (_("%s: would close weakref loop: %s"),
3918 S_GET_NAME (symbolP
), loop
);
3922 ignore_rest_of_line ();
3926 /* Short-circuiting instead of just checking here might speed
3927 things up a tiny little bit, but loop error messages would
3928 miss intermediate links. */
3929 /* symbolP2 = symp; */
3932 memset (&exp
, 0, sizeof (exp
));
3933 exp
.X_op
= O_symbol
;
3934 exp
.X_add_symbol
= symbolP2
;
3936 S_SET_SEGMENT (symbolP
, undefined_section
);
3937 symbol_set_value_expression (symbolP
, &exp
);
3938 symbol_set_frag (symbolP
, &zero_address_frag
);
3939 S_SET_WEAKREFR (symbolP
);
3941 demand_empty_rest_of_line ();
3946 ignore_rest_of_line ();
3952 /* Verify that we are at the end of a line. If not, issue an error and
3953 skip to EOL. This function may leave input_line_pointer one past
3954 buffer_limit, so should not be called from places that may
3955 dereference input_line_pointer unconditionally. Note that when the
3956 gas parser is switched to handling a string (where buffer_limit
3957 should be the size of the string excluding the NUL terminator) this
3958 will be one past the NUL; is_end_of_line(0) returns true. */
3961 demand_empty_rest_of_line (void)
3964 if (input_line_pointer
> buffer_limit
)
3966 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3967 input_line_pointer
++;
3970 if (ISPRINT (*input_line_pointer
))
3971 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3972 *input_line_pointer
);
3974 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3975 *input_line_pointer
);
3976 ignore_rest_of_line ();
3978 /* Return pointing just after end-of-line. */
3981 /* Silently advance to the end of line. Use this after already having
3982 issued an error about something bad. Like demand_empty_rest_of_line,
3983 this function may leave input_line_pointer one after buffer_limit;
3984 Don't call it from within expression parsing code in an attempt to
3985 silence further errors. */
3988 ignore_rest_of_line (void)
3990 while (input_line_pointer
<= buffer_limit
)
3991 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3993 /* Return pointing just after end-of-line. */
3996 /* Sets frag for given symbol to zero_address_frag, except when the
3997 symbol frag is already set to a dummy listing frag. */
4000 set_zero_frag (symbolS
*symbolP
)
4002 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
4003 symbol_set_frag (symbolP
, &zero_address_frag
);
4006 /* In: Pointer to a symbol.
4007 Input_line_pointer->expression.
4009 Out: Input_line_pointer->just after any whitespace after expression.
4010 Tried to set symbol to value of expression.
4011 Will change symbols type, value, and frag; */
4014 pseudo_set (symbolS
*symbolP
)
4019 know (symbolP
); /* NULL pointer is logic error. */
4021 if (!S_IS_FORWARD_REF (symbolP
))
4022 (void) expression (&exp
);
4024 (void) deferred_expression (&exp
);
4026 if (exp
.X_op
== O_illegal
)
4027 as_bad (_("illegal expression"));
4028 else if (exp
.X_op
== O_absent
)
4029 as_bad (_("missing expression"));
4030 else if (exp
.X_op
== O_big
)
4032 if (exp
.X_add_number
> 0)
4033 as_bad (_("bignum invalid"));
4035 as_bad (_("floating point number invalid"));
4037 else if (exp
.X_op
== O_subtract
4038 && !S_IS_FORWARD_REF (symbolP
)
4039 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
4040 && (symbol_get_frag (exp
.X_add_symbol
)
4041 == symbol_get_frag (exp
.X_op_symbol
)))
4043 exp
.X_op
= O_constant
;
4044 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
4045 - S_GET_VALUE (exp
.X_op_symbol
));
4048 if (symbol_section_p (symbolP
))
4050 as_bad ("attempt to set value of section symbol");
4059 exp
.X_add_number
= 0;
4062 S_SET_SEGMENT (symbolP
, absolute_section
);
4063 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4064 set_zero_frag (symbolP
);
4068 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
4069 if (S_IS_EXTERNAL (symbolP
))
4071 as_bad ("can't equate global symbol `%s' with register name",
4072 S_GET_NAME (symbolP
));
4076 S_SET_SEGMENT (symbolP
, reg_section
);
4077 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4078 set_zero_frag (symbolP
);
4079 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
4083 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4084 /* For x=undef+const, create an expression symbol.
4085 For x=x+const, just update x except when x is an undefined symbol
4086 For x=defined+const, evaluate x. */
4087 if (symbolP
== exp
.X_add_symbol
4088 && (seg
!= undefined_section
4089 || !symbol_constant_p (symbolP
)))
4091 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4094 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4096 symbolS
*s
= exp
.X_add_symbol
;
4098 if (S_IS_COMMON (s
))
4099 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4100 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4102 S_SET_SEGMENT (symbolP
, seg
);
4103 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4104 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4105 copy_symbol_attributes (symbolP
, s
);
4108 S_SET_SEGMENT (symbolP
, undefined_section
);
4109 symbol_set_value_expression (symbolP
, &exp
);
4110 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4111 set_zero_frag (symbolP
);
4115 /* The value is some complex expression. */
4116 S_SET_SEGMENT (symbolP
, expr_section
);
4117 symbol_set_value_expression (symbolP
, &exp
);
4118 set_zero_frag (symbolP
);
4125 CONStruct more frag of .bytes, or .words etc.
4126 Should need_pass_2 be 1 then emit no frag(s).
4127 This understands EXPRESSIONS.
4131 This has a split personality. We use expression() to read the
4132 value. We can detect if the value won't fit in a byte or word.
4133 But we can't detect if expression() discarded significant digits
4134 in the case of a long. Not worth the crocks required to fix it. */
4136 /* Select a parser for cons expressions. */
4138 /* Some targets need to parse the expression in various fancy ways.
4139 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4140 (for example, the HPPA does this). Otherwise, you can define
4141 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4142 are defined, which is the normal case, then only simple expressions
4147 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4150 #ifndef TC_PARSE_CONS_EXPRESSION
4151 #ifdef REPEAT_CONS_EXPRESSIONS
4152 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4153 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4155 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4158 /* If we haven't gotten one yet, just call expression. */
4159 #ifndef TC_PARSE_CONS_EXPRESSION
4160 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4161 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4166 do_parse_cons_expression (expressionS
*exp
,
4167 int nbytes ATTRIBUTE_UNUSED
)
4169 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4173 /* Worker to do .byte etc statements.
4174 Clobbers input_line_pointer and checks end-of-line. */
4177 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4185 #ifdef md_flush_pending_output
4186 md_flush_pending_output ();
4190 stop
= mri_comment_field (&stopc
);
4192 if (is_it_end_of_statement ())
4194 demand_empty_rest_of_line ();
4196 mri_comment_end (stop
, stopc
);
4201 nbytes
= TC_ADDRESS_BYTES ();
4203 #ifdef md_cons_align
4204 md_cons_align (nbytes
);
4210 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4211 #ifdef TC_CONS_FIX_CHECK
4212 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4214 if (*cur_fix
!= NULL
)
4215 cur_fix
= &(*cur_fix
)->fx_next
;
4220 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4225 if (*input_line_pointer
== '"')
4227 as_bad (_("unexpected `\"' in expression"));
4228 ignore_rest_of_line ();
4232 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4237 if (exp
.X_op
== O_symbol
)
4238 exp
.X_op
= O_symbol_rva
;
4240 as_fatal (_("rva without symbol"));
4242 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4243 #ifdef TC_CONS_FIX_CHECK
4244 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4248 while (*input_line_pointer
++ == ',');
4250 /* In MRI mode, after an odd number of bytes, we must align to an
4251 even word boundary, unless the next instruction is a dc.b, ds.b
4253 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4254 mri_pending_align
= 1;
4256 input_line_pointer
--; /* Put terminator back into stream. */
4258 demand_empty_rest_of_line ();
4261 mri_comment_end (stop
, stopc
);
4267 cons_worker (size
, 0);
4273 cons_worker (size
, 1);
4276 /* .reloc offset, reloc_name, symbol+addend. */
4279 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4286 struct reloc_list
*reloc
;
4287 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4288 static struct _bfd_rel bfd_relocs
[] =
4290 { "NONE", BFD_RELOC_NONE
},
4291 { "8", BFD_RELOC_8
},
4292 { "16", BFD_RELOC_16
},
4293 { "32", BFD_RELOC_32
},
4294 { "64", BFD_RELOC_64
}
4297 reloc
= XNEW (struct reloc_list
);
4300 stop
= mri_comment_field (&stopc
);
4309 as_bad (_("missing or bad offset expression"));
4312 exp
.X_add_symbol
= section_symbol (now_seg
);
4313 /* Mark the section symbol used in relocation so that it will be
4314 included in the symbol table. */
4315 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4316 exp
.X_op
= O_symbol
;
4319 if (exp
.X_add_number
== 0)
4321 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4326 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4331 if (*input_line_pointer
!= ',')
4333 as_bad (_("missing reloc type"));
4337 ++input_line_pointer
;
4339 c
= get_symbol_name (& r_name
);
4340 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4344 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4345 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4347 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4348 bfd_relocs
[i
].code
);
4353 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4354 *input_line_pointer
= c
;
4355 if (reloc
->u
.a
.howto
== NULL
)
4357 as_bad (_("unrecognized reloc type"));
4361 exp
.X_op
= O_absent
;
4362 SKIP_WHITESPACE_AFTER_NAME ();
4363 if (*input_line_pointer
== ',')
4365 ++input_line_pointer
;
4373 as_bad (_("bad reloc expression"));
4375 ignore_rest_of_line ();
4378 mri_comment_end (stop
, stopc
);
4381 reloc
->u
.a
.sym
= NULL
;
4382 reloc
->u
.a
.addend
= 0;
4385 reloc
->u
.a
.sym
= NULL
;
4386 reloc
->u
.a
.addend
= exp
.X_add_number
;
4389 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4390 reloc
->u
.a
.addend
= exp
.X_add_number
;
4393 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4394 reloc
->u
.a
.addend
= 0;
4398 reloc
->file
= as_where (&reloc
->line
);
4399 reloc
->next
= reloc_list
;
4402 demand_empty_rest_of_line ();
4404 mri_comment_end (stop
, stopc
);
4407 /* Put the contents of expression EXP into the object file using
4408 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4411 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4413 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4417 emit_expr_with_reloc (expressionS
*exp
,
4418 unsigned int nbytes
,
4419 TC_PARSE_CONS_RETURN_TYPE reloc
)
4423 valueT extra_digit
= 0;
4425 /* Don't do anything if we are going to make another pass. */
4430 dot_value
= frag_now_fix ();
4431 dot_frag
= frag_now
;
4435 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4436 appear as a four byte positive constant in the .line section,
4437 followed by a 2 byte 0xffff. Look for that case here. */
4439 static int dwarf_line
= -1;
4441 if (strcmp (segment_name (now_seg
), ".line") != 0)
4443 else if (dwarf_line
>= 0
4445 && exp
->X_op
== O_constant
4446 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4447 listing_source_line ((unsigned int) dwarf_line
);
4448 else if (nbytes
== 4
4449 && exp
->X_op
== O_constant
4450 && exp
->X_add_number
>= 0)
4451 dwarf_line
= exp
->X_add_number
;
4456 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4457 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4458 AT_sibling (0x12) followed by a four byte address of the sibling
4459 followed by a 2 byte AT_name (0x38) followed by the name of the
4460 file. We look for that case here. */
4462 static int dwarf_file
= 0;
4464 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4466 else if (dwarf_file
== 0
4468 && exp
->X_op
== O_constant
4469 && exp
->X_add_number
== 0x11)
4471 else if (dwarf_file
== 1
4473 && exp
->X_op
== O_constant
4474 && exp
->X_add_number
== 0x12)
4476 else if (dwarf_file
== 2
4479 else if (dwarf_file
== 3
4481 && exp
->X_op
== O_constant
4482 && exp
->X_add_number
== 0x38)
4487 /* The variable dwarf_file_string tells stringer that the string
4488 may be the name of the source file. */
4489 if (dwarf_file
== 4)
4490 dwarf_file_string
= 1;
4492 dwarf_file_string
= 0;
4497 if (check_eh_frame (exp
, &nbytes
))
4502 /* Handle a negative bignum. */
4504 && exp
->X_add_number
== 0
4505 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4506 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4509 unsigned long carry
;
4511 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4513 /* Negate the bignum: one's complement each digit and add 1. */
4515 for (i
= 0; i
< exp
->X_add_number
; i
++)
4519 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4522 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4523 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4526 /* We can ignore any carry out, because it will be handled by
4527 extra_digit if it is needed. */
4529 extra_digit
= (valueT
) -1;
4533 if (op
== O_absent
|| op
== O_illegal
)
4535 as_warn (_("zero assumed for missing expression"));
4536 exp
->X_add_number
= 0;
4539 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4541 as_bad (_("floating point number invalid"));
4542 exp
->X_add_number
= 0;
4545 else if (op
== O_register
)
4547 as_warn (_("register value used as expression"));
4551 /* Allow `.word 0' in the absolute section. */
4552 if (now_seg
== absolute_section
)
4554 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4555 as_bad (_("attempt to store value in absolute section"));
4556 abs_section_offset
+= nbytes
;
4560 /* Allow `.word 0' in BSS style sections. */
4561 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4562 as_bad (_("attempt to store non-zero value in section `%s'"),
4563 segment_name (now_seg
));
4565 p
= frag_more ((int) nbytes
);
4567 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4569 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4573 #ifndef WORKING_DOT_WORD
4574 /* If we have the difference of two symbols in a word, save it on
4575 the broken_words list. See the code in write.c. */
4576 if (op
== O_subtract
&& nbytes
== 2)
4578 struct broken_word
*x
;
4580 x
= XNEW (struct broken_word
);
4581 x
->next_broken_word
= broken_words
;
4584 x
->subseg
= now_subseg
;
4586 x
->word_goes_here
= p
;
4588 x
->add
= exp
->X_add_symbol
;
4589 x
->sub
= exp
->X_op_symbol
;
4590 x
->addnum
= exp
->X_add_number
;
4598 /* If we have an integer, but the number of bytes is too large to
4599 pass to md_number_to_chars, handle it as a bignum. */
4600 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4602 extra_digit
= exp
->X_unsigned
? 0 : -1;
4603 convert_to_bignum (exp
, !exp
->X_unsigned
);
4607 if (op
== O_constant
)
4614 /* JF << of >= number of bits in the object is undefined. In
4615 particular SPARC (Sun 4) has problems. */
4616 if (nbytes
>= sizeof (valueT
))
4618 know (nbytes
== sizeof (valueT
));
4623 /* Don't store these bits. */
4624 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4627 unmask
= ~mask
; /* Do store these bits. */
4630 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4631 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4634 get
= exp
->X_add_number
;
4636 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4641 /* These buffers help to ease the translation of the warning message. */
4642 sprintf_vma (get_buf
, get
);
4643 sprintf_vma (use_buf
, use
);
4644 /* Leading bits contain both 0s & 1s. */
4645 as_warn (_("value 0x%s truncated to 0x%s"), get_buf
, use_buf
);
4647 /* Put bytes in right order. */
4648 md_number_to_chars (p
, use
, (int) nbytes
);
4650 else if (op
== O_big
)
4653 LITTLENUM_TYPE
*nums
;
4655 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4658 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4662 LITTLENUM_TYPE sign
= 0;
4663 if ((generic_bignum
[--i
]
4664 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4665 sign
= ~(LITTLENUM_TYPE
) 0;
4667 while (++i
< exp
->X_add_number
)
4668 if (generic_bignum
[i
] != sign
)
4671 else if (nbytes
== 1)
4673 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4674 Check that bits 8.. of generic_bignum[0] match bit 7
4675 and that they match all of generic_bignum[1..exp->X_add_number]. */
4676 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4677 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4679 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4681 while (++i
< exp
->X_add_number
)
4682 if (generic_bignum
[i
] != sign
)
4687 if (i
< exp
->X_add_number
)
4688 as_warn (ngettext ("bignum truncated to %d byte",
4689 "bignum truncated to %d bytes",
4697 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4700 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4702 if (target_big_endian
)
4704 while (nbytes
> size
)
4706 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4707 nbytes
-= CHARS_PER_LITTLENUM
;
4708 p
+= CHARS_PER_LITTLENUM
;
4711 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4712 while (size
>= CHARS_PER_LITTLENUM
)
4715 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4716 size
-= CHARS_PER_LITTLENUM
;
4717 p
+= CHARS_PER_LITTLENUM
;
4722 nums
= generic_bignum
;
4723 while (size
>= CHARS_PER_LITTLENUM
)
4725 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4727 size
-= CHARS_PER_LITTLENUM
;
4728 p
+= CHARS_PER_LITTLENUM
;
4729 nbytes
-= CHARS_PER_LITTLENUM
;
4732 while (nbytes
>= CHARS_PER_LITTLENUM
)
4734 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4735 nbytes
-= CHARS_PER_LITTLENUM
;
4736 p
+= CHARS_PER_LITTLENUM
;
4741 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4745 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4746 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4749 unsigned int size
= nbytes
;
4751 memset (p
, 0, size
);
4753 /* Generate a fixS to record the symbol value. */
4755 #ifdef TC_CONS_FIX_NEW
4756 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4758 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4760 reloc_howto_type
*reloc_howto
;
4762 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4763 size
= bfd_get_reloc_size (reloc_howto
);
4767 as_bad (ngettext ("%s relocations do not fit in %u byte",
4768 "%s relocations do not fit in %u bytes",
4770 reloc_howto
->name
, nbytes
);
4773 else if (target_big_endian
)
4774 offset
= nbytes
- size
;
4795 as_bad (_("unsupported BFD relocation size %u"), size
);
4798 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4803 /* Handle an MRI style string expression. */
4807 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4809 if (*input_line_pointer
!= '\''
4810 && (input_line_pointer
[1] != '\''
4811 || (*input_line_pointer
!= 'A'
4812 && *input_line_pointer
!= 'E')))
4813 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4817 unsigned int result
= 0;
4819 /* An MRI style string. Cut into as many bytes as will fit into
4820 a nbyte chunk, left justify if necessary, and separate with
4821 commas so we can try again later. */
4822 if (*input_line_pointer
== 'A')
4823 ++input_line_pointer
;
4824 else if (*input_line_pointer
== 'E')
4826 as_bad (_("EBCDIC constants are not supported"));
4827 ++input_line_pointer
;
4830 input_line_pointer
++;
4831 for (scan
= 0; scan
< nbytes
; scan
++)
4833 if (*input_line_pointer
== '\'')
4835 if (input_line_pointer
[1] == '\'')
4837 input_line_pointer
++;
4842 result
= (result
<< 8) | (*input_line_pointer
++);
4846 while (scan
< nbytes
)
4852 /* Create correct expression. */
4853 exp
->X_op
= O_constant
;
4854 exp
->X_add_number
= result
;
4856 /* Fake it so that we can read the next char too. */
4857 if (input_line_pointer
[0] != '\'' ||
4858 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4860 input_line_pointer
-= 2;
4861 input_line_pointer
[0] = ',';
4862 input_line_pointer
[1] = '\'';
4865 input_line_pointer
++;
4868 #endif /* TC_M68K */
4870 #ifdef REPEAT_CONS_EXPRESSIONS
4872 /* Parse a repeat expression for cons. This is used by the MIPS
4873 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4874 object file COUNT times.
4876 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4879 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4886 if (*input_line_pointer
!= ':')
4888 /* No repeat count. */
4892 ++input_line_pointer
;
4893 expression (&count
);
4894 if (count
.X_op
!= O_constant
4895 || count
.X_add_number
<= 0)
4897 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4901 /* The cons function is going to output this expression once. So we
4902 output it count - 1 times. */
4903 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4904 emit_expr (exp
, nbytes
);
4907 #endif /* REPEAT_CONS_EXPRESSIONS */
4909 /* Parse a floating point number represented as a hex constant. This
4910 permits users to specify the exact bits they want in the floating
4914 hex_float (int float_type
, char *bytes
)
4916 int pad
, length
= float_length (float_type
, &pad
);
4922 /* It would be nice if we could go through expression to parse the
4923 hex constant, but if we get a bignum it's a pain to sort it into
4924 the buffer correctly. */
4926 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4930 /* The MRI assembler accepts arbitrary underscores strewn about
4931 through the hex constant, so we ignore them as well. */
4932 if (*input_line_pointer
== '_')
4934 ++input_line_pointer
;
4940 as_warn (_("floating point constant too large"));
4943 d
= hex_value (*input_line_pointer
) << 4;
4944 ++input_line_pointer
;
4945 while (*input_line_pointer
== '_')
4946 ++input_line_pointer
;
4947 if (hex_p (*input_line_pointer
))
4949 d
+= hex_value (*input_line_pointer
);
4950 ++input_line_pointer
;
4952 if (target_big_endian
)
4955 bytes
[length
- i
- 1] = d
;
4961 if (target_big_endian
)
4962 memset (bytes
+ i
, 0, length
- i
);
4964 memset (bytes
, 0, length
- i
);
4967 memset (bytes
+ length
, 0, pad
);
4969 return length
+ pad
;
4974 CONStruct some more frag chars of .floats .ffloats etc.
4975 Makes 0 or more new frags.
4976 If need_pass_2 == 1, no frags are emitted.
4977 This understands only floating literals, not expressions. Sorry.
4979 A floating constant is defined by atof_generic(), except it is preceded
4980 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4981 reading, I decided to be incompatible. This always tries to give you
4982 rounded bits to the precision of the pseudo-op. Former AS did premature
4983 truncation, restored noisy bits instead of trailing 0s AND gave you
4984 a choice of 2 flavours of noise according to which of 2 floating-point
4985 scanners you directed AS to use.
4987 In: input_line_pointer->whitespace before, or '0' of flonum. */
4990 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4991 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4994 int length
; /* Number of chars in an object. */
4995 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4997 if (is_it_end_of_statement ())
4999 demand_empty_rest_of_line ();
5003 if (now_seg
== absolute_section
)
5005 as_bad (_("attempt to store float in absolute section"));
5006 ignore_rest_of_line ();
5012 as_bad (_("attempt to store float in section `%s'"),
5013 segment_name (now_seg
));
5014 ignore_rest_of_line ();
5018 #ifdef md_flush_pending_output
5019 md_flush_pending_output ();
5022 #ifdef md_cons_align
5028 length
= parse_one_float (float_type
, temp
);
5038 #ifdef REPEAT_CONS_EXPRESSIONS
5039 if (*input_line_pointer
== ':')
5041 expressionS count_exp
;
5043 ++input_line_pointer
;
5044 expression (&count_exp
);
5046 if (count_exp
.X_op
!= O_constant
5047 || count_exp
.X_add_number
<= 0)
5048 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5050 count
= count_exp
.X_add_number
;
5054 while (--count
>= 0)
5056 p
= frag_more (length
);
5057 memcpy (p
, temp
, (unsigned int) length
);
5062 while (*input_line_pointer
++ == ',');
5064 /* Put terminator back into stream. */
5065 --input_line_pointer
;
5066 demand_empty_rest_of_line ();
5071 Note - we are using the DWARF standard's definition of LEB128 encoding
5072 where each 7-bit value is a stored in a byte, *not* an octet. This
5073 means that on targets where a byte contains multiple octets there is
5074 a *huge waste of space*. (This also means that we do not have to
5075 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5078 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5079 we would then have to consider whether multiple, successive LEB128
5080 values should be packed into the bytes without padding (bad idea) or
5081 whether each LEB128 number is padded out to a whole number of bytes.
5082 Plus you have to decide on the endianness of packing octets into a
5085 /* Return the size of a LEB128 value in bytes. */
5087 static inline unsigned int
5088 sizeof_sleb128 (offsetT value
)
5095 byte
= (value
& 0x7f);
5096 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5097 Fortunately, we can structure things so that the extra work reduces
5098 to a noop on systems that do things "properly". */
5099 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5102 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5103 || ((value
== -1) && ((byte
& 0x40) != 0))));
5108 static inline unsigned int
5109 sizeof_uleb128 (valueT value
)
5124 sizeof_leb128 (valueT value
, int sign
)
5127 return sizeof_sleb128 ((offsetT
) value
);
5129 return sizeof_uleb128 (value
);
5132 /* Output a LEB128 value. Returns the number of bytes used. */
5134 static inline unsigned int
5135 output_sleb128 (char *p
, offsetT value
)
5142 unsigned byte
= (value
& 0x7f);
5144 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5145 Fortunately, we can structure things so that the extra work reduces
5146 to a noop on systems that do things "properly". */
5147 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5149 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5150 || ((value
== -1) && ((byte
& 0x40) != 0))));
5161 static inline unsigned int
5162 output_uleb128 (char *p
, valueT value
)
5168 unsigned byte
= (value
& 0x7f);
5172 /* More bytes to follow. */
5183 output_leb128 (char *p
, valueT value
, int sign
)
5186 return output_sleb128 (p
, (offsetT
) value
);
5188 return output_uleb128 (p
, value
);
5191 /* Do the same for bignums. We combine sizeof with output here in that
5192 we don't output for NULL values of P. It isn't really as critical as
5193 for "normal" values that this be streamlined. Returns the number of
5196 static inline unsigned int
5197 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5204 /* Strip leading sign extensions off the bignum. */
5206 && bignum
[size
- 1] == LITTLENUM_MASK
5207 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5212 /* OR in the next part of the littlenum. */
5213 val
|= (*bignum
<< loaded
);
5214 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5218 /* Add bytes until there are less than 7 bits left in VAL
5219 or until every non-sign bit has been written. */
5226 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5233 while ((byte
& 0x80) != 0 && loaded
>= 7);
5237 /* Mop up any left-over bits (of which there will be less than 7). */
5238 if ((byte
& 0x80) != 0)
5240 /* Sign-extend VAL. */
5241 if (val
& (1 << (loaded
- 1)))
5242 val
|= ~0U << loaded
;
5251 static inline unsigned int
5252 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5259 /* Strip leading zeros off the bignum. */
5260 /* XXX: Is this needed? */
5261 while (size
> 0 && bignum
[size
- 1] == 0)
5266 if (loaded
< 7 && size
> 0)
5268 val
|= (*bignum
<< loaded
);
5269 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5278 if (size
> 0 || val
)
5285 while (byte
& 0x80);
5291 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5294 return output_big_sleb128 (p
, bignum
, size
);
5296 return output_big_uleb128 (p
, bignum
, size
);
5299 /* Generate the appropriate fragments for a given expression to emit a
5300 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5303 emit_leb128_expr (expressionS
*exp
, int sign
)
5305 operatorT op
= exp
->X_op
;
5306 unsigned int nbytes
;
5308 if (op
== O_absent
|| op
== O_illegal
)
5310 as_warn (_("zero assumed for missing expression"));
5311 exp
->X_add_number
= 0;
5314 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5316 as_bad (_("floating point number invalid"));
5317 exp
->X_add_number
= 0;
5320 else if (op
== O_register
)
5322 as_warn (_("register value used as expression"));
5325 else if (op
== O_constant
5327 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5329 /* We're outputting a signed leb128 and the sign of X_add_number
5330 doesn't reflect the sign of the original value. Convert EXP
5331 to a correctly-extended bignum instead. */
5332 convert_to_bignum (exp
, exp
->X_extrabit
);
5336 if (now_seg
== absolute_section
)
5338 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5339 as_bad (_("attempt to store value in absolute section"));
5340 abs_section_offset
++;
5344 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5345 as_bad (_("attempt to store non-zero value in section `%s'"),
5346 segment_name (now_seg
));
5348 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5349 a signal that this is leb128 data. It shouldn't optimize this away. */
5350 nbytes
= (unsigned int) -1;
5351 if (check_eh_frame (exp
, &nbytes
))
5354 /* Let the backend know that subsequent data may be byte aligned. */
5355 #ifdef md_cons_align
5359 if (op
== O_constant
)
5361 /* If we've got a constant, emit the thing directly right now. */
5363 valueT value
= exp
->X_add_number
;
5367 size
= sizeof_leb128 (value
, sign
);
5368 p
= frag_more (size
);
5369 if (output_leb128 (p
, value
, sign
) > size
)
5372 else if (op
== O_big
)
5374 /* O_big is a different sort of constant. */
5375 int nbr_digits
= exp
->X_add_number
;
5379 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5380 a signed number. Unary operators like - or ~ always extend the
5381 bignum to its largest size. */
5383 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5384 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5385 generic_bignum
[nbr_digits
++] = 0;
5387 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5388 p
= frag_more (size
);
5389 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5394 /* Otherwise, we have to create a variable sized fragment and
5395 resolve things later. */
5397 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5398 make_expr_symbol (exp
), 0, (char *) NULL
);
5402 /* Parse the .sleb128 and .uleb128 pseudos. */
5409 #ifdef md_flush_pending_output
5410 md_flush_pending_output ();
5416 emit_leb128_expr (&exp
, sign
);
5418 while (*input_line_pointer
++ == ',');
5420 input_line_pointer
--;
5421 demand_empty_rest_of_line ();
5425 stringer_append_char (int c
, int bitsize
)
5428 as_bad (_("attempt to store non-empty string in section `%s'"),
5429 segment_name (now_seg
));
5431 if (!target_big_endian
)
5432 FRAG_APPEND_1_CHAR (c
);
5437 FRAG_APPEND_1_CHAR (0);
5438 FRAG_APPEND_1_CHAR (0);
5439 FRAG_APPEND_1_CHAR (0);
5440 FRAG_APPEND_1_CHAR (0);
5443 FRAG_APPEND_1_CHAR (0);
5444 FRAG_APPEND_1_CHAR (0);
5447 FRAG_APPEND_1_CHAR (0);
5452 /* Called with invalid bitsize argument. */
5456 if (target_big_endian
)
5457 FRAG_APPEND_1_CHAR (c
);
5460 /* Worker to do .ascii etc statements.
5461 Reads 0 or more ',' separated, double-quoted strings.
5462 Caller should have checked need_pass_2 is FALSE because we don't
5464 Checks for end-of-line.
5465 BITS_APPENDZERO says how many bits are in a target char.
5466 The bottom bit is set if a NUL char should be appended to the strings. */
5469 stringer (int bits_appendzero
)
5471 const int bitsize
= bits_appendzero
& ~7;
5472 const int append_zero
= bits_appendzero
& 1;
5474 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5478 #ifdef md_flush_pending_output
5479 md_flush_pending_output ();
5482 #ifdef md_cons_align
5486 /* If we have been switched into the abs_section then we
5487 will not have an obstack onto which we can hang strings. */
5488 if (now_seg
== absolute_section
)
5490 as_bad (_("strings must be placed into a section"));
5491 ignore_rest_of_line ();
5495 /* The following awkward logic is to parse ZERO or more strings,
5496 comma separated. Recall a string expression includes spaces
5497 before the opening '\"' and spaces after the closing '\"'.
5498 We fake a leading ',' if there is (supposed to be)
5499 a 1st, expression. We keep demanding expressions for each ','. */
5500 if (is_it_end_of_statement ())
5502 c
= 0; /* Skip loop. */
5503 ++input_line_pointer
; /* Compensate for end of loop. */
5507 c
= ','; /* Do loop. */
5510 while (c
== ',' || c
== '<' || c
== '"')
5513 switch (*input_line_pointer
)
5516 ++input_line_pointer
; /*->1st char of string. */
5517 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5518 start
= input_line_pointer
;
5521 while (is_a_char (c
= next_char_of_string ()))
5522 stringer_append_char (c
, bitsize
);
5524 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5525 SKIP_ALL_WHITESPACE ();
5526 if (*input_line_pointer
== '"')
5530 stringer_append_char (0, bitsize
);
5532 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5533 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5534 will emit .string with a filename in the .debug section
5535 after a sequence of constants. See the comment in
5536 emit_expr for the sequence. emit_expr will set
5537 dwarf_file_string to non-zero if this string might be a
5538 source file name. */
5539 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5540 dwarf_file_string
= 0;
5541 else if (dwarf_file_string
)
5543 c
= input_line_pointer
[-1];
5544 input_line_pointer
[-1] = '\0';
5545 listing_source_file (start
);
5546 input_line_pointer
[-1] = c
;
5552 input_line_pointer
++;
5553 c
= get_single_number ();
5554 stringer_append_char (c
, bitsize
);
5555 if (*input_line_pointer
!= '>')
5557 as_bad (_("expected <nn>"));
5558 ignore_rest_of_line ();
5561 input_line_pointer
++;
5564 input_line_pointer
++;
5568 c
= *input_line_pointer
;
5571 demand_empty_rest_of_line ();
5574 /* FIXME-SOMEDAY: I had trouble here on characters with the
5575 high bits set. We'll probably also have trouble with
5576 multibyte chars, wide chars, etc. Also be careful about
5577 returning values bigger than 1 byte. xoxorich. */
5580 next_char_of_string (void)
5584 c
= *input_line_pointer
++ & CHAR_MASK
;
5588 /* PR 20902: Do not advance past the end of the buffer. */
5589 -- input_line_pointer
;
5598 as_warn (_("unterminated string; newline inserted"));
5599 bump_line_counters ();
5603 if (!TC_STRING_ESCAPES
)
5605 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5633 break; /* As itself. */
5649 for (i
= 0, number
= 0;
5650 ISDIGIT (c
) && i
< 3;
5651 c
= *input_line_pointer
++, i
++)
5653 number
= number
* 8 + c
- '0';
5656 c
= number
& CHAR_MASK
;
5658 --input_line_pointer
;
5667 c
= *input_line_pointer
++;
5668 while (ISXDIGIT (c
))
5671 number
= number
* 16 + c
- '0';
5672 else if (ISUPPER (c
))
5673 number
= number
* 16 + c
- 'A' + 10;
5675 number
= number
* 16 + c
- 'a' + 10;
5676 c
= *input_line_pointer
++;
5678 c
= number
& CHAR_MASK
;
5679 --input_line_pointer
;
5684 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5685 as_warn (_("unterminated string; newline inserted"));
5687 bump_line_counters ();
5691 /* Do not advance past the end of the buffer. */
5692 -- input_line_pointer
;
5698 #ifdef ONLY_STANDARD_ESCAPES
5699 as_bad (_("bad escaped character in string"));
5701 #endif /* ONLY_STANDARD_ESCAPES */
5714 get_segmented_expression (expressionS
*expP
)
5718 retval
= expression (expP
);
5719 if (expP
->X_op
== O_illegal
5720 || expP
->X_op
== O_absent
5721 || expP
->X_op
== O_big
)
5723 as_bad (_("expected address expression"));
5724 expP
->X_op
= O_constant
;
5725 expP
->X_add_number
= 0;
5726 retval
= absolute_section
;
5732 get_known_segmented_expression (expressionS
*expP
)
5734 segT retval
= get_segmented_expression (expP
);
5736 if (retval
== undefined_section
)
5738 /* There is no easy way to extract the undefined symbol from the
5740 if (expP
->X_add_symbol
!= NULL
5741 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5742 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5743 S_GET_NAME (expP
->X_add_symbol
));
5745 as_warn (_("some symbol undefined; zero assumed"));
5746 retval
= absolute_section
;
5747 expP
->X_op
= O_constant
;
5748 expP
->X_add_number
= 0;
5753 char /* Return terminator. */
5754 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5756 /* FIXME: val_pointer should probably be offsetT *. */
5757 *val_pointer
= (long) get_absolute_expression ();
5758 return (*input_line_pointer
++);
5761 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5762 Give a warning if that happens. */
5765 demand_copy_C_string (int *len_pointer
)
5769 if ((s
= demand_copy_string (len_pointer
)) != 0)
5773 for (len
= *len_pointer
; len
> 0; len
--)
5775 if (s
[len
- 1] == 0)
5779 as_bad (_("this string may not contain \'\\0\'"));
5788 /* Demand string, but return a safe (=private) copy of the string.
5789 Return NULL if we can't read a string here. */
5792 demand_copy_string (int *lenP
)
5800 if (*input_line_pointer
== '\"')
5802 input_line_pointer
++; /* Skip opening quote. */
5804 while (is_a_char (c
= next_char_of_string ()))
5806 obstack_1grow (¬es
, c
);
5809 /* JF this next line is so demand_copy_C_string will return a
5810 null terminated string. */
5811 obstack_1grow (¬es
, '\0');
5812 retval
= (char *) obstack_finish (¬es
);
5816 as_bad (_("missing string"));
5818 ignore_rest_of_line ();
5824 /* In: Input_line_pointer->next character.
5826 Do: Skip input_line_pointer over all whitespace.
5828 Out: 1 if input_line_pointer->end-of-line. */
5831 is_it_end_of_statement (void)
5834 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5838 equals (char *sym_name
, int reassign
)
5843 input_line_pointer
++;
5844 if (*input_line_pointer
== '=')
5845 input_line_pointer
++;
5846 if (reassign
< 0 && *input_line_pointer
== '=')
5847 input_line_pointer
++;
5849 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5850 input_line_pointer
++;
5853 stop
= mri_comment_field (&stopc
);
5855 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5859 demand_empty_rest_of_line ();
5860 mri_comment_end (stop
, stopc
);
5864 /* .incbin -- include a file verbatim at the current location. */
5867 s_incbin (int x ATTRIBUTE_UNUSED
)
5878 #ifdef md_flush_pending_output
5879 md_flush_pending_output ();
5882 #ifdef md_cons_align
5887 filename
= demand_copy_string (& len
);
5888 if (filename
== NULL
)
5893 /* Look for optional skip and count. */
5894 if (* input_line_pointer
== ',')
5896 ++ input_line_pointer
;
5897 skip
= get_absolute_expression ();
5901 if (* input_line_pointer
== ',')
5903 ++ input_line_pointer
;
5905 count
= get_absolute_expression ();
5907 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5913 demand_empty_rest_of_line ();
5915 /* Try opening absolute path first, then try include dirs. */
5916 binfile
= fopen (filename
, FOPEN_RB
);
5917 if (binfile
== NULL
)
5921 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5923 for (i
= 0; i
< include_dir_count
; i
++)
5925 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5927 binfile
= fopen (path
, FOPEN_RB
);
5928 if (binfile
!= NULL
)
5932 if (binfile
== NULL
)
5933 as_bad (_("file not found: %s"), filename
);
5936 path
= xstrdup (filename
);
5941 struct stat filestat
;
5943 if (fstat (fileno (binfile
), &filestat
) != 0
5944 || ! S_ISREG (filestat
.st_mode
)
5945 || S_ISDIR (filestat
.st_mode
))
5947 as_bad (_("unable to include `%s'"), path
);
5951 register_dependency (path
);
5953 /* Compute the length of the file. */
5954 if (fseek (binfile
, 0, SEEK_END
) != 0)
5956 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5959 file_len
= ftell (binfile
);
5961 /* If a count was not specified use the remainder of the file. */
5963 count
= file_len
- skip
;
5965 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5967 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5968 skip
, count
, file_len
);
5972 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5974 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5978 /* Allocate frag space and store file contents in it. */
5979 binfrag
= frag_more (count
);
5981 bytes
= fread (binfrag
, 1, count
, binfile
);
5983 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5984 path
, bytes
, count
);
5987 if (binfile
!= NULL
)
5992 /* .include -- include a file at this point. */
5995 s_include (int arg ATTRIBUTE_UNUSED
)
6004 filename
= demand_copy_string (&i
);
6005 if (filename
== NULL
)
6007 /* demand_copy_string has already printed an error and
6008 called ignore_rest_of_line. */
6016 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
6017 && *input_line_pointer
!= ' '
6018 && *input_line_pointer
!= '\t')
6020 obstack_1grow (¬es
, *input_line_pointer
);
6021 ++input_line_pointer
;
6025 obstack_1grow (¬es
, '\0');
6026 filename
= (char *) obstack_finish (¬es
);
6027 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
6028 ++input_line_pointer
;
6031 demand_empty_rest_of_line ();
6032 path
= XNEWVEC (char, (unsigned long) i
6033 + include_dir_maxlen
+ 5 /* slop */ );
6035 for (i
= 0; i
< include_dir_count
; i
++)
6037 strcpy (path
, include_dirs
[i
]);
6039 strcat (path
, filename
);
6040 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
6050 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
6051 register_dependency (path
);
6052 input_scrub_insert_file (path
);
6056 add_include_dir (char *path
)
6060 if (include_dir_count
== 0)
6062 include_dirs
= XNEWVEC (const char *, 2);
6063 include_dirs
[0] = "."; /* Current dir. */
6064 include_dir_count
= 2;
6068 include_dir_count
++;
6069 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6073 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6076 if (i
> include_dir_maxlen
)
6077 include_dir_maxlen
= i
;
6080 /* Output debugging information to denote the source file. */
6083 generate_file_debug (void)
6085 if (debug_type
== DEBUG_STABS
)
6086 stabs_generate_asm_file ();
6089 /* Output line number debugging information for the current source line. */
6092 generate_lineno_debug (void)
6096 case DEBUG_UNSPECIFIED
:
6101 stabs_generate_asm_lineno ();
6104 ecoff_generate_asm_lineno ();
6107 /* ??? We could here indicate to dwarf2dbg.c that something
6108 has changed. However, since there is additional backend
6109 support that is required (calling dwarf2_emit_insn), we
6110 let dwarf2dbg.c call as_where on its own. */
6115 /* Output debugging information to mark a function entry point or end point.
6116 END_P is zero for .func, and non-zero for .endfunc. */
6121 do_s_func (end_p
, NULL
);
6124 /* Subroutine of s_func so targets can choose a different default prefix.
6125 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6128 do_s_func (int end_p
, const char *default_prefix
)
6130 /* Record the current function so that we can issue an error message for
6131 misplaced .func,.endfunc, and also so that .endfunc needs no
6133 static char *current_name
;
6134 static char *current_label
;
6138 if (current_name
== NULL
)
6140 as_bad (_("missing .func"));
6141 ignore_rest_of_line ();
6145 if (debug_type
== DEBUG_STABS
)
6146 stabs_generate_asm_endfunc (current_name
, current_label
);
6148 current_name
= current_label
= NULL
;
6153 char delim1
, delim2
;
6155 if (current_name
!= NULL
)
6157 as_bad (_(".endfunc missing for previous .func"));
6158 ignore_rest_of_line ();
6162 delim1
= get_symbol_name (& name
);
6163 name
= xstrdup (name
);
6164 *input_line_pointer
= delim1
;
6165 SKIP_WHITESPACE_AFTER_NAME ();
6166 if (*input_line_pointer
!= ',')
6170 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6171 as_fatal ("%s", xstrerror (errno
));
6175 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6176 /* Missing entry point, use function's name with the leading
6180 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6181 as_fatal ("%s", xstrerror (errno
));
6189 ++input_line_pointer
;
6191 delim2
= get_symbol_name (& label
);
6192 label
= xstrdup (label
);
6193 restore_line_pointer (delim2
);
6196 if (debug_type
== DEBUG_STABS
)
6197 stabs_generate_asm_func (name
, label
);
6199 current_name
= name
;
6200 current_label
= label
;
6203 demand_empty_rest_of_line ();
6206 #ifdef HANDLE_BUNDLE
6209 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6211 unsigned int align
= get_absolute_expression ();
6213 demand_empty_rest_of_line ();
6215 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6216 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6217 (unsigned int) TC_ALIGN_LIMIT
);
6219 if (bundle_lock_frag
!= NULL
)
6221 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6225 bundle_align_p2
= align
;
6229 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6231 demand_empty_rest_of_line ();
6233 if (bundle_align_p2
== 0)
6235 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6239 if (bundle_lock_depth
== 0)
6241 bundle_lock_frchain
= frchain_now
;
6242 bundle_lock_frag
= start_bundle ();
6244 ++bundle_lock_depth
;
6248 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6252 demand_empty_rest_of_line ();
6254 if (bundle_lock_frag
== NULL
)
6256 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6260 gas_assert (bundle_align_p2
> 0);
6262 gas_assert (bundle_lock_depth
> 0);
6263 if (--bundle_lock_depth
> 0)
6266 size
= pending_bundle_size (bundle_lock_frag
);
6268 if (size
> 1U << bundle_align_p2
)
6269 as_bad (_(".bundle_lock sequence is %u bytes, "
6270 "but bundle size is only %u bytes"),
6271 size
, 1u << bundle_align_p2
);
6273 finish_bundle (bundle_lock_frag
, size
);
6275 bundle_lock_frag
= NULL
;
6276 bundle_lock_frchain
= NULL
;
6279 #endif /* HANDLE_BUNDLE */
6282 s_ignore (int arg ATTRIBUTE_UNUSED
)
6284 ignore_rest_of_line ();
6288 read_print_statistics (FILE *file
)
6290 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6293 /* Inserts the given line into the input stream.
6295 This call avoids macro/conditionals nesting checking, since the contents of
6296 the line are assumed to replace the contents of a line already scanned.
6298 An appropriate use of this function would be substitution of input lines when
6299 called by md_start_line_hook(). The given line is assumed to already be
6300 properly scrubbed. */
6303 input_scrub_insert_line (const char *line
)
6306 size_t len
= strlen (line
);
6307 sb_build (&newline
, len
);
6308 sb_add_buffer (&newline
, line
, len
);
6309 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6311 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6314 /* Insert a file into the input stream; the path must resolve to an actual
6315 file; no include path searching or dependency registering is performed. */
6318 input_scrub_insert_file (char *path
)
6320 input_scrub_include_file (path
, input_line_pointer
);
6321 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6324 /* Find the end of a line, considering quotation and escaping of quotes. */
6326 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6327 # define TC_SINGLE_QUOTE_STRINGS 1
6331 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6334 char inquote
= '\0';
6337 while (!is_end_of_line
[(unsigned char) *s
]
6338 || (inquote
&& !ISCNTRL (*s
))
6339 || (inquote
== '\'' && flag_mri
)
6340 #ifdef TC_EOL_IN_INSN
6341 || (insn
&& TC_EOL_IN_INSN (s
))
6343 /* PR 6926: When we are parsing the body of a macro the sequence
6344 \@ is special - it refers to the invocation count. If the @
6345 character happens to be registered as a line-separator character
6346 by the target, then the is_end_of_line[] test above will have
6347 returned true, but we need to ignore the line separating
6348 semantics in this particular case. */
6349 || (in_macro
&& inescape
&& *s
== '@')
6352 if (mri_string
&& *s
== '\'')
6356 else if (*s
== '\\')
6360 #ifdef TC_SINGLE_QUOTE_STRINGS
6361 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6368 as_warn (_("missing closing `%c'"), inquote
);
6369 if (inescape
&& !ignore_input ())
6370 as_warn (_("stray `\\'"));
6375 find_end_of_line (char *s
, int mri_string
)
6377 return _find_end_of_line (s
, mri_string
, 0, 0);
6380 static char *saved_ilp
= NULL
;
6381 static char *saved_limit
;
6383 /* Use BUF as a temporary input pointer for calling other functions in this
6384 file. BUF must be a C string, so that its end can be found by strlen.
6385 Also sets the buffer_limit variable (local to this file) so that buffer
6386 overruns should not occur. Saves the current input line pointer so that
6387 it can be restored by calling restore_ilp().
6389 Does not support recursion. */
6392 temp_ilp (char *buf
)
6394 gas_assert (saved_ilp
== NULL
);
6395 gas_assert (buf
!= NULL
);
6397 saved_ilp
= input_line_pointer
;
6398 saved_limit
= buffer_limit
;
6399 /* Prevent the assert in restore_ilp from triggering if
6400 the input_line_pointer has not yet been initialised. */
6401 if (saved_ilp
== NULL
)
6402 saved_limit
= saved_ilp
= (char *) "";
6404 input_line_pointer
= buf
;
6405 buffer_limit
= buf
+ strlen (buf
);
6406 input_from_string
= true;
6409 /* Restore a saved input line pointer. */
6414 gas_assert (saved_ilp
!= NULL
);
6416 input_line_pointer
= saved_ilp
;
6417 buffer_limit
= saved_limit
;
6418 input_from_string
= false;