1 /* read.c - read a source file -
2 Copyright (C) 1986-2023 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"
43 #include "filenames.h"
47 #ifndef TC_START_LABEL
48 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
51 /* Set by the object-format or the target. */
52 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
53 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
58 else if ((SIZE) >= 4) \
60 else if ((SIZE) >= 2) \
68 char *input_line_pointer
; /*->next char of source file to parse. */
69 bool input_from_string
= false;
71 #if BITS_PER_CHAR != 8
72 /* The following table is indexed by[(char)] and will break if
73 a char does not have exactly 256 states (hopefully 0:255!)! */
82 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
87 /* The Delta 68k assembler permits % inside label names. */
92 /* The PowerPC Windows NT assemblers permits ? inside label names. */
97 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
98 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
107 /* The Delta 68k assembler permits ~ at start of label names. */
111 /* Used by is_... macros. our ctype[]. */
112 char lex_type
[256] = {
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
115 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
117 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
119 0, 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
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
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
132 Out: 1 if this character ends a line.
133 2 if this character is a line separator. */
134 char is_end_of_line
[256] = {
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
138 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
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 /* */
157 #ifndef TC_CASE_SENSITIVE
158 char original_case_string
[128];
161 /* Functions private to this file. */
163 static char *buffer
; /* 1st char of each buffer of lines is here. */
164 static char *buffer_limit
; /*->1 + last char in buffer. */
166 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
167 in the tc-<CPU>.h file. See the "Porting GAS" section of the
169 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
171 /* Variables for handling include file directory table. */
173 /* Table of pointers to directories to search for .include's. */
174 const char **include_dirs
;
176 /* How many are in the table. */
177 size_t include_dir_count
;
179 /* Length of longest in table. */
180 size_t include_dir_maxlen
;
182 #ifndef WORKING_DOT_WORD
183 struct broken_word
*broken_words
;
184 int new_broken_words
;
187 /* The current offset into the absolute section. We don't try to
188 build frags in the absolute section, since no data can be stored
189 there. We just keep track of the current offset. */
190 addressT abs_section_offset
;
192 /* If this line had an MRI style label, it is stored in this variable.
193 This is used by some of the MRI pseudo-ops. */
196 /* This global variable is used to support MRI common sections. We
197 translate such sections into a common symbol. This variable is
198 non-NULL when we are in an MRI common section. */
199 symbolS
*mri_common_symbol
;
201 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
202 need to align to an even byte boundary unless the next pseudo-op is
203 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
205 static int mri_pending_align
;
207 /* Record the current function so that we can issue an error message for
208 misplaced .func,.endfunc, and also so that .endfunc needs no
210 static char *current_name
;
211 static char *current_label
;
215 static int dwarf_file
;
216 static int dwarf_line
;
218 /* This variable is set to be non-zero if the next string we see might
219 be the name of the source file in DWARF debugging information. See
220 the comment in emit_expr for the format we look for. */
221 static int dwarf_file_string
;
225 /* If the target defines the md_frag_max_var hook then we know
226 enough to implement the .bundle_align_mode features. */
227 #ifdef md_frag_max_var
228 # define HANDLE_BUNDLE
232 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
233 it's the exponent of the bundle size, and aligned instruction bundle
234 mode is in effect. */
235 static unsigned int bundle_align_p2
;
237 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
238 bundle_lock_frag to frag_now and then starts a new frag with
239 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
240 so that .bundle_unlock can verify that we didn't change segments.
241 .bundle_unlock resets both to NULL. If we detect a bundling violation,
242 then we reset bundle_lock_frchain to NULL as an indicator that we've
243 already diagnosed the error with as_bad and don't need a cascade of
244 redundant errors, but bundle_lock_frag remains set to indicate that
245 we are expecting to see .bundle_unlock. */
246 static fragS
*bundle_lock_frag
;
247 static frchainS
*bundle_lock_frchain
;
249 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
251 static unsigned int bundle_lock_depth
;
254 static void do_s_func (int end_p
, const char *default_prefix
);
255 static void s_align (int, int);
256 static void s_altmacro (int);
257 static void s_bad_end (int);
258 static void s_reloc (int);
259 static int hex_float (int, char *);
260 static segT
get_known_segmented_expression (expressionS
* expP
);
261 static void pobegin (void);
262 static void poend (void);
263 static size_t get_non_macro_line_sb (sb
*);
264 static void generate_file_debug (void);
265 static char *_find_end_of_line (char *, int, int, int);
273 obj_read_begin_hook ();
275 obstack_begin (&cond_obstack
, chunksize
);
277 #ifndef tc_line_separator_chars
278 #define tc_line_separator_chars line_separator_chars
280 /* Use machine dependent syntax. */
281 for (p
= tc_line_separator_chars
; *p
; p
++)
282 is_end_of_line
[(unsigned char) *p
] = 2;
283 /* Use more. FIXME-SOMEDAY. */
289 #ifndef WORKING_DOT_WORD
291 new_broken_words
= 0;
294 abs_section_offset
= 0;
297 mri_common_symbol
= NULL
;
298 mri_pending_align
= 0;
301 current_label
= NULL
;
307 dwarf_file_string
= 0;
313 bundle_lock_frag
= NULL
;
314 bundle_lock_frchain
= NULL
;
315 bundle_lock_depth
= 0;
324 _obstack_free (&cond_obstack
, NULL
);
327 #ifndef TC_ADDRESS_BYTES
328 #define TC_ADDRESS_BYTES address_bytes
333 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
334 contain an address. */
335 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
343 /* Set up pseudo-op tables. */
345 static htab_t po_hash
;
347 static const pseudo_typeS potable
[] = {
348 {"abort", s_abort
, 0},
349 {"align", s_align_ptwo
, 0},
350 {"altmacro", s_altmacro
, 1},
351 {"ascii", stringer
, 8+0},
352 {"asciz", stringer
, 8+1},
353 {"balign", s_align_bytes
, 0},
354 {"balignw", s_align_bytes
, -2},
355 {"balignl", s_align_bytes
, -4},
358 {"bundle_align_mode", s_bundle_align_mode
, 0},
359 {"bundle_lock", s_bundle_lock
, 0},
360 {"bundle_unlock", s_bundle_unlock
, 0},
364 {"common", s_mri_common
, 0},
365 {"common.s", s_mri_common
, 1},
370 {"dc.d", float_cons
, 'd'},
372 {"dc.s", float_cons
, 'f'},
374 {"dc.x", float_cons
, 'x'},
376 {"dcb.b", s_space
, 1},
377 {"dcb.d", s_float_space
, 'd'},
378 {"dcb.l", s_space
, 4},
379 {"dcb.s", s_float_space
, 'f'},
380 {"dcb.w", s_space
, 2},
381 {"dcb.x", s_float_space
, 'x'},
383 {"ds.b", s_space
, 1},
384 {"ds.d", s_space
, 8},
385 {"ds.l", s_space
, 4},
386 {"ds.p", s_space
, 'p'},
387 {"ds.s", s_space
, 4},
388 {"ds.w", s_space
, 2},
389 {"ds.x", s_space
, 'x'},
390 {"debug", s_ignore
, 0},
395 {"double", float_cons
, 'd'},
397 {"eject", listing_eject
, 0}, /* Formfeed listing. */
399 {"elsec", s_else
, 0},
400 {"elseif", s_elseif
, (int) O_ne
},
402 {"endc", s_endif
, 0},
403 {"endfunc", s_func
, 1},
404 {"endif", s_endif
, 0},
405 {"endm", s_bad_end
, 0},
406 {"endr", s_bad_end
, 1},
412 {"error", s_errwarn
, 1},
413 {"exitm", s_mexit
, 0},
415 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
419 {"float", float_cons
, 'f'},
420 {"format", s_ignore
, 0},
422 {"global", s_globl
, 0},
423 {"globl", s_globl
, 0},
425 {"if", s_if
, (int) O_ne
},
428 {"ifdef", s_ifdef
, 0},
429 {"ifeq", s_if
, (int) O_eq
},
430 {"ifeqs", s_ifeqs
, 0},
431 {"ifge", s_if
, (int) O_ge
},
432 {"ifgt", s_if
, (int) O_gt
},
433 {"ifle", s_if
, (int) O_le
},
434 {"iflt", s_if
, (int) O_lt
},
437 {"ifndef", s_ifdef
, 1},
438 {"ifne", s_if
, (int) O_ne
},
439 {"ifnes", s_ifeqs
, 1},
440 {"ifnotdef", s_ifdef
, 1},
441 {"incbin", s_incbin
, 0},
442 {"include", s_include
, 0},
448 {"lcomm", s_lcomm
, 0},
449 {"lflags", s_ignore
, 0}, /* Listing flags. */
450 {"linefile", s_linefile
, 0},
451 {"linkonce", s_linkonce
, 0},
452 {"list", listing_list
, 1}, /* Turn listing on. */
453 {"llen", listing_psize
, 1},
456 {"macro", s_macro
, 0},
457 {"mexit", s_mexit
, 0},
459 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
460 {"name", s_ignore
, 0},
461 {"noaltmacro", s_altmacro
, 0},
462 {"noformat", s_ignore
, 0},
463 {"nolist", listing_list
, 0}, /* Turn listing off. */
464 {"nopage", listing_nopage
, 0},
468 {"offset", s_struct
, 0},
470 {"p2align", s_align_ptwo
, 0},
471 {"p2alignw", s_align_ptwo
, -2},
472 {"p2alignl", s_align_ptwo
, -4},
473 {"page", listing_eject
, 0},
474 {"plen", listing_psize
, 0},
475 {"print", s_print
, 0},
476 {"psize", listing_psize
, 0}, /* Set paper size. */
477 {"purgem", s_purgem
, 0},
479 {"reloc", s_reloc
, 0},
483 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
488 {"single", float_cons
, 'f'},
490 {"space", s_space
, 0},
491 {"skip", s_space
, 0},
492 {"sleb128", s_leb128
, 1},
493 {"spc", s_ignore
, 0},
494 {"stabd", s_stab
, 'd'},
495 {"stabn", s_stab
, 'n'},
496 {"stabs", s_stab
, 's'},
497 {"string", stringer
, 8+1},
498 {"string8", stringer
, 8+1},
499 {"string16", stringer
, 16+1},
500 {"string32", stringer
, 32+1},
501 {"string64", stringer
, 64+1},
502 {"struct", s_struct
, 0},
506 /* This is for gcc to use. It's only just been added (2/94), so gcc
507 won't be able to use it for a while -- probably a year or more.
508 But once this has been released, check with gcc maintainers
509 before deleting it or even changing the spelling. */
510 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
511 /* If we're folding case -- done for some targets, not necessarily
512 all -- the above string in an input file will be converted to
513 this one. Match it either way... */
514 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
516 {"title", listing_title
, 0}, /* Listing title. */
517 {"ttl", listing_title
, 0},
519 {"uleb128", s_leb128
, 0},
523 {"xdef", s_globl
, 0},
524 {"xref", s_ignore
, 0},
525 {"xstabs", s_xstab
, 's'},
526 {"warning", s_errwarn
, 0},
527 {"weakref", s_weakref
, 0},
529 {"zero", s_space
, 0},
533 {NULL
, NULL
, 0} /* End sentinel. */
537 get_absolute_expr (expressionS
*exp
)
539 expression_and_evaluate (exp
);
541 if (exp
->X_op
!= O_constant
)
543 if (exp
->X_op
!= O_absent
)
544 as_bad (_("bad or irreducible absolute expression"));
545 exp
->X_add_number
= 0;
547 return exp
->X_add_number
;
551 get_absolute_expression (void)
555 return get_absolute_expr (&exp
);
558 static int pop_override_ok
;
559 static const char *pop_table_name
;
562 pop_insert (const pseudo_typeS
*table
)
564 const pseudo_typeS
*pop
;
565 for (pop
= table
; pop
->poc_name
; pop
++)
567 if (str_hash_insert (po_hash
, pop
->poc_name
, pop
, 0) != NULL
)
569 if (!pop_override_ok
)
570 as_fatal (_("error constructing %s pseudo-op table"),
576 #ifndef md_pop_insert
577 #define md_pop_insert() pop_insert(md_pseudo_table)
580 #ifndef obj_pop_insert
581 #define obj_pop_insert() pop_insert(obj_pseudo_table)
584 #ifndef cfi_pop_insert
585 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
591 po_hash
= str_htab_create ();
593 /* Do the target-specific pseudo ops. */
594 pop_table_name
= "md";
598 /* Now object specific. Skip any that were in the target table. */
599 pop_table_name
= "obj";
603 /* Now portable ones. Skip any that we've seen already. */
604 pop_table_name
= "standard";
605 pop_insert (potable
);
608 pop_table_name
= "cfi";
615 htab_delete (po_hash
);
618 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
619 if (ignore_input ()) \
621 char *eol = find_end_of_line (input_line_pointer - (num_read), \
623 input_line_pointer = (input_line_pointer <= buffer_limit \
624 && eol >= buffer_limit) \
630 /* Helper function of read_a_source_file, which tries to expand a macro. */
632 try_macro (char term
, const char *line
)
638 if (check_macro (line
, &out
, &err
, ¯o
))
642 *input_line_pointer
++ = term
;
643 input_scrub_include_sb (&out
,
644 input_line_pointer
, expanding_macro
);
647 input_scrub_next_buffer (&input_line_pointer
);
649 md_macro_info (macro
);
657 /* Start a new instruction bundle. Returns the rs_align_code frag that
658 will be used to align the new bundle. */
662 fragS
*frag
= frag_now
;
664 frag_align_code (0, 0);
666 while (frag
->fr_type
!= rs_align_code
)
667 frag
= frag
->fr_next
;
669 gas_assert (frag
!= frag_now
);
674 /* Calculate the maximum size after relaxation of the region starting
675 at the given frag and extending through frag_now (which is unfinished). */
677 pending_bundle_size (fragS
*frag
)
679 unsigned int offset
= frag
->fr_fix
;
680 unsigned int size
= 0;
682 gas_assert (frag
!= frag_now
);
683 gas_assert (frag
->fr_type
== rs_align_code
);
685 while (frag
!= frag_now
)
687 /* This should only happen in what will later become an error case. */
691 size
+= frag
->fr_fix
;
692 if (frag
->fr_type
== rs_machine_dependent
)
693 size
+= md_frag_max_var (frag
);
695 frag
= frag
->fr_next
;
698 gas_assert (frag
== frag_now
);
699 size
+= frag_now_fix ();
700 if (frag
->fr_type
== rs_machine_dependent
)
701 size
+= md_frag_max_var (frag
);
703 gas_assert (size
>= offset
);
705 return size
- offset
;
708 /* Finish off the frag created to ensure bundle alignment. */
710 finish_bundle (fragS
*frag
, unsigned int size
)
712 gas_assert (bundle_align_p2
> 0);
713 gas_assert (frag
->fr_type
== rs_align_code
);
717 /* If there is more than a single byte, then we need to set up the
718 alignment frag. Otherwise we leave it at its initial state from
719 calling frag_align_code (0, 0), so that it does nothing. */
720 frag
->fr_offset
= bundle_align_p2
;
721 frag
->fr_subtype
= size
- 1;
724 /* We do this every time rather than just in s_bundle_align_mode
725 so that we catch any affected section without needing hooks all
726 over for all paths that do section changes. It's cheap enough. */
727 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
728 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
731 /* Assemble one instruction. This takes care of the bundle features
732 around calling md_assemble. */
734 assemble_one (char *line
)
736 fragS
*insn_start_frag
= NULL
;
738 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
740 as_bad (_("cannot change section or subsection inside .bundle_lock"));
741 /* Clearing this serves as a marker that we have already complained. */
742 bundle_lock_frchain
= NULL
;
745 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
746 insn_start_frag
= start_bundle ();
750 if (bundle_lock_frchain
!= NULL
)
752 /* Make sure this hasn't pushed the locked sequence
753 past the bundle size. */
754 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
755 if (bundle_size
> 1U << bundle_align_p2
)
756 as_bad (_ (".bundle_lock sequence at %u bytes, "
757 "but .bundle_align_mode limit is %u bytes"),
758 bundle_size
, 1U << bundle_align_p2
);
760 else if (bundle_align_p2
> 0)
762 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
764 if (insn_size
> 1U << bundle_align_p2
)
765 as_bad (_("single instruction is %u bytes long, "
766 "but .bundle_align_mode limit is %u bytes"),
767 insn_size
, 1U << bundle_align_p2
);
769 finish_bundle (insn_start_frag
, insn_size
);
773 #else /* !HANDLE_BUNDLE */
775 # define assemble_one(line) md_assemble(line)
777 #endif /* HANDLE_BUNDLE */
782 flagword flags
= bfd_section_flags (now_seg
);
784 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
787 /* Guts of .align directive:
788 N is the power of two to which to align. A value of zero is accepted but
789 ignored: the default alignment of the section will be at least this.
790 FILL may be NULL, or it may point to the bytes of the fill pattern.
791 LEN is the length of whatever FILL points to, if anything. If LEN is zero
792 but FILL is not NULL then LEN is treated as if it were one.
793 MAX is the maximum number of characters to skip when doing the alignment,
794 or 0 if there is no maximum. */
797 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
799 if (now_seg
== absolute_section
|| in_bss ())
805 if (now_seg
== absolute_section
)
806 as_warn (_("ignoring fill value in absolute section"));
808 as_warn (_("ignoring fill value in section `%s'"),
809 segment_name (now_seg
));
816 #ifdef md_flush_pending_output
817 md_flush_pending_output ();
821 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
824 /* Only make a frag if we HAVE to... */
825 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
829 if (subseg_text_p (now_seg
))
830 frag_align_code (n
, max
);
832 frag_align (n
, 0, max
);
835 frag_align (n
, *fill
, max
);
837 frag_align_pattern (n
, fill
, len
, max
);
841 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
844 if (n
> OCTETS_PER_BYTE_POWER
)
845 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
848 /* We read the file, putting things into a web that represents what we
849 have been reading. */
851 read_a_source_file (const char *name
)
855 char *s
; /* String of symbol, '\0' appended. */
857 const pseudo_typeS
*pop
;
863 buffer
= input_scrub_new_file (name
);
866 listing_newline (NULL
);
867 register_dependency (name
);
869 /* Generate debugging information before we've read anything in to denote
870 this file as the "main" source file and not a subordinate one
871 (e.g. N_SO vs N_SOL in stabs). */
872 generate_file_debug ();
874 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
875 { /* We have another line to parse. */
877 /* In order to avoid listing macro expansion lines with labels
878 multiple times, keep track of which line was last issued. */
879 char *last_eol
= NULL
;
882 while (input_line_pointer
< buffer_limit
)
885 /* We have more of this buffer to parse. */
887 /* We now have input_line_pointer->1st char of next line.
888 If input_line_pointer [-1] == '\n' then we just
889 scanned another line: so bump line counters. */
890 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
893 symbol_set_value_now (&dot_symbol
);
894 #ifdef md_start_line_hook
895 md_start_line_hook ();
897 if (input_line_pointer
[-1] == '\n')
898 bump_line_counters ();
902 /* If listing is on, and we are expanding a macro, then give
903 the listing code the contents of the expanded line. */
906 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
908 /* Find the end of the current expanded macro line. */
909 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
912 && !startswith (input_line_pointer
,
913 !flag_m68k_mri
? " .linefile "
920 /* Copy it for safe keeping. Also give an indication of
921 how much macro nesting is involved at this point. */
922 len
= s
- input_line_pointer
;
923 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
924 memset (copy
, '>', macro_nest
);
925 copy
[macro_nest
] = ' ';
926 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
927 copy
[macro_nest
+ 1 + len
] = '\0';
929 /* Install the line with the listing facility. */
930 listing_newline (copy
);
934 listing_newline (NULL
);
941 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
943 next_char
= * input_line_pointer
;
944 /* Text at the start of a line must be a label, we
945 run down and stick a colon in. */
946 if (is_name_beginner (next_char
) || next_char
== '"')
951 HANDLE_CONDITIONAL_ASSEMBLY (0);
953 nul_char
= get_symbol_name (& line_start
);
954 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
956 /* In MRI mode, the EQU and MACRO pseudoops must
957 be handled specially. */
961 char *rest
= input_line_pointer
+ 1;
965 if (*rest
== ' ' || *rest
== '\t')
967 if ((strncasecmp (rest
, "EQU", 3) == 0
968 || strncasecmp (rest
, "SET", 3) == 0)
969 && (rest
[3] == ' ' || rest
[3] == '\t'))
971 input_line_pointer
= rest
+ 3;
973 strncasecmp (rest
, "SET", 3) == 0);
976 if (strncasecmp (rest
, "MACRO", 5) == 0
979 || is_end_of_line
[(unsigned char) rest
[5]]))
983 /* In MRI mode, we need to handle the MACRO
984 pseudo-op specially: we don't want to put the
985 symbol in the symbol table. */
987 #ifdef TC_START_LABEL_WITHOUT_COLON
988 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
991 line_label
= colon (line_start
);
993 line_label
= symbol_create (line_start
,
995 &zero_address_frag
, 0);
997 next_char
= restore_line_pointer (nul_char
);
998 if (next_char
== ':')
999 input_line_pointer
++;
1004 /* We are at the beginning of a line, or similar place.
1005 We expect a well-formed assembler statement.
1006 A "symbol-name:" is a statement.
1008 Depending on what compiler is used, the order of these tests
1009 may vary to catch most common case 1st.
1010 Each test is independent of all other tests at the (top)
1013 nul_char
= next_char
= *input_line_pointer
++;
1014 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1016 /* C is the 1st significant character.
1017 Input_line_pointer points after that character. */
1018 if (is_name_beginner (next_char
) || next_char
== '"')
1022 /* Want user-defined label or pseudo/opcode. */
1023 HANDLE_CONDITIONAL_ASSEMBLY (1);
1025 --input_line_pointer
;
1026 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1027 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1028 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1030 /* NEXT_CHAR is character after symbol.
1031 The end of symbol in the input line is now '\0'.
1032 S points to the beginning of the symbol.
1033 [In case of pseudo-op, s->'.'.]
1034 Input_line_pointer->'\0' where NUL_CHAR was. */
1035 if (TC_START_LABEL (s
, nul_char
, next_char
))
1039 /* In MRI mode, \tsym: set 0 is permitted. */
1043 if (*rest
== ' ' || *rest
== '\t')
1046 if ((strncasecmp (rest
, "EQU", 3) == 0
1047 || strncasecmp (rest
, "SET", 3) == 0)
1048 && (rest
[3] == ' ' || rest
[3] == '\t'))
1050 input_line_pointer
= rest
+ 3;
1056 line_label
= colon (s
); /* User-defined label. */
1057 restore_line_pointer (nul_char
);
1058 ++ input_line_pointer
;
1059 #ifdef tc_check_label
1060 tc_check_label (line_label
);
1062 /* Input_line_pointer->after ':'. */
1065 else if ((next_char
== '=' && *rest
== '=')
1066 || ((next_char
== ' ' || next_char
== '\t')
1071 demand_empty_rest_of_line ();
1073 else if ((next_char
== '='
1074 || ((next_char
== ' ' || next_char
== '\t')
1076 #ifdef TC_EQUAL_IN_INSN
1077 && !TC_EQUAL_IN_INSN (next_char
, s
)
1082 demand_empty_rest_of_line ();
1086 /* Expect pseudo-op or machine instruction. */
1089 #ifndef TC_CASE_SENSITIVE
1093 strncpy (original_case_string
, s2
,
1094 sizeof (original_case_string
) - 1);
1095 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1099 *s2
= TOLOWER (*s2
);
1104 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1106 /* The MRI assembler uses pseudo-ops without
1108 pop
= str_hash_find (po_hash
, s
);
1109 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1114 || (!flag_m68k_mri
&& *s
== '.'))
1118 WARNING: next_char may be end-of-line.
1119 We lookup the pseudo-op table with s+1 because we
1120 already know that the pseudo-op begins with a '.'. */
1123 pop
= str_hash_find (po_hash
, s
+ 1);
1124 if (pop
&& !pop
->poc_handler
)
1127 /* In MRI mode, we may need to insert an
1128 automatic alignment directive. What a hack
1130 if (mri_pending_align
1132 || !((pop
->poc_handler
== cons
1133 && pop
->poc_val
== 1)
1134 || (pop
->poc_handler
== s_space
1135 && pop
->poc_val
== 1)
1136 #ifdef tc_conditional_pseudoop
1137 || tc_conditional_pseudoop (pop
)
1139 || pop
->poc_handler
== s_if
1140 || pop
->poc_handler
== s_ifdef
1141 || pop
->poc_handler
== s_ifc
1142 || pop
->poc_handler
== s_ifeqs
1143 || pop
->poc_handler
== s_else
1144 || pop
->poc_handler
== s_endif
1145 || pop
->poc_handler
== s_globl
1146 || pop
->poc_handler
== s_ignore
)))
1148 do_align (1, (char *) NULL
, 0, 0);
1149 mri_pending_align
= 0;
1151 if (line_label
!= NULL
)
1153 symbol_set_frag (line_label
, frag_now
);
1154 S_SET_VALUE (line_label
, frag_now_fix ());
1158 /* Print the error msg now, while we still can. */
1161 char *end
= input_line_pointer
;
1163 (void) restore_line_pointer (nul_char
);
1165 nul_char
= next_char
= *--input_line_pointer
;
1166 *input_line_pointer
= '\0';
1167 if (! macro_defined
|| ! try_macro (next_char
, s
))
1170 as_bad (_("unknown pseudo-op: `%s'"), s
);
1171 *input_line_pointer
++ = nul_char
;
1176 /* Put it back for error messages etc. */
1177 next_char
= restore_line_pointer (nul_char
);
1178 /* The following skip of whitespace is compulsory.
1179 A well shaped space is sometimes all that separates
1180 keyword from operands. */
1181 if (next_char
== ' ' || next_char
== '\t')
1182 input_line_pointer
++;
1184 /* Input_line is restored.
1185 Input_line_pointer->1st non-blank char
1186 after pseudo-operation. */
1187 (*pop
->poc_handler
) (pop
->poc_val
);
1189 /* If that was .end, just get out now. */
1190 if (pop
->poc_handler
== s_end
)
1195 /* WARNING: next_char may be end-of-line. */
1196 /* Also: input_line_pointer->`\0` where nul_char was. */
1197 (void) restore_line_pointer (nul_char
);
1198 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1199 next_char
= nul_char
= *input_line_pointer
;
1200 *input_line_pointer
= '\0';
1202 generate_lineno_debug ();
1204 if (macro_defined
&& try_macro (next_char
, s
))
1207 if (mri_pending_align
)
1209 do_align (1, (char *) NULL
, 0, 0);
1210 mri_pending_align
= 0;
1211 if (line_label
!= NULL
)
1213 symbol_set_frag (line_label
, frag_now
);
1214 S_SET_VALUE (line_label
, frag_now_fix ());
1218 assemble_one (s
); /* Assemble 1 instruction. */
1220 /* PR 19630: The backend may have set ilp to NULL
1221 if it encountered a catastrophic failure. */
1222 if (input_line_pointer
== NULL
)
1223 as_fatal (_("unable to continue with assembly."));
1225 *input_line_pointer
++ = nul_char
;
1227 /* We resume loop AFTER the end-of-line from
1228 this instruction. */
1234 /* Empty statement? */
1235 if (is_end_of_line
[(unsigned char) next_char
])
1238 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1240 /* local label ("4:") */
1241 char *backup
= input_line_pointer
;
1243 HANDLE_CONDITIONAL_ASSEMBLY (1);
1245 temp
= next_char
- '0';
1247 if (nul_char
== '"')
1248 ++ input_line_pointer
;
1250 /* Read the whole number. */
1251 while (ISDIGIT (*input_line_pointer
))
1253 const long digit
= *input_line_pointer
- '0';
1254 if (temp
> (INT_MAX
- digit
) / 10)
1256 as_bad (_("local label too large near %s"), backup
);
1260 temp
= temp
* 10 + digit
;
1261 ++input_line_pointer
;
1264 /* Overflow: stop processing the label. */
1267 ignore_rest_of_line ();
1271 if (LOCAL_LABELS_DOLLAR
1272 && *input_line_pointer
== '$'
1273 && *(input_line_pointer
+ 1) == ':')
1275 input_line_pointer
+= 2;
1277 if (dollar_label_defined (temp
))
1279 as_fatal (_("label \"%ld$\" redefined"), temp
);
1282 define_dollar_label (temp
);
1283 colon (dollar_label_name (temp
, 0));
1288 && *input_line_pointer
++ == ':')
1290 fb_label_instance_inc (temp
);
1291 colon (fb_label_name (temp
, 0));
1295 input_line_pointer
= backup
;
1298 if (next_char
&& strchr (line_comment_chars
, next_char
))
1299 { /* Its a comment. Better say APP or NO_APP. */
1304 s
= input_line_pointer
;
1305 if (!startswith (s
, "APP\n"))
1308 ignore_rest_of_line ();
1311 bump_line_counters ();
1314 ends
= strstr (s
, "#NO_APP\n");
1315 len
= ends
? ends
- s
: buffer_limit
- s
;
1317 sb_build (&sbuf
, len
+ 100);
1318 sb_add_buffer (&sbuf
, s
, len
);
1321 /* The end of the #APP wasn't in this buffer. We
1322 keep reading in buffers until we find the #NO_APP
1323 that goes with this #APP There is one. The specs
1327 buffer_limit
= input_scrub_next_buffer (&buffer
);
1330 ends
= strstr (buffer
, "#NO_APP\n");
1331 len
= ends
? ends
- buffer
: buffer_limit
- buffer
;
1332 sb_add_buffer (&sbuf
, buffer
, len
);
1337 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1338 input_scrub_include_sb (&sbuf
, input_line_pointer
, expanding_none
);
1340 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1344 HANDLE_CONDITIONAL_ASSEMBLY (1);
1346 #ifdef tc_unrecognized_line
1347 if (tc_unrecognized_line (next_char
))
1350 input_line_pointer
--;
1351 /* Report unknown char as error. */
1352 demand_empty_rest_of_line ();
1357 symbol_set_value_now (&dot_symbol
);
1359 #ifdef HANDLE_BUNDLE
1360 if (bundle_lock_frag
!= NULL
)
1362 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1363 _(".bundle_lock with no matching .bundle_unlock"));
1364 bundle_lock_frag
= NULL
;
1365 bundle_lock_frchain
= NULL
;
1366 bundle_lock_depth
= 0;
1373 /* Close the input file. */
1374 input_scrub_close ();
1375 #ifdef WARN_COMMENTS
1377 if (warn_comment
&& found_comment
)
1378 as_warn_where (found_comment_file
, found_comment
,
1379 "first comment found here");
1384 /* Convert O_constant expression EXP into the equivalent O_big representation.
1385 Take the sign of the number from SIGN rather than X_add_number. */
1388 convert_to_bignum (expressionS
*exp
, int sign
)
1393 value
= exp
->X_add_number
;
1394 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1396 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1397 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1399 /* Add a sequence of sign bits if the top bit of X_add_number is not
1400 the sign of the original value. */
1401 if ((exp
->X_add_number
< 0) == !sign
)
1402 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1404 exp
->X_add_number
= i
;
1407 /* For most MRI pseudo-ops, the line actually ends at the first
1408 nonquoted space. This function looks for that point, stuffs a null
1409 in, and sets *STOPCP to the character that used to be there, and
1410 returns the location.
1412 Until I hear otherwise, I am going to assume that this is only true
1413 for the m68k MRI assembler. */
1416 mri_comment_field (char *stopcp
)
1422 know (flag_m68k_mri
);
1424 for (s
= input_line_pointer
;
1425 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1433 for (s
= input_line_pointer
;
1434 !is_end_of_line
[(unsigned char) *s
];
1444 /* Skip to the end of an MRI comment field. */
1447 mri_comment_end (char *stop
, int stopc
)
1451 input_line_pointer
= stop
;
1453 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1454 ++input_line_pointer
;
1458 s_abort (int ignore ATTRIBUTE_UNUSED
)
1460 as_fatal (_(".abort detected. Abandoning ship."));
1463 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1464 (in bytes). A negative ARG is the negative of the length of the
1465 fill pattern. BYTES_P is non-zero if the alignment value should be
1466 interpreted as the byte boundary, rather than the power of 2. */
1467 #ifndef TC_ALIGN_LIMIT
1468 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1472 s_align (signed int arg
, int bytes_p
)
1474 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1483 stop
= mri_comment_field (&stopc
);
1485 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1490 align
= arg
; /* Default value from pseudo-op table. */
1494 align
= get_absolute_expression ();
1497 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1498 if (arg
> 0 && align
== 0)
1505 /* Convert to a power of 2. */
1510 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1513 as_bad (_("alignment not a power of 2"));
1519 if (align
> align_limit
)
1521 align
= align_limit
;
1522 as_warn (_("alignment too large: %u assumed"), align_limit
);
1525 if (*input_line_pointer
!= ',')
1532 ++input_line_pointer
;
1533 if (*input_line_pointer
== ',')
1537 fill
= get_absolute_expression ();
1542 if (*input_line_pointer
!= ',')
1546 ++input_line_pointer
;
1547 max
= get_absolute_expression ();
1554 as_warn (_("expected fill pattern missing"));
1555 do_align (align
, (char *) NULL
, 0, max
);
1559 unsigned int fill_len
;
1571 do_align (align
, &fill_char
, fill_len
, max
);
1577 if ((size_t) fill_len
> sizeof ab
)
1579 as_warn (_("fill pattern too long, truncating to %u"),
1580 (unsigned) sizeof ab
);
1581 fill_len
= sizeof ab
;
1584 md_number_to_chars (ab
, fill
, fill_len
);
1585 do_align (align
, ab
, fill_len
, max
);
1589 demand_empty_rest_of_line ();
1592 mri_comment_end (stop
, stopc
);
1595 /* Handle the .align pseudo-op on machines where ".align 4" means
1596 align to a 4 byte boundary. */
1599 s_align_bytes (int arg
)
1604 /* Handle the .align pseudo-op on machines where ".align 4" means align
1605 to a 2**4 boundary. */
1608 s_align_ptwo (int arg
)
1613 /* Switch in and out of alternate macro mode. */
1618 demand_empty_rest_of_line ();
1619 flag_macro_alternate
= on
;
1622 /* Read a symbol name from input_line_pointer.
1624 Stores the symbol name in a buffer and returns a pointer to this buffer.
1625 The buffer is xalloc'ed. It is the caller's responsibility to free
1628 The name is not left in the i_l_p buffer as it may need processing
1629 to handle escape characters.
1631 Advances i_l_p to the next non-whitespace character.
1633 If a symbol name could not be read, the routine issues an error
1634 messages, skips to the end of the line and returns NULL. */
1637 read_symbol_name (void)
1643 c
= *input_line_pointer
++;
1647 #define SYM_NAME_CHUNK_LEN 128
1648 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1652 start
= name
= XNEWVEC (char, len
+ 1);
1654 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1656 while (is_a_char (C
= next_char_of_string ()))
1658 if (name
>= name_end
)
1662 sofar
= name
- start
;
1663 len
+= SYM_NAME_CHUNK_LEN
;
1664 start
= XRESIZEVEC (char, start
, len
+ 1);
1665 name_end
= start
+ len
;
1666 name
= start
+ sofar
;
1673 /* Since quoted symbol names can contain non-ASCII characters,
1674 check the string and warn if it cannot be recognised by the
1675 current character set. */
1676 /* PR 29447: mbstowcs ignores the third (length) parameter when
1677 the first (destination) parameter is NULL. For clarity sake
1678 therefore we pass 0 rather than 'len' as the third parameter. */
1679 if (mbstowcs (NULL
, name
, 0) == (size_t) -1)
1680 as_warn (_("symbol name not recognised in the current locale"));
1682 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1686 name
= input_line_pointer
- 1;
1688 /* We accept FAKE_LABEL_CHAR in a name in case this is
1689 being called with a constructed string. */
1690 while (is_part_of_name (c
= *input_line_pointer
++)
1691 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1694 len
= (input_line_pointer
- name
) - 1;
1695 start
= XNEWVEC (char, len
+ 1);
1697 memcpy (start
, name
, len
);
1700 /* Skip a name ender char if one is present. */
1701 if (! is_name_ender (c
))
1702 --input_line_pointer
;
1705 name
= start
= NULL
;
1709 as_bad (_("expected symbol name"));
1710 ignore_rest_of_line ();
1722 s_comm_internal (int param
,
1723 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1727 symbolS
*symbolP
= NULL
;
1733 stop
= mri_comment_field (&stopc
);
1735 if ((name
= read_symbol_name ()) == NULL
)
1738 /* Accept an optional comma after the name. The comma used to be
1739 required, but Irix 5 cc does not generate it for .lcomm. */
1740 if (*input_line_pointer
== ',')
1741 input_line_pointer
++;
1743 temp
= get_absolute_expr (&exp
);
1745 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1746 if (exp
.X_op
== O_absent
)
1748 as_bad (_("missing size expression"));
1749 ignore_rest_of_line ();
1752 else if (temp
!= size
|| !exp
.X_unsigned
)
1754 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1755 ignore_rest_of_line ();
1759 symbolP
= symbol_find_or_make (name
);
1760 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1761 && !S_IS_COMMON (symbolP
))
1763 if (!S_IS_VOLATILE (symbolP
))
1766 as_bad (_("symbol `%s' is already defined"), name
);
1767 ignore_rest_of_line ();
1770 symbolP
= symbol_clone (symbolP
, 1);
1771 S_SET_SEGMENT (symbolP
, undefined_section
);
1772 S_SET_VALUE (symbolP
, 0);
1773 symbol_set_frag (symbolP
, &zero_address_frag
);
1774 S_CLEAR_VOLATILE (symbolP
);
1777 size
= S_GET_VALUE (symbolP
);
1780 else if (size
!= temp
)
1781 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1782 name
, (long) size
, (long) temp
);
1784 if (comm_parse_extra
!= NULL
)
1785 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1788 S_SET_VALUE (symbolP
, (valueT
) size
);
1789 S_SET_EXTERNAL (symbolP
);
1790 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1793 demand_empty_rest_of_line ();
1796 mri_comment_end (stop
, stopc
);
1804 s_comm_internal (ignore
, NULL
);
1807 /* The MRI COMMON pseudo-op. We handle this by creating a common
1808 symbol with the appropriate name. We make s_space do the right
1809 thing by increasing the size. */
1812 s_mri_common (int small ATTRIBUTE_UNUSED
)
1828 stop
= mri_comment_field (&stopc
);
1832 name
= input_line_pointer
;
1833 if (!ISDIGIT (*name
))
1834 c
= get_symbol_name (& name
);
1839 ++input_line_pointer
;
1841 while (ISDIGIT (*input_line_pointer
));
1843 c
= *input_line_pointer
;
1844 *input_line_pointer
= '\0';
1846 if (line_label
!= NULL
)
1848 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1849 + (input_line_pointer
- name
) + 1);
1850 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1855 sym
= symbol_find_or_make (name
);
1856 c
= restore_line_pointer (c
);
1859 if (*input_line_pointer
!= ',')
1863 ++input_line_pointer
;
1864 align
= get_absolute_expression ();
1867 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1869 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1870 mri_comment_end (stop
, stopc
);
1874 S_SET_EXTERNAL (sym
);
1875 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1876 mri_common_symbol
= sym
;
1880 S_SET_ALIGN (sym
, align
);
1885 if (line_label
!= NULL
)
1888 exp
.X_op
= O_symbol
;
1889 exp
.X_add_symbol
= sym
;
1890 exp
.X_add_number
= 0;
1891 symbol_set_value_expression (line_label
, &exp
);
1892 symbol_set_frag (line_label
, &zero_address_frag
);
1893 S_SET_SEGMENT (line_label
, expr_section
);
1896 /* FIXME: We just ignore the small argument, which distinguishes
1897 COMMON and COMMON.S. I don't know what we can do about it. */
1899 /* Ignore the type and hptype. */
1900 if (*input_line_pointer
== ',')
1901 input_line_pointer
+= 2;
1902 if (*input_line_pointer
== ',')
1903 input_line_pointer
+= 2;
1905 demand_empty_rest_of_line ();
1907 mri_comment_end (stop
, stopc
);
1911 s_data (int ignore ATTRIBUTE_UNUSED
)
1916 temp
= get_absolute_expression ();
1917 if (flag_readonly_data_in_text
)
1919 section
= text_section
;
1923 section
= data_section
;
1925 subseg_set (section
, (subsegT
) temp
);
1927 demand_empty_rest_of_line ();
1930 /* Handle the .file pseudo-op. This default definition may be overridden by
1931 the object or CPU specific pseudo-ops. */
1934 s_file_string (char *file
)
1938 listing_source_file (file
);
1940 register_dependency (file
);
1942 obj_app_file (file
);
1947 s_file (int ignore ATTRIBUTE_UNUSED
)
1952 /* Some assemblers tolerate immediately following '"'. */
1953 if ((s
= demand_copy_string (&length
)) != 0)
1955 new_logical_line_flags (s
, -1, 1);
1957 /* In MRI mode, the preprocessor may have inserted an extraneous
1960 && *input_line_pointer
== '\''
1961 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1962 ++input_line_pointer
;
1964 demand_empty_rest_of_line ();
1970 get_linefile_number (int *flag
)
1976 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1979 /* Don't mistakenly interpret octal numbers as line numbers. */
1980 if (*input_line_pointer
== '0')
1983 ++input_line_pointer
;
1987 expression_and_evaluate (&exp
);
1988 if (exp
.X_op
!= O_constant
)
1991 #if defined (BFD64) || LONG_MAX > INT_MAX
1992 if (exp
.X_add_number
< INT_MIN
|| exp
.X_add_number
> INT_MAX
)
1996 *flag
= exp
.X_add_number
;
2001 /* Handle the .linefile pseudo-op. This is automatically generated by
2002 do_scrub_chars when a preprocessor # line comment is seen. This
2003 default definition may be overridden by the object or CPU specific
2007 s_linefile (int ignore ATTRIBUTE_UNUSED
)
2010 int linenum
, flags
= 0;
2012 /* The given number is that of the next line. */
2013 if (!get_linefile_number (&linenum
))
2015 ignore_rest_of_line ();
2020 /* Some of the back ends can't deal with non-positive line numbers.
2021 Besides, it's silly. GCC however will generate a line number of
2022 zero when it is pre-processing builtins for assembler-with-cpp files:
2026 We do not want to barf on this, especially since such files are used
2027 in the GCC and GDB testsuites. So we check for negative line numbers
2028 rather than non-positive line numbers. */
2029 as_warn (_("line numbers must be positive; line number %d rejected"),
2037 if (*input_line_pointer
== '"')
2038 file
= demand_copy_string (&length
);
2039 else if (*input_line_pointer
== '.')
2041 /* buffer_and_nest() may insert this form. */
2042 ++input_line_pointer
;
2050 while (get_linefile_number (&this_flag
))
2053 /* From GCC's cpp documentation:
2054 1: start of a new file.
2055 2: returning to a file after having included another file.
2056 3: following text comes from a system header file.
2057 4: following text should be treated as extern "C".
2059 4 is nonsensical for the assembler; 3, we don't care about,
2060 so we ignore it just in case a system header file is
2061 included while preprocessing assembly. So 1 and 2 are all
2062 we care about, and they are mutually incompatible.
2063 new_logical_line_flags() demands this. */
2066 if (flags
&& flags
!= (1 << this_flag
))
2067 as_warn (_("incompatible flag %i in line directive"),
2070 flags
|= 1 << this_flag
;
2075 /* We ignore these. */
2079 as_warn (_("unsupported flag %i in line directive"),
2084 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2090 demand_empty_rest_of_line ();
2092 /* read_a_source_file() will bump the line number only if the line
2093 is terminated by '\n'. */
2094 if (input_line_pointer
[-1] == '\n')
2097 new_logical_line_flags (file
, linenum
, flags
);
2100 listing_source_line (linenum
);
2105 ignore_rest_of_line ();
2108 /* Handle the .end pseudo-op. Actually, the real work is done in
2109 read_a_source_file. */
2112 s_end (int ignore ATTRIBUTE_UNUSED
)
2116 /* The MRI assembler permits the start symbol to follow .end,
2117 but we don't support that. */
2119 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2120 && *input_line_pointer
!= '*'
2121 && *input_line_pointer
!= '!')
2122 as_warn (_("start address not supported"));
2126 /* Handle the .err pseudo-op. */
2129 s_err (int ignore ATTRIBUTE_UNUSED
)
2131 as_bad (_(".err encountered"));
2132 demand_empty_rest_of_line ();
2135 /* Handle the .error and .warning pseudo-ops. */
2141 /* The purpose for the conditional assignment is not to
2142 internationalize the directive itself, but that we need a
2143 self-contained message, one that can be passed like the
2144 demand_copy_C_string return value, and with no assumption on the
2145 location of the name of the directive within the message. */
2147 = (err
? _(".error directive invoked in source file")
2148 : _(".warning directive invoked in source file"));
2150 if (!is_it_end_of_statement ())
2152 if (*input_line_pointer
!= '\"')
2154 as_bad (_("%s argument must be a string"),
2155 err
? ".error" : ".warning");
2156 ignore_rest_of_line ();
2160 msg
= demand_copy_C_string (&len
);
2168 as_warn ("%s", msg
);
2169 demand_empty_rest_of_line ();
2172 /* Handle the MRI fail pseudo-op. */
2175 s_fail (int ignore ATTRIBUTE_UNUSED
)
2182 stop
= mri_comment_field (&stopc
);
2184 temp
= get_absolute_expression ();
2186 as_warn (_(".fail %ld encountered"), (long) temp
);
2188 as_bad (_(".fail %ld encountered"), (long) temp
);
2190 demand_empty_rest_of_line ();
2193 mri_comment_end (stop
, stopc
);
2197 s_fill (int ignore ATTRIBUTE_UNUSED
)
2199 expressionS rep_exp
;
2204 #ifdef md_flush_pending_output
2205 md_flush_pending_output ();
2208 #ifdef md_cons_align
2212 expression (&rep_exp
);
2213 if (*input_line_pointer
== ',')
2215 input_line_pointer
++;
2216 size
= get_absolute_expression ();
2217 if (*input_line_pointer
== ',')
2219 input_line_pointer
++;
2220 fill
= get_absolute_expression ();
2224 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2225 #define BSD_FILL_SIZE_CROCK_8 (8)
2226 if (size
> BSD_FILL_SIZE_CROCK_8
)
2228 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2229 size
= BSD_FILL_SIZE_CROCK_8
;
2233 as_warn (_("size negative; .fill ignored"));
2236 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2238 if (rep_exp
.X_add_number
< 0)
2239 as_warn (_("repeat < 0; .fill ignored"));
2242 else if (size
&& !need_pass_2
)
2244 if (now_seg
== absolute_section
&& rep_exp
.X_op
!= O_constant
)
2246 as_bad (_("non-constant fill count for absolute section"));
2249 else if (now_seg
== absolute_section
&& fill
&& rep_exp
.X_add_number
!= 0)
2251 as_bad (_("attempt to fill absolute section with non-zero value"));
2255 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2258 as_bad (_("attempt to fill section `%s' with non-zero value"),
2259 segment_name (now_seg
));
2264 if (size
&& !need_pass_2
)
2266 if (now_seg
== absolute_section
)
2267 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2269 if (rep_exp
.X_op
== O_constant
)
2271 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2272 (relax_substateT
) 0, (symbolS
*) 0,
2273 (offsetT
) rep_exp
.X_add_number
,
2278 /* We don't have a constant repeat count, so we can't use
2279 rs_fill. We can get the same results out of rs_space,
2280 but its argument is in bytes, so we must multiply the
2281 repeat count by size. */
2284 rep_sym
= make_expr_symbol (&rep_exp
);
2287 expressionS size_exp
;
2288 size_exp
.X_op
= O_constant
;
2289 size_exp
.X_add_number
= size
;
2291 rep_exp
.X_op
= O_multiply
;
2292 rep_exp
.X_add_symbol
= rep_sym
;
2293 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2294 rep_exp
.X_add_number
= 0;
2295 rep_sym
= make_expr_symbol (&rep_exp
);
2298 p
= frag_var (rs_space
, (int) size
, (int) size
,
2299 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2302 memset (p
, 0, (unsigned int) size
);
2304 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2305 flavoured AS. The following bizarre behaviour is to be
2306 compatible with above. I guess they tried to take up to 8
2307 bytes from a 4-byte expression and they forgot to sign
2309 #define BSD_FILL_SIZE_CROCK_4 (4)
2310 md_number_to_chars (p
, (valueT
) fill
,
2311 (size
> BSD_FILL_SIZE_CROCK_4
2312 ? BSD_FILL_SIZE_CROCK_4
2314 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2315 but emits no error message because it seems a legal thing to do.
2316 It is a degenerate case of .fill but could be emitted by a
2319 demand_empty_rest_of_line ();
2323 s_globl (int ignore ATTRIBUTE_UNUSED
)
2332 stop
= mri_comment_field (&stopc
);
2336 if ((name
= read_symbol_name ()) == NULL
)
2339 symbolP
= symbol_find_or_make (name
);
2340 S_SET_EXTERNAL (symbolP
);
2343 c
= *input_line_pointer
;
2346 input_line_pointer
++;
2348 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2356 demand_empty_rest_of_line ();
2359 mri_comment_end (stop
, stopc
);
2362 /* Handle the MRI IRP and IRPC pseudo-ops. */
2374 file
= as_where (&line
);
2376 eol
= find_end_of_line (input_line_pointer
, 0);
2377 sb_build (&s
, eol
- input_line_pointer
);
2378 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2379 input_line_pointer
= eol
;
2383 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2385 as_bad_where (file
, line
, "%s", err
);
2389 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2391 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2394 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2395 the section to only be linked once. However, this is not supported
2396 by most object file formats. This takes an optional argument,
2397 which is what to do about duplicates. */
2400 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2402 enum linkonce_type type
;
2406 type
= LINKONCE_DISCARD
;
2408 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2413 c
= get_symbol_name (& s
);
2414 if (strcasecmp (s
, "discard") == 0)
2415 type
= LINKONCE_DISCARD
;
2416 else if (strcasecmp (s
, "one_only") == 0)
2417 type
= LINKONCE_ONE_ONLY
;
2418 else if (strcasecmp (s
, "same_size") == 0)
2419 type
= LINKONCE_SAME_SIZE
;
2420 else if (strcasecmp (s
, "same_contents") == 0)
2421 type
= LINKONCE_SAME_CONTENTS
;
2423 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2425 (void) restore_line_pointer (c
);
2428 #ifdef obj_handle_link_once
2429 obj_handle_link_once (type
);
2430 #else /* ! defined (obj_handle_link_once) */
2434 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2435 as_warn (_(".linkonce is not supported for this object file format"));
2437 flags
= bfd_section_flags (now_seg
);
2438 flags
|= SEC_LINK_ONCE
;
2443 case LINKONCE_DISCARD
:
2444 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2446 case LINKONCE_ONE_ONLY
:
2447 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2449 case LINKONCE_SAME_SIZE
:
2450 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2452 case LINKONCE_SAME_CONTENTS
:
2453 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2456 if (!bfd_set_section_flags (now_seg
, flags
))
2457 as_bad (_("bfd_set_section_flags: %s"),
2458 bfd_errmsg (bfd_get_error ()));
2460 #endif /* ! defined (obj_handle_link_once) */
2462 demand_empty_rest_of_line ();
2466 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2469 segT current_seg
= now_seg
;
2470 subsegT current_subseg
= now_subseg
;
2471 segT bss_seg
= bss_section
;
2473 #if defined (TC_MIPS) || defined (TC_ALPHA)
2474 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2475 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2477 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2478 if (size
<= bfd_get_gp_size (stdoutput
))
2480 bss_seg
= subseg_new (".sbss", 1);
2481 seg_info (bss_seg
)->bss
= 1;
2482 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2483 as_warn (_("error setting flags for \".sbss\": %s"),
2484 bfd_errmsg (bfd_get_error ()));
2488 subseg_set (bss_seg
, 1);
2490 if (align
> OCTETS_PER_BYTE_POWER
)
2492 record_alignment (bss_seg
, align
);
2493 frag_align (align
, 0, 0);
2496 /* Detach from old frag. */
2497 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2498 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2500 symbol_set_frag (symbolP
, frag_now
);
2501 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2505 S_SET_SIZE (symbolP
, size
);
2507 S_SET_SEGMENT (symbolP
, bss_seg
);
2510 /* The symbol may already have been created with a preceding
2511 ".globl" directive -- be careful not to step on storage class
2512 in that case. Otherwise, set it to static. */
2513 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2514 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2515 #endif /* OBJ_COFF */
2517 subseg_set (current_seg
, current_subseg
);
2521 parse_align (int align_bytes
)
2527 if (*input_line_pointer
!= ',')
2530 as_bad (_("expected alignment after size"));
2531 ignore_rest_of_line ();
2535 input_line_pointer
++;
2538 align
= get_absolute_expr (&exp
);
2539 if (exp
.X_op
== O_absent
)
2542 if (!exp
.X_unsigned
)
2544 as_warn (_("alignment negative; 0 assumed"));
2548 if (align_bytes
&& align
!= 0)
2550 /* convert to a power of 2 alignment */
2551 unsigned int alignp2
= 0;
2552 while ((align
& 1) == 0)
2553 align
>>= 1, ++alignp2
;
2556 as_bad (_("alignment not a power of 2"));
2557 ignore_rest_of_line ();
2565 /* Called from s_comm_internal after symbol name and size have been
2566 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2567 1 if this was a ".bss" directive which has a 3rd argument
2568 (alignment as a power of 2), or 2 if this was a ".bss" directive
2569 with alignment in bytes. */
2572 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2578 align
= parse_align (needs_align
- 1);
2579 if (align
== (addressT
) -1)
2583 /* Assume some objects may require alignment on some systems. */
2584 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2586 bss_alloc (symbolP
, size
, align
);
2591 s_lcomm (int needs_align
)
2593 s_comm_internal (needs_align
, s_lcomm_internal
);
2597 s_lcomm_bytes (int needs_align
)
2599 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2603 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2609 /* We permit ANY defined expression: BSD4.2 demands constants. */
2610 if ((name
= read_symbol_name ()) == NULL
)
2613 if (*input_line_pointer
!= ',')
2615 as_bad (_("expected comma after \"%s\""), name
);
2619 input_line_pointer
++;
2620 expression_and_evaluate (&exp
);
2622 if (exp
.X_op
!= O_constant
2623 && exp
.X_op
!= O_register
)
2625 as_bad (_("bad expression"));
2629 symbolP
= symbol_find_or_make (name
);
2631 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2633 /* The name might be an undefined .global symbol; be sure to
2634 keep the "external" bit. */
2635 S_SET_SEGMENT (symbolP
,
2636 (exp
.X_op
== O_constant
2639 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2643 as_bad (_("symbol `%s' is already defined"), name
);
2646 demand_empty_rest_of_line ();
2651 ignore_rest_of_line ();
2656 /* Read a line into an sb. Returns the character that ended the line
2657 or zero if there are no more lines. */
2660 get_line_sb (sb
*line
, int in_macro
)
2664 if (input_line_pointer
[-1] == '\n')
2665 bump_line_counters ();
2667 if (input_line_pointer
>= buffer_limit
)
2669 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2670 if (buffer_limit
== 0)
2674 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2675 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2676 input_line_pointer
= eol
;
2678 /* Don't skip multiple end-of-line characters, because that breaks support
2679 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2680 characters but isn't. Instead just skip one end of line character and
2681 return the character skipped so that the caller can re-insert it if
2683 return *input_line_pointer
++;
2687 get_non_macro_line_sb (sb
*line
)
2689 return get_line_sb (line
, 0);
2693 get_macro_line_sb (sb
*line
)
2695 return get_line_sb (line
, 1);
2698 /* Define a macro. This is an interface to macro.c. */
2701 s_macro (int ignore ATTRIBUTE_UNUSED
)
2707 eol
= find_end_of_line (input_line_pointer
, 0);
2708 sb_build (&s
, eol
- input_line_pointer
);
2709 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2710 input_line_pointer
= eol
;
2712 if (line_label
!= NULL
)
2718 name
= S_GET_NAME (line_label
);
2719 len
= strlen (name
);
2720 sb_build (&label
, len
);
2721 sb_add_buffer (&label
, name
, len
);
2722 macro
= define_macro (&s
, &label
, get_macro_line_sb
);
2726 macro
= define_macro (&s
, NULL
, get_macro_line_sb
);
2729 if (line_label
!= NULL
)
2731 S_SET_SEGMENT (line_label
, absolute_section
);
2732 S_SET_VALUE (line_label
, 0);
2733 symbol_set_frag (line_label
, &zero_address_frag
);
2736 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2737 && str_hash_find (po_hash
, macro
->name
) != NULL
)
2739 && macro
->name
[0] == '.'
2740 && str_hash_find (po_hash
, macro
->name
+ 1) != NULL
))
2742 as_warn_where (macro
->file
, macro
->line
,
2743 _("attempt to redefine pseudo-op `%s' ignored"),
2745 str_hash_delete (macro_hash
, macro
->name
);
2752 /* Handle the .mexit pseudo-op, which immediately exits a macro
2756 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2760 cond_exit_macro (macro_nest
);
2761 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2764 as_warn (_("ignoring macro exit outside a macro definition."));
2767 /* Switch in and out of MRI mode. */
2770 s_mri (int ignore ATTRIBUTE_UNUSED
)
2773 #ifdef MRI_MODE_CHANGE
2777 on
= get_absolute_expression ();
2778 #ifdef MRI_MODE_CHANGE
2779 old_flag
= flag_mri
;
2796 /* Operator precedence changes in m68k MRI mode, so we need to
2797 update the operator rankings. */
2798 expr_set_precedence ();
2800 #ifdef MRI_MODE_CHANGE
2802 MRI_MODE_CHANGE (on
);
2805 demand_empty_rest_of_line ();
2808 /* Handle changing the location counter. */
2811 do_org (segT segment
, expressionS
*exp
, int fill
)
2813 if (segment
!= now_seg
2814 && segment
!= absolute_section
2815 && segment
!= expr_section
)
2816 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2818 if (now_seg
== absolute_section
)
2821 as_warn (_("ignoring fill value in absolute section"));
2822 if (exp
->X_op
!= O_constant
)
2824 as_bad (_("only constant offsets supported in absolute section"));
2825 exp
->X_add_number
= 0;
2827 abs_section_offset
= exp
->X_add_number
;
2832 symbolS
*sym
= exp
->X_add_symbol
;
2833 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2835 if (fill
&& in_bss ())
2836 as_warn (_("ignoring fill value in section `%s'"),
2837 segment_name (now_seg
));
2839 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2841 /* Handle complex expressions. */
2842 sym
= make_expr_symbol (exp
);
2846 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2852 s_org (int ignore ATTRIBUTE_UNUSED
)
2858 #ifdef md_flush_pending_output
2859 md_flush_pending_output ();
2862 /* The m68k MRI assembler has a different meaning for .org. It
2863 means to create an absolute section at a given address. We can't
2864 support that--use a linker script instead. */
2867 as_bad (_("MRI style ORG pseudo-op not supported"));
2868 ignore_rest_of_line ();
2872 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2873 thing as a sub-segment-relative origin. Any absolute origin is
2874 given a warning, then assumed to be segment-relative. Any
2875 segmented origin expression ("foo+42") had better be in the right
2876 segment or the .org is ignored.
2878 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2879 we never know sub-segment sizes when we are reading code. BSD
2880 will crash trying to emit negative numbers of filler bytes in
2881 certain .orgs. We don't crash, but see as-write for that code.
2883 Don't make frag if need_pass_2==1. */
2884 segment
= get_known_segmented_expression (&exp
);
2885 if (*input_line_pointer
== ',')
2887 input_line_pointer
++;
2888 temp_fill
= get_absolute_expression ();
2894 do_org (segment
, &exp
, temp_fill
);
2896 demand_empty_rest_of_line ();
2899 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2900 called by the obj-format routine which handles section changing
2901 when in MRI mode. It will create a new section, and return it. It
2902 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2903 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2906 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2916 name
= input_line_pointer
;
2917 if (!ISDIGIT (*name
))
2918 c
= get_symbol_name (& name
);
2923 ++input_line_pointer
;
2925 while (ISDIGIT (*input_line_pointer
));
2927 c
= *input_line_pointer
;
2928 *input_line_pointer
= '\0';
2931 name
= xstrdup (name
);
2933 c
= restore_line_pointer (c
);
2935 seg
= subseg_new (name
, 0);
2941 ++input_line_pointer
;
2942 align
= get_absolute_expression ();
2943 record_alignment (seg
, align
);
2947 if (*input_line_pointer
== ',')
2949 c
= *++input_line_pointer
;
2951 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2954 as_bad (_("unrecognized section type"));
2955 ++input_line_pointer
;
2960 flags
= SEC_NO_FLAGS
;
2962 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2963 else if (*type
== 'D' || *type
== 'M')
2964 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2965 else if (*type
== 'R')
2966 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2967 if (flags
!= SEC_NO_FLAGS
)
2969 if (!bfd_set_section_flags (seg
, flags
))
2970 as_warn (_("error setting flags for \"%s\": %s"),
2971 bfd_section_name (seg
),
2972 bfd_errmsg (bfd_get_error ()));
2977 /* Ignore the HP type. */
2978 if (*input_line_pointer
== ',')
2979 input_line_pointer
+= 2;
2981 demand_empty_rest_of_line ();
2983 #else /* ! TC_M68K */
2984 /* The MRI assembler seems to use different forms of .sect for
2985 different targets. */
2986 as_bad ("MRI mode not supported for this target");
2987 ignore_rest_of_line ();
2988 #endif /* ! TC_M68K */
2991 /* Handle the .print pseudo-op. */
2994 s_print (int ignore ATTRIBUTE_UNUSED
)
2999 s
= demand_copy_C_string (&len
);
3002 demand_empty_rest_of_line ();
3005 /* Handle the .purgem pseudo-op. */
3008 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3010 if (is_it_end_of_statement ())
3012 demand_empty_rest_of_line ();
3022 c
= get_symbol_name (& name
);
3023 delete_macro (name
);
3024 *input_line_pointer
= c
;
3025 SKIP_WHITESPACE_AFTER_NAME ();
3027 while (*input_line_pointer
++ == ',');
3029 --input_line_pointer
;
3030 demand_empty_rest_of_line ();
3033 /* Handle the .endm/.endr pseudo-ops. */
3036 s_bad_end (int endr
)
3038 as_warn (_(".end%c encountered without preceding %s"),
3040 endr
? ".rept, .irp, or .irpc" : ".macro");
3041 demand_empty_rest_of_line ();
3044 /* Handle the .rept pseudo-op. */
3047 s_rept (int ignore ATTRIBUTE_UNUSED
)
3051 count
= (size_t) get_absolute_expression ();
3053 do_repeat (count
, "REPT", "ENDR", NULL
);
3056 /* This function provides a generic repeat block implementation. It allows
3057 different directives to be used as the start/end keys. Any text matching
3058 the optional EXPANDER in the block is replaced by the remaining iteration
3062 do_repeat (size_t count
, const char *start
, const char *end
,
3063 const char *expander
)
3068 if (((ssize_t
) count
) < 0)
3070 as_bad (_("negative count for %s - ignored"), start
);
3075 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3077 as_bad (_("%s without %s"), start
, end
);
3082 if (expander
== NULL
|| strstr (one
.ptr
, expander
) == NULL
)
3084 sb_build (&many
, count
* one
.len
);
3086 sb_add_sb (&many
, &one
);
3092 while (count
-- > 0)
3098 sb_build (& processed
, one
.len
);
3099 sb_add_sb (& processed
, & one
);
3100 sub
= strstr (processed
.ptr
, expander
);
3101 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3102 gas_assert (len
< 8);
3103 memmove (sub
+ len
, sub
+ 8,
3104 processed
.ptr
+ processed
.len
- (sub
+ 8));
3105 processed
.len
-= (8 - len
);
3106 sb_add_sb (& many
, & processed
);
3107 sb_kill (& processed
);
3113 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3115 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3118 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3119 input buffers to skip. Assumes that conditionals preceding the loop end
3120 are properly nested.
3122 This function makes it easier to implement a premature "break" out of the
3123 loop. The EXTRA arg accounts for other buffers we might have inserted,
3124 such as line substitutions. */
3127 end_repeat (int extra
)
3129 cond_exit_macro (macro_nest
);
3130 while (extra
-- >= 0)
3131 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3135 assign_symbol (char *name
, int mode
)
3139 if (name
[0] == '.' && name
[1] == '\0')
3141 /* Turn '. = mumble' into a .org mumble. */
3145 segment
= get_known_segmented_expression (&exp
);
3148 do_org (segment
, &exp
, 0);
3153 if ((symbolP
= symbol_find (name
)) == NULL
3154 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3156 symbolP
= symbol_find_or_make (name
);
3158 /* When doing symbol listings, play games with dummy fragments living
3159 outside the normal fragment chain to record the file and line info
3161 if (listing
& LISTING_SYMBOLS
)
3163 extern struct list_info_struct
*listing_tail
;
3164 fragS
*dummy_frag
= notes_calloc (1, sizeof (*dummy_frag
));
3165 dummy_frag
->line
= listing_tail
;
3166 dummy_frag
->fr_symbol
= symbolP
;
3167 symbol_set_frag (symbolP
, dummy_frag
);
3170 #if defined (OBJ_COFF) && !defined (TE_PE)
3171 /* "set" symbols are local unless otherwise specified. */
3172 SF_SET_LOCAL (symbolP
);
3176 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3178 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3179 && !S_CAN_BE_REDEFINED (symbolP
))
3181 as_bad (_("symbol `%s' is already defined"), name
);
3182 ignore_rest_of_line ();
3183 input_line_pointer
--;
3186 /* If the symbol is volatile, copy the symbol and replace the
3187 original with the copy, so that previous uses of the symbol will
3188 retain the value of the symbol at the point of use. */
3189 else if (S_IS_VOLATILE (symbolP
))
3190 symbolP
= symbol_clone (symbolP
, 1);
3194 S_SET_VOLATILE (symbolP
);
3196 S_SET_FORWARD_REF (symbolP
);
3198 pseudo_set (symbolP
);
3201 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3202 then this is .equiv, and it is an error if the symbol is already
3203 defined. If EQUIV is -1, the symbol additionally is a forward
3211 /* Especial apologies for the random logic:
3212 this just grew, and could be parsed much more simply!
3214 if ((name
= read_symbol_name ()) == NULL
)
3217 if (*input_line_pointer
!= ',')
3219 as_bad (_("expected comma after \"%s\""), name
);
3220 ignore_rest_of_line ();
3225 input_line_pointer
++;
3226 assign_symbol (name
, equiv
);
3227 demand_empty_rest_of_line ();
3241 #ifdef md_flush_pending_output
3242 md_flush_pending_output ();
3249 # ifndef P_PRECISION
3250 # define P_PRECISION X_PRECISION
3251 # define P_PRECISION_PAD X_PRECISION_PAD
3253 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3261 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3268 #ifdef md_cons_align
3273 stop
= mri_comment_field (&stopc
);
3275 /* In m68k MRI mode, we need to align to a word boundary, unless
3277 if (flag_m68k_mri
&& mult
> 1)
3279 if (now_seg
== absolute_section
)
3281 abs_section_offset
+= abs_section_offset
& 1;
3282 if (line_label
!= NULL
)
3283 S_SET_VALUE (line_label
, abs_section_offset
);
3285 else if (mri_common_symbol
!= NULL
)
3289 mri_val
= S_GET_VALUE (mri_common_symbol
);
3290 if ((mri_val
& 1) != 0)
3292 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3293 if (line_label
!= NULL
)
3295 expressionS
*symexp
;
3297 symexp
= symbol_get_value_expression (line_label
);
3298 know (symexp
->X_op
== O_symbol
);
3299 know (symexp
->X_add_symbol
== mri_common_symbol
);
3300 symexp
->X_add_number
+= 1;
3306 do_align (1, (char *) NULL
, 0, 0);
3307 if (line_label
!= NULL
)
3309 symbol_set_frag (line_label
, frag_now
);
3310 S_SET_VALUE (line_label
, frag_now_fix ());
3320 if (*input_line_pointer
== ',')
3322 ++input_line_pointer
;
3327 val
.X_op
= O_constant
;
3328 val
.X_add_number
= 0;
3331 if ((val
.X_op
!= O_constant
3332 || val
.X_add_number
< - 0x80
3333 || val
.X_add_number
> 0xff
3334 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3335 && (now_seg
!= absolute_section
&& !in_bss ()))
3337 resolve_expression (&exp
);
3338 if (exp
.X_op
!= O_constant
)
3339 as_bad (_("unsupported variable size or fill value"));
3344 /* PR 20901: Check for excessive values.
3345 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3346 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3347 as_bad (_("size value for space directive too large: %lx"),
3348 (long) exp
.X_add_number
);
3353 bytes
= mult
* exp
.X_add_number
;
3355 for (i
= 0; i
< exp
.X_add_number
; i
++)
3356 emit_expr (&val
, mult
);
3362 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3363 resolve_expression (&exp
);
3365 if (exp
.X_op
== O_constant
)
3367 addressT repeat
= exp
.X_add_number
;
3371 if ((offsetT
) repeat
< 0)
3373 as_warn (_(".space repeat count is negative, ignored"));
3379 as_warn (_(".space repeat count is zero, ignored"));
3382 if ((unsigned int) mult
<= 1)
3384 else if (gas_mul_overflow (repeat
, mult
, &total
)
3385 || (offsetT
) total
< 0)
3387 as_warn (_(".space repeat count overflow, ignored"));
3392 /* If we are in the absolute section, just bump the offset. */
3393 if (now_seg
== absolute_section
)
3395 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3396 as_warn (_("ignoring fill value in absolute section"));
3397 abs_section_offset
+= total
;
3401 /* If we are secretly in an MRI common section, then
3402 creating space just increases the size of the common
3404 if (mri_common_symbol
!= NULL
)
3406 S_SET_VALUE (mri_common_symbol
,
3407 S_GET_VALUE (mri_common_symbol
) + total
);
3412 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3413 (offsetT
) total
, (char *) 0);
3417 if (now_seg
== absolute_section
)
3419 as_bad (_("space allocation too complex in absolute section"));
3420 subseg_set (text_section
, 0);
3423 if (mri_common_symbol
!= NULL
)
3425 as_bad (_("space allocation too complex in common section"));
3426 mri_common_symbol
= NULL
;
3430 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3431 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3434 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3435 as_warn (_("ignoring fill value in section `%s'"),
3436 segment_name (now_seg
));
3438 *p
= val
.X_add_number
;
3443 /* In MRI mode, after an odd number of bytes, we must align to an
3444 even word boundary, unless the next instruction is a dc.b, ds.b
3446 if (flag_mri
&& (bytes
& 1) != 0)
3447 mri_pending_align
= 1;
3449 demand_empty_rest_of_line ();
3452 mri_comment_end (stop
, stopc
);
3456 s_nop (int ignore ATTRIBUTE_UNUSED
)
3463 #ifdef md_flush_pending_output
3464 md_flush_pending_output ();
3467 #ifdef md_cons_align
3473 demand_empty_rest_of_line ();
3476 start_off
= frag_now_fix ();
3479 #ifdef md_emit_single_noop
3480 md_emit_single_noop
;
3484 #ifndef md_single_noop_insn
3485 #define md_single_noop_insn "nop"
3487 /* md_assemble might modify its argument, so
3488 we must pass it a string that is writable. */
3489 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3490 as_fatal ("%s", xstrerror (errno
));
3492 /* Some targets assume that they can update input_line_pointer
3493 inside md_assemble, and, worse, that they can leave it
3494 assigned to the string pointer that was provided as an
3495 argument. So preserve ilp here. */
3496 char *saved_ilp
= input_line_pointer
;
3498 input_line_pointer
= saved_ilp
;
3501 #ifdef md_flush_pending_output
3502 md_flush_pending_output ();
3504 } while (exp
.X_op
== O_constant
3505 && exp
.X_add_number
> 0
3506 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3507 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3511 s_nops (int ignore ATTRIBUTE_UNUSED
)
3516 #ifdef md_flush_pending_output
3517 md_flush_pending_output ();
3520 #ifdef md_cons_align
3526 /* Note - this expression is tested for an absolute value in
3527 write.c:relax_segment(). */
3530 if (*input_line_pointer
== ',')
3532 ++input_line_pointer
;
3537 val
.X_op
= O_constant
;
3538 val
.X_add_number
= 0;
3541 if (val
.X_op
!= O_constant
)
3543 as_bad (_("unsupported variable nop control in .nops directive"));
3544 val
.X_op
= O_constant
;
3545 val
.X_add_number
= 0;
3547 else if (val
.X_add_number
< 0)
3549 as_warn (_("negative nop control byte, ignored"));
3550 val
.X_add_number
= 0;
3553 demand_empty_rest_of_line ();
3556 /* Ignore this directive if we are going to perform a second pass. */
3559 /* Store the no-op instruction control byte in the first byte of frag. */
3561 symbolS
*sym
= make_expr_symbol (&exp
);
3562 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3563 sym
, (offsetT
) 0, (char *) 0);
3564 *p
= val
.X_add_number
;
3567 /* Obtain the size of a floating point number, given a type. */
3570 float_length (int float_type
, int *pad_p
)
3572 int length
, pad
= 0;
3600 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3601 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3610 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3611 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3618 as_bad (_("unknown floating type '%c'"), float_type
);
3630 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3636 /* Skip any 0{letter} that may be present. Don't even check if the
3637 letter is legal. Someone may invent a "z" format and this routine
3638 has no use for such information. Lusers beware: you get
3639 diagnostics if your input is ill-conditioned. */
3640 if (input_line_pointer
[0] == '0'
3641 && ISALPHA (input_line_pointer
[1]))
3642 input_line_pointer
+= 2;
3644 /* Accept :xxxx, where the x's are hex digits, for a floating point
3645 with the exact digits specified. */
3646 if (input_line_pointer
[0] == ':')
3648 ++input_line_pointer
;
3649 length
= hex_float (float_type
, temp
);
3652 ignore_rest_of_line ();
3660 err
= md_atof (float_type
, temp
, &length
);
3661 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3662 know (err
!= NULL
|| length
> 0);
3665 as_bad (_("bad floating literal: %s"), err
);
3666 ignore_rest_of_line ();
3674 /* This is like s_space, but the value is a floating point number with
3675 the given precision. This is for the MRI dcb.s pseudo-op and
3679 s_float_space (int float_type
)
3683 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3687 #ifdef md_cons_align
3692 stop
= mri_comment_field (&stopc
);
3694 count
= get_absolute_expression ();
3697 if (*input_line_pointer
!= ',')
3701 flen
= float_length (float_type
, &pad
);
3703 memset (temp
, 0, flen
+= pad
);
3707 ++input_line_pointer
;
3709 flen
= parse_one_float (float_type
, temp
);
3715 mri_comment_end (stop
, stopc
);
3719 while (--count
>= 0)
3723 p
= frag_more (flen
);
3724 memcpy (p
, temp
, (unsigned int) flen
);
3727 demand_empty_rest_of_line ();
3730 mri_comment_end (stop
, stopc
);
3733 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3736 s_struct (int ignore ATTRIBUTE_UNUSED
)
3742 stop
= mri_comment_field (&stopc
);
3743 abs_section_offset
= get_absolute_expression ();
3744 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3745 /* The ELF backend needs to know that we are changing sections, so
3746 that .previous works correctly. */
3748 obj_elf_section_change_hook ();
3750 subseg_set (absolute_section
, 0);
3751 demand_empty_rest_of_line ();
3753 mri_comment_end (stop
, stopc
);
3757 s_text (int ignore ATTRIBUTE_UNUSED
)
3761 temp
= get_absolute_expression ();
3762 subseg_set (text_section
, (subsegT
) temp
);
3763 demand_empty_rest_of_line ();
3766 /* .weakref x, y sets x as an alias to y that, as long as y is not
3767 referenced directly, will cause y to become a weak symbol. */
3769 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3776 if ((name
= read_symbol_name ()) == NULL
)
3779 symbolP
= symbol_find_or_make (name
);
3781 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3783 if (!S_IS_VOLATILE (symbolP
))
3785 as_bad (_("symbol `%s' is already defined"), name
);
3788 symbolP
= symbol_clone (symbolP
, 1);
3789 S_CLEAR_VOLATILE (symbolP
);
3794 if (*input_line_pointer
!= ',')
3796 as_bad (_("expected comma after \"%s\""), name
);
3800 input_line_pointer
++;
3805 if ((name
= read_symbol_name ()) == NULL
)
3808 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3809 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3811 symbolP2
= symbol_find_or_make (name
);
3812 S_SET_WEAKREFD (symbolP2
);
3816 symbolS
*symp
= symbolP2
;
3818 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3820 expressionS
*expP
= symbol_get_value_expression (symp
);
3822 gas_assert (expP
->X_op
== O_symbol
3823 && expP
->X_add_number
== 0);
3824 symp
= expP
->X_add_symbol
;
3826 if (symp
== symbolP
)
3830 loop
= concat (S_GET_NAME (symbolP
),
3831 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3834 while (symp
!= symbolP
)
3836 char *old_loop
= loop
;
3838 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3839 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3840 (const char *) NULL
);
3844 as_bad (_("%s: would close weakref loop: %s"),
3845 S_GET_NAME (symbolP
), loop
);
3849 ignore_rest_of_line ();
3853 /* Short-circuiting instead of just checking here might speed
3854 things up a tiny little bit, but loop error messages would
3855 miss intermediate links. */
3856 /* symbolP2 = symp; */
3859 memset (&exp
, 0, sizeof (exp
));
3860 exp
.X_op
= O_symbol
;
3861 exp
.X_add_symbol
= symbolP2
;
3863 S_SET_SEGMENT (symbolP
, undefined_section
);
3864 symbol_set_value_expression (symbolP
, &exp
);
3865 symbol_set_frag (symbolP
, &zero_address_frag
);
3866 S_SET_WEAKREFR (symbolP
);
3868 demand_empty_rest_of_line ();
3873 ignore_rest_of_line ();
3879 /* Verify that we are at the end of a line. If not, issue an error and
3880 skip to EOL. This function may leave input_line_pointer one past
3881 buffer_limit, so should not be called from places that may
3882 dereference input_line_pointer unconditionally. Note that when the
3883 gas parser is switched to handling a string (where buffer_limit
3884 should be the size of the string excluding the NUL terminator) this
3885 will be one past the NUL; is_end_of_line(0) returns true. */
3888 demand_empty_rest_of_line (void)
3891 if (input_line_pointer
> buffer_limit
)
3893 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3894 input_line_pointer
++;
3897 if (ISPRINT (*input_line_pointer
))
3898 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3899 *input_line_pointer
);
3901 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3902 *input_line_pointer
);
3903 ignore_rest_of_line ();
3905 /* Return pointing just after end-of-line. */
3908 /* Silently advance to the end of line. Use this after already having
3909 issued an error about something bad. Like demand_empty_rest_of_line,
3910 this function may leave input_line_pointer one after buffer_limit;
3911 Don't call it from within expression parsing code in an attempt to
3912 silence further errors. */
3915 ignore_rest_of_line (void)
3917 while (input_line_pointer
<= buffer_limit
)
3918 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3920 /* Return pointing just after end-of-line. */
3923 /* Sets frag for given symbol to zero_address_frag, except when the
3924 symbol frag is already set to a dummy listing frag. */
3927 set_zero_frag (symbolS
*symbolP
)
3929 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3930 symbol_set_frag (symbolP
, &zero_address_frag
);
3933 /* In: Pointer to a symbol.
3934 Input_line_pointer->expression.
3936 Out: Input_line_pointer->just after any whitespace after expression.
3937 Tried to set symbol to value of expression.
3938 Will change symbols type, value, and frag; */
3941 pseudo_set (symbolS
*symbolP
)
3946 know (symbolP
); /* NULL pointer is logic error. */
3948 if (!S_IS_FORWARD_REF (symbolP
))
3949 (void) expression (&exp
);
3951 (void) deferred_expression (&exp
);
3953 if (exp
.X_op
== O_illegal
)
3954 as_bad (_("illegal expression"));
3955 else if (exp
.X_op
== O_absent
)
3956 as_bad (_("missing expression"));
3957 else if (exp
.X_op
== O_big
)
3959 if (exp
.X_add_number
> 0)
3960 as_bad (_("bignum invalid"));
3962 as_bad (_("floating point number invalid"));
3964 else if (exp
.X_op
== O_subtract
3965 && !S_IS_FORWARD_REF (symbolP
)
3966 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3967 && (symbol_get_frag (exp
.X_add_symbol
)
3968 == symbol_get_frag (exp
.X_op_symbol
)))
3970 exp
.X_op
= O_constant
;
3971 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3972 - S_GET_VALUE (exp
.X_op_symbol
));
3975 if (symbol_section_p (symbolP
))
3977 as_bad ("attempt to set value of section symbol");
3986 exp
.X_add_number
= 0;
3989 S_SET_SEGMENT (symbolP
, absolute_section
);
3990 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3991 set_zero_frag (symbolP
);
3995 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3996 if (S_IS_EXTERNAL (symbolP
))
3998 as_bad ("can't equate global symbol `%s' with register name",
3999 S_GET_NAME (symbolP
));
4003 symbol_set_value_expression (symbolP
, &exp
);
4004 S_SET_SEGMENT (symbolP
, reg_section
);
4005 set_zero_frag (symbolP
);
4009 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4010 /* For x=undef+const, create an expression symbol.
4011 For x=x+const, just update x except when x is an undefined symbol
4012 For x=defined+const, evaluate x. */
4013 if (symbolP
== exp
.X_add_symbol
4014 && (seg
!= undefined_section
4015 || !symbol_constant_p (symbolP
)))
4017 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4020 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4022 symbolS
*s
= exp
.X_add_symbol
;
4024 if (S_IS_COMMON (s
))
4025 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4026 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4028 S_SET_SEGMENT (symbolP
, seg
);
4029 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4030 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4031 copy_symbol_attributes (symbolP
, s
);
4034 S_SET_SEGMENT (symbolP
, undefined_section
);
4035 symbol_set_value_expression (symbolP
, &exp
);
4036 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4037 set_zero_frag (symbolP
);
4041 /* The value is some complex expression. */
4042 S_SET_SEGMENT (symbolP
, expr_section
);
4043 symbol_set_value_expression (symbolP
, &exp
);
4044 set_zero_frag (symbolP
);
4051 CONStruct more frag of .bytes, or .words etc.
4052 Should need_pass_2 be 1 then emit no frag(s).
4053 This understands EXPRESSIONS.
4057 This has a split personality. We use expression() to read the
4058 value. We can detect if the value won't fit in a byte or word.
4059 But we can't detect if expression() discarded significant digits
4060 in the case of a long. Not worth the crocks required to fix it. */
4062 /* Select a parser for cons expressions. */
4064 /* Some targets need to parse the expression in various fancy ways.
4065 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4066 (for example, the HPPA does this). Otherwise, you can define
4067 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4068 are defined, which is the normal case, then only simple expressions
4073 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4076 #ifndef TC_PARSE_CONS_EXPRESSION
4077 #ifdef REPEAT_CONS_EXPRESSIONS
4078 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4079 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4081 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4084 /* If we haven't gotten one yet, just call expression. */
4085 #ifndef TC_PARSE_CONS_EXPRESSION
4086 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4087 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4092 do_parse_cons_expression (expressionS
*exp
,
4093 int nbytes ATTRIBUTE_UNUSED
)
4095 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4099 /* Worker to do .byte etc statements.
4100 Clobbers input_line_pointer and checks end-of-line. */
4103 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4111 #ifdef md_flush_pending_output
4112 md_flush_pending_output ();
4116 stop
= mri_comment_field (&stopc
);
4118 if (is_it_end_of_statement ())
4120 demand_empty_rest_of_line ();
4122 mri_comment_end (stop
, stopc
);
4127 nbytes
= TC_ADDRESS_BYTES ();
4129 #ifdef md_cons_align
4130 md_cons_align (nbytes
);
4136 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4137 #ifdef TC_CONS_FIX_CHECK
4138 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4140 if (*cur_fix
!= NULL
)
4141 cur_fix
= &(*cur_fix
)->fx_next
;
4146 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4151 if (*input_line_pointer
== '"')
4153 as_bad (_("unexpected `\"' in expression"));
4154 ignore_rest_of_line ();
4158 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4163 if (exp
.X_op
== O_symbol
)
4164 exp
.X_op
= O_symbol_rva
;
4166 as_fatal (_("rva without symbol"));
4168 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4169 #ifdef TC_CONS_FIX_CHECK
4170 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4174 while (*input_line_pointer
++ == ',');
4176 /* In MRI mode, after an odd number of bytes, we must align to an
4177 even word boundary, unless the next instruction is a dc.b, ds.b
4179 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4180 mri_pending_align
= 1;
4182 input_line_pointer
--; /* Put terminator back into stream. */
4184 demand_empty_rest_of_line ();
4187 mri_comment_end (stop
, stopc
);
4193 cons_worker (size
, 0);
4199 cons_worker (size
, 1);
4202 /* .reloc offset, reloc_name, symbol+addend. */
4205 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4212 struct reloc_list
*reloc
;
4213 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4214 static const struct _bfd_rel bfd_relocs
[] =
4216 { "NONE", BFD_RELOC_NONE
},
4217 { "8", BFD_RELOC_8
},
4218 { "16", BFD_RELOC_16
},
4219 { "32", BFD_RELOC_32
},
4220 { "64", BFD_RELOC_64
}
4223 reloc
= XNEW (struct reloc_list
);
4226 stop
= mri_comment_field (&stopc
);
4235 as_bad (_("missing or bad offset expression"));
4238 exp
.X_add_symbol
= section_symbol (now_seg
);
4239 /* Mark the section symbol used in relocation so that it will be
4240 included in the symbol table. */
4241 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4242 exp
.X_op
= O_symbol
;
4245 if (exp
.X_add_number
== 0)
4247 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4252 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4257 if (*input_line_pointer
!= ',')
4259 as_bad (_("missing reloc type"));
4263 ++input_line_pointer
;
4265 c
= get_symbol_name (& r_name
);
4266 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4270 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4271 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4273 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4274 bfd_relocs
[i
].code
);
4279 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4280 *input_line_pointer
= c
;
4281 if (reloc
->u
.a
.howto
== NULL
)
4283 as_bad (_("unrecognized reloc type"));
4287 exp
.X_op
= O_absent
;
4288 SKIP_WHITESPACE_AFTER_NAME ();
4289 if (*input_line_pointer
== ',')
4291 ++input_line_pointer
;
4299 as_bad (_("bad reloc expression"));
4301 ignore_rest_of_line ();
4304 mri_comment_end (stop
, stopc
);
4307 reloc
->u
.a
.sym
= NULL
;
4308 reloc
->u
.a
.addend
= 0;
4311 reloc
->u
.a
.sym
= NULL
;
4312 reloc
->u
.a
.addend
= exp
.X_add_number
;
4315 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4316 reloc
->u
.a
.addend
= exp
.X_add_number
;
4319 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4320 reloc
->u
.a
.addend
= 0;
4324 reloc
->file
= as_where (&reloc
->line
);
4325 reloc
->next
= reloc_list
;
4328 demand_empty_rest_of_line ();
4330 mri_comment_end (stop
, stopc
);
4333 /* Put the contents of expression EXP into the object file using
4334 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4337 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4339 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4343 emit_expr_with_reloc (expressionS
*exp
,
4344 unsigned int nbytes
,
4345 TC_PARSE_CONS_RETURN_TYPE reloc
)
4349 valueT extra_digit
= 0;
4351 /* Don't do anything if we are going to make another pass. */
4356 dot_value
= frag_now_fix ();
4357 dot_frag
= frag_now
;
4361 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4362 appear as a four byte positive constant in the .line section,
4363 followed by a 2 byte 0xffff. Look for that case here. */
4364 if (strcmp (segment_name (now_seg
), ".line") != 0)
4366 else if (dwarf_line
>= 0
4368 && exp
->X_op
== O_constant
4369 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4370 listing_source_line ((unsigned int) dwarf_line
);
4371 else if (nbytes
== 4
4372 && exp
->X_op
== O_constant
4373 && exp
->X_add_number
>= 0)
4374 dwarf_line
= exp
->X_add_number
;
4378 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4379 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4380 AT_sibling (0x12) followed by a four byte address of the sibling
4381 followed by a 2 byte AT_name (0x38) followed by the name of the
4382 file. We look for that case here. */
4383 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4385 else if (dwarf_file
== 0
4387 && exp
->X_op
== O_constant
4388 && exp
->X_add_number
== 0x11)
4390 else if (dwarf_file
== 1
4392 && exp
->X_op
== O_constant
4393 && exp
->X_add_number
== 0x12)
4395 else if (dwarf_file
== 2
4398 else if (dwarf_file
== 3
4400 && exp
->X_op
== O_constant
4401 && exp
->X_add_number
== 0x38)
4406 /* The variable dwarf_file_string tells stringer that the string
4407 may be the name of the source file. */
4408 if (dwarf_file
== 4)
4409 dwarf_file_string
= 1;
4411 dwarf_file_string
= 0;
4415 if (check_eh_frame (exp
, &nbytes
))
4420 /* Handle a negative bignum. */
4422 && exp
->X_add_number
== 0
4423 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4424 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4427 unsigned long carry
;
4429 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4431 /* Negate the bignum: one's complement each digit and add 1. */
4433 for (i
= 0; i
< exp
->X_add_number
; i
++)
4437 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4440 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4441 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4444 /* We can ignore any carry out, because it will be handled by
4445 extra_digit if it is needed. */
4447 extra_digit
= (valueT
) -1;
4451 if (op
== O_absent
|| op
== O_illegal
)
4453 as_warn (_("zero assumed for missing expression"));
4454 exp
->X_add_number
= 0;
4457 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4459 as_bad (_("floating point number invalid"));
4460 exp
->X_add_number
= 0;
4463 else if (op
== O_register
)
4465 as_warn (_("register value used as expression"));
4469 /* Allow `.word 0' in the absolute section. */
4470 if (now_seg
== absolute_section
)
4472 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4473 as_bad (_("attempt to store value in absolute section"));
4474 abs_section_offset
+= nbytes
;
4478 /* Allow `.word 0' in BSS style sections. */
4479 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4480 as_bad (_("attempt to store non-zero value in section `%s'"),
4481 segment_name (now_seg
));
4483 p
= frag_more ((int) nbytes
);
4485 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4487 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4491 #ifndef WORKING_DOT_WORD
4492 /* If we have the difference of two symbols in a word, save it on
4493 the broken_words list. See the code in write.c. */
4494 if (op
== O_subtract
&& nbytes
== 2)
4496 struct broken_word
*x
;
4498 x
= XNEW (struct broken_word
);
4499 x
->next_broken_word
= broken_words
;
4502 x
->subseg
= now_subseg
;
4504 x
->word_goes_here
= p
;
4506 x
->add
= exp
->X_add_symbol
;
4507 x
->sub
= exp
->X_op_symbol
;
4508 x
->addnum
= exp
->X_add_number
;
4516 /* If we have an integer, but the number of bytes is too large to
4517 pass to md_number_to_chars, handle it as a bignum. */
4518 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4520 extra_digit
= exp
->X_unsigned
? 0 : -1;
4521 convert_to_bignum (exp
, !exp
->X_unsigned
);
4525 if (op
== O_constant
)
4532 /* JF << of >= number of bits in the object is undefined. In
4533 particular SPARC (Sun 4) has problems. */
4534 if (nbytes
>= sizeof (valueT
))
4536 know (nbytes
== sizeof (valueT
));
4541 /* Don't store these bits. */
4542 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4545 unmask
= ~mask
; /* Do store these bits. */
4548 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4549 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4552 get
= exp
->X_add_number
;
4554 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4556 /* Leading bits contain both 0s & 1s. */
4557 as_warn (_("value 0x%" PRIx64
" truncated to 0x%" PRIx64
),
4558 (uint64_t) get
, (uint64_t) use
);
4560 /* Put bytes in right order. */
4561 md_number_to_chars (p
, use
, (int) nbytes
);
4563 else if (op
== O_big
)
4566 LITTLENUM_TYPE
*nums
;
4568 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4571 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4575 LITTLENUM_TYPE sign
= 0;
4576 if ((generic_bignum
[--i
]
4577 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4578 sign
= ~(LITTLENUM_TYPE
) 0;
4580 while (++i
< exp
->X_add_number
)
4581 if (generic_bignum
[i
] != sign
)
4584 else if (nbytes
== 1)
4586 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4587 Check that bits 8.. of generic_bignum[0] match bit 7
4588 and that they match all of generic_bignum[1..exp->X_add_number]. */
4589 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4590 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4592 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4594 while (++i
< exp
->X_add_number
)
4595 if (generic_bignum
[i
] != sign
)
4600 if (i
< exp
->X_add_number
)
4601 as_warn (ngettext ("bignum truncated to %d byte",
4602 "bignum truncated to %d bytes",
4610 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4613 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4615 if (target_big_endian
)
4617 while (nbytes
> size
)
4619 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4620 nbytes
-= CHARS_PER_LITTLENUM
;
4621 p
+= CHARS_PER_LITTLENUM
;
4624 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4625 while (size
>= CHARS_PER_LITTLENUM
)
4628 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4629 size
-= CHARS_PER_LITTLENUM
;
4630 p
+= CHARS_PER_LITTLENUM
;
4635 nums
= generic_bignum
;
4636 while (size
>= CHARS_PER_LITTLENUM
)
4638 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4640 size
-= CHARS_PER_LITTLENUM
;
4641 p
+= CHARS_PER_LITTLENUM
;
4642 nbytes
-= CHARS_PER_LITTLENUM
;
4645 while (nbytes
>= CHARS_PER_LITTLENUM
)
4647 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4648 nbytes
-= CHARS_PER_LITTLENUM
;
4649 p
+= CHARS_PER_LITTLENUM
;
4654 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4658 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4659 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4662 unsigned int size
= nbytes
;
4664 memset (p
, 0, size
);
4666 /* Generate a fixS to record the symbol value. */
4668 #ifdef TC_CONS_FIX_NEW
4669 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4671 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4673 reloc_howto_type
*reloc_howto
;
4675 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4676 size
= bfd_get_reloc_size (reloc_howto
);
4680 as_bad (ngettext ("%s relocations do not fit in %u byte",
4681 "%s relocations do not fit in %u bytes",
4683 reloc_howto
->name
, nbytes
);
4686 else if (target_big_endian
)
4687 offset
= nbytes
- size
;
4708 as_bad (_("unsupported BFD relocation size %u"), size
);
4711 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4716 /* Handle an MRI style string expression. */
4720 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4722 if (*input_line_pointer
!= '\''
4723 && (input_line_pointer
[1] != '\''
4724 || (*input_line_pointer
!= 'A'
4725 && *input_line_pointer
!= 'E')))
4726 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4730 unsigned int result
= 0;
4732 /* An MRI style string. Cut into as many bytes as will fit into
4733 a nbyte chunk, left justify if necessary, and separate with
4734 commas so we can try again later. */
4735 if (*input_line_pointer
== 'A')
4736 ++input_line_pointer
;
4737 else if (*input_line_pointer
== 'E')
4739 as_bad (_("EBCDIC constants are not supported"));
4740 ++input_line_pointer
;
4743 input_line_pointer
++;
4744 for (scan
= 0; scan
< nbytes
; scan
++)
4746 if (*input_line_pointer
== '\'')
4748 if (input_line_pointer
[1] == '\'')
4750 input_line_pointer
++;
4755 result
= (result
<< 8) | (*input_line_pointer
++);
4759 while (scan
< nbytes
)
4765 /* Create correct expression. */
4766 exp
->X_op
= O_constant
;
4767 exp
->X_add_number
= result
;
4769 /* Fake it so that we can read the next char too. */
4770 if (input_line_pointer
[0] != '\'' ||
4771 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4773 input_line_pointer
-= 2;
4774 input_line_pointer
[0] = ',';
4775 input_line_pointer
[1] = '\'';
4778 input_line_pointer
++;
4781 #endif /* TC_M68K */
4783 #ifdef REPEAT_CONS_EXPRESSIONS
4785 /* Parse a repeat expression for cons. This is used by the MIPS
4786 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4787 object file COUNT times.
4789 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4792 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4799 if (*input_line_pointer
!= ':')
4801 /* No repeat count. */
4805 ++input_line_pointer
;
4806 expression (&count
);
4807 if (count
.X_op
!= O_constant
4808 || count
.X_add_number
<= 0)
4810 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4814 /* The cons function is going to output this expression once. So we
4815 output it count - 1 times. */
4816 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4817 emit_expr (exp
, nbytes
);
4820 #endif /* REPEAT_CONS_EXPRESSIONS */
4822 /* Parse a floating point number represented as a hex constant. This
4823 permits users to specify the exact bits they want in the floating
4827 hex_float (int float_type
, char *bytes
)
4829 int pad
, length
= float_length (float_type
, &pad
);
4835 /* It would be nice if we could go through expression to parse the
4836 hex constant, but if we get a bignum it's a pain to sort it into
4837 the buffer correctly. */
4839 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4843 /* The MRI assembler accepts arbitrary underscores strewn about
4844 through the hex constant, so we ignore them as well. */
4845 if (*input_line_pointer
== '_')
4847 ++input_line_pointer
;
4853 as_warn (_("floating point constant too large"));
4856 d
= hex_value (*input_line_pointer
) << 4;
4857 ++input_line_pointer
;
4858 while (*input_line_pointer
== '_')
4859 ++input_line_pointer
;
4860 if (hex_p (*input_line_pointer
))
4862 d
+= hex_value (*input_line_pointer
);
4863 ++input_line_pointer
;
4865 if (target_big_endian
)
4868 bytes
[length
- i
- 1] = d
;
4874 if (target_big_endian
)
4875 memset (bytes
+ i
, 0, length
- i
);
4877 memset (bytes
, 0, length
- i
);
4880 memset (bytes
+ length
, 0, pad
);
4882 return length
+ pad
;
4887 CONStruct some more frag chars of .floats .ffloats etc.
4888 Makes 0 or more new frags.
4889 If need_pass_2 == 1, no frags are emitted.
4890 This understands only floating literals, not expressions. Sorry.
4892 A floating constant is defined by atof_generic(), except it is preceded
4893 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4894 reading, I decided to be incompatible. This always tries to give you
4895 rounded bits to the precision of the pseudo-op. Former AS did premature
4896 truncation, restored noisy bits instead of trailing 0s AND gave you
4897 a choice of 2 flavours of noise according to which of 2 floating-point
4898 scanners you directed AS to use.
4900 In: input_line_pointer->whitespace before, or '0' of flonum. */
4903 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4904 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4907 int length
; /* Number of chars in an object. */
4908 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4910 if (is_it_end_of_statement ())
4912 demand_empty_rest_of_line ();
4916 if (now_seg
== absolute_section
)
4918 as_bad (_("attempt to store float in absolute section"));
4919 ignore_rest_of_line ();
4925 as_bad (_("attempt to store float in section `%s'"),
4926 segment_name (now_seg
));
4927 ignore_rest_of_line ();
4931 #ifdef md_flush_pending_output
4932 md_flush_pending_output ();
4935 #ifdef md_cons_align
4941 length
= parse_one_float (float_type
, temp
);
4951 #ifdef REPEAT_CONS_EXPRESSIONS
4952 if (*input_line_pointer
== ':')
4954 expressionS count_exp
;
4956 ++input_line_pointer
;
4957 expression (&count_exp
);
4959 if (count_exp
.X_op
!= O_constant
4960 || count_exp
.X_add_number
<= 0)
4961 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4963 count
= count_exp
.X_add_number
;
4967 while (--count
>= 0)
4969 p
= frag_more (length
);
4970 memcpy (p
, temp
, (unsigned int) length
);
4975 while (*input_line_pointer
++ == ',');
4977 /* Put terminator back into stream. */
4978 --input_line_pointer
;
4979 demand_empty_rest_of_line ();
4984 Note - we are using the DWARF standard's definition of LEB128 encoding
4985 where each 7-bit value is a stored in a byte, *not* an octet. This
4986 means that on targets where a byte contains multiple octets there is
4987 a *huge waste of space*. (This also means that we do not have to
4988 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4991 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4992 we would then have to consider whether multiple, successive LEB128
4993 values should be packed into the bytes without padding (bad idea) or
4994 whether each LEB128 number is padded out to a whole number of bytes.
4995 Plus you have to decide on the endianness of packing octets into a
4998 /* Return the size of a LEB128 value in bytes. */
5000 static inline unsigned int
5001 sizeof_sleb128 (offsetT value
)
5008 byte
= (value
& 0x7f);
5009 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5010 Fortunately, we can structure things so that the extra work reduces
5011 to a noop on systems that do things "properly". */
5012 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5015 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5016 || ((value
== -1) && ((byte
& 0x40) != 0))));
5021 static inline unsigned int
5022 sizeof_uleb128 (valueT value
)
5037 sizeof_leb128 (valueT value
, int sign
)
5040 return sizeof_sleb128 ((offsetT
) value
);
5042 return sizeof_uleb128 (value
);
5045 /* Output a LEB128 value. Returns the number of bytes used. */
5047 static inline unsigned int
5048 output_sleb128 (char *p
, offsetT value
)
5055 unsigned byte
= (value
& 0x7f);
5057 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5058 Fortunately, we can structure things so that the extra work reduces
5059 to a noop on systems that do things "properly". */
5060 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5062 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5063 || ((value
== -1) && ((byte
& 0x40) != 0))));
5074 static inline unsigned int
5075 output_uleb128 (char *p
, valueT value
)
5081 unsigned byte
= (value
& 0x7f);
5085 /* More bytes to follow. */
5096 output_leb128 (char *p
, valueT value
, int sign
)
5099 return output_sleb128 (p
, (offsetT
) value
);
5101 return output_uleb128 (p
, value
);
5104 /* Do the same for bignums. We combine sizeof with output here in that
5105 we don't output for NULL values of P. It isn't really as critical as
5106 for "normal" values that this be streamlined. Returns the number of
5109 static inline unsigned int
5110 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5117 /* Strip leading sign extensions off the bignum. */
5119 && bignum
[size
- 1] == LITTLENUM_MASK
5120 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5125 /* OR in the next part of the littlenum. */
5126 val
|= (*bignum
<< loaded
);
5127 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5131 /* Add bytes until there are less than 7 bits left in VAL
5132 or until every non-sign bit has been written. */
5139 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5146 while ((byte
& 0x80) != 0 && loaded
>= 7);
5150 /* Mop up any left-over bits (of which there will be less than 7). */
5151 if ((byte
& 0x80) != 0)
5153 /* Sign-extend VAL. */
5154 if (val
& (1 << (loaded
- 1)))
5155 val
|= ~0U << loaded
;
5164 static inline unsigned int
5165 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5172 /* Strip leading zeros off the bignum. */
5173 /* XXX: Is this needed? */
5174 while (size
> 0 && bignum
[size
- 1] == 0)
5179 if (loaded
< 7 && size
> 0)
5181 val
|= (*bignum
<< loaded
);
5182 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5191 if (size
> 0 || val
)
5198 while (byte
& 0x80);
5204 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5207 return output_big_sleb128 (p
, bignum
, size
);
5209 return output_big_uleb128 (p
, bignum
, size
);
5212 /* Generate the appropriate fragments for a given expression to emit a
5213 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5216 emit_leb128_expr (expressionS
*exp
, int sign
)
5218 operatorT op
= exp
->X_op
;
5219 unsigned int nbytes
;
5221 if (op
== O_absent
|| op
== O_illegal
)
5223 as_warn (_("zero assumed for missing expression"));
5224 exp
->X_add_number
= 0;
5227 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5229 as_bad (_("floating point number invalid"));
5230 exp
->X_add_number
= 0;
5233 else if (op
== O_register
)
5235 as_warn (_("register value used as expression"));
5238 else if (op
== O_constant
5240 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5242 /* We're outputting a signed leb128 and the sign of X_add_number
5243 doesn't reflect the sign of the original value. Convert EXP
5244 to a correctly-extended bignum instead. */
5245 convert_to_bignum (exp
, exp
->X_extrabit
);
5249 if (now_seg
== absolute_section
)
5251 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5252 as_bad (_("attempt to store value in absolute section"));
5253 abs_section_offset
++;
5257 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5258 as_bad (_("attempt to store non-zero value in section `%s'"),
5259 segment_name (now_seg
));
5261 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5262 a signal that this is leb128 data. It shouldn't optimize this away. */
5263 nbytes
= (unsigned int) -1;
5264 if (check_eh_frame (exp
, &nbytes
))
5267 /* Let the backend know that subsequent data may be byte aligned. */
5268 #ifdef md_cons_align
5272 if (op
== O_constant
)
5274 /* If we've got a constant, emit the thing directly right now. */
5276 valueT value
= exp
->X_add_number
;
5280 size
= sizeof_leb128 (value
, sign
);
5281 p
= frag_more (size
);
5282 if (output_leb128 (p
, value
, sign
) > size
)
5285 else if (op
== O_big
)
5287 /* O_big is a different sort of constant. */
5288 int nbr_digits
= exp
->X_add_number
;
5292 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5293 a signed number. Unary operators like - or ~ always extend the
5294 bignum to its largest size. */
5296 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5297 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5298 generic_bignum
[nbr_digits
++] = 0;
5300 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5301 p
= frag_more (size
);
5302 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5307 /* Otherwise, we have to create a variable sized fragment and
5308 resolve things later. */
5310 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5311 make_expr_symbol (exp
), 0, (char *) NULL
);
5315 /* Parse the .sleb128 and .uleb128 pseudos. */
5322 #ifdef md_flush_pending_output
5323 md_flush_pending_output ();
5329 emit_leb128_expr (&exp
, sign
);
5331 while (*input_line_pointer
++ == ',');
5333 input_line_pointer
--;
5334 demand_empty_rest_of_line ();
5338 stringer_append_char (int c
, int bitsize
)
5341 as_bad (_("attempt to store non-empty string in section `%s'"),
5342 segment_name (now_seg
));
5344 if (!target_big_endian
)
5345 FRAG_APPEND_1_CHAR (c
);
5350 FRAG_APPEND_1_CHAR (0);
5351 FRAG_APPEND_1_CHAR (0);
5352 FRAG_APPEND_1_CHAR (0);
5353 FRAG_APPEND_1_CHAR (0);
5356 FRAG_APPEND_1_CHAR (0);
5357 FRAG_APPEND_1_CHAR (0);
5360 FRAG_APPEND_1_CHAR (0);
5365 /* Called with invalid bitsize argument. */
5369 if (target_big_endian
)
5370 FRAG_APPEND_1_CHAR (c
);
5373 /* Worker to do .ascii etc statements.
5374 Reads 0 or more ',' separated, double-quoted strings.
5375 Caller should have checked need_pass_2 is FALSE because we don't
5377 Checks for end-of-line.
5378 BITS_APPENDZERO says how many bits are in a target char.
5379 The bottom bit is set if a NUL char should be appended to the strings. */
5382 stringer (int bits_appendzero
)
5384 const int bitsize
= bits_appendzero
& ~7;
5385 const int append_zero
= bits_appendzero
& 1;
5387 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5391 #ifdef md_flush_pending_output
5392 md_flush_pending_output ();
5395 #ifdef md_cons_align
5399 /* If we have been switched into the abs_section then we
5400 will not have an obstack onto which we can hang strings. */
5401 if (now_seg
== absolute_section
)
5403 as_bad (_("strings must be placed into a section"));
5404 ignore_rest_of_line ();
5408 /* The following awkward logic is to parse ZERO or more strings,
5409 comma separated. Recall a string expression includes spaces
5410 before the opening '\"' and spaces after the closing '\"'.
5411 We fake a leading ',' if there is (supposed to be)
5412 a 1st, expression. We keep demanding expressions for each ','. */
5413 if (is_it_end_of_statement ())
5415 c
= 0; /* Skip loop. */
5416 ++input_line_pointer
; /* Compensate for end of loop. */
5420 c
= ','; /* Do loop. */
5423 while (c
== ',' || c
== '<' || c
== '"')
5426 switch (*input_line_pointer
)
5429 ++input_line_pointer
; /*->1st char of string. */
5430 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5431 start
= input_line_pointer
;
5434 while (is_a_char (c
= next_char_of_string ()))
5435 stringer_append_char (c
, bitsize
);
5437 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5438 SKIP_ALL_WHITESPACE ();
5439 if (*input_line_pointer
== '"')
5443 stringer_append_char (0, bitsize
);
5445 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5446 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5447 will emit .string with a filename in the .debug section
5448 after a sequence of constants. See the comment in
5449 emit_expr for the sequence. emit_expr will set
5450 dwarf_file_string to non-zero if this string might be a
5451 source file name. */
5452 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5453 dwarf_file_string
= 0;
5454 else if (dwarf_file_string
)
5456 c
= input_line_pointer
[-1];
5457 input_line_pointer
[-1] = '\0';
5458 listing_source_file (start
);
5459 input_line_pointer
[-1] = c
;
5465 input_line_pointer
++;
5466 c
= get_single_number ();
5467 stringer_append_char (c
, bitsize
);
5468 if (*input_line_pointer
!= '>')
5470 as_bad (_("expected <nn>"));
5471 ignore_rest_of_line ();
5474 input_line_pointer
++;
5477 input_line_pointer
++;
5481 c
= *input_line_pointer
;
5484 demand_empty_rest_of_line ();
5487 /* FIXME-SOMEDAY: I had trouble here on characters with the
5488 high bits set. We'll probably also have trouble with
5489 multibyte chars, wide chars, etc. Also be careful about
5490 returning values bigger than 1 byte. xoxorich. */
5493 next_char_of_string (void)
5497 c
= *input_line_pointer
++ & CHAR_MASK
;
5501 /* PR 20902: Do not advance past the end of the buffer. */
5502 -- input_line_pointer
;
5511 as_warn (_("unterminated string; newline inserted"));
5512 bump_line_counters ();
5516 if (!TC_STRING_ESCAPES
)
5518 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5546 break; /* As itself. */
5562 for (i
= 0, number
= 0;
5563 ISDIGIT (c
) && i
< 3;
5564 c
= *input_line_pointer
++, i
++)
5566 number
= number
* 8 + c
- '0';
5569 c
= number
& CHAR_MASK
;
5571 --input_line_pointer
;
5580 c
= *input_line_pointer
++;
5581 while (ISXDIGIT (c
))
5584 number
= number
* 16 + c
- '0';
5585 else if (ISUPPER (c
))
5586 number
= number
* 16 + c
- 'A' + 10;
5588 number
= number
* 16 + c
- 'a' + 10;
5589 c
= *input_line_pointer
++;
5591 c
= number
& CHAR_MASK
;
5592 --input_line_pointer
;
5597 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5598 as_warn (_("unterminated string; newline inserted"));
5600 bump_line_counters ();
5604 /* Do not advance past the end of the buffer. */
5605 -- input_line_pointer
;
5611 #ifdef ONLY_STANDARD_ESCAPES
5612 as_bad (_("bad escaped character in string"));
5614 #endif /* ONLY_STANDARD_ESCAPES */
5627 get_segmented_expression (expressionS
*expP
)
5631 retval
= expression (expP
);
5632 if (expP
->X_op
== O_illegal
5633 || expP
->X_op
== O_absent
5634 || expP
->X_op
== O_big
)
5636 as_bad (_("expected address expression"));
5637 expP
->X_op
= O_constant
;
5638 expP
->X_add_number
= 0;
5639 retval
= absolute_section
;
5645 get_known_segmented_expression (expressionS
*expP
)
5647 segT retval
= get_segmented_expression (expP
);
5649 if (retval
== undefined_section
)
5651 /* There is no easy way to extract the undefined symbol from the
5653 if (expP
->X_add_symbol
!= NULL
5654 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5655 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5656 S_GET_NAME (expP
->X_add_symbol
));
5658 as_warn (_("some symbol undefined; zero assumed"));
5659 retval
= absolute_section
;
5660 expP
->X_op
= O_constant
;
5661 expP
->X_add_number
= 0;
5666 char /* Return terminator. */
5667 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5669 /* FIXME: val_pointer should probably be offsetT *. */
5670 *val_pointer
= (long) get_absolute_expression ();
5671 return (*input_line_pointer
++);
5674 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5675 Give a warning if that happens. */
5678 demand_copy_C_string (int *len_pointer
)
5682 if ((s
= demand_copy_string (len_pointer
)) != 0)
5686 for (len
= *len_pointer
; len
> 0; len
--)
5688 if (s
[len
- 1] == 0)
5692 as_bad (_("this string may not contain \'\\0\'"));
5701 /* Demand string, but return a safe (=private) copy of the string.
5702 Return NULL if we can't read a string here. */
5705 demand_copy_string (int *lenP
)
5713 if (*input_line_pointer
== '\"')
5715 input_line_pointer
++; /* Skip opening quote. */
5717 while (is_a_char (c
= next_char_of_string ()))
5719 obstack_1grow (¬es
, c
);
5722 /* JF this next line is so demand_copy_C_string will return a
5723 null terminated string. */
5724 obstack_1grow (¬es
, '\0');
5725 retval
= (char *) obstack_finish (¬es
);
5729 as_bad (_("missing string"));
5731 ignore_rest_of_line ();
5737 /* In: Input_line_pointer->next character.
5739 Do: Skip input_line_pointer over all whitespace.
5741 Out: 1 if input_line_pointer->end-of-line. */
5744 is_it_end_of_statement (void)
5747 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5751 equals (char *sym_name
, int reassign
)
5756 input_line_pointer
++;
5757 if (*input_line_pointer
== '=')
5758 input_line_pointer
++;
5759 if (reassign
< 0 && *input_line_pointer
== '=')
5760 input_line_pointer
++;
5762 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5763 input_line_pointer
++;
5766 stop
= mri_comment_field (&stopc
);
5768 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5772 demand_empty_rest_of_line ();
5773 mri_comment_end (stop
, stopc
);
5777 /* Open FILENAME, first trying the unadorned file name, then if that
5778 fails and the file name is not an absolute path, attempt to open
5779 the file in current -I include paths. PATH is a preallocated
5780 buffer which will be set to the file opened, or FILENAME if no file
5784 search_and_open (const char *filename
, char *path
)
5786 FILE *f
= fopen (filename
, FOPEN_RB
);
5787 if (f
== NULL
&& !IS_ABSOLUTE_PATH (filename
))
5789 for (size_t i
= 0; i
< include_dir_count
; i
++)
5791 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5792 f
= fopen (path
, FOPEN_RB
);
5797 strcpy (path
, filename
);
5801 /* .incbin -- include a file verbatim at the current location. */
5804 s_incbin (int x ATTRIBUTE_UNUSED
)
5815 #ifdef md_flush_pending_output
5816 md_flush_pending_output ();
5819 #ifdef md_cons_align
5824 filename
= demand_copy_string (& len
);
5825 if (filename
== NULL
)
5830 /* Look for optional skip and count. */
5831 if (* input_line_pointer
== ',')
5833 ++ input_line_pointer
;
5834 skip
= get_absolute_expression ();
5838 if (* input_line_pointer
== ',')
5840 ++ input_line_pointer
;
5842 count
= get_absolute_expression ();
5844 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5850 demand_empty_rest_of_line ();
5852 path
= XNEWVEC (char, len
+ include_dir_maxlen
+ 2);
5853 binfile
= search_and_open (filename
, path
);
5855 if (binfile
== NULL
)
5856 as_bad (_("file not found: %s"), filename
);
5860 struct stat filestat
;
5862 if (fstat (fileno (binfile
), &filestat
) != 0
5863 || ! S_ISREG (filestat
.st_mode
)
5864 || S_ISDIR (filestat
.st_mode
))
5866 as_bad (_("unable to include `%s'"), path
);
5870 register_dependency (path
);
5872 /* Compute the length of the file. */
5873 if (fseek (binfile
, 0, SEEK_END
) != 0)
5875 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5878 file_len
= ftell (binfile
);
5880 /* If a count was not specified use the remainder of the file. */
5882 count
= file_len
- skip
;
5884 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5886 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5887 skip
, count
, file_len
);
5891 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5893 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5897 /* Allocate frag space and store file contents in it. */
5898 binfrag
= frag_more (count
);
5900 bytes
= fread (binfrag
, 1, count
, binfile
);
5902 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5903 path
, bytes
, count
);
5906 if (binfile
!= NULL
)
5911 /* .include -- include a file at this point. */
5914 s_include (int arg ATTRIBUTE_UNUSED
)
5923 filename
= demand_copy_string (&i
);
5924 if (filename
== NULL
)
5926 /* demand_copy_string has already printed an error and
5927 called ignore_rest_of_line. */
5935 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5936 && *input_line_pointer
!= ' '
5937 && *input_line_pointer
!= '\t')
5939 obstack_1grow (¬es
, *input_line_pointer
);
5940 ++input_line_pointer
;
5944 obstack_1grow (¬es
, '\0');
5945 filename
= (char *) obstack_finish (¬es
);
5946 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5947 ++input_line_pointer
;
5950 demand_empty_rest_of_line ();
5952 path
= notes_alloc (i
+ include_dir_maxlen
+ 2);
5953 try_file
= search_and_open (filename
, path
);
5957 register_dependency (path
);
5958 input_scrub_insert_file (path
);
5962 init_include_dir (void)
5964 include_dirs
= XNEWVEC (const char *, 1);
5965 include_dirs
[0] = "."; /* Current dir. */
5966 include_dir_count
= 1;
5967 include_dir_maxlen
= 1;
5971 add_include_dir (char *path
)
5973 include_dir_count
++;
5974 include_dirs
= XRESIZEVEC (const char *, include_dirs
, include_dir_count
);
5975 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5977 size_t i
= strlen (path
);
5978 if (i
> include_dir_maxlen
)
5979 include_dir_maxlen
= i
;
5982 /* Output debugging information to denote the source file. */
5985 generate_file_debug (void)
5987 if (debug_type
== DEBUG_STABS
)
5988 stabs_generate_asm_file ();
5991 /* Output line number debugging information for the current source line. */
5994 generate_lineno_debug (void)
5998 case DEBUG_UNSPECIFIED
:
6003 stabs_generate_asm_lineno ();
6006 ecoff_generate_asm_lineno ();
6009 /* ??? We could here indicate to dwarf2dbg.c that something
6010 has changed. However, since there is additional backend
6011 support that is required (calling dwarf2_emit_insn), we
6012 let dwarf2dbg.c call as_where on its own. */
6014 case DEBUG_CODEVIEW
:
6015 codeview_generate_asm_lineno ();
6020 /* Output debugging information to mark a function entry point or end point.
6021 END_P is zero for .func, and non-zero for .endfunc. */
6026 do_s_func (end_p
, NULL
);
6029 /* Subroutine of s_func so targets can choose a different default prefix.
6030 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6033 do_s_func (int end_p
, const char *default_prefix
)
6037 if (current_name
== NULL
)
6039 as_bad (_("missing .func"));
6040 ignore_rest_of_line ();
6044 if (debug_type
== DEBUG_STABS
)
6045 stabs_generate_asm_endfunc (current_name
, current_label
);
6047 current_name
= current_label
= NULL
;
6052 char delim1
, delim2
;
6054 if (current_name
!= NULL
)
6056 as_bad (_(".endfunc missing for previous .func"));
6057 ignore_rest_of_line ();
6061 delim1
= get_symbol_name (& name
);
6062 name
= xstrdup (name
);
6063 *input_line_pointer
= delim1
;
6064 SKIP_WHITESPACE_AFTER_NAME ();
6065 if (*input_line_pointer
!= ',')
6069 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6070 as_fatal ("%s", xstrerror (errno
));
6074 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6075 /* Missing entry point, use function's name with the leading
6079 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6080 as_fatal ("%s", xstrerror (errno
));
6088 ++input_line_pointer
;
6090 delim2
= get_symbol_name (& label
);
6091 label
= xstrdup (label
);
6092 restore_line_pointer (delim2
);
6095 if (debug_type
== DEBUG_STABS
)
6096 stabs_generate_asm_func (name
, label
);
6098 current_name
= name
;
6099 current_label
= label
;
6102 demand_empty_rest_of_line ();
6105 #ifdef HANDLE_BUNDLE
6108 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6110 unsigned int align
= get_absolute_expression ();
6112 demand_empty_rest_of_line ();
6114 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6115 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6116 (unsigned int) TC_ALIGN_LIMIT
);
6118 if (bundle_lock_frag
!= NULL
)
6120 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6124 bundle_align_p2
= align
;
6128 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6130 demand_empty_rest_of_line ();
6132 if (bundle_align_p2
== 0)
6134 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6138 if (bundle_lock_depth
== 0)
6140 bundle_lock_frchain
= frchain_now
;
6141 bundle_lock_frag
= start_bundle ();
6143 ++bundle_lock_depth
;
6147 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6151 demand_empty_rest_of_line ();
6153 if (bundle_lock_frag
== NULL
)
6155 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6159 gas_assert (bundle_align_p2
> 0);
6161 gas_assert (bundle_lock_depth
> 0);
6162 if (--bundle_lock_depth
> 0)
6165 size
= pending_bundle_size (bundle_lock_frag
);
6167 if (size
> 1U << bundle_align_p2
)
6168 as_bad (_(".bundle_lock sequence is %u bytes, "
6169 "but bundle size is only %u bytes"),
6170 size
, 1u << bundle_align_p2
);
6172 finish_bundle (bundle_lock_frag
, size
);
6174 bundle_lock_frag
= NULL
;
6175 bundle_lock_frchain
= NULL
;
6178 #endif /* HANDLE_BUNDLE */
6181 s_ignore (int arg ATTRIBUTE_UNUSED
)
6183 ignore_rest_of_line ();
6187 read_print_statistics (FILE *file
)
6189 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6192 /* Inserts the given line into the input stream.
6194 This call avoids macro/conditionals nesting checking, since the contents of
6195 the line are assumed to replace the contents of a line already scanned.
6197 An appropriate use of this function would be substitution of input lines when
6198 called by md_start_line_hook(). The given line is assumed to already be
6199 properly scrubbed. */
6202 input_scrub_insert_line (const char *line
)
6205 size_t len
= strlen (line
);
6206 sb_build (&newline
, len
);
6207 sb_add_buffer (&newline
, line
, len
);
6208 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6210 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6213 /* Insert a file into the input stream; the path must resolve to an actual
6214 file; no include path searching or dependency registering is performed. */
6217 input_scrub_insert_file (char *path
)
6219 input_scrub_include_file (path
, input_line_pointer
);
6220 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6223 /* Find the end of a line, considering quotation and escaping of quotes. */
6225 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6226 # define TC_SINGLE_QUOTE_STRINGS 1
6230 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6233 char inquote
= '\0';
6236 while (!is_end_of_line
[(unsigned char) *s
]
6237 || (inquote
&& !ISCNTRL (*s
))
6238 || (inquote
== '\'' && flag_mri
)
6239 #ifdef TC_EOL_IN_INSN
6240 || (insn
&& TC_EOL_IN_INSN (s
))
6242 /* PR 6926: When we are parsing the body of a macro the sequence
6243 \@ is special - it refers to the invocation count. If the @
6244 character happens to be registered as a line-separator character
6245 by the target, then the is_end_of_line[] test above will have
6246 returned true, but we need to ignore the line separating
6247 semantics in this particular case. */
6248 || (in_macro
&& inescape
&& *s
== '@')
6251 if (mri_string
&& *s
== '\'')
6255 else if (*s
== '\\')
6259 #ifdef TC_SINGLE_QUOTE_STRINGS
6260 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6267 as_warn (_("missing closing `%c'"), inquote
);
6268 if (inescape
&& !ignore_input ())
6269 as_warn (_("stray `\\'"));
6274 find_end_of_line (char *s
, int mri_string
)
6276 return _find_end_of_line (s
, mri_string
, 0, 0);
6279 static char *saved_ilp
;
6280 static char *saved_limit
;
6282 /* Use BUF as a temporary input pointer for calling other functions in this
6283 file. BUF must be a C string, so that its end can be found by strlen.
6284 Also sets the buffer_limit variable (local to this file) so that buffer
6285 overruns should not occur. Saves the current input line pointer so that
6286 it can be restored by calling restore_ilp().
6288 Does not support recursion. */
6291 temp_ilp (char *buf
)
6293 gas_assert (saved_ilp
== NULL
);
6294 gas_assert (buf
!= NULL
);
6296 saved_ilp
= input_line_pointer
;
6297 saved_limit
= buffer_limit
;
6298 /* Prevent the assert in restore_ilp from triggering if
6299 the input_line_pointer has not yet been initialised. */
6300 if (saved_ilp
== NULL
)
6301 saved_limit
= saved_ilp
= (char *) "";
6303 input_line_pointer
= buf
;
6304 buffer_limit
= buf
+ strlen (buf
);
6305 input_from_string
= true;
6308 /* Restore a saved input line pointer. */
6313 gas_assert (saved_ilp
!= NULL
);
6315 input_line_pointer
= saved_ilp
;
6316 buffer_limit
= saved_limit
;
6317 input_from_string
= false;