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. */
298 static htab_t po_hash
;
300 static const pseudo_typeS potable
[] = {
301 {"abort", s_abort
, 0},
302 {"align", s_align_ptwo
, 0},
303 {"altmacro", s_altmacro
, 1},
304 {"ascii", stringer
, 8+0},
305 {"asciz", stringer
, 8+1},
306 {"balign", s_align_bytes
, 0},
307 {"balignw", s_align_bytes
, -2},
308 {"balignl", s_align_bytes
, -4},
311 {"bundle_align_mode", s_bundle_align_mode
, 0},
312 {"bundle_lock", s_bundle_lock
, 0},
313 {"bundle_unlock", s_bundle_unlock
, 0},
317 {"common", s_mri_common
, 0},
318 {"common.s", s_mri_common
, 1},
323 {"dc.d", float_cons
, 'd'},
325 {"dc.s", float_cons
, 'f'},
327 {"dc.x", float_cons
, 'x'},
329 {"dcb.b", s_space
, 1},
330 {"dcb.d", s_float_space
, 'd'},
331 {"dcb.l", s_space
, 4},
332 {"dcb.s", s_float_space
, 'f'},
333 {"dcb.w", s_space
, 2},
334 {"dcb.x", s_float_space
, 'x'},
336 {"ds.b", s_space
, 1},
337 {"ds.d", s_space
, 8},
338 {"ds.l", s_space
, 4},
339 {"ds.p", s_space
, 'p'},
340 {"ds.s", s_space
, 4},
341 {"ds.w", s_space
, 2},
342 {"ds.x", s_space
, 'x'},
343 {"debug", s_ignore
, 0},
348 {"double", float_cons
, 'd'},
350 {"eject", listing_eject
, 0}, /* Formfeed listing. */
352 {"elsec", s_else
, 0},
353 {"elseif", s_elseif
, (int) O_ne
},
355 {"endc", s_endif
, 0},
356 {"endfunc", s_func
, 1},
357 {"endif", s_endif
, 0},
358 {"endm", s_bad_end
, 0},
359 {"endr", s_bad_end
, 1},
365 {"error", s_errwarn
, 1},
366 {"exitm", s_mexit
, 0},
368 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
372 {"float", float_cons
, 'f'},
373 {"format", s_ignore
, 0},
375 {"global", s_globl
, 0},
376 {"globl", s_globl
, 0},
378 {"if", s_if
, (int) O_ne
},
381 {"ifdef", s_ifdef
, 0},
382 {"ifeq", s_if
, (int) O_eq
},
383 {"ifeqs", s_ifeqs
, 0},
384 {"ifge", s_if
, (int) O_ge
},
385 {"ifgt", s_if
, (int) O_gt
},
386 {"ifle", s_if
, (int) O_le
},
387 {"iflt", s_if
, (int) O_lt
},
390 {"ifndef", s_ifdef
, 1},
391 {"ifne", s_if
, (int) O_ne
},
392 {"ifnes", s_ifeqs
, 1},
393 {"ifnotdef", s_ifdef
, 1},
394 {"incbin", s_incbin
, 0},
395 {"include", s_include
, 0},
401 {"lcomm", s_lcomm
, 0},
402 {"lflags", s_ignore
, 0}, /* Listing flags. */
403 {"linefile", s_linefile
, 0},
404 {"linkonce", s_linkonce
, 0},
405 {"list", listing_list
, 1}, /* Turn listing on. */
406 {"llen", listing_psize
, 1},
409 {"macro", s_macro
, 0},
410 {"mexit", s_mexit
, 0},
412 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
413 {"name", s_ignore
, 0},
414 {"noaltmacro", s_altmacro
, 0},
415 {"noformat", s_ignore
, 0},
416 {"nolist", listing_list
, 0}, /* Turn listing off. */
417 {"nopage", listing_nopage
, 0},
421 {"offset", s_struct
, 0},
423 {"p2align", s_align_ptwo
, 0},
424 {"p2alignw", s_align_ptwo
, -2},
425 {"p2alignl", s_align_ptwo
, -4},
426 {"page", listing_eject
, 0},
427 {"plen", listing_psize
, 0},
428 {"print", s_print
, 0},
429 {"psize", listing_psize
, 0}, /* Set paper size. */
430 {"purgem", s_purgem
, 0},
432 {"reloc", s_reloc
, 0},
436 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
441 {"single", float_cons
, 'f'},
443 {"space", s_space
, 0},
444 {"skip", s_space
, 0},
445 {"sleb128", s_leb128
, 1},
446 {"spc", s_ignore
, 0},
447 {"stabd", s_stab
, 'd'},
448 {"stabn", s_stab
, 'n'},
449 {"stabs", s_stab
, 's'},
450 {"string", stringer
, 8+1},
451 {"string8", stringer
, 8+1},
452 {"string16", stringer
, 16+1},
453 {"string32", stringer
, 32+1},
454 {"string64", stringer
, 64+1},
455 {"struct", s_struct
, 0},
459 /* This is for gcc to use. It's only just been added (2/94), so gcc
460 won't be able to use it for a while -- probably a year or more.
461 But once this has been released, check with gcc maintainers
462 before deleting it or even changing the spelling. */
463 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
464 /* If we're folding case -- done for some targets, not necessarily
465 all -- the above string in an input file will be converted to
466 this one. Match it either way... */
467 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
469 {"title", listing_title
, 0}, /* Listing title. */
470 {"ttl", listing_title
, 0},
472 {"uleb128", s_leb128
, 0},
476 {"xdef", s_globl
, 0},
477 {"xref", s_ignore
, 0},
478 {"xstabs", s_xstab
, 's'},
479 {"warning", s_errwarn
, 0},
480 {"weakref", s_weakref
, 0},
482 {"zero", s_space
, 0},
486 {NULL
, NULL
, 0} /* End sentinel. */
490 get_absolute_expr (expressionS
*exp
)
492 expression_and_evaluate (exp
);
494 if (exp
->X_op
!= O_constant
)
496 if (exp
->X_op
!= O_absent
)
497 as_bad (_("bad or irreducible absolute expression"));
498 exp
->X_add_number
= 0;
500 return exp
->X_add_number
;
504 get_absolute_expression (void)
508 return get_absolute_expr (&exp
);
511 static int pop_override_ok
= 0;
512 static const char *pop_table_name
;
515 pop_insert (const pseudo_typeS
*table
)
517 const pseudo_typeS
*pop
;
518 for (pop
= table
; pop
->poc_name
; pop
++)
520 if (str_hash_insert (po_hash
, pop
->poc_name
, pop
, 0) != NULL
)
522 if (!pop_override_ok
)
523 as_fatal (_("error constructing %s pseudo-op table"),
529 #ifndef md_pop_insert
530 #define md_pop_insert() pop_insert(md_pseudo_table)
533 #ifndef obj_pop_insert
534 #define obj_pop_insert() pop_insert(obj_pseudo_table)
537 #ifndef cfi_pop_insert
538 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
544 po_hash
= str_htab_create ();
546 /* Do the target-specific pseudo ops. */
547 pop_table_name
= "md";
550 /* Now object specific. Skip any that were in the target table. */
551 pop_table_name
= "obj";
555 /* Now portable ones. Skip any that we've seen already. */
556 pop_table_name
= "standard";
557 pop_insert (potable
);
560 pop_table_name
= "cfi";
565 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
566 if (ignore_input ()) \
568 char *eol = find_end_of_line (input_line_pointer - (num_read), \
570 input_line_pointer = (input_line_pointer <= buffer_limit \
571 && eol >= buffer_limit) \
577 /* Helper function of read_a_source_file, which tries to expand a macro. */
579 try_macro (char term
, const char *line
)
585 if (check_macro (line
, &out
, &err
, ¯o
))
589 *input_line_pointer
++ = term
;
590 input_scrub_include_sb (&out
,
591 input_line_pointer
, expanding_macro
);
594 input_scrub_next_buffer (&input_line_pointer
);
596 md_macro_info (macro
);
604 /* Start a new instruction bundle. Returns the rs_align_code frag that
605 will be used to align the new bundle. */
609 fragS
*frag
= frag_now
;
611 frag_align_code (0, 0);
613 while (frag
->fr_type
!= rs_align_code
)
614 frag
= frag
->fr_next
;
616 gas_assert (frag
!= frag_now
);
621 /* Calculate the maximum size after relaxation of the region starting
622 at the given frag and extending through frag_now (which is unfinished). */
624 pending_bundle_size (fragS
*frag
)
626 unsigned int offset
= frag
->fr_fix
;
627 unsigned int size
= 0;
629 gas_assert (frag
!= frag_now
);
630 gas_assert (frag
->fr_type
== rs_align_code
);
632 while (frag
!= frag_now
)
634 /* This should only happen in what will later become an error case. */
638 size
+= frag
->fr_fix
;
639 if (frag
->fr_type
== rs_machine_dependent
)
640 size
+= md_frag_max_var (frag
);
642 frag
= frag
->fr_next
;
645 gas_assert (frag
== frag_now
);
646 size
+= frag_now_fix ();
647 if (frag
->fr_type
== rs_machine_dependent
)
648 size
+= md_frag_max_var (frag
);
650 gas_assert (size
>= offset
);
652 return size
- offset
;
655 /* Finish off the frag created to ensure bundle alignment. */
657 finish_bundle (fragS
*frag
, unsigned int size
)
659 gas_assert (bundle_align_p2
> 0);
660 gas_assert (frag
->fr_type
== rs_align_code
);
664 /* If there is more than a single byte, then we need to set up the
665 alignment frag. Otherwise we leave it at its initial state from
666 calling frag_align_code (0, 0), so that it does nothing. */
667 frag
->fr_offset
= bundle_align_p2
;
668 frag
->fr_subtype
= size
- 1;
671 /* We do this every time rather than just in s_bundle_align_mode
672 so that we catch any affected section without needing hooks all
673 over for all paths that do section changes. It's cheap enough. */
674 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
675 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
678 /* Assemble one instruction. This takes care of the bundle features
679 around calling md_assemble. */
681 assemble_one (char *line
)
683 fragS
*insn_start_frag
= NULL
;
685 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
687 as_bad (_("cannot change section or subsection inside .bundle_lock"));
688 /* Clearing this serves as a marker that we have already complained. */
689 bundle_lock_frchain
= NULL
;
692 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
693 insn_start_frag
= start_bundle ();
697 if (bundle_lock_frchain
!= NULL
)
699 /* Make sure this hasn't pushed the locked sequence
700 past the bundle size. */
701 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
702 if (bundle_size
> 1U << bundle_align_p2
)
703 as_bad (_ (".bundle_lock sequence at %u bytes, "
704 "but .bundle_align_mode limit is %u bytes"),
705 bundle_size
, 1U << bundle_align_p2
);
707 else if (bundle_align_p2
> 0)
709 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
711 if (insn_size
> 1U << bundle_align_p2
)
712 as_bad (_("single instruction is %u bytes long, "
713 "but .bundle_align_mode limit is %u bytes"),
714 insn_size
, 1U << bundle_align_p2
);
716 finish_bundle (insn_start_frag
, insn_size
);
720 #else /* !HANDLE_BUNDLE */
722 # define assemble_one(line) md_assemble(line)
724 #endif /* HANDLE_BUNDLE */
729 flagword flags
= bfd_section_flags (now_seg
);
731 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
734 /* Guts of .align directive:
735 N is the power of two to which to align. A value of zero is accepted but
736 ignored: the default alignment of the section will be at least this.
737 FILL may be NULL, or it may point to the bytes of the fill pattern.
738 LEN is the length of whatever FILL points to, if anything. If LEN is zero
739 but FILL is not NULL then LEN is treated as if it were one.
740 MAX is the maximum number of characters to skip when doing the alignment,
741 or 0 if there is no maximum. */
744 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
746 if (now_seg
== absolute_section
|| in_bss ())
752 if (now_seg
== absolute_section
)
753 as_warn (_("ignoring fill value in absolute section"));
755 as_warn (_("ignoring fill value in section `%s'"),
756 segment_name (now_seg
));
763 #ifdef md_flush_pending_output
764 md_flush_pending_output ();
768 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
771 /* Only make a frag if we HAVE to... */
772 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
776 if (subseg_text_p (now_seg
))
777 frag_align_code (n
, max
);
779 frag_align (n
, 0, max
);
782 frag_align (n
, *fill
, max
);
784 frag_align_pattern (n
, fill
, len
, max
);
788 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
791 if (n
> OCTETS_PER_BYTE_POWER
)
792 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
795 /* We read the file, putting things into a web that represents what we
796 have been reading. */
798 read_a_source_file (const char *name
)
802 char *s
; /* String of symbol, '\0' appended. */
804 const pseudo_typeS
*pop
;
810 buffer
= input_scrub_new_file (name
);
813 listing_newline (NULL
);
814 register_dependency (name
);
816 /* Generate debugging information before we've read anything in to denote
817 this file as the "main" source file and not a subordinate one
818 (e.g. N_SO vs N_SOL in stabs). */
819 generate_file_debug ();
821 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
822 { /* We have another line to parse. */
824 /* In order to avoid listing macro expansion lines with labels
825 multiple times, keep track of which line was last issued. */
826 static char *last_eol
;
830 while (input_line_pointer
< buffer_limit
)
833 /* We have more of this buffer to parse. */
835 /* We now have input_line_pointer->1st char of next line.
836 If input_line_pointer [-1] == '\n' then we just
837 scanned another line: so bump line counters. */
838 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
841 symbol_set_value_now (&dot_symbol
);
842 #ifdef md_start_line_hook
843 md_start_line_hook ();
845 if (input_line_pointer
[-1] == '\n')
846 bump_line_counters ();
850 /* If listing is on, and we are expanding a macro, then give
851 the listing code the contents of the expanded line. */
854 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
856 /* Find the end of the current expanded macro line. */
857 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
865 /* Copy it for safe keeping. Also give an indication of
866 how much macro nesting is involved at this point. */
867 len
= s
- input_line_pointer
;
868 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
869 memset (copy
, '>', macro_nest
);
870 copy
[macro_nest
] = ' ';
871 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
872 copy
[macro_nest
+ 1 + len
] = '\0';
874 /* Install the line with the listing facility. */
875 listing_newline (copy
);
879 listing_newline (NULL
);
886 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
888 next_char
= * input_line_pointer
;
889 /* Text at the start of a line must be a label, we
890 run down and stick a colon in. */
891 if (is_name_beginner (next_char
) || next_char
== '"')
896 HANDLE_CONDITIONAL_ASSEMBLY (0);
898 nul_char
= get_symbol_name (& line_start
);
899 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
901 /* In MRI mode, the EQU and MACRO pseudoops must
902 be handled specially. */
906 char *rest
= input_line_pointer
+ 1;
910 if (*rest
== ' ' || *rest
== '\t')
912 if ((strncasecmp (rest
, "EQU", 3) == 0
913 || strncasecmp (rest
, "SET", 3) == 0)
914 && (rest
[3] == ' ' || rest
[3] == '\t'))
916 input_line_pointer
= rest
+ 3;
918 strncasecmp (rest
, "SET", 3) == 0);
921 if (strncasecmp (rest
, "MACRO", 5) == 0
924 || is_end_of_line
[(unsigned char) rest
[5]]))
928 /* In MRI mode, we need to handle the MACRO
929 pseudo-op specially: we don't want to put the
930 symbol in the symbol table. */
932 #ifdef TC_START_LABEL_WITHOUT_COLON
933 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
936 line_label
= colon (line_start
);
938 line_label
= symbol_create (line_start
,
940 &zero_address_frag
, 0);
942 next_char
= restore_line_pointer (nul_char
);
943 if (next_char
== ':')
944 input_line_pointer
++;
949 /* We are at the beginning of a line, or similar place.
950 We expect a well-formed assembler statement.
951 A "symbol-name:" is a statement.
953 Depending on what compiler is used, the order of these tests
954 may vary to catch most common case 1st.
955 Each test is independent of all other tests at the (top)
958 nul_char
= next_char
= *input_line_pointer
++;
959 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
961 /* C is the 1st significant character.
962 Input_line_pointer points after that character. */
963 if (is_name_beginner (next_char
) || next_char
== '"')
967 /* Want user-defined label or pseudo/opcode. */
968 HANDLE_CONDITIONAL_ASSEMBLY (1);
970 --input_line_pointer
;
971 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
972 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
973 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
975 /* NEXT_CHAR is character after symbol.
976 The end of symbol in the input line is now '\0'.
977 S points to the beginning of the symbol.
978 [In case of pseudo-op, s->'.'.]
979 Input_line_pointer->'\0' where NUL_CHAR was. */
980 if (TC_START_LABEL (s
, nul_char
, next_char
))
984 /* In MRI mode, \tsym: set 0 is permitted. */
988 if (*rest
== ' ' || *rest
== '\t')
991 if ((strncasecmp (rest
, "EQU", 3) == 0
992 || strncasecmp (rest
, "SET", 3) == 0)
993 && (rest
[3] == ' ' || rest
[3] == '\t'))
995 input_line_pointer
= rest
+ 3;
1001 line_label
= colon (s
); /* User-defined label. */
1002 restore_line_pointer (nul_char
);
1003 ++ input_line_pointer
;
1004 #ifdef tc_check_label
1005 tc_check_label (line_label
);
1007 /* Input_line_pointer->after ':'. */
1010 else if ((next_char
== '=' && *rest
== '=')
1011 || ((next_char
== ' ' || next_char
== '\t')
1016 demand_empty_rest_of_line ();
1018 else if ((next_char
== '='
1019 || ((next_char
== ' ' || next_char
== '\t')
1021 #ifdef TC_EQUAL_IN_INSN
1022 && !TC_EQUAL_IN_INSN (next_char
, s
)
1027 demand_empty_rest_of_line ();
1031 /* Expect pseudo-op or machine instruction. */
1034 #ifndef TC_CASE_SENSITIVE
1038 strncpy (original_case_string
, s2
,
1039 sizeof (original_case_string
) - 1);
1040 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1044 *s2
= TOLOWER (*s2
);
1049 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1051 /* The MRI assembler uses pseudo-ops without
1053 pop
= str_hash_find (po_hash
, s
);
1054 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1059 || (!flag_m68k_mri
&& *s
== '.'))
1063 WARNING: next_char may be end-of-line.
1064 We lookup the pseudo-op table with s+1 because we
1065 already know that the pseudo-op begins with a '.'. */
1068 pop
= str_hash_find (po_hash
, s
+ 1);
1069 if (pop
&& !pop
->poc_handler
)
1072 /* In MRI mode, we may need to insert an
1073 automatic alignment directive. What a hack
1075 if (mri_pending_align
1077 || !((pop
->poc_handler
== cons
1078 && pop
->poc_val
== 1)
1079 || (pop
->poc_handler
== s_space
1080 && pop
->poc_val
== 1)
1081 #ifdef tc_conditional_pseudoop
1082 || tc_conditional_pseudoop (pop
)
1084 || pop
->poc_handler
== s_if
1085 || pop
->poc_handler
== s_ifdef
1086 || pop
->poc_handler
== s_ifc
1087 || pop
->poc_handler
== s_ifeqs
1088 || pop
->poc_handler
== s_else
1089 || pop
->poc_handler
== s_endif
1090 || pop
->poc_handler
== s_globl
1091 || pop
->poc_handler
== s_ignore
)))
1093 do_align (1, (char *) NULL
, 0, 0);
1094 mri_pending_align
= 0;
1096 if (line_label
!= NULL
)
1098 symbol_set_frag (line_label
, frag_now
);
1099 S_SET_VALUE (line_label
, frag_now_fix ());
1103 /* Print the error msg now, while we still can. */
1106 char *end
= input_line_pointer
;
1108 (void) restore_line_pointer (nul_char
);
1110 nul_char
= next_char
= *--input_line_pointer
;
1111 *input_line_pointer
= '\0';
1112 if (! macro_defined
|| ! try_macro (next_char
, s
))
1115 as_bad (_("unknown pseudo-op: `%s'"), s
);
1116 *input_line_pointer
++ = nul_char
;
1121 /* Put it back for error messages etc. */
1122 next_char
= restore_line_pointer (nul_char
);
1123 /* The following skip of whitespace is compulsory.
1124 A well shaped space is sometimes all that separates
1125 keyword from operands. */
1126 if (next_char
== ' ' || next_char
== '\t')
1127 input_line_pointer
++;
1129 /* Input_line is restored.
1130 Input_line_pointer->1st non-blank char
1131 after pseudo-operation. */
1132 (*pop
->poc_handler
) (pop
->poc_val
);
1134 /* If that was .end, just get out now. */
1135 if (pop
->poc_handler
== s_end
)
1140 /* WARNING: next_char may be end-of-line. */
1141 /* Also: input_line_pointer->`\0` where nul_char was. */
1142 (void) restore_line_pointer (nul_char
);
1143 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1144 next_char
= nul_char
= *input_line_pointer
;
1145 *input_line_pointer
= '\0';
1147 generate_lineno_debug ();
1149 if (macro_defined
&& try_macro (next_char
, s
))
1152 if (mri_pending_align
)
1154 do_align (1, (char *) NULL
, 0, 0);
1155 mri_pending_align
= 0;
1156 if (line_label
!= NULL
)
1158 symbol_set_frag (line_label
, frag_now
);
1159 S_SET_VALUE (line_label
, frag_now_fix ());
1163 assemble_one (s
); /* Assemble 1 instruction. */
1165 /* PR 19630: The backend may have set ilp to NULL
1166 if it encountered a catastrophic failure. */
1167 if (input_line_pointer
== NULL
)
1168 as_fatal (_("unable to continue with assembly."));
1170 *input_line_pointer
++ = nul_char
;
1172 /* We resume loop AFTER the end-of-line from
1173 this instruction. */
1179 /* Empty statement? */
1180 if (is_end_of_line
[(unsigned char) next_char
])
1183 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1185 /* local label ("4:") */
1186 char *backup
= input_line_pointer
;
1188 HANDLE_CONDITIONAL_ASSEMBLY (1);
1190 temp
= next_char
- '0';
1192 if (nul_char
== '"')
1193 ++ input_line_pointer
;
1195 /* Read the whole number. */
1196 while (ISDIGIT (*input_line_pointer
))
1198 const long digit
= *input_line_pointer
- '0';
1199 if (temp
> (INT_MAX
- digit
) / 10)
1201 as_bad (_("local label too large near %s"), backup
);
1205 temp
= temp
* 10 + digit
;
1206 ++input_line_pointer
;
1209 /* Overflow: stop processing the label. */
1212 ignore_rest_of_line ();
1216 if (LOCAL_LABELS_DOLLAR
1217 && *input_line_pointer
== '$'
1218 && *(input_line_pointer
+ 1) == ':')
1220 input_line_pointer
+= 2;
1222 if (dollar_label_defined (temp
))
1224 as_fatal (_("label \"%ld$\" redefined"), temp
);
1227 define_dollar_label (temp
);
1228 colon (dollar_label_name (temp
, 0));
1233 && *input_line_pointer
++ == ':')
1235 fb_label_instance_inc (temp
);
1236 colon (fb_label_name (temp
, 0));
1240 input_line_pointer
= backup
;
1243 if (next_char
&& strchr (line_comment_chars
, next_char
))
1244 { /* Its a comment. Better say APP or NO_APP. */
1249 s
= input_line_pointer
;
1250 if (!startswith (s
, "APP\n"))
1253 ignore_rest_of_line ();
1256 bump_line_counters ();
1259 ends
= strstr (s
, "#NO_APP\n");
1260 len
= ends
? ends
- s
: buffer_limit
- s
;
1262 sb_build (&sbuf
, len
+ 100);
1263 sb_add_buffer (&sbuf
, s
, len
);
1266 /* The end of the #APP wasn't in this buffer. We
1267 keep reading in buffers until we find the #NO_APP
1268 that goes with this #APP There is one. The specs
1272 buffer_limit
= input_scrub_next_buffer (&buffer
);
1275 ends
= strstr (buffer
, "#NO_APP\n");
1276 len
= ends
? ends
- buffer
: buffer_limit
- buffer
;
1277 sb_add_buffer (&sbuf
, buffer
, len
);
1282 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1283 input_scrub_include_sb (&sbuf
, input_line_pointer
, expanding_none
);
1285 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1289 HANDLE_CONDITIONAL_ASSEMBLY (1);
1291 #ifdef tc_unrecognized_line
1292 if (tc_unrecognized_line (next_char
))
1295 input_line_pointer
--;
1296 /* Report unknown char as error. */
1297 demand_empty_rest_of_line ();
1302 symbol_set_value_now (&dot_symbol
);
1304 #ifdef HANDLE_BUNDLE
1305 if (bundle_lock_frag
!= NULL
)
1307 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1308 _(".bundle_lock with no matching .bundle_unlock"));
1309 bundle_lock_frag
= NULL
;
1310 bundle_lock_frchain
= NULL
;
1311 bundle_lock_depth
= 0;
1318 /* Close the input file. */
1319 input_scrub_close ();
1320 #ifdef WARN_COMMENTS
1322 if (warn_comment
&& found_comment
)
1323 as_warn_where (found_comment_file
, found_comment
,
1324 "first comment found here");
1329 /* Convert O_constant expression EXP into the equivalent O_big representation.
1330 Take the sign of the number from SIGN rather than X_add_number. */
1333 convert_to_bignum (expressionS
*exp
, int sign
)
1338 value
= exp
->X_add_number
;
1339 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1341 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1342 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1344 /* Add a sequence of sign bits if the top bit of X_add_number is not
1345 the sign of the original value. */
1346 if ((exp
->X_add_number
< 0) == !sign
)
1347 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1349 exp
->X_add_number
= i
;
1352 /* For most MRI pseudo-ops, the line actually ends at the first
1353 nonquoted space. This function looks for that point, stuffs a null
1354 in, and sets *STOPCP to the character that used to be there, and
1355 returns the location.
1357 Until I hear otherwise, I am going to assume that this is only true
1358 for the m68k MRI assembler. */
1361 mri_comment_field (char *stopcp
)
1367 know (flag_m68k_mri
);
1369 for (s
= input_line_pointer
;
1370 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1378 for (s
= input_line_pointer
;
1379 !is_end_of_line
[(unsigned char) *s
];
1389 /* Skip to the end of an MRI comment field. */
1392 mri_comment_end (char *stop
, int stopc
)
1396 input_line_pointer
= stop
;
1398 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1399 ++input_line_pointer
;
1403 s_abort (int ignore ATTRIBUTE_UNUSED
)
1405 as_fatal (_(".abort detected. Abandoning ship."));
1408 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1409 (in bytes). A negative ARG is the negative of the length of the
1410 fill pattern. BYTES_P is non-zero if the alignment value should be
1411 interpreted as the byte boundary, rather than the power of 2. */
1412 #ifndef TC_ALIGN_LIMIT
1413 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1417 s_align (signed int arg
, int bytes_p
)
1419 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1428 stop
= mri_comment_field (&stopc
);
1430 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1435 align
= arg
; /* Default value from pseudo-op table. */
1439 align
= get_absolute_expression ();
1442 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1443 if (arg
> 0 && align
== 0)
1450 /* Convert to a power of 2. */
1455 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1458 as_bad (_("alignment not a power of 2"));
1464 if (align
> align_limit
)
1466 align
= align_limit
;
1467 as_warn (_("alignment too large: %u assumed"), align_limit
);
1470 if (*input_line_pointer
!= ',')
1477 ++input_line_pointer
;
1478 if (*input_line_pointer
== ',')
1482 fill
= get_absolute_expression ();
1487 if (*input_line_pointer
!= ',')
1491 ++input_line_pointer
;
1492 max
= get_absolute_expression ();
1499 as_warn (_("expected fill pattern missing"));
1500 do_align (align
, (char *) NULL
, 0, max
);
1504 unsigned int fill_len
;
1516 do_align (align
, &fill_char
, fill_len
, max
);
1522 if ((size_t) fill_len
> sizeof ab
)
1524 as_warn (_("fill pattern too long, truncating to %u"),
1525 (unsigned) sizeof ab
);
1526 fill_len
= sizeof ab
;
1529 md_number_to_chars (ab
, fill
, fill_len
);
1530 do_align (align
, ab
, fill_len
, max
);
1534 demand_empty_rest_of_line ();
1537 mri_comment_end (stop
, stopc
);
1540 /* Handle the .align pseudo-op on machines where ".align 4" means
1541 align to a 4 byte boundary. */
1544 s_align_bytes (int arg
)
1549 /* Handle the .align pseudo-op on machines where ".align 4" means align
1550 to a 2**4 boundary. */
1553 s_align_ptwo (int arg
)
1558 /* Switch in and out of alternate macro mode. */
1563 demand_empty_rest_of_line ();
1564 macro_set_alternate (on
);
1567 /* Read a symbol name from input_line_pointer.
1569 Stores the symbol name in a buffer and returns a pointer to this buffer.
1570 The buffer is xalloc'ed. It is the caller's responsibility to free
1573 The name is not left in the i_l_p buffer as it may need processing
1574 to handle escape characters.
1576 Advances i_l_p to the next non-whitespace character.
1578 If a symbol name could not be read, the routine issues an error
1579 messages, skips to the end of the line and returns NULL. */
1582 read_symbol_name (void)
1588 c
= *input_line_pointer
++;
1592 #define SYM_NAME_CHUNK_LEN 128
1593 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1597 start
= name
= XNEWVEC (char, len
+ 1);
1599 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1601 while (is_a_char (C
= next_char_of_string ()))
1603 if (name
>= name_end
)
1607 sofar
= name
- start
;
1608 len
+= SYM_NAME_CHUNK_LEN
;
1609 start
= XRESIZEVEC (char, start
, len
+ 1);
1610 name_end
= start
+ len
;
1611 name
= start
+ sofar
;
1618 /* Since quoted symbol names can contain non-ASCII characters,
1619 check the string and warn if it cannot be recognised by the
1620 current character set. */
1621 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1622 as_warn (_("symbol name not recognised in the current locale"));
1624 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1628 name
= input_line_pointer
- 1;
1630 /* We accept FAKE_LABEL_CHAR in a name in case this is
1631 being called with a constructed string. */
1632 while (is_part_of_name (c
= *input_line_pointer
++)
1633 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1636 len
= (input_line_pointer
- name
) - 1;
1637 start
= XNEWVEC (char, len
+ 1);
1639 memcpy (start
, name
, len
);
1642 /* Skip a name ender char if one is present. */
1643 if (! is_name_ender (c
))
1644 --input_line_pointer
;
1647 name
= start
= NULL
;
1651 as_bad (_("expected symbol name"));
1652 ignore_rest_of_line ();
1664 s_comm_internal (int param
,
1665 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1669 symbolS
*symbolP
= NULL
;
1675 stop
= mri_comment_field (&stopc
);
1677 if ((name
= read_symbol_name ()) == NULL
)
1680 /* Accept an optional comma after the name. The comma used to be
1681 required, but Irix 5 cc does not generate it for .lcomm. */
1682 if (*input_line_pointer
== ',')
1683 input_line_pointer
++;
1685 temp
= get_absolute_expr (&exp
);
1687 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1688 if (exp
.X_op
== O_absent
)
1690 as_bad (_("missing size expression"));
1691 ignore_rest_of_line ();
1694 else if (temp
!= size
|| !exp
.X_unsigned
)
1696 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1697 ignore_rest_of_line ();
1701 symbolP
= symbol_find_or_make (name
);
1702 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1703 && !S_IS_COMMON (symbolP
))
1705 if (!S_IS_VOLATILE (symbolP
))
1708 as_bad (_("symbol `%s' is already defined"), name
);
1709 ignore_rest_of_line ();
1712 symbolP
= symbol_clone (symbolP
, 1);
1713 S_SET_SEGMENT (symbolP
, undefined_section
);
1714 S_SET_VALUE (symbolP
, 0);
1715 symbol_set_frag (symbolP
, &zero_address_frag
);
1716 S_CLEAR_VOLATILE (symbolP
);
1719 size
= S_GET_VALUE (symbolP
);
1722 else if (size
!= temp
)
1723 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1724 name
, (long) size
, (long) temp
);
1726 if (comm_parse_extra
!= NULL
)
1727 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1730 S_SET_VALUE (symbolP
, (valueT
) size
);
1731 S_SET_EXTERNAL (symbolP
);
1732 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1735 demand_empty_rest_of_line ();
1738 mri_comment_end (stop
, stopc
);
1746 s_comm_internal (ignore
, NULL
);
1749 /* The MRI COMMON pseudo-op. We handle this by creating a common
1750 symbol with the appropriate name. We make s_space do the right
1751 thing by increasing the size. */
1754 s_mri_common (int small ATTRIBUTE_UNUSED
)
1770 stop
= mri_comment_field (&stopc
);
1774 name
= input_line_pointer
;
1775 if (!ISDIGIT (*name
))
1776 c
= get_symbol_name (& name
);
1781 ++input_line_pointer
;
1783 while (ISDIGIT (*input_line_pointer
));
1785 c
= *input_line_pointer
;
1786 *input_line_pointer
= '\0';
1788 if (line_label
!= NULL
)
1790 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1791 + (input_line_pointer
- name
) + 1);
1792 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1797 sym
= symbol_find_or_make (name
);
1798 c
= restore_line_pointer (c
);
1801 if (*input_line_pointer
!= ',')
1805 ++input_line_pointer
;
1806 align
= get_absolute_expression ();
1809 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1811 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1812 mri_comment_end (stop
, stopc
);
1816 S_SET_EXTERNAL (sym
);
1817 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1818 mri_common_symbol
= sym
;
1822 S_SET_ALIGN (sym
, align
);
1827 if (line_label
!= NULL
)
1830 exp
.X_op
= O_symbol
;
1831 exp
.X_add_symbol
= sym
;
1832 exp
.X_add_number
= 0;
1833 symbol_set_value_expression (line_label
, &exp
);
1834 symbol_set_frag (line_label
, &zero_address_frag
);
1835 S_SET_SEGMENT (line_label
, expr_section
);
1838 /* FIXME: We just ignore the small argument, which distinguishes
1839 COMMON and COMMON.S. I don't know what we can do about it. */
1841 /* Ignore the type and hptype. */
1842 if (*input_line_pointer
== ',')
1843 input_line_pointer
+= 2;
1844 if (*input_line_pointer
== ',')
1845 input_line_pointer
+= 2;
1847 demand_empty_rest_of_line ();
1849 mri_comment_end (stop
, stopc
);
1853 s_data (int ignore ATTRIBUTE_UNUSED
)
1858 temp
= get_absolute_expression ();
1859 if (flag_readonly_data_in_text
)
1861 section
= text_section
;
1865 section
= data_section
;
1867 subseg_set (section
, (subsegT
) temp
);
1869 demand_empty_rest_of_line ();
1872 /* Handle the .file pseudo-op. This default definition may be overridden by
1873 the object or CPU specific pseudo-ops. */
1876 s_file_string (char *file
)
1880 listing_source_file (file
);
1882 register_dependency (file
);
1884 obj_app_file (file
);
1889 s_file (int ignore ATTRIBUTE_UNUSED
)
1894 /* Some assemblers tolerate immediately following '"'. */
1895 if ((s
= demand_copy_string (&length
)) != 0)
1897 new_logical_line_flags (s
, -1, 1);
1899 /* In MRI mode, the preprocessor may have inserted an extraneous
1902 && *input_line_pointer
== '\''
1903 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1904 ++input_line_pointer
;
1906 demand_empty_rest_of_line ();
1912 get_linefile_number (int *flag
)
1918 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1921 /* Don't mistakenly interpret octal numbers as line numbers. */
1922 if (*input_line_pointer
== '0')
1925 ++input_line_pointer
;
1929 expression_and_evaluate (&exp
);
1930 if (exp
.X_op
!= O_constant
)
1933 #if defined (BFD64) || LONG_MAX > INT_MAX
1934 if (exp
.X_add_number
< INT_MIN
|| exp
.X_add_number
> INT_MAX
)
1938 *flag
= exp
.X_add_number
;
1943 /* Handle the .linefile pseudo-op. This is automatically generated by
1944 do_scrub_chars when a preprocessor # line comment is seen. This
1945 default definition may be overridden by the object or CPU specific
1949 s_linefile (int ignore ATTRIBUTE_UNUSED
)
1952 int linenum
, flags
= 0;
1954 /* The given number is that of the next line. */
1955 if (!get_linefile_number (&linenum
))
1957 ignore_rest_of_line ();
1962 /* Some of the back ends can't deal with non-positive line numbers.
1963 Besides, it's silly. GCC however will generate a line number of
1964 zero when it is pre-processing builtins for assembler-with-cpp files:
1968 We do not want to barf on this, especially since such files are used
1969 in the GCC and GDB testsuites. So we check for negative line numbers
1970 rather than non-positive line numbers. */
1971 as_warn (_("line numbers must be positive; line number %d rejected"),
1979 if (*input_line_pointer
== '"')
1980 file
= demand_copy_string (&length
);
1981 else if (*input_line_pointer
== '.')
1983 /* buffer_and_nest() may insert this form. */
1984 ++input_line_pointer
;
1992 while (get_linefile_number (&this_flag
))
1995 /* From GCC's cpp documentation:
1996 1: start of a new file.
1997 2: returning to a file after having included another file.
1998 3: following text comes from a system header file.
1999 4: following text should be treated as extern "C".
2001 4 is nonsensical for the assembler; 3, we don't care about,
2002 so we ignore it just in case a system header file is
2003 included while preprocessing assembly. So 1 and 2 are all
2004 we care about, and they are mutually incompatible.
2005 new_logical_line_flags() demands this. */
2008 if (flags
&& flags
!= (1 << this_flag
))
2009 as_warn (_("incompatible flag %i in line directive"),
2012 flags
|= 1 << this_flag
;
2017 /* We ignore these. */
2021 as_warn (_("unsupported flag %i in line directive"),
2026 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2033 new_logical_line_flags (file
, linenum
, flags
);
2036 listing_source_line (linenum
);
2041 demand_empty_rest_of_line ();
2043 ignore_rest_of_line ();
2046 /* Handle the .end pseudo-op. Actually, the real work is done in
2047 read_a_source_file. */
2050 s_end (int ignore ATTRIBUTE_UNUSED
)
2054 /* The MRI assembler permits the start symbol to follow .end,
2055 but we don't support that. */
2057 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2058 && *input_line_pointer
!= '*'
2059 && *input_line_pointer
!= '!')
2060 as_warn (_("start address not supported"));
2064 /* Handle the .err pseudo-op. */
2067 s_err (int ignore ATTRIBUTE_UNUSED
)
2069 as_bad (_(".err encountered"));
2070 demand_empty_rest_of_line ();
2073 /* Handle the .error and .warning pseudo-ops. */
2079 /* The purpose for the conditional assignment is not to
2080 internationalize the directive itself, but that we need a
2081 self-contained message, one that can be passed like the
2082 demand_copy_C_string return value, and with no assumption on the
2083 location of the name of the directive within the message. */
2085 = (err
? _(".error directive invoked in source file")
2086 : _(".warning directive invoked in source file"));
2088 if (!is_it_end_of_statement ())
2090 if (*input_line_pointer
!= '\"')
2092 as_bad (_("%s argument must be a string"),
2093 err
? ".error" : ".warning");
2094 ignore_rest_of_line ();
2098 msg
= demand_copy_C_string (&len
);
2106 as_warn ("%s", msg
);
2107 demand_empty_rest_of_line ();
2110 /* Handle the MRI fail pseudo-op. */
2113 s_fail (int ignore ATTRIBUTE_UNUSED
)
2120 stop
= mri_comment_field (&stopc
);
2122 temp
= get_absolute_expression ();
2124 as_warn (_(".fail %ld encountered"), (long) temp
);
2126 as_bad (_(".fail %ld encountered"), (long) temp
);
2128 demand_empty_rest_of_line ();
2131 mri_comment_end (stop
, stopc
);
2135 s_fill (int ignore ATTRIBUTE_UNUSED
)
2137 expressionS rep_exp
;
2142 #ifdef md_flush_pending_output
2143 md_flush_pending_output ();
2146 #ifdef md_cons_align
2150 expression (&rep_exp
);
2151 if (*input_line_pointer
== ',')
2153 input_line_pointer
++;
2154 size
= get_absolute_expression ();
2155 if (*input_line_pointer
== ',')
2157 input_line_pointer
++;
2158 fill
= get_absolute_expression ();
2162 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2163 #define BSD_FILL_SIZE_CROCK_8 (8)
2164 if (size
> BSD_FILL_SIZE_CROCK_8
)
2166 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2167 size
= BSD_FILL_SIZE_CROCK_8
;
2171 as_warn (_("size negative; .fill ignored"));
2174 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2176 if (rep_exp
.X_add_number
< 0)
2177 as_warn (_("repeat < 0; .fill ignored"));
2181 if (size
&& !need_pass_2
)
2183 if (now_seg
== absolute_section
)
2185 if (rep_exp
.X_op
!= O_constant
)
2186 as_bad (_("non-constant fill count for absolute section"));
2187 else if (fill
&& rep_exp
.X_add_number
!= 0)
2188 as_bad (_("attempt to fill absolute section with non-zero value"));
2189 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2192 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2194 as_bad (_("attempt to fill section `%s' with non-zero value"),
2195 segment_name (now_seg
));
2197 if (rep_exp
.X_op
== O_constant
)
2199 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2200 (relax_substateT
) 0, (symbolS
*) 0,
2201 (offsetT
) rep_exp
.X_add_number
,
2206 /* We don't have a constant repeat count, so we can't use
2207 rs_fill. We can get the same results out of rs_space,
2208 but its argument is in bytes, so we must multiply the
2209 repeat count by size. */
2212 rep_sym
= make_expr_symbol (&rep_exp
);
2215 expressionS size_exp
;
2216 size_exp
.X_op
= O_constant
;
2217 size_exp
.X_add_number
= size
;
2219 rep_exp
.X_op
= O_multiply
;
2220 rep_exp
.X_add_symbol
= rep_sym
;
2221 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2222 rep_exp
.X_add_number
= 0;
2223 rep_sym
= make_expr_symbol (&rep_exp
);
2226 p
= frag_var (rs_space
, (int) size
, (int) size
,
2227 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2230 memset (p
, 0, (unsigned int) size
);
2232 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2233 flavoured AS. The following bizarre behaviour is to be
2234 compatible with above. I guess they tried to take up to 8
2235 bytes from a 4-byte expression and they forgot to sign
2237 #define BSD_FILL_SIZE_CROCK_4 (4)
2238 md_number_to_chars (p
, (valueT
) fill
,
2239 (size
> BSD_FILL_SIZE_CROCK_4
2240 ? BSD_FILL_SIZE_CROCK_4
2242 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2243 but emits no error message because it seems a legal thing to do.
2244 It is a degenerate case of .fill but could be emitted by a
2247 demand_empty_rest_of_line ();
2251 s_globl (int ignore ATTRIBUTE_UNUSED
)
2260 stop
= mri_comment_field (&stopc
);
2264 if ((name
= read_symbol_name ()) == NULL
)
2267 symbolP
= symbol_find_or_make (name
);
2268 S_SET_EXTERNAL (symbolP
);
2271 c
= *input_line_pointer
;
2274 input_line_pointer
++;
2276 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2284 demand_empty_rest_of_line ();
2287 mri_comment_end (stop
, stopc
);
2290 /* Handle the MRI IRP and IRPC pseudo-ops. */
2302 file
= as_where (&line
);
2304 eol
= find_end_of_line (input_line_pointer
, 0);
2305 sb_build (&s
, eol
- input_line_pointer
);
2306 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2307 input_line_pointer
= eol
;
2311 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2313 as_bad_where (file
, line
, "%s", err
);
2317 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2319 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2322 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2323 the section to only be linked once. However, this is not supported
2324 by most object file formats. This takes an optional argument,
2325 which is what to do about duplicates. */
2328 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2330 enum linkonce_type type
;
2334 type
= LINKONCE_DISCARD
;
2336 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2341 c
= get_symbol_name (& s
);
2342 if (strcasecmp (s
, "discard") == 0)
2343 type
= LINKONCE_DISCARD
;
2344 else if (strcasecmp (s
, "one_only") == 0)
2345 type
= LINKONCE_ONE_ONLY
;
2346 else if (strcasecmp (s
, "same_size") == 0)
2347 type
= LINKONCE_SAME_SIZE
;
2348 else if (strcasecmp (s
, "same_contents") == 0)
2349 type
= LINKONCE_SAME_CONTENTS
;
2351 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2353 (void) restore_line_pointer (c
);
2356 #ifdef obj_handle_link_once
2357 obj_handle_link_once (type
);
2358 #else /* ! defined (obj_handle_link_once) */
2362 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2363 as_warn (_(".linkonce is not supported for this object file format"));
2365 flags
= bfd_section_flags (now_seg
);
2366 flags
|= SEC_LINK_ONCE
;
2371 case LINKONCE_DISCARD
:
2372 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2374 case LINKONCE_ONE_ONLY
:
2375 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2377 case LINKONCE_SAME_SIZE
:
2378 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2380 case LINKONCE_SAME_CONTENTS
:
2381 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2384 if (!bfd_set_section_flags (now_seg
, flags
))
2385 as_bad (_("bfd_set_section_flags: %s"),
2386 bfd_errmsg (bfd_get_error ()));
2388 #endif /* ! defined (obj_handle_link_once) */
2390 demand_empty_rest_of_line ();
2394 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2397 segT current_seg
= now_seg
;
2398 subsegT current_subseg
= now_subseg
;
2399 segT bss_seg
= bss_section
;
2401 #if defined (TC_MIPS) || defined (TC_ALPHA)
2402 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2403 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2405 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2406 if (size
<= bfd_get_gp_size (stdoutput
))
2408 bss_seg
= subseg_new (".sbss", 1);
2409 seg_info (bss_seg
)->bss
= 1;
2410 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2411 as_warn (_("error setting flags for \".sbss\": %s"),
2412 bfd_errmsg (bfd_get_error ()));
2416 subseg_set (bss_seg
, 1);
2418 if (align
> OCTETS_PER_BYTE_POWER
)
2420 record_alignment (bss_seg
, align
);
2421 frag_align (align
, 0, 0);
2424 /* Detach from old frag. */
2425 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2426 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2428 symbol_set_frag (symbolP
, frag_now
);
2429 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2433 S_SET_SIZE (symbolP
, size
);
2435 S_SET_SEGMENT (symbolP
, bss_seg
);
2438 /* The symbol may already have been created with a preceding
2439 ".globl" directive -- be careful not to step on storage class
2440 in that case. Otherwise, set it to static. */
2441 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2442 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2443 #endif /* OBJ_COFF */
2445 subseg_set (current_seg
, current_subseg
);
2449 parse_align (int align_bytes
)
2455 if (*input_line_pointer
!= ',')
2458 as_bad (_("expected alignment after size"));
2459 ignore_rest_of_line ();
2463 input_line_pointer
++;
2466 align
= get_absolute_expr (&exp
);
2467 if (exp
.X_op
== O_absent
)
2470 if (!exp
.X_unsigned
)
2472 as_warn (_("alignment negative; 0 assumed"));
2476 if (align_bytes
&& align
!= 0)
2478 /* convert to a power of 2 alignment */
2479 unsigned int alignp2
= 0;
2480 while ((align
& 1) == 0)
2481 align
>>= 1, ++alignp2
;
2484 as_bad (_("alignment not a power of 2"));
2485 ignore_rest_of_line ();
2493 /* Called from s_comm_internal after symbol name and size have been
2494 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2495 1 if this was a ".bss" directive which has a 3rd argument
2496 (alignment as a power of 2), or 2 if this was a ".bss" directive
2497 with alignment in bytes. */
2500 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2506 align
= parse_align (needs_align
- 1);
2507 if (align
== (addressT
) -1)
2511 /* Assume some objects may require alignment on some systems. */
2512 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2514 bss_alloc (symbolP
, size
, align
);
2519 s_lcomm (int needs_align
)
2521 s_comm_internal (needs_align
, s_lcomm_internal
);
2525 s_lcomm_bytes (int needs_align
)
2527 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2531 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2537 /* We permit ANY defined expression: BSD4.2 demands constants. */
2538 if ((name
= read_symbol_name ()) == NULL
)
2541 if (*input_line_pointer
!= ',')
2543 as_bad (_("expected comma after \"%s\""), name
);
2547 input_line_pointer
++;
2548 expression_and_evaluate (&exp
);
2550 if (exp
.X_op
!= O_constant
2551 && exp
.X_op
!= O_register
)
2553 as_bad (_("bad expression"));
2557 symbolP
= symbol_find_or_make (name
);
2559 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2561 /* The name might be an undefined .global symbol; be sure to
2562 keep the "external" bit. */
2563 S_SET_SEGMENT (symbolP
,
2564 (exp
.X_op
== O_constant
2567 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2571 as_bad (_("symbol `%s' is already defined"), name
);
2574 demand_empty_rest_of_line ();
2579 ignore_rest_of_line ();
2584 /* Read a line into an sb. Returns the character that ended the line
2585 or zero if there are no more lines. */
2588 get_line_sb (sb
*line
, int in_macro
)
2592 if (input_line_pointer
[-1] == '\n')
2593 bump_line_counters ();
2595 if (input_line_pointer
>= buffer_limit
)
2597 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2598 if (buffer_limit
== 0)
2602 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2603 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2604 input_line_pointer
= eol
;
2606 /* Don't skip multiple end-of-line characters, because that breaks support
2607 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2608 characters but isn't. Instead just skip one end of line character and
2609 return the character skipped so that the caller can re-insert it if
2611 return *input_line_pointer
++;
2615 get_non_macro_line_sb (sb
*line
)
2617 return get_line_sb (line
, 0);
2621 get_macro_line_sb (sb
*line
)
2623 return get_line_sb (line
, 1);
2626 /* Define a macro. This is an interface to macro.c. */
2629 s_macro (int ignore ATTRIBUTE_UNUSED
)
2638 file
= as_where (&line
);
2640 eol
= find_end_of_line (input_line_pointer
, 0);
2641 sb_build (&s
, eol
- input_line_pointer
);
2642 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2643 input_line_pointer
= eol
;
2645 if (line_label
!= NULL
)
2650 name
= S_GET_NAME (line_label
);
2651 len
= strlen (name
);
2652 sb_build (&label
, len
);
2653 sb_add_buffer (&label
, name
, len
);
2654 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2658 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2660 as_bad_where (file
, line
, err
, name
);
2663 if (line_label
!= NULL
)
2665 S_SET_SEGMENT (line_label
, absolute_section
);
2666 S_SET_VALUE (line_label
, 0);
2667 symbol_set_frag (line_label
, &zero_address_frag
);
2670 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2671 && str_hash_find (po_hash
, name
) != NULL
)
2674 && str_hash_find (po_hash
, name
+ 1) != NULL
))
2675 as_warn_where (file
,
2677 _("attempt to redefine pseudo-op `%s' ignored"),
2684 /* Handle the .mexit pseudo-op, which immediately exits a macro
2688 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2692 cond_exit_macro (macro_nest
);
2693 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2696 as_warn (_("ignoring macro exit outside a macro definition."));
2699 /* Switch in and out of MRI mode. */
2702 s_mri (int ignore ATTRIBUTE_UNUSED
)
2705 #ifdef MRI_MODE_CHANGE
2709 on
= get_absolute_expression ();
2710 #ifdef MRI_MODE_CHANGE
2711 old_flag
= flag_mri
;
2730 /* Operator precedence changes in m68k MRI mode, so we need to
2731 update the operator rankings. */
2732 expr_set_precedence ();
2734 #ifdef MRI_MODE_CHANGE
2736 MRI_MODE_CHANGE (on
);
2739 demand_empty_rest_of_line ();
2742 /* Handle changing the location counter. */
2745 do_org (segT segment
, expressionS
*exp
, int fill
)
2747 if (segment
!= now_seg
2748 && segment
!= absolute_section
2749 && segment
!= expr_section
)
2750 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2752 if (now_seg
== absolute_section
)
2755 as_warn (_("ignoring fill value in absolute section"));
2756 if (exp
->X_op
!= O_constant
)
2758 as_bad (_("only constant offsets supported in absolute section"));
2759 exp
->X_add_number
= 0;
2761 abs_section_offset
= exp
->X_add_number
;
2766 symbolS
*sym
= exp
->X_add_symbol
;
2767 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2769 if (fill
&& in_bss ())
2770 as_warn (_("ignoring fill value in section `%s'"),
2771 segment_name (now_seg
));
2773 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2775 /* Handle complex expressions. */
2776 sym
= make_expr_symbol (exp
);
2780 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2786 s_org (int ignore ATTRIBUTE_UNUSED
)
2792 #ifdef md_flush_pending_output
2793 md_flush_pending_output ();
2796 /* The m68k MRI assembler has a different meaning for .org. It
2797 means to create an absolute section at a given address. We can't
2798 support that--use a linker script instead. */
2801 as_bad (_("MRI style ORG pseudo-op not supported"));
2802 ignore_rest_of_line ();
2806 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2807 thing as a sub-segment-relative origin. Any absolute origin is
2808 given a warning, then assumed to be segment-relative. Any
2809 segmented origin expression ("foo+42") had better be in the right
2810 segment or the .org is ignored.
2812 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2813 we never know sub-segment sizes when we are reading code. BSD
2814 will crash trying to emit negative numbers of filler bytes in
2815 certain .orgs. We don't crash, but see as-write for that code.
2817 Don't make frag if need_pass_2==1. */
2818 segment
= get_known_segmented_expression (&exp
);
2819 if (*input_line_pointer
== ',')
2821 input_line_pointer
++;
2822 temp_fill
= get_absolute_expression ();
2828 do_org (segment
, &exp
, temp_fill
);
2830 demand_empty_rest_of_line ();
2833 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2834 called by the obj-format routine which handles section changing
2835 when in MRI mode. It will create a new section, and return it. It
2836 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2837 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2840 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2850 name
= input_line_pointer
;
2851 if (!ISDIGIT (*name
))
2852 c
= get_symbol_name (& name
);
2857 ++input_line_pointer
;
2859 while (ISDIGIT (*input_line_pointer
));
2861 c
= *input_line_pointer
;
2862 *input_line_pointer
= '\0';
2865 name
= xstrdup (name
);
2867 c
= restore_line_pointer (c
);
2869 seg
= subseg_new (name
, 0);
2875 ++input_line_pointer
;
2876 align
= get_absolute_expression ();
2877 record_alignment (seg
, align
);
2881 if (*input_line_pointer
== ',')
2883 c
= *++input_line_pointer
;
2885 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2888 as_bad (_("unrecognized section type"));
2889 ++input_line_pointer
;
2894 flags
= SEC_NO_FLAGS
;
2896 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2897 else if (*type
== 'D' || *type
== 'M')
2898 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2899 else if (*type
== 'R')
2900 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2901 if (flags
!= SEC_NO_FLAGS
)
2903 if (!bfd_set_section_flags (seg
, flags
))
2904 as_warn (_("error setting flags for \"%s\": %s"),
2905 bfd_section_name (seg
),
2906 bfd_errmsg (bfd_get_error ()));
2911 /* Ignore the HP type. */
2912 if (*input_line_pointer
== ',')
2913 input_line_pointer
+= 2;
2915 demand_empty_rest_of_line ();
2917 #else /* ! TC_M68K */
2918 /* The MRI assembler seems to use different forms of .sect for
2919 different targets. */
2920 as_bad ("MRI mode not supported for this target");
2921 ignore_rest_of_line ();
2922 #endif /* ! TC_M68K */
2925 /* Handle the .print pseudo-op. */
2928 s_print (int ignore ATTRIBUTE_UNUSED
)
2933 s
= demand_copy_C_string (&len
);
2936 demand_empty_rest_of_line ();
2939 /* Handle the .purgem pseudo-op. */
2942 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2944 if (is_it_end_of_statement ())
2946 demand_empty_rest_of_line ();
2956 c
= get_symbol_name (& name
);
2957 delete_macro (name
);
2958 *input_line_pointer
= c
;
2959 SKIP_WHITESPACE_AFTER_NAME ();
2961 while (*input_line_pointer
++ == ',');
2963 --input_line_pointer
;
2964 demand_empty_rest_of_line ();
2967 /* Handle the .endm/.endr pseudo-ops. */
2970 s_bad_end (int endr
)
2972 as_warn (_(".end%c encountered without preceding %s"),
2974 endr
? ".rept, .irp, or .irpc" : ".macro");
2975 demand_empty_rest_of_line ();
2978 /* Handle the .rept pseudo-op. */
2981 s_rept (int ignore ATTRIBUTE_UNUSED
)
2985 count
= (size_t) get_absolute_expression ();
2987 do_repeat (count
, "REPT", "ENDR", NULL
);
2990 /* This function provides a generic repeat block implementation. It allows
2991 different directives to be used as the start/end keys. Any text matching
2992 the optional EXPANDER in the block is replaced by the remaining iteration
2996 do_repeat (size_t count
, const char *start
, const char *end
,
2997 const char *expander
)
3002 if (((ssize_t
) count
) < 0)
3004 as_bad (_("negative count for %s - ignored"), start
);
3009 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3011 as_bad (_("%s without %s"), start
, end
);
3015 if (expander
== NULL
|| strstr (one
.ptr
, expander
) == NULL
)
3017 sb_build (&many
, count
* one
.len
);
3019 sb_add_sb (&many
, &one
);
3025 while (count
-- > 0)
3031 sb_build (& processed
, one
.len
);
3032 sb_add_sb (& processed
, & one
);
3033 sub
= strstr (processed
.ptr
, expander
);
3034 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3035 gas_assert (len
< 8);
3036 memmove (sub
+ len
, sub
+ 8,
3037 processed
.ptr
+ processed
.len
- (sub
+ 8));
3038 processed
.len
-= (8 - len
);
3039 sb_add_sb (& many
, & processed
);
3040 sb_kill (& processed
);
3046 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3048 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3051 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3052 input buffers to skip. Assumes that conditionals preceding the loop end
3053 are properly nested.
3055 This function makes it easier to implement a premature "break" out of the
3056 loop. The EXTRA arg accounts for other buffers we might have inserted,
3057 such as line substitutions. */
3060 end_repeat (int extra
)
3062 cond_exit_macro (macro_nest
);
3063 while (extra
-- >= 0)
3064 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3068 assign_symbol (char *name
, int mode
)
3072 if (name
[0] == '.' && name
[1] == '\0')
3074 /* Turn '. = mumble' into a .org mumble. */
3078 segment
= get_known_segmented_expression (&exp
);
3081 do_org (segment
, &exp
, 0);
3086 if ((symbolP
= symbol_find (name
)) == NULL
3087 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3089 symbolP
= symbol_find_or_make (name
);
3091 /* When doing symbol listings, play games with dummy fragments living
3092 outside the normal fragment chain to record the file and line info
3094 if (listing
& LISTING_SYMBOLS
)
3096 extern struct list_info_struct
*listing_tail
;
3097 fragS
*dummy_frag
= XCNEW (fragS
);
3098 dummy_frag
->line
= listing_tail
;
3099 dummy_frag
->fr_symbol
= symbolP
;
3100 symbol_set_frag (symbolP
, dummy_frag
);
3103 #if defined (OBJ_COFF) && !defined (TE_PE)
3104 /* "set" symbols are local unless otherwise specified. */
3105 SF_SET_LOCAL (symbolP
);
3109 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3111 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3112 && !S_CAN_BE_REDEFINED (symbolP
))
3114 as_bad (_("symbol `%s' is already defined"), name
);
3115 ignore_rest_of_line ();
3116 input_line_pointer
--;
3119 /* If the symbol is volatile, copy the symbol and replace the
3120 original with the copy, so that previous uses of the symbol will
3121 retain the value of the symbol at the point of use. */
3122 else if (S_IS_VOLATILE (symbolP
))
3123 symbolP
= symbol_clone (symbolP
, 1);
3127 S_SET_VOLATILE (symbolP
);
3129 S_SET_FORWARD_REF (symbolP
);
3131 pseudo_set (symbolP
);
3134 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3135 then this is .equiv, and it is an error if the symbol is already
3136 defined. If EQUIV is -1, the symbol additionally is a forward
3144 /* Especial apologies for the random logic:
3145 this just grew, and could be parsed much more simply!
3147 if ((name
= read_symbol_name ()) == NULL
)
3150 if (*input_line_pointer
!= ',')
3152 as_bad (_("expected comma after \"%s\""), name
);
3153 ignore_rest_of_line ();
3158 input_line_pointer
++;
3159 assign_symbol (name
, equiv
);
3160 demand_empty_rest_of_line ();
3174 #ifdef md_flush_pending_output
3175 md_flush_pending_output ();
3182 # ifndef P_PRECISION
3183 # define P_PRECISION X_PRECISION
3184 # define P_PRECISION_PAD X_PRECISION_PAD
3186 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3194 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3201 #ifdef md_cons_align
3206 stop
= mri_comment_field (&stopc
);
3208 /* In m68k MRI mode, we need to align to a word boundary, unless
3210 if (flag_m68k_mri
&& mult
> 1)
3212 if (now_seg
== absolute_section
)
3214 abs_section_offset
+= abs_section_offset
& 1;
3215 if (line_label
!= NULL
)
3216 S_SET_VALUE (line_label
, abs_section_offset
);
3218 else if (mri_common_symbol
!= NULL
)
3222 mri_val
= S_GET_VALUE (mri_common_symbol
);
3223 if ((mri_val
& 1) != 0)
3225 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3226 if (line_label
!= NULL
)
3228 expressionS
*symexp
;
3230 symexp
= symbol_get_value_expression (line_label
);
3231 know (symexp
->X_op
== O_symbol
);
3232 know (symexp
->X_add_symbol
== mri_common_symbol
);
3233 symexp
->X_add_number
+= 1;
3239 do_align (1, (char *) NULL
, 0, 0);
3240 if (line_label
!= NULL
)
3242 symbol_set_frag (line_label
, frag_now
);
3243 S_SET_VALUE (line_label
, frag_now_fix ());
3253 if (*input_line_pointer
== ',')
3255 ++input_line_pointer
;
3260 val
.X_op
= O_constant
;
3261 val
.X_add_number
= 0;
3264 if ((val
.X_op
!= O_constant
3265 || val
.X_add_number
< - 0x80
3266 || val
.X_add_number
> 0xff
3267 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3268 && (now_seg
!= absolute_section
&& !in_bss ()))
3270 resolve_expression (&exp
);
3271 if (exp
.X_op
!= O_constant
)
3272 as_bad (_("unsupported variable size or fill value"));
3277 /* PR 20901: Check for excessive values.
3278 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3279 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3280 as_bad (_("size value for space directive too large: %lx"),
3281 (long) exp
.X_add_number
);
3286 bytes
= mult
* exp
.X_add_number
;
3288 for (i
= 0; i
< exp
.X_add_number
; i
++)
3289 emit_expr (&val
, mult
);
3295 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3296 resolve_expression (&exp
);
3298 if (exp
.X_op
== O_constant
)
3302 repeat
= exp
.X_add_number
;
3309 as_warn (_(".space repeat count is zero, ignored"));
3310 else if (repeat
< 0)
3311 as_warn (_(".space repeat count is negative, ignored"));
3315 /* If we are in the absolute section, just bump the offset. */
3316 if (now_seg
== absolute_section
)
3318 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3319 as_warn (_("ignoring fill value in absolute section"));
3320 abs_section_offset
+= repeat
;
3324 /* If we are secretly in an MRI common section, then
3325 creating space just increases the size of the common
3327 if (mri_common_symbol
!= NULL
)
3329 S_SET_VALUE (mri_common_symbol
,
3330 S_GET_VALUE (mri_common_symbol
) + repeat
);
3335 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3336 (offsetT
) repeat
, (char *) 0);
3340 if (now_seg
== absolute_section
)
3342 as_bad (_("space allocation too complex in absolute section"));
3343 subseg_set (text_section
, 0);
3346 if (mri_common_symbol
!= NULL
)
3348 as_bad (_("space allocation too complex in common section"));
3349 mri_common_symbol
= NULL
;
3353 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3354 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3357 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3358 as_warn (_("ignoring fill value in section `%s'"),
3359 segment_name (now_seg
));
3361 *p
= val
.X_add_number
;
3366 /* In MRI mode, after an odd number of bytes, we must align to an
3367 even word boundary, unless the next instruction is a dc.b, ds.b
3369 if (flag_mri
&& (bytes
& 1) != 0)
3370 mri_pending_align
= 1;
3372 demand_empty_rest_of_line ();
3375 mri_comment_end (stop
, stopc
);
3379 s_nop (int ignore ATTRIBUTE_UNUSED
)
3386 #ifdef md_flush_pending_output
3387 md_flush_pending_output ();
3390 #ifdef md_cons_align
3396 demand_empty_rest_of_line ();
3399 start_off
= frag_now_fix ();
3402 #ifdef md_emit_single_noop
3403 md_emit_single_noop
;
3407 #ifndef md_single_noop_insn
3408 #define md_single_noop_insn "nop"
3410 /* md_assemble might modify its argument, so
3411 we must pass it a string that is writable. */
3412 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3413 as_fatal ("%s", xstrerror (errno
));
3415 /* Some targets assume that they can update input_line_pointer
3416 inside md_assemble, and, worse, that they can leave it
3417 assigned to the string pointer that was provided as an
3418 argument. So preserve ilp here. */
3419 char *saved_ilp
= input_line_pointer
;
3421 input_line_pointer
= saved_ilp
;
3424 #ifdef md_flush_pending_output
3425 md_flush_pending_output ();
3427 } while (exp
.X_op
== O_constant
3428 && exp
.X_add_number
> 0
3429 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3430 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3434 s_nops (int ignore ATTRIBUTE_UNUSED
)
3439 #ifdef md_flush_pending_output
3440 md_flush_pending_output ();
3443 #ifdef md_cons_align
3449 /* Note - this expression is tested for an absolute value in
3450 write.c:relax_segment(). */
3453 if (*input_line_pointer
== ',')
3455 ++input_line_pointer
;
3460 val
.X_op
= O_constant
;
3461 val
.X_add_number
= 0;
3464 if (val
.X_op
!= O_constant
)
3466 as_bad (_("unsupported variable nop control in .nops directive"));
3467 val
.X_op
= O_constant
;
3468 val
.X_add_number
= 0;
3470 else if (val
.X_add_number
< 0)
3472 as_warn (_("negative nop control byte, ignored"));
3473 val
.X_add_number
= 0;
3476 demand_empty_rest_of_line ();
3479 /* Ignore this directive if we are going to perform a second pass. */
3482 /* Store the no-op instruction control byte in the first byte of frag. */
3484 symbolS
*sym
= make_expr_symbol (&exp
);
3485 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3486 sym
, (offsetT
) 0, (char *) 0);
3487 *p
= val
.X_add_number
;
3490 /* Obtain the size of a floating point number, given a type. */
3493 float_length (int float_type
, int *pad_p
)
3495 int length
, pad
= 0;
3523 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3524 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3533 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3534 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3541 as_bad (_("unknown floating type '%c'"), float_type
);
3553 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3559 /* Skip any 0{letter} that may be present. Don't even check if the
3560 letter is legal. Someone may invent a "z" format and this routine
3561 has no use for such information. Lusers beware: you get
3562 diagnostics if your input is ill-conditioned. */
3563 if (input_line_pointer
[0] == '0'
3564 && ISALPHA (input_line_pointer
[1]))
3565 input_line_pointer
+= 2;
3567 /* Accept :xxxx, where the x's are hex digits, for a floating point
3568 with the exact digits specified. */
3569 if (input_line_pointer
[0] == ':')
3571 ++input_line_pointer
;
3572 length
= hex_float (float_type
, temp
);
3575 ignore_rest_of_line ();
3583 err
= md_atof (float_type
, temp
, &length
);
3584 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3585 know (err
!= NULL
|| length
> 0);
3588 as_bad (_("bad floating literal: %s"), err
);
3589 ignore_rest_of_line ();
3597 /* This is like s_space, but the value is a floating point number with
3598 the given precision. This is for the MRI dcb.s pseudo-op and
3602 s_float_space (int float_type
)
3606 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3610 #ifdef md_cons_align
3615 stop
= mri_comment_field (&stopc
);
3617 count
= get_absolute_expression ();
3620 if (*input_line_pointer
!= ',')
3624 flen
= float_length (float_type
, &pad
);
3626 memset (temp
, 0, flen
+= pad
);
3630 ++input_line_pointer
;
3632 flen
= parse_one_float (float_type
, temp
);
3638 mri_comment_end (stop
, stopc
);
3642 while (--count
>= 0)
3646 p
= frag_more (flen
);
3647 memcpy (p
, temp
, (unsigned int) flen
);
3650 demand_empty_rest_of_line ();
3653 mri_comment_end (stop
, stopc
);
3656 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3659 s_struct (int ignore ATTRIBUTE_UNUSED
)
3665 stop
= mri_comment_field (&stopc
);
3666 abs_section_offset
= get_absolute_expression ();
3667 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3668 /* The ELF backend needs to know that we are changing sections, so
3669 that .previous works correctly. */
3671 obj_elf_section_change_hook ();
3673 subseg_set (absolute_section
, 0);
3674 demand_empty_rest_of_line ();
3676 mri_comment_end (stop
, stopc
);
3680 s_text (int ignore ATTRIBUTE_UNUSED
)
3684 temp
= get_absolute_expression ();
3685 subseg_set (text_section
, (subsegT
) temp
);
3686 demand_empty_rest_of_line ();
3689 /* .weakref x, y sets x as an alias to y that, as long as y is not
3690 referenced directly, will cause y to become a weak symbol. */
3692 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3699 if ((name
= read_symbol_name ()) == NULL
)
3702 symbolP
= symbol_find_or_make (name
);
3704 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3706 if (!S_IS_VOLATILE (symbolP
))
3708 as_bad (_("symbol `%s' is already defined"), name
);
3711 symbolP
= symbol_clone (symbolP
, 1);
3712 S_CLEAR_VOLATILE (symbolP
);
3717 if (*input_line_pointer
!= ',')
3719 as_bad (_("expected comma after \"%s\""), name
);
3723 input_line_pointer
++;
3728 if ((name
= read_symbol_name ()) == NULL
)
3731 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3732 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3734 symbolP2
= symbol_find_or_make (name
);
3735 S_SET_WEAKREFD (symbolP2
);
3739 symbolS
*symp
= symbolP2
;
3741 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3743 expressionS
*expP
= symbol_get_value_expression (symp
);
3745 gas_assert (expP
->X_op
== O_symbol
3746 && expP
->X_add_number
== 0);
3747 symp
= expP
->X_add_symbol
;
3749 if (symp
== symbolP
)
3753 loop
= concat (S_GET_NAME (symbolP
),
3754 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3757 while (symp
!= symbolP
)
3759 char *old_loop
= loop
;
3761 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3762 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3763 (const char *) NULL
);
3767 as_bad (_("%s: would close weakref loop: %s"),
3768 S_GET_NAME (symbolP
), loop
);
3772 ignore_rest_of_line ();
3776 /* Short-circuiting instead of just checking here might speed
3777 things up a tiny little bit, but loop error messages would
3778 miss intermediate links. */
3779 /* symbolP2 = symp; */
3782 memset (&exp
, 0, sizeof (exp
));
3783 exp
.X_op
= O_symbol
;
3784 exp
.X_add_symbol
= symbolP2
;
3786 S_SET_SEGMENT (symbolP
, undefined_section
);
3787 symbol_set_value_expression (symbolP
, &exp
);
3788 symbol_set_frag (symbolP
, &zero_address_frag
);
3789 S_SET_WEAKREFR (symbolP
);
3791 demand_empty_rest_of_line ();
3796 ignore_rest_of_line ();
3802 /* Verify that we are at the end of a line. If not, issue an error and
3803 skip to EOL. This function may leave input_line_pointer one past
3804 buffer_limit, so should not be called from places that may
3805 dereference input_line_pointer unconditionally. Note that when the
3806 gas parser is switched to handling a string (where buffer_limit
3807 should be the size of the string excluding the NUL terminator) this
3808 will be one past the NUL; is_end_of_line(0) returns true. */
3811 demand_empty_rest_of_line (void)
3814 if (input_line_pointer
> buffer_limit
)
3816 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3817 input_line_pointer
++;
3820 if (ISPRINT (*input_line_pointer
))
3821 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3822 *input_line_pointer
);
3824 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3825 *input_line_pointer
);
3826 ignore_rest_of_line ();
3828 /* Return pointing just after end-of-line. */
3831 /* Silently advance to the end of line. Use this after already having
3832 issued an error about something bad. Like demand_empty_rest_of_line,
3833 this function may leave input_line_pointer one after buffer_limit;
3834 Don't call it from within expression parsing code in an attempt to
3835 silence further errors. */
3838 ignore_rest_of_line (void)
3840 while (input_line_pointer
<= buffer_limit
)
3841 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3843 /* Return pointing just after end-of-line. */
3846 /* Sets frag for given symbol to zero_address_frag, except when the
3847 symbol frag is already set to a dummy listing frag. */
3850 set_zero_frag (symbolS
*symbolP
)
3852 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3853 symbol_set_frag (symbolP
, &zero_address_frag
);
3856 /* In: Pointer to a symbol.
3857 Input_line_pointer->expression.
3859 Out: Input_line_pointer->just after any whitespace after expression.
3860 Tried to set symbol to value of expression.
3861 Will change symbols type, value, and frag; */
3864 pseudo_set (symbolS
*symbolP
)
3869 know (symbolP
); /* NULL pointer is logic error. */
3871 if (!S_IS_FORWARD_REF (symbolP
))
3872 (void) expression (&exp
);
3874 (void) deferred_expression (&exp
);
3876 if (exp
.X_op
== O_illegal
)
3877 as_bad (_("illegal expression"));
3878 else if (exp
.X_op
== O_absent
)
3879 as_bad (_("missing expression"));
3880 else if (exp
.X_op
== O_big
)
3882 if (exp
.X_add_number
> 0)
3883 as_bad (_("bignum invalid"));
3885 as_bad (_("floating point number invalid"));
3887 else if (exp
.X_op
== O_subtract
3888 && !S_IS_FORWARD_REF (symbolP
)
3889 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3890 && (symbol_get_frag (exp
.X_add_symbol
)
3891 == symbol_get_frag (exp
.X_op_symbol
)))
3893 exp
.X_op
= O_constant
;
3894 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3895 - S_GET_VALUE (exp
.X_op_symbol
));
3898 if (symbol_section_p (symbolP
))
3900 as_bad ("attempt to set value of section symbol");
3909 exp
.X_add_number
= 0;
3912 S_SET_SEGMENT (symbolP
, absolute_section
);
3913 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3914 set_zero_frag (symbolP
);
3918 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3919 if (S_IS_EXTERNAL (symbolP
))
3921 as_bad ("can't equate global symbol `%s' with register name",
3922 S_GET_NAME (symbolP
));
3926 S_SET_SEGMENT (symbolP
, reg_section
);
3927 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3928 set_zero_frag (symbolP
);
3929 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3933 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3934 /* For x=undef+const, create an expression symbol.
3935 For x=x+const, just update x except when x is an undefined symbol
3936 For x=defined+const, evaluate x. */
3937 if (symbolP
== exp
.X_add_symbol
3938 && (seg
!= undefined_section
3939 || !symbol_constant_p (symbolP
)))
3941 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3944 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3946 symbolS
*s
= exp
.X_add_symbol
;
3948 if (S_IS_COMMON (s
))
3949 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3950 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3952 S_SET_SEGMENT (symbolP
, seg
);
3953 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3954 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3955 copy_symbol_attributes (symbolP
, s
);
3958 S_SET_SEGMENT (symbolP
, undefined_section
);
3959 symbol_set_value_expression (symbolP
, &exp
);
3960 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3961 set_zero_frag (symbolP
);
3965 /* The value is some complex expression. */
3966 S_SET_SEGMENT (symbolP
, expr_section
);
3967 symbol_set_value_expression (symbolP
, &exp
);
3968 set_zero_frag (symbolP
);
3975 CONStruct more frag of .bytes, or .words etc.
3976 Should need_pass_2 be 1 then emit no frag(s).
3977 This understands EXPRESSIONS.
3981 This has a split personality. We use expression() to read the
3982 value. We can detect if the value won't fit in a byte or word.
3983 But we can't detect if expression() discarded significant digits
3984 in the case of a long. Not worth the crocks required to fix it. */
3986 /* Select a parser for cons expressions. */
3988 /* Some targets need to parse the expression in various fancy ways.
3989 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3990 (for example, the HPPA does this). Otherwise, you can define
3991 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3992 are defined, which is the normal case, then only simple expressions
3997 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4000 #ifndef TC_PARSE_CONS_EXPRESSION
4001 #ifdef REPEAT_CONS_EXPRESSIONS
4002 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4003 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4005 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4008 /* If we haven't gotten one yet, just call expression. */
4009 #ifndef TC_PARSE_CONS_EXPRESSION
4010 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4011 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4016 do_parse_cons_expression (expressionS
*exp
,
4017 int nbytes ATTRIBUTE_UNUSED
)
4019 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4023 /* Worker to do .byte etc statements.
4024 Clobbers input_line_pointer and checks end-of-line. */
4027 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4035 #ifdef md_flush_pending_output
4036 md_flush_pending_output ();
4040 stop
= mri_comment_field (&stopc
);
4042 if (is_it_end_of_statement ())
4044 demand_empty_rest_of_line ();
4046 mri_comment_end (stop
, stopc
);
4051 nbytes
= TC_ADDRESS_BYTES ();
4053 #ifdef md_cons_align
4054 md_cons_align (nbytes
);
4060 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4061 #ifdef TC_CONS_FIX_CHECK
4062 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4064 if (*cur_fix
!= NULL
)
4065 cur_fix
= &(*cur_fix
)->fx_next
;
4070 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4075 if (*input_line_pointer
== '"')
4077 as_bad (_("unexpected `\"' in expression"));
4078 ignore_rest_of_line ();
4082 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4087 if (exp
.X_op
== O_symbol
)
4088 exp
.X_op
= O_symbol_rva
;
4090 as_fatal (_("rva without symbol"));
4092 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4093 #ifdef TC_CONS_FIX_CHECK
4094 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4098 while (*input_line_pointer
++ == ',');
4100 /* In MRI mode, after an odd number of bytes, we must align to an
4101 even word boundary, unless the next instruction is a dc.b, ds.b
4103 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4104 mri_pending_align
= 1;
4106 input_line_pointer
--; /* Put terminator back into stream. */
4108 demand_empty_rest_of_line ();
4111 mri_comment_end (stop
, stopc
);
4117 cons_worker (size
, 0);
4123 cons_worker (size
, 1);
4126 /* .reloc offset, reloc_name, symbol+addend. */
4129 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4136 struct reloc_list
*reloc
;
4137 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4138 static struct _bfd_rel bfd_relocs
[] =
4140 { "NONE", BFD_RELOC_NONE
},
4141 { "8", BFD_RELOC_8
},
4142 { "16", BFD_RELOC_16
},
4143 { "32", BFD_RELOC_32
},
4144 { "64", BFD_RELOC_64
}
4147 reloc
= XNEW (struct reloc_list
);
4150 stop
= mri_comment_field (&stopc
);
4159 as_bad (_("missing or bad offset expression"));
4162 exp
.X_add_symbol
= section_symbol (now_seg
);
4163 /* Mark the section symbol used in relocation so that it will be
4164 included in the symbol table. */
4165 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4166 exp
.X_op
= O_symbol
;
4169 if (exp
.X_add_number
== 0)
4171 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4176 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4181 if (*input_line_pointer
!= ',')
4183 as_bad (_("missing reloc type"));
4187 ++input_line_pointer
;
4189 c
= get_symbol_name (& r_name
);
4190 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4194 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4195 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4197 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4198 bfd_relocs
[i
].code
);
4203 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4204 *input_line_pointer
= c
;
4205 if (reloc
->u
.a
.howto
== NULL
)
4207 as_bad (_("unrecognized reloc type"));
4211 exp
.X_op
= O_absent
;
4212 SKIP_WHITESPACE_AFTER_NAME ();
4213 if (*input_line_pointer
== ',')
4215 ++input_line_pointer
;
4223 as_bad (_("bad reloc expression"));
4225 ignore_rest_of_line ();
4228 mri_comment_end (stop
, stopc
);
4231 reloc
->u
.a
.sym
= NULL
;
4232 reloc
->u
.a
.addend
= 0;
4235 reloc
->u
.a
.sym
= NULL
;
4236 reloc
->u
.a
.addend
= exp
.X_add_number
;
4239 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4240 reloc
->u
.a
.addend
= exp
.X_add_number
;
4243 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4244 reloc
->u
.a
.addend
= 0;
4248 reloc
->file
= as_where (&reloc
->line
);
4249 reloc
->next
= reloc_list
;
4252 demand_empty_rest_of_line ();
4254 mri_comment_end (stop
, stopc
);
4257 /* Put the contents of expression EXP into the object file using
4258 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4261 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4263 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4267 emit_expr_with_reloc (expressionS
*exp
,
4268 unsigned int nbytes
,
4269 TC_PARSE_CONS_RETURN_TYPE reloc
)
4273 valueT extra_digit
= 0;
4275 /* Don't do anything if we are going to make another pass. */
4280 dot_value
= frag_now_fix ();
4281 dot_frag
= frag_now
;
4285 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4286 appear as a four byte positive constant in the .line section,
4287 followed by a 2 byte 0xffff. Look for that case here. */
4289 static int dwarf_line
= -1;
4291 if (strcmp (segment_name (now_seg
), ".line") != 0)
4293 else if (dwarf_line
>= 0
4295 && exp
->X_op
== O_constant
4296 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4297 listing_source_line ((unsigned int) dwarf_line
);
4298 else if (nbytes
== 4
4299 && exp
->X_op
== O_constant
4300 && exp
->X_add_number
>= 0)
4301 dwarf_line
= exp
->X_add_number
;
4306 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4307 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4308 AT_sibling (0x12) followed by a four byte address of the sibling
4309 followed by a 2 byte AT_name (0x38) followed by the name of the
4310 file. We look for that case here. */
4312 static int dwarf_file
= 0;
4314 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4316 else if (dwarf_file
== 0
4318 && exp
->X_op
== O_constant
4319 && exp
->X_add_number
== 0x11)
4321 else if (dwarf_file
== 1
4323 && exp
->X_op
== O_constant
4324 && exp
->X_add_number
== 0x12)
4326 else if (dwarf_file
== 2
4329 else if (dwarf_file
== 3
4331 && exp
->X_op
== O_constant
4332 && exp
->X_add_number
== 0x38)
4337 /* The variable dwarf_file_string tells stringer that the string
4338 may be the name of the source file. */
4339 if (dwarf_file
== 4)
4340 dwarf_file_string
= 1;
4342 dwarf_file_string
= 0;
4347 if (check_eh_frame (exp
, &nbytes
))
4352 /* Handle a negative bignum. */
4354 && exp
->X_add_number
== 0
4355 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4356 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4359 unsigned long carry
;
4361 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4363 /* Negate the bignum: one's complement each digit and add 1. */
4365 for (i
= 0; i
< exp
->X_add_number
; i
++)
4369 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4372 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4373 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4376 /* We can ignore any carry out, because it will be handled by
4377 extra_digit if it is needed. */
4379 extra_digit
= (valueT
) -1;
4383 if (op
== O_absent
|| op
== O_illegal
)
4385 as_warn (_("zero assumed for missing expression"));
4386 exp
->X_add_number
= 0;
4389 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4391 as_bad (_("floating point number invalid"));
4392 exp
->X_add_number
= 0;
4395 else if (op
== O_register
)
4397 as_warn (_("register value used as expression"));
4401 /* Allow `.word 0' in the absolute section. */
4402 if (now_seg
== absolute_section
)
4404 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4405 as_bad (_("attempt to store value in absolute section"));
4406 abs_section_offset
+= nbytes
;
4410 /* Allow `.word 0' in BSS style sections. */
4411 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4412 as_bad (_("attempt to store non-zero value in section `%s'"),
4413 segment_name (now_seg
));
4415 p
= frag_more ((int) nbytes
);
4417 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4419 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4423 #ifndef WORKING_DOT_WORD
4424 /* If we have the difference of two symbols in a word, save it on
4425 the broken_words list. See the code in write.c. */
4426 if (op
== O_subtract
&& nbytes
== 2)
4428 struct broken_word
*x
;
4430 x
= XNEW (struct broken_word
);
4431 x
->next_broken_word
= broken_words
;
4434 x
->subseg
= now_subseg
;
4436 x
->word_goes_here
= p
;
4438 x
->add
= exp
->X_add_symbol
;
4439 x
->sub
= exp
->X_op_symbol
;
4440 x
->addnum
= exp
->X_add_number
;
4448 /* If we have an integer, but the number of bytes is too large to
4449 pass to md_number_to_chars, handle it as a bignum. */
4450 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4452 extra_digit
= exp
->X_unsigned
? 0 : -1;
4453 convert_to_bignum (exp
, !exp
->X_unsigned
);
4457 if (op
== O_constant
)
4464 /* JF << of >= number of bits in the object is undefined. In
4465 particular SPARC (Sun 4) has problems. */
4466 if (nbytes
>= sizeof (valueT
))
4468 know (nbytes
== sizeof (valueT
));
4473 /* Don't store these bits. */
4474 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4477 unmask
= ~mask
; /* Do store these bits. */
4480 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4481 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4484 get
= exp
->X_add_number
;
4486 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4491 /* These buffers help to ease the translation of the warning message. */
4492 sprintf_vma (get_buf
, get
);
4493 sprintf_vma (use_buf
, use
);
4494 /* Leading bits contain both 0s & 1s. */
4495 as_warn (_("value 0x%s truncated to 0x%s"), get_buf
, use_buf
);
4497 /* Put bytes in right order. */
4498 md_number_to_chars (p
, use
, (int) nbytes
);
4500 else if (op
== O_big
)
4503 LITTLENUM_TYPE
*nums
;
4505 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4508 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4512 LITTLENUM_TYPE sign
= 0;
4513 if ((generic_bignum
[--i
]
4514 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4515 sign
= ~(LITTLENUM_TYPE
) 0;
4517 while (++i
< exp
->X_add_number
)
4518 if (generic_bignum
[i
] != sign
)
4521 else if (nbytes
== 1)
4523 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4524 Check that bits 8.. of generic_bignum[0] match bit 7
4525 and that they match all of generic_bignum[1..exp->X_add_number]. */
4526 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4527 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4529 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4531 while (++i
< exp
->X_add_number
)
4532 if (generic_bignum
[i
] != sign
)
4537 if (i
< exp
->X_add_number
)
4538 as_warn (ngettext ("bignum truncated to %d byte",
4539 "bignum truncated to %d bytes",
4547 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4550 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4552 if (target_big_endian
)
4554 while (nbytes
> size
)
4556 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4557 nbytes
-= CHARS_PER_LITTLENUM
;
4558 p
+= CHARS_PER_LITTLENUM
;
4561 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4562 while (size
>= CHARS_PER_LITTLENUM
)
4565 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4566 size
-= CHARS_PER_LITTLENUM
;
4567 p
+= CHARS_PER_LITTLENUM
;
4572 nums
= generic_bignum
;
4573 while (size
>= CHARS_PER_LITTLENUM
)
4575 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4577 size
-= CHARS_PER_LITTLENUM
;
4578 p
+= CHARS_PER_LITTLENUM
;
4579 nbytes
-= CHARS_PER_LITTLENUM
;
4582 while (nbytes
>= CHARS_PER_LITTLENUM
)
4584 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4585 nbytes
-= CHARS_PER_LITTLENUM
;
4586 p
+= CHARS_PER_LITTLENUM
;
4591 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4595 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4596 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4599 unsigned int size
= nbytes
;
4601 memset (p
, 0, size
);
4603 /* Generate a fixS to record the symbol value. */
4605 #ifdef TC_CONS_FIX_NEW
4606 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4608 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4610 reloc_howto_type
*reloc_howto
;
4612 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4613 size
= bfd_get_reloc_size (reloc_howto
);
4617 as_bad (ngettext ("%s relocations do not fit in %u byte",
4618 "%s relocations do not fit in %u bytes",
4620 reloc_howto
->name
, nbytes
);
4623 else if (target_big_endian
)
4624 offset
= nbytes
- size
;
4645 as_bad (_("unsupported BFD relocation size %u"), size
);
4648 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4653 /* Handle an MRI style string expression. */
4657 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4659 if (*input_line_pointer
!= '\''
4660 && (input_line_pointer
[1] != '\''
4661 || (*input_line_pointer
!= 'A'
4662 && *input_line_pointer
!= 'E')))
4663 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4667 unsigned int result
= 0;
4669 /* An MRI style string. Cut into as many bytes as will fit into
4670 a nbyte chunk, left justify if necessary, and separate with
4671 commas so we can try again later. */
4672 if (*input_line_pointer
== 'A')
4673 ++input_line_pointer
;
4674 else if (*input_line_pointer
== 'E')
4676 as_bad (_("EBCDIC constants are not supported"));
4677 ++input_line_pointer
;
4680 input_line_pointer
++;
4681 for (scan
= 0; scan
< nbytes
; scan
++)
4683 if (*input_line_pointer
== '\'')
4685 if (input_line_pointer
[1] == '\'')
4687 input_line_pointer
++;
4692 result
= (result
<< 8) | (*input_line_pointer
++);
4696 while (scan
< nbytes
)
4702 /* Create correct expression. */
4703 exp
->X_op
= O_constant
;
4704 exp
->X_add_number
= result
;
4706 /* Fake it so that we can read the next char too. */
4707 if (input_line_pointer
[0] != '\'' ||
4708 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4710 input_line_pointer
-= 2;
4711 input_line_pointer
[0] = ',';
4712 input_line_pointer
[1] = '\'';
4715 input_line_pointer
++;
4718 #endif /* TC_M68K */
4720 #ifdef REPEAT_CONS_EXPRESSIONS
4722 /* Parse a repeat expression for cons. This is used by the MIPS
4723 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4724 object file COUNT times.
4726 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4729 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4736 if (*input_line_pointer
!= ':')
4738 /* No repeat count. */
4742 ++input_line_pointer
;
4743 expression (&count
);
4744 if (count
.X_op
!= O_constant
4745 || count
.X_add_number
<= 0)
4747 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4751 /* The cons function is going to output this expression once. So we
4752 output it count - 1 times. */
4753 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4754 emit_expr (exp
, nbytes
);
4757 #endif /* REPEAT_CONS_EXPRESSIONS */
4759 /* Parse a floating point number represented as a hex constant. This
4760 permits users to specify the exact bits they want in the floating
4764 hex_float (int float_type
, char *bytes
)
4766 int pad
, length
= float_length (float_type
, &pad
);
4772 /* It would be nice if we could go through expression to parse the
4773 hex constant, but if we get a bignum it's a pain to sort it into
4774 the buffer correctly. */
4776 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4780 /* The MRI assembler accepts arbitrary underscores strewn about
4781 through the hex constant, so we ignore them as well. */
4782 if (*input_line_pointer
== '_')
4784 ++input_line_pointer
;
4790 as_warn (_("floating point constant too large"));
4793 d
= hex_value (*input_line_pointer
) << 4;
4794 ++input_line_pointer
;
4795 while (*input_line_pointer
== '_')
4796 ++input_line_pointer
;
4797 if (hex_p (*input_line_pointer
))
4799 d
+= hex_value (*input_line_pointer
);
4800 ++input_line_pointer
;
4802 if (target_big_endian
)
4805 bytes
[length
- i
- 1] = d
;
4811 if (target_big_endian
)
4812 memset (bytes
+ i
, 0, length
- i
);
4814 memset (bytes
, 0, length
- i
);
4817 memset (bytes
+ length
, 0, pad
);
4819 return length
+ pad
;
4824 CONStruct some more frag chars of .floats .ffloats etc.
4825 Makes 0 or more new frags.
4826 If need_pass_2 == 1, no frags are emitted.
4827 This understands only floating literals, not expressions. Sorry.
4829 A floating constant is defined by atof_generic(), except it is preceded
4830 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4831 reading, I decided to be incompatible. This always tries to give you
4832 rounded bits to the precision of the pseudo-op. Former AS did premature
4833 truncation, restored noisy bits instead of trailing 0s AND gave you
4834 a choice of 2 flavours of noise according to which of 2 floating-point
4835 scanners you directed AS to use.
4837 In: input_line_pointer->whitespace before, or '0' of flonum. */
4840 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4841 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4844 int length
; /* Number of chars in an object. */
4845 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4847 if (is_it_end_of_statement ())
4849 demand_empty_rest_of_line ();
4853 if (now_seg
== absolute_section
)
4855 as_bad (_("attempt to store float in absolute section"));
4856 ignore_rest_of_line ();
4862 as_bad (_("attempt to store float in section `%s'"),
4863 segment_name (now_seg
));
4864 ignore_rest_of_line ();
4868 #ifdef md_flush_pending_output
4869 md_flush_pending_output ();
4872 #ifdef md_cons_align
4878 length
= parse_one_float (float_type
, temp
);
4888 #ifdef REPEAT_CONS_EXPRESSIONS
4889 if (*input_line_pointer
== ':')
4891 expressionS count_exp
;
4893 ++input_line_pointer
;
4894 expression (&count_exp
);
4896 if (count_exp
.X_op
!= O_constant
4897 || count_exp
.X_add_number
<= 0)
4898 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4900 count
= count_exp
.X_add_number
;
4904 while (--count
>= 0)
4906 p
= frag_more (length
);
4907 memcpy (p
, temp
, (unsigned int) length
);
4912 while (*input_line_pointer
++ == ',');
4914 /* Put terminator back into stream. */
4915 --input_line_pointer
;
4916 demand_empty_rest_of_line ();
4921 Note - we are using the DWARF standard's definition of LEB128 encoding
4922 where each 7-bit value is a stored in a byte, *not* an octet. This
4923 means that on targets where a byte contains multiple octets there is
4924 a *huge waste of space*. (This also means that we do not have to
4925 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4928 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4929 we would then have to consider whether multiple, successive LEB128
4930 values should be packed into the bytes without padding (bad idea) or
4931 whether each LEB128 number is padded out to a whole number of bytes.
4932 Plus you have to decide on the endianness of packing octets into a
4935 /* Return the size of a LEB128 value in bytes. */
4937 static inline unsigned int
4938 sizeof_sleb128 (offsetT value
)
4945 byte
= (value
& 0x7f);
4946 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4947 Fortunately, we can structure things so that the extra work reduces
4948 to a noop on systems that do things "properly". */
4949 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4952 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4953 || ((value
== -1) && ((byte
& 0x40) != 0))));
4958 static inline unsigned int
4959 sizeof_uleb128 (valueT value
)
4974 sizeof_leb128 (valueT value
, int sign
)
4977 return sizeof_sleb128 ((offsetT
) value
);
4979 return sizeof_uleb128 (value
);
4982 /* Output a LEB128 value. Returns the number of bytes used. */
4984 static inline unsigned int
4985 output_sleb128 (char *p
, offsetT value
)
4992 unsigned byte
= (value
& 0x7f);
4994 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4995 Fortunately, we can structure things so that the extra work reduces
4996 to a noop on systems that do things "properly". */
4997 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4999 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5000 || ((value
== -1) && ((byte
& 0x40) != 0))));
5011 static inline unsigned int
5012 output_uleb128 (char *p
, valueT value
)
5018 unsigned byte
= (value
& 0x7f);
5022 /* More bytes to follow. */
5033 output_leb128 (char *p
, valueT value
, int sign
)
5036 return output_sleb128 (p
, (offsetT
) value
);
5038 return output_uleb128 (p
, value
);
5041 /* Do the same for bignums. We combine sizeof with output here in that
5042 we don't output for NULL values of P. It isn't really as critical as
5043 for "normal" values that this be streamlined. Returns the number of
5046 static inline unsigned int
5047 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5054 /* Strip leading sign extensions off the bignum. */
5056 && bignum
[size
- 1] == LITTLENUM_MASK
5057 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5062 /* OR in the next part of the littlenum. */
5063 val
|= (*bignum
<< loaded
);
5064 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5068 /* Add bytes until there are less than 7 bits left in VAL
5069 or until every non-sign bit has been written. */
5076 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5083 while ((byte
& 0x80) != 0 && loaded
>= 7);
5087 /* Mop up any left-over bits (of which there will be less than 7). */
5088 if ((byte
& 0x80) != 0)
5090 /* Sign-extend VAL. */
5091 if (val
& (1 << (loaded
- 1)))
5092 val
|= ~0U << loaded
;
5101 static inline unsigned int
5102 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5109 /* Strip leading zeros off the bignum. */
5110 /* XXX: Is this needed? */
5111 while (size
> 0 && bignum
[size
- 1] == 0)
5116 if (loaded
< 7 && size
> 0)
5118 val
|= (*bignum
<< loaded
);
5119 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5128 if (size
> 0 || val
)
5135 while (byte
& 0x80);
5141 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5144 return output_big_sleb128 (p
, bignum
, size
);
5146 return output_big_uleb128 (p
, bignum
, size
);
5149 /* Generate the appropriate fragments for a given expression to emit a
5150 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5153 emit_leb128_expr (expressionS
*exp
, int sign
)
5155 operatorT op
= exp
->X_op
;
5156 unsigned int nbytes
;
5158 if (op
== O_absent
|| op
== O_illegal
)
5160 as_warn (_("zero assumed for missing expression"));
5161 exp
->X_add_number
= 0;
5164 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5166 as_bad (_("floating point number invalid"));
5167 exp
->X_add_number
= 0;
5170 else if (op
== O_register
)
5172 as_warn (_("register value used as expression"));
5175 else if (op
== O_constant
5177 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5179 /* We're outputting a signed leb128 and the sign of X_add_number
5180 doesn't reflect the sign of the original value. Convert EXP
5181 to a correctly-extended bignum instead. */
5182 convert_to_bignum (exp
, exp
->X_extrabit
);
5186 if (now_seg
== absolute_section
)
5188 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5189 as_bad (_("attempt to store value in absolute section"));
5190 abs_section_offset
++;
5194 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5195 as_bad (_("attempt to store non-zero value in section `%s'"),
5196 segment_name (now_seg
));
5198 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5199 a signal that this is leb128 data. It shouldn't optimize this away. */
5200 nbytes
= (unsigned int) -1;
5201 if (check_eh_frame (exp
, &nbytes
))
5204 /* Let the backend know that subsequent data may be byte aligned. */
5205 #ifdef md_cons_align
5209 if (op
== O_constant
)
5211 /* If we've got a constant, emit the thing directly right now. */
5213 valueT value
= exp
->X_add_number
;
5217 size
= sizeof_leb128 (value
, sign
);
5218 p
= frag_more (size
);
5219 if (output_leb128 (p
, value
, sign
) > size
)
5222 else if (op
== O_big
)
5224 /* O_big is a different sort of constant. */
5225 int nbr_digits
= exp
->X_add_number
;
5229 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5230 a signed number. Unary operators like - or ~ always extend the
5231 bignum to its largest size. */
5233 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5234 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5235 generic_bignum
[nbr_digits
++] = 0;
5237 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5238 p
= frag_more (size
);
5239 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5244 /* Otherwise, we have to create a variable sized fragment and
5245 resolve things later. */
5247 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5248 make_expr_symbol (exp
), 0, (char *) NULL
);
5252 /* Parse the .sleb128 and .uleb128 pseudos. */
5259 #ifdef md_flush_pending_output
5260 md_flush_pending_output ();
5266 emit_leb128_expr (&exp
, sign
);
5268 while (*input_line_pointer
++ == ',');
5270 input_line_pointer
--;
5271 demand_empty_rest_of_line ();
5275 stringer_append_char (int c
, int bitsize
)
5278 as_bad (_("attempt to store non-empty string in section `%s'"),
5279 segment_name (now_seg
));
5281 if (!target_big_endian
)
5282 FRAG_APPEND_1_CHAR (c
);
5287 FRAG_APPEND_1_CHAR (0);
5288 FRAG_APPEND_1_CHAR (0);
5289 FRAG_APPEND_1_CHAR (0);
5290 FRAG_APPEND_1_CHAR (0);
5293 FRAG_APPEND_1_CHAR (0);
5294 FRAG_APPEND_1_CHAR (0);
5297 FRAG_APPEND_1_CHAR (0);
5302 /* Called with invalid bitsize argument. */
5306 if (target_big_endian
)
5307 FRAG_APPEND_1_CHAR (c
);
5310 /* Worker to do .ascii etc statements.
5311 Reads 0 or more ',' separated, double-quoted strings.
5312 Caller should have checked need_pass_2 is FALSE because we don't
5314 Checks for end-of-line.
5315 BITS_APPENDZERO says how many bits are in a target char.
5316 The bottom bit is set if a NUL char should be appended to the strings. */
5319 stringer (int bits_appendzero
)
5321 const int bitsize
= bits_appendzero
& ~7;
5322 const int append_zero
= bits_appendzero
& 1;
5324 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5328 #ifdef md_flush_pending_output
5329 md_flush_pending_output ();
5332 #ifdef md_cons_align
5336 /* If we have been switched into the abs_section then we
5337 will not have an obstack onto which we can hang strings. */
5338 if (now_seg
== absolute_section
)
5340 as_bad (_("strings must be placed into a section"));
5341 ignore_rest_of_line ();
5345 /* The following awkward logic is to parse ZERO or more strings,
5346 comma separated. Recall a string expression includes spaces
5347 before the opening '\"' and spaces after the closing '\"'.
5348 We fake a leading ',' if there is (supposed to be)
5349 a 1st, expression. We keep demanding expressions for each ','. */
5350 if (is_it_end_of_statement ())
5352 c
= 0; /* Skip loop. */
5353 ++input_line_pointer
; /* Compensate for end of loop. */
5357 c
= ','; /* Do loop. */
5360 while (c
== ',' || c
== '<' || c
== '"')
5363 switch (*input_line_pointer
)
5366 ++input_line_pointer
; /*->1st char of string. */
5367 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5368 start
= input_line_pointer
;
5371 while (is_a_char (c
= next_char_of_string ()))
5372 stringer_append_char (c
, bitsize
);
5374 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5375 SKIP_ALL_WHITESPACE ();
5376 if (*input_line_pointer
== '"')
5380 stringer_append_char (0, bitsize
);
5382 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5383 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5384 will emit .string with a filename in the .debug section
5385 after a sequence of constants. See the comment in
5386 emit_expr for the sequence. emit_expr will set
5387 dwarf_file_string to non-zero if this string might be a
5388 source file name. */
5389 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5390 dwarf_file_string
= 0;
5391 else if (dwarf_file_string
)
5393 c
= input_line_pointer
[-1];
5394 input_line_pointer
[-1] = '\0';
5395 listing_source_file (start
);
5396 input_line_pointer
[-1] = c
;
5402 input_line_pointer
++;
5403 c
= get_single_number ();
5404 stringer_append_char (c
, bitsize
);
5405 if (*input_line_pointer
!= '>')
5407 as_bad (_("expected <nn>"));
5408 ignore_rest_of_line ();
5411 input_line_pointer
++;
5414 input_line_pointer
++;
5418 c
= *input_line_pointer
;
5421 demand_empty_rest_of_line ();
5424 /* FIXME-SOMEDAY: I had trouble here on characters with the
5425 high bits set. We'll probably also have trouble with
5426 multibyte chars, wide chars, etc. Also be careful about
5427 returning values bigger than 1 byte. xoxorich. */
5430 next_char_of_string (void)
5434 c
= *input_line_pointer
++ & CHAR_MASK
;
5438 /* PR 20902: Do not advance past the end of the buffer. */
5439 -- input_line_pointer
;
5448 as_warn (_("unterminated string; newline inserted"));
5449 bump_line_counters ();
5453 if (!TC_STRING_ESCAPES
)
5455 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5483 break; /* As itself. */
5499 for (i
= 0, number
= 0;
5500 ISDIGIT (c
) && i
< 3;
5501 c
= *input_line_pointer
++, i
++)
5503 number
= number
* 8 + c
- '0';
5506 c
= number
& CHAR_MASK
;
5508 --input_line_pointer
;
5517 c
= *input_line_pointer
++;
5518 while (ISXDIGIT (c
))
5521 number
= number
* 16 + c
- '0';
5522 else if (ISUPPER (c
))
5523 number
= number
* 16 + c
- 'A' + 10;
5525 number
= number
* 16 + c
- 'a' + 10;
5526 c
= *input_line_pointer
++;
5528 c
= number
& CHAR_MASK
;
5529 --input_line_pointer
;
5534 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5535 as_warn (_("unterminated string; newline inserted"));
5537 bump_line_counters ();
5541 /* Do not advance past the end of the buffer. */
5542 -- input_line_pointer
;
5548 #ifdef ONLY_STANDARD_ESCAPES
5549 as_bad (_("bad escaped character in string"));
5551 #endif /* ONLY_STANDARD_ESCAPES */
5564 get_segmented_expression (expressionS
*expP
)
5568 retval
= expression (expP
);
5569 if (expP
->X_op
== O_illegal
5570 || expP
->X_op
== O_absent
5571 || expP
->X_op
== O_big
)
5573 as_bad (_("expected address expression"));
5574 expP
->X_op
= O_constant
;
5575 expP
->X_add_number
= 0;
5576 retval
= absolute_section
;
5582 get_known_segmented_expression (expressionS
*expP
)
5584 segT retval
= get_segmented_expression (expP
);
5586 if (retval
== undefined_section
)
5588 /* There is no easy way to extract the undefined symbol from the
5590 if (expP
->X_add_symbol
!= NULL
5591 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5592 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5593 S_GET_NAME (expP
->X_add_symbol
));
5595 as_warn (_("some symbol undefined; zero assumed"));
5596 retval
= absolute_section
;
5597 expP
->X_op
= O_constant
;
5598 expP
->X_add_number
= 0;
5603 char /* Return terminator. */
5604 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5606 /* FIXME: val_pointer should probably be offsetT *. */
5607 *val_pointer
= (long) get_absolute_expression ();
5608 return (*input_line_pointer
++);
5611 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5612 Give a warning if that happens. */
5615 demand_copy_C_string (int *len_pointer
)
5619 if ((s
= demand_copy_string (len_pointer
)) != 0)
5623 for (len
= *len_pointer
; len
> 0; len
--)
5625 if (s
[len
- 1] == 0)
5629 as_bad (_("this string may not contain \'\\0\'"));
5638 /* Demand string, but return a safe (=private) copy of the string.
5639 Return NULL if we can't read a string here. */
5642 demand_copy_string (int *lenP
)
5650 if (*input_line_pointer
== '\"')
5652 input_line_pointer
++; /* Skip opening quote. */
5654 while (is_a_char (c
= next_char_of_string ()))
5656 obstack_1grow (¬es
, c
);
5659 /* JF this next line is so demand_copy_C_string will return a
5660 null terminated string. */
5661 obstack_1grow (¬es
, '\0');
5662 retval
= (char *) obstack_finish (¬es
);
5666 as_bad (_("missing string"));
5668 ignore_rest_of_line ();
5674 /* In: Input_line_pointer->next character.
5676 Do: Skip input_line_pointer over all whitespace.
5678 Out: 1 if input_line_pointer->end-of-line. */
5681 is_it_end_of_statement (void)
5684 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5688 equals (char *sym_name
, int reassign
)
5693 input_line_pointer
++;
5694 if (*input_line_pointer
== '=')
5695 input_line_pointer
++;
5696 if (reassign
< 0 && *input_line_pointer
== '=')
5697 input_line_pointer
++;
5699 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5700 input_line_pointer
++;
5703 stop
= mri_comment_field (&stopc
);
5705 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5709 demand_empty_rest_of_line ();
5710 mri_comment_end (stop
, stopc
);
5714 /* .incbin -- include a file verbatim at the current location. */
5717 s_incbin (int x ATTRIBUTE_UNUSED
)
5728 #ifdef md_flush_pending_output
5729 md_flush_pending_output ();
5732 #ifdef md_cons_align
5737 filename
= demand_copy_string (& len
);
5738 if (filename
== NULL
)
5743 /* Look for optional skip and count. */
5744 if (* input_line_pointer
== ',')
5746 ++ input_line_pointer
;
5747 skip
= get_absolute_expression ();
5751 if (* input_line_pointer
== ',')
5753 ++ input_line_pointer
;
5755 count
= get_absolute_expression ();
5757 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5763 demand_empty_rest_of_line ();
5765 /* Try opening absolute path first, then try include dirs. */
5766 binfile
= fopen (filename
, FOPEN_RB
);
5767 if (binfile
== NULL
)
5771 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5773 for (i
= 0; i
< include_dir_count
; i
++)
5775 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5777 binfile
= fopen (path
, FOPEN_RB
);
5778 if (binfile
!= NULL
)
5782 if (binfile
== NULL
)
5783 as_bad (_("file not found: %s"), filename
);
5786 path
= xstrdup (filename
);
5791 struct stat filestat
;
5793 if (fstat (fileno (binfile
), &filestat
) != 0
5794 || ! S_ISREG (filestat
.st_mode
)
5795 || S_ISDIR (filestat
.st_mode
))
5797 as_bad (_("unable to include `%s'"), path
);
5801 register_dependency (path
);
5803 /* Compute the length of the file. */
5804 if (fseek (binfile
, 0, SEEK_END
) != 0)
5806 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5809 file_len
= ftell (binfile
);
5811 /* If a count was not specified use the remainder of the file. */
5813 count
= file_len
- skip
;
5815 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5817 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5818 skip
, count
, file_len
);
5822 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5824 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5828 /* Allocate frag space and store file contents in it. */
5829 binfrag
= frag_more (count
);
5831 bytes
= fread (binfrag
, 1, count
, binfile
);
5833 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5834 path
, bytes
, count
);
5837 if (binfile
!= NULL
)
5842 /* .include -- include a file at this point. */
5845 s_include (int arg ATTRIBUTE_UNUSED
)
5854 filename
= demand_copy_string (&i
);
5855 if (filename
== NULL
)
5857 /* demand_copy_string has already printed an error and
5858 called ignore_rest_of_line. */
5866 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5867 && *input_line_pointer
!= ' '
5868 && *input_line_pointer
!= '\t')
5870 obstack_1grow (¬es
, *input_line_pointer
);
5871 ++input_line_pointer
;
5875 obstack_1grow (¬es
, '\0');
5876 filename
= (char *) obstack_finish (¬es
);
5877 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5878 ++input_line_pointer
;
5881 demand_empty_rest_of_line ();
5882 path
= notes_alloc ((size_t) i
+ include_dir_maxlen
+ 5);
5884 for (i
= 0; i
< include_dir_count
; i
++)
5886 strcpy (path
, include_dirs
[i
]);
5888 strcat (path
, filename
);
5889 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5899 register_dependency (path
);
5900 input_scrub_insert_file (path
);
5904 add_include_dir (char *path
)
5908 if (include_dir_count
== 0)
5910 include_dirs
= XNEWVEC (const char *, 2);
5911 include_dirs
[0] = "."; /* Current dir. */
5912 include_dir_count
= 2;
5916 include_dir_count
++;
5917 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5921 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5924 if (i
> include_dir_maxlen
)
5925 include_dir_maxlen
= i
;
5928 /* Output debugging information to denote the source file. */
5931 generate_file_debug (void)
5933 if (debug_type
== DEBUG_STABS
)
5934 stabs_generate_asm_file ();
5937 /* Output line number debugging information for the current source line. */
5940 generate_lineno_debug (void)
5944 case DEBUG_UNSPECIFIED
:
5949 stabs_generate_asm_lineno ();
5952 ecoff_generate_asm_lineno ();
5955 /* ??? We could here indicate to dwarf2dbg.c that something
5956 has changed. However, since there is additional backend
5957 support that is required (calling dwarf2_emit_insn), we
5958 let dwarf2dbg.c call as_where on its own. */
5963 /* Output debugging information to mark a function entry point or end point.
5964 END_P is zero for .func, and non-zero for .endfunc. */
5969 do_s_func (end_p
, NULL
);
5972 /* Subroutine of s_func so targets can choose a different default prefix.
5973 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5976 do_s_func (int end_p
, const char *default_prefix
)
5978 /* Record the current function so that we can issue an error message for
5979 misplaced .func,.endfunc, and also so that .endfunc needs no
5981 static char *current_name
;
5982 static char *current_label
;
5986 if (current_name
== NULL
)
5988 as_bad (_("missing .func"));
5989 ignore_rest_of_line ();
5993 if (debug_type
== DEBUG_STABS
)
5994 stabs_generate_asm_endfunc (current_name
, current_label
);
5996 current_name
= current_label
= NULL
;
6001 char delim1
, delim2
;
6003 if (current_name
!= NULL
)
6005 as_bad (_(".endfunc missing for previous .func"));
6006 ignore_rest_of_line ();
6010 delim1
= get_symbol_name (& name
);
6011 name
= xstrdup (name
);
6012 *input_line_pointer
= delim1
;
6013 SKIP_WHITESPACE_AFTER_NAME ();
6014 if (*input_line_pointer
!= ',')
6018 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6019 as_fatal ("%s", xstrerror (errno
));
6023 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6024 /* Missing entry point, use function's name with the leading
6028 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6029 as_fatal ("%s", xstrerror (errno
));
6037 ++input_line_pointer
;
6039 delim2
= get_symbol_name (& label
);
6040 label
= xstrdup (label
);
6041 restore_line_pointer (delim2
);
6044 if (debug_type
== DEBUG_STABS
)
6045 stabs_generate_asm_func (name
, label
);
6047 current_name
= name
;
6048 current_label
= label
;
6051 demand_empty_rest_of_line ();
6054 #ifdef HANDLE_BUNDLE
6057 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6059 unsigned int align
= get_absolute_expression ();
6061 demand_empty_rest_of_line ();
6063 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6064 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6065 (unsigned int) TC_ALIGN_LIMIT
);
6067 if (bundle_lock_frag
!= NULL
)
6069 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6073 bundle_align_p2
= align
;
6077 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6079 demand_empty_rest_of_line ();
6081 if (bundle_align_p2
== 0)
6083 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6087 if (bundle_lock_depth
== 0)
6089 bundle_lock_frchain
= frchain_now
;
6090 bundle_lock_frag
= start_bundle ();
6092 ++bundle_lock_depth
;
6096 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6100 demand_empty_rest_of_line ();
6102 if (bundle_lock_frag
== NULL
)
6104 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6108 gas_assert (bundle_align_p2
> 0);
6110 gas_assert (bundle_lock_depth
> 0);
6111 if (--bundle_lock_depth
> 0)
6114 size
= pending_bundle_size (bundle_lock_frag
);
6116 if (size
> 1U << bundle_align_p2
)
6117 as_bad (_(".bundle_lock sequence is %u bytes, "
6118 "but bundle size is only %u bytes"),
6119 size
, 1u << bundle_align_p2
);
6121 finish_bundle (bundle_lock_frag
, size
);
6123 bundle_lock_frag
= NULL
;
6124 bundle_lock_frchain
= NULL
;
6127 #endif /* HANDLE_BUNDLE */
6130 s_ignore (int arg ATTRIBUTE_UNUSED
)
6132 ignore_rest_of_line ();
6136 read_print_statistics (FILE *file
)
6138 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6141 /* Inserts the given line into the input stream.
6143 This call avoids macro/conditionals nesting checking, since the contents of
6144 the line are assumed to replace the contents of a line already scanned.
6146 An appropriate use of this function would be substitution of input lines when
6147 called by md_start_line_hook(). The given line is assumed to already be
6148 properly scrubbed. */
6151 input_scrub_insert_line (const char *line
)
6154 size_t len
= strlen (line
);
6155 sb_build (&newline
, len
);
6156 sb_add_buffer (&newline
, line
, len
);
6157 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6159 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6162 /* Insert a file into the input stream; the path must resolve to an actual
6163 file; no include path searching or dependency registering is performed. */
6166 input_scrub_insert_file (char *path
)
6168 input_scrub_include_file (path
, input_line_pointer
);
6169 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6172 /* Find the end of a line, considering quotation and escaping of quotes. */
6174 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6175 # define TC_SINGLE_QUOTE_STRINGS 1
6179 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6182 char inquote
= '\0';
6185 while (!is_end_of_line
[(unsigned char) *s
]
6186 || (inquote
&& !ISCNTRL (*s
))
6187 || (inquote
== '\'' && flag_mri
)
6188 #ifdef TC_EOL_IN_INSN
6189 || (insn
&& TC_EOL_IN_INSN (s
))
6191 /* PR 6926: When we are parsing the body of a macro the sequence
6192 \@ is special - it refers to the invocation count. If the @
6193 character happens to be registered as a line-separator character
6194 by the target, then the is_end_of_line[] test above will have
6195 returned true, but we need to ignore the line separating
6196 semantics in this particular case. */
6197 || (in_macro
&& inescape
&& *s
== '@')
6200 if (mri_string
&& *s
== '\'')
6204 else if (*s
== '\\')
6208 #ifdef TC_SINGLE_QUOTE_STRINGS
6209 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6216 as_warn (_("missing closing `%c'"), inquote
);
6217 if (inescape
&& !ignore_input ())
6218 as_warn (_("stray `\\'"));
6223 find_end_of_line (char *s
, int mri_string
)
6225 return _find_end_of_line (s
, mri_string
, 0, 0);
6228 static char *saved_ilp
= NULL
;
6229 static char *saved_limit
;
6231 /* Use BUF as a temporary input pointer for calling other functions in this
6232 file. BUF must be a C string, so that its end can be found by strlen.
6233 Also sets the buffer_limit variable (local to this file) so that buffer
6234 overruns should not occur. Saves the current input line pointer so that
6235 it can be restored by calling restore_ilp().
6237 Does not support recursion. */
6240 temp_ilp (char *buf
)
6242 gas_assert (saved_ilp
== NULL
);
6243 gas_assert (buf
!= NULL
);
6245 saved_ilp
= input_line_pointer
;
6246 saved_limit
= buffer_limit
;
6247 /* Prevent the assert in restore_ilp from triggering if
6248 the input_line_pointer has not yet been initialised. */
6249 if (saved_ilp
== NULL
)
6250 saved_limit
= saved_ilp
= (char *) "";
6252 input_line_pointer
= buf
;
6253 buffer_limit
= buf
+ strlen (buf
);
6254 input_from_string
= true;
6257 /* Restore a saved input line pointer. */
6262 gas_assert (saved_ilp
!= NULL
);
6264 input_line_pointer
= saved_ilp
;
6265 buffer_limit
= saved_limit
;
6266 input_from_string
= false;