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"
46 #ifndef TC_START_LABEL
47 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
50 /* Set by the object-format or the target. */
51 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
52 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
57 else if ((SIZE) >= 4) \
59 else if ((SIZE) >= 2) \
67 char *input_line_pointer
; /*->next char of source file to parse. */
68 bool input_from_string
= false;
70 #if BITS_PER_CHAR != 8
71 /* The following table is indexed by[(char)] and will break if
72 a char does not have exactly 256 states (hopefully 0:255!)! */
81 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
86 /* The Delta 68k assembler permits % inside label names. */
91 /* The PowerPC Windows NT assemblers permits ? inside label names. */
96 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
97 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
106 /* The Delta 68k assembler permits ~ at start of label names. */
110 /* Used by is_... macros. our ctype[]. */
111 char lex_type
[256] = {
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
114 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
116 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
118 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
127 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
131 Out: 1 if this character ends a line.
132 2 if this character is a line separator. */
133 char is_end_of_line
[256] = {
135 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
137 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
156 #ifndef TC_CASE_SENSITIVE
157 char original_case_string
[128];
160 /* Functions private to this file. */
162 static char *buffer
; /* 1st char of each buffer of lines is here. */
163 static char *buffer_limit
; /*->1 + last char in buffer. */
165 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
166 in the tc-<CPU>.h file. See the "Porting GAS" section of the
168 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
170 /* Variables for handling include file directory table. */
172 /* Table of pointers to directories to search for .include's. */
173 const char **include_dirs
;
175 /* How many are in the table. */
176 int include_dir_count
;
178 /* Length of longest in table. */
179 int include_dir_maxlen
= 1;
181 #ifndef WORKING_DOT_WORD
182 struct broken_word
*broken_words
;
183 int new_broken_words
;
186 /* The current offset into the absolute section. We don't try to
187 build frags in the absolute section, since no data can be stored
188 there. We just keep track of the current offset. */
189 addressT abs_section_offset
;
191 /* If this line had an MRI style label, it is stored in this variable.
192 This is used by some of the MRI pseudo-ops. */
195 /* This global variable is used to support MRI common sections. We
196 translate such sections into a common symbol. This variable is
197 non-NULL when we are in an MRI common section. */
198 symbolS
*mri_common_symbol
;
200 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
201 need to align to an even byte boundary unless the next pseudo-op is
202 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
204 static int mri_pending_align
;
208 /* This variable is set to be non-zero if the next string we see might
209 be the name of the source file in DWARF debugging information. See
210 the comment in emit_expr for the format we look for. */
211 static int dwarf_file_string
;
215 /* If the target defines the md_frag_max_var hook then we know
216 enough to implement the .bundle_align_mode features. */
217 #ifdef md_frag_max_var
218 # define HANDLE_BUNDLE
222 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
223 it's the exponent of the bundle size, and aligned instruction bundle
224 mode is in effect. */
225 static unsigned int bundle_align_p2
;
227 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
228 bundle_lock_frag to frag_now and then starts a new frag with
229 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
230 so that .bundle_unlock can verify that we didn't change segments.
231 .bundle_unlock resets both to NULL. If we detect a bundling violation,
232 then we reset bundle_lock_frchain to NULL as an indicator that we've
233 already diagnosed the error with as_bad and don't need a cascade of
234 redundant errors, but bundle_lock_frag remains set to indicate that
235 we are expecting to see .bundle_unlock. */
236 static fragS
*bundle_lock_frag
;
237 static frchainS
*bundle_lock_frchain
;
239 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
241 static unsigned int bundle_lock_depth
;
244 static void do_s_func (int end_p
, const char *default_prefix
);
245 static void s_align (int, int);
246 static void s_altmacro (int);
247 static void s_bad_end (int);
248 static void s_reloc (int);
249 static int hex_float (int, char *);
250 static segT
get_known_segmented_expression (expressionS
* expP
);
251 static void pobegin (void);
252 static void poend (void);
253 static size_t get_non_macro_line_sb (sb
*);
254 static void generate_file_debug (void);
255 static char *_find_end_of_line (char *, int, int, int);
263 obj_read_begin_hook ();
265 obstack_begin (&cond_obstack
, chunksize
);
267 #ifndef tc_line_separator_chars
268 #define tc_line_separator_chars line_separator_chars
270 /* Use machine dependent syntax. */
271 for (p
= tc_line_separator_chars
; *p
; p
++)
272 is_end_of_line
[(unsigned char) *p
] = 2;
273 /* Use more. FIXME-SOMEDAY. */
285 _obstack_free (&cond_obstack
, NULL
);
288 #ifndef TC_ADDRESS_BYTES
289 #define TC_ADDRESS_BYTES address_bytes
294 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
295 contain an address. */
296 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
304 /* Set up pseudo-op tables. */
306 static htab_t po_hash
;
308 static const pseudo_typeS potable
[] = {
309 {"abort", s_abort
, 0},
310 {"align", s_align_ptwo
, 0},
311 {"altmacro", s_altmacro
, 1},
312 {"ascii", stringer
, 8+0},
313 {"asciz", stringer
, 8+1},
314 {"balign", s_align_bytes
, 0},
315 {"balignw", s_align_bytes
, -2},
316 {"balignl", s_align_bytes
, -4},
319 {"bundle_align_mode", s_bundle_align_mode
, 0},
320 {"bundle_lock", s_bundle_lock
, 0},
321 {"bundle_unlock", s_bundle_unlock
, 0},
325 {"common", s_mri_common
, 0},
326 {"common.s", s_mri_common
, 1},
331 {"dc.d", float_cons
, 'd'},
333 {"dc.s", float_cons
, 'f'},
335 {"dc.x", float_cons
, 'x'},
337 {"dcb.b", s_space
, 1},
338 {"dcb.d", s_float_space
, 'd'},
339 {"dcb.l", s_space
, 4},
340 {"dcb.s", s_float_space
, 'f'},
341 {"dcb.w", s_space
, 2},
342 {"dcb.x", s_float_space
, 'x'},
344 {"ds.b", s_space
, 1},
345 {"ds.d", s_space
, 8},
346 {"ds.l", s_space
, 4},
347 {"ds.p", s_space
, 'p'},
348 {"ds.s", s_space
, 4},
349 {"ds.w", s_space
, 2},
350 {"ds.x", s_space
, 'x'},
351 {"debug", s_ignore
, 0},
356 {"double", float_cons
, 'd'},
358 {"eject", listing_eject
, 0}, /* Formfeed listing. */
360 {"elsec", s_else
, 0},
361 {"elseif", s_elseif
, (int) O_ne
},
363 {"endc", s_endif
, 0},
364 {"endfunc", s_func
, 1},
365 {"endif", s_endif
, 0},
366 {"endm", s_bad_end
, 0},
367 {"endr", s_bad_end
, 1},
373 {"error", s_errwarn
, 1},
374 {"exitm", s_mexit
, 0},
376 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
380 {"float", float_cons
, 'f'},
381 {"format", s_ignore
, 0},
383 {"global", s_globl
, 0},
384 {"globl", s_globl
, 0},
386 {"if", s_if
, (int) O_ne
},
389 {"ifdef", s_ifdef
, 0},
390 {"ifeq", s_if
, (int) O_eq
},
391 {"ifeqs", s_ifeqs
, 0},
392 {"ifge", s_if
, (int) O_ge
},
393 {"ifgt", s_if
, (int) O_gt
},
394 {"ifle", s_if
, (int) O_le
},
395 {"iflt", s_if
, (int) O_lt
},
398 {"ifndef", s_ifdef
, 1},
399 {"ifne", s_if
, (int) O_ne
},
400 {"ifnes", s_ifeqs
, 1},
401 {"ifnotdef", s_ifdef
, 1},
402 {"incbin", s_incbin
, 0},
403 {"include", s_include
, 0},
409 {"lcomm", s_lcomm
, 0},
410 {"lflags", s_ignore
, 0}, /* Listing flags. */
411 {"linefile", s_linefile
, 0},
412 {"linkonce", s_linkonce
, 0},
413 {"list", listing_list
, 1}, /* Turn listing on. */
414 {"llen", listing_psize
, 1},
417 {"macro", s_macro
, 0},
418 {"mexit", s_mexit
, 0},
420 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
421 {"name", s_ignore
, 0},
422 {"noaltmacro", s_altmacro
, 0},
423 {"noformat", s_ignore
, 0},
424 {"nolist", listing_list
, 0}, /* Turn listing off. */
425 {"nopage", listing_nopage
, 0},
429 {"offset", s_struct
, 0},
431 {"p2align", s_align_ptwo
, 0},
432 {"p2alignw", s_align_ptwo
, -2},
433 {"p2alignl", s_align_ptwo
, -4},
434 {"page", listing_eject
, 0},
435 {"plen", listing_psize
, 0},
436 {"print", s_print
, 0},
437 {"psize", listing_psize
, 0}, /* Set paper size. */
438 {"purgem", s_purgem
, 0},
440 {"reloc", s_reloc
, 0},
444 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
449 {"single", float_cons
, 'f'},
451 {"space", s_space
, 0},
452 {"skip", s_space
, 0},
453 {"sleb128", s_leb128
, 1},
454 {"spc", s_ignore
, 0},
455 {"stabd", s_stab
, 'd'},
456 {"stabn", s_stab
, 'n'},
457 {"stabs", s_stab
, 's'},
458 {"string", stringer
, 8+1},
459 {"string8", stringer
, 8+1},
460 {"string16", stringer
, 16+1},
461 {"string32", stringer
, 32+1},
462 {"string64", stringer
, 64+1},
463 {"struct", s_struct
, 0},
467 /* This is for gcc to use. It's only just been added (2/94), so gcc
468 won't be able to use it for a while -- probably a year or more.
469 But once this has been released, check with gcc maintainers
470 before deleting it or even changing the spelling. */
471 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
472 /* If we're folding case -- done for some targets, not necessarily
473 all -- the above string in an input file will be converted to
474 this one. Match it either way... */
475 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
477 {"title", listing_title
, 0}, /* Listing title. */
478 {"ttl", listing_title
, 0},
480 {"uleb128", s_leb128
, 0},
484 {"xdef", s_globl
, 0},
485 {"xref", s_ignore
, 0},
486 {"xstabs", s_xstab
, 's'},
487 {"warning", s_errwarn
, 0},
488 {"weakref", s_weakref
, 0},
490 {"zero", s_space
, 0},
494 {NULL
, NULL
, 0} /* End sentinel. */
498 get_absolute_expr (expressionS
*exp
)
500 expression_and_evaluate (exp
);
502 if (exp
->X_op
!= O_constant
)
504 if (exp
->X_op
!= O_absent
)
505 as_bad (_("bad or irreducible absolute expression"));
506 exp
->X_add_number
= 0;
508 return exp
->X_add_number
;
512 get_absolute_expression (void)
516 return get_absolute_expr (&exp
);
519 static int pop_override_ok
= 0;
520 static const char *pop_table_name
;
523 pop_insert (const pseudo_typeS
*table
)
525 const pseudo_typeS
*pop
;
526 for (pop
= table
; pop
->poc_name
; pop
++)
528 if (str_hash_insert (po_hash
, pop
->poc_name
, pop
, 0) != NULL
)
530 if (!pop_override_ok
)
531 as_fatal (_("error constructing %s pseudo-op table"),
537 #ifndef md_pop_insert
538 #define md_pop_insert() pop_insert(md_pseudo_table)
541 #ifndef obj_pop_insert
542 #define obj_pop_insert() pop_insert(obj_pseudo_table)
545 #ifndef cfi_pop_insert
546 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
552 po_hash
= str_htab_create ();
554 /* Do the target-specific pseudo ops. */
555 pop_table_name
= "md";
558 /* Now object specific. Skip any that were in the target table. */
559 pop_table_name
= "obj";
563 /* Now portable ones. Skip any that we've seen already. */
564 pop_table_name
= "standard";
565 pop_insert (potable
);
568 pop_table_name
= "cfi";
576 htab_delete (po_hash
);
579 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
580 if (ignore_input ()) \
582 char *eol = find_end_of_line (input_line_pointer - (num_read), \
584 input_line_pointer = (input_line_pointer <= buffer_limit \
585 && eol >= buffer_limit) \
591 /* Helper function of read_a_source_file, which tries to expand a macro. */
593 try_macro (char term
, const char *line
)
599 if (check_macro (line
, &out
, &err
, ¯o
))
603 *input_line_pointer
++ = term
;
604 input_scrub_include_sb (&out
,
605 input_line_pointer
, expanding_macro
);
608 input_scrub_next_buffer (&input_line_pointer
);
610 md_macro_info (macro
);
618 /* Start a new instruction bundle. Returns the rs_align_code frag that
619 will be used to align the new bundle. */
623 fragS
*frag
= frag_now
;
625 frag_align_code (0, 0);
627 while (frag
->fr_type
!= rs_align_code
)
628 frag
= frag
->fr_next
;
630 gas_assert (frag
!= frag_now
);
635 /* Calculate the maximum size after relaxation of the region starting
636 at the given frag and extending through frag_now (which is unfinished). */
638 pending_bundle_size (fragS
*frag
)
640 unsigned int offset
= frag
->fr_fix
;
641 unsigned int size
= 0;
643 gas_assert (frag
!= frag_now
);
644 gas_assert (frag
->fr_type
== rs_align_code
);
646 while (frag
!= frag_now
)
648 /* This should only happen in what will later become an error case. */
652 size
+= frag
->fr_fix
;
653 if (frag
->fr_type
== rs_machine_dependent
)
654 size
+= md_frag_max_var (frag
);
656 frag
= frag
->fr_next
;
659 gas_assert (frag
== frag_now
);
660 size
+= frag_now_fix ();
661 if (frag
->fr_type
== rs_machine_dependent
)
662 size
+= md_frag_max_var (frag
);
664 gas_assert (size
>= offset
);
666 return size
- offset
;
669 /* Finish off the frag created to ensure bundle alignment. */
671 finish_bundle (fragS
*frag
, unsigned int size
)
673 gas_assert (bundle_align_p2
> 0);
674 gas_assert (frag
->fr_type
== rs_align_code
);
678 /* If there is more than a single byte, then we need to set up the
679 alignment frag. Otherwise we leave it at its initial state from
680 calling frag_align_code (0, 0), so that it does nothing. */
681 frag
->fr_offset
= bundle_align_p2
;
682 frag
->fr_subtype
= size
- 1;
685 /* We do this every time rather than just in s_bundle_align_mode
686 so that we catch any affected section without needing hooks all
687 over for all paths that do section changes. It's cheap enough. */
688 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
689 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
692 /* Assemble one instruction. This takes care of the bundle features
693 around calling md_assemble. */
695 assemble_one (char *line
)
697 fragS
*insn_start_frag
= NULL
;
699 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
701 as_bad (_("cannot change section or subsection inside .bundle_lock"));
702 /* Clearing this serves as a marker that we have already complained. */
703 bundle_lock_frchain
= NULL
;
706 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
707 insn_start_frag
= start_bundle ();
711 if (bundle_lock_frchain
!= NULL
)
713 /* Make sure this hasn't pushed the locked sequence
714 past the bundle size. */
715 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
716 if (bundle_size
> 1U << bundle_align_p2
)
717 as_bad (_ (".bundle_lock sequence at %u bytes, "
718 "but .bundle_align_mode limit is %u bytes"),
719 bundle_size
, 1U << bundle_align_p2
);
721 else if (bundle_align_p2
> 0)
723 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
725 if (insn_size
> 1U << bundle_align_p2
)
726 as_bad (_("single instruction is %u bytes long, "
727 "but .bundle_align_mode limit is %u bytes"),
728 insn_size
, 1U << bundle_align_p2
);
730 finish_bundle (insn_start_frag
, insn_size
);
734 #else /* !HANDLE_BUNDLE */
736 # define assemble_one(line) md_assemble(line)
738 #endif /* HANDLE_BUNDLE */
743 flagword flags
= bfd_section_flags (now_seg
);
745 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
748 /* Guts of .align directive:
749 N is the power of two to which to align. A value of zero is accepted but
750 ignored: the default alignment of the section will be at least this.
751 FILL may be NULL, or it may point to the bytes of the fill pattern.
752 LEN is the length of whatever FILL points to, if anything. If LEN is zero
753 but FILL is not NULL then LEN is treated as if it were one.
754 MAX is the maximum number of characters to skip when doing the alignment,
755 or 0 if there is no maximum. */
758 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
760 if (now_seg
== absolute_section
|| in_bss ())
766 if (now_seg
== absolute_section
)
767 as_warn (_("ignoring fill value in absolute section"));
769 as_warn (_("ignoring fill value in section `%s'"),
770 segment_name (now_seg
));
777 #ifdef md_flush_pending_output
778 md_flush_pending_output ();
782 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
785 /* Only make a frag if we HAVE to... */
786 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
790 if (subseg_text_p (now_seg
))
791 frag_align_code (n
, max
);
793 frag_align (n
, 0, max
);
796 frag_align (n
, *fill
, max
);
798 frag_align_pattern (n
, fill
, len
, max
);
802 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
805 if (n
> OCTETS_PER_BYTE_POWER
)
806 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
809 /* We read the file, putting things into a web that represents what we
810 have been reading. */
812 read_a_source_file (const char *name
)
816 char *s
; /* String of symbol, '\0' appended. */
818 const pseudo_typeS
*pop
;
824 buffer
= input_scrub_new_file (name
);
827 listing_newline (NULL
);
828 register_dependency (name
);
830 /* Generate debugging information before we've read anything in to denote
831 this file as the "main" source file and not a subordinate one
832 (e.g. N_SO vs N_SOL in stabs). */
833 generate_file_debug ();
835 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
836 { /* We have another line to parse. */
838 /* In order to avoid listing macro expansion lines with labels
839 multiple times, keep track of which line was last issued. */
840 static char *last_eol
;
844 while (input_line_pointer
< buffer_limit
)
847 /* We have more of this buffer to parse. */
849 /* We now have input_line_pointer->1st char of next line.
850 If input_line_pointer [-1] == '\n' then we just
851 scanned another line: so bump line counters. */
852 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
855 symbol_set_value_now (&dot_symbol
);
856 #ifdef md_start_line_hook
857 md_start_line_hook ();
859 if (input_line_pointer
[-1] == '\n')
860 bump_line_counters ();
864 /* If listing is on, and we are expanding a macro, then give
865 the listing code the contents of the expanded line. */
868 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
870 /* Find the end of the current expanded macro line. */
871 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
874 && !startswith (input_line_pointer
,
875 !flag_m68k_mri
? " .linefile "
882 /* Copy it for safe keeping. Also give an indication of
883 how much macro nesting is involved at this point. */
884 len
= s
- input_line_pointer
;
885 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
886 memset (copy
, '>', macro_nest
);
887 copy
[macro_nest
] = ' ';
888 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
889 copy
[macro_nest
+ 1 + len
] = '\0';
891 /* Install the line with the listing facility. */
892 listing_newline (copy
);
896 listing_newline (NULL
);
903 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
905 next_char
= * input_line_pointer
;
906 /* Text at the start of a line must be a label, we
907 run down and stick a colon in. */
908 if (is_name_beginner (next_char
) || next_char
== '"')
913 HANDLE_CONDITIONAL_ASSEMBLY (0);
915 nul_char
= get_symbol_name (& line_start
);
916 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
918 /* In MRI mode, the EQU and MACRO pseudoops must
919 be handled specially. */
923 char *rest
= input_line_pointer
+ 1;
927 if (*rest
== ' ' || *rest
== '\t')
929 if ((strncasecmp (rest
, "EQU", 3) == 0
930 || strncasecmp (rest
, "SET", 3) == 0)
931 && (rest
[3] == ' ' || rest
[3] == '\t'))
933 input_line_pointer
= rest
+ 3;
935 strncasecmp (rest
, "SET", 3) == 0);
938 if (strncasecmp (rest
, "MACRO", 5) == 0
941 || is_end_of_line
[(unsigned char) rest
[5]]))
945 /* In MRI mode, we need to handle the MACRO
946 pseudo-op specially: we don't want to put the
947 symbol in the symbol table. */
949 #ifdef TC_START_LABEL_WITHOUT_COLON
950 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
953 line_label
= colon (line_start
);
955 line_label
= symbol_create (line_start
,
957 &zero_address_frag
, 0);
959 next_char
= restore_line_pointer (nul_char
);
960 if (next_char
== ':')
961 input_line_pointer
++;
966 /* We are at the beginning of a line, or similar place.
967 We expect a well-formed assembler statement.
968 A "symbol-name:" is a statement.
970 Depending on what compiler is used, the order of these tests
971 may vary to catch most common case 1st.
972 Each test is independent of all other tests at the (top)
975 nul_char
= next_char
= *input_line_pointer
++;
976 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
978 /* C is the 1st significant character.
979 Input_line_pointer points after that character. */
980 if (is_name_beginner (next_char
) || next_char
== '"')
984 /* Want user-defined label or pseudo/opcode. */
985 HANDLE_CONDITIONAL_ASSEMBLY (1);
987 --input_line_pointer
;
988 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
989 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
990 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
992 /* NEXT_CHAR is character after symbol.
993 The end of symbol in the input line is now '\0'.
994 S points to the beginning of the symbol.
995 [In case of pseudo-op, s->'.'.]
996 Input_line_pointer->'\0' where NUL_CHAR was. */
997 if (TC_START_LABEL (s
, nul_char
, next_char
))
1001 /* In MRI mode, \tsym: set 0 is permitted. */
1005 if (*rest
== ' ' || *rest
== '\t')
1008 if ((strncasecmp (rest
, "EQU", 3) == 0
1009 || strncasecmp (rest
, "SET", 3) == 0)
1010 && (rest
[3] == ' ' || rest
[3] == '\t'))
1012 input_line_pointer
= rest
+ 3;
1018 line_label
= colon (s
); /* User-defined label. */
1019 restore_line_pointer (nul_char
);
1020 ++ input_line_pointer
;
1021 #ifdef tc_check_label
1022 tc_check_label (line_label
);
1024 /* Input_line_pointer->after ':'. */
1027 else if ((next_char
== '=' && *rest
== '=')
1028 || ((next_char
== ' ' || next_char
== '\t')
1033 demand_empty_rest_of_line ();
1035 else if ((next_char
== '='
1036 || ((next_char
== ' ' || next_char
== '\t')
1038 #ifdef TC_EQUAL_IN_INSN
1039 && !TC_EQUAL_IN_INSN (next_char
, s
)
1044 demand_empty_rest_of_line ();
1048 /* Expect pseudo-op or machine instruction. */
1051 #ifndef TC_CASE_SENSITIVE
1055 strncpy (original_case_string
, s2
,
1056 sizeof (original_case_string
) - 1);
1057 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1061 *s2
= TOLOWER (*s2
);
1066 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1068 /* The MRI assembler uses pseudo-ops without
1070 pop
= str_hash_find (po_hash
, s
);
1071 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1076 || (!flag_m68k_mri
&& *s
== '.'))
1080 WARNING: next_char may be end-of-line.
1081 We lookup the pseudo-op table with s+1 because we
1082 already know that the pseudo-op begins with a '.'. */
1085 pop
= str_hash_find (po_hash
, s
+ 1);
1086 if (pop
&& !pop
->poc_handler
)
1089 /* In MRI mode, we may need to insert an
1090 automatic alignment directive. What a hack
1092 if (mri_pending_align
1094 || !((pop
->poc_handler
== cons
1095 && pop
->poc_val
== 1)
1096 || (pop
->poc_handler
== s_space
1097 && pop
->poc_val
== 1)
1098 #ifdef tc_conditional_pseudoop
1099 || tc_conditional_pseudoop (pop
)
1101 || pop
->poc_handler
== s_if
1102 || pop
->poc_handler
== s_ifdef
1103 || pop
->poc_handler
== s_ifc
1104 || pop
->poc_handler
== s_ifeqs
1105 || pop
->poc_handler
== s_else
1106 || pop
->poc_handler
== s_endif
1107 || pop
->poc_handler
== s_globl
1108 || pop
->poc_handler
== s_ignore
)))
1110 do_align (1, (char *) NULL
, 0, 0);
1111 mri_pending_align
= 0;
1113 if (line_label
!= NULL
)
1115 symbol_set_frag (line_label
, frag_now
);
1116 S_SET_VALUE (line_label
, frag_now_fix ());
1120 /* Print the error msg now, while we still can. */
1123 char *end
= input_line_pointer
;
1125 (void) restore_line_pointer (nul_char
);
1127 nul_char
= next_char
= *--input_line_pointer
;
1128 *input_line_pointer
= '\0';
1129 if (! macro_defined
|| ! try_macro (next_char
, s
))
1132 as_bad (_("unknown pseudo-op: `%s'"), s
);
1133 *input_line_pointer
++ = nul_char
;
1138 /* Put it back for error messages etc. */
1139 next_char
= restore_line_pointer (nul_char
);
1140 /* The following skip of whitespace is compulsory.
1141 A well shaped space is sometimes all that separates
1142 keyword from operands. */
1143 if (next_char
== ' ' || next_char
== '\t')
1144 input_line_pointer
++;
1146 /* Input_line is restored.
1147 Input_line_pointer->1st non-blank char
1148 after pseudo-operation. */
1149 (*pop
->poc_handler
) (pop
->poc_val
);
1151 /* If that was .end, just get out now. */
1152 if (pop
->poc_handler
== s_end
)
1157 /* WARNING: next_char may be end-of-line. */
1158 /* Also: input_line_pointer->`\0` where nul_char was. */
1159 (void) restore_line_pointer (nul_char
);
1160 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1161 next_char
= nul_char
= *input_line_pointer
;
1162 *input_line_pointer
= '\0';
1164 generate_lineno_debug ();
1166 if (macro_defined
&& try_macro (next_char
, s
))
1169 if (mri_pending_align
)
1171 do_align (1, (char *) NULL
, 0, 0);
1172 mri_pending_align
= 0;
1173 if (line_label
!= NULL
)
1175 symbol_set_frag (line_label
, frag_now
);
1176 S_SET_VALUE (line_label
, frag_now_fix ());
1180 assemble_one (s
); /* Assemble 1 instruction. */
1182 /* PR 19630: The backend may have set ilp to NULL
1183 if it encountered a catastrophic failure. */
1184 if (input_line_pointer
== NULL
)
1185 as_fatal (_("unable to continue with assembly."));
1187 *input_line_pointer
++ = nul_char
;
1189 /* We resume loop AFTER the end-of-line from
1190 this instruction. */
1196 /* Empty statement? */
1197 if (is_end_of_line
[(unsigned char) next_char
])
1200 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1202 /* local label ("4:") */
1203 char *backup
= input_line_pointer
;
1205 HANDLE_CONDITIONAL_ASSEMBLY (1);
1207 temp
= next_char
- '0';
1209 if (nul_char
== '"')
1210 ++ input_line_pointer
;
1212 /* Read the whole number. */
1213 while (ISDIGIT (*input_line_pointer
))
1215 const long digit
= *input_line_pointer
- '0';
1216 if (temp
> (INT_MAX
- digit
) / 10)
1218 as_bad (_("local label too large near %s"), backup
);
1222 temp
= temp
* 10 + digit
;
1223 ++input_line_pointer
;
1226 /* Overflow: stop processing the label. */
1229 ignore_rest_of_line ();
1233 if (LOCAL_LABELS_DOLLAR
1234 && *input_line_pointer
== '$'
1235 && *(input_line_pointer
+ 1) == ':')
1237 input_line_pointer
+= 2;
1239 if (dollar_label_defined (temp
))
1241 as_fatal (_("label \"%ld$\" redefined"), temp
);
1244 define_dollar_label (temp
);
1245 colon (dollar_label_name (temp
, 0));
1250 && *input_line_pointer
++ == ':')
1252 fb_label_instance_inc (temp
);
1253 colon (fb_label_name (temp
, 0));
1257 input_line_pointer
= backup
;
1260 if (next_char
&& strchr (line_comment_chars
, next_char
))
1261 { /* Its a comment. Better say APP or NO_APP. */
1266 s
= input_line_pointer
;
1267 if (!startswith (s
, "APP\n"))
1270 ignore_rest_of_line ();
1273 bump_line_counters ();
1276 ends
= strstr (s
, "#NO_APP\n");
1277 len
= ends
? ends
- s
: buffer_limit
- s
;
1279 sb_build (&sbuf
, len
+ 100);
1280 sb_add_buffer (&sbuf
, s
, len
);
1283 /* The end of the #APP wasn't in this buffer. We
1284 keep reading in buffers until we find the #NO_APP
1285 that goes with this #APP There is one. The specs
1289 buffer_limit
= input_scrub_next_buffer (&buffer
);
1292 ends
= strstr (buffer
, "#NO_APP\n");
1293 len
= ends
? ends
- buffer
: buffer_limit
- buffer
;
1294 sb_add_buffer (&sbuf
, buffer
, len
);
1299 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1300 input_scrub_include_sb (&sbuf
, input_line_pointer
, expanding_none
);
1302 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1306 HANDLE_CONDITIONAL_ASSEMBLY (1);
1308 #ifdef tc_unrecognized_line
1309 if (tc_unrecognized_line (next_char
))
1312 input_line_pointer
--;
1313 /* Report unknown char as error. */
1314 demand_empty_rest_of_line ();
1319 symbol_set_value_now (&dot_symbol
);
1321 #ifdef HANDLE_BUNDLE
1322 if (bundle_lock_frag
!= NULL
)
1324 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1325 _(".bundle_lock with no matching .bundle_unlock"));
1326 bundle_lock_frag
= NULL
;
1327 bundle_lock_frchain
= NULL
;
1328 bundle_lock_depth
= 0;
1335 /* Close the input file. */
1336 input_scrub_close ();
1337 #ifdef WARN_COMMENTS
1339 if (warn_comment
&& found_comment
)
1340 as_warn_where (found_comment_file
, found_comment
,
1341 "first comment found here");
1346 /* Convert O_constant expression EXP into the equivalent O_big representation.
1347 Take the sign of the number from SIGN rather than X_add_number. */
1350 convert_to_bignum (expressionS
*exp
, int sign
)
1355 value
= exp
->X_add_number
;
1356 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1358 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1359 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1361 /* Add a sequence of sign bits if the top bit of X_add_number is not
1362 the sign of the original value. */
1363 if ((exp
->X_add_number
< 0) == !sign
)
1364 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1366 exp
->X_add_number
= i
;
1369 /* For most MRI pseudo-ops, the line actually ends at the first
1370 nonquoted space. This function looks for that point, stuffs a null
1371 in, and sets *STOPCP to the character that used to be there, and
1372 returns the location.
1374 Until I hear otherwise, I am going to assume that this is only true
1375 for the m68k MRI assembler. */
1378 mri_comment_field (char *stopcp
)
1384 know (flag_m68k_mri
);
1386 for (s
= input_line_pointer
;
1387 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1395 for (s
= input_line_pointer
;
1396 !is_end_of_line
[(unsigned char) *s
];
1406 /* Skip to the end of an MRI comment field. */
1409 mri_comment_end (char *stop
, int stopc
)
1413 input_line_pointer
= stop
;
1415 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1416 ++input_line_pointer
;
1420 s_abort (int ignore ATTRIBUTE_UNUSED
)
1422 as_fatal (_(".abort detected. Abandoning ship."));
1425 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1426 (in bytes). A negative ARG is the negative of the length of the
1427 fill pattern. BYTES_P is non-zero if the alignment value should be
1428 interpreted as the byte boundary, rather than the power of 2. */
1429 #ifndef TC_ALIGN_LIMIT
1430 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1434 s_align (signed int arg
, int bytes_p
)
1436 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1445 stop
= mri_comment_field (&stopc
);
1447 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1452 align
= arg
; /* Default value from pseudo-op table. */
1456 align
= get_absolute_expression ();
1459 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1460 if (arg
> 0 && align
== 0)
1467 /* Convert to a power of 2. */
1472 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1475 as_bad (_("alignment not a power of 2"));
1481 if (align
> align_limit
)
1483 align
= align_limit
;
1484 as_warn (_("alignment too large: %u assumed"), align_limit
);
1487 if (*input_line_pointer
!= ',')
1494 ++input_line_pointer
;
1495 if (*input_line_pointer
== ',')
1499 fill
= get_absolute_expression ();
1504 if (*input_line_pointer
!= ',')
1508 ++input_line_pointer
;
1509 max
= get_absolute_expression ();
1516 as_warn (_("expected fill pattern missing"));
1517 do_align (align
, (char *) NULL
, 0, max
);
1521 unsigned int fill_len
;
1533 do_align (align
, &fill_char
, fill_len
, max
);
1539 if ((size_t) fill_len
> sizeof ab
)
1541 as_warn (_("fill pattern too long, truncating to %u"),
1542 (unsigned) sizeof ab
);
1543 fill_len
= sizeof ab
;
1546 md_number_to_chars (ab
, fill
, fill_len
);
1547 do_align (align
, ab
, fill_len
, max
);
1551 demand_empty_rest_of_line ();
1554 mri_comment_end (stop
, stopc
);
1557 /* Handle the .align pseudo-op on machines where ".align 4" means
1558 align to a 4 byte boundary. */
1561 s_align_bytes (int arg
)
1566 /* Handle the .align pseudo-op on machines where ".align 4" means align
1567 to a 2**4 boundary. */
1570 s_align_ptwo (int arg
)
1575 /* Switch in and out of alternate macro mode. */
1580 demand_empty_rest_of_line ();
1581 macro_set_alternate (on
);
1584 /* Read a symbol name from input_line_pointer.
1586 Stores the symbol name in a buffer and returns a pointer to this buffer.
1587 The buffer is xalloc'ed. It is the caller's responsibility to free
1590 The name is not left in the i_l_p buffer as it may need processing
1591 to handle escape characters.
1593 Advances i_l_p to the next non-whitespace character.
1595 If a symbol name could not be read, the routine issues an error
1596 messages, skips to the end of the line and returns NULL. */
1599 read_symbol_name (void)
1605 c
= *input_line_pointer
++;
1609 #define SYM_NAME_CHUNK_LEN 128
1610 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1614 start
= name
= XNEWVEC (char, len
+ 1);
1616 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1618 while (is_a_char (C
= next_char_of_string ()))
1620 if (name
>= name_end
)
1624 sofar
= name
- start
;
1625 len
+= SYM_NAME_CHUNK_LEN
;
1626 start
= XRESIZEVEC (char, start
, len
+ 1);
1627 name_end
= start
+ len
;
1628 name
= start
+ sofar
;
1635 /* Since quoted symbol names can contain non-ASCII characters,
1636 check the string and warn if it cannot be recognised by the
1637 current character set. */
1638 /* PR 29447: mbstowcs ignores the third (length) parameter when
1639 the first (destination) parameter is NULL. For clarity sake
1640 therefore we pass 0 rather than 'len' as the third parameter. */
1641 if (mbstowcs (NULL
, name
, 0) == (size_t) -1)
1642 as_warn (_("symbol name not recognised in the current locale"));
1644 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1648 name
= input_line_pointer
- 1;
1650 /* We accept FAKE_LABEL_CHAR in a name in case this is
1651 being called with a constructed string. */
1652 while (is_part_of_name (c
= *input_line_pointer
++)
1653 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1656 len
= (input_line_pointer
- name
) - 1;
1657 start
= XNEWVEC (char, len
+ 1);
1659 memcpy (start
, name
, len
);
1662 /* Skip a name ender char if one is present. */
1663 if (! is_name_ender (c
))
1664 --input_line_pointer
;
1667 name
= start
= NULL
;
1671 as_bad (_("expected symbol name"));
1672 ignore_rest_of_line ();
1684 s_comm_internal (int param
,
1685 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1689 symbolS
*symbolP
= NULL
;
1695 stop
= mri_comment_field (&stopc
);
1697 if ((name
= read_symbol_name ()) == NULL
)
1700 /* Accept an optional comma after the name. The comma used to be
1701 required, but Irix 5 cc does not generate it for .lcomm. */
1702 if (*input_line_pointer
== ',')
1703 input_line_pointer
++;
1705 temp
= get_absolute_expr (&exp
);
1707 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1708 if (exp
.X_op
== O_absent
)
1710 as_bad (_("missing size expression"));
1711 ignore_rest_of_line ();
1714 else if (temp
!= size
|| !exp
.X_unsigned
)
1716 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1717 ignore_rest_of_line ();
1721 symbolP
= symbol_find_or_make (name
);
1722 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1723 && !S_IS_COMMON (symbolP
))
1725 if (!S_IS_VOLATILE (symbolP
))
1728 as_bad (_("symbol `%s' is already defined"), name
);
1729 ignore_rest_of_line ();
1732 symbolP
= symbol_clone (symbolP
, 1);
1733 S_SET_SEGMENT (symbolP
, undefined_section
);
1734 S_SET_VALUE (symbolP
, 0);
1735 symbol_set_frag (symbolP
, &zero_address_frag
);
1736 S_CLEAR_VOLATILE (symbolP
);
1739 size
= S_GET_VALUE (symbolP
);
1742 else if (size
!= temp
)
1743 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1744 name
, (long) size
, (long) temp
);
1746 if (comm_parse_extra
!= NULL
)
1747 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1750 S_SET_VALUE (symbolP
, (valueT
) size
);
1751 S_SET_EXTERNAL (symbolP
);
1752 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1755 demand_empty_rest_of_line ();
1758 mri_comment_end (stop
, stopc
);
1766 s_comm_internal (ignore
, NULL
);
1769 /* The MRI COMMON pseudo-op. We handle this by creating a common
1770 symbol with the appropriate name. We make s_space do the right
1771 thing by increasing the size. */
1774 s_mri_common (int small ATTRIBUTE_UNUSED
)
1790 stop
= mri_comment_field (&stopc
);
1794 name
= input_line_pointer
;
1795 if (!ISDIGIT (*name
))
1796 c
= get_symbol_name (& name
);
1801 ++input_line_pointer
;
1803 while (ISDIGIT (*input_line_pointer
));
1805 c
= *input_line_pointer
;
1806 *input_line_pointer
= '\0';
1808 if (line_label
!= NULL
)
1810 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1811 + (input_line_pointer
- name
) + 1);
1812 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1817 sym
= symbol_find_or_make (name
);
1818 c
= restore_line_pointer (c
);
1821 if (*input_line_pointer
!= ',')
1825 ++input_line_pointer
;
1826 align
= get_absolute_expression ();
1829 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1831 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1832 mri_comment_end (stop
, stopc
);
1836 S_SET_EXTERNAL (sym
);
1837 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1838 mri_common_symbol
= sym
;
1842 S_SET_ALIGN (sym
, align
);
1847 if (line_label
!= NULL
)
1850 exp
.X_op
= O_symbol
;
1851 exp
.X_add_symbol
= sym
;
1852 exp
.X_add_number
= 0;
1853 symbol_set_value_expression (line_label
, &exp
);
1854 symbol_set_frag (line_label
, &zero_address_frag
);
1855 S_SET_SEGMENT (line_label
, expr_section
);
1858 /* FIXME: We just ignore the small argument, which distinguishes
1859 COMMON and COMMON.S. I don't know what we can do about it. */
1861 /* Ignore the type and hptype. */
1862 if (*input_line_pointer
== ',')
1863 input_line_pointer
+= 2;
1864 if (*input_line_pointer
== ',')
1865 input_line_pointer
+= 2;
1867 demand_empty_rest_of_line ();
1869 mri_comment_end (stop
, stopc
);
1873 s_data (int ignore ATTRIBUTE_UNUSED
)
1878 temp
= get_absolute_expression ();
1879 if (flag_readonly_data_in_text
)
1881 section
= text_section
;
1885 section
= data_section
;
1887 subseg_set (section
, (subsegT
) temp
);
1889 demand_empty_rest_of_line ();
1892 /* Handle the .file pseudo-op. This default definition may be overridden by
1893 the object or CPU specific pseudo-ops. */
1896 s_file_string (char *file
)
1900 listing_source_file (file
);
1902 register_dependency (file
);
1904 obj_app_file (file
);
1909 s_file (int ignore ATTRIBUTE_UNUSED
)
1914 /* Some assemblers tolerate immediately following '"'. */
1915 if ((s
= demand_copy_string (&length
)) != 0)
1917 new_logical_line_flags (s
, -1, 1);
1919 /* In MRI mode, the preprocessor may have inserted an extraneous
1922 && *input_line_pointer
== '\''
1923 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1924 ++input_line_pointer
;
1926 demand_empty_rest_of_line ();
1932 get_linefile_number (int *flag
)
1938 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1941 /* Don't mistakenly interpret octal numbers as line numbers. */
1942 if (*input_line_pointer
== '0')
1945 ++input_line_pointer
;
1949 expression_and_evaluate (&exp
);
1950 if (exp
.X_op
!= O_constant
)
1953 #if defined (BFD64) || LONG_MAX > INT_MAX
1954 if (exp
.X_add_number
< INT_MIN
|| exp
.X_add_number
> INT_MAX
)
1958 *flag
= exp
.X_add_number
;
1963 /* Handle the .linefile pseudo-op. This is automatically generated by
1964 do_scrub_chars when a preprocessor # line comment is seen. This
1965 default definition may be overridden by the object or CPU specific
1969 s_linefile (int ignore ATTRIBUTE_UNUSED
)
1972 int linenum
, flags
= 0;
1974 /* The given number is that of the next line. */
1975 if (!get_linefile_number (&linenum
))
1977 ignore_rest_of_line ();
1982 /* Some of the back ends can't deal with non-positive line numbers.
1983 Besides, it's silly. GCC however will generate a line number of
1984 zero when it is pre-processing builtins for assembler-with-cpp files:
1988 We do not want to barf on this, especially since such files are used
1989 in the GCC and GDB testsuites. So we check for negative line numbers
1990 rather than non-positive line numbers. */
1991 as_warn (_("line numbers must be positive; line number %d rejected"),
1999 if (*input_line_pointer
== '"')
2000 file
= demand_copy_string (&length
);
2001 else if (*input_line_pointer
== '.')
2003 /* buffer_and_nest() may insert this form. */
2004 ++input_line_pointer
;
2012 while (get_linefile_number (&this_flag
))
2015 /* From GCC's cpp documentation:
2016 1: start of a new file.
2017 2: returning to a file after having included another file.
2018 3: following text comes from a system header file.
2019 4: following text should be treated as extern "C".
2021 4 is nonsensical for the assembler; 3, we don't care about,
2022 so we ignore it just in case a system header file is
2023 included while preprocessing assembly. So 1 and 2 are all
2024 we care about, and they are mutually incompatible.
2025 new_logical_line_flags() demands this. */
2028 if (flags
&& flags
!= (1 << this_flag
))
2029 as_warn (_("incompatible flag %i in line directive"),
2032 flags
|= 1 << this_flag
;
2037 /* We ignore these. */
2041 as_warn (_("unsupported flag %i in line directive"),
2046 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2052 demand_empty_rest_of_line ();
2054 /* read_a_source_file() will bump the line number only if the line
2055 is terminated by '\n'. */
2056 if (input_line_pointer
[-1] == '\n')
2059 new_logical_line_flags (file
, linenum
, flags
);
2062 listing_source_line (linenum
);
2067 ignore_rest_of_line ();
2070 /* Handle the .end pseudo-op. Actually, the real work is done in
2071 read_a_source_file. */
2074 s_end (int ignore ATTRIBUTE_UNUSED
)
2078 /* The MRI assembler permits the start symbol to follow .end,
2079 but we don't support that. */
2081 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2082 && *input_line_pointer
!= '*'
2083 && *input_line_pointer
!= '!')
2084 as_warn (_("start address not supported"));
2088 /* Handle the .err pseudo-op. */
2091 s_err (int ignore ATTRIBUTE_UNUSED
)
2093 as_bad (_(".err encountered"));
2094 demand_empty_rest_of_line ();
2097 /* Handle the .error and .warning pseudo-ops. */
2103 /* The purpose for the conditional assignment is not to
2104 internationalize the directive itself, but that we need a
2105 self-contained message, one that can be passed like the
2106 demand_copy_C_string return value, and with no assumption on the
2107 location of the name of the directive within the message. */
2109 = (err
? _(".error directive invoked in source file")
2110 : _(".warning directive invoked in source file"));
2112 if (!is_it_end_of_statement ())
2114 if (*input_line_pointer
!= '\"')
2116 as_bad (_("%s argument must be a string"),
2117 err
? ".error" : ".warning");
2118 ignore_rest_of_line ();
2122 msg
= demand_copy_C_string (&len
);
2130 as_warn ("%s", msg
);
2131 demand_empty_rest_of_line ();
2134 /* Handle the MRI fail pseudo-op. */
2137 s_fail (int ignore ATTRIBUTE_UNUSED
)
2144 stop
= mri_comment_field (&stopc
);
2146 temp
= get_absolute_expression ();
2148 as_warn (_(".fail %ld encountered"), (long) temp
);
2150 as_bad (_(".fail %ld encountered"), (long) temp
);
2152 demand_empty_rest_of_line ();
2155 mri_comment_end (stop
, stopc
);
2159 s_fill (int ignore ATTRIBUTE_UNUSED
)
2161 expressionS rep_exp
;
2166 #ifdef md_flush_pending_output
2167 md_flush_pending_output ();
2170 #ifdef md_cons_align
2174 expression (&rep_exp
);
2175 if (*input_line_pointer
== ',')
2177 input_line_pointer
++;
2178 size
= get_absolute_expression ();
2179 if (*input_line_pointer
== ',')
2181 input_line_pointer
++;
2182 fill
= get_absolute_expression ();
2186 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2187 #define BSD_FILL_SIZE_CROCK_8 (8)
2188 if (size
> BSD_FILL_SIZE_CROCK_8
)
2190 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2191 size
= BSD_FILL_SIZE_CROCK_8
;
2195 as_warn (_("size negative; .fill ignored"));
2198 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2200 if (rep_exp
.X_add_number
< 0)
2201 as_warn (_("repeat < 0; .fill ignored"));
2204 else if (size
&& !need_pass_2
)
2206 if (now_seg
== absolute_section
&& rep_exp
.X_op
!= O_constant
)
2208 as_bad (_("non-constant fill count for absolute section"));
2211 else if (now_seg
== absolute_section
&& fill
&& rep_exp
.X_add_number
!= 0)
2213 as_bad (_("attempt to fill absolute section with non-zero value"));
2217 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2220 as_bad (_("attempt to fill section `%s' with non-zero value"),
2221 segment_name (now_seg
));
2226 if (size
&& !need_pass_2
)
2228 if (now_seg
== absolute_section
)
2229 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2231 if (rep_exp
.X_op
== O_constant
)
2233 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2234 (relax_substateT
) 0, (symbolS
*) 0,
2235 (offsetT
) rep_exp
.X_add_number
,
2240 /* We don't have a constant repeat count, so we can't use
2241 rs_fill. We can get the same results out of rs_space,
2242 but its argument is in bytes, so we must multiply the
2243 repeat count by size. */
2246 rep_sym
= make_expr_symbol (&rep_exp
);
2249 expressionS size_exp
;
2250 size_exp
.X_op
= O_constant
;
2251 size_exp
.X_add_number
= size
;
2253 rep_exp
.X_op
= O_multiply
;
2254 rep_exp
.X_add_symbol
= rep_sym
;
2255 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2256 rep_exp
.X_add_number
= 0;
2257 rep_sym
= make_expr_symbol (&rep_exp
);
2260 p
= frag_var (rs_space
, (int) size
, (int) size
,
2261 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2264 memset (p
, 0, (unsigned int) size
);
2266 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2267 flavoured AS. The following bizarre behaviour is to be
2268 compatible with above. I guess they tried to take up to 8
2269 bytes from a 4-byte expression and they forgot to sign
2271 #define BSD_FILL_SIZE_CROCK_4 (4)
2272 md_number_to_chars (p
, (valueT
) fill
,
2273 (size
> BSD_FILL_SIZE_CROCK_4
2274 ? BSD_FILL_SIZE_CROCK_4
2276 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2277 but emits no error message because it seems a legal thing to do.
2278 It is a degenerate case of .fill but could be emitted by a
2281 demand_empty_rest_of_line ();
2285 s_globl (int ignore ATTRIBUTE_UNUSED
)
2294 stop
= mri_comment_field (&stopc
);
2298 if ((name
= read_symbol_name ()) == NULL
)
2301 symbolP
= symbol_find_or_make (name
);
2302 S_SET_EXTERNAL (symbolP
);
2305 c
= *input_line_pointer
;
2308 input_line_pointer
++;
2310 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2318 demand_empty_rest_of_line ();
2321 mri_comment_end (stop
, stopc
);
2324 /* Handle the MRI IRP and IRPC pseudo-ops. */
2336 file
= as_where (&line
);
2338 eol
= find_end_of_line (input_line_pointer
, 0);
2339 sb_build (&s
, eol
- input_line_pointer
);
2340 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2341 input_line_pointer
= eol
;
2345 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2347 as_bad_where (file
, line
, "%s", err
);
2351 input_scrub_include_sb (&out
, input_line_pointer
, expanding_repeat
);
2353 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2356 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2357 the section to only be linked once. However, this is not supported
2358 by most object file formats. This takes an optional argument,
2359 which is what to do about duplicates. */
2362 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2364 enum linkonce_type type
;
2368 type
= LINKONCE_DISCARD
;
2370 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2375 c
= get_symbol_name (& s
);
2376 if (strcasecmp (s
, "discard") == 0)
2377 type
= LINKONCE_DISCARD
;
2378 else if (strcasecmp (s
, "one_only") == 0)
2379 type
= LINKONCE_ONE_ONLY
;
2380 else if (strcasecmp (s
, "same_size") == 0)
2381 type
= LINKONCE_SAME_SIZE
;
2382 else if (strcasecmp (s
, "same_contents") == 0)
2383 type
= LINKONCE_SAME_CONTENTS
;
2385 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2387 (void) restore_line_pointer (c
);
2390 #ifdef obj_handle_link_once
2391 obj_handle_link_once (type
);
2392 #else /* ! defined (obj_handle_link_once) */
2396 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2397 as_warn (_(".linkonce is not supported for this object file format"));
2399 flags
= bfd_section_flags (now_seg
);
2400 flags
|= SEC_LINK_ONCE
;
2405 case LINKONCE_DISCARD
:
2406 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2408 case LINKONCE_ONE_ONLY
:
2409 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2411 case LINKONCE_SAME_SIZE
:
2412 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2414 case LINKONCE_SAME_CONTENTS
:
2415 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2418 if (!bfd_set_section_flags (now_seg
, flags
))
2419 as_bad (_("bfd_set_section_flags: %s"),
2420 bfd_errmsg (bfd_get_error ()));
2422 #endif /* ! defined (obj_handle_link_once) */
2424 demand_empty_rest_of_line ();
2428 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2431 segT current_seg
= now_seg
;
2432 subsegT current_subseg
= now_subseg
;
2433 segT bss_seg
= bss_section
;
2435 #if defined (TC_MIPS) || defined (TC_ALPHA)
2436 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2437 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2439 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2440 if (size
<= bfd_get_gp_size (stdoutput
))
2442 bss_seg
= subseg_new (".sbss", 1);
2443 seg_info (bss_seg
)->bss
= 1;
2444 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2445 as_warn (_("error setting flags for \".sbss\": %s"),
2446 bfd_errmsg (bfd_get_error ()));
2450 subseg_set (bss_seg
, 1);
2452 if (align
> OCTETS_PER_BYTE_POWER
)
2454 record_alignment (bss_seg
, align
);
2455 frag_align (align
, 0, 0);
2458 /* Detach from old frag. */
2459 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2460 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2462 symbol_set_frag (symbolP
, frag_now
);
2463 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
* OCTETS_PER_BYTE
, NULL
);
2467 S_SET_SIZE (symbolP
, size
);
2469 S_SET_SEGMENT (symbolP
, bss_seg
);
2472 /* The symbol may already have been created with a preceding
2473 ".globl" directive -- be careful not to step on storage class
2474 in that case. Otherwise, set it to static. */
2475 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2476 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2477 #endif /* OBJ_COFF */
2479 subseg_set (current_seg
, current_subseg
);
2483 parse_align (int align_bytes
)
2489 if (*input_line_pointer
!= ',')
2492 as_bad (_("expected alignment after size"));
2493 ignore_rest_of_line ();
2497 input_line_pointer
++;
2500 align
= get_absolute_expr (&exp
);
2501 if (exp
.X_op
== O_absent
)
2504 if (!exp
.X_unsigned
)
2506 as_warn (_("alignment negative; 0 assumed"));
2510 if (align_bytes
&& align
!= 0)
2512 /* convert to a power of 2 alignment */
2513 unsigned int alignp2
= 0;
2514 while ((align
& 1) == 0)
2515 align
>>= 1, ++alignp2
;
2518 as_bad (_("alignment not a power of 2"));
2519 ignore_rest_of_line ();
2527 /* Called from s_comm_internal after symbol name and size have been
2528 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2529 1 if this was a ".bss" directive which has a 3rd argument
2530 (alignment as a power of 2), or 2 if this was a ".bss" directive
2531 with alignment in bytes. */
2534 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2540 align
= parse_align (needs_align
- 1);
2541 if (align
== (addressT
) -1)
2545 /* Assume some objects may require alignment on some systems. */
2546 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2548 bss_alloc (symbolP
, size
, align
);
2553 s_lcomm (int needs_align
)
2555 s_comm_internal (needs_align
, s_lcomm_internal
);
2559 s_lcomm_bytes (int needs_align
)
2561 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2565 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2571 /* We permit ANY defined expression: BSD4.2 demands constants. */
2572 if ((name
= read_symbol_name ()) == NULL
)
2575 if (*input_line_pointer
!= ',')
2577 as_bad (_("expected comma after \"%s\""), name
);
2581 input_line_pointer
++;
2582 expression_and_evaluate (&exp
);
2584 if (exp
.X_op
!= O_constant
2585 && exp
.X_op
!= O_register
)
2587 as_bad (_("bad expression"));
2591 symbolP
= symbol_find_or_make (name
);
2593 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2595 /* The name might be an undefined .global symbol; be sure to
2596 keep the "external" bit. */
2597 S_SET_SEGMENT (symbolP
,
2598 (exp
.X_op
== O_constant
2601 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2605 as_bad (_("symbol `%s' is already defined"), name
);
2608 demand_empty_rest_of_line ();
2613 ignore_rest_of_line ();
2618 /* Read a line into an sb. Returns the character that ended the line
2619 or zero if there are no more lines. */
2622 get_line_sb (sb
*line
, int in_macro
)
2626 if (input_line_pointer
[-1] == '\n')
2627 bump_line_counters ();
2629 if (input_line_pointer
>= buffer_limit
)
2631 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2632 if (buffer_limit
== 0)
2636 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2637 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2638 input_line_pointer
= eol
;
2640 /* Don't skip multiple end-of-line characters, because that breaks support
2641 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2642 characters but isn't. Instead just skip one end of line character and
2643 return the character skipped so that the caller can re-insert it if
2645 return *input_line_pointer
++;
2649 get_non_macro_line_sb (sb
*line
)
2651 return get_line_sb (line
, 0);
2655 get_macro_line_sb (sb
*line
)
2657 return get_line_sb (line
, 1);
2660 /* Define a macro. This is an interface to macro.c. */
2663 s_macro (int ignore ATTRIBUTE_UNUSED
)
2669 eol
= find_end_of_line (input_line_pointer
, 0);
2670 sb_build (&s
, eol
- input_line_pointer
);
2671 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2672 input_line_pointer
= eol
;
2674 if (line_label
!= NULL
)
2680 name
= S_GET_NAME (line_label
);
2681 len
= strlen (name
);
2682 sb_build (&label
, len
);
2683 sb_add_buffer (&label
, name
, len
);
2684 macro
= define_macro (&s
, &label
, get_macro_line_sb
);
2688 macro
= define_macro (&s
, NULL
, get_macro_line_sb
);
2691 if (line_label
!= NULL
)
2693 S_SET_SEGMENT (line_label
, absolute_section
);
2694 S_SET_VALUE (line_label
, 0);
2695 symbol_set_frag (line_label
, &zero_address_frag
);
2698 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2699 && str_hash_find (po_hash
, macro
->name
) != NULL
)
2701 && macro
->name
[0] == '.'
2702 && str_hash_find (po_hash
, macro
->name
+ 1) != NULL
))
2704 as_warn_where (macro
->file
, macro
->line
,
2705 _("attempt to redefine pseudo-op `%s' ignored"),
2707 str_hash_delete (macro_hash
, macro
->name
);
2714 /* Handle the .mexit pseudo-op, which immediately exits a macro
2718 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2722 cond_exit_macro (macro_nest
);
2723 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2726 as_warn (_("ignoring macro exit outside a macro definition."));
2729 /* Switch in and out of MRI mode. */
2732 s_mri (int ignore ATTRIBUTE_UNUSED
)
2735 #ifdef MRI_MODE_CHANGE
2739 on
= get_absolute_expression ();
2740 #ifdef MRI_MODE_CHANGE
2741 old_flag
= flag_mri
;
2760 /* Operator precedence changes in m68k MRI mode, so we need to
2761 update the operator rankings. */
2762 expr_set_precedence ();
2764 #ifdef MRI_MODE_CHANGE
2766 MRI_MODE_CHANGE (on
);
2769 demand_empty_rest_of_line ();
2772 /* Handle changing the location counter. */
2775 do_org (segT segment
, expressionS
*exp
, int fill
)
2777 if (segment
!= now_seg
2778 && segment
!= absolute_section
2779 && segment
!= expr_section
)
2780 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2782 if (now_seg
== absolute_section
)
2785 as_warn (_("ignoring fill value in absolute section"));
2786 if (exp
->X_op
!= O_constant
)
2788 as_bad (_("only constant offsets supported in absolute section"));
2789 exp
->X_add_number
= 0;
2791 abs_section_offset
= exp
->X_add_number
;
2796 symbolS
*sym
= exp
->X_add_symbol
;
2797 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2799 if (fill
&& in_bss ())
2800 as_warn (_("ignoring fill value in section `%s'"),
2801 segment_name (now_seg
));
2803 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2805 /* Handle complex expressions. */
2806 sym
= make_expr_symbol (exp
);
2810 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2816 s_org (int ignore ATTRIBUTE_UNUSED
)
2822 #ifdef md_flush_pending_output
2823 md_flush_pending_output ();
2826 /* The m68k MRI assembler has a different meaning for .org. It
2827 means to create an absolute section at a given address. We can't
2828 support that--use a linker script instead. */
2831 as_bad (_("MRI style ORG pseudo-op not supported"));
2832 ignore_rest_of_line ();
2836 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2837 thing as a sub-segment-relative origin. Any absolute origin is
2838 given a warning, then assumed to be segment-relative. Any
2839 segmented origin expression ("foo+42") had better be in the right
2840 segment or the .org is ignored.
2842 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2843 we never know sub-segment sizes when we are reading code. BSD
2844 will crash trying to emit negative numbers of filler bytes in
2845 certain .orgs. We don't crash, but see as-write for that code.
2847 Don't make frag if need_pass_2==1. */
2848 segment
= get_known_segmented_expression (&exp
);
2849 if (*input_line_pointer
== ',')
2851 input_line_pointer
++;
2852 temp_fill
= get_absolute_expression ();
2858 do_org (segment
, &exp
, temp_fill
);
2860 demand_empty_rest_of_line ();
2863 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2864 called by the obj-format routine which handles section changing
2865 when in MRI mode. It will create a new section, and return it. It
2866 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2867 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2870 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2880 name
= input_line_pointer
;
2881 if (!ISDIGIT (*name
))
2882 c
= get_symbol_name (& name
);
2887 ++input_line_pointer
;
2889 while (ISDIGIT (*input_line_pointer
));
2891 c
= *input_line_pointer
;
2892 *input_line_pointer
= '\0';
2895 name
= xstrdup (name
);
2897 c
= restore_line_pointer (c
);
2899 seg
= subseg_new (name
, 0);
2905 ++input_line_pointer
;
2906 align
= get_absolute_expression ();
2907 record_alignment (seg
, align
);
2911 if (*input_line_pointer
== ',')
2913 c
= *++input_line_pointer
;
2915 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2918 as_bad (_("unrecognized section type"));
2919 ++input_line_pointer
;
2924 flags
= SEC_NO_FLAGS
;
2926 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2927 else if (*type
== 'D' || *type
== 'M')
2928 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2929 else if (*type
== 'R')
2930 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2931 if (flags
!= SEC_NO_FLAGS
)
2933 if (!bfd_set_section_flags (seg
, flags
))
2934 as_warn (_("error setting flags for \"%s\": %s"),
2935 bfd_section_name (seg
),
2936 bfd_errmsg (bfd_get_error ()));
2941 /* Ignore the HP type. */
2942 if (*input_line_pointer
== ',')
2943 input_line_pointer
+= 2;
2945 demand_empty_rest_of_line ();
2947 #else /* ! TC_M68K */
2948 /* The MRI assembler seems to use different forms of .sect for
2949 different targets. */
2950 as_bad ("MRI mode not supported for this target");
2951 ignore_rest_of_line ();
2952 #endif /* ! TC_M68K */
2955 /* Handle the .print pseudo-op. */
2958 s_print (int ignore ATTRIBUTE_UNUSED
)
2963 s
= demand_copy_C_string (&len
);
2966 demand_empty_rest_of_line ();
2969 /* Handle the .purgem pseudo-op. */
2972 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2974 if (is_it_end_of_statement ())
2976 demand_empty_rest_of_line ();
2986 c
= get_symbol_name (& name
);
2987 delete_macro (name
);
2988 *input_line_pointer
= c
;
2989 SKIP_WHITESPACE_AFTER_NAME ();
2991 while (*input_line_pointer
++ == ',');
2993 --input_line_pointer
;
2994 demand_empty_rest_of_line ();
2997 /* Handle the .endm/.endr pseudo-ops. */
3000 s_bad_end (int endr
)
3002 as_warn (_(".end%c encountered without preceding %s"),
3004 endr
? ".rept, .irp, or .irpc" : ".macro");
3005 demand_empty_rest_of_line ();
3008 /* Handle the .rept pseudo-op. */
3011 s_rept (int ignore ATTRIBUTE_UNUSED
)
3015 count
= (size_t) get_absolute_expression ();
3017 do_repeat (count
, "REPT", "ENDR", NULL
);
3020 /* This function provides a generic repeat block implementation. It allows
3021 different directives to be used as the start/end keys. Any text matching
3022 the optional EXPANDER in the block is replaced by the remaining iteration
3026 do_repeat (size_t count
, const char *start
, const char *end
,
3027 const char *expander
)
3032 if (((ssize_t
) count
) < 0)
3034 as_bad (_("negative count for %s - ignored"), start
);
3039 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3041 as_bad (_("%s without %s"), start
, end
);
3046 if (expander
== NULL
|| strstr (one
.ptr
, expander
) == NULL
)
3048 sb_build (&many
, count
* one
.len
);
3050 sb_add_sb (&many
, &one
);
3056 while (count
-- > 0)
3062 sb_build (& processed
, one
.len
);
3063 sb_add_sb (& processed
, & one
);
3064 sub
= strstr (processed
.ptr
, expander
);
3065 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3066 gas_assert (len
< 8);
3067 memmove (sub
+ len
, sub
+ 8,
3068 processed
.ptr
+ processed
.len
- (sub
+ 8));
3069 processed
.len
-= (8 - len
);
3070 sb_add_sb (& many
, & processed
);
3071 sb_kill (& processed
);
3077 input_scrub_include_sb (&many
, input_line_pointer
, expanding_repeat
);
3079 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3082 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3083 input buffers to skip. Assumes that conditionals preceding the loop end
3084 are properly nested.
3086 This function makes it easier to implement a premature "break" out of the
3087 loop. The EXTRA arg accounts for other buffers we might have inserted,
3088 such as line substitutions. */
3091 end_repeat (int extra
)
3093 cond_exit_macro (macro_nest
);
3094 while (extra
-- >= 0)
3095 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3099 assign_symbol (char *name
, int mode
)
3103 if (name
[0] == '.' && name
[1] == '\0')
3105 /* Turn '. = mumble' into a .org mumble. */
3109 segment
= get_known_segmented_expression (&exp
);
3112 do_org (segment
, &exp
, 0);
3117 if ((symbolP
= symbol_find (name
)) == NULL
3118 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3120 symbolP
= symbol_find_or_make (name
);
3122 /* When doing symbol listings, play games with dummy fragments living
3123 outside the normal fragment chain to record the file and line info
3125 if (listing
& LISTING_SYMBOLS
)
3127 extern struct list_info_struct
*listing_tail
;
3128 fragS
*dummy_frag
= notes_calloc (1, sizeof (*dummy_frag
));
3129 dummy_frag
->line
= listing_tail
;
3130 dummy_frag
->fr_symbol
= symbolP
;
3131 symbol_set_frag (symbolP
, dummy_frag
);
3134 #if defined (OBJ_COFF) && !defined (TE_PE)
3135 /* "set" symbols are local unless otherwise specified. */
3136 SF_SET_LOCAL (symbolP
);
3140 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3142 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3143 && !S_CAN_BE_REDEFINED (symbolP
))
3145 as_bad (_("symbol `%s' is already defined"), name
);
3146 ignore_rest_of_line ();
3147 input_line_pointer
--;
3150 /* If the symbol is volatile, copy the symbol and replace the
3151 original with the copy, so that previous uses of the symbol will
3152 retain the value of the symbol at the point of use. */
3153 else if (S_IS_VOLATILE (symbolP
))
3154 symbolP
= symbol_clone (symbolP
, 1);
3158 S_SET_VOLATILE (symbolP
);
3160 S_SET_FORWARD_REF (symbolP
);
3162 pseudo_set (symbolP
);
3165 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3166 then this is .equiv, and it is an error if the symbol is already
3167 defined. If EQUIV is -1, the symbol additionally is a forward
3175 /* Especial apologies for the random logic:
3176 this just grew, and could be parsed much more simply!
3178 if ((name
= read_symbol_name ()) == NULL
)
3181 if (*input_line_pointer
!= ',')
3183 as_bad (_("expected comma after \"%s\""), name
);
3184 ignore_rest_of_line ();
3189 input_line_pointer
++;
3190 assign_symbol (name
, equiv
);
3191 demand_empty_rest_of_line ();
3205 #ifdef md_flush_pending_output
3206 md_flush_pending_output ();
3213 # ifndef P_PRECISION
3214 # define P_PRECISION X_PRECISION
3215 # define P_PRECISION_PAD X_PRECISION_PAD
3217 mult
= (X_PRECISION
+ X_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3225 mult
= (P_PRECISION
+ P_PRECISION_PAD
) * sizeof (LITTLENUM_TYPE
);
3232 #ifdef md_cons_align
3237 stop
= mri_comment_field (&stopc
);
3239 /* In m68k MRI mode, we need to align to a word boundary, unless
3241 if (flag_m68k_mri
&& mult
> 1)
3243 if (now_seg
== absolute_section
)
3245 abs_section_offset
+= abs_section_offset
& 1;
3246 if (line_label
!= NULL
)
3247 S_SET_VALUE (line_label
, abs_section_offset
);
3249 else if (mri_common_symbol
!= NULL
)
3253 mri_val
= S_GET_VALUE (mri_common_symbol
);
3254 if ((mri_val
& 1) != 0)
3256 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3257 if (line_label
!= NULL
)
3259 expressionS
*symexp
;
3261 symexp
= symbol_get_value_expression (line_label
);
3262 know (symexp
->X_op
== O_symbol
);
3263 know (symexp
->X_add_symbol
== mri_common_symbol
);
3264 symexp
->X_add_number
+= 1;
3270 do_align (1, (char *) NULL
, 0, 0);
3271 if (line_label
!= NULL
)
3273 symbol_set_frag (line_label
, frag_now
);
3274 S_SET_VALUE (line_label
, frag_now_fix ());
3284 if (*input_line_pointer
== ',')
3286 ++input_line_pointer
;
3291 val
.X_op
= O_constant
;
3292 val
.X_add_number
= 0;
3295 if ((val
.X_op
!= O_constant
3296 || val
.X_add_number
< - 0x80
3297 || val
.X_add_number
> 0xff
3298 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3299 && (now_seg
!= absolute_section
&& !in_bss ()))
3301 resolve_expression (&exp
);
3302 if (exp
.X_op
!= O_constant
)
3303 as_bad (_("unsupported variable size or fill value"));
3308 /* PR 20901: Check for excessive values.
3309 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3310 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3311 as_bad (_("size value for space directive too large: %lx"),
3312 (long) exp
.X_add_number
);
3317 bytes
= mult
* exp
.X_add_number
;
3319 for (i
= 0; i
< exp
.X_add_number
; i
++)
3320 emit_expr (&val
, mult
);
3326 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3327 resolve_expression (&exp
);
3329 if (exp
.X_op
== O_constant
)
3331 addressT repeat
= exp
.X_add_number
;
3335 if ((offsetT
) repeat
< 0)
3337 as_warn (_(".space repeat count is negative, ignored"));
3343 as_warn (_(".space repeat count is zero, ignored"));
3346 if ((unsigned int) mult
<= 1)
3348 else if (gas_mul_overflow (repeat
, mult
, &total
)
3349 || (offsetT
) total
< 0)
3351 as_warn (_(".space repeat count overflow, ignored"));
3356 /* If we are in the absolute section, just bump the offset. */
3357 if (now_seg
== absolute_section
)
3359 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3360 as_warn (_("ignoring fill value in absolute section"));
3361 abs_section_offset
+= total
;
3365 /* If we are secretly in an MRI common section, then
3366 creating space just increases the size of the common
3368 if (mri_common_symbol
!= NULL
)
3370 S_SET_VALUE (mri_common_symbol
,
3371 S_GET_VALUE (mri_common_symbol
) + total
);
3376 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3377 (offsetT
) total
, (char *) 0);
3381 if (now_seg
== absolute_section
)
3383 as_bad (_("space allocation too complex in absolute section"));
3384 subseg_set (text_section
, 0);
3387 if (mri_common_symbol
!= NULL
)
3389 as_bad (_("space allocation too complex in common section"));
3390 mri_common_symbol
= NULL
;
3394 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3395 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3398 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3399 as_warn (_("ignoring fill value in section `%s'"),
3400 segment_name (now_seg
));
3402 *p
= val
.X_add_number
;
3407 /* In MRI mode, after an odd number of bytes, we must align to an
3408 even word boundary, unless the next instruction is a dc.b, ds.b
3410 if (flag_mri
&& (bytes
& 1) != 0)
3411 mri_pending_align
= 1;
3413 demand_empty_rest_of_line ();
3416 mri_comment_end (stop
, stopc
);
3420 s_nop (int ignore ATTRIBUTE_UNUSED
)
3427 #ifdef md_flush_pending_output
3428 md_flush_pending_output ();
3431 #ifdef md_cons_align
3437 demand_empty_rest_of_line ();
3440 start_off
= frag_now_fix ();
3443 #ifdef md_emit_single_noop
3444 md_emit_single_noop
;
3448 #ifndef md_single_noop_insn
3449 #define md_single_noop_insn "nop"
3451 /* md_assemble might modify its argument, so
3452 we must pass it a string that is writable. */
3453 if (asprintf (&nop
, "%s", md_single_noop_insn
) < 0)
3454 as_fatal ("%s", xstrerror (errno
));
3456 /* Some targets assume that they can update input_line_pointer
3457 inside md_assemble, and, worse, that they can leave it
3458 assigned to the string pointer that was provided as an
3459 argument. So preserve ilp here. */
3460 char *saved_ilp
= input_line_pointer
;
3462 input_line_pointer
= saved_ilp
;
3465 #ifdef md_flush_pending_output
3466 md_flush_pending_output ();
3468 } while (exp
.X_op
== O_constant
3469 && exp
.X_add_number
> 0
3470 && frag_offset_ignore_align_p (start
, frag_now
, &frag_off
)
3471 && frag_off
+ frag_now_fix () < start_off
+ exp
.X_add_number
);
3475 s_nops (int ignore ATTRIBUTE_UNUSED
)
3480 #ifdef md_flush_pending_output
3481 md_flush_pending_output ();
3484 #ifdef md_cons_align
3490 /* Note - this expression is tested for an absolute value in
3491 write.c:relax_segment(). */
3494 if (*input_line_pointer
== ',')
3496 ++input_line_pointer
;
3501 val
.X_op
= O_constant
;
3502 val
.X_add_number
= 0;
3505 if (val
.X_op
!= O_constant
)
3507 as_bad (_("unsupported variable nop control in .nops directive"));
3508 val
.X_op
= O_constant
;
3509 val
.X_add_number
= 0;
3511 else if (val
.X_add_number
< 0)
3513 as_warn (_("negative nop control byte, ignored"));
3514 val
.X_add_number
= 0;
3517 demand_empty_rest_of_line ();
3520 /* Ignore this directive if we are going to perform a second pass. */
3523 /* Store the no-op instruction control byte in the first byte of frag. */
3525 symbolS
*sym
= make_expr_symbol (&exp
);
3526 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3527 sym
, (offsetT
) 0, (char *) 0);
3528 *p
= val
.X_add_number
;
3531 /* Obtain the size of a floating point number, given a type. */
3534 float_length (int float_type
, int *pad_p
)
3536 int length
, pad
= 0;
3564 length
= X_PRECISION
* sizeof (LITTLENUM_TYPE
);
3565 pad
= X_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3574 length
= P_PRECISION
* sizeof (LITTLENUM_TYPE
);
3575 pad
= P_PRECISION_PAD
* sizeof (LITTLENUM_TYPE
);
3582 as_bad (_("unknown floating type '%c'"), float_type
);
3594 parse_one_float (int float_type
, char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
])
3600 /* Skip any 0{letter} that may be present. Don't even check if the
3601 letter is legal. Someone may invent a "z" format and this routine
3602 has no use for such information. Lusers beware: you get
3603 diagnostics if your input is ill-conditioned. */
3604 if (input_line_pointer
[0] == '0'
3605 && ISALPHA (input_line_pointer
[1]))
3606 input_line_pointer
+= 2;
3608 /* Accept :xxxx, where the x's are hex digits, for a floating point
3609 with the exact digits specified. */
3610 if (input_line_pointer
[0] == ':')
3612 ++input_line_pointer
;
3613 length
= hex_float (float_type
, temp
);
3616 ignore_rest_of_line ();
3624 err
= md_atof (float_type
, temp
, &length
);
3625 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3626 know (err
!= NULL
|| length
> 0);
3629 as_bad (_("bad floating literal: %s"), err
);
3630 ignore_rest_of_line ();
3638 /* This is like s_space, but the value is a floating point number with
3639 the given precision. This is for the MRI dcb.s pseudo-op and
3643 s_float_space (int float_type
)
3647 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3651 #ifdef md_cons_align
3656 stop
= mri_comment_field (&stopc
);
3658 count
= get_absolute_expression ();
3661 if (*input_line_pointer
!= ',')
3665 flen
= float_length (float_type
, &pad
);
3667 memset (temp
, 0, flen
+= pad
);
3671 ++input_line_pointer
;
3673 flen
= parse_one_float (float_type
, temp
);
3679 mri_comment_end (stop
, stopc
);
3683 while (--count
>= 0)
3687 p
= frag_more (flen
);
3688 memcpy (p
, temp
, (unsigned int) flen
);
3691 demand_empty_rest_of_line ();
3694 mri_comment_end (stop
, stopc
);
3697 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3700 s_struct (int ignore ATTRIBUTE_UNUSED
)
3706 stop
= mri_comment_field (&stopc
);
3707 abs_section_offset
= get_absolute_expression ();
3708 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3709 /* The ELF backend needs to know that we are changing sections, so
3710 that .previous works correctly. */
3712 obj_elf_section_change_hook ();
3714 subseg_set (absolute_section
, 0);
3715 demand_empty_rest_of_line ();
3717 mri_comment_end (stop
, stopc
);
3721 s_text (int ignore ATTRIBUTE_UNUSED
)
3725 temp
= get_absolute_expression ();
3726 subseg_set (text_section
, (subsegT
) temp
);
3727 demand_empty_rest_of_line ();
3730 /* .weakref x, y sets x as an alias to y that, as long as y is not
3731 referenced directly, will cause y to become a weak symbol. */
3733 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3740 if ((name
= read_symbol_name ()) == NULL
)
3743 symbolP
= symbol_find_or_make (name
);
3745 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3747 if (!S_IS_VOLATILE (symbolP
))
3749 as_bad (_("symbol `%s' is already defined"), name
);
3752 symbolP
= symbol_clone (symbolP
, 1);
3753 S_CLEAR_VOLATILE (symbolP
);
3758 if (*input_line_pointer
!= ',')
3760 as_bad (_("expected comma after \"%s\""), name
);
3764 input_line_pointer
++;
3769 if ((name
= read_symbol_name ()) == NULL
)
3772 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3773 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3775 symbolP2
= symbol_find_or_make (name
);
3776 S_SET_WEAKREFD (symbolP2
);
3780 symbolS
*symp
= symbolP2
;
3782 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3784 expressionS
*expP
= symbol_get_value_expression (symp
);
3786 gas_assert (expP
->X_op
== O_symbol
3787 && expP
->X_add_number
== 0);
3788 symp
= expP
->X_add_symbol
;
3790 if (symp
== symbolP
)
3794 loop
= concat (S_GET_NAME (symbolP
),
3795 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3798 while (symp
!= symbolP
)
3800 char *old_loop
= loop
;
3802 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3803 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3804 (const char *) NULL
);
3808 as_bad (_("%s: would close weakref loop: %s"),
3809 S_GET_NAME (symbolP
), loop
);
3813 ignore_rest_of_line ();
3817 /* Short-circuiting instead of just checking here might speed
3818 things up a tiny little bit, but loop error messages would
3819 miss intermediate links. */
3820 /* symbolP2 = symp; */
3823 memset (&exp
, 0, sizeof (exp
));
3824 exp
.X_op
= O_symbol
;
3825 exp
.X_add_symbol
= symbolP2
;
3827 S_SET_SEGMENT (symbolP
, undefined_section
);
3828 symbol_set_value_expression (symbolP
, &exp
);
3829 symbol_set_frag (symbolP
, &zero_address_frag
);
3830 S_SET_WEAKREFR (symbolP
);
3832 demand_empty_rest_of_line ();
3837 ignore_rest_of_line ();
3843 /* Verify that we are at the end of a line. If not, issue an error and
3844 skip to EOL. This function may leave input_line_pointer one past
3845 buffer_limit, so should not be called from places that may
3846 dereference input_line_pointer unconditionally. Note that when the
3847 gas parser is switched to handling a string (where buffer_limit
3848 should be the size of the string excluding the NUL terminator) this
3849 will be one past the NUL; is_end_of_line(0) returns true. */
3852 demand_empty_rest_of_line (void)
3855 if (input_line_pointer
> buffer_limit
)
3857 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3858 input_line_pointer
++;
3861 if (ISPRINT (*input_line_pointer
))
3862 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3863 *input_line_pointer
);
3865 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3866 *input_line_pointer
);
3867 ignore_rest_of_line ();
3869 /* Return pointing just after end-of-line. */
3872 /* Silently advance to the end of line. Use this after already having
3873 issued an error about something bad. Like demand_empty_rest_of_line,
3874 this function may leave input_line_pointer one after buffer_limit;
3875 Don't call it from within expression parsing code in an attempt to
3876 silence further errors. */
3879 ignore_rest_of_line (void)
3881 while (input_line_pointer
<= buffer_limit
)
3882 if (is_end_of_line
[(unsigned char) *input_line_pointer
++])
3884 /* Return pointing just after end-of-line. */
3887 /* Sets frag for given symbol to zero_address_frag, except when the
3888 symbol frag is already set to a dummy listing frag. */
3891 set_zero_frag (symbolS
*symbolP
)
3893 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3894 symbol_set_frag (symbolP
, &zero_address_frag
);
3897 /* In: Pointer to a symbol.
3898 Input_line_pointer->expression.
3900 Out: Input_line_pointer->just after any whitespace after expression.
3901 Tried to set symbol to value of expression.
3902 Will change symbols type, value, and frag; */
3905 pseudo_set (symbolS
*symbolP
)
3910 know (symbolP
); /* NULL pointer is logic error. */
3912 if (!S_IS_FORWARD_REF (symbolP
))
3913 (void) expression (&exp
);
3915 (void) deferred_expression (&exp
);
3917 if (exp
.X_op
== O_illegal
)
3918 as_bad (_("illegal expression"));
3919 else if (exp
.X_op
== O_absent
)
3920 as_bad (_("missing expression"));
3921 else if (exp
.X_op
== O_big
)
3923 if (exp
.X_add_number
> 0)
3924 as_bad (_("bignum invalid"));
3926 as_bad (_("floating point number invalid"));
3928 else if (exp
.X_op
== O_subtract
3929 && !S_IS_FORWARD_REF (symbolP
)
3930 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3931 && (symbol_get_frag (exp
.X_add_symbol
)
3932 == symbol_get_frag (exp
.X_op_symbol
)))
3934 exp
.X_op
= O_constant
;
3935 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3936 - S_GET_VALUE (exp
.X_op_symbol
));
3939 if (symbol_section_p (symbolP
))
3941 as_bad ("attempt to set value of section symbol");
3950 exp
.X_add_number
= 0;
3953 S_SET_SEGMENT (symbolP
, absolute_section
);
3954 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3955 set_zero_frag (symbolP
);
3959 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3960 if (S_IS_EXTERNAL (symbolP
))
3962 as_bad ("can't equate global symbol `%s' with register name",
3963 S_GET_NAME (symbolP
));
3967 symbol_set_value_expression (symbolP
, &exp
);
3968 S_SET_SEGMENT (symbolP
, reg_section
);
3969 set_zero_frag (symbolP
);
3973 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3974 /* For x=undef+const, create an expression symbol.
3975 For x=x+const, just update x except when x is an undefined symbol
3976 For x=defined+const, evaluate x. */
3977 if (symbolP
== exp
.X_add_symbol
3978 && (seg
!= undefined_section
3979 || !symbol_constant_p (symbolP
)))
3981 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3984 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3986 symbolS
*s
= exp
.X_add_symbol
;
3988 if (S_IS_COMMON (s
))
3989 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3990 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3992 S_SET_SEGMENT (symbolP
, seg
);
3993 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3994 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3995 copy_symbol_attributes (symbolP
, s
);
3998 S_SET_SEGMENT (symbolP
, undefined_section
);
3999 symbol_set_value_expression (symbolP
, &exp
);
4000 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
4001 set_zero_frag (symbolP
);
4005 /* The value is some complex expression. */
4006 S_SET_SEGMENT (symbolP
, expr_section
);
4007 symbol_set_value_expression (symbolP
, &exp
);
4008 set_zero_frag (symbolP
);
4015 CONStruct more frag of .bytes, or .words etc.
4016 Should need_pass_2 be 1 then emit no frag(s).
4017 This understands EXPRESSIONS.
4021 This has a split personality. We use expression() to read the
4022 value. We can detect if the value won't fit in a byte or word.
4023 But we can't detect if expression() discarded significant digits
4024 in the case of a long. Not worth the crocks required to fix it. */
4026 /* Select a parser for cons expressions. */
4028 /* Some targets need to parse the expression in various fancy ways.
4029 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
4030 (for example, the HPPA does this). Otherwise, you can define
4031 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
4032 are defined, which is the normal case, then only simple expressions
4037 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
4040 #ifndef TC_PARSE_CONS_EXPRESSION
4041 #ifdef REPEAT_CONS_EXPRESSIONS
4042 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4043 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4045 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4048 /* If we haven't gotten one yet, just call expression. */
4049 #ifndef TC_PARSE_CONS_EXPRESSION
4050 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4051 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4056 do_parse_cons_expression (expressionS
*exp
,
4057 int nbytes ATTRIBUTE_UNUSED
)
4059 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4063 /* Worker to do .byte etc statements.
4064 Clobbers input_line_pointer and checks end-of-line. */
4067 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4075 #ifdef md_flush_pending_output
4076 md_flush_pending_output ();
4080 stop
= mri_comment_field (&stopc
);
4082 if (is_it_end_of_statement ())
4084 demand_empty_rest_of_line ();
4086 mri_comment_end (stop
, stopc
);
4091 nbytes
= TC_ADDRESS_BYTES ();
4093 #ifdef md_cons_align
4094 md_cons_align (nbytes
);
4100 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4101 #ifdef TC_CONS_FIX_CHECK
4102 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4104 if (*cur_fix
!= NULL
)
4105 cur_fix
= &(*cur_fix
)->fx_next
;
4110 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4115 if (*input_line_pointer
== '"')
4117 as_bad (_("unexpected `\"' in expression"));
4118 ignore_rest_of_line ();
4122 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4127 if (exp
.X_op
== O_symbol
)
4128 exp
.X_op
= O_symbol_rva
;
4130 as_fatal (_("rva without symbol"));
4132 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4133 #ifdef TC_CONS_FIX_CHECK
4134 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4138 while (*input_line_pointer
++ == ',');
4140 /* In MRI mode, after an odd number of bytes, we must align to an
4141 even word boundary, unless the next instruction is a dc.b, ds.b
4143 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4144 mri_pending_align
= 1;
4146 input_line_pointer
--; /* Put terminator back into stream. */
4148 demand_empty_rest_of_line ();
4151 mri_comment_end (stop
, stopc
);
4157 cons_worker (size
, 0);
4163 cons_worker (size
, 1);
4166 /* .reloc offset, reloc_name, symbol+addend. */
4169 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4176 struct reloc_list
*reloc
;
4177 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4178 static struct _bfd_rel bfd_relocs
[] =
4180 { "NONE", BFD_RELOC_NONE
},
4181 { "8", BFD_RELOC_8
},
4182 { "16", BFD_RELOC_16
},
4183 { "32", BFD_RELOC_32
},
4184 { "64", BFD_RELOC_64
}
4187 reloc
= XNEW (struct reloc_list
);
4190 stop
= mri_comment_field (&stopc
);
4199 as_bad (_("missing or bad offset expression"));
4202 exp
.X_add_symbol
= section_symbol (now_seg
);
4203 /* Mark the section symbol used in relocation so that it will be
4204 included in the symbol table. */
4205 symbol_mark_used_in_reloc (exp
.X_add_symbol
);
4206 exp
.X_op
= O_symbol
;
4209 if (exp
.X_add_number
== 0)
4211 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4216 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4221 if (*input_line_pointer
!= ',')
4223 as_bad (_("missing reloc type"));
4227 ++input_line_pointer
;
4229 c
= get_symbol_name (& r_name
);
4230 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4234 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4235 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4237 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4238 bfd_relocs
[i
].code
);
4243 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4244 *input_line_pointer
= c
;
4245 if (reloc
->u
.a
.howto
== NULL
)
4247 as_bad (_("unrecognized reloc type"));
4251 exp
.X_op
= O_absent
;
4252 SKIP_WHITESPACE_AFTER_NAME ();
4253 if (*input_line_pointer
== ',')
4255 ++input_line_pointer
;
4263 as_bad (_("bad reloc expression"));
4265 ignore_rest_of_line ();
4268 mri_comment_end (stop
, stopc
);
4271 reloc
->u
.a
.sym
= NULL
;
4272 reloc
->u
.a
.addend
= 0;
4275 reloc
->u
.a
.sym
= NULL
;
4276 reloc
->u
.a
.addend
= exp
.X_add_number
;
4279 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4280 reloc
->u
.a
.addend
= exp
.X_add_number
;
4283 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4284 reloc
->u
.a
.addend
= 0;
4288 reloc
->file
= as_where (&reloc
->line
);
4289 reloc
->next
= reloc_list
;
4292 demand_empty_rest_of_line ();
4294 mri_comment_end (stop
, stopc
);
4297 /* Put the contents of expression EXP into the object file using
4298 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4301 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4303 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4307 emit_expr_with_reloc (expressionS
*exp
,
4308 unsigned int nbytes
,
4309 TC_PARSE_CONS_RETURN_TYPE reloc
)
4313 valueT extra_digit
= 0;
4315 /* Don't do anything if we are going to make another pass. */
4320 dot_value
= frag_now_fix ();
4321 dot_frag
= frag_now
;
4325 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4326 appear as a four byte positive constant in the .line section,
4327 followed by a 2 byte 0xffff. Look for that case here. */
4329 static int dwarf_line
= -1;
4331 if (strcmp (segment_name (now_seg
), ".line") != 0)
4333 else if (dwarf_line
>= 0
4335 && exp
->X_op
== O_constant
4336 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4337 listing_source_line ((unsigned int) dwarf_line
);
4338 else if (nbytes
== 4
4339 && exp
->X_op
== O_constant
4340 && exp
->X_add_number
>= 0)
4341 dwarf_line
= exp
->X_add_number
;
4346 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4347 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4348 AT_sibling (0x12) followed by a four byte address of the sibling
4349 followed by a 2 byte AT_name (0x38) followed by the name of the
4350 file. We look for that case here. */
4352 static int dwarf_file
= 0;
4354 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4356 else if (dwarf_file
== 0
4358 && exp
->X_op
== O_constant
4359 && exp
->X_add_number
== 0x11)
4361 else if (dwarf_file
== 1
4363 && exp
->X_op
== O_constant
4364 && exp
->X_add_number
== 0x12)
4366 else if (dwarf_file
== 2
4369 else if (dwarf_file
== 3
4371 && exp
->X_op
== O_constant
4372 && exp
->X_add_number
== 0x38)
4377 /* The variable dwarf_file_string tells stringer that the string
4378 may be the name of the source file. */
4379 if (dwarf_file
== 4)
4380 dwarf_file_string
= 1;
4382 dwarf_file_string
= 0;
4387 if (check_eh_frame (exp
, &nbytes
))
4392 /* Handle a negative bignum. */
4394 && exp
->X_add_number
== 0
4395 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4396 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4399 unsigned long carry
;
4401 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4403 /* Negate the bignum: one's complement each digit and add 1. */
4405 for (i
= 0; i
< exp
->X_add_number
; i
++)
4409 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4412 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4413 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4416 /* We can ignore any carry out, because it will be handled by
4417 extra_digit if it is needed. */
4419 extra_digit
= (valueT
) -1;
4423 if (op
== O_absent
|| op
== O_illegal
)
4425 as_warn (_("zero assumed for missing expression"));
4426 exp
->X_add_number
= 0;
4429 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4431 as_bad (_("floating point number invalid"));
4432 exp
->X_add_number
= 0;
4435 else if (op
== O_register
)
4437 as_warn (_("register value used as expression"));
4441 /* Allow `.word 0' in the absolute section. */
4442 if (now_seg
== absolute_section
)
4444 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4445 as_bad (_("attempt to store value in absolute section"));
4446 abs_section_offset
+= nbytes
;
4450 /* Allow `.word 0' in BSS style sections. */
4451 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4452 as_bad (_("attempt to store non-zero value in section `%s'"),
4453 segment_name (now_seg
));
4455 p
= frag_more ((int) nbytes
);
4457 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4459 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4463 #ifndef WORKING_DOT_WORD
4464 /* If we have the difference of two symbols in a word, save it on
4465 the broken_words list. See the code in write.c. */
4466 if (op
== O_subtract
&& nbytes
== 2)
4468 struct broken_word
*x
;
4470 x
= XNEW (struct broken_word
);
4471 x
->next_broken_word
= broken_words
;
4474 x
->subseg
= now_subseg
;
4476 x
->word_goes_here
= p
;
4478 x
->add
= exp
->X_add_symbol
;
4479 x
->sub
= exp
->X_op_symbol
;
4480 x
->addnum
= exp
->X_add_number
;
4488 /* If we have an integer, but the number of bytes is too large to
4489 pass to md_number_to_chars, handle it as a bignum. */
4490 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4492 extra_digit
= exp
->X_unsigned
? 0 : -1;
4493 convert_to_bignum (exp
, !exp
->X_unsigned
);
4497 if (op
== O_constant
)
4504 /* JF << of >= number of bits in the object is undefined. In
4505 particular SPARC (Sun 4) has problems. */
4506 if (nbytes
>= sizeof (valueT
))
4508 know (nbytes
== sizeof (valueT
));
4513 /* Don't store these bits. */
4514 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4517 unmask
= ~mask
; /* Do store these bits. */
4520 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4521 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4524 get
= exp
->X_add_number
;
4526 if ((get
& mask
) != 0 && (-get
& mask
) != 0)
4528 /* Leading bits contain both 0s & 1s. */
4529 as_warn (_("value 0x%" PRIx64
" truncated to 0x%" PRIx64
),
4530 (uint64_t) get
, (uint64_t) use
);
4532 /* Put bytes in right order. */
4533 md_number_to_chars (p
, use
, (int) nbytes
);
4535 else if (op
== O_big
)
4538 LITTLENUM_TYPE
*nums
;
4540 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4543 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4547 LITTLENUM_TYPE sign
= 0;
4548 if ((generic_bignum
[--i
]
4549 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4550 sign
= ~(LITTLENUM_TYPE
) 0;
4552 while (++i
< exp
->X_add_number
)
4553 if (generic_bignum
[i
] != sign
)
4556 else if (nbytes
== 1)
4558 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4559 Check that bits 8.. of generic_bignum[0] match bit 7
4560 and that they match all of generic_bignum[1..exp->X_add_number]. */
4561 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4562 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4564 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4566 while (++i
< exp
->X_add_number
)
4567 if (generic_bignum
[i
] != sign
)
4572 if (i
< exp
->X_add_number
)
4573 as_warn (ngettext ("bignum truncated to %d byte",
4574 "bignum truncated to %d bytes",
4582 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4585 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4587 if (target_big_endian
)
4589 while (nbytes
> size
)
4591 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4592 nbytes
-= CHARS_PER_LITTLENUM
;
4593 p
+= CHARS_PER_LITTLENUM
;
4596 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4597 while (size
>= CHARS_PER_LITTLENUM
)
4600 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4601 size
-= CHARS_PER_LITTLENUM
;
4602 p
+= CHARS_PER_LITTLENUM
;
4607 nums
= generic_bignum
;
4608 while (size
>= CHARS_PER_LITTLENUM
)
4610 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4612 size
-= CHARS_PER_LITTLENUM
;
4613 p
+= CHARS_PER_LITTLENUM
;
4614 nbytes
-= CHARS_PER_LITTLENUM
;
4617 while (nbytes
>= CHARS_PER_LITTLENUM
)
4619 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4620 nbytes
-= CHARS_PER_LITTLENUM
;
4621 p
+= CHARS_PER_LITTLENUM
;
4626 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4630 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4631 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4634 unsigned int size
= nbytes
;
4636 memset (p
, 0, size
);
4638 /* Generate a fixS to record the symbol value. */
4640 #ifdef TC_CONS_FIX_NEW
4641 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4643 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4645 reloc_howto_type
*reloc_howto
;
4647 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4648 size
= bfd_get_reloc_size (reloc_howto
);
4652 as_bad (ngettext ("%s relocations do not fit in %u byte",
4653 "%s relocations do not fit in %u bytes",
4655 reloc_howto
->name
, nbytes
);
4658 else if (target_big_endian
)
4659 offset
= nbytes
- size
;
4680 as_bad (_("unsupported BFD relocation size %u"), size
);
4683 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4688 /* Handle an MRI style string expression. */
4692 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4694 if (*input_line_pointer
!= '\''
4695 && (input_line_pointer
[1] != '\''
4696 || (*input_line_pointer
!= 'A'
4697 && *input_line_pointer
!= 'E')))
4698 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4702 unsigned int result
= 0;
4704 /* An MRI style string. Cut into as many bytes as will fit into
4705 a nbyte chunk, left justify if necessary, and separate with
4706 commas so we can try again later. */
4707 if (*input_line_pointer
== 'A')
4708 ++input_line_pointer
;
4709 else if (*input_line_pointer
== 'E')
4711 as_bad (_("EBCDIC constants are not supported"));
4712 ++input_line_pointer
;
4715 input_line_pointer
++;
4716 for (scan
= 0; scan
< nbytes
; scan
++)
4718 if (*input_line_pointer
== '\'')
4720 if (input_line_pointer
[1] == '\'')
4722 input_line_pointer
++;
4727 result
= (result
<< 8) | (*input_line_pointer
++);
4731 while (scan
< nbytes
)
4737 /* Create correct expression. */
4738 exp
->X_op
= O_constant
;
4739 exp
->X_add_number
= result
;
4741 /* Fake it so that we can read the next char too. */
4742 if (input_line_pointer
[0] != '\'' ||
4743 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4745 input_line_pointer
-= 2;
4746 input_line_pointer
[0] = ',';
4747 input_line_pointer
[1] = '\'';
4750 input_line_pointer
++;
4753 #endif /* TC_M68K */
4755 #ifdef REPEAT_CONS_EXPRESSIONS
4757 /* Parse a repeat expression for cons. This is used by the MIPS
4758 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4759 object file COUNT times.
4761 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4764 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4771 if (*input_line_pointer
!= ':')
4773 /* No repeat count. */
4777 ++input_line_pointer
;
4778 expression (&count
);
4779 if (count
.X_op
!= O_constant
4780 || count
.X_add_number
<= 0)
4782 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4786 /* The cons function is going to output this expression once. So we
4787 output it count - 1 times. */
4788 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4789 emit_expr (exp
, nbytes
);
4792 #endif /* REPEAT_CONS_EXPRESSIONS */
4794 /* Parse a floating point number represented as a hex constant. This
4795 permits users to specify the exact bits they want in the floating
4799 hex_float (int float_type
, char *bytes
)
4801 int pad
, length
= float_length (float_type
, &pad
);
4807 /* It would be nice if we could go through expression to parse the
4808 hex constant, but if we get a bignum it's a pain to sort it into
4809 the buffer correctly. */
4811 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4815 /* The MRI assembler accepts arbitrary underscores strewn about
4816 through the hex constant, so we ignore them as well. */
4817 if (*input_line_pointer
== '_')
4819 ++input_line_pointer
;
4825 as_warn (_("floating point constant too large"));
4828 d
= hex_value (*input_line_pointer
) << 4;
4829 ++input_line_pointer
;
4830 while (*input_line_pointer
== '_')
4831 ++input_line_pointer
;
4832 if (hex_p (*input_line_pointer
))
4834 d
+= hex_value (*input_line_pointer
);
4835 ++input_line_pointer
;
4837 if (target_big_endian
)
4840 bytes
[length
- i
- 1] = d
;
4846 if (target_big_endian
)
4847 memset (bytes
+ i
, 0, length
- i
);
4849 memset (bytes
, 0, length
- i
);
4852 memset (bytes
+ length
, 0, pad
);
4854 return length
+ pad
;
4859 CONStruct some more frag chars of .floats .ffloats etc.
4860 Makes 0 or more new frags.
4861 If need_pass_2 == 1, no frags are emitted.
4862 This understands only floating literals, not expressions. Sorry.
4864 A floating constant is defined by atof_generic(), except it is preceded
4865 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4866 reading, I decided to be incompatible. This always tries to give you
4867 rounded bits to the precision of the pseudo-op. Former AS did premature
4868 truncation, restored noisy bits instead of trailing 0s AND gave you
4869 a choice of 2 flavours of noise according to which of 2 floating-point
4870 scanners you directed AS to use.
4872 In: input_line_pointer->whitespace before, or '0' of flonum. */
4875 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4876 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4879 int length
; /* Number of chars in an object. */
4880 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4882 if (is_it_end_of_statement ())
4884 demand_empty_rest_of_line ();
4888 if (now_seg
== absolute_section
)
4890 as_bad (_("attempt to store float in absolute section"));
4891 ignore_rest_of_line ();
4897 as_bad (_("attempt to store float in section `%s'"),
4898 segment_name (now_seg
));
4899 ignore_rest_of_line ();
4903 #ifdef md_flush_pending_output
4904 md_flush_pending_output ();
4907 #ifdef md_cons_align
4913 length
= parse_one_float (float_type
, temp
);
4923 #ifdef REPEAT_CONS_EXPRESSIONS
4924 if (*input_line_pointer
== ':')
4926 expressionS count_exp
;
4928 ++input_line_pointer
;
4929 expression (&count_exp
);
4931 if (count_exp
.X_op
!= O_constant
4932 || count_exp
.X_add_number
<= 0)
4933 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4935 count
= count_exp
.X_add_number
;
4939 while (--count
>= 0)
4941 p
= frag_more (length
);
4942 memcpy (p
, temp
, (unsigned int) length
);
4947 while (*input_line_pointer
++ == ',');
4949 /* Put terminator back into stream. */
4950 --input_line_pointer
;
4951 demand_empty_rest_of_line ();
4956 Note - we are using the DWARF standard's definition of LEB128 encoding
4957 where each 7-bit value is a stored in a byte, *not* an octet. This
4958 means that on targets where a byte contains multiple octets there is
4959 a *huge waste of space*. (This also means that we do not have to
4960 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4963 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4964 we would then have to consider whether multiple, successive LEB128
4965 values should be packed into the bytes without padding (bad idea) or
4966 whether each LEB128 number is padded out to a whole number of bytes.
4967 Plus you have to decide on the endianness of packing octets into a
4970 /* Return the size of a LEB128 value in bytes. */
4972 static inline unsigned int
4973 sizeof_sleb128 (offsetT value
)
4980 byte
= (value
& 0x7f);
4981 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4982 Fortunately, we can structure things so that the extra work reduces
4983 to a noop on systems that do things "properly". */
4984 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4987 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4988 || ((value
== -1) && ((byte
& 0x40) != 0))));
4993 static inline unsigned int
4994 sizeof_uleb128 (valueT value
)
5009 sizeof_leb128 (valueT value
, int sign
)
5012 return sizeof_sleb128 ((offsetT
) value
);
5014 return sizeof_uleb128 (value
);
5017 /* Output a LEB128 value. Returns the number of bytes used. */
5019 static inline unsigned int
5020 output_sleb128 (char *p
, offsetT value
)
5027 unsigned byte
= (value
& 0x7f);
5029 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5030 Fortunately, we can structure things so that the extra work reduces
5031 to a noop on systems that do things "properly". */
5032 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5034 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5035 || ((value
== -1) && ((byte
& 0x40) != 0))));
5046 static inline unsigned int
5047 output_uleb128 (char *p
, valueT value
)
5053 unsigned byte
= (value
& 0x7f);
5057 /* More bytes to follow. */
5068 output_leb128 (char *p
, valueT value
, int sign
)
5071 return output_sleb128 (p
, (offsetT
) value
);
5073 return output_uleb128 (p
, value
);
5076 /* Do the same for bignums. We combine sizeof with output here in that
5077 we don't output for NULL values of P. It isn't really as critical as
5078 for "normal" values that this be streamlined. Returns the number of
5081 static inline unsigned int
5082 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5089 /* Strip leading sign extensions off the bignum. */
5091 && bignum
[size
- 1] == LITTLENUM_MASK
5092 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5097 /* OR in the next part of the littlenum. */
5098 val
|= (*bignum
<< loaded
);
5099 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5103 /* Add bytes until there are less than 7 bits left in VAL
5104 or until every non-sign bit has been written. */
5111 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5118 while ((byte
& 0x80) != 0 && loaded
>= 7);
5122 /* Mop up any left-over bits (of which there will be less than 7). */
5123 if ((byte
& 0x80) != 0)
5125 /* Sign-extend VAL. */
5126 if (val
& (1 << (loaded
- 1)))
5127 val
|= ~0U << loaded
;
5136 static inline unsigned int
5137 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5144 /* Strip leading zeros off the bignum. */
5145 /* XXX: Is this needed? */
5146 while (size
> 0 && bignum
[size
- 1] == 0)
5151 if (loaded
< 7 && size
> 0)
5153 val
|= (*bignum
<< loaded
);
5154 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5163 if (size
> 0 || val
)
5170 while (byte
& 0x80);
5176 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5179 return output_big_sleb128 (p
, bignum
, size
);
5181 return output_big_uleb128 (p
, bignum
, size
);
5184 /* Generate the appropriate fragments for a given expression to emit a
5185 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5188 emit_leb128_expr (expressionS
*exp
, int sign
)
5190 operatorT op
= exp
->X_op
;
5191 unsigned int nbytes
;
5193 if (op
== O_absent
|| op
== O_illegal
)
5195 as_warn (_("zero assumed for missing expression"));
5196 exp
->X_add_number
= 0;
5199 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5201 as_bad (_("floating point number invalid"));
5202 exp
->X_add_number
= 0;
5205 else if (op
== O_register
)
5207 as_warn (_("register value used as expression"));
5210 else if (op
== O_constant
5212 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5214 /* We're outputting a signed leb128 and the sign of X_add_number
5215 doesn't reflect the sign of the original value. Convert EXP
5216 to a correctly-extended bignum instead. */
5217 convert_to_bignum (exp
, exp
->X_extrabit
);
5221 if (now_seg
== absolute_section
)
5223 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5224 as_bad (_("attempt to store value in absolute section"));
5225 abs_section_offset
++;
5229 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5230 as_bad (_("attempt to store non-zero value in section `%s'"),
5231 segment_name (now_seg
));
5233 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5234 a signal that this is leb128 data. It shouldn't optimize this away. */
5235 nbytes
= (unsigned int) -1;
5236 if (check_eh_frame (exp
, &nbytes
))
5239 /* Let the backend know that subsequent data may be byte aligned. */
5240 #ifdef md_cons_align
5244 if (op
== O_constant
)
5246 /* If we've got a constant, emit the thing directly right now. */
5248 valueT value
= exp
->X_add_number
;
5252 size
= sizeof_leb128 (value
, sign
);
5253 p
= frag_more (size
);
5254 if (output_leb128 (p
, value
, sign
) > size
)
5257 else if (op
== O_big
)
5259 /* O_big is a different sort of constant. */
5260 int nbr_digits
= exp
->X_add_number
;
5264 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5265 a signed number. Unary operators like - or ~ always extend the
5266 bignum to its largest size. */
5268 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5269 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5270 generic_bignum
[nbr_digits
++] = 0;
5272 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5273 p
= frag_more (size
);
5274 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5279 /* Otherwise, we have to create a variable sized fragment and
5280 resolve things later. */
5282 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5283 make_expr_symbol (exp
), 0, (char *) NULL
);
5287 /* Parse the .sleb128 and .uleb128 pseudos. */
5294 #ifdef md_flush_pending_output
5295 md_flush_pending_output ();
5301 emit_leb128_expr (&exp
, sign
);
5303 while (*input_line_pointer
++ == ',');
5305 input_line_pointer
--;
5306 demand_empty_rest_of_line ();
5310 stringer_append_char (int c
, int bitsize
)
5313 as_bad (_("attempt to store non-empty string in section `%s'"),
5314 segment_name (now_seg
));
5316 if (!target_big_endian
)
5317 FRAG_APPEND_1_CHAR (c
);
5322 FRAG_APPEND_1_CHAR (0);
5323 FRAG_APPEND_1_CHAR (0);
5324 FRAG_APPEND_1_CHAR (0);
5325 FRAG_APPEND_1_CHAR (0);
5328 FRAG_APPEND_1_CHAR (0);
5329 FRAG_APPEND_1_CHAR (0);
5332 FRAG_APPEND_1_CHAR (0);
5337 /* Called with invalid bitsize argument. */
5341 if (target_big_endian
)
5342 FRAG_APPEND_1_CHAR (c
);
5345 /* Worker to do .ascii etc statements.
5346 Reads 0 or more ',' separated, double-quoted strings.
5347 Caller should have checked need_pass_2 is FALSE because we don't
5349 Checks for end-of-line.
5350 BITS_APPENDZERO says how many bits are in a target char.
5351 The bottom bit is set if a NUL char should be appended to the strings. */
5354 stringer (int bits_appendzero
)
5356 const int bitsize
= bits_appendzero
& ~7;
5357 const int append_zero
= bits_appendzero
& 1;
5359 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5363 #ifdef md_flush_pending_output
5364 md_flush_pending_output ();
5367 #ifdef md_cons_align
5371 /* If we have been switched into the abs_section then we
5372 will not have an obstack onto which we can hang strings. */
5373 if (now_seg
== absolute_section
)
5375 as_bad (_("strings must be placed into a section"));
5376 ignore_rest_of_line ();
5380 /* The following awkward logic is to parse ZERO or more strings,
5381 comma separated. Recall a string expression includes spaces
5382 before the opening '\"' and spaces after the closing '\"'.
5383 We fake a leading ',' if there is (supposed to be)
5384 a 1st, expression. We keep demanding expressions for each ','. */
5385 if (is_it_end_of_statement ())
5387 c
= 0; /* Skip loop. */
5388 ++input_line_pointer
; /* Compensate for end of loop. */
5392 c
= ','; /* Do loop. */
5395 while (c
== ',' || c
== '<' || c
== '"')
5398 switch (*input_line_pointer
)
5401 ++input_line_pointer
; /*->1st char of string. */
5402 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5403 start
= input_line_pointer
;
5406 while (is_a_char (c
= next_char_of_string ()))
5407 stringer_append_char (c
, bitsize
);
5409 /* Treat "a" "b" as "ab". Even if we are appending zeros. */
5410 SKIP_ALL_WHITESPACE ();
5411 if (*input_line_pointer
== '"')
5415 stringer_append_char (0, bitsize
);
5417 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5418 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5419 will emit .string with a filename in the .debug section
5420 after a sequence of constants. See the comment in
5421 emit_expr for the sequence. emit_expr will set
5422 dwarf_file_string to non-zero if this string might be a
5423 source file name. */
5424 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5425 dwarf_file_string
= 0;
5426 else if (dwarf_file_string
)
5428 c
= input_line_pointer
[-1];
5429 input_line_pointer
[-1] = '\0';
5430 listing_source_file (start
);
5431 input_line_pointer
[-1] = c
;
5437 input_line_pointer
++;
5438 c
= get_single_number ();
5439 stringer_append_char (c
, bitsize
);
5440 if (*input_line_pointer
!= '>')
5442 as_bad (_("expected <nn>"));
5443 ignore_rest_of_line ();
5446 input_line_pointer
++;
5449 input_line_pointer
++;
5453 c
= *input_line_pointer
;
5456 demand_empty_rest_of_line ();
5459 /* FIXME-SOMEDAY: I had trouble here on characters with the
5460 high bits set. We'll probably also have trouble with
5461 multibyte chars, wide chars, etc. Also be careful about
5462 returning values bigger than 1 byte. xoxorich. */
5465 next_char_of_string (void)
5469 c
= *input_line_pointer
++ & CHAR_MASK
;
5473 /* PR 20902: Do not advance past the end of the buffer. */
5474 -- input_line_pointer
;
5483 as_warn (_("unterminated string; newline inserted"));
5484 bump_line_counters ();
5488 if (!TC_STRING_ESCAPES
)
5490 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5518 break; /* As itself. */
5534 for (i
= 0, number
= 0;
5535 ISDIGIT (c
) && i
< 3;
5536 c
= *input_line_pointer
++, i
++)
5538 number
= number
* 8 + c
- '0';
5541 c
= number
& CHAR_MASK
;
5543 --input_line_pointer
;
5552 c
= *input_line_pointer
++;
5553 while (ISXDIGIT (c
))
5556 number
= number
* 16 + c
- '0';
5557 else if (ISUPPER (c
))
5558 number
= number
* 16 + c
- 'A' + 10;
5560 number
= number
* 16 + c
- 'a' + 10;
5561 c
= *input_line_pointer
++;
5563 c
= number
& CHAR_MASK
;
5564 --input_line_pointer
;
5569 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5570 as_warn (_("unterminated string; newline inserted"));
5572 bump_line_counters ();
5576 /* Do not advance past the end of the buffer. */
5577 -- input_line_pointer
;
5583 #ifdef ONLY_STANDARD_ESCAPES
5584 as_bad (_("bad escaped character in string"));
5586 #endif /* ONLY_STANDARD_ESCAPES */
5599 get_segmented_expression (expressionS
*expP
)
5603 retval
= expression (expP
);
5604 if (expP
->X_op
== O_illegal
5605 || expP
->X_op
== O_absent
5606 || expP
->X_op
== O_big
)
5608 as_bad (_("expected address expression"));
5609 expP
->X_op
= O_constant
;
5610 expP
->X_add_number
= 0;
5611 retval
= absolute_section
;
5617 get_known_segmented_expression (expressionS
*expP
)
5619 segT retval
= get_segmented_expression (expP
);
5621 if (retval
== undefined_section
)
5623 /* There is no easy way to extract the undefined symbol from the
5625 if (expP
->X_add_symbol
!= NULL
5626 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5627 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5628 S_GET_NAME (expP
->X_add_symbol
));
5630 as_warn (_("some symbol undefined; zero assumed"));
5631 retval
= absolute_section
;
5632 expP
->X_op
= O_constant
;
5633 expP
->X_add_number
= 0;
5638 char /* Return terminator. */
5639 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5641 /* FIXME: val_pointer should probably be offsetT *. */
5642 *val_pointer
= (long) get_absolute_expression ();
5643 return (*input_line_pointer
++);
5646 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5647 Give a warning if that happens. */
5650 demand_copy_C_string (int *len_pointer
)
5654 if ((s
= demand_copy_string (len_pointer
)) != 0)
5658 for (len
= *len_pointer
; len
> 0; len
--)
5660 if (s
[len
- 1] == 0)
5664 as_bad (_("this string may not contain \'\\0\'"));
5673 /* Demand string, but return a safe (=private) copy of the string.
5674 Return NULL if we can't read a string here. */
5677 demand_copy_string (int *lenP
)
5685 if (*input_line_pointer
== '\"')
5687 input_line_pointer
++; /* Skip opening quote. */
5689 while (is_a_char (c
= next_char_of_string ()))
5691 obstack_1grow (¬es
, c
);
5694 /* JF this next line is so demand_copy_C_string will return a
5695 null terminated string. */
5696 obstack_1grow (¬es
, '\0');
5697 retval
= (char *) obstack_finish (¬es
);
5701 as_bad (_("missing string"));
5703 ignore_rest_of_line ();
5709 /* In: Input_line_pointer->next character.
5711 Do: Skip input_line_pointer over all whitespace.
5713 Out: 1 if input_line_pointer->end-of-line. */
5716 is_it_end_of_statement (void)
5719 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5723 equals (char *sym_name
, int reassign
)
5728 input_line_pointer
++;
5729 if (*input_line_pointer
== '=')
5730 input_line_pointer
++;
5731 if (reassign
< 0 && *input_line_pointer
== '=')
5732 input_line_pointer
++;
5734 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5735 input_line_pointer
++;
5738 stop
= mri_comment_field (&stopc
);
5740 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5744 demand_empty_rest_of_line ();
5745 mri_comment_end (stop
, stopc
);
5749 /* .incbin -- include a file verbatim at the current location. */
5752 s_incbin (int x ATTRIBUTE_UNUSED
)
5763 #ifdef md_flush_pending_output
5764 md_flush_pending_output ();
5767 #ifdef md_cons_align
5772 filename
= demand_copy_string (& len
);
5773 if (filename
== NULL
)
5778 /* Look for optional skip and count. */
5779 if (* input_line_pointer
== ',')
5781 ++ input_line_pointer
;
5782 skip
= get_absolute_expression ();
5786 if (* input_line_pointer
== ',')
5788 ++ input_line_pointer
;
5790 count
= get_absolute_expression ();
5792 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5798 demand_empty_rest_of_line ();
5800 /* Try opening absolute path first, then try include dirs. */
5801 binfile
= fopen (filename
, FOPEN_RB
);
5802 if (binfile
== NULL
)
5806 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5808 for (i
= 0; i
< include_dir_count
; i
++)
5810 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5812 binfile
= fopen (path
, FOPEN_RB
);
5813 if (binfile
!= NULL
)
5817 if (binfile
== NULL
)
5818 as_bad (_("file not found: %s"), filename
);
5821 path
= xstrdup (filename
);
5826 struct stat filestat
;
5828 if (fstat (fileno (binfile
), &filestat
) != 0
5829 || ! S_ISREG (filestat
.st_mode
)
5830 || S_ISDIR (filestat
.st_mode
))
5832 as_bad (_("unable to include `%s'"), path
);
5836 register_dependency (path
);
5838 /* Compute the length of the file. */
5839 if (fseek (binfile
, 0, SEEK_END
) != 0)
5841 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5844 file_len
= ftell (binfile
);
5846 /* If a count was not specified use the remainder of the file. */
5848 count
= file_len
- skip
;
5850 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5852 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5853 skip
, count
, file_len
);
5857 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5859 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5863 /* Allocate frag space and store file contents in it. */
5864 binfrag
= frag_more (count
);
5866 bytes
= fread (binfrag
, 1, count
, binfile
);
5868 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5869 path
, bytes
, count
);
5872 if (binfile
!= NULL
)
5877 /* .include -- include a file at this point. */
5880 s_include (int arg ATTRIBUTE_UNUSED
)
5889 filename
= demand_copy_string (&i
);
5890 if (filename
== NULL
)
5892 /* demand_copy_string has already printed an error and
5893 called ignore_rest_of_line. */
5901 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5902 && *input_line_pointer
!= ' '
5903 && *input_line_pointer
!= '\t')
5905 obstack_1grow (¬es
, *input_line_pointer
);
5906 ++input_line_pointer
;
5910 obstack_1grow (¬es
, '\0');
5911 filename
= (char *) obstack_finish (¬es
);
5912 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5913 ++input_line_pointer
;
5916 demand_empty_rest_of_line ();
5917 path
= notes_alloc ((size_t) i
+ include_dir_maxlen
+ 5);
5919 for (i
= 0; i
< include_dir_count
; i
++)
5921 strcpy (path
, include_dirs
[i
]);
5923 strcat (path
, filename
);
5924 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5934 register_dependency (path
);
5935 input_scrub_insert_file (path
);
5939 add_include_dir (char *path
)
5943 if (include_dir_count
== 0)
5945 include_dirs
= XNEWVEC (const char *, 2);
5946 include_dirs
[0] = "."; /* Current dir. */
5947 include_dir_count
= 2;
5951 include_dir_count
++;
5952 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5956 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5959 if (i
> include_dir_maxlen
)
5960 include_dir_maxlen
= i
;
5963 /* Output debugging information to denote the source file. */
5966 generate_file_debug (void)
5968 if (debug_type
== DEBUG_STABS
)
5969 stabs_generate_asm_file ();
5972 /* Output line number debugging information for the current source line. */
5975 generate_lineno_debug (void)
5979 case DEBUG_UNSPECIFIED
:
5984 stabs_generate_asm_lineno ();
5987 ecoff_generate_asm_lineno ();
5990 /* ??? We could here indicate to dwarf2dbg.c that something
5991 has changed. However, since there is additional backend
5992 support that is required (calling dwarf2_emit_insn), we
5993 let dwarf2dbg.c call as_where on its own. */
5995 case DEBUG_CODEVIEW
:
5996 codeview_generate_asm_lineno ();
6001 /* Output debugging information to mark a function entry point or end point.
6002 END_P is zero for .func, and non-zero for .endfunc. */
6007 do_s_func (end_p
, NULL
);
6010 /* Subroutine of s_func so targets can choose a different default prefix.
6011 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6014 do_s_func (int end_p
, const char *default_prefix
)
6016 /* Record the current function so that we can issue an error message for
6017 misplaced .func,.endfunc, and also so that .endfunc needs no
6019 static char *current_name
;
6020 static char *current_label
;
6024 if (current_name
== NULL
)
6026 as_bad (_("missing .func"));
6027 ignore_rest_of_line ();
6031 if (debug_type
== DEBUG_STABS
)
6032 stabs_generate_asm_endfunc (current_name
, current_label
);
6034 current_name
= current_label
= NULL
;
6039 char delim1
, delim2
;
6041 if (current_name
!= NULL
)
6043 as_bad (_(".endfunc missing for previous .func"));
6044 ignore_rest_of_line ();
6048 delim1
= get_symbol_name (& name
);
6049 name
= xstrdup (name
);
6050 *input_line_pointer
= delim1
;
6051 SKIP_WHITESPACE_AFTER_NAME ();
6052 if (*input_line_pointer
!= ',')
6056 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6057 as_fatal ("%s", xstrerror (errno
));
6061 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6062 /* Missing entry point, use function's name with the leading
6066 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6067 as_fatal ("%s", xstrerror (errno
));
6075 ++input_line_pointer
;
6077 delim2
= get_symbol_name (& label
);
6078 label
= xstrdup (label
);
6079 restore_line_pointer (delim2
);
6082 if (debug_type
== DEBUG_STABS
)
6083 stabs_generate_asm_func (name
, label
);
6085 current_name
= name
;
6086 current_label
= label
;
6089 demand_empty_rest_of_line ();
6092 #ifdef HANDLE_BUNDLE
6095 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6097 unsigned int align
= get_absolute_expression ();
6099 demand_empty_rest_of_line ();
6101 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6102 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6103 (unsigned int) TC_ALIGN_LIMIT
);
6105 if (bundle_lock_frag
!= NULL
)
6107 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6111 bundle_align_p2
= align
;
6115 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6117 demand_empty_rest_of_line ();
6119 if (bundle_align_p2
== 0)
6121 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6125 if (bundle_lock_depth
== 0)
6127 bundle_lock_frchain
= frchain_now
;
6128 bundle_lock_frag
= start_bundle ();
6130 ++bundle_lock_depth
;
6134 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6138 demand_empty_rest_of_line ();
6140 if (bundle_lock_frag
== NULL
)
6142 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6146 gas_assert (bundle_align_p2
> 0);
6148 gas_assert (bundle_lock_depth
> 0);
6149 if (--bundle_lock_depth
> 0)
6152 size
= pending_bundle_size (bundle_lock_frag
);
6154 if (size
> 1U << bundle_align_p2
)
6155 as_bad (_(".bundle_lock sequence is %u bytes, "
6156 "but bundle size is only %u bytes"),
6157 size
, 1u << bundle_align_p2
);
6159 finish_bundle (bundle_lock_frag
, size
);
6161 bundle_lock_frag
= NULL
;
6162 bundle_lock_frchain
= NULL
;
6165 #endif /* HANDLE_BUNDLE */
6168 s_ignore (int arg ATTRIBUTE_UNUSED
)
6170 ignore_rest_of_line ();
6174 read_print_statistics (FILE *file
)
6176 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6179 /* Inserts the given line into the input stream.
6181 This call avoids macro/conditionals nesting checking, since the contents of
6182 the line are assumed to replace the contents of a line already scanned.
6184 An appropriate use of this function would be substitution of input lines when
6185 called by md_start_line_hook(). The given line is assumed to already be
6186 properly scrubbed. */
6189 input_scrub_insert_line (const char *line
)
6192 size_t len
= strlen (line
);
6193 sb_build (&newline
, len
);
6194 sb_add_buffer (&newline
, line
, len
);
6195 input_scrub_include_sb (&newline
, input_line_pointer
, expanding_none
);
6197 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6200 /* Insert a file into the input stream; the path must resolve to an actual
6201 file; no include path searching or dependency registering is performed. */
6204 input_scrub_insert_file (char *path
)
6206 input_scrub_include_file (path
, input_line_pointer
);
6207 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6210 /* Find the end of a line, considering quotation and escaping of quotes. */
6212 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6213 # define TC_SINGLE_QUOTE_STRINGS 1
6217 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6220 char inquote
= '\0';
6223 while (!is_end_of_line
[(unsigned char) *s
]
6224 || (inquote
&& !ISCNTRL (*s
))
6225 || (inquote
== '\'' && flag_mri
)
6226 #ifdef TC_EOL_IN_INSN
6227 || (insn
&& TC_EOL_IN_INSN (s
))
6229 /* PR 6926: When we are parsing the body of a macro the sequence
6230 \@ is special - it refers to the invocation count. If the @
6231 character happens to be registered as a line-separator character
6232 by the target, then the is_end_of_line[] test above will have
6233 returned true, but we need to ignore the line separating
6234 semantics in this particular case. */
6235 || (in_macro
&& inescape
&& *s
== '@')
6238 if (mri_string
&& *s
== '\'')
6242 else if (*s
== '\\')
6246 #ifdef TC_SINGLE_QUOTE_STRINGS
6247 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6254 as_warn (_("missing closing `%c'"), inquote
);
6255 if (inescape
&& !ignore_input ())
6256 as_warn (_("stray `\\'"));
6261 find_end_of_line (char *s
, int mri_string
)
6263 return _find_end_of_line (s
, mri_string
, 0, 0);
6266 static char *saved_ilp
= NULL
;
6267 static char *saved_limit
;
6269 /* Use BUF as a temporary input pointer for calling other functions in this
6270 file. BUF must be a C string, so that its end can be found by strlen.
6271 Also sets the buffer_limit variable (local to this file) so that buffer
6272 overruns should not occur. Saves the current input line pointer so that
6273 it can be restored by calling restore_ilp().
6275 Does not support recursion. */
6278 temp_ilp (char *buf
)
6280 gas_assert (saved_ilp
== NULL
);
6281 gas_assert (buf
!= NULL
);
6283 saved_ilp
= input_line_pointer
;
6284 saved_limit
= buffer_limit
;
6285 /* Prevent the assert in restore_ilp from triggering if
6286 the input_line_pointer has not yet been initialised. */
6287 if (saved_ilp
== NULL
)
6288 saved_limit
= saved_ilp
= (char *) "";
6290 input_line_pointer
= buf
;
6291 buffer_limit
= buf
+ strlen (buf
);
6292 input_from_string
= true;
6295 /* Restore a saved input line pointer. */
6300 gas_assert (saved_ilp
!= NULL
);
6302 input_line_pointer
= saved_ilp
;
6303 buffer_limit
= saved_limit
;
6304 input_from_string
= false;