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 /* Make sure symbol_equated_p() recognizes the symbol as an equate. */
4004 exp
.X_add_symbol
= make_expr_symbol (&exp
);
4005 exp
.X_add_number
= 0;
4006 exp
.X_op
= O_symbol
;
4007 symbol_set_value_expression (symbolP
, &exp
);
4008 S_SET_SEGMENT (symbolP
, reg_section
);
4009 set_zero_frag (symbolP
);
4013 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
4014 /* For x=undef+const, create an expression symbol.
4015 For x=x+const, just update x except when x is an undefined symbol
4016 For x=defined+const, evaluate x. */
4017 if (symbolP
== exp
.X_add_symbol
4018 && (seg
!= undefined_section
4019 || !symbol_constant_p (symbolP
)))
4021 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
4024 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
4026 symbolS
*s
= exp
.X_add_symbol
;
4028 if (S_IS_COMMON (s
))
4029 as_bad (_("`%s' can't be equated to common symbol `%s'"),
4030 S_GET_NAME (symbolP
), S_GET_NAME (s
));
4032 S_SET_SEGMENT (symbolP
, seg
);
4033 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
4034 symbol_set_frag (symbolP
, symbol_get_frag (s
));
4035 copy_symbol_attributes (symbolP
, s
);
4038 S_SET_SEGMENT (symbolP
, undefined_section
);
4039 symbol_set_value_expression (symbolP
, &exp
);
4040 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4041 set_zero_frag (symbolP
);
4045 /* The value is some complex expression. */
4046 S_SET_SEGMENT (symbolP
, expr_section
);
4047 symbol_set_value_expression (symbolP
, &exp
);
4048 set_zero_frag (symbolP
);
4055 CONStruct more frag of .bytes, or .words etc.
4056 Should need_pass_2 be 1 then emit no frag(s).
4057 This understands EXPRESSIONS.
4061 This has a split personality. We use expression() to read the
4062 value. We can detect if the value won't fit in a byte or word.
4063 But we can't detect if expression() discarded significant digits
4064 in the case of a long. Not worth the crocks required to fix it. */
4066 /* Select a parser for cons expressions. */
4068 /* Some targets need to parse the expression in various fancy ways.
4069 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4070 (for example, the HPPA does this). Otherwise, you can define
4071 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4072 are defined, which is the normal case, then only simple expressions
4077 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4080 #ifndef TC_PARSE_CONS_EXPRESSION
4081 #ifdef REPEAT_CONS_EXPRESSIONS
4082 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4083 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4085 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4088 /* If we haven't gotten one yet, just call expression. */
4089 #ifndef TC_PARSE_CONS_EXPRESSION
4090 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4091 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4096 do_parse_cons_expression (expressionS
*exp
,
4097 int nbytes ATTRIBUTE_UNUSED
)
4099 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4103 /* Worker to do .byte etc statements.
4104 Clobbers input_line_pointer and checks end-of-line. */
4107 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4115 #ifdef md_flush_pending_output
4116 md_flush_pending_output ();
4120 stop
= mri_comment_field (&stopc
);
4122 if (is_it_end_of_statement ())
4124 demand_empty_rest_of_line ();
4126 mri_comment_end (stop
, stopc
);
4131 nbytes
= TC_ADDRESS_BYTES ();
4133 #ifdef md_cons_align
4134 md_cons_align (nbytes
);
4140 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4141 #ifdef TC_CONS_FIX_CHECK
4142 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4144 if (*cur_fix
!= NULL
)
4145 cur_fix
= &(*cur_fix
)->fx_next
;
4150 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4155 if (*input_line_pointer
== '"')
4157 as_bad (_("unexpected `\"' in expression"));
4158 ignore_rest_of_line ();
4162 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4167 if (exp
.X_op
== O_symbol
)
4168 exp
.X_op
= O_symbol_rva
;
4170 as_fatal (_("rva without symbol"));
4172 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4173 #ifdef TC_CONS_FIX_CHECK
4174 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4178 while (*input_line_pointer
++ == ',');
4180 /* In MRI mode, after an odd number of bytes, we must align to an
4181 even word boundary, unless the next instruction is a dc.b, ds.b
4183 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4184 mri_pending_align
= 1;
4186 input_line_pointer
--; /* Put terminator back into stream. */
4188 demand_empty_rest_of_line ();
4191 mri_comment_end (stop
, stopc
);
4197 cons_worker (size
, 0);
4203 cons_worker (size
, 1);
4206 /* .reloc offset, reloc_name, symbol+addend. */
4209 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4216 struct reloc_list
*reloc
;
4217 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4218 static const struct _bfd_rel bfd_relocs
[] =
4220 { "NONE", BFD_RELOC_NONE
},
4221 { "8", BFD_RELOC_8
},
4222 { "16", BFD_RELOC_16
},
4223 { "32", BFD_RELOC_32
},
4224 { "64", BFD_RELOC_64
}
4227 reloc
= XNEW (struct reloc_list
);
4230 stop
= mri_comment_field (&stopc
);
4239 as_bad (_("missing or bad offset expression"));
4242 exp
.X_add_symbol
= section_symbol (now_seg
);
4243 /* Mark the section symbol used in relocation so that it will be
4244 included in the symbol table. */
4245 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4246 exp
.X_op
= O_symbol
;
4249 if (exp
.X_add_number
== 0)
4251 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4256 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4261 if (*input_line_pointer
!= ',')
4263 as_bad (_("missing reloc type"));
4267 ++input_line_pointer
;
4269 c
= get_symbol_name (& r_name
);
4270 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4274 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4275 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4277 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4278 bfd_relocs
[i
].code
);
4283 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4284 *input_line_pointer
= c
;
4285 if (reloc
->u
.a
.howto
== NULL
)
4287 as_bad (_("unrecognized reloc type"));
4291 exp
.X_op
= O_absent
;
4292 SKIP_WHITESPACE_AFTER_NAME ();
4293 if (*input_line_pointer
== ',')
4295 ++input_line_pointer
;
4303 as_bad (_("bad reloc expression"));
4305 ignore_rest_of_line ();
4308 mri_comment_end (stop
, stopc
);
4311 reloc
->u
.a
.sym
= NULL
;
4312 reloc
->u
.a
.addend
= 0;
4315 reloc
->u
.a
.sym
= NULL
;
4316 reloc
->u
.a
.addend
= exp
.X_add_number
;
4319 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4320 reloc
->u
.a
.addend
= exp
.X_add_number
;
4323 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4324 reloc
->u
.a
.addend
= 0;
4328 reloc
->file
= as_where (&reloc
->line
);
4329 reloc
->next
= reloc_list
;
4332 demand_empty_rest_of_line ();
4334 mri_comment_end (stop
, stopc
);
4337 /* Put the contents of expression EXP into the object file using
4338 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4341 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4343 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4347 emit_expr_with_reloc (expressionS
*exp
,
4348 unsigned int nbytes
,
4349 TC_PARSE_CONS_RETURN_TYPE reloc
)
4353 valueT extra_digit
= 0;
4355 /* Don't do anything if we are going to make another pass. */
4360 dot_value
= frag_now_fix ();
4361 dot_frag
= frag_now
;
4365 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4366 appear as a four byte positive constant in the .line section,
4367 followed by a 2 byte 0xffff. Look for that case here. */
4368 if (strcmp (segment_name (now_seg
), ".line") != 0)
4370 else if (dwarf_line
>= 0
4372 && exp
->X_op
== O_constant
4373 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4374 listing_source_line ((unsigned int) dwarf_line
);
4375 else if (nbytes
== 4
4376 && exp
->X_op
== O_constant
4377 && exp
->X_add_number
>= 0)
4378 dwarf_line
= exp
->X_add_number
;
4382 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4383 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4384 AT_sibling (0x12) followed by a four byte address of the sibling
4385 followed by a 2 byte AT_name (0x38) followed by the name of the
4386 file. We look for that case here. */
4387 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4389 else if (dwarf_file
== 0
4391 && exp
->X_op
== O_constant
4392 && exp
->X_add_number
== 0x11)
4394 else if (dwarf_file
== 1
4396 && exp
->X_op
== O_constant
4397 && exp
->X_add_number
== 0x12)
4399 else if (dwarf_file
== 2
4402 else if (dwarf_file
== 3
4404 && exp
->X_op
== O_constant
4405 && exp
->X_add_number
== 0x38)
4410 /* The variable dwarf_file_string tells stringer that the string
4411 may be the name of the source file. */
4412 if (dwarf_file
== 4)
4413 dwarf_file_string
= 1;
4415 dwarf_file_string
= 0;
4419 if (check_eh_frame (exp
, &nbytes
))
4424 /* Handle a negative bignum. */
4426 && exp
->X_add_number
== 0
4427 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4428 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4431 unsigned long carry
;
4433 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4435 /* Negate the bignum: one's complement each digit and add 1. */
4437 for (i
= 0; i
< exp
->X_add_number
; i
++)
4441 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4444 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4445 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4448 /* We can ignore any carry out, because it will be handled by
4449 extra_digit if it is needed. */
4451 extra_digit
= (valueT
) -1;
4455 if (op
== O_absent
|| op
== O_illegal
)
4457 as_warn (_("zero assumed for missing expression"));
4458 exp
->X_add_number
= 0;
4461 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4463 as_bad (_("floating point number invalid"));
4464 exp
->X_add_number
= 0;
4467 else if (op
== O_register
)
4469 as_warn (_("register value used as expression"));
4473 /* Allow `.word 0' in the absolute section. */
4474 if (now_seg
== absolute_section
)
4476 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4477 as_bad (_("attempt to store value in absolute section"));
4478 abs_section_offset
+= nbytes
;
4482 /* Allow `.word 0' in BSS style sections. */
4483 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4484 as_bad (_("attempt to store non-zero value in section `%s'"),
4485 segment_name (now_seg
));
4487 p
= frag_more ((int) nbytes
);
4489 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4491 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4495 #ifndef WORKING_DOT_WORD
4496 /* If we have the difference of two symbols in a word, save it on
4497 the broken_words list. See the code in write.c. */
4498 if (op
== O_subtract
&& nbytes
== 2)
4500 struct broken_word
*x
;
4502 x
= XNEW (struct broken_word
);
4503 x
->next_broken_word
= broken_words
;
4506 x
->subseg
= now_subseg
;
4508 x
->word_goes_here
= p
;
4510 x
->add
= exp
->X_add_symbol
;
4511 x
->sub
= exp
->X_op_symbol
;
4512 x
->addnum
= exp
->X_add_number
;
4520 /* If we have an integer, but the number of bytes is too large to
4521 pass to md_number_to_chars, handle it as a bignum. */
4522 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4524 extra_digit
= exp
->X_unsigned
? 0 : -1;
4525 convert_to_bignum (exp
, !exp
->X_unsigned
);
4529 if (op
== O_constant
)
4536 /* JF << of >= number of bits in the object is undefined. In
4537 particular SPARC (Sun 4) has problems. */
4538 if (nbytes
>= sizeof (valueT
))
4540 know (nbytes
== sizeof (valueT
));
4545 /* Don't store these bits. */
4546 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4549 unmask
= ~mask
; /* Do store these bits. */
4552 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4553 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4556 get
= exp
->X_add_number
;
4558 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4560 /* Leading bits contain both 0s & 1s. */
4561 as_warn (_("value 0x%" PRIx64
" truncated to 0x%" PRIx64
),
4562 (uint64_t) get
, (uint64_t) use
);
4564 /* Put bytes in right order. */
4565 md_number_to_chars (p
, use
, (int) nbytes
);
4567 else if (op
== O_big
)
4570 LITTLENUM_TYPE
*nums
;
4572 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4575 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4579 LITTLENUM_TYPE sign
= 0;
4580 if ((generic_bignum
[--i
]
4581 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4582 sign
= ~(LITTLENUM_TYPE
) 0;
4584 while (++i
< exp
->X_add_number
)
4585 if (generic_bignum
[i
] != sign
)
4588 else if (nbytes
== 1)
4590 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4591 Check that bits 8.. of generic_bignum[0] match bit 7
4592 and that they match all of generic_bignum[1..exp->X_add_number]. */
4593 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4594 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4596 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4598 while (++i
< exp
->X_add_number
)
4599 if (generic_bignum
[i
] != sign
)
4604 if (i
< exp
->X_add_number
)
4605 as_warn (ngettext ("bignum truncated to %d byte",
4606 "bignum truncated to %d bytes",
4614 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4617 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4619 if (target_big_endian
)
4621 while (nbytes
> size
)
4623 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4624 nbytes
-= CHARS_PER_LITTLENUM
;
4625 p
+= CHARS_PER_LITTLENUM
;
4628 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4629 while (size
>= CHARS_PER_LITTLENUM
)
4632 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4633 size
-= CHARS_PER_LITTLENUM
;
4634 p
+= CHARS_PER_LITTLENUM
;
4639 nums
= generic_bignum
;
4640 while (size
>= CHARS_PER_LITTLENUM
)
4642 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4644 size
-= CHARS_PER_LITTLENUM
;
4645 p
+= CHARS_PER_LITTLENUM
;
4646 nbytes
-= CHARS_PER_LITTLENUM
;
4649 while (nbytes
>= CHARS_PER_LITTLENUM
)
4651 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4652 nbytes
-= CHARS_PER_LITTLENUM
;
4653 p
+= CHARS_PER_LITTLENUM
;
4658 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4662 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4663 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4666 unsigned int size
= nbytes
;
4668 memset (p
, 0, size
);
4670 /* Generate a fixS to record the symbol value. */
4672 #ifdef TC_CONS_FIX_NEW
4673 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4675 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4677 reloc_howto_type
*reloc_howto
;
4679 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4680 size
= bfd_get_reloc_size (reloc_howto
);
4684 as_bad (ngettext ("%s relocations do not fit in %u byte",
4685 "%s relocations do not fit in %u bytes",
4687 reloc_howto
->name
, nbytes
);
4690 else if (target_big_endian
)
4691 offset
= nbytes
- size
;
4712 as_bad (_("unsupported BFD relocation size %u"), size
);
4715 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4720 /* Handle an MRI style string expression. */
4724 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4726 if (*input_line_pointer
!= '\''
4727 && (input_line_pointer
[1] != '\''
4728 || (*input_line_pointer
!= 'A'
4729 && *input_line_pointer
!= 'E')))
4730 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4734 unsigned int result
= 0;
4736 /* An MRI style string. Cut into as many bytes as will fit into
4737 a nbyte chunk, left justify if necessary, and separate with
4738 commas so we can try again later. */
4739 if (*input_line_pointer
== 'A')
4740 ++input_line_pointer
;
4741 else if (*input_line_pointer
== 'E')
4743 as_bad (_("EBCDIC constants are not supported"));
4744 ++input_line_pointer
;
4747 input_line_pointer
++;
4748 for (scan
= 0; scan
< nbytes
; scan
++)
4750 if (*input_line_pointer
== '\'')
4752 if (input_line_pointer
[1] == '\'')
4754 input_line_pointer
++;
4759 result
= (result
<< 8) | (*input_line_pointer
++);
4763 while (scan
< nbytes
)
4769 /* Create correct expression. */
4770 exp
->X_op
= O_constant
;
4771 exp
->X_add_number
= result
;
4773 /* Fake it so that we can read the next char too. */
4774 if (input_line_pointer
[0] != '\'' ||
4775 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4777 input_line_pointer
-= 2;
4778 input_line_pointer
[0] = ',';
4779 input_line_pointer
[1] = '\'';
4782 input_line_pointer
++;
4785 #endif /* TC_M68K */
4787 #ifdef REPEAT_CONS_EXPRESSIONS
4789 /* Parse a repeat expression for cons. This is used by the MIPS
4790 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4791 object file COUNT times.
4793 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4796 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4803 if (*input_line_pointer
!= ':')
4805 /* No repeat count. */
4809 ++input_line_pointer
;
4810 expression (&count
);
4811 if (count
.X_op
!= O_constant
4812 || count
.X_add_number
<= 0)
4814 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4818 /* The cons function is going to output this expression once. So we
4819 output it count - 1 times. */
4820 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4821 emit_expr (exp
, nbytes
);
4824 #endif /* REPEAT_CONS_EXPRESSIONS */
4826 /* Parse a floating point number represented as a hex constant. This
4827 permits users to specify the exact bits they want in the floating
4831 hex_float (int float_type
, char *bytes
)
4833 int pad
, length
= float_length (float_type
, &pad
);
4839 /* It would be nice if we could go through expression to parse the
4840 hex constant, but if we get a bignum it's a pain to sort it into
4841 the buffer correctly. */
4843 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4847 /* The MRI assembler accepts arbitrary underscores strewn about
4848 through the hex constant, so we ignore them as well. */
4849 if (*input_line_pointer
== '_')
4851 ++input_line_pointer
;
4857 as_warn (_("floating point constant too large"));
4860 d
= hex_value (*input_line_pointer
) << 4;
4861 ++input_line_pointer
;
4862 while (*input_line_pointer
== '_')
4863 ++input_line_pointer
;
4864 if (hex_p (*input_line_pointer
))
4866 d
+= hex_value (*input_line_pointer
);
4867 ++input_line_pointer
;
4869 if (target_big_endian
)
4872 bytes
[length
- i
- 1] = d
;
4878 if (target_big_endian
)
4879 memset (bytes
+ i
, 0, length
- i
);
4881 memset (bytes
, 0, length
- i
);
4884 memset (bytes
+ length
, 0, pad
);
4886 return length
+ pad
;
4891 CONStruct some more frag chars of .floats .ffloats etc.
4892 Makes 0 or more new frags.
4893 If need_pass_2 == 1, no frags are emitted.
4894 This understands only floating literals, not expressions. Sorry.
4896 A floating constant is defined by atof_generic(), except it is preceded
4897 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4898 reading, I decided to be incompatible. This always tries to give you
4899 rounded bits to the precision of the pseudo-op. Former AS did premature
4900 truncation, restored noisy bits instead of trailing 0s AND gave you
4901 a choice of 2 flavours of noise according to which of 2 floating-point
4902 scanners you directed AS to use.
4904 In: input_line_pointer->whitespace before, or '0' of flonum. */
4907 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4908 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4911 int length
; /* Number of chars in an object. */
4912 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4914 if (is_it_end_of_statement ())
4916 demand_empty_rest_of_line ();
4920 if (now_seg
== absolute_section
)
4922 as_bad (_("attempt to store float in absolute section"));
4923 ignore_rest_of_line ();
4929 as_bad (_("attempt to store float in section `%s'"),
4930 segment_name (now_seg
));
4931 ignore_rest_of_line ();
4935 #ifdef md_flush_pending_output
4936 md_flush_pending_output ();
4939 #ifdef md_cons_align
4945 length
= parse_one_float (float_type
, temp
);
4955 #ifdef REPEAT_CONS_EXPRESSIONS
4956 if (*input_line_pointer
== ':')
4958 expressionS count_exp
;
4960 ++input_line_pointer
;
4961 expression (&count_exp
);
4963 if (count_exp
.X_op
!= O_constant
4964 || count_exp
.X_add_number
<= 0)
4965 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4967 count
= count_exp
.X_add_number
;
4971 while (--count
>= 0)
4973 p
= frag_more (length
);
4974 memcpy (p
, temp
, (unsigned int) length
);
4979 while (*input_line_pointer
++ == ',');
4981 /* Put terminator back into stream. */
4982 --input_line_pointer
;
4983 demand_empty_rest_of_line ();
4988 Note - we are using the DWARF standard's definition of LEB128 encoding
4989 where each 7-bit value is a stored in a byte, *not* an octet. This
4990 means that on targets where a byte contains multiple octets there is
4991 a *huge waste of space*. (This also means that we do not have to
4992 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4995 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4996 we would then have to consider whether multiple, successive LEB128
4997 values should be packed into the bytes without padding (bad idea) or
4998 whether each LEB128 number is padded out to a whole number of bytes.
4999 Plus you have to decide on the endianness of packing octets into a
5002 /* Return the size of a LEB128 value in bytes. */
5004 static inline unsigned int
5005 sizeof_sleb128 (offsetT value
)
5012 byte
= (value
& 0x7f);
5013 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5014 Fortunately, we can structure things so that the extra work reduces
5015 to a noop on systems that do things "properly". */
5016 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5019 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5020 || ((value
== -1) && ((byte
& 0x40) != 0))));
5025 static inline unsigned int
5026 sizeof_uleb128 (valueT value
)
5041 sizeof_leb128 (valueT value
, int sign
)
5044 return sizeof_sleb128 ((offsetT
) value
);
5046 return sizeof_uleb128 (value
);
5049 /* Output a LEB128 value. Returns the number of bytes used. */
5051 static inline unsigned int
5052 output_sleb128 (char *p
, offsetT value
)
5059 unsigned byte
= (value
& 0x7f);
5061 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5062 Fortunately, we can structure things so that the extra work reduces
5063 to a noop on systems that do things "properly". */
5064 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5066 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5067 || ((value
== -1) && ((byte
& 0x40) != 0))));
5078 static inline unsigned int
5079 output_uleb128 (char *p
, valueT value
)
5085 unsigned byte
= (value
& 0x7f);
5089 /* More bytes to follow. */
5100 output_leb128 (char *p
, valueT value
, int sign
)
5103 return output_sleb128 (p
, (offsetT
) value
);
5105 return output_uleb128 (p
, value
);
5108 /* Do the same for bignums. We combine sizeof with output here in that
5109 we don't output for NULL values of P. It isn't really as critical as
5110 for "normal" values that this be streamlined. Returns the number of
5113 static inline unsigned int
5114 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5121 /* Strip leading sign extensions off the bignum. */
5123 && bignum
[size
- 1] == LITTLENUM_MASK
5124 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5129 /* OR in the next part of the littlenum. */
5130 val
|= (*bignum
<< loaded
);
5131 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5135 /* Add bytes until there are less than 7 bits left in VAL
5136 or until every non-sign bit has been written. */
5143 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5150 while ((byte
& 0x80) != 0 && loaded
>= 7);
5154 /* Mop up any left-over bits (of which there will be less than 7). */
5155 if ((byte
& 0x80) != 0)
5157 /* Sign-extend VAL. */
5158 if (val
& (1 << (loaded
- 1)))
5159 val
|= ~0U << loaded
;
5168 static inline unsigned int
5169 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5176 /* Strip leading zeros off the bignum. */
5177 /* XXX: Is this needed? */
5178 while (size
> 0 && bignum
[size
- 1] == 0)
5183 if (loaded
< 7 && size
> 0)
5185 val
|= (*bignum
<< loaded
);
5186 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5195 if (size
> 0 || val
)
5202 while (byte
& 0x80);
5208 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5211 return output_big_sleb128 (p
, bignum
, size
);
5213 return output_big_uleb128 (p
, bignum
, size
);
5216 /* Generate the appropriate fragments for a given expression to emit a
5217 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5220 emit_leb128_expr (expressionS
*exp
, int sign
)
5222 operatorT op
= exp
->X_op
;
5223 unsigned int nbytes
;
5225 if (op
== O_absent
|| op
== O_illegal
)
5227 as_warn (_("zero assumed for missing expression"));
5228 exp
->X_add_number
= 0;
5231 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5233 as_bad (_("floating point number invalid"));
5234 exp
->X_add_number
= 0;
5237 else if (op
== O_register
)
5239 as_warn (_("register value used as expression"));
5242 else if (op
== O_constant
5244 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5246 /* We're outputting a signed leb128 and the sign of X_add_number
5247 doesn't reflect the sign of the original value. Convert EXP
5248 to a correctly-extended bignum instead. */
5249 convert_to_bignum (exp
, exp
->X_extrabit
);
5253 if (now_seg
== absolute_section
)
5255 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5256 as_bad (_("attempt to store value in absolute section"));
5257 abs_section_offset
++;
5261 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5262 as_bad (_("attempt to store non-zero value in section `%s'"),
5263 segment_name (now_seg
));
5265 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5266 a signal that this is leb128 data. It shouldn't optimize this away. */
5267 nbytes
= (unsigned int) -1;
5268 if (check_eh_frame (exp
, &nbytes
))
5271 /* Let the backend know that subsequent data may be byte aligned. */
5272 #ifdef md_cons_align
5276 if (op
== O_constant
)
5278 /* If we've got a constant, emit the thing directly right now. */
5280 valueT value
= exp
->X_add_number
;
5284 size
= sizeof_leb128 (value
, sign
);
5285 p
= frag_more (size
);
5286 if (output_leb128 (p
, value
, sign
) > size
)
5289 else if (op
== O_big
)
5291 /* O_big is a different sort of constant. */
5292 int nbr_digits
= exp
->X_add_number
;
5296 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5297 a signed number. Unary operators like - or ~ always extend the
5298 bignum to its largest size. */
5300 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5301 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5302 generic_bignum
[nbr_digits
++] = 0;
5304 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5305 p
= frag_more (size
);
5306 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5311 /* Otherwise, we have to create a variable sized fragment and
5312 resolve things later. */
5314 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5315 make_expr_symbol (exp
), 0, (char *) NULL
);
5319 /* Parse the .sleb128 and .uleb128 pseudos. */
5326 #ifdef md_flush_pending_output
5327 md_flush_pending_output ();
5333 emit_leb128_expr (&exp
, sign
);
5335 while (*input_line_pointer
++ == ',');
5337 input_line_pointer
--;
5338 demand_empty_rest_of_line ();
5342 stringer_append_char (int c
, int bitsize
)
5345 as_bad (_("attempt to store non-empty string in section `%s'"),
5346 segment_name (now_seg
));
5348 if (!target_big_endian
)
5349 FRAG_APPEND_1_CHAR (c
);
5354 FRAG_APPEND_1_CHAR (0);
5355 FRAG_APPEND_1_CHAR (0);
5356 FRAG_APPEND_1_CHAR (0);
5357 FRAG_APPEND_1_CHAR (0);
5360 FRAG_APPEND_1_CHAR (0);
5361 FRAG_APPEND_1_CHAR (0);
5364 FRAG_APPEND_1_CHAR (0);
5369 /* Called with invalid bitsize argument. */
5373 if (target_big_endian
)
5374 FRAG_APPEND_1_CHAR (c
);
5377 /* Worker to do .ascii etc statements.
5378 Reads 0 or more ',' separated, double-quoted strings.
5379 Caller should have checked need_pass_2 is FALSE because we don't
5381 Checks for end-of-line.
5382 BITS_APPENDZERO says how many bits are in a target char.
5383 The bottom bit is set if a NUL char should be appended to the strings. */
5386 stringer (int bits_appendzero
)
5388 const int bitsize
= bits_appendzero
& ~7;
5389 const int append_zero
= bits_appendzero
& 1;
5391 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5395 #ifdef md_flush_pending_output
5396 md_flush_pending_output ();
5399 #ifdef md_cons_align
5403 /* If we have been switched into the abs_section then we
5404 will not have an obstack onto which we can hang strings. */
5405 if (now_seg
== absolute_section
)
5407 as_bad (_("strings must be placed into a section"));
5408 ignore_rest_of_line ();
5412 /* The following awkward logic is to parse ZERO or more strings,
5413 comma separated. Recall a string expression includes spaces
5414 before the opening '\"' and spaces after the closing '\"'.
5415 We fake a leading ',' if there is (supposed to be)
5416 a 1st, expression. We keep demanding expressions for each ','. */
5417 if (is_it_end_of_statement ())
5419 c
= 0; /* Skip loop. */
5420 ++input_line_pointer
; /* Compensate for end of loop. */
5424 c
= ','; /* Do loop. */
5427 while (c
== ',' || c
== '<' || c
== '"')
5430 switch (*input_line_pointer
)
5433 ++input_line_pointer
; /*->1st char of string. */
5434 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5435 start
= input_line_pointer
;
5438 while (is_a_char (c
= next_char_of_string ()))
5439 stringer_append_char (c
, bitsize
);
5441 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5442 SKIP_ALL_WHITESPACE ();
5443 if (*input_line_pointer
== '"')
5447 stringer_append_char (0, bitsize
);
5449 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5450 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5451 will emit .string with a filename in the .debug section
5452 after a sequence of constants. See the comment in
5453 emit_expr for the sequence. emit_expr will set
5454 dwarf_file_string to non-zero if this string might be a
5455 source file name. */
5456 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5457 dwarf_file_string
= 0;
5458 else if (dwarf_file_string
)
5460 c
= input_line_pointer
[-1];
5461 input_line_pointer
[-1] = '\0';
5462 listing_source_file (start
);
5463 input_line_pointer
[-1] = c
;
5469 input_line_pointer
++;
5470 c
= get_single_number ();
5471 stringer_append_char (c
, bitsize
);
5472 if (*input_line_pointer
!= '>')
5474 as_bad (_("expected <nn>"));
5475 ignore_rest_of_line ();
5478 input_line_pointer
++;
5481 input_line_pointer
++;
5485 c
= *input_line_pointer
;
5488 demand_empty_rest_of_line ();
5491 /* FIXME-SOMEDAY: I had trouble here on characters with the
5492 high bits set. We'll probably also have trouble with
5493 multibyte chars, wide chars, etc. Also be careful about
5494 returning values bigger than 1 byte. xoxorich. */
5497 next_char_of_string (void)
5501 c
= *input_line_pointer
++ & CHAR_MASK
;
5505 /* PR 20902: Do not advance past the end of the buffer. */
5506 -- input_line_pointer
;
5515 as_warn (_("unterminated string; newline inserted"));
5516 bump_line_counters ();
5520 if (!TC_STRING_ESCAPES
)
5522 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5550 break; /* As itself. */
5566 for (i
= 0, number
= 0;
5567 ISDIGIT (c
) && i
< 3;
5568 c
= *input_line_pointer
++, i
++)
5570 number
= number
* 8 + c
- '0';
5573 c
= number
& CHAR_MASK
;
5575 --input_line_pointer
;
5584 c
= *input_line_pointer
++;
5585 while (ISXDIGIT (c
))
5588 number
= number
* 16 + c
- '0';
5589 else if (ISUPPER (c
))
5590 number
= number
* 16 + c
- 'A' + 10;
5592 number
= number
* 16 + c
- 'a' + 10;
5593 c
= *input_line_pointer
++;
5595 c
= number
& CHAR_MASK
;
5596 --input_line_pointer
;
5601 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5602 as_warn (_("unterminated string; newline inserted"));
5604 bump_line_counters ();
5608 /* Do not advance past the end of the buffer. */
5609 -- input_line_pointer
;
5615 #ifdef ONLY_STANDARD_ESCAPES
5616 as_bad (_("bad escaped character in string"));
5618 #endif /* ONLY_STANDARD_ESCAPES */
5631 get_segmented_expression (expressionS
*expP
)
5635 retval
= expression (expP
);
5636 if (expP
->X_op
== O_illegal
5637 || expP
->X_op
== O_absent
5638 || expP
->X_op
== O_big
)
5640 as_bad (_("expected address expression"));
5641 expP
->X_op
= O_constant
;
5642 expP
->X_add_number
= 0;
5643 retval
= absolute_section
;
5649 get_known_segmented_expression (expressionS
*expP
)
5651 segT retval
= get_segmented_expression (expP
);
5653 if (retval
== undefined_section
)
5655 /* There is no easy way to extract the undefined symbol from the
5657 if (expP
->X_add_symbol
!= NULL
5658 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5659 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5660 S_GET_NAME (expP
->X_add_symbol
));
5662 as_warn (_("some symbol undefined; zero assumed"));
5663 retval
= absolute_section
;
5664 expP
->X_op
= O_constant
;
5665 expP
->X_add_number
= 0;
5670 char /* Return terminator. */
5671 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5673 /* FIXME: val_pointer should probably be offsetT *. */
5674 *val_pointer
= (long) get_absolute_expression ();
5675 return (*input_line_pointer
++);
5678 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5679 Give a warning if that happens. */
5682 demand_copy_C_string (int *len_pointer
)
5686 if ((s
= demand_copy_string (len_pointer
)) != 0)
5690 for (len
= *len_pointer
; len
> 0; len
--)
5692 if (s
[len
- 1] == 0)
5696 as_bad (_("this string may not contain \'\\0\'"));
5705 /* Demand string, but return a safe (=private) copy of the string.
5706 Return NULL if we can't read a string here. */
5709 demand_copy_string (int *lenP
)
5717 if (*input_line_pointer
== '\"')
5719 input_line_pointer
++; /* Skip opening quote. */
5721 while (is_a_char (c
= next_char_of_string ()))
5723 obstack_1grow (¬es
, c
);
5726 /* JF this next line is so demand_copy_C_string will return a
5727 null terminated string. */
5728 obstack_1grow (¬es
, '\0');
5729 retval
= (char *) obstack_finish (¬es
);
5733 as_bad (_("missing string"));
5735 ignore_rest_of_line ();
5741 /* In: Input_line_pointer->next character.
5743 Do: Skip input_line_pointer over all whitespace.
5745 Out: 1 if input_line_pointer->end-of-line. */
5748 is_it_end_of_statement (void)
5751 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5755 equals (char *sym_name
, int reassign
)
5760 input_line_pointer
++;
5761 if (*input_line_pointer
== '=')
5762 input_line_pointer
++;
5763 if (reassign
< 0 && *input_line_pointer
== '=')
5764 input_line_pointer
++;
5766 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5767 input_line_pointer
++;
5770 stop
= mri_comment_field (&stopc
);
5772 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5776 demand_empty_rest_of_line ();
5777 mri_comment_end (stop
, stopc
);
5781 /* Open FILENAME, first trying the unadorned file name, then if that
5782 fails and the file name is not an absolute path, attempt to open
5783 the file in current -I include paths. PATH is a preallocated
5784 buffer which will be set to the file opened, or FILENAME if no file
5788 search_and_open (const char *filename
, char *path
)
5790 FILE *f
= fopen (filename
, FOPEN_RB
);
5791 if (f
== NULL
&& !IS_ABSOLUTE_PATH (filename
))
5793 for (size_t i
= 0; i
< include_dir_count
; i
++)
5795 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5796 f
= fopen (path
, FOPEN_RB
);
5801 strcpy (path
, filename
);
5805 /* .incbin -- include a file verbatim at the current location. */
5808 s_incbin (int x ATTRIBUTE_UNUSED
)
5819 #ifdef md_flush_pending_output
5820 md_flush_pending_output ();
5823 #ifdef md_cons_align
5828 filename
= demand_copy_string (& len
);
5829 if (filename
== NULL
)
5834 /* Look for optional skip and count. */
5835 if (* input_line_pointer
== ',')
5837 ++ input_line_pointer
;
5838 skip
= get_absolute_expression ();
5842 if (* input_line_pointer
== ',')
5844 ++ input_line_pointer
;
5846 count
= get_absolute_expression ();
5848 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5854 demand_empty_rest_of_line ();
5856 path
= XNEWVEC (char, len
+ include_dir_maxlen
+ 2);
5857 binfile
= search_and_open (filename
, path
);
5859 if (binfile
== NULL
)
5860 as_bad (_("file not found: %s"), filename
);
5864 struct stat filestat
;
5866 if (fstat (fileno (binfile
), &filestat
) != 0
5867 || ! S_ISREG (filestat
.st_mode
)
5868 || S_ISDIR (filestat
.st_mode
))
5870 as_bad (_("unable to include `%s'"), path
);
5874 register_dependency (path
);
5876 /* Compute the length of the file. */
5877 if (fseek (binfile
, 0, SEEK_END
) != 0)
5879 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5882 file_len
= ftell (binfile
);
5884 /* If a count was not specified use the remainder of the file. */
5886 count
= file_len
- skip
;
5888 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5890 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5891 skip
, count
, file_len
);
5895 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5897 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5901 /* Allocate frag space and store file contents in it. */
5902 binfrag
= frag_more (count
);
5904 bytes
= fread (binfrag
, 1, count
, binfile
);
5906 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5907 path
, bytes
, count
);
5910 if (binfile
!= NULL
)
5915 /* .include -- include a file at this point. */
5918 s_include (int arg ATTRIBUTE_UNUSED
)
5927 filename
= demand_copy_string (&i
);
5928 if (filename
== NULL
)
5930 /* demand_copy_string has already printed an error and
5931 called ignore_rest_of_line. */
5939 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5940 && *input_line_pointer
!= ' '
5941 && *input_line_pointer
!= '\t')
5943 obstack_1grow (¬es
, *input_line_pointer
);
5944 ++input_line_pointer
;
5948 obstack_1grow (¬es
, '\0');
5949 filename
= (char *) obstack_finish (¬es
);
5950 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5951 ++input_line_pointer
;
5954 demand_empty_rest_of_line ();
5956 path
= notes_alloc (i
+ include_dir_maxlen
+ 2);
5957 try_file
= search_and_open (filename
, path
);
5961 register_dependency (path
);
5962 input_scrub_insert_file (path
);
5966 init_include_dir (void)
5968 include_dirs
= XNEWVEC (const char *, 1);
5969 include_dirs
[0] = "."; /* Current dir. */
5970 include_dir_count
= 1;
5971 include_dir_maxlen
= 1;
5975 add_include_dir (char *path
)
5977 include_dir_count
++;
5978 include_dirs
= XRESIZEVEC (const char *, include_dirs
, include_dir_count
);
5979 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5981 size_t i
= strlen (path
);
5982 if (i
> include_dir_maxlen
)
5983 include_dir_maxlen
= i
;
5986 /* Output debugging information to denote the source file. */
5989 generate_file_debug (void)
5991 if (debug_type
== DEBUG_STABS
)
5992 stabs_generate_asm_file ();
5995 /* Output line number debugging information for the current source line. */
5998 generate_lineno_debug (void)
6002 case DEBUG_UNSPECIFIED
:
6007 stabs_generate_asm_lineno ();
6010 ecoff_generate_asm_lineno ();
6013 /* ??? We could here indicate to dwarf2dbg.c that something
6014 has changed. However, since there is additional backend
6015 support that is required (calling dwarf2_emit_insn), we
6016 let dwarf2dbg.c call as_where on its own. */
6018 case DEBUG_CODEVIEW
:
6019 codeview_generate_asm_lineno ();
6024 /* Output debugging information to mark a function entry point or end point.
6025 END_P is zero for .func, and non-zero for .endfunc. */
6030 do_s_func (end_p
, NULL
);
6033 /* Subroutine of s_func so targets can choose a different default prefix.
6034 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6037 do_s_func (int end_p
, const char *default_prefix
)
6041 if (current_name
== NULL
)
6043 as_bad (_("missing .func"));
6044 ignore_rest_of_line ();
6048 if (debug_type
== DEBUG_STABS
)
6049 stabs_generate_asm_endfunc (current_name
, current_label
);
6051 current_name
= current_label
= NULL
;
6056 char delim1
, delim2
;
6058 if (current_name
!= NULL
)
6060 as_bad (_(".endfunc missing for previous .func"));
6061 ignore_rest_of_line ();
6065 delim1
= get_symbol_name (& name
);
6066 name
= xstrdup (name
);
6067 *input_line_pointer
= delim1
;
6068 SKIP_WHITESPACE_AFTER_NAME ();
6069 if (*input_line_pointer
!= ',')
6073 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6074 as_fatal ("%s", xstrerror (errno
));
6078 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6079 /* Missing entry point, use function's name with the leading
6083 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6084 as_fatal ("%s", xstrerror (errno
));
6092 ++input_line_pointer
;
6094 delim2
= get_symbol_name (& label
);
6095 label
= xstrdup (label
);
6096 restore_line_pointer (delim2
);
6099 if (debug_type
== DEBUG_STABS
)
6100 stabs_generate_asm_func (name
, label
);
6102 current_name
= name
;
6103 current_label
= label
;
6106 demand_empty_rest_of_line ();
6109 #ifdef HANDLE_BUNDLE
6112 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6114 unsigned int align
= get_absolute_expression ();
6116 demand_empty_rest_of_line ();
6118 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6119 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6120 (unsigned int) TC_ALIGN_LIMIT
);
6122 if (bundle_lock_frag
!= NULL
)
6124 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6128 bundle_align_p2
= align
;
6132 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6134 demand_empty_rest_of_line ();
6136 if (bundle_align_p2
== 0)
6138 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6142 if (bundle_lock_depth
== 0)
6144 bundle_lock_frchain
= frchain_now
;
6145 bundle_lock_frag
= start_bundle ();
6147 ++bundle_lock_depth
;
6151 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6155 demand_empty_rest_of_line ();
6157 if (bundle_lock_frag
== NULL
)
6159 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6163 gas_assert (bundle_align_p2
> 0);
6165 gas_assert (bundle_lock_depth
> 0);
6166 if (--bundle_lock_depth
> 0)
6169 size
= pending_bundle_size (bundle_lock_frag
);
6171 if (size
> 1U << bundle_align_p2
)
6172 as_bad (_(".bundle_lock sequence is %u bytes, "
6173 "but bundle size is only %u bytes"),
6174 size
, 1u << bundle_align_p2
);
6176 finish_bundle (bundle_lock_frag
, size
);
6178 bundle_lock_frag
= NULL
;
6179 bundle_lock_frchain
= NULL
;
6182 #endif /* HANDLE_BUNDLE */
6185 s_ignore (int arg ATTRIBUTE_UNUSED
)
6187 ignore_rest_of_line ();
6191 read_print_statistics (FILE *file
)
6193 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6196 /* Inserts the given line into the input stream.
6198 This call avoids macro/conditionals nesting checking, since the contents of
6199 the line are assumed to replace the contents of a line already scanned.
6201 An appropriate use of this function would be substitution of input lines when
6202 called by md_start_line_hook(). The given line is assumed to already be
6203 properly scrubbed. */
6206 input_scrub_insert_line (const char *line
)
6209 size_t len
= strlen (line
);
6210 sb_build (&newline
, len
);
6211 sb_add_buffer (&newline
, line
, len
);
6212 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6214 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6217 /* Insert a file into the input stream; the path must resolve to an actual
6218 file; no include path searching or dependency registering is performed. */
6221 input_scrub_insert_file (char *path
)
6223 input_scrub_include_file (path
, input_line_pointer
);
6224 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6227 /* Find the end of a line, considering quotation and escaping of quotes. */
6229 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6230 # define TC_SINGLE_QUOTE_STRINGS 1
6234 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6237 char inquote
= '\0';
6240 while (!is_end_of_line
[(unsigned char) *s
]
6241 || (inquote
&& !ISCNTRL (*s
))
6242 || (inquote
== '\'' && flag_mri
)
6243 #ifdef TC_EOL_IN_INSN
6244 || (insn
&& TC_EOL_IN_INSN (s
))
6246 /* PR 6926: When we are parsing the body of a macro the sequence
6247 \@ is special - it refers to the invocation count. If the @
6248 character happens to be registered as a line-separator character
6249 by the target, then the is_end_of_line[] test above will have
6250 returned true, but we need to ignore the line separating
6251 semantics in this particular case. */
6252 || (in_macro
&& inescape
&& *s
== '@')
6255 if (mri_string
&& *s
== '\'')
6259 else if (*s
== '\\')
6263 #ifdef TC_SINGLE_QUOTE_STRINGS
6264 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6271 as_warn (_("missing closing `%c'"), inquote
);
6272 if (inescape
&& !ignore_input ())
6273 as_warn (_("stray `\\'"));
6278 find_end_of_line (char *s
, int mri_string
)
6280 return _find_end_of_line (s
, mri_string
, 0, 0);
6283 static char *saved_ilp
;
6284 static char *saved_limit
;
6286 /* Use BUF as a temporary input pointer for calling other functions in this
6287 file. BUF must be a C string, so that its end can be found by strlen.
6288 Also sets the buffer_limit variable (local to this file) so that buffer
6289 overruns should not occur. Saves the current input line pointer so that
6290 it can be restored by calling restore_ilp().
6292 Does not support recursion. */
6295 temp_ilp (char *buf
)
6297 gas_assert (saved_ilp
== NULL
);
6298 gas_assert (buf
!= NULL
);
6300 saved_ilp
= input_line_pointer
;
6301 saved_limit
= buffer_limit
;
6302 /* Prevent the assert in restore_ilp from triggering if
6303 the input_line_pointer has not yet been initialised. */
6304 if (saved_ilp
== NULL
)
6305 saved_limit
= saved_ilp
= (char *) "";
6307 input_line_pointer
= buf
;
6308 buffer_limit
= buf
+ strlen (buf
);
6309 input_from_string
= true;
6312 /* Restore a saved input line pointer. */
6317 gas_assert (saved_ilp
!= NULL
);
6319 input_line_pointer
= saved_ilp
;
6320 buffer_limit
= saved_limit
;
6321 input_from_string
= false;