1 /* read.c - read a source file -
2 Copyright (C) 1986-2024 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"
41 #include "scfidw2gen.h"
44 #include "filenames.h"
49 #ifndef TC_START_LABEL
50 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
53 /* Set by the object-format or the target. */
54 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
55 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
60 else if ((SIZE) >= 4) \
62 else if ((SIZE) >= 2) \
70 char *input_line_pointer
; /*->next char of source file to parse. */
71 bool input_from_string
= false;
73 #if BITS_PER_CHAR != 8
74 /* The following table is indexed by[(char)] and will break if
75 a char does not have exactly 256 states (hopefully 0:255!)! */
84 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
89 /* The Delta 68k assembler permits % inside label names. */
94 /* The PowerPC Windows NT assemblers permits ? inside label names. */
99 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
100 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
109 /* The Delta 68k assembler permits ~ at start of label names. */
113 /* Used by is_... macros. our ctype[]. */
114 char lex_type
[256] = {
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
117 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
118 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
119 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
121 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
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,
127 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
128 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
129 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
130 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
134 Out: 1 if this character ends a line.
135 2 if this character is a line separator. */
136 char is_end_of_line
[256] = {
138 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
140 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
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, /* 0123456789:;<=>? */
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, /* */
153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
155 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
156 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
159 #ifndef TC_CASE_SENSITIVE
160 char original_case_string
[128];
163 /* Functions private to this file. */
165 static char *buffer
; /* 1st char of each buffer of lines is here. */
166 static char *buffer_limit
; /*->1 + last char in buffer. */
168 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
169 in the tc-<CPU>.h file. See the "Porting GAS" section of the
171 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
173 /* Variables for handling include file directory table. */
175 /* Table of pointers to directories to search for .include's. */
176 const char **include_dirs
;
178 /* How many are in the table. */
179 size_t include_dir_count
;
181 /* Length of longest in table. */
182 size_t include_dir_maxlen
;
184 #ifndef WORKING_DOT_WORD
185 struct broken_word
*broken_words
;
186 int new_broken_words
;
189 /* The current offset into the absolute section. We don't try to
190 build frags in the absolute section, since no data can be stored
191 there. We just keep track of the current offset. */
192 addressT abs_section_offset
;
194 /* If this line had an MRI style label, it is stored in this variable.
195 This is used by some of the MRI pseudo-ops. */
198 /* This global variable is used to support MRI common sections. We
199 translate such sections into a common symbol. This variable is
200 non-NULL when we are in an MRI common section. */
201 symbolS
*mri_common_symbol
;
203 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
204 need to align to an even byte boundary unless the next pseudo-op is
205 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
207 static int mri_pending_align
;
209 /* Record the current function so that we can issue an error message for
210 misplaced .func,.endfunc, and also so that .endfunc needs no
212 static char *current_name
;
213 static char *current_label
;
217 static int dwarf_file
;
218 static int dwarf_line
;
220 /* This variable is set to be non-zero if the next string we see might
221 be the name of the source file in DWARF debugging information. See
222 the comment in emit_expr for the format we look for. */
223 static int dwarf_file_string
;
227 /* If the target defines the md_frag_max_var hook then we know
228 enough to implement the .bundle_align_mode features. */
229 #ifdef md_frag_max_var
230 # define HANDLE_BUNDLE
234 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
235 it's the exponent of the bundle size, and aligned instruction bundle
236 mode is in effect. */
237 static unsigned int bundle_align_p2
;
239 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
240 bundle_lock_frag to frag_now and then starts a new frag with
241 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
242 so that .bundle_unlock can verify that we didn't change segments.
243 .bundle_unlock resets both to NULL. If we detect a bundling violation,
244 then we reset bundle_lock_frchain to NULL as an indicator that we've
245 already diagnosed the error with as_bad and don't need a cascade of
246 redundant errors, but bundle_lock_frag remains set to indicate that
247 we are expecting to see .bundle_unlock. */
248 static fragS
*bundle_lock_frag
;
249 static frchainS
*bundle_lock_frchain
;
251 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
253 static unsigned int bundle_lock_depth
;
256 static void do_s_func (int end_p
, const char *default_prefix
);
257 static void s_align (int, int);
258 static void s_altmacro (int);
259 static void s_bad_end (int);
260 static void s_reloc (int);
261 static int hex_float (int, char *);
262 static segT
get_known_segmented_expression (expressionS
* expP
);
263 static void pobegin (void);
264 static void poend (void);
265 static size_t get_non_macro_line_sb (sb
*);
266 static void generate_file_debug (void);
267 static char *_find_end_of_line (char *, int, int, int);
275 obj_read_begin_hook ();
277 obstack_begin (&cond_obstack
, chunksize
);
279 #ifndef tc_line_separator_chars
280 #define tc_line_separator_chars line_separator_chars
282 /* Use machine dependent syntax. */
283 for (p
= tc_line_separator_chars
; *p
; p
++)
284 is_end_of_line
[(unsigned char) *p
] = 2;
285 /* Use more. FIXME-SOMEDAY. */
291 #ifndef WORKING_DOT_WORD
293 new_broken_words
= 0;
296 abs_section_offset
= 0;
299 mri_common_symbol
= NULL
;
300 mri_pending_align
= 0;
303 current_label
= NULL
;
309 dwarf_file_string
= 0;
315 bundle_lock_frag
= NULL
;
316 bundle_lock_frchain
= NULL
;
317 bundle_lock_depth
= 0;
326 _obstack_free (&cond_obstack
, NULL
);
328 free (current_label
);
331 #ifndef TC_ADDRESS_BYTES
332 #define TC_ADDRESS_BYTES address_bytes
337 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
338 contain an address. */
339 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
347 /* Set up pseudo-op tables. */
349 static htab_t po_hash
;
351 static const pseudo_typeS potable
[] = {
352 {"abort", s_abort
, 0},
353 {"align", s_align_ptwo
, 0},
354 {"altmacro", s_altmacro
, 1},
355 {"ascii", stringer
, 8+0},
356 {"asciz", stringer
, 8+1},
357 {"balign", s_align_bytes
, 0},
358 {"balignw", s_align_bytes
, -2},
359 {"balignl", s_align_bytes
, -4},
362 {"bundle_align_mode", s_bundle_align_mode
, 0},
363 {"bundle_lock", s_bundle_lock
, 0},
364 {"bundle_unlock", s_bundle_unlock
, 0},
368 {"common", s_mri_common
, 0},
369 {"common.s", s_mri_common
, 1},
374 {"dc.d", float_cons
, 'd'},
376 {"dc.s", float_cons
, 'f'},
378 {"dc.x", float_cons
, 'x'},
380 {"dcb.b", s_space
, 1},
381 {"dcb.d", s_float_space
, 'd'},
382 {"dcb.l", s_space
, 4},
383 {"dcb.s", s_float_space
, 'f'},
384 {"dcb.w", s_space
, 2},
385 {"dcb.x", s_float_space
, 'x'},
387 {"ds.b", s_space
, 1},
388 {"ds.d", s_space
, 8},
389 {"ds.l", s_space
, 4},
390 {"ds.p", s_space
, 'p'},
391 {"ds.s", s_space
, 4},
392 {"ds.w", s_space
, 2},
393 {"ds.x", s_space
, 'x'},
394 {"debug", s_ignore
, 0},
399 {"double", float_cons
, 'd'},
401 {"eject", listing_eject
, 0}, /* Formfeed listing. */
403 {"elsec", s_else
, 0},
404 {"elseif", s_elseif
, (int) O_ne
},
406 {"endc", s_endif
, 0},
407 {"endfunc", s_func
, 1},
408 {"endif", s_endif
, 0},
409 {"endm", s_bad_end
, 0},
410 {"endr", s_bad_end
, 1},
416 {"error", s_errwarn
, 1},
417 {"exitm", s_mexit
, 0},
419 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
423 {"float", float_cons
, 'f'},
424 {"format", s_ignore
, 0},
426 {"global", s_globl
, 0},
427 {"globl", s_globl
, 0},
429 {"if", s_if
, (int) O_ne
},
432 {"ifdef", s_ifdef
, 0},
433 {"ifeq", s_if
, (int) O_eq
},
434 {"ifeqs", s_ifeqs
, 0},
435 {"ifge", s_if
, (int) O_ge
},
436 {"ifgt", s_if
, (int) O_gt
},
437 {"ifle", s_if
, (int) O_le
},
438 {"iflt", s_if
, (int) O_lt
},
441 {"ifndef", s_ifdef
, 1},
442 {"ifne", s_if
, (int) O_ne
},
443 {"ifnes", s_ifeqs
, 1},
444 {"ifnotdef", s_ifdef
, 1},
445 {"incbin", s_incbin
, 0},
446 {"include", s_include
, 0},
452 {"lcomm", s_lcomm
, 0},
453 {"lflags", s_ignore
, 0}, /* Listing flags. */
454 {"linefile", s_linefile
, 0},
455 {"linkonce", s_linkonce
, 0},
456 {"list", listing_list
, 1}, /* Turn listing on. */
457 {"llen", listing_psize
, 1},
460 {"macro", s_macro
, 0},
461 {"mexit", s_mexit
, 0},
463 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
464 {"name", s_ignore
, 0},
465 {"noaltmacro", s_altmacro
, 0},
466 {"noformat", s_ignore
, 0},
467 {"nolist", listing_list
, 0}, /* Turn listing off. */
468 {"nopage", listing_nopage
, 0},
472 {"offset", s_struct
, 0},
474 {"p2align", s_align_ptwo
, 0},
475 {"p2alignw", s_align_ptwo
, -2},
476 {"p2alignl", s_align_ptwo
, -4},
477 {"page", listing_eject
, 0},
478 {"plen", listing_psize
, 0},
479 {"print", s_print
, 0},
480 {"psize", listing_psize
, 0}, /* Set paper size. */
481 {"purgem", s_purgem
, 0},
483 {"reloc", s_reloc
, 0},
487 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
492 {"single", float_cons
, 'f'},
494 {"space", s_space
, 0},
495 {"skip", s_space
, 0},
496 {"sleb128", s_leb128
, 1},
497 {"spc", s_ignore
, 0},
498 {"stabd", s_stab
, 'd'},
499 {"stabn", s_stab
, 'n'},
500 {"stabs", s_stab
, 's'},
501 {"string", stringer
, 8+1},
502 {"string8", stringer
, 8+1},
503 {"string16", stringer
, 16+1},
504 {"string32", stringer
, 32+1},
505 {"string64", stringer
, 64+1},
506 {"struct", s_struct
, 0},
510 /* This is for gcc to use. It's only just been added (2/94), so gcc
511 won't be able to use it for a while -- probably a year or more.
512 But once this has been released, check with gcc maintainers
513 before deleting it or even changing the spelling. */
514 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
515 /* If we're folding case -- done for some targets, not necessarily
516 all -- the above string in an input file will be converted to
517 this one. Match it either way... */
518 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
520 {"title", listing_title
, 0}, /* Listing title. */
521 {"ttl", listing_title
, 0},
523 {"uleb128", s_leb128
, 0},
527 {"xdef", s_globl
, 0},
528 {"xref", s_ignore
, 0},
529 {"xstabs", s_xstab
, 's'},
530 {"warning", s_errwarn
, 0},
531 {"weakref", s_weakref
, 0},
533 {"zero", s_space
, 0},
537 {NULL
, NULL
, 0} /* End sentinel. */
541 get_absolute_expr (expressionS
*exp
)
543 expression_and_evaluate (exp
);
545 if (exp
->X_op
!= O_constant
)
547 if (exp
->X_op
!= O_absent
)
548 as_bad (_("bad or irreducible absolute expression"));
549 exp
->X_add_number
= 0;
551 return exp
->X_add_number
;
555 get_absolute_expression (void)
559 return get_absolute_expr (&exp
);
562 static int pop_override_ok
;
563 static const char *pop_table_name
;
566 pop_insert (const pseudo_typeS
*table
)
568 const pseudo_typeS
*pop
;
569 for (pop
= table
; pop
->poc_name
; pop
++)
571 if (str_hash_insert (po_hash
, pop
->poc_name
, pop
, 0) != NULL
)
573 if (!pop_override_ok
)
574 as_fatal (_("error constructing %s pseudo-op table"),
580 #ifndef md_pop_insert
581 #define md_pop_insert() pop_insert(md_pseudo_table)
584 #ifndef obj_pop_insert
585 #define obj_pop_insert() pop_insert(obj_pseudo_table)
588 #ifndef cfi_pop_insert
589 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
592 #ifndef scfi_pop_insert
593 #define scfi_pop_insert() pop_insert(scfi_pseudo_table)
599 po_hash
= str_htab_create ();
601 /* Do the target-specific pseudo ops. */
602 pop_table_name
= "md";
606 /* Now object specific. Skip any that were in the target table. */
607 pop_table_name
= "obj";
611 /* Now portable ones. Skip any that we've seen already. */
612 pop_table_name
= "standard";
613 pop_insert (potable
);
616 #if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
619 pop_table_name
= "scfi";
625 pop_table_name
= "cfi";
633 htab_delete (po_hash
);
636 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
637 if (ignore_input ()) \
639 char *eol = find_end_of_line (input_line_pointer - (num_read), \
641 input_line_pointer = (input_line_pointer <= buffer_limit \
642 && eol >= buffer_limit) \
648 /* Helper function of read_a_source_file, which tries to expand a macro. */
650 try_macro (char term
, const char *line
)
656 if (check_macro (line
, &out
, &err
, ¯o
))
660 *input_line_pointer
++ = term
;
661 input_scrub_include_sb (&out
,
662 input_line_pointer
, expanding_macro
);
665 input_scrub_next_buffer (&input_line_pointer
);
667 md_macro_info (macro
);
675 /* Start a new instruction bundle. Returns the rs_align_code frag that
676 will be used to align the new bundle. */
680 fragS
*frag
= frag_now
;
682 frag_align_code (0, 0);
684 while (frag
->fr_type
!= rs_align_code
)
685 frag
= frag
->fr_next
;
687 gas_assert (frag
!= frag_now
);
692 /* Calculate the maximum size after relaxation of the region starting
693 at the given frag and extending through frag_now (which is unfinished). */
695 pending_bundle_size (fragS
*frag
)
697 unsigned int offset
= frag
->fr_fix
;
698 unsigned int size
= 0;
700 gas_assert (frag
!= frag_now
);
701 gas_assert (frag
->fr_type
== rs_align_code
);
703 while (frag
!= frag_now
)
705 /* This should only happen in what will later become an error case. */
709 size
+= frag
->fr_fix
;
710 if (frag
->fr_type
== rs_machine_dependent
)
711 size
+= md_frag_max_var (frag
);
713 frag
= frag
->fr_next
;
716 gas_assert (frag
== frag_now
);
717 size
+= frag_now_fix ();
718 if (frag
->fr_type
== rs_machine_dependent
)
719 size
+= md_frag_max_var (frag
);
721 gas_assert (size
>= offset
);
723 return size
- offset
;
726 /* Finish off the frag created to ensure bundle alignment. */
728 finish_bundle (fragS
*frag
, unsigned int size
)
730 gas_assert (bundle_align_p2
> 0);
731 gas_assert (frag
->fr_type
== rs_align_code
);
735 /* If there is more than a single byte, then we need to set up the
736 alignment frag. Otherwise we leave it at its initial state from
737 calling frag_align_code (0, 0), so that it does nothing. */
738 frag
->fr_offset
= bundle_align_p2
;
739 frag
->fr_subtype
= size
- 1;
742 /* We do this every time rather than just in s_bundle_align_mode
743 so that we catch any affected section without needing hooks all
744 over for all paths that do section changes. It's cheap enough. */
745 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
746 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
749 /* Assemble one instruction. This takes care of the bundle features
750 around calling md_assemble. */
752 assemble_one (char *line
)
754 fragS
*insn_start_frag
= NULL
;
756 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
758 as_bad (_("cannot change section or subsection inside .bundle_lock"));
759 /* Clearing this serves as a marker that we have already complained. */
760 bundle_lock_frchain
= NULL
;
763 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
764 insn_start_frag
= start_bundle ();
768 if (bundle_lock_frchain
!= NULL
)
770 /* Make sure this hasn't pushed the locked sequence
771 past the bundle size. */
772 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
773 if (bundle_size
> 1U << bundle_align_p2
)
774 as_bad (_ (".bundle_lock sequence at %u bytes, "
775 "but .bundle_align_mode limit is %u bytes"),
776 bundle_size
, 1U << bundle_align_p2
);
778 else if (bundle_align_p2
> 0)
780 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
782 if (insn_size
> 1U << bundle_align_p2
)
783 as_bad (_("single instruction is %u bytes long, "
784 "but .bundle_align_mode limit is %u bytes"),
785 insn_size
, 1U << bundle_align_p2
);
787 finish_bundle (insn_start_frag
, insn_size
);
791 #else /* !HANDLE_BUNDLE */
793 # define assemble_one(line) md_assemble(line)
795 #endif /* HANDLE_BUNDLE */
800 flagword flags
= bfd_section_flags (now_seg
);
802 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
805 /* Guts of .align directive:
806 N is the power of two to which to align. A value of zero is accepted but
807 ignored: the default alignment of the section will be at least this.
808 FILL may be NULL, or it may point to the bytes of the fill pattern.
809 LEN is the length of whatever FILL points to, if anything. If LEN is zero
810 but FILL is not NULL then LEN is treated as if it were one.
811 MAX is the maximum number of characters to skip when doing the alignment,
812 or 0 if there is no maximum. */
815 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
817 if (now_seg
== absolute_section
|| in_bss ())
823 if (now_seg
== absolute_section
)
824 as_warn (_("ignoring fill value in absolute section"));
826 as_warn (_("ignoring fill value in section `%s'"),
827 segment_name (now_seg
));
834 #ifdef md_flush_pending_output
835 md_flush_pending_output ();
839 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
842 /* Only make a frag if we HAVE to... */
843 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
847 if (subseg_text_p (now_seg
))
848 frag_align_code (n
, max
);
850 frag_align (n
, 0, max
);
853 frag_align (n
, *fill
, max
);
855 frag_align_pattern (n
, fill
, len
, max
);
859 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
862 if (n
> OCTETS_PER_BYTE_POWER
)
863 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
866 /* We read the file, putting things into a web that represents what we
867 have been reading. */
869 read_a_source_file (const char *name
)
873 char *s
; /* String of symbol, '\0' appended. */
875 const pseudo_typeS
*pop
;
881 buffer
= input_scrub_new_file (name
);
884 listing_newline (NULL
);
885 register_dependency (name
);
887 /* Generate debugging information before we've read anything in to denote
888 this file as the "main" source file and not a subordinate one
889 (e.g. N_SO vs N_SOL in stabs). */
890 generate_file_debug ();
892 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
893 { /* We have another line to parse. */
895 /* In order to avoid listing macro expansion lines with labels
896 multiple times, keep track of which line was last issued. */
897 char *last_eol
= NULL
;
900 while (input_line_pointer
< buffer_limit
)
903 /* We have more of this buffer to parse. */
905 /* We now have input_line_pointer->1st char of next line.
906 If input_line_pointer [-1] == '\n' then we just
907 scanned another line: so bump line counters. */
908 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
911 symbol_set_value_now (&dot_symbol
);
912 #ifdef md_start_line_hook
913 md_start_line_hook ();
915 if (input_line_pointer
[-1] == '\n')
916 bump_line_counters ();
920 /* If listing is on, and we are expanding a macro, then give
921 the listing code the contents of the expanded line. */
924 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
926 /* Find the end of the current expanded macro line. */
927 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
930 && !startswith (input_line_pointer
,
931 !flag_m68k_mri
? " .linefile "
938 /* Copy it for safe keeping. Also give an indication of
939 how much macro nesting is involved at this point. */
940 len
= s
- input_line_pointer
;
941 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
942 memset (copy
, '>', macro_nest
);
943 copy
[macro_nest
] = ' ';
944 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
945 copy
[macro_nest
+ 1 + len
] = '\0';
947 /* Install the line with the listing facility. */
948 listing_newline (copy
);
952 listing_newline (NULL
);
959 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
961 next_char
= * input_line_pointer
;
962 /* Text at the start of a line must be a label, we
963 run down and stick a colon in. */
964 if (is_name_beginner (next_char
) || next_char
== '"')
969 HANDLE_CONDITIONAL_ASSEMBLY (0);
971 nul_char
= get_symbol_name (& line_start
);
972 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
974 /* In MRI mode, the EQU and MACRO pseudoops must
975 be handled specially. */
979 char *rest
= input_line_pointer
+ 1;
983 if (*rest
== ' ' || *rest
== '\t')
985 if ((strncasecmp (rest
, "EQU", 3) == 0
986 || strncasecmp (rest
, "SET", 3) == 0)
987 && (rest
[3] == ' ' || rest
[3] == '\t'))
989 input_line_pointer
= rest
+ 3;
991 strncasecmp (rest
, "SET", 3) == 0);
994 if (strncasecmp (rest
, "MACRO", 5) == 0
997 || is_end_of_line
[(unsigned char) rest
[5]]))
1001 /* In MRI mode, we need to handle the MACRO
1002 pseudo-op specially: we don't want to put the
1003 symbol in the symbol table. */
1005 #ifdef TC_START_LABEL_WITHOUT_COLON
1006 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1009 line_label
= colon (line_start
);
1011 line_label
= symbol_create (line_start
,
1013 &zero_address_frag
, 0);
1015 next_char
= restore_line_pointer (nul_char
);
1016 if (next_char
== ':')
1017 input_line_pointer
++;
1022 /* We are at the beginning of a line, or similar place.
1023 We expect a well-formed assembler statement.
1024 A "symbol-name:" is a statement.
1026 Depending on what compiler is used, the order of these tests
1027 may vary to catch most common case 1st.
1028 Each test is independent of all other tests at the (top)
1031 nul_char
= next_char
= *input_line_pointer
++;
1032 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1034 /* C is the 1st significant character.
1035 Input_line_pointer points after that character. */
1036 if (is_name_beginner (next_char
) || next_char
== '"')
1040 /* Want user-defined label or pseudo/opcode. */
1041 HANDLE_CONDITIONAL_ASSEMBLY (1);
1043 --input_line_pointer
;
1044 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1045 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1046 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1048 /* NEXT_CHAR is character after symbol.
1049 The end of symbol in the input line is now '\0'.
1050 S points to the beginning of the symbol.
1051 [In case of pseudo-op, s->'.'.]
1052 Input_line_pointer->'\0' where NUL_CHAR was. */
1053 if (TC_START_LABEL (s
, nul_char
, next_char
))
1057 /* In MRI mode, \tsym: set 0 is permitted. */
1061 if (*rest
== ' ' || *rest
== '\t')
1064 if ((strncasecmp (rest
, "EQU", 3) == 0
1065 || strncasecmp (rest
, "SET", 3) == 0)
1066 && (rest
[3] == ' ' || rest
[3] == '\t'))
1068 input_line_pointer
= rest
+ 3;
1074 line_label
= colon (s
); /* User-defined label. */
1075 restore_line_pointer (nul_char
);
1076 ++ input_line_pointer
;
1077 #ifdef tc_check_label
1078 tc_check_label (line_label
);
1080 /* Input_line_pointer->after ':'. */
1083 else if ((next_char
== '=' && *rest
== '=')
1084 || ((next_char
== ' ' || next_char
== '\t')
1089 demand_empty_rest_of_line ();
1091 else if ((next_char
== '='
1092 || ((next_char
== ' ' || next_char
== '\t')
1094 #ifdef TC_EQUAL_IN_INSN
1095 && !TC_EQUAL_IN_INSN (next_char
, s
)
1100 demand_empty_rest_of_line ();
1104 /* Expect pseudo-op or machine instruction. */
1107 #ifndef TC_CASE_SENSITIVE
1111 strncpy (original_case_string
, s2
,
1112 sizeof (original_case_string
) - 1);
1113 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1117 *s2
= TOLOWER (*s2
);
1122 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1124 /* The MRI assembler uses pseudo-ops without
1126 pop
= str_hash_find (po_hash
, s
);
1127 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1132 || (!flag_m68k_mri
&& *s
== '.'))
1136 WARNING: next_char may be end-of-line.
1137 We lookup the pseudo-op table with s+1 because we
1138 already know that the pseudo-op begins with a '.'. */
1141 pop
= str_hash_find (po_hash
, s
+ 1);
1142 if (pop
&& !pop
->poc_handler
)
1145 /* In MRI mode, we may need to insert an
1146 automatic alignment directive. What a hack
1148 if (mri_pending_align
1150 || !((pop
->poc_handler
== cons
1151 && pop
->poc_val
== 1)
1152 || (pop
->poc_handler
== s_space
1153 && pop
->poc_val
== 1)
1154 #ifdef tc_conditional_pseudoop
1155 || tc_conditional_pseudoop (pop
)
1157 || pop
->poc_handler
== s_if
1158 || pop
->poc_handler
== s_ifdef
1159 || pop
->poc_handler
== s_ifc
1160 || pop
->poc_handler
== s_ifeqs
1161 || pop
->poc_handler
== s_else
1162 || pop
->poc_handler
== s_endif
1163 || pop
->poc_handler
== s_globl
1164 || pop
->poc_handler
== s_ignore
)))
1166 do_align (1, (char *) NULL
, 0, 0);
1167 mri_pending_align
= 0;
1169 if (line_label
!= NULL
)
1171 symbol_set_frag (line_label
, frag_now
);
1172 S_SET_VALUE (line_label
, frag_now_fix ());
1176 /* Print the error msg now, while we still can. */
1179 char *end
= input_line_pointer
;
1181 (void) restore_line_pointer (nul_char
);
1183 nul_char
= next_char
= *--input_line_pointer
;
1184 *input_line_pointer
= '\0';
1185 if (! macro_defined
|| ! try_macro (next_char
, s
))
1188 as_bad (_("unknown pseudo-op: `%s'"), s
);
1189 *input_line_pointer
++ = nul_char
;
1194 /* Put it back for error messages etc. */
1195 next_char
= restore_line_pointer (nul_char
);
1196 /* The following skip of whitespace is compulsory.
1197 A well shaped space is sometimes all that separates
1198 keyword from operands. */
1199 if (next_char
== ' ' || next_char
== '\t')
1200 input_line_pointer
++;
1202 /* Input_line is restored.
1203 Input_line_pointer->1st non-blank char
1204 after pseudo-operation. */
1205 (*pop
->poc_handler
) (pop
->poc_val
);
1207 /* If that was .end, just get out now. */
1208 if (pop
->poc_handler
== s_end
)
1213 /* WARNING: next_char may be end-of-line. */
1214 /* Also: input_line_pointer->`\0` where nul_char was. */
1215 (void) restore_line_pointer (nul_char
);
1216 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1217 next_char
= nul_char
= *input_line_pointer
;
1218 *input_line_pointer
= '\0';
1220 generate_lineno_debug ();
1222 if (macro_defined
&& try_macro (next_char
, s
))
1225 if (mri_pending_align
)
1227 do_align (1, (char *) NULL
, 0, 0);
1228 mri_pending_align
= 0;
1229 if (line_label
!= NULL
)
1231 symbol_set_frag (line_label
, frag_now
);
1232 S_SET_VALUE (line_label
, frag_now_fix ());
1236 assemble_one (s
); /* Assemble 1 instruction. */
1238 /* PR 19630: The backend may have set ilp to NULL
1239 if it encountered a catastrophic failure. */
1240 if (input_line_pointer
== NULL
)
1241 as_fatal (_("unable to continue with assembly."));
1243 *input_line_pointer
++ = nul_char
;
1245 /* We resume loop AFTER the end-of-line from
1246 this instruction. */
1252 /* Empty statement? */
1253 if (is_end_of_line
[(unsigned char) next_char
])
1256 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1258 /* local label ("4:") */
1259 char *backup
= input_line_pointer
;
1261 HANDLE_CONDITIONAL_ASSEMBLY (1);
1263 temp
= next_char
- '0';
1265 /* Read the whole number. */
1266 while (ISDIGIT (*input_line_pointer
))
1268 const long digit
= *input_line_pointer
- '0';
1270 /* Don't accept labels which look like octal numbers. */
1273 if (temp
> (INT_MAX
- digit
) / 10)
1275 as_bad (_("local label too large near %s"), backup
);
1279 temp
= temp
* 10 + digit
;
1280 ++input_line_pointer
;
1283 /* Overflow: stop processing the label. */
1286 ignore_rest_of_line ();
1290 if (LOCAL_LABELS_DOLLAR
1291 && *input_line_pointer
== '$'
1292 && *(input_line_pointer
+ 1) == ':')
1294 input_line_pointer
+= 2;
1296 if (dollar_label_defined (temp
))
1298 as_fatal (_("label \"%ld$\" redefined"), temp
);
1301 define_dollar_label (temp
);
1302 colon (dollar_label_name (temp
, 0));
1307 && *input_line_pointer
++ == ':')
1309 fb_label_instance_inc (temp
);
1310 colon (fb_label_name (temp
, 0));
1314 input_line_pointer
= backup
;
1317 if (next_char
&& strchr (line_comment_chars
, next_char
))
1318 { /* Its a comment. Better say APP or NO_APP. */
1323 s
= input_line_pointer
;
1324 if (!startswith (s
, "APP\n"))
1327 ignore_rest_of_line ();
1330 bump_line_counters ();
1333 ends
= strstr (s
, "#NO_APP\n");
1334 len
= ends
? ends
- s
: buffer_limit
- s
;
1336 sb_build (&sbuf
, len
+ 100);
1337 sb_add_buffer (&sbuf
, s
, len
);
1340 /* The end of the #APP wasn't in this buffer. We
1341 keep reading in buffers until we find the #NO_APP
1342 that goes with this #APP There is one. The specs
1346 buffer_limit
= input_scrub_next_buffer (&buffer
);
1349 ends
= strstr (buffer
, "#NO_APP\n");
1350 len
= ends
? ends
- buffer
: buffer_limit
- buffer
;
1351 sb_add_buffer (&sbuf
, buffer
, len
);
1356 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1357 input_scrub_include_sb (&sbuf
, input_line_pointer
, expanding_none
);
1359 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1363 HANDLE_CONDITIONAL_ASSEMBLY (1);
1365 #ifdef tc_unrecognized_line
1366 if (tc_unrecognized_line (next_char
))
1369 input_line_pointer
--;
1370 /* Report unknown char as error. */
1371 demand_empty_rest_of_line ();
1376 symbol_set_value_now (&dot_symbol
);
1378 #ifdef HANDLE_BUNDLE
1379 if (bundle_lock_frag
!= NULL
)
1381 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1382 _(".bundle_lock with no matching .bundle_unlock"));
1383 bundle_lock_frag
= NULL
;
1384 bundle_lock_frchain
= NULL
;
1385 bundle_lock_depth
= 0;
1390 ginsn_data_end (symbol_temp_new_now ());
1395 /* Close the input file. */
1396 input_scrub_close ();
1397 #ifdef WARN_COMMENTS
1399 if (warn_comment
&& found_comment
)
1400 as_warn_where (found_comment_file
, found_comment
,
1401 "first comment found here");
1406 /* Convert O_constant expression EXP into the equivalent O_big representation.
1407 Take the sign of the number from SIGN rather than X_add_number. */
1410 convert_to_bignum (expressionS
*exp
, int sign
)
1415 value
= exp
->X_add_number
;
1416 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1418 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1419 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1421 /* Add a sequence of sign bits if the top bit of X_add_number is not
1422 the sign of the original value. */
1423 if ((exp
->X_add_number
< 0) == !sign
)
1424 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1426 exp
->X_add_number
= i
;
1429 /* For most MRI pseudo-ops, the line actually ends at the first
1430 nonquoted space. This function looks for that point, stuffs a null
1431 in, and sets *STOPCP to the character that used to be there, and
1432 returns the location.
1434 Until I hear otherwise, I am going to assume that this is only true
1435 for the m68k MRI assembler. */
1438 mri_comment_field (char *stopcp
)
1444 know (flag_m68k_mri
);
1446 for (s
= input_line_pointer
;
1447 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1455 for (s
= input_line_pointer
;
1456 !is_end_of_line
[(unsigned char) *s
];
1466 /* Skip to the end of an MRI comment field. */
1469 mri_comment_end (char *stop
, int stopc
)
1473 input_line_pointer
= stop
;
1475 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1476 ++input_line_pointer
;
1480 s_abort (int ignore ATTRIBUTE_UNUSED
)
1482 as_fatal (_(".abort detected. Abandoning ship."));
1485 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1486 (in bytes). A negative ARG is the negative of the length of the
1487 fill pattern. BYTES_P is non-zero if the alignment value should be
1488 interpreted as the byte boundary, rather than the power of 2. */
1489 #ifndef TC_ALIGN_LIMIT
1490 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1494 s_align (signed int arg
, int bytes_p
)
1496 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1505 stop
= mri_comment_field (&stopc
);
1507 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1512 align
= arg
; /* Default value from pseudo-op table. */
1516 align
= get_absolute_expression ();
1519 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1520 if (arg
> 0 && align
== 0)
1527 /* Convert to a power of 2. */
1532 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1535 as_bad (_("alignment not a power of 2"));
1541 if (align
> align_limit
)
1543 align
= align_limit
;
1544 as_warn (_("alignment too large: %u assumed"), align_limit
);
1547 if (*input_line_pointer
!= ',')
1554 ++input_line_pointer
;
1555 if (*input_line_pointer
== ',')
1559 fill
= get_absolute_expression ();
1564 if (*input_line_pointer
!= ',')
1568 ++input_line_pointer
;
1569 max
= get_absolute_expression ();
1576 as_warn (_("expected fill pattern missing"));
1577 do_align (align
, (char *) NULL
, 0, max
);
1581 unsigned int fill_len
;
1593 do_align (align
, &fill_char
, fill_len
, max
);
1599 if ((size_t) fill_len
> sizeof ab
)
1601 as_warn (_("fill pattern too long, truncating to %u"),
1602 (unsigned) sizeof ab
);
1603 fill_len
= sizeof ab
;
1606 md_number_to_chars (ab
, fill
, fill_len
);
1607 do_align (align
, ab
, fill_len
, max
);
1611 demand_empty_rest_of_line ();
1614 mri_comment_end (stop
, stopc
);
1617 /* Handle the .align pseudo-op on machines where ".align 4" means
1618 align to a 4 byte boundary. */
1621 s_align_bytes (int arg
)
1626 /* Handle the .align pseudo-op on machines where ".align 4" means align
1627 to a 2**4 boundary. */
1630 s_align_ptwo (int arg
)
1635 /* Switch in and out of alternate macro mode. */
1640 demand_empty_rest_of_line ();
1641 flag_macro_alternate
= on
;
1644 /* Read a symbol name from input_line_pointer.
1646 Stores the symbol name in a buffer and returns a pointer to this buffer.
1647 The buffer is xalloc'ed. It is the caller's responsibility to free
1650 The name is not left in the i_l_p buffer as it may need processing
1651 to handle escape characters.
1653 Advances i_l_p to the next non-whitespace character.
1655 If a symbol name could not be read, the routine issues an error
1656 messages, skips to the end of the line and returns NULL. */
1659 read_symbol_name (void)
1665 c
= *input_line_pointer
++;
1669 #define SYM_NAME_CHUNK_LEN 128
1670 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1674 start
= name
= XNEWVEC (char, len
+ 1);
1676 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1678 while (is_a_char (C
= next_char_of_string ()))
1680 if (name
>= name_end
)
1684 sofar
= name
- start
;
1685 len
+= SYM_NAME_CHUNK_LEN
;
1686 start
= XRESIZEVEC (char, start
, len
+ 1);
1687 name_end
= start
+ len
;
1688 name
= start
+ sofar
;
1695 /* Since quoted symbol names can contain non-ASCII characters,
1696 check the string and warn if it cannot be recognised by the
1697 current character set. */
1698 /* PR 29447: mbstowcs ignores the third (length) parameter when
1699 the first (destination) parameter is NULL. For clarity sake
1700 therefore we pass 0 rather than 'len' as the third parameter. */
1701 if (mbstowcs (NULL
, name
, 0) == (size_t) -1)
1702 as_warn (_("symbol name not recognised in the current locale"));
1704 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1708 name
= input_line_pointer
- 1;
1710 /* We accept FAKE_LABEL_CHAR in a name in case this is
1711 being called with a constructed string. */
1712 while (is_part_of_name (c
= *input_line_pointer
++)
1713 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1716 len
= (input_line_pointer
- name
) - 1;
1717 start
= XNEWVEC (char, len
+ 1);
1719 memcpy (start
, name
, len
);
1722 /* Skip a name ender char if one is present. */
1723 if (! is_name_ender (c
))
1724 --input_line_pointer
;
1727 name
= start
= NULL
;
1731 as_bad (_("expected symbol name"));
1732 ignore_rest_of_line ();
1744 s_comm_internal (int param
,
1745 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1749 symbolS
*symbolP
= NULL
;
1755 stop
= mri_comment_field (&stopc
);
1757 if ((name
= read_symbol_name ()) == NULL
)
1760 /* Accept an optional comma after the name. The comma used to be
1761 required, but Irix 5 cc does not generate it for .lcomm. */
1762 if (*input_line_pointer
== ',')
1763 input_line_pointer
++;
1765 temp
= get_absolute_expr (&exp
);
1767 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1768 if (exp
.X_op
== O_absent
)
1770 as_bad (_("missing size expression"));
1771 ignore_rest_of_line ();
1774 else if (temp
!= size
|| (!exp
.X_unsigned
&& exp
.X_add_number
< 0))
1776 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1777 ignore_rest_of_line ();
1781 symbolP
= symbol_find_or_make (name
);
1782 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1783 && !S_IS_COMMON (symbolP
))
1785 if (!S_IS_VOLATILE (symbolP
))
1788 as_bad (_("symbol `%s' is already defined"), name
);
1789 ignore_rest_of_line ();
1792 symbolP
= symbol_clone (symbolP
, 1);
1793 S_SET_SEGMENT (symbolP
, undefined_section
);
1794 S_SET_VALUE (symbolP
, 0);
1795 symbol_set_frag (symbolP
, &zero_address_frag
);
1796 S_CLEAR_VOLATILE (symbolP
);
1799 size
= S_GET_VALUE (symbolP
);
1802 else if (size
!= temp
)
1803 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1804 name
, (long) size
, (long) temp
);
1806 if (comm_parse_extra
!= NULL
)
1807 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1810 S_SET_VALUE (symbolP
, (valueT
) size
);
1811 S_SET_EXTERNAL (symbolP
);
1812 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1815 demand_empty_rest_of_line ();
1818 mri_comment_end (stop
, stopc
);
1826 s_comm_internal (ignore
, NULL
);
1829 /* The MRI COMMON pseudo-op. We handle this by creating a common
1830 symbol with the appropriate name. We make s_space do the right
1831 thing by increasing the size. */
1834 s_mri_common (int small ATTRIBUTE_UNUSED
)
1850 stop
= mri_comment_field (&stopc
);
1854 name
= input_line_pointer
;
1855 if (!ISDIGIT (*name
))
1856 c
= get_symbol_name (& name
);
1861 ++input_line_pointer
;
1863 while (ISDIGIT (*input_line_pointer
));
1865 c
= *input_line_pointer
;
1866 *input_line_pointer
= '\0';
1868 if (line_label
!= NULL
)
1870 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1871 + (input_line_pointer
- name
) + 1);
1872 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1877 sym
= symbol_find_or_make (name
);
1878 c
= restore_line_pointer (c
);
1881 if (*input_line_pointer
!= ',')
1885 ++input_line_pointer
;
1886 align
= get_absolute_expression ();
1889 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1891 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1892 mri_comment_end (stop
, stopc
);
1896 S_SET_EXTERNAL (sym
);
1897 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1898 mri_common_symbol
= sym
;
1902 S_SET_ALIGN (sym
, align
);
1907 if (line_label
!= NULL
)
1910 exp
.X_op
= O_symbol
;
1911 exp
.X_add_symbol
= sym
;
1912 exp
.X_add_number
= 0;
1913 symbol_set_value_expression (line_label
, &exp
);
1914 symbol_set_frag (line_label
, &zero_address_frag
);
1915 S_SET_SEGMENT (line_label
, expr_section
);
1918 /* FIXME: We just ignore the small argument, which distinguishes
1919 COMMON and COMMON.S. I don't know what we can do about it. */
1921 /* Ignore the type and hptype. */
1922 if (*input_line_pointer
== ',')
1923 input_line_pointer
+= 2;
1924 if (*input_line_pointer
== ',')
1925 input_line_pointer
+= 2;
1927 demand_empty_rest_of_line ();
1929 mri_comment_end (stop
, stopc
);
1933 s_data (int ignore ATTRIBUTE_UNUSED
)
1938 temp
= get_absolute_expression ();
1939 if (flag_readonly_data_in_text
)
1941 section
= text_section
;
1945 section
= data_section
;
1947 subseg_set (section
, (subsegT
) temp
);
1949 demand_empty_rest_of_line ();
1952 /* Handle the .file pseudo-op. This default definition may be overridden by
1953 the object or CPU specific pseudo-ops. */
1956 s_file_string (char *file
)
1960 listing_source_file (file
);
1962 register_dependency (file
);
1964 obj_app_file (file
);
1969 s_file (int ignore ATTRIBUTE_UNUSED
)
1974 /* Some assemblers tolerate immediately following '"'. */
1975 if ((s
= demand_copy_string (&length
)) != 0)
1977 new_logical_line_flags (s
, -1, 1);
1979 /* In MRI mode, the preprocessor may have inserted an extraneous
1982 && *input_line_pointer
== '\''
1983 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1984 ++input_line_pointer
;
1986 demand_empty_rest_of_line ();
1992 get_linefile_number (int *flag
)
1998 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2001 /* Don't mistakenly interpret octal numbers as line numbers. */
2002 if (*input_line_pointer
== '0')
2005 ++input_line_pointer
;
2009 expression_and_evaluate (&exp
);
2010 if (exp
.X_op
!= O_constant
)
2013 #if defined (BFD64) || LONG_MAX > INT_MAX
2014 if (exp
.X_add_number
< INT_MIN
|| exp
.X_add_number
> INT_MAX
)
2018 *flag
= exp
.X_add_number
;
2023 /* Handle the .linefile pseudo-op. This is automatically generated by
2024 do_scrub_chars when a preprocessor # line comment is seen. This
2025 default definition may be overridden by the object or CPU specific
2029 s_linefile (int ignore ATTRIBUTE_UNUSED
)
2032 int linenum
, flags
= 0;
2034 /* The given number is that of the next line. */
2035 if (!get_linefile_number (&linenum
))
2037 ignore_rest_of_line ();
2042 /* Some of the back ends can't deal with non-positive line numbers.
2043 Besides, it's silly. GCC however will generate a line number of
2044 zero when it is pre-processing builtins for assembler-with-cpp files:
2048 We do not want to barf on this, especially since such files are used
2049 in the GCC and GDB testsuites. So we check for negative line numbers
2050 rather than non-positive line numbers. */
2051 as_warn (_("line numbers must be positive; line number %d rejected"),
2059 if (*input_line_pointer
== '"')
2060 file
= demand_copy_string (&length
);
2061 else if (*input_line_pointer
== '.')
2063 /* buffer_and_nest() may insert this form. */
2064 ++input_line_pointer
;
2072 while (get_linefile_number (&this_flag
))
2075 /* From GCC's cpp documentation:
2076 1: start of a new file.
2077 2: returning to a file after having included another file.
2078 3: following text comes from a system header file.
2079 4: following text should be treated as extern "C".
2081 4 is nonsensical for the assembler; 3, we don't care about,
2082 so we ignore it just in case a system header file is
2083 included while preprocessing assembly. So 1 and 2 are all
2084 we care about, and they are mutually incompatible.
2085 new_logical_line_flags() demands this. */
2088 if (flags
&& flags
!= (1 << this_flag
))
2089 as_warn (_("incompatible flag %i in line directive"),
2092 flags
|= 1 << this_flag
;
2097 /* We ignore these. */
2101 as_warn (_("unsupported flag %i in line directive"),
2106 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2112 demand_empty_rest_of_line ();
2114 /* read_a_source_file() will bump the line number only if the line
2115 is terminated by '\n'. */
2116 if (input_line_pointer
[-1] == '\n')
2119 new_logical_line_flags (file
, linenum
, flags
);
2122 listing_source_line (linenum
);
2127 ignore_rest_of_line ();
2130 /* Handle the .end pseudo-op. Actually, the real work is done in
2131 read_a_source_file. */
2134 s_end (int ignore ATTRIBUTE_UNUSED
)
2138 /* The MRI assembler permits the start symbol to follow .end,
2139 but we don't support that. */
2141 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2142 && *input_line_pointer
!= '*'
2143 && *input_line_pointer
!= '!')
2144 as_warn (_("start address not supported"));
2148 /* Handle the .err pseudo-op. */
2151 s_err (int ignore ATTRIBUTE_UNUSED
)
2153 as_bad (_(".err encountered"));
2154 demand_empty_rest_of_line ();
2157 /* Handle the .error and .warning pseudo-ops. */
2163 /* The purpose for the conditional assignment is not to
2164 internationalize the directive itself, but that we need a
2165 self-contained message, one that can be passed like the
2166 demand_copy_C_string return value, and with no assumption on the
2167 location of the name of the directive within the message. */
2169 = (err
? _(".error directive invoked in source file")
2170 : _(".warning directive invoked in source file"));
2172 if (!is_it_end_of_statement ())
2174 if (*input_line_pointer
!= '\"')
2176 as_bad (_("%s argument must be a string"),
2177 err
? ".error" : ".warning");
2178 ignore_rest_of_line ();
2182 msg
= demand_copy_C_string (&len
);
2190 as_warn ("%s", msg
);
2191 demand_empty_rest_of_line ();
2194 /* Handle the MRI fail pseudo-op. */
2197 s_fail (int ignore ATTRIBUTE_UNUSED
)
2204 stop
= mri_comment_field (&stopc
);
2206 temp
= get_absolute_expression ();
2208 as_warn (_(".fail %ld encountered"), (long) temp
);
2210 as_bad (_(".fail %ld encountered"), (long) temp
);
2212 demand_empty_rest_of_line ();
2215 mri_comment_end (stop
, stopc
);
2219 s_fill (int ignore ATTRIBUTE_UNUSED
)
2221 expressionS rep_exp
;
2226 #ifdef md_flush_pending_output
2227 md_flush_pending_output ();
2230 #ifdef md_cons_align
2234 expression (&rep_exp
);
2235 if (*input_line_pointer
== ',')
2237 input_line_pointer
++;
2238 size
= get_absolute_expression ();
2239 if (*input_line_pointer
== ',')
2241 input_line_pointer
++;
2242 fill
= get_absolute_expression ();
2246 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2247 #define BSD_FILL_SIZE_CROCK_8 (8)
2248 if (size
> BSD_FILL_SIZE_CROCK_8
)
2250 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2251 size
= BSD_FILL_SIZE_CROCK_8
;
2255 as_warn (_("size negative; .fill ignored"));
2258 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2260 if (rep_exp
.X_add_number
< 0)
2261 as_warn (_("repeat < 0; .fill ignored"));
2264 else if (size
&& !need_pass_2
)
2266 if (now_seg
== absolute_section
&& rep_exp
.X_op
!= O_constant
)
2268 as_bad (_("non-constant fill count for absolute section"));
2271 else if (now_seg
== absolute_section
&& fill
&& rep_exp
.X_add_number
!= 0)
2273 as_bad (_("attempt to fill absolute section with non-zero value"));
2277 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2280 as_bad (_("attempt to fill section `%s' with non-zero value"),
2281 segment_name (now_seg
));
2286 if (size
&& !need_pass_2
)
2288 if (now_seg
== absolute_section
)
2289 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2291 if (rep_exp
.X_op
== O_constant
)
2293 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2294 (relax_substateT
) 0, (symbolS
*) 0,
2295 (offsetT
) rep_exp
.X_add_number
,
2300 /* We don't have a constant repeat count, so we can't use
2301 rs_fill. We can get the same results out of rs_space,
2302 but its argument is in bytes, so we must multiply the
2303 repeat count by size. */
2306 rep_sym
= make_expr_symbol (&rep_exp
);
2309 expressionS size_exp
;
2310 size_exp
.X_op
= O_constant
;
2311 size_exp
.X_add_number
= size
;
2313 rep_exp
.X_op
= O_multiply
;
2314 rep_exp
.X_add_symbol
= rep_sym
;
2315 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2316 rep_exp
.X_add_number
= 0;
2317 rep_sym
= make_expr_symbol (&rep_exp
);
2320 p
= frag_var (rs_space
, (int) size
, (int) size
,
2321 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2324 memset (p
, 0, (unsigned int) size
);
2326 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2327 flavoured AS. The following bizarre behaviour is to be
2328 compatible with above. I guess they tried to take up to 8
2329 bytes from a 4-byte expression and they forgot to sign
2331 #define BSD_FILL_SIZE_CROCK_4 (4)
2332 md_number_to_chars (p
, (valueT
) fill
,
2333 (size
> BSD_FILL_SIZE_CROCK_4
2334 ? BSD_FILL_SIZE_CROCK_4
2336 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2337 but emits no error message because it seems a legal thing to do.
2338 It is a degenerate case of .fill but could be emitted by a
2341 demand_empty_rest_of_line ();
2345 s_globl (int ignore ATTRIBUTE_UNUSED
)
2354 stop
= mri_comment_field (&stopc
);
2358 if ((name
= read_symbol_name ()) == NULL
)
2361 symbolP
= symbol_find_or_make (name
);
2362 S_SET_EXTERNAL (symbolP
);
2365 c
= *input_line_pointer
;
2368 input_line_pointer
++;
2370 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2378 demand_empty_rest_of_line ();
2381 mri_comment_end (stop
, stopc
);
2384 /* Handle the MRI IRP and IRPC pseudo-ops. */
2396 file
= as_where (&line
);
2398 eol
= find_end_of_line (input_line_pointer
, 0);
2399 sb_build (&s
, eol
- input_line_pointer
);
2400 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2401 input_line_pointer
= eol
;
2405 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2407 as_bad_where (file
, line
, "%s", err
);
2411 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2413 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2416 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2417 the section to only be linked once. However, this is not supported
2418 by most object file formats. This takes an optional argument,
2419 which is what to do about duplicates. */
2422 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2424 enum linkonce_type type
;
2428 type
= LINKONCE_DISCARD
;
2430 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2435 c
= get_symbol_name (& s
);
2436 if (strcasecmp (s
, "discard") == 0)
2437 type
= LINKONCE_DISCARD
;
2438 else if (strcasecmp (s
, "one_only") == 0)
2439 type
= LINKONCE_ONE_ONLY
;
2440 else if (strcasecmp (s
, "same_size") == 0)
2441 type
= LINKONCE_SAME_SIZE
;
2442 else if (strcasecmp (s
, "same_contents") == 0)
2443 type
= LINKONCE_SAME_CONTENTS
;
2445 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2447 (void) restore_line_pointer (c
);
2450 #ifdef obj_handle_link_once
2451 obj_handle_link_once (type
);
2452 #else /* ! defined (obj_handle_link_once) */
2456 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2457 as_warn (_(".linkonce is not supported for this object file format"));
2459 flags
= bfd_section_flags (now_seg
);
2460 flags
|= SEC_LINK_ONCE
;
2465 case LINKONCE_DISCARD
:
2466 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2468 case LINKONCE_ONE_ONLY
:
2469 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2471 case LINKONCE_SAME_SIZE
:
2472 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2474 case LINKONCE_SAME_CONTENTS
:
2475 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2478 if (!bfd_set_section_flags (now_seg
, flags
))
2479 as_bad (_("bfd_set_section_flags: %s"),
2480 bfd_errmsg (bfd_get_error ()));
2482 #endif /* ! defined (obj_handle_link_once) */
2484 demand_empty_rest_of_line ();
2488 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2491 segT current_seg
= now_seg
;
2492 subsegT current_subseg
= now_subseg
;
2493 segT bss_seg
= bss_section
;
2495 #if defined (TC_MIPS) || defined (TC_ALPHA)
2496 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2497 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2499 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2500 if (size
<= bfd_get_gp_size (stdoutput
))
2502 bss_seg
= subseg_new (".sbss", 1);
2503 seg_info (bss_seg
)->bss
= 1;
2504 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2505 as_warn (_("error setting flags for \".sbss\": %s"),
2506 bfd_errmsg (bfd_get_error ()));
2510 subseg_set (bss_seg
, 1);
2512 if (align
> OCTETS_PER_BYTE_POWER
)
2514 record_alignment (bss_seg
, align
);
2515 frag_align (align
, 0, 0);
2518 /* Detach from old frag. */
2519 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2520 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2522 symbol_set_frag (symbolP
, frag_now
);
2523 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2527 S_SET_SIZE (symbolP
, size
);
2529 S_SET_SEGMENT (symbolP
, bss_seg
);
2532 /* The symbol may already have been created with a preceding
2533 ".globl" directive -- be careful not to step on storage class
2534 in that case. Otherwise, set it to static. */
2535 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2536 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2537 #endif /* OBJ_COFF */
2539 subseg_set (current_seg
, current_subseg
);
2543 parse_align (int align_bytes
)
2549 if (*input_line_pointer
!= ',')
2552 as_bad (_("expected alignment after size"));
2553 ignore_rest_of_line ();
2557 input_line_pointer
++;
2560 align
= get_absolute_expr (&exp
);
2561 if (exp
.X_op
== O_absent
)
2564 if (!exp
.X_unsigned
&& exp
.X_add_number
< 0)
2566 as_warn (_("alignment negative; 0 assumed"));
2570 if (align_bytes
&& align
!= 0)
2572 /* convert to a power of 2 alignment */
2573 unsigned int alignp2
= 0;
2574 while ((align
& 1) == 0)
2575 align
>>= 1, ++alignp2
;
2578 as_bad (_("alignment not a power of 2"));
2579 ignore_rest_of_line ();
2587 /* Called from s_comm_internal after symbol name and size have been
2588 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2589 1 if this was a ".bss" directive which has a 3rd argument
2590 (alignment as a power of 2), or 2 if this was a ".bss" directive
2591 with alignment in bytes. */
2594 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2600 align
= parse_align (needs_align
- 1);
2601 if (align
== (addressT
) -1)
2605 /* Assume some objects may require alignment on some systems. */
2606 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2608 bss_alloc (symbolP
, size
, align
);
2613 s_lcomm (int needs_align
)
2615 s_comm_internal (needs_align
, s_lcomm_internal
);
2619 s_lcomm_bytes (int needs_align
)
2621 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2625 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2631 /* We permit ANY defined expression: BSD4.2 demands constants. */
2632 if ((name
= read_symbol_name ()) == NULL
)
2635 if (*input_line_pointer
!= ',')
2637 as_bad (_("expected comma after \"%s\""), name
);
2641 input_line_pointer
++;
2642 expression_and_evaluate (&exp
);
2644 if (exp
.X_op
!= O_constant
2645 && exp
.X_op
!= O_register
)
2647 as_bad (_("bad expression"));
2651 symbolP
= symbol_find_or_make (name
);
2653 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2655 /* The name might be an undefined .global symbol; be sure to
2656 keep the "external" bit. */
2657 S_SET_SEGMENT (symbolP
,
2658 (exp
.X_op
== O_constant
2661 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2665 as_bad (_("symbol `%s' is already defined"), name
);
2668 demand_empty_rest_of_line ();
2673 ignore_rest_of_line ();
2678 /* Read a line into an sb. Returns the character that ended the line
2679 or zero if there are no more lines. */
2682 get_line_sb (sb
*line
, int in_macro
)
2686 if (input_line_pointer
[-1] == '\n')
2687 bump_line_counters ();
2689 if (input_line_pointer
>= buffer_limit
)
2691 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2692 if (buffer_limit
== 0)
2696 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2697 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2698 input_line_pointer
= eol
;
2700 /* Don't skip multiple end-of-line characters, because that breaks support
2701 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2702 characters but isn't. Instead just skip one end of line character and
2703 return the character skipped so that the caller can re-insert it if
2705 return *input_line_pointer
++;
2709 get_non_macro_line_sb (sb
*line
)
2711 return get_line_sb (line
, 0);
2715 get_macro_line_sb (sb
*line
)
2717 return get_line_sb (line
, 1);
2720 /* Define a macro. This is an interface to macro.c. */
2723 s_macro (int ignore ATTRIBUTE_UNUSED
)
2729 eol
= find_end_of_line (input_line_pointer
, 0);
2730 sb_build (&s
, eol
- input_line_pointer
);
2731 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2732 input_line_pointer
= eol
;
2734 if (line_label
!= NULL
)
2740 name
= S_GET_NAME (line_label
);
2741 len
= strlen (name
);
2742 sb_build (&label
, len
);
2743 sb_add_buffer (&label
, name
, len
);
2744 macro
= define_macro (&s
, &label
, get_macro_line_sb
);
2748 macro
= define_macro (&s
, NULL
, get_macro_line_sb
);
2751 if (line_label
!= NULL
)
2753 S_SET_SEGMENT (line_label
, absolute_section
);
2754 S_SET_VALUE (line_label
, 0);
2755 symbol_set_frag (line_label
, &zero_address_frag
);
2758 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2759 && str_hash_find (po_hash
, macro
->name
) != NULL
)
2761 && macro
->name
[0] == '.'
2762 && str_hash_find (po_hash
, macro
->name
+ 1) != NULL
))
2764 as_warn_where (macro
->file
, macro
->line
,
2765 _("attempt to redefine pseudo-op `%s' ignored"),
2767 str_hash_delete (macro_hash
, macro
->name
);
2774 /* Handle the .mexit pseudo-op, which immediately exits a macro
2778 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2782 cond_exit_macro (macro_nest
);
2783 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2786 as_warn (_("ignoring macro exit outside a macro definition."));
2789 /* Switch in and out of MRI mode. */
2792 s_mri (int ignore ATTRIBUTE_UNUSED
)
2795 #ifdef MRI_MODE_CHANGE
2799 on
= get_absolute_expression ();
2800 #ifdef MRI_MODE_CHANGE
2801 old_flag
= flag_mri
;
2818 /* Operator precedence changes in m68k MRI mode, so we need to
2819 update the operator rankings. */
2820 expr_set_precedence ();
2822 #ifdef MRI_MODE_CHANGE
2824 MRI_MODE_CHANGE (on
);
2827 demand_empty_rest_of_line ();
2830 /* Handle changing the location counter. */
2833 do_org (segT segment
, expressionS
*exp
, int fill
)
2835 if (segment
!= now_seg
2836 && segment
!= absolute_section
2837 && segment
!= expr_section
)
2838 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2840 if (now_seg
== absolute_section
)
2843 as_warn (_("ignoring fill value in absolute section"));
2844 if (exp
->X_op
!= O_constant
)
2846 as_bad (_("only constant offsets supported in absolute section"));
2847 exp
->X_add_number
= 0;
2849 abs_section_offset
= exp
->X_add_number
;
2854 symbolS
*sym
= exp
->X_add_symbol
;
2855 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2857 if (fill
&& in_bss ())
2858 as_warn (_("ignoring fill value in section `%s'"),
2859 segment_name (now_seg
));
2861 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2863 /* Handle complex expressions. */
2864 sym
= make_expr_symbol (exp
);
2868 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2874 s_org (int ignore ATTRIBUTE_UNUSED
)
2880 #ifdef md_flush_pending_output
2881 md_flush_pending_output ();
2884 /* The m68k MRI assembler has a different meaning for .org. It
2885 means to create an absolute section at a given address. We can't
2886 support that--use a linker script instead. */
2889 as_bad (_("MRI style ORG pseudo-op not supported"));
2890 ignore_rest_of_line ();
2894 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2895 thing as a sub-segment-relative origin. Any absolute origin is
2896 given a warning, then assumed to be segment-relative. Any
2897 segmented origin expression ("foo+42") had better be in the right
2898 segment or the .org is ignored.
2900 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2901 we never know sub-segment sizes when we are reading code. BSD
2902 will crash trying to emit negative numbers of filler bytes in
2903 certain .orgs. We don't crash, but see as-write for that code.
2905 Don't make frag if need_pass_2==1. */
2906 segment
= get_known_segmented_expression (&exp
);
2907 if (*input_line_pointer
== ',')
2909 input_line_pointer
++;
2910 temp_fill
= get_absolute_expression ();
2916 do_org (segment
, &exp
, temp_fill
);
2918 demand_empty_rest_of_line ();
2921 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2922 called by the obj-format routine which handles section changing
2923 when in MRI mode. It will create a new section, and return it. It
2924 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2925 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2928 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2938 name
= input_line_pointer
;
2939 if (!ISDIGIT (*name
))
2940 c
= get_symbol_name (& name
);
2945 ++input_line_pointer
;
2947 while (ISDIGIT (*input_line_pointer
));
2949 c
= *input_line_pointer
;
2950 *input_line_pointer
= '\0';
2953 name
= xstrdup (name
);
2955 c
= restore_line_pointer (c
);
2957 seg
= subseg_new (name
, 0);
2963 ++input_line_pointer
;
2964 align
= get_absolute_expression ();
2965 record_alignment (seg
, align
);
2969 if (*input_line_pointer
== ',')
2971 c
= *++input_line_pointer
;
2973 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2976 as_bad (_("unrecognized section type"));
2977 ++input_line_pointer
;
2982 flags
= SEC_NO_FLAGS
;
2984 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2985 else if (*type
== 'D' || *type
== 'M')
2986 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2987 else if (*type
== 'R')
2988 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2989 if (flags
!= SEC_NO_FLAGS
)
2991 if (!bfd_set_section_flags (seg
, flags
))
2992 as_warn (_("error setting flags for \"%s\": %s"),
2993 bfd_section_name (seg
),
2994 bfd_errmsg (bfd_get_error ()));
2999 /* Ignore the HP type. */
3000 if (*input_line_pointer
== ',')
3001 input_line_pointer
+= 2;
3003 demand_empty_rest_of_line ();
3005 #else /* ! TC_M68K */
3006 /* The MRI assembler seems to use different forms of .sect for
3007 different targets. */
3008 as_bad ("MRI mode not supported for this target");
3009 ignore_rest_of_line ();
3010 #endif /* ! TC_M68K */
3013 /* Handle the .print pseudo-op. */
3016 s_print (int ignore ATTRIBUTE_UNUSED
)
3021 s
= demand_copy_C_string (&len
);
3024 demand_empty_rest_of_line ();
3027 /* Handle the .purgem pseudo-op. */
3030 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3032 if (is_it_end_of_statement ())
3034 demand_empty_rest_of_line ();
3044 c
= get_symbol_name (& name
);
3045 delete_macro (name
);
3046 *input_line_pointer
= c
;
3047 SKIP_WHITESPACE_AFTER_NAME ();
3049 while (*input_line_pointer
++ == ',');
3051 --input_line_pointer
;
3052 demand_empty_rest_of_line ();
3055 /* Handle the .endm/.endr pseudo-ops. */
3058 s_bad_end (int endr
)
3060 as_warn (_(".end%c encountered without preceding %s"),
3062 endr
? ".rept, .irp, or .irpc" : ".macro");
3063 demand_empty_rest_of_line ();
3066 /* Handle the .rept pseudo-op. */
3069 s_rept (int ignore ATTRIBUTE_UNUSED
)
3073 count
= (size_t) get_absolute_expression ();
3075 do_repeat (count
, "REPT", "ENDR", NULL
);
3078 /* This function provides a generic repeat block implementation. It allows
3079 different directives to be used as the start/end keys. Any text matching
3080 the optional EXPANDER in the block is replaced by the remaining iteration
3084 do_repeat (size_t count
, const char *start
, const char *end
,
3085 const char *expander
)
3090 if (((ssize_t
) count
) < 0)
3092 as_bad (_("negative count for %s - ignored"), start
);
3097 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3099 as_bad (_("%s without %s"), start
, end
);
3104 if (expander
== NULL
|| strstr (one
.ptr
, expander
) == NULL
)
3106 sb_build (&many
, count
* one
.len
);
3108 sb_add_sb (&many
, &one
);
3114 while (count
-- > 0)
3120 sb_build (& processed
, one
.len
);
3121 sb_add_sb (& processed
, & one
);
3122 sub
= strstr (processed
.ptr
, expander
);
3123 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3124 gas_assert (len
< 8);
3125 memmove (sub
+ len
, sub
+ 8,
3126 processed
.ptr
+ processed
.len
- (sub
+ 8));
3127 processed
.len
-= (8 - len
);
3128 sb_add_sb (& many
, & processed
);
3129 sb_kill (& processed
);
3135 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3137 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3140 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3141 input buffers to skip. Assumes that conditionals preceding the loop end
3142 are properly nested.
3144 This function makes it easier to implement a premature "break" out of the
3145 loop. The EXTRA arg accounts for other buffers we might have inserted,
3146 such as line substitutions. */
3149 end_repeat (int extra
)
3151 cond_exit_macro (macro_nest
);
3152 while (extra
-- >= 0)
3153 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3157 assign_symbol (char *name
, int mode
)
3161 if (name
[0] == '.' && name
[1] == '\0')
3163 /* Turn '. = mumble' into a .org mumble. */
3167 segment
= get_known_segmented_expression (&exp
);
3170 do_org (segment
, &exp
, 0);
3175 if ((symbolP
= symbol_find (name
)) == NULL
3176 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3178 symbolP
= symbol_find_or_make (name
);
3180 /* When doing symbol listings, play games with dummy fragments living
3181 outside the normal fragment chain to record the file and line info
3183 if (listing
& LISTING_SYMBOLS
)
3185 extern struct list_info_struct
*listing_tail
;
3186 fragS
*dummy_frag
= notes_calloc (1, sizeof (*dummy_frag
));
3187 dummy_frag
->line
= listing_tail
;
3188 dummy_frag
->fr_symbol
= symbolP
;
3189 symbol_set_frag (symbolP
, dummy_frag
);
3192 #if defined (OBJ_COFF) && !defined (TE_PE)
3193 /* "set" symbols are local unless otherwise specified. */
3194 SF_SET_LOCAL (symbolP
);
3198 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3200 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3201 && !S_CAN_BE_REDEFINED (symbolP
))
3203 as_bad (_("symbol `%s' is already defined"), name
);
3204 ignore_rest_of_line ();
3205 input_line_pointer
--;
3208 /* If the symbol is volatile, copy the symbol and replace the
3209 original with the copy, so that previous uses of the symbol will
3210 retain the value of the symbol at the point of use. */
3211 else if (S_IS_VOLATILE (symbolP
))
3212 symbolP
= symbol_clone (symbolP
, 1);
3216 S_SET_VOLATILE (symbolP
);
3218 S_SET_FORWARD_REF (symbolP
);
3220 pseudo_set (symbolP
);
3223 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3224 then this is .equiv, and it is an error if the symbol is already
3225 defined. If EQUIV is -1, the symbol additionally is a forward
3233 /* Especial apologies for the random logic:
3234 this just grew, and could be parsed much more simply!
3236 if ((name
= read_symbol_name ()) == NULL
)
3239 if (*input_line_pointer
!= ',')
3241 as_bad (_("expected comma after \"%s\""), name
);
3242 ignore_rest_of_line ();
3247 input_line_pointer
++;
3248 assign_symbol (name
, equiv
);
3249 demand_empty_rest_of_line ();
3263 #ifdef md_flush_pending_output
3264 md_flush_pending_output ();
3271 # ifndef P_PRECISION
3272 # define P_PRECISION X_PRECISION
3273 # define P_PRECISION_PAD X_PRECISION_PAD
3275 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3283 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3290 #ifdef md_cons_align
3295 stop
= mri_comment_field (&stopc
);
3297 /* In m68k MRI mode, we need to align to a word boundary, unless
3299 if (flag_m68k_mri
&& mult
> 1)
3301 if (now_seg
== absolute_section
)
3303 abs_section_offset
+= abs_section_offset
& 1;
3304 if (line_label
!= NULL
)
3305 S_SET_VALUE (line_label
, abs_section_offset
);
3307 else if (mri_common_symbol
!= NULL
)
3311 mri_val
= S_GET_VALUE (mri_common_symbol
);
3312 if ((mri_val
& 1) != 0)
3314 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3315 if (line_label
!= NULL
)
3317 expressionS
*symexp
;
3319 symexp
= symbol_get_value_expression (line_label
);
3320 know (symexp
->X_op
== O_symbol
);
3321 know (symexp
->X_add_symbol
== mri_common_symbol
);
3322 symexp
->X_add_number
+= 1;
3328 do_align (1, (char *) NULL
, 0, 0);
3329 if (line_label
!= NULL
)
3331 symbol_set_frag (line_label
, frag_now
);
3332 S_SET_VALUE (line_label
, frag_now_fix ());
3342 if (*input_line_pointer
== ',')
3344 ++input_line_pointer
;
3349 val
.X_op
= O_constant
;
3350 val
.X_add_number
= 0;
3353 if ((val
.X_op
!= O_constant
3354 || val
.X_add_number
< - 0x80
3355 || val
.X_add_number
> 0xff
3356 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3357 && (now_seg
!= absolute_section
&& !in_bss ()))
3359 resolve_expression (&exp
);
3360 if (exp
.X_op
!= O_constant
)
3361 as_bad (_("unsupported variable size or fill value"));
3366 /* PR 20901: Check for excessive values.
3367 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3368 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3369 as_bad (_("size value for space directive too large: %lx"),
3370 (long) exp
.X_add_number
);
3375 bytes
= mult
* exp
.X_add_number
;
3377 for (i
= 0; i
< exp
.X_add_number
; i
++)
3378 emit_expr (&val
, mult
);
3384 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3385 resolve_expression (&exp
);
3387 if (exp
.X_op
== O_constant
)
3389 addressT repeat
= exp
.X_add_number
;
3393 if ((offsetT
) repeat
< 0)
3395 as_warn (_(".space repeat count is negative, ignored"));
3401 as_warn (_(".space repeat count is zero, ignored"));
3404 if ((unsigned int) mult
<= 1)
3406 else if (gas_mul_overflow (repeat
, mult
, &total
)
3407 || (offsetT
) total
< 0)
3409 as_warn (_(".space repeat count overflow, ignored"));
3414 /* If we are in the absolute section, just bump the offset. */
3415 if (now_seg
== absolute_section
)
3417 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3418 as_warn (_("ignoring fill value in absolute section"));
3419 abs_section_offset
+= total
;
3423 /* If we are secretly in an MRI common section, then
3424 creating space just increases the size of the common
3426 if (mri_common_symbol
!= NULL
)
3428 S_SET_VALUE (mri_common_symbol
,
3429 S_GET_VALUE (mri_common_symbol
) + total
);
3434 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3435 (offsetT
) total
, (char *) 0);
3439 if (now_seg
== absolute_section
)
3441 as_bad (_("space allocation too complex in absolute section"));
3442 subseg_set (text_section
, 0);
3445 if (mri_common_symbol
!= NULL
)
3447 as_bad (_("space allocation too complex in common section"));
3448 mri_common_symbol
= NULL
;
3452 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3453 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3456 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3457 as_warn (_("ignoring fill value in section `%s'"),
3458 segment_name (now_seg
));
3460 *p
= val
.X_add_number
;
3465 /* In MRI mode, after an odd number of bytes, we must align to an
3466 even word boundary, unless the next instruction is a dc.b, ds.b
3468 if (flag_mri
&& (bytes
& 1) != 0)
3469 mri_pending_align
= 1;
3471 demand_empty_rest_of_line ();
3474 mri_comment_end (stop
, stopc
);
3478 s_nop (int ignore ATTRIBUTE_UNUSED
)
3485 #ifdef md_flush_pending_output
3486 md_flush_pending_output ();
3491 demand_empty_rest_of_line ();
3494 start_off
= frag_now_fix ();
3497 #ifdef md_emit_single_noop
3498 md_emit_single_noop
;
3502 #ifndef md_single_noop_insn
3503 #define md_single_noop_insn "nop"
3505 /* md_assemble might modify its argument, so
3506 we must pass it a string that is writable. */
3507 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3508 as_fatal ("%s", xstrerror (errno
));
3510 /* Some targets assume that they can update input_line_pointer
3511 inside md_assemble, and, worse, that they can leave it
3512 assigned to the string pointer that was provided as an
3513 argument. So preserve ilp here. */
3514 char *saved_ilp
= input_line_pointer
;
3516 input_line_pointer
= saved_ilp
;
3519 #ifdef md_flush_pending_output
3520 md_flush_pending_output ();
3522 } while (exp
.X_op
== O_constant
3523 && exp
.X_add_number
> 0
3524 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3525 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3529 s_nops (int ignore ATTRIBUTE_UNUSED
)
3534 #ifdef md_flush_pending_output
3535 md_flush_pending_output ();
3540 /* Note - this expression is tested for an absolute value in
3541 write.c:relax_segment(). */
3544 if (*input_line_pointer
== ',')
3546 ++input_line_pointer
;
3551 val
.X_op
= O_constant
;
3552 val
.X_add_number
= 0;
3555 if (val
.X_op
!= O_constant
)
3557 as_bad (_("unsupported variable nop control in .nops directive"));
3558 val
.X_op
= O_constant
;
3559 val
.X_add_number
= 0;
3561 else if (val
.X_add_number
< 0)
3563 as_warn (_("negative nop control byte, ignored"));
3564 val
.X_add_number
= 0;
3567 demand_empty_rest_of_line ();
3570 /* Ignore this directive if we are going to perform a second pass. */
3573 /* Store the no-op instruction control byte in the first byte of frag. */
3575 symbolS
*sym
= make_expr_symbol (&exp
);
3576 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3577 sym
, (offsetT
) 0, (char *) 0);
3578 *p
= val
.X_add_number
;
3581 /* Obtain the size of a floating point number, given a type. */
3584 float_length (int float_type
, int *pad_p
)
3586 int length
, pad
= 0;
3614 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3615 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3624 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3625 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3632 as_bad (_("unknown floating type '%c'"), float_type
);
3644 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3650 /* Skip any 0{letter} that may be present. Don't even check if the
3651 letter is legal. Someone may invent a "z" format and this routine
3652 has no use for such information. Lusers beware: you get
3653 diagnostics if your input is ill-conditioned. */
3654 if (input_line_pointer
[0] == '0'
3655 && ISALPHA (input_line_pointer
[1]))
3656 input_line_pointer
+= 2;
3658 /* Accept :xxxx, where the x's are hex digits, for a floating point
3659 with the exact digits specified. */
3660 if (input_line_pointer
[0] == ':')
3662 ++input_line_pointer
;
3663 length
= hex_float (float_type
, temp
);
3666 ignore_rest_of_line ();
3674 err
= md_atof (float_type
, temp
, &length
);
3675 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3676 know (err
!= NULL
|| length
> 0);
3679 as_bad (_("bad floating literal: %s"), err
);
3680 ignore_rest_of_line ();
3688 /* This is like s_space, but the value is a floating point number with
3689 the given precision. This is for the MRI dcb.s pseudo-op and
3693 s_float_space (int float_type
)
3697 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3701 #ifdef md_cons_align
3706 stop
= mri_comment_field (&stopc
);
3708 count
= get_absolute_expression ();
3711 if (*input_line_pointer
!= ',')
3715 flen
= float_length (float_type
, &pad
);
3717 memset (temp
, 0, flen
+= pad
);
3721 ++input_line_pointer
;
3723 flen
= parse_one_float (float_type
, temp
);
3729 mri_comment_end (stop
, stopc
);
3733 while (--count
>= 0)
3737 p
= frag_more (flen
);
3738 memcpy (p
, temp
, (unsigned int) flen
);
3741 demand_empty_rest_of_line ();
3744 mri_comment_end (stop
, stopc
);
3747 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3750 s_struct (int ignore ATTRIBUTE_UNUSED
)
3756 stop
= mri_comment_field (&stopc
);
3757 abs_section_offset
= get_absolute_expression ();
3758 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3759 /* The ELF backend needs to know that we are changing sections, so
3760 that .previous works correctly. */
3762 obj_elf_section_change_hook ();
3764 subseg_set (absolute_section
, 0);
3765 demand_empty_rest_of_line ();
3767 mri_comment_end (stop
, stopc
);
3771 s_text (int ignore ATTRIBUTE_UNUSED
)
3775 temp
= get_absolute_expression ();
3776 subseg_set (text_section
, (subsegT
) temp
);
3777 demand_empty_rest_of_line ();
3780 /* .weakref x, y sets x as an alias to y that, as long as y is not
3781 referenced directly, will cause y to become a weak symbol. */
3783 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3790 if ((name
= read_symbol_name ()) == NULL
)
3793 symbolP
= symbol_find_or_make (name
);
3795 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3797 if (!S_IS_VOLATILE (symbolP
))
3799 as_bad (_("symbol `%s' is already defined"), name
);
3802 symbolP
= symbol_clone (symbolP
, 1);
3803 S_CLEAR_VOLATILE (symbolP
);
3808 if (*input_line_pointer
!= ',')
3810 as_bad (_("expected comma after \"%s\""), name
);
3814 input_line_pointer
++;
3819 if ((name
= read_symbol_name ()) == NULL
)
3822 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3823 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3825 symbolP2
= symbol_find_or_make (name
);
3826 S_SET_WEAKREFD (symbolP2
);
3830 symbolS
*symp
= symbolP2
;
3832 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3834 expressionS
*expP
= symbol_get_value_expression (symp
);
3836 gas_assert (expP
->X_op
== O_symbol
3837 && expP
->X_add_number
== 0);
3838 symp
= expP
->X_add_symbol
;
3840 if (symp
== symbolP
)
3844 loop
= concat (S_GET_NAME (symbolP
),
3845 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3848 while (symp
!= symbolP
)
3850 char *old_loop
= loop
;
3852 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3853 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3854 (const char *) NULL
);
3858 as_bad (_("%s: would close weakref loop: %s"),
3859 S_GET_NAME (symbolP
), loop
);
3863 ignore_rest_of_line ();
3867 /* Short-circuiting instead of just checking here might speed
3868 things up a tiny little bit, but loop error messages would
3869 miss intermediate links. */
3870 /* symbolP2 = symp; */
3873 memset (&exp
, 0, sizeof (exp
));
3874 exp
.X_op
= O_symbol
;
3875 exp
.X_add_symbol
= symbolP2
;
3877 S_SET_SEGMENT (symbolP
, undefined_section
);
3878 symbol_set_value_expression (symbolP
, &exp
);
3879 symbol_set_frag (symbolP
, &zero_address_frag
);
3880 S_SET_WEAKREFR (symbolP
);
3882 demand_empty_rest_of_line ();
3887 ignore_rest_of_line ();
3893 /* Verify that we are at the end of a line. If not, issue an error and
3894 skip to EOL. This function may leave input_line_pointer one past
3895 buffer_limit, so should not be called from places that may
3896 dereference input_line_pointer unconditionally. Note that when the
3897 gas parser is switched to handling a string (where buffer_limit
3898 should be the size of the string excluding the NUL terminator) this
3899 will be one past the NUL; is_end_of_line(0) returns true. */
3902 demand_empty_rest_of_line (void)
3905 if (input_line_pointer
> buffer_limit
)
3907 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3908 input_line_pointer
++;
3911 if (ISPRINT (*input_line_pointer
))
3912 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3913 *input_line_pointer
);
3915 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3916 *input_line_pointer
);
3917 ignore_rest_of_line ();
3919 /* Return pointing just after end-of-line. */
3922 /* Silently advance to the end of line. Use this after already having
3923 issued an error about something bad. Like demand_empty_rest_of_line,
3924 this function may leave input_line_pointer one after buffer_limit;
3925 Don't call it from within expression parsing code in an attempt to
3926 silence further errors. */
3929 ignore_rest_of_line (void)
3931 while (input_line_pointer
<= buffer_limit
)
3932 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3934 /* Return pointing just after end-of-line. */
3937 /* Sets frag for given symbol to zero_address_frag, except when the
3938 symbol frag is already set to a dummy listing frag. */
3941 set_zero_frag (symbolS
*symbolP
)
3943 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3944 symbol_set_frag (symbolP
, &zero_address_frag
);
3947 /* In: Pointer to a symbol.
3948 Input_line_pointer->expression.
3950 Out: Input_line_pointer->just after any whitespace after expression.
3951 Tried to set symbol to value of expression.
3952 Will change symbols type, value, and frag; */
3955 pseudo_set (symbolS
*symbolP
)
3960 know (symbolP
); /* NULL pointer is logic error. */
3962 if (!S_IS_FORWARD_REF (symbolP
))
3963 (void) expression (&exp
);
3965 (void) deferred_expression (&exp
);
3967 if (exp
.X_op
== O_illegal
)
3968 as_bad (_("illegal expression"));
3969 else if (exp
.X_op
== O_absent
)
3970 as_bad (_("missing expression"));
3971 else if (exp
.X_op
== O_big
)
3973 if (exp
.X_add_number
> 0)
3974 as_bad (_("bignum invalid"));
3976 as_bad (_("floating point number invalid"));
3978 else if (exp
.X_op
== O_subtract
3979 && !S_IS_FORWARD_REF (symbolP
)
3980 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3981 && (symbol_get_frag (exp
.X_add_symbol
)
3982 == symbol_get_frag (exp
.X_op_symbol
)))
3984 exp
.X_op
= O_constant
;
3985 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3986 - S_GET_VALUE (exp
.X_op_symbol
));
3989 if (symbol_section_p (symbolP
))
3991 as_bad ("attempt to set value of section symbol");
4000 exp
.X_add_number
= 0;
4003 S_SET_SEGMENT (symbolP
, absolute_section
);
4004 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
4005 set_zero_frag (symbolP
);
4009 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
4010 if (S_IS_EXTERNAL (symbolP
))
4012 as_bad ("can't equate global symbol `%s' with register name",
4013 S_GET_NAME (symbolP
));
4017 /* Make sure symbol_equated_p() recognizes the symbol as an equate. */
4018 exp
.X_add_symbol
= make_expr_symbol (&exp
);
4019 exp
.X_add_number
= 0;
4020 exp
.X_op
= O_symbol
;
4021 symbol_set_value_expression (symbolP
, &exp
);
4022 S_SET_SEGMENT (symbolP
, reg_section
);
4023 set_zero_frag (symbolP
);
4027 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4028 /* For x=undef+const, create an expression symbol.
4029 For x=x+const, just update x except when x is an undefined symbol
4030 For x=defined+const, evaluate x. */
4031 if (symbolP
== exp
.X_add_symbol
4032 && (seg
!= undefined_section
4033 || !symbol_constant_p (symbolP
)))
4035 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4038 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4040 symbolS
*s
= exp
.X_add_symbol
;
4042 if (S_IS_COMMON (s
))
4043 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4044 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4046 S_SET_SEGMENT (symbolP
, seg
);
4047 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4048 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4049 copy_symbol_attributes (symbolP
, s
);
4052 S_SET_SEGMENT (symbolP
, undefined_section
);
4053 symbol_set_value_expression (symbolP
, &exp
);
4054 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4055 set_zero_frag (symbolP
);
4059 /* The value is some complex expression. */
4060 S_SET_SEGMENT (symbolP
, expr_section
);
4061 symbol_set_value_expression (symbolP
, &exp
);
4062 set_zero_frag (symbolP
);
4069 CONStruct more frag of .bytes, or .words etc.
4070 Should need_pass_2 be 1 then emit no frag(s).
4071 This understands EXPRESSIONS.
4075 This has a split personality. We use expression() to read the
4076 value. We can detect if the value won't fit in a byte or word.
4077 But we can't detect if expression() discarded significant digits
4078 in the case of a long. Not worth the crocks required to fix it. */
4080 /* Select a parser for cons expressions. */
4082 /* Some targets need to parse the expression in various fancy ways.
4083 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4084 (for example, the HPPA does this). Otherwise, you can define
4085 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4086 are defined, which is the normal case, then only simple expressions
4091 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4094 #ifndef TC_PARSE_CONS_EXPRESSION
4095 #ifdef REPEAT_CONS_EXPRESSIONS
4096 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4097 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4099 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4102 /* If we haven't gotten one yet, just call expression. */
4103 #ifndef TC_PARSE_CONS_EXPRESSION
4104 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4105 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4110 do_parse_cons_expression (expressionS
*exp
,
4111 int nbytes ATTRIBUTE_UNUSED
)
4113 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4117 /* Worker to do .byte etc statements.
4118 Clobbers input_line_pointer and checks end-of-line. */
4121 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4129 #ifdef md_flush_pending_output
4130 md_flush_pending_output ();
4134 stop
= mri_comment_field (&stopc
);
4136 if (is_it_end_of_statement ())
4138 demand_empty_rest_of_line ();
4140 mri_comment_end (stop
, stopc
);
4145 nbytes
= TC_ADDRESS_BYTES ();
4147 #ifdef md_cons_align
4148 md_cons_align (nbytes
);
4154 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4155 #ifdef TC_CONS_FIX_CHECK
4156 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4158 if (*cur_fix
!= NULL
)
4159 cur_fix
= &(*cur_fix
)->fx_next
;
4164 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4169 if (*input_line_pointer
== '"')
4171 as_bad (_("unexpected `\"' in expression"));
4172 ignore_rest_of_line ();
4176 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4181 if (exp
.X_op
== O_symbol
)
4182 exp
.X_op
= O_symbol_rva
;
4184 as_fatal (_("rva without symbol"));
4186 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4187 #ifdef TC_CONS_FIX_CHECK
4188 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4192 while (*input_line_pointer
++ == ',');
4194 /* In MRI mode, after an odd number of bytes, we must align to an
4195 even word boundary, unless the next instruction is a dc.b, ds.b
4197 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4198 mri_pending_align
= 1;
4200 input_line_pointer
--; /* Put terminator back into stream. */
4202 demand_empty_rest_of_line ();
4205 mri_comment_end (stop
, stopc
);
4207 /* Disallow hand-crafting instructions using .byte. FIXME - what about
4208 .word, .long etc ? */
4209 if (flag_synth_cfi
&& frchain_now
&& frchain_now
->frch_ginsn_data
4211 as_bad (_("SCFI: hand-crafting instructions not supported"));
4217 cons_worker (size
, 0);
4223 cons_worker (size
, 1);
4226 /* .reloc offset, reloc_name, symbol+addend. */
4229 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4236 struct reloc_list
*reloc
;
4237 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4238 static const struct _bfd_rel bfd_relocs
[] =
4240 { "NONE", BFD_RELOC_NONE
},
4241 { "8", BFD_RELOC_8
},
4242 { "16", BFD_RELOC_16
},
4243 { "32", BFD_RELOC_32
},
4244 { "64", BFD_RELOC_64
}
4247 reloc
= XNEW (struct reloc_list
);
4250 stop
= mri_comment_field (&stopc
);
4259 as_bad (_("missing or bad offset expression"));
4262 exp
.X_add_symbol
= section_symbol (now_seg
);
4263 /* Mark the section symbol used in relocation so that it will be
4264 included in the symbol table. */
4265 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4266 exp
.X_op
= O_symbol
;
4269 if (exp
.X_add_number
== 0)
4271 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4276 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4281 if (*input_line_pointer
!= ',')
4283 as_bad (_("missing reloc type"));
4287 ++input_line_pointer
;
4289 c
= get_symbol_name (& r_name
);
4290 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4294 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4295 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4297 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4298 bfd_relocs
[i
].code
);
4303 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4304 *input_line_pointer
= c
;
4305 if (reloc
->u
.a
.howto
== NULL
)
4307 as_bad (_("unrecognized reloc type"));
4311 exp
.X_op
= O_absent
;
4312 SKIP_WHITESPACE_AFTER_NAME ();
4313 if (*input_line_pointer
== ',')
4315 ++input_line_pointer
;
4323 as_bad (_("bad reloc expression"));
4325 ignore_rest_of_line ();
4328 mri_comment_end (stop
, stopc
);
4331 reloc
->u
.a
.sym
= NULL
;
4332 reloc
->u
.a
.addend
= 0;
4335 reloc
->u
.a
.sym
= NULL
;
4336 reloc
->u
.a
.addend
= exp
.X_add_number
;
4339 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4340 reloc
->u
.a
.addend
= exp
.X_add_number
;
4343 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4344 reloc
->u
.a
.addend
= 0;
4348 reloc
->file
= as_where (&reloc
->line
);
4349 reloc
->next
= reloc_list
;
4352 demand_empty_rest_of_line ();
4354 mri_comment_end (stop
, stopc
);
4357 /* Put the contents of expression EXP into the object file using
4358 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4361 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4363 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4367 emit_expr_with_reloc (expressionS
*exp
,
4368 unsigned int nbytes
,
4369 TC_PARSE_CONS_RETURN_TYPE reloc
)
4373 valueT extra_digit
= 0;
4375 /* Don't do anything if we are going to make another pass. */
4380 dot_value
= frag_now_fix ();
4381 dot_frag
= frag_now
;
4385 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4386 appear as a four byte positive constant in the .line section,
4387 followed by a 2 byte 0xffff. Look for that case here. */
4388 if (strcmp (segment_name (now_seg
), ".line") != 0)
4390 else if (dwarf_line
>= 0
4392 && exp
->X_op
== O_constant
4393 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4394 listing_source_line ((unsigned int) dwarf_line
);
4395 else if (nbytes
== 4
4396 && exp
->X_op
== O_constant
4397 && exp
->X_add_number
>= 0)
4398 dwarf_line
= exp
->X_add_number
;
4402 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4403 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4404 AT_sibling (0x12) followed by a four byte address of the sibling
4405 followed by a 2 byte AT_name (0x38) followed by the name of the
4406 file. We look for that case here. */
4407 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4409 else if (dwarf_file
== 0
4411 && exp
->X_op
== O_constant
4412 && exp
->X_add_number
== 0x11)
4414 else if (dwarf_file
== 1
4416 && exp
->X_op
== O_constant
4417 && exp
->X_add_number
== 0x12)
4419 else if (dwarf_file
== 2
4422 else if (dwarf_file
== 3
4424 && exp
->X_op
== O_constant
4425 && exp
->X_add_number
== 0x38)
4430 /* The variable dwarf_file_string tells stringer that the string
4431 may be the name of the source file. */
4432 if (dwarf_file
== 4)
4433 dwarf_file_string
= 1;
4435 dwarf_file_string
= 0;
4439 if (check_eh_frame (exp
, &nbytes
))
4444 /* Handle a negative bignum. */
4446 && exp
->X_add_number
== 0
4447 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4448 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4451 unsigned long carry
;
4453 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4455 /* Negate the bignum: one's complement each digit and add 1. */
4457 for (i
= 0; i
< exp
->X_add_number
; i
++)
4461 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4464 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4465 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4468 /* We can ignore any carry out, because it will be handled by
4469 extra_digit if it is needed. */
4471 extra_digit
= (valueT
) -1;
4475 if (op
== O_absent
|| op
== O_illegal
)
4477 as_warn (_("zero assumed for missing expression"));
4478 exp
->X_add_number
= 0;
4481 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4483 as_bad (_("floating point number invalid"));
4484 exp
->X_add_number
= 0;
4487 else if (op
== O_register
)
4489 as_warn (_("register value used as expression"));
4493 /* Allow `.word 0' in the absolute section. */
4494 if (now_seg
== absolute_section
)
4496 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4497 as_bad (_("attempt to store value in absolute section"));
4498 abs_section_offset
+= nbytes
;
4502 /* Allow `.word 0' in BSS style sections. */
4503 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4504 as_bad (_("attempt to store non-zero value in section `%s'"),
4505 segment_name (now_seg
));
4507 p
= frag_more ((int) nbytes
);
4509 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4511 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4515 #ifndef WORKING_DOT_WORD
4516 /* If we have the difference of two symbols in a word, save it on
4517 the broken_words list. See the code in write.c. */
4518 if (op
== O_subtract
&& nbytes
== 2)
4520 struct broken_word
*x
;
4522 x
= XNEW (struct broken_word
);
4523 x
->next_broken_word
= broken_words
;
4526 x
->subseg
= now_subseg
;
4528 x
->word_goes_here
= p
;
4530 x
->add
= exp
->X_add_symbol
;
4531 x
->sub
= exp
->X_op_symbol
;
4532 x
->addnum
= exp
->X_add_number
;
4540 /* If we have an integer, but the number of bytes is too large to
4541 pass to md_number_to_chars, handle it as a bignum. */
4542 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4544 extra_digit
= exp
->X_unsigned
? 0 : -1;
4545 convert_to_bignum (exp
, !exp
->X_unsigned
);
4549 if (op
== O_constant
)
4556 /* JF << of >= number of bits in the object is undefined. In
4557 particular SPARC (Sun 4) has problems. */
4558 if (nbytes
>= sizeof (valueT
))
4560 know (nbytes
== sizeof (valueT
));
4565 /* Don't store these bits. */
4566 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4569 unmask
= ~mask
; /* Do store these bits. */
4572 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4573 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4576 get
= exp
->X_add_number
;
4578 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4580 /* Leading bits contain both 0s & 1s. */
4581 as_warn (_("value 0x%" PRIx64
" truncated to 0x%" PRIx64
),
4582 (uint64_t) get
, (uint64_t) use
);
4584 /* Put bytes in right order. */
4585 md_number_to_chars (p
, use
, (int) nbytes
);
4587 else if (op
== O_big
)
4590 LITTLENUM_TYPE
*nums
;
4592 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4595 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4599 LITTLENUM_TYPE sign
= 0;
4600 if ((generic_bignum
[--i
]
4601 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4602 sign
= ~(LITTLENUM_TYPE
) 0;
4604 while (++i
< exp
->X_add_number
)
4605 if (generic_bignum
[i
] != sign
)
4608 else if (nbytes
== 1)
4610 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4611 Check that bits 8.. of generic_bignum[0] match bit 7
4612 and that they match all of generic_bignum[1..exp->X_add_number]. */
4613 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4614 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4616 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4618 while (++i
< exp
->X_add_number
)
4619 if (generic_bignum
[i
] != sign
)
4624 if (i
< exp
->X_add_number
)
4625 as_warn (ngettext ("bignum truncated to %d byte",
4626 "bignum truncated to %d bytes",
4634 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4637 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4639 if (target_big_endian
)
4641 while (nbytes
> size
)
4643 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4644 nbytes
-= CHARS_PER_LITTLENUM
;
4645 p
+= CHARS_PER_LITTLENUM
;
4648 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4649 while (size
>= CHARS_PER_LITTLENUM
)
4652 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4653 size
-= CHARS_PER_LITTLENUM
;
4654 p
+= CHARS_PER_LITTLENUM
;
4659 nums
= generic_bignum
;
4660 while (size
>= CHARS_PER_LITTLENUM
)
4662 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4664 size
-= CHARS_PER_LITTLENUM
;
4665 p
+= CHARS_PER_LITTLENUM
;
4666 nbytes
-= CHARS_PER_LITTLENUM
;
4669 while (nbytes
>= CHARS_PER_LITTLENUM
)
4671 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4672 nbytes
-= CHARS_PER_LITTLENUM
;
4673 p
+= CHARS_PER_LITTLENUM
;
4678 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4682 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4683 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4686 unsigned int size
= nbytes
;
4688 memset (p
, 0, size
);
4690 /* Generate a fixS to record the symbol value. */
4692 #ifdef TC_CONS_FIX_NEW
4693 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4695 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4697 reloc_howto_type
*reloc_howto
;
4699 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4700 size
= bfd_get_reloc_size (reloc_howto
);
4704 as_bad (ngettext ("%s relocations do not fit in %u byte",
4705 "%s relocations do not fit in %u bytes",
4707 reloc_howto
->name
, nbytes
);
4710 else if (target_big_endian
)
4711 offset
= nbytes
- size
;
4732 as_bad (_("unsupported BFD relocation size %u"), size
);
4735 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4740 /* Handle an MRI style string expression. */
4744 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4746 if (*input_line_pointer
!= '\''
4747 && (input_line_pointer
[1] != '\''
4748 || (*input_line_pointer
!= 'A'
4749 && *input_line_pointer
!= 'E')))
4750 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4754 unsigned int result
= 0;
4756 /* An MRI style string. Cut into as many bytes as will fit into
4757 a nbyte chunk, left justify if necessary, and separate with
4758 commas so we can try again later. */
4759 if (*input_line_pointer
== 'A')
4760 ++input_line_pointer
;
4761 else if (*input_line_pointer
== 'E')
4763 as_bad (_("EBCDIC constants are not supported"));
4764 ++input_line_pointer
;
4767 input_line_pointer
++;
4768 for (scan
= 0; scan
< nbytes
; scan
++)
4770 if (*input_line_pointer
== '\'')
4772 if (input_line_pointer
[1] == '\'')
4774 input_line_pointer
++;
4779 result
= (result
<< 8) | (*input_line_pointer
++);
4783 while (scan
< nbytes
)
4789 /* Create correct expression. */
4790 exp
->X_op
= O_constant
;
4791 exp
->X_add_number
= result
;
4793 /* Fake it so that we can read the next char too. */
4794 if (input_line_pointer
[0] != '\'' ||
4795 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4797 input_line_pointer
-= 2;
4798 input_line_pointer
[0] = ',';
4799 input_line_pointer
[1] = '\'';
4802 input_line_pointer
++;
4805 #endif /* TC_M68K */
4807 #ifdef REPEAT_CONS_EXPRESSIONS
4809 /* Parse a repeat expression for cons. This is used by the MIPS
4810 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4811 object file COUNT times.
4813 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4816 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4823 if (*input_line_pointer
!= ':')
4825 /* No repeat count. */
4829 ++input_line_pointer
;
4830 expression (&count
);
4831 if (count
.X_op
!= O_constant
4832 || count
.X_add_number
<= 0)
4834 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4838 /* The cons function is going to output this expression once. So we
4839 output it count - 1 times. */
4840 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4841 emit_expr (exp
, nbytes
);
4844 #endif /* REPEAT_CONS_EXPRESSIONS */
4846 /* Parse a floating point number represented as a hex constant. This
4847 permits users to specify the exact bits they want in the floating
4851 hex_float (int float_type
, char *bytes
)
4853 int pad
, length
= float_length (float_type
, &pad
);
4859 /* It would be nice if we could go through expression to parse the
4860 hex constant, but if we get a bignum it's a pain to sort it into
4861 the buffer correctly. */
4863 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4867 /* The MRI assembler accepts arbitrary underscores strewn about
4868 through the hex constant, so we ignore them as well. */
4869 if (*input_line_pointer
== '_')
4871 ++input_line_pointer
;
4877 as_warn (_("floating point constant too large"));
4880 d
= hex_value (*input_line_pointer
) << 4;
4881 ++input_line_pointer
;
4882 while (*input_line_pointer
== '_')
4883 ++input_line_pointer
;
4884 if (hex_p (*input_line_pointer
))
4886 d
+= hex_value (*input_line_pointer
);
4887 ++input_line_pointer
;
4889 if (target_big_endian
)
4892 bytes
[length
- i
- 1] = d
;
4898 if (target_big_endian
)
4899 memset (bytes
+ i
, 0, length
- i
);
4901 memset (bytes
, 0, length
- i
);
4904 memset (bytes
+ length
, 0, pad
);
4906 return length
+ pad
;
4911 CONStruct some more frag chars of .floats .ffloats etc.
4912 Makes 0 or more new frags.
4913 If need_pass_2 == 1, no frags are emitted.
4914 This understands only floating literals, not expressions. Sorry.
4916 A floating constant is defined by atof_generic(), except it is preceded
4917 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4918 reading, I decided to be incompatible. This always tries to give you
4919 rounded bits to the precision of the pseudo-op. Former AS did premature
4920 truncation, restored noisy bits instead of trailing 0s AND gave you
4921 a choice of 2 flavours of noise according to which of 2 floating-point
4922 scanners you directed AS to use.
4924 In: input_line_pointer->whitespace before, or '0' of flonum. */
4927 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4928 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4931 int length
; /* Number of chars in an object. */
4932 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4934 if (is_it_end_of_statement ())
4936 demand_empty_rest_of_line ();
4940 if (now_seg
== absolute_section
)
4942 as_bad (_("attempt to store float in absolute section"));
4943 ignore_rest_of_line ();
4949 as_bad (_("attempt to store float in section `%s'"),
4950 segment_name (now_seg
));
4951 ignore_rest_of_line ();
4955 #ifdef md_flush_pending_output
4956 md_flush_pending_output ();
4959 #ifdef md_cons_align
4965 length
= parse_one_float (float_type
, temp
);
4975 #ifdef REPEAT_CONS_EXPRESSIONS
4976 if (*input_line_pointer
== ':')
4978 expressionS count_exp
;
4980 ++input_line_pointer
;
4981 expression (&count_exp
);
4983 if (count_exp
.X_op
!= O_constant
4984 || count_exp
.X_add_number
<= 0)
4985 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4987 count
= count_exp
.X_add_number
;
4991 while (--count
>= 0)
4993 p
= frag_more (length
);
4994 memcpy (p
, temp
, (unsigned int) length
);
4999 while (*input_line_pointer
++ == ',');
5001 /* Put terminator back into stream. */
5002 --input_line_pointer
;
5003 demand_empty_rest_of_line ();
5008 Note - we are using the DWARF standard's definition of LEB128 encoding
5009 where each 7-bit value is a stored in a byte, *not* an octet. This
5010 means that on targets where a byte contains multiple octets there is
5011 a *huge waste of space*. (This also means that we do not have to
5012 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5015 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5016 we would then have to consider whether multiple, successive LEB128
5017 values should be packed into the bytes without padding (bad idea) or
5018 whether each LEB128 number is padded out to a whole number of bytes.
5019 Plus you have to decide on the endianness of packing octets into a
5022 /* Return the size of a LEB128 value in bytes. */
5024 static inline unsigned int
5025 sizeof_sleb128 (offsetT value
)
5032 byte
= (value
& 0x7f);
5033 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5034 Fortunately, we can structure things so that the extra work reduces
5035 to a noop on systems that do things "properly". */
5036 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5039 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5040 || ((value
== -1) && ((byte
& 0x40) != 0))));
5045 static inline unsigned int
5046 sizeof_uleb128 (valueT value
)
5061 sizeof_leb128 (valueT value
, int sign
)
5064 return sizeof_sleb128 ((offsetT
) value
);
5066 return sizeof_uleb128 (value
);
5069 /* Output a LEB128 value. Returns the number of bytes used. */
5071 static inline unsigned int
5072 output_sleb128 (char *p
, offsetT value
)
5079 unsigned byte
= (value
& 0x7f);
5081 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5082 Fortunately, we can structure things so that the extra work reduces
5083 to a noop on systems that do things "properly". */
5084 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5086 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5087 || ((value
== -1) && ((byte
& 0x40) != 0))));
5098 static inline unsigned int
5099 output_uleb128 (char *p
, valueT value
)
5105 unsigned byte
= (value
& 0x7f);
5109 /* More bytes to follow. */
5120 output_leb128 (char *p
, valueT value
, int sign
)
5123 return output_sleb128 (p
, (offsetT
) value
);
5125 return output_uleb128 (p
, value
);
5128 /* Do the same for bignums. We combine sizeof with output here in that
5129 we don't output for NULL values of P. It isn't really as critical as
5130 for "normal" values that this be streamlined. Returns the number of
5133 static inline unsigned int
5134 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5141 /* Strip leading sign extensions off the bignum. */
5143 && bignum
[size
- 1] == LITTLENUM_MASK
5144 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5149 /* OR in the next part of the littlenum. */
5150 val
|= (*bignum
<< loaded
);
5151 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5155 /* Add bytes until there are less than 7 bits left in VAL
5156 or until every non-sign bit has been written. */
5163 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5170 while ((byte
& 0x80) != 0 && loaded
>= 7);
5174 /* Mop up any left-over bits (of which there will be less than 7). */
5175 if ((byte
& 0x80) != 0)
5177 /* Sign-extend VAL. */
5178 if (val
& (1 << (loaded
- 1)))
5179 val
|= ~0U << loaded
;
5188 static inline unsigned int
5189 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5196 /* Strip leading zeros off the bignum. */
5197 /* XXX: Is this needed? */
5198 while (size
> 0 && bignum
[size
- 1] == 0)
5203 if (loaded
< 7 && size
> 0)
5205 val
|= (*bignum
<< loaded
);
5206 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5215 if (size
> 0 || val
)
5222 while (byte
& 0x80);
5228 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5231 return output_big_sleb128 (p
, bignum
, size
);
5233 return output_big_uleb128 (p
, bignum
, size
);
5236 /* Generate the appropriate fragments for a given expression to emit a
5237 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5240 emit_leb128_expr (expressionS
*exp
, int sign
)
5242 operatorT op
= exp
->X_op
;
5243 unsigned int nbytes
;
5245 if (op
== O_absent
|| op
== O_illegal
)
5247 as_warn (_("zero assumed for missing expression"));
5248 exp
->X_add_number
= 0;
5251 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5253 as_bad (_("floating point number invalid"));
5254 exp
->X_add_number
= 0;
5257 else if (op
== O_register
)
5259 as_warn (_("register value used as expression"));
5262 else if (op
== O_constant
5264 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5266 /* We're outputting a signed leb128 and the sign of X_add_number
5267 doesn't reflect the sign of the original value. Convert EXP
5268 to a correctly-extended bignum instead. */
5269 convert_to_bignum (exp
, exp
->X_extrabit
);
5273 if (now_seg
== absolute_section
)
5275 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5276 as_bad (_("attempt to store value in absolute section"));
5277 abs_section_offset
++;
5281 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5282 as_bad (_("attempt to store non-zero value in section `%s'"),
5283 segment_name (now_seg
));
5285 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5286 a signal that this is leb128 data. It shouldn't optimize this away. */
5287 nbytes
= (unsigned int) -1;
5288 if (check_eh_frame (exp
, &nbytes
))
5291 /* Let the backend know that subsequent data may be byte aligned. */
5292 #ifdef md_cons_align
5296 if (op
== O_constant
)
5298 /* If we've got a constant, emit the thing directly right now. */
5300 valueT value
= exp
->X_add_number
;
5304 size
= sizeof_leb128 (value
, sign
);
5305 p
= frag_more (size
);
5306 if (output_leb128 (p
, value
, sign
) > size
)
5309 else if (op
== O_big
)
5311 /* O_big is a different sort of constant. */
5312 int nbr_digits
= exp
->X_add_number
;
5316 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5317 a signed number. Unary operators like - or ~ always extend the
5318 bignum to its largest size. */
5320 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5321 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5322 generic_bignum
[nbr_digits
++] = 0;
5324 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5325 p
= frag_more (size
);
5326 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5331 /* Otherwise, we have to create a variable sized fragment and
5332 resolve things later. */
5334 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5335 make_expr_symbol (exp
), 0, (char *) NULL
);
5339 /* Parse the .sleb128 and .uleb128 pseudos. */
5346 #ifdef md_flush_pending_output
5347 md_flush_pending_output ();
5353 emit_leb128_expr (&exp
, sign
);
5355 while (*input_line_pointer
++ == ',');
5357 input_line_pointer
--;
5358 demand_empty_rest_of_line ();
5362 stringer_append_char (int c
, int bitsize
)
5365 as_bad (_("attempt to store non-empty string in section `%s'"),
5366 segment_name (now_seg
));
5368 if (!target_big_endian
)
5369 FRAG_APPEND_1_CHAR (c
);
5374 FRAG_APPEND_1_CHAR (0);
5375 FRAG_APPEND_1_CHAR (0);
5376 FRAG_APPEND_1_CHAR (0);
5377 FRAG_APPEND_1_CHAR (0);
5380 FRAG_APPEND_1_CHAR (0);
5381 FRAG_APPEND_1_CHAR (0);
5384 FRAG_APPEND_1_CHAR (0);
5389 /* Called with invalid bitsize argument. */
5393 if (target_big_endian
)
5394 FRAG_APPEND_1_CHAR (c
);
5397 /* Worker to do .ascii etc statements.
5398 Reads 0 or more ',' separated, double-quoted strings.
5399 Caller should have checked need_pass_2 is FALSE because we don't
5401 Checks for end-of-line.
5402 BITS_APPENDZERO says how many bits are in a target char.
5403 The bottom bit is set if a NUL char should be appended to the strings. */
5406 stringer (int bits_appendzero
)
5408 const int bitsize
= bits_appendzero
& ~7;
5409 const int append_zero
= bits_appendzero
& 1;
5411 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5415 #ifdef md_flush_pending_output
5416 md_flush_pending_output ();
5419 #ifdef md_cons_align
5423 /* If we have been switched into the abs_section then we
5424 will not have an obstack onto which we can hang strings. */
5425 if (now_seg
== absolute_section
)
5427 as_bad (_("strings must be placed into a section"));
5428 ignore_rest_of_line ();
5432 /* The following awkward logic is to parse ZERO or more strings,
5433 comma separated. Recall a string expression includes spaces
5434 before the opening '\"' and spaces after the closing '\"'.
5435 We fake a leading ',' if there is (supposed to be)
5436 a 1st, expression. We keep demanding expressions for each ','. */
5437 if (is_it_end_of_statement ())
5439 c
= 0; /* Skip loop. */
5440 ++input_line_pointer
; /* Compensate for end of loop. */
5444 c
= ','; /* Do loop. */
5447 while (c
== ',' || c
== '<' || c
== '"')
5450 switch (*input_line_pointer
)
5453 ++input_line_pointer
; /*->1st char of string. */
5454 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5455 start
= input_line_pointer
;
5458 while (is_a_char (c
= next_char_of_string ()))
5459 stringer_append_char (c
, bitsize
);
5461 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5462 SKIP_ALL_WHITESPACE ();
5463 if (*input_line_pointer
== '"')
5467 stringer_append_char (0, bitsize
);
5469 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5470 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5471 will emit .string with a filename in the .debug section
5472 after a sequence of constants. See the comment in
5473 emit_expr for the sequence. emit_expr will set
5474 dwarf_file_string to non-zero if this string might be a
5475 source file name. */
5476 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5477 dwarf_file_string
= 0;
5478 else if (dwarf_file_string
)
5480 c
= input_line_pointer
[-1];
5481 input_line_pointer
[-1] = '\0';
5482 listing_source_file (start
);
5483 input_line_pointer
[-1] = c
;
5489 input_line_pointer
++;
5490 c
= get_single_number ();
5491 stringer_append_char (c
, bitsize
);
5492 if (*input_line_pointer
!= '>')
5494 as_bad (_("expected <nn>"));
5495 ignore_rest_of_line ();
5498 input_line_pointer
++;
5501 input_line_pointer
++;
5505 c
= *input_line_pointer
;
5508 demand_empty_rest_of_line ();
5511 /* FIXME-SOMEDAY: I had trouble here on characters with the
5512 high bits set. We'll probably also have trouble with
5513 multibyte chars, wide chars, etc. Also be careful about
5514 returning values bigger than 1 byte. xoxorich. */
5517 next_char_of_string (void)
5521 c
= *input_line_pointer
++ & CHAR_MASK
;
5525 /* PR 20902: Do not advance past the end of the buffer. */
5526 -- input_line_pointer
;
5535 as_warn (_("unterminated string; newline inserted"));
5536 bump_line_counters ();
5540 if (!TC_STRING_ESCAPES
)
5542 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5570 break; /* As itself. */
5586 for (i
= 0, number
= 0;
5587 ISDIGIT (c
) && i
< 3;
5588 c
= *input_line_pointer
++, i
++)
5590 number
= number
* 8 + c
- '0';
5593 c
= number
& CHAR_MASK
;
5595 --input_line_pointer
;
5604 c
= *input_line_pointer
++;
5605 while (ISXDIGIT (c
))
5608 number
= number
* 16 + c
- '0';
5609 else if (ISUPPER (c
))
5610 number
= number
* 16 + c
- 'A' + 10;
5612 number
= number
* 16 + c
- 'a' + 10;
5613 c
= *input_line_pointer
++;
5615 c
= number
& CHAR_MASK
;
5616 --input_line_pointer
;
5621 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5622 as_warn (_("unterminated string; newline inserted"));
5624 bump_line_counters ();
5628 /* Do not advance past the end of the buffer. */
5629 -- input_line_pointer
;
5635 #ifdef ONLY_STANDARD_ESCAPES
5636 as_bad (_("bad escaped character in string"));
5638 #endif /* ONLY_STANDARD_ESCAPES */
5651 get_segmented_expression (expressionS
*expP
)
5655 retval
= expression (expP
);
5656 if (expP
->X_op
== O_illegal
5657 || expP
->X_op
== O_absent
5658 || expP
->X_op
== O_big
)
5660 as_bad (_("expected address expression"));
5661 expP
->X_op
= O_constant
;
5662 expP
->X_add_number
= 0;
5663 retval
= absolute_section
;
5669 get_known_segmented_expression (expressionS
*expP
)
5671 segT retval
= get_segmented_expression (expP
);
5673 if (retval
== undefined_section
)
5675 /* There is no easy way to extract the undefined symbol from the
5677 if (expP
->X_add_symbol
!= NULL
5678 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5679 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5680 S_GET_NAME (expP
->X_add_symbol
));
5682 as_warn (_("some symbol undefined; zero assumed"));
5683 retval
= absolute_section
;
5684 expP
->X_op
= O_constant
;
5685 expP
->X_add_number
= 0;
5690 char /* Return terminator. */
5691 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5693 /* FIXME: val_pointer should probably be offsetT *. */
5694 *val_pointer
= (long) get_absolute_expression ();
5695 return (*input_line_pointer
++);
5698 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5699 Give a warning if that happens. */
5702 demand_copy_C_string (int *len_pointer
)
5706 if ((s
= demand_copy_string (len_pointer
)) != 0)
5710 for (len
= *len_pointer
; len
> 0; len
--)
5712 if (s
[len
- 1] == 0)
5716 as_bad (_("this string may not contain \'\\0\'"));
5725 /* Demand string, but return a safe (=private) copy of the string.
5726 Return NULL if we can't read a string here. */
5729 demand_copy_string (int *lenP
)
5737 if (*input_line_pointer
== '\"')
5739 input_line_pointer
++; /* Skip opening quote. */
5741 while (is_a_char (c
= next_char_of_string ()))
5743 obstack_1grow (¬es
, c
);
5746 /* JF this next line is so demand_copy_C_string will return a
5747 null terminated string. */
5748 obstack_1grow (¬es
, '\0');
5749 retval
= (char *) obstack_finish (¬es
);
5753 as_bad (_("missing string"));
5755 ignore_rest_of_line ();
5761 /* In: Input_line_pointer->next character.
5763 Do: Skip input_line_pointer over all whitespace.
5765 Out: 1 if input_line_pointer->end-of-line. */
5768 is_it_end_of_statement (void)
5771 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5775 equals (char *sym_name
, int reassign
)
5780 input_line_pointer
++;
5781 if (*input_line_pointer
== '=')
5782 input_line_pointer
++;
5783 if (reassign
< 0 && *input_line_pointer
== '=')
5784 input_line_pointer
++;
5786 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5787 input_line_pointer
++;
5790 stop
= mri_comment_field (&stopc
);
5792 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5796 demand_empty_rest_of_line ();
5797 mri_comment_end (stop
, stopc
);
5801 /* Open FILENAME, first trying the unadorned file name, then if that
5802 fails and the file name is not an absolute path, attempt to open
5803 the file in current -I include paths. PATH is a preallocated
5804 buffer which will be set to the file opened, or FILENAME if no file
5808 search_and_open (const char *filename
, char *path
)
5810 FILE *f
= fopen (filename
, FOPEN_RB
);
5811 if (f
== NULL
&& !IS_ABSOLUTE_PATH (filename
))
5813 for (size_t i
= 0; i
< include_dir_count
; i
++)
5815 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5816 f
= fopen (path
, FOPEN_RB
);
5821 strcpy (path
, filename
);
5825 /* .incbin -- include a file verbatim at the current location. */
5828 s_incbin (int x ATTRIBUTE_UNUSED
)
5839 #ifdef md_flush_pending_output
5840 md_flush_pending_output ();
5843 #ifdef md_cons_align
5848 filename
= demand_copy_string (& len
);
5849 if (filename
== NULL
)
5854 /* Look for optional skip and count. */
5855 if (* input_line_pointer
== ',')
5857 ++ input_line_pointer
;
5858 skip
= get_absolute_expression ();
5862 if (* input_line_pointer
== ',')
5864 ++ input_line_pointer
;
5866 count
= get_absolute_expression ();
5868 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5874 demand_empty_rest_of_line ();
5876 path
= XNEWVEC (char, len
+ include_dir_maxlen
+ 2);
5877 binfile
= search_and_open (filename
, path
);
5879 if (binfile
== NULL
)
5880 as_bad (_("file not found: %s"), filename
);
5884 struct stat filestat
;
5886 if (fstat (fileno (binfile
), &filestat
) != 0
5887 || ! S_ISREG (filestat
.st_mode
)
5888 || S_ISDIR (filestat
.st_mode
))
5890 as_bad (_("unable to include `%s'"), path
);
5894 register_dependency (path
);
5896 /* Compute the length of the file. */
5897 if (fseek (binfile
, 0, SEEK_END
) != 0)
5899 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5902 file_len
= ftell (binfile
);
5904 /* If a count was not specified use the remainder of the file. */
5906 count
= file_len
- skip
;
5908 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5910 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5911 skip
, count
, file_len
);
5915 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5917 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5921 /* Allocate frag space and store file contents in it. */
5922 binfrag
= frag_more (count
);
5924 bytes
= fread (binfrag
, 1, count
, binfile
);
5926 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5927 path
, bytes
, count
);
5930 if (binfile
!= NULL
)
5935 /* .include -- include a file at this point. */
5938 s_include (int arg ATTRIBUTE_UNUSED
)
5947 filename
= demand_copy_string (&i
);
5948 if (filename
== NULL
)
5950 /* demand_copy_string has already printed an error and
5951 called ignore_rest_of_line. */
5959 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5960 && *input_line_pointer
!= ' '
5961 && *input_line_pointer
!= '\t')
5963 obstack_1grow (¬es
, *input_line_pointer
);
5964 ++input_line_pointer
;
5968 obstack_1grow (¬es
, '\0');
5969 filename
= (char *) obstack_finish (¬es
);
5970 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5971 ++input_line_pointer
;
5974 demand_empty_rest_of_line ();
5976 path
= notes_alloc (i
+ include_dir_maxlen
+ 2);
5977 try_file
= search_and_open (filename
, path
);
5981 register_dependency (path
);
5982 input_scrub_insert_file (path
);
5986 init_include_dir (void)
5988 include_dirs
= XNEWVEC (const char *, 1);
5989 include_dirs
[0] = "."; /* Current dir. */
5990 include_dir_count
= 1;
5991 include_dir_maxlen
= 1;
5995 add_include_dir (char *path
)
5997 include_dir_count
++;
5998 include_dirs
= XRESIZEVEC (const char *, include_dirs
, include_dir_count
);
5999 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6001 size_t i
= strlen (path
);
6002 if (i
> include_dir_maxlen
)
6003 include_dir_maxlen
= i
;
6006 /* Output debugging information to denote the source file. */
6009 generate_file_debug (void)
6011 if (debug_type
== DEBUG_STABS
)
6012 stabs_generate_asm_file ();
6015 /* Output line number debugging information for the current source line. */
6018 generate_lineno_debug (void)
6022 case DEBUG_UNSPECIFIED
:
6027 stabs_generate_asm_lineno ();
6030 ecoff_generate_asm_lineno ();
6033 /* ??? We could here indicate to dwarf2dbg.c that something
6034 has changed. However, since there is additional backend
6035 support that is required (calling dwarf2_emit_insn), we
6036 let dwarf2dbg.c call as_where on its own. */
6038 case DEBUG_CODEVIEW
:
6039 codeview_generate_asm_lineno ();
6044 /* Output debugging information to mark a function entry point or end point.
6045 END_P is zero for .func, and non-zero for .endfunc. */
6050 do_s_func (end_p
, NULL
);
6053 /* Subroutine of s_func so targets can choose a different default prefix.
6054 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6057 do_s_func (int end_p
, const char *default_prefix
)
6061 if (current_name
== NULL
)
6063 as_bad (_("missing .func"));
6064 ignore_rest_of_line ();
6068 if (debug_type
== DEBUG_STABS
)
6069 stabs_generate_asm_endfunc (current_name
, current_label
);
6071 free (current_name
);
6072 free (current_label
);
6073 current_name
= current_label
= NULL
;
6078 char delim1
, delim2
;
6080 if (current_name
!= NULL
)
6082 as_bad (_(".endfunc missing for previous .func"));
6083 ignore_rest_of_line ();
6087 delim1
= get_symbol_name (& name
);
6088 name
= xstrdup (name
);
6089 *input_line_pointer
= delim1
;
6090 SKIP_WHITESPACE_AFTER_NAME ();
6091 if (*input_line_pointer
!= ',')
6095 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6096 as_fatal ("%s", xstrerror (errno
));
6100 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6101 /* Missing entry point, use function's name with the leading
6105 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6106 as_fatal ("%s", xstrerror (errno
));
6109 label
= xstrdup (name
);
6114 ++input_line_pointer
;
6116 delim2
= get_symbol_name (& label
);
6117 label
= xstrdup (label
);
6118 restore_line_pointer (delim2
);
6121 if (debug_type
== DEBUG_STABS
)
6122 stabs_generate_asm_func (name
, label
);
6124 current_name
= name
;
6125 current_label
= label
;
6128 demand_empty_rest_of_line ();
6131 #ifdef HANDLE_BUNDLE
6134 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6136 unsigned int align
= get_absolute_expression ();
6138 demand_empty_rest_of_line ();
6140 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6141 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6142 (unsigned int) TC_ALIGN_LIMIT
);
6144 if (bundle_lock_frag
!= NULL
)
6146 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6150 bundle_align_p2
= align
;
6154 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6156 demand_empty_rest_of_line ();
6158 if (bundle_align_p2
== 0)
6160 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6164 if (bundle_lock_depth
== 0)
6166 bundle_lock_frchain
= frchain_now
;
6167 bundle_lock_frag
= start_bundle ();
6169 ++bundle_lock_depth
;
6173 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6177 demand_empty_rest_of_line ();
6179 if (bundle_lock_frag
== NULL
)
6181 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6185 gas_assert (bundle_align_p2
> 0);
6187 gas_assert (bundle_lock_depth
> 0);
6188 if (--bundle_lock_depth
> 0)
6191 size
= pending_bundle_size (bundle_lock_frag
);
6193 if (size
> 1U << bundle_align_p2
)
6194 as_bad (_(".bundle_lock sequence is %u bytes, "
6195 "but bundle size is only %u bytes"),
6196 size
, 1u << bundle_align_p2
);
6198 finish_bundle (bundle_lock_frag
, size
);
6200 bundle_lock_frag
= NULL
;
6201 bundle_lock_frchain
= NULL
;
6204 #endif /* HANDLE_BUNDLE */
6207 s_ignore (int arg ATTRIBUTE_UNUSED
)
6209 ignore_rest_of_line ();
6213 read_print_statistics (FILE *file
)
6215 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6218 /* Inserts the given line into the input stream.
6220 This call avoids macro/conditionals nesting checking, since the contents of
6221 the line are assumed to replace the contents of a line already scanned.
6223 An appropriate use of this function would be substitution of input lines when
6224 called by md_start_line_hook(). The given line is assumed to already be
6225 properly scrubbed. */
6228 input_scrub_insert_line (const char *line
)
6231 size_t len
= strlen (line
);
6232 sb_build (&newline
, len
);
6233 sb_add_buffer (&newline
, line
, len
);
6234 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6236 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6239 /* Insert a file into the input stream; the path must resolve to an actual
6240 file; no include path searching or dependency registering is performed. */
6243 input_scrub_insert_file (char *path
)
6245 input_scrub_include_file (path
, input_line_pointer
);
6246 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6249 /* Find the end of a line, considering quotation and escaping of quotes. */
6251 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6252 # define TC_SINGLE_QUOTE_STRINGS 1
6256 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6259 char inquote
= '\0';
6262 while (!is_end_of_line
[(unsigned char) *s
]
6263 || (inquote
&& !ISCNTRL (*s
))
6264 || (inquote
== '\'' && flag_mri
)
6265 #ifdef TC_EOL_IN_INSN
6266 || (insn
&& TC_EOL_IN_INSN (s
))
6268 /* PR 6926: When we are parsing the body of a macro the sequence
6269 \@ is special - it refers to the invocation count. If the @
6270 character happens to be registered as a line-separator character
6271 by the target, then the is_end_of_line[] test above will have
6272 returned true, but we need to ignore the line separating
6273 semantics in this particular case. */
6274 || (in_macro
&& inescape
&& *s
== '@')
6277 if (mri_string
&& *s
== '\'')
6281 else if (*s
== '\\')
6285 #ifdef TC_SINGLE_QUOTE_STRINGS
6286 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6293 as_warn (_("missing closing `%c'"), inquote
);
6294 if (inescape
&& !ignore_input ())
6295 as_warn (_("stray `\\'"));
6300 find_end_of_line (char *s
, int mri_string
)
6302 return _find_end_of_line (s
, mri_string
, 0, 0);
6305 static char *saved_ilp
;
6306 static char *saved_limit
;
6308 /* Use BUF as a temporary input pointer for calling other functions in this
6309 file. BUF must be a C string, so that its end can be found by strlen.
6310 Also sets the buffer_limit variable (local to this file) so that buffer
6311 overruns should not occur. Saves the current input line pointer so that
6312 it can be restored by calling restore_ilp().
6314 Does not support recursion. */
6317 temp_ilp (char *buf
)
6319 gas_assert (saved_ilp
== NULL
);
6320 gas_assert (buf
!= NULL
);
6322 saved_ilp
= input_line_pointer
;
6323 saved_limit
= buffer_limit
;
6324 /* Prevent the assert in restore_ilp from triggering if
6325 the input_line_pointer has not yet been initialised. */
6326 if (saved_ilp
== NULL
)
6327 saved_limit
= saved_ilp
= (char *) "";
6329 input_line_pointer
= buf
;
6330 buffer_limit
= buf
+ strlen (buf
);
6331 input_from_string
= true;
6334 /* Restore a saved input line pointer. */
6339 gas_assert (saved_ilp
!= NULL
);
6341 input_line_pointer
= saved_ilp
;
6342 buffer_limit
= saved_limit
;
6343 input_from_string
= false;