1 /* read.c - read a source file -
2 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
43 #ifndef TC_START_LABEL
44 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
47 /* Set by the object-format or the target. */
48 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
49 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
54 else if ((SIZE) >= 4) \
56 else if ((SIZE) >= 2) \
64 char *input_line_pointer
; /*->next char of source file to parse. */
65 bfd_boolean input_from_string
= FALSE
;
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
94 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
103 /* The Delta 68k assembler permits ~ at start of label names. */
107 /* Used by is_... macros. our ctype[]. */
108 char lex_type
[256] = {
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
111 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
113 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
114 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
115 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
128 Out: 1 if this character ends a line.
129 2 if this character is a line separator. */
130 char is_end_of_line
[256] = {
132 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
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, /* */
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 /* */
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string
[128];
157 /* Functions private to this file. */
159 static char *buffer
; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit
; /*->1 + last char in buffer. */
162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
163 in the tc-<CPU>.h file. See the "Porting GAS" section of the
165 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
167 /* Variables for handling include file directory table. */
169 /* Table of pointers to directories to search for .include's. */
170 const char **include_dirs
;
172 /* How many are in the table. */
173 int include_dir_count
;
175 /* Length of longest in table. */
176 int include_dir_maxlen
= 1;
178 #ifndef WORKING_DOT_WORD
179 struct broken_word
*broken_words
;
180 int new_broken_words
;
183 /* The current offset into the absolute section. We don't try to
184 build frags in the absolute section, since no data can be stored
185 there. We just keep track of the current offset. */
186 addressT abs_section_offset
;
188 /* If this line had an MRI style label, it is stored in this variable.
189 This is used by some of the MRI pseudo-ops. */
192 /* This global variable is used to support MRI common sections. We
193 translate such sections into a common symbol. This variable is
194 non-NULL when we are in an MRI common section. */
195 symbolS
*mri_common_symbol
;
197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
198 need to align to an even byte boundary unless the next pseudo-op is
199 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
201 static int mri_pending_align
;
205 /* This variable is set to be non-zero if the next string we see might
206 be the name of the source file in DWARF debugging information. See
207 the comment in emit_expr for the format we look for. */
208 static int dwarf_file_string
;
212 /* If the target defines the md_frag_max_var hook then we know
213 enough to implement the .bundle_align_mode features. */
214 #ifdef md_frag_max_var
215 # define HANDLE_BUNDLE
219 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
220 it's the exponent of the bundle size, and aligned instruction bundle
221 mode is in effect. */
222 static unsigned int bundle_align_p2
;
224 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
225 bundle_lock_frag to frag_now and then starts a new frag with
226 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
227 so that .bundle_unlock can verify that we didn't change segments.
228 .bundle_unlock resets both to NULL. If we detect a bundling violation,
229 then we reset bundle_lock_frchain to NULL as an indicator that we've
230 already diagnosed the error with as_bad and don't need a cascade of
231 redundant errors, but bundle_lock_frag remains set to indicate that
232 we are expecting to see .bundle_unlock. */
233 static fragS
*bundle_lock_frag
;
234 static frchainS
*bundle_lock_frchain
;
236 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
238 static unsigned int bundle_lock_depth
;
241 static void do_s_func (int end_p
, const char *default_prefix
);
242 static void s_align (int, int);
243 static void s_altmacro (int);
244 static void s_bad_end (int);
245 static void s_reloc (int);
246 static int hex_float (int, char *);
247 static segT
get_known_segmented_expression (expressionS
* expP
);
248 static void pobegin (void);
249 static size_t get_non_macro_line_sb (sb
*);
250 static void generate_file_debug (void);
251 static char *_find_end_of_line (char *, int, int, int);
259 obj_read_begin_hook ();
261 /* Something close -- but not too close -- to a multiple of 1024.
262 The debugging malloc I'm using has 24 bytes of overhead. */
263 obstack_begin (¬es
, chunksize
);
264 obstack_begin (&cond_obstack
, chunksize
);
266 #ifndef tc_line_separator_chars
267 #define tc_line_separator_chars line_separator_chars
269 /* Use machine dependent syntax. */
270 for (p
= tc_line_separator_chars
; *p
; p
++)
271 is_end_of_line
[(unsigned char) *p
] = 2;
272 /* Use more. FIXME-SOMEDAY. */
278 #ifndef TC_ADDRESS_BYTES
279 #define TC_ADDRESS_BYTES address_bytes
284 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
285 contain an address. */
286 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
294 /* Set up pseudo-op tables. */
296 static struct hash_control
*po_hash
;
298 static const pseudo_typeS potable
[] = {
299 {"abort", s_abort
, 0},
300 {"align", s_align_ptwo
, 0},
301 {"altmacro", s_altmacro
, 1},
302 {"ascii", stringer
, 8+0},
303 {"asciz", stringer
, 8+1},
304 {"balign", s_align_bytes
, 0},
305 {"balignw", s_align_bytes
, -2},
306 {"balignl", s_align_bytes
, -4},
309 {"bundle_align_mode", s_bundle_align_mode
, 0},
310 {"bundle_lock", s_bundle_lock
, 0},
311 {"bundle_unlock", s_bundle_unlock
, 0},
315 {"common", s_mri_common
, 0},
316 {"common.s", s_mri_common
, 1},
319 #ifdef TC_ADDRESS_BYTES
323 {"dc.d", float_cons
, 'd'},
325 {"dc.s", float_cons
, 'f'},
327 {"dc.x", float_cons
, 'x'},
329 {"dcb.b", s_space
, 1},
330 {"dcb.d", s_float_space
, 'd'},
331 {"dcb.l", s_space
, 4},
332 {"dcb.s", s_float_space
, 'f'},
333 {"dcb.w", s_space
, 2},
334 {"dcb.x", s_float_space
, 'x'},
336 {"ds.b", s_space
, 1},
337 {"ds.d", s_space
, 8},
338 {"ds.l", s_space
, 4},
339 {"ds.p", s_space
, 12},
340 {"ds.s", s_space
, 4},
341 {"ds.w", s_space
, 2},
342 {"ds.x", s_space
, 12},
343 {"debug", s_ignore
, 0},
348 {"double", float_cons
, 'd'},
350 {"eject", listing_eject
, 0}, /* Formfeed listing. */
352 {"elsec", s_else
, 0},
353 {"elseif", s_elseif
, (int) O_ne
},
355 {"endc", s_endif
, 0},
356 {"endfunc", s_func
, 1},
357 {"endif", s_endif
, 0},
358 {"endm", s_bad_end
, 0},
359 {"endr", s_bad_end
, 1},
365 {"error", s_errwarn
, 1},
366 {"exitm", s_mexit
, 0},
368 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
369 {"appfile", s_app_file
, 1},
370 {"appline", s_app_line
, 1},
372 {"file", s_app_file
, 0},
374 {"float", float_cons
, 'f'},
375 {"format", s_ignore
, 0},
377 {"global", s_globl
, 0},
378 {"globl", s_globl
, 0},
380 {"if", s_if
, (int) O_ne
},
383 {"ifdef", s_ifdef
, 0},
384 {"ifeq", s_if
, (int) O_eq
},
385 {"ifeqs", s_ifeqs
, 0},
386 {"ifge", s_if
, (int) O_ge
},
387 {"ifgt", s_if
, (int) O_gt
},
388 {"ifle", s_if
, (int) O_le
},
389 {"iflt", s_if
, (int) O_lt
},
392 {"ifndef", s_ifdef
, 1},
393 {"ifne", s_if
, (int) O_ne
},
394 {"ifnes", s_ifeqs
, 1},
395 {"ifnotdef", s_ifdef
, 1},
396 {"incbin", s_incbin
, 0},
397 {"include", s_include
, 0},
403 {"lcomm", s_lcomm
, 0},
404 {"lflags", s_ignore
, 0}, /* Listing flags. */
405 {"linefile", s_app_line
, 0},
406 {"linkonce", s_linkonce
, 0},
407 {"list", listing_list
, 1}, /* Turn listing on. */
408 {"llen", listing_psize
, 1},
411 {"macro", s_macro
, 0},
412 {"mexit", s_mexit
, 0},
414 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
415 {"name", s_ignore
, 0},
416 {"noaltmacro", s_altmacro
, 0},
417 {"noformat", s_ignore
, 0},
418 {"nolist", listing_list
, 0}, /* Turn listing off. */
419 {"nopage", listing_nopage
, 0},
422 {"offset", s_struct
, 0},
424 {"p2align", s_align_ptwo
, 0},
425 {"p2alignw", s_align_ptwo
, -2},
426 {"p2alignl", s_align_ptwo
, -4},
427 {"page", listing_eject
, 0},
428 {"plen", listing_psize
, 0},
429 {"print", s_print
, 0},
430 {"psize", listing_psize
, 0}, /* Set paper size. */
431 {"purgem", s_purgem
, 0},
433 {"reloc", s_reloc
, 0},
437 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
442 {"single", float_cons
, 'f'},
444 {"space", s_space
, 0},
445 {"skip", s_space
, 0},
446 {"sleb128", s_leb128
, 1},
447 {"spc", s_ignore
, 0},
448 {"stabd", s_stab
, 'd'},
449 {"stabn", s_stab
, 'n'},
450 {"stabs", s_stab
, 's'},
451 {"string", stringer
, 8+1},
452 {"string8", stringer
, 8+1},
453 {"string16", stringer
, 16+1},
454 {"string32", stringer
, 32+1},
455 {"string64", stringer
, 64+1},
456 {"struct", s_struct
, 0},
460 /* This is for gcc to use. It's only just been added (2/94), so gcc
461 won't be able to use it for a while -- probably a year or more.
462 But once this has been released, check with gcc maintainers
463 before deleting it or even changing the spelling. */
464 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
465 /* If we're folding case -- done for some targets, not necessarily
466 all -- the above string in an input file will be converted to
467 this one. Match it either way... */
468 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
470 {"title", listing_title
, 0}, /* Listing title. */
471 {"ttl", listing_title
, 0},
473 {"uleb128", s_leb128
, 0},
477 {"xdef", s_globl
, 0},
478 {"xref", s_ignore
, 0},
479 {"xstabs", s_xstab
, 's'},
480 {"warning", s_errwarn
, 0},
481 {"weakref", s_weakref
, 0},
483 {"zero", s_space
, 0},
484 {NULL
, NULL
, 0} /* End sentinel. */
488 get_absolute_expr (expressionS
*exp
)
490 expression_and_evaluate (exp
);
492 if (exp
->X_op
!= O_constant
)
494 if (exp
->X_op
!= O_absent
)
495 as_bad (_("bad or irreducible absolute expression"));
496 exp
->X_add_number
= 0;
498 return exp
->X_add_number
;
502 get_absolute_expression (void)
506 return get_absolute_expr (&exp
);
509 static int pop_override_ok
= 0;
510 static const char *pop_table_name
;
513 pop_insert (const pseudo_typeS
*table
)
516 const pseudo_typeS
*pop
;
517 for (pop
= table
; pop
->poc_name
; pop
++)
519 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
520 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
521 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
526 #ifndef md_pop_insert
527 #define md_pop_insert() pop_insert(md_pseudo_table)
530 #ifndef obj_pop_insert
531 #define obj_pop_insert() pop_insert(obj_pseudo_table)
534 #ifndef cfi_pop_insert
535 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
541 po_hash
= hash_new ();
543 /* Do the target-specific pseudo ops. */
544 pop_table_name
= "md";
547 /* Now object specific. Skip any that were in the target table. */
548 pop_table_name
= "obj";
552 /* Now portable ones. Skip any that we've seen already. */
553 pop_table_name
= "standard";
554 pop_insert (potable
);
557 pop_table_name
= "cfi";
562 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
563 if (ignore_input ()) \
565 char *eol = find_end_of_line (input_line_pointer - (num_read), \
567 input_line_pointer = (input_line_pointer <= buffer_limit \
568 && eol >= buffer_limit) \
574 /* This function is used when scrubbing the characters between #APP
577 static char *scrub_string
;
578 static char *scrub_string_end
;
581 scrub_from_string (char *buf
, size_t buflen
)
585 copy
= scrub_string_end
- scrub_string
;
588 memcpy (buf
, scrub_string
, copy
);
589 scrub_string
+= copy
;
593 /* Helper function of read_a_source_file, which tries to expand a macro. */
595 try_macro (char term
, const char *line
)
601 if (check_macro (line
, &out
, &err
, ¯o
))
605 *input_line_pointer
++ = term
;
606 input_scrub_include_sb (&out
,
607 input_line_pointer
, 1);
610 input_scrub_next_buffer (&input_line_pointer
);
612 md_macro_info (macro
);
620 /* Start a new instruction bundle. Returns the rs_align_code frag that
621 will be used to align the new bundle. */
625 fragS
*frag
= frag_now
;
627 frag_align_code (0, 0);
629 while (frag
->fr_type
!= rs_align_code
)
630 frag
= frag
->fr_next
;
632 gas_assert (frag
!= frag_now
);
637 /* Calculate the maximum size after relaxation of the region starting
638 at the given frag and extending through frag_now (which is unfinished). */
640 pending_bundle_size (fragS
*frag
)
642 unsigned int offset
= frag
->fr_fix
;
643 unsigned int size
= 0;
645 gas_assert (frag
!= frag_now
);
646 gas_assert (frag
->fr_type
== rs_align_code
);
648 while (frag
!= frag_now
)
650 /* This should only happen in what will later become an error case. */
654 size
+= frag
->fr_fix
;
655 if (frag
->fr_type
== rs_machine_dependent
)
656 size
+= md_frag_max_var (frag
);
658 frag
= frag
->fr_next
;
661 gas_assert (frag
== frag_now
);
662 size
+= frag_now_fix ();
663 if (frag
->fr_type
== rs_machine_dependent
)
664 size
+= md_frag_max_var (frag
);
666 gas_assert (size
>= offset
);
668 return size
- offset
;
671 /* Finish off the frag created to ensure bundle alignment. */
673 finish_bundle (fragS
*frag
, unsigned int size
)
675 gas_assert (bundle_align_p2
> 0);
676 gas_assert (frag
->fr_type
== rs_align_code
);
680 /* If there is more than a single byte, then we need to set up the
681 alignment frag. Otherwise we leave it at its initial state from
682 calling frag_align_code (0, 0), so that it does nothing. */
683 frag
->fr_offset
= bundle_align_p2
;
684 frag
->fr_subtype
= size
- 1;
687 /* We do this every time rather than just in s_bundle_align_mode
688 so that we catch any affected section without needing hooks all
689 over for all paths that do section changes. It's cheap enough. */
690 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
691 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
694 /* Assemble one instruction. This takes care of the bundle features
695 around calling md_assemble. */
697 assemble_one (char *line
)
699 fragS
*insn_start_frag
= NULL
;
701 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
703 as_bad (_("cannot change section or subsection inside .bundle_lock"));
704 /* Clearing this serves as a marker that we have already complained. */
705 bundle_lock_frchain
= NULL
;
708 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
709 insn_start_frag
= start_bundle ();
713 if (bundle_lock_frchain
!= NULL
)
715 /* Make sure this hasn't pushed the locked sequence
716 past the bundle size. */
717 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
718 if (bundle_size
> 1U << bundle_align_p2
)
719 as_bad (_ (".bundle_lock sequence at %u bytes, "
720 "but .bundle_align_mode limit is %u bytes"),
721 bundle_size
, 1U << bundle_align_p2
);
723 else if (bundle_align_p2
> 0)
725 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
727 if (insn_size
> 1U << bundle_align_p2
)
728 as_bad (_("single instruction is %u bytes long, "
729 "but .bundle_align_mode limit is %u bytes"),
730 insn_size
, 1U << bundle_align_p2
);
732 finish_bundle (insn_start_frag
, insn_size
);
736 #else /* !HANDLE_BUNDLE */
738 # define assemble_one(line) md_assemble(line)
740 #endif /* HANDLE_BUNDLE */
745 flagword flags
= bfd_get_section_flags (stdoutput
, now_seg
);
747 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
750 /* Guts of .align directive:
751 N is the power of two to which to align. A value of zero is accepted but
752 ignored: the default alignment of the section will be at least this.
753 FILL may be NULL, or it may point to the bytes of the fill pattern.
754 LEN is the length of whatever FILL points to, if anything. If LEN is zero
755 but FILL is not NULL then LEN is treated as if it were one.
756 MAX is the maximum number of characters to skip when doing the alignment,
757 or 0 if there is no maximum. */
760 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
762 if (now_seg
== absolute_section
|| in_bss ())
768 if (now_seg
== absolute_section
)
769 as_warn (_("ignoring fill value in absolute section"));
771 as_warn (_("ignoring fill value in section `%s'"),
772 segment_name (now_seg
));
779 #ifdef md_flush_pending_output
780 md_flush_pending_output ();
784 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
787 /* Only make a frag if we HAVE to... */
788 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
792 if (subseg_text_p (now_seg
))
793 frag_align_code (n
, max
);
795 frag_align (n
, 0, max
);
798 frag_align (n
, *fill
, max
);
800 frag_align_pattern (n
, fill
, len
, max
);
804 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
807 if (n
> OCTETS_PER_BYTE_POWER
)
808 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
811 /* We read the file, putting things into a web that represents what we
812 have been reading. */
814 read_a_source_file (const char *name
)
818 char *s
; /* String of symbol, '\0' appended. */
826 buffer
= input_scrub_new_file (name
);
829 listing_newline (NULL
);
830 register_dependency (name
);
832 /* Generate debugging information before we've read anything in to denote
833 this file as the "main" source file and not a subordinate one
834 (e.g. N_SO vs N_SOL in stabs). */
835 generate_file_debug ();
837 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
838 { /* We have another line to parse. */
840 /* In order to avoid listing macro expansion lines with labels
841 multiple times, keep track of which line was last issued. */
842 static char *last_eol
;
846 while (input_line_pointer
< buffer_limit
)
848 bfd_boolean was_new_line
;
849 /* We have more of this buffer to parse. */
851 /* We now have input_line_pointer->1st char of next line.
852 If input_line_pointer [-1] == '\n' then we just
853 scanned another line: so bump line counters. */
854 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
857 symbol_set_value_now (&dot_symbol
);
858 #ifdef md_start_line_hook
859 md_start_line_hook ();
861 if (input_line_pointer
[-1] == '\n')
862 bump_line_counters ();
866 /* If listing is on, and we are expanding a macro, then give
867 the listing code the contents of the expanded line. */
870 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
872 /* Find the end of the current expanded macro line. */
873 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
881 /* Copy it for safe keeping. Also give an indication of
882 how much macro nesting is involved at this point. */
883 len
= s
- input_line_pointer
;
884 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
885 memset (copy
, '>', macro_nest
);
886 copy
[macro_nest
] = ' ';
887 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
888 copy
[macro_nest
+ 1 + len
] = '\0';
890 /* Install the line with the listing facility. */
891 listing_newline (copy
);
895 listing_newline (NULL
);
902 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
904 next_char
= * input_line_pointer
;
905 /* Text at the start of a line must be a label, we
906 run down and stick a colon in. */
907 if (is_name_beginner (next_char
) || next_char
== '"')
912 HANDLE_CONDITIONAL_ASSEMBLY (0);
914 nul_char
= get_symbol_name (& line_start
);
915 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
917 /* In MRI mode, the EQU and MACRO pseudoops must
918 be handled specially. */
922 char *rest
= input_line_pointer
+ 1;
926 if (*rest
== ' ' || *rest
== '\t')
928 if ((strncasecmp (rest
, "EQU", 3) == 0
929 || strncasecmp (rest
, "SET", 3) == 0)
930 && (rest
[3] == ' ' || rest
[3] == '\t'))
932 input_line_pointer
= rest
+ 3;
934 strncasecmp (rest
, "SET", 3) == 0);
937 if (strncasecmp (rest
, "MACRO", 5) == 0
940 || is_end_of_line
[(unsigned char) rest
[5]]))
944 /* In MRI mode, we need to handle the MACRO
945 pseudo-op specially: we don't want to put the
946 symbol in the symbol table. */
948 #ifdef TC_START_LABEL_WITHOUT_COLON
949 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
952 line_label
= colon (line_start
);
954 line_label
= symbol_create (line_start
,
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
, sizeof (original_case_string
));
1056 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1060 *s2
= TOLOWER (*s2
);
1065 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1067 /* The MRI assembler uses pseudo-ops without
1069 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
1070 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1075 || (!flag_m68k_mri
&& *s
== '.'))
1079 WARNING: next_char may be end-of-line.
1080 We lookup the pseudo-op table with s+1 because we
1081 already know that the pseudo-op begins with a '.'. */
1084 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1085 if (pop
&& !pop
->poc_handler
)
1088 /* In MRI mode, we may need to insert an
1089 automatic alignment directive. What a hack
1091 if (mri_pending_align
1093 || !((pop
->poc_handler
== cons
1094 && pop
->poc_val
== 1)
1095 || (pop
->poc_handler
== s_space
1096 && pop
->poc_val
== 1)
1097 #ifdef tc_conditional_pseudoop
1098 || tc_conditional_pseudoop (pop
)
1100 || pop
->poc_handler
== s_if
1101 || pop
->poc_handler
== s_ifdef
1102 || pop
->poc_handler
== s_ifc
1103 || pop
->poc_handler
== s_ifeqs
1104 || pop
->poc_handler
== s_else
1105 || pop
->poc_handler
== s_endif
1106 || pop
->poc_handler
== s_globl
1107 || pop
->poc_handler
== s_ignore
)))
1109 do_align (1, (char *) NULL
, 0, 0);
1110 mri_pending_align
= 0;
1112 if (line_label
!= NULL
)
1114 symbol_set_frag (line_label
, frag_now
);
1115 S_SET_VALUE (line_label
, frag_now_fix ());
1119 /* Print the error msg now, while we still can. */
1122 char *end
= input_line_pointer
;
1124 (void) restore_line_pointer (nul_char
);
1126 nul_char
= next_char
= *--input_line_pointer
;
1127 *input_line_pointer
= '\0';
1128 if (! macro_defined
|| ! try_macro (next_char
, s
))
1131 as_bad (_("unknown pseudo-op: `%s'"), s
);
1132 *input_line_pointer
++ = nul_char
;
1137 /* Put it back for error messages etc. */
1138 next_char
= restore_line_pointer (nul_char
);
1139 /* The following skip of whitespace is compulsory.
1140 A well shaped space is sometimes all that separates
1141 keyword from operands. */
1142 if (next_char
== ' ' || next_char
== '\t')
1143 input_line_pointer
++;
1145 /* Input_line is restored.
1146 Input_line_pointer->1st non-blank char
1147 after pseudo-operation. */
1148 (*pop
->poc_handler
) (pop
->poc_val
);
1150 /* If that was .end, just get out now. */
1151 if (pop
->poc_handler
== s_end
)
1156 /* WARNING: next_char may be end-of-line. */
1157 /* Also: input_line_pointer->`\0` where nul_char was. */
1158 (void) restore_line_pointer (nul_char
);
1159 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1160 next_char
= nul_char
= *input_line_pointer
;
1161 *input_line_pointer
= '\0';
1163 generate_lineno_debug ();
1165 if (macro_defined
&& try_macro (next_char
, s
))
1168 if (mri_pending_align
)
1170 do_align (1, (char *) NULL
, 0, 0);
1171 mri_pending_align
= 0;
1172 if (line_label
!= NULL
)
1174 symbol_set_frag (line_label
, frag_now
);
1175 S_SET_VALUE (line_label
, frag_now_fix ());
1179 assemble_one (s
); /* Assemble 1 instruction. */
1181 /* PR 19630: The backend may have set ilp to NULL
1182 if it encountered a catastrophic failure. */
1183 if (input_line_pointer
== NULL
)
1184 as_fatal (_("unable to continue with assembly."));
1186 *input_line_pointer
++ = nul_char
;
1188 /* We resume loop AFTER the end-of-line from
1189 this instruction. */
1195 /* Empty statement? */
1196 if (is_end_of_line
[(unsigned char) next_char
])
1199 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1201 /* local label ("4:") */
1202 char *backup
= input_line_pointer
;
1204 HANDLE_CONDITIONAL_ASSEMBLY (1);
1206 temp
= next_char
- '0';
1208 if (nul_char
== '"')
1209 ++ input_line_pointer
;
1211 /* Read the whole number. */
1212 while (ISDIGIT (*input_line_pointer
))
1214 temp
= (temp
* 10) + *input_line_pointer
- '0';
1215 ++input_line_pointer
;
1218 if (LOCAL_LABELS_DOLLAR
1219 && *input_line_pointer
== '$'
1220 && *(input_line_pointer
+ 1) == ':')
1222 input_line_pointer
+= 2;
1224 if (dollar_label_defined (temp
))
1226 as_fatal (_("label \"%d$\" redefined"), temp
);
1229 define_dollar_label (temp
);
1230 colon (dollar_label_name (temp
, 0));
1235 && *input_line_pointer
++ == ':')
1237 fb_label_instance_inc (temp
);
1238 colon (fb_label_name (temp
, 0));
1242 input_line_pointer
= backup
;
1245 if (next_char
&& strchr (line_comment_chars
, next_char
))
1246 { /* Its a comment. Better say APP or NO_APP. */
1251 unsigned int new_length
;
1254 s
= input_line_pointer
;
1255 if (strncmp (s
, "APP\n", 4))
1258 ignore_rest_of_line ();
1261 bump_line_counters ();
1264 ends
= strstr (s
, "#NO_APP\n");
1268 unsigned int tmp_len
;
1271 /* The end of the #APP wasn't in this buffer. We
1272 keep reading in buffers until we find the #NO_APP
1273 that goes with this #APP There is one. The specs
1275 tmp_len
= buffer_limit
- s
;
1276 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1277 memcpy (tmp_buf
, s
, tmp_len
);
1280 new_tmp
= input_scrub_next_buffer (&buffer
);
1284 buffer_limit
= new_tmp
;
1285 input_line_pointer
= buffer
;
1286 ends
= strstr (buffer
, "#NO_APP\n");
1288 num
= ends
- buffer
;
1290 num
= buffer_limit
- buffer
;
1292 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1293 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1298 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1306 input_line_pointer
= ends
+ 8;
1310 scrub_string_end
= ends
;
1312 new_length
= ends
- s
;
1313 new_buf
= XNEWVEC (char, new_length
);
1320 space
= (new_buf
+ new_length
) - new_tmp
;
1321 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1329 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1330 new_tmp
= new_buf
+ new_length
;
1337 /* We've "scrubbed" input to the preferred format. In the
1338 process we may have consumed the whole of the remaining
1339 file (and included files). We handle this formatted
1340 input similar to that of macro expansion, letting
1341 actual macro expansion (possibly nested) and other
1342 input expansion work. Beware that in messages, line
1343 numbers and possibly file names will be incorrect. */
1344 new_length
= strlen (new_buf
);
1345 sb_build (&sbuf
, new_length
);
1346 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1347 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1349 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1354 HANDLE_CONDITIONAL_ASSEMBLY (1);
1356 #ifdef tc_unrecognized_line
1357 if (tc_unrecognized_line (next_char
))
1360 input_line_pointer
--;
1361 /* Report unknown char as error. */
1362 demand_empty_rest_of_line ();
1367 symbol_set_value_now (&dot_symbol
);
1369 #ifdef HANDLE_BUNDLE
1370 if (bundle_lock_frag
!= NULL
)
1372 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1373 _(".bundle_lock with no matching .bundle_unlock"));
1374 bundle_lock_frag
= NULL
;
1375 bundle_lock_frchain
= NULL
;
1376 bundle_lock_depth
= 0;
1383 /* Close the input file. */
1384 input_scrub_close ();
1385 #ifdef WARN_COMMENTS
1387 if (warn_comment
&& found_comment
)
1388 as_warn_where (found_comment_file
, found_comment
,
1389 "first comment found here");
1394 /* Convert O_constant expression EXP into the equivalent O_big representation.
1395 Take the sign of the number from SIGN rather than X_add_number. */
1398 convert_to_bignum (expressionS
*exp
, int sign
)
1403 value
= exp
->X_add_number
;
1404 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1406 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1407 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1409 /* Add a sequence of sign bits if the top bit of X_add_number is not
1410 the sign of the original value. */
1411 if ((exp
->X_add_number
< 0) == !sign
)
1412 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1414 exp
->X_add_number
= i
;
1417 /* For most MRI pseudo-ops, the line actually ends at the first
1418 nonquoted space. This function looks for that point, stuffs a null
1419 in, and sets *STOPCP to the character that used to be there, and
1420 returns the location.
1422 Until I hear otherwise, I am going to assume that this is only true
1423 for the m68k MRI assembler. */
1426 mri_comment_field (char *stopcp
)
1432 know (flag_m68k_mri
);
1434 for (s
= input_line_pointer
;
1435 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1443 for (s
= input_line_pointer
;
1444 !is_end_of_line
[(unsigned char) *s
];
1454 /* Skip to the end of an MRI comment field. */
1457 mri_comment_end (char *stop
, int stopc
)
1461 input_line_pointer
= stop
;
1463 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1464 ++input_line_pointer
;
1468 s_abort (int ignore ATTRIBUTE_UNUSED
)
1470 as_fatal (_(".abort detected. Abandoning ship."));
1473 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1474 (in bytes). A negative ARG is the negative of the length of the
1475 fill pattern. BYTES_P is non-zero if the alignment value should be
1476 interpreted as the byte boundary, rather than the power of 2. */
1477 #ifndef TC_ALIGN_LIMIT
1478 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1482 s_align (signed int arg
, int bytes_p
)
1484 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1493 stop
= mri_comment_field (&stopc
);
1495 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1500 align
= arg
; /* Default value from pseudo-op table. */
1504 align
= get_absolute_expression ();
1507 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1508 if (arg
> 0 && align
== 0)
1515 /* Convert to a power of 2. */
1520 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1523 as_bad (_("alignment not a power of 2"));
1529 if (align
> align_limit
)
1531 align
= align_limit
;
1532 as_warn (_("alignment too large: %u assumed"), align
);
1535 if (*input_line_pointer
!= ',')
1542 ++input_line_pointer
;
1543 if (*input_line_pointer
== ',')
1547 fill
= get_absolute_expression ();
1552 if (*input_line_pointer
!= ',')
1556 ++input_line_pointer
;
1557 max
= get_absolute_expression ();
1564 as_warn (_("expected fill pattern missing"));
1565 do_align (align
, (char *) NULL
, 0, max
);
1569 unsigned int fill_len
;
1581 do_align (align
, &fill_char
, fill_len
, max
);
1587 if ((size_t) fill_len
> sizeof ab
)
1589 as_warn (_("fill pattern too long, truncating to %u"),
1590 (unsigned) sizeof ab
);
1591 fill_len
= sizeof ab
;
1594 md_number_to_chars (ab
, fill
, fill_len
);
1595 do_align (align
, ab
, fill_len
, max
);
1599 demand_empty_rest_of_line ();
1602 mri_comment_end (stop
, stopc
);
1605 /* Handle the .align pseudo-op on machines where ".align 4" means
1606 align to a 4 byte boundary. */
1609 s_align_bytes (int arg
)
1614 /* Handle the .align pseudo-op on machines where ".align 4" means align
1615 to a 2**4 boundary. */
1618 s_align_ptwo (int arg
)
1623 /* Switch in and out of alternate macro mode. */
1628 demand_empty_rest_of_line ();
1629 macro_set_alternate (on
);
1632 /* Read a symbol name from input_line_pointer.
1634 Stores the symbol name in a buffer and returns a pointer to this buffer.
1635 The buffer is xalloc'ed. It is the caller's responsibility to free
1638 The name is not left in the i_l_p buffer as it may need processing
1639 to handle escape characters.
1641 Advances i_l_p to the next non-whitespace character.
1643 If a symbol name could not be read, the routine issues an error
1644 messages, skips to the end of the line and returns NULL. */
1647 read_symbol_name (void)
1653 c
= *input_line_pointer
++;
1657 #define SYM_NAME_CHUNK_LEN 128
1658 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1662 start
= name
= XNEWVEC (char, len
+ 1);
1664 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1666 while (is_a_char (C
= next_char_of_string ()))
1668 if (name
>= name_end
)
1672 sofar
= name
- start
;
1673 len
+= SYM_NAME_CHUNK_LEN
;
1674 start
= XRESIZEVEC (char, start
, len
+ 1);
1675 name_end
= start
+ len
;
1676 name
= start
+ sofar
;
1683 /* Since quoted symbol names can contain non-ASCII characters,
1684 check the string and warn if it cannot be recognised by the
1685 current character set. */
1686 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1687 as_warn (_("symbol name not recognised in the current locale"));
1689 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1693 name
= input_line_pointer
- 1;
1695 /* We accept FAKE_LABEL_CHAR in a name in case this is
1696 being called with a constructed string. */
1697 while (is_part_of_name (c
= *input_line_pointer
++)
1698 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1701 len
= (input_line_pointer
- name
) - 1;
1702 start
= XNEWVEC (char, len
+ 1);
1704 memcpy (start
, name
, len
);
1707 /* Skip a name ender char if one is present. */
1708 if (! is_name_ender (c
))
1709 --input_line_pointer
;
1712 name
= start
= NULL
;
1716 as_bad (_("expected symbol name"));
1717 ignore_rest_of_line ();
1728 s_comm_internal (int param
,
1729 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1733 symbolS
*symbolP
= NULL
;
1739 stop
= mri_comment_field (&stopc
);
1741 if ((name
= read_symbol_name ()) == NULL
)
1744 /* Accept an optional comma after the name. The comma used to be
1745 required, but Irix 5 cc does not generate it for .lcomm. */
1746 if (*input_line_pointer
== ',')
1747 input_line_pointer
++;
1749 temp
= get_absolute_expr (&exp
);
1751 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1752 if (exp
.X_op
== O_absent
)
1754 as_bad (_("missing size expression"));
1755 ignore_rest_of_line ();
1758 else if (temp
!= size
|| !exp
.X_unsigned
)
1760 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1761 ignore_rest_of_line ();
1765 symbolP
= symbol_find_or_make (name
);
1766 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1767 && !S_IS_COMMON (symbolP
))
1769 if (!S_IS_VOLATILE (symbolP
))
1772 as_bad (_("symbol `%s' is already defined"), name
);
1773 ignore_rest_of_line ();
1776 symbolP
= symbol_clone (symbolP
, 1);
1777 S_SET_SEGMENT (symbolP
, undefined_section
);
1778 S_SET_VALUE (symbolP
, 0);
1779 symbol_set_frag (symbolP
, &zero_address_frag
);
1780 S_CLEAR_VOLATILE (symbolP
);
1783 size
= S_GET_VALUE (symbolP
);
1786 else if (size
!= temp
)
1787 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1788 name
, (long) size
, (long) temp
);
1790 if (comm_parse_extra
!= NULL
)
1791 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1794 S_SET_VALUE (symbolP
, (valueT
) size
);
1795 S_SET_EXTERNAL (symbolP
);
1796 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1799 demand_empty_rest_of_line ();
1802 mri_comment_end (stop
, stopc
);
1811 s_comm_internal (ignore
, NULL
);
1814 /* The MRI COMMON pseudo-op. We handle this by creating a common
1815 symbol with the appropriate name. We make s_space do the right
1816 thing by increasing the size. */
1819 s_mri_common (int small ATTRIBUTE_UNUSED
)
1835 stop
= mri_comment_field (&stopc
);
1839 name
= input_line_pointer
;
1840 if (!ISDIGIT (*name
))
1841 c
= get_symbol_name (& name
);
1846 ++input_line_pointer
;
1848 while (ISDIGIT (*input_line_pointer
));
1850 c
= *input_line_pointer
;
1851 *input_line_pointer
= '\0';
1853 if (line_label
!= NULL
)
1855 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1856 + (input_line_pointer
- name
) + 1);
1857 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1862 sym
= symbol_find_or_make (name
);
1863 c
= restore_line_pointer (c
);
1867 if (*input_line_pointer
!= ',')
1871 ++input_line_pointer
;
1872 align
= get_absolute_expression ();
1875 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1877 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1878 ignore_rest_of_line ();
1879 mri_comment_end (stop
, stopc
);
1883 S_SET_EXTERNAL (sym
);
1884 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1885 mri_common_symbol
= sym
;
1889 S_SET_ALIGN (sym
, align
);
1894 if (line_label
!= NULL
)
1897 exp
.X_op
= O_symbol
;
1898 exp
.X_add_symbol
= sym
;
1899 exp
.X_add_number
= 0;
1900 symbol_set_value_expression (line_label
, &exp
);
1901 symbol_set_frag (line_label
, &zero_address_frag
);
1902 S_SET_SEGMENT (line_label
, expr_section
);
1905 /* FIXME: We just ignore the small argument, which distinguishes
1906 COMMON and COMMON.S. I don't know what we can do about it. */
1908 /* Ignore the type and hptype. */
1909 if (*input_line_pointer
== ',')
1910 input_line_pointer
+= 2;
1911 if (*input_line_pointer
== ',')
1912 input_line_pointer
+= 2;
1914 demand_empty_rest_of_line ();
1916 mri_comment_end (stop
, stopc
);
1920 s_data (int ignore ATTRIBUTE_UNUSED
)
1925 temp
= get_absolute_expression ();
1926 if (flag_readonly_data_in_text
)
1928 section
= text_section
;
1932 section
= data_section
;
1934 subseg_set (section
, (subsegT
) temp
);
1936 demand_empty_rest_of_line ();
1939 /* Handle the .appfile pseudo-op. This is automatically generated by
1940 do_scrub_chars when a preprocessor # line comment is seen with a
1941 file name. This default definition may be overridden by the object
1942 or CPU specific pseudo-ops. This function is also the default
1943 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1947 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1951 listing_source_file (file
);
1953 register_dependency (file
);
1955 obj_app_file (file
, appfile
);
1960 s_app_file (int appfile
)
1965 /* Some assemblers tolerate immediately following '"'. */
1966 if ((s
= demand_copy_string (&length
)) != 0)
1969 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1971 /* In MRI mode, the preprocessor may have inserted an extraneous
1974 && *input_line_pointer
== '\''
1975 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1976 ++input_line_pointer
;
1978 demand_empty_rest_of_line ();
1980 s_app_file_string (s
, appfile
);
1985 get_linefile_number (int *flag
)
1989 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1992 *flag
= get_absolute_expression ();
1997 /* Handle the .appline pseudo-op. This is automatically generated by
1998 do_scrub_chars when a preprocessor # line comment is seen. This
1999 default definition may be overridden by the object or CPU specific
2003 s_app_line (int appline
)
2008 /* The given number is that of the next line. */
2010 l
= get_absolute_expression ();
2011 else if (!get_linefile_number (&l
))
2013 ignore_rest_of_line ();
2020 /* Some of the back ends can't deal with non-positive line numbers.
2021 Besides, it's silly. GCC however will generate a line number of
2022 zero when it is pre-processing builtins for assembler-with-cpp files:
2026 We do not want to barf on this, especially since such files are used
2027 in the GCC and GDB testsuites. So we check for negative line numbers
2028 rather than non-positive line numbers. */
2029 as_warn (_("line numbers must be positive; line number %d rejected"),
2040 if (*input_line_pointer
== '"')
2041 file
= demand_copy_string (&length
);
2047 while (get_linefile_number (&this_flag
))
2050 /* From GCC's cpp documentation:
2051 1: start of a new file.
2052 2: returning to a file after having included
2054 3: following text comes from a system header file.
2055 4: following text should be treated as extern "C".
2057 4 is nonsensical for the assembler; 3, we don't
2058 care about, so we ignore it just in case a
2059 system header file is included while
2060 preprocessing assembly. So 1 and 2 are all we
2061 care about, and they are mutually incompatible.
2062 new_logical_line_flags() demands this. */
2065 if (flags
&& flags
!= (1 << this_flag
))
2066 as_warn (_("incompatible flag %i in line directive"),
2069 flags
|= 1 << this_flag
;
2074 /* We ignore these. */
2078 as_warn (_("unsupported flag %i in line directive"),
2083 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2088 if (appline
|| file
)
2090 new_logical_line_flags (file
, l
, flags
);
2093 listing_source_line (l
);
2097 if (appline
|| file
)
2098 demand_empty_rest_of_line ();
2100 ignore_rest_of_line ();
2103 /* Handle the .end pseudo-op. Actually, the real work is done in
2104 read_a_source_file. */
2107 s_end (int ignore ATTRIBUTE_UNUSED
)
2111 /* The MRI assembler permits the start symbol to follow .end,
2112 but we don't support that. */
2114 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2115 && *input_line_pointer
!= '*'
2116 && *input_line_pointer
!= '!')
2117 as_warn (_("start address not supported"));
2121 /* Handle the .err pseudo-op. */
2124 s_err (int ignore ATTRIBUTE_UNUSED
)
2126 as_bad (_(".err encountered"));
2127 demand_empty_rest_of_line ();
2130 /* Handle the .error and .warning pseudo-ops. */
2136 /* The purpose for the conditional assignment is not to
2137 internationalize the directive itself, but that we need a
2138 self-contained message, one that can be passed like the
2139 demand_copy_C_string return value, and with no assumption on the
2140 location of the name of the directive within the message. */
2142 = (err
? _(".error directive invoked in source file")
2143 : _(".warning directive invoked in source file"));
2145 if (!is_it_end_of_statement ())
2147 if (*input_line_pointer
!= '\"')
2149 as_bad (_("%s argument must be a string"),
2150 err
? ".error" : ".warning");
2151 ignore_rest_of_line ();
2155 msg
= demand_copy_C_string (&len
);
2163 as_warn ("%s", msg
);
2164 demand_empty_rest_of_line ();
2167 /* Handle the MRI fail pseudo-op. */
2170 s_fail (int ignore ATTRIBUTE_UNUSED
)
2177 stop
= mri_comment_field (&stopc
);
2179 temp
= get_absolute_expression ();
2181 as_warn (_(".fail %ld encountered"), (long) temp
);
2183 as_bad (_(".fail %ld encountered"), (long) temp
);
2185 demand_empty_rest_of_line ();
2188 mri_comment_end (stop
, stopc
);
2192 s_fill (int ignore ATTRIBUTE_UNUSED
)
2194 expressionS rep_exp
;
2199 #ifdef md_flush_pending_output
2200 md_flush_pending_output ();
2203 #ifdef md_cons_align
2207 expression (&rep_exp
);
2208 if (*input_line_pointer
== ',')
2210 input_line_pointer
++;
2211 size
= get_absolute_expression ();
2212 if (*input_line_pointer
== ',')
2214 input_line_pointer
++;
2215 fill
= get_absolute_expression ();
2219 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2220 #define BSD_FILL_SIZE_CROCK_8 (8)
2221 if (size
> BSD_FILL_SIZE_CROCK_8
)
2223 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2224 size
= BSD_FILL_SIZE_CROCK_8
;
2228 as_warn (_("size negative; .fill ignored"));
2231 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2233 if (rep_exp
.X_add_number
< 0)
2234 as_warn (_("repeat < 0; .fill ignored"));
2238 if (size
&& !need_pass_2
)
2240 if (now_seg
== absolute_section
)
2242 if (rep_exp
.X_op
!= O_constant
)
2243 as_bad (_("non-constant fill count for absolute section"));
2244 else if (fill
&& rep_exp
.X_add_number
!= 0)
2245 as_bad (_("attempt to fill absolute section with non-zero value"));
2246 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2249 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2251 as_bad (_("attempt to fill section `%s' with non-zero value"),
2252 segment_name (now_seg
));
2254 if (rep_exp
.X_op
== O_constant
)
2256 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2257 (relax_substateT
) 0, (symbolS
*) 0,
2258 (offsetT
) rep_exp
.X_add_number
,
2263 /* We don't have a constant repeat count, so we can't use
2264 rs_fill. We can get the same results out of rs_space,
2265 but its argument is in bytes, so we must multiply the
2266 repeat count by size. */
2269 rep_sym
= make_expr_symbol (&rep_exp
);
2272 expressionS size_exp
;
2273 size_exp
.X_op
= O_constant
;
2274 size_exp
.X_add_number
= size
;
2276 rep_exp
.X_op
= O_multiply
;
2277 rep_exp
.X_add_symbol
= rep_sym
;
2278 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2279 rep_exp
.X_add_number
= 0;
2280 rep_sym
= make_expr_symbol (&rep_exp
);
2283 p
= frag_var (rs_space
, (int) size
, (int) size
,
2284 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2287 memset (p
, 0, (unsigned int) size
);
2289 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2290 flavoured AS. The following bizarre behaviour is to be
2291 compatible with above. I guess they tried to take up to 8
2292 bytes from a 4-byte expression and they forgot to sign
2294 #define BSD_FILL_SIZE_CROCK_4 (4)
2295 md_number_to_chars (p
, (valueT
) fill
,
2296 (size
> BSD_FILL_SIZE_CROCK_4
2297 ? BSD_FILL_SIZE_CROCK_4
2299 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2300 but emits no error message because it seems a legal thing to do.
2301 It is a degenerate case of .fill but could be emitted by a
2304 demand_empty_rest_of_line ();
2308 s_globl (int ignore ATTRIBUTE_UNUSED
)
2317 stop
= mri_comment_field (&stopc
);
2321 if ((name
= read_symbol_name ()) == NULL
)
2324 symbolP
= symbol_find_or_make (name
);
2325 S_SET_EXTERNAL (symbolP
);
2328 c
= *input_line_pointer
;
2331 input_line_pointer
++;
2333 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2341 demand_empty_rest_of_line ();
2344 mri_comment_end (stop
, stopc
);
2347 /* Handle the MRI IRP and IRPC pseudo-ops. */
2359 file
= as_where (&line
);
2361 eol
= find_end_of_line (input_line_pointer
, 0);
2362 sb_build (&s
, eol
- input_line_pointer
);
2363 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2364 input_line_pointer
= eol
;
2368 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2370 as_bad_where (file
, line
, "%s", err
);
2374 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2376 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2379 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2380 the section to only be linked once. However, this is not supported
2381 by most object file formats. This takes an optional argument,
2382 which is what to do about duplicates. */
2385 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2387 enum linkonce_type type
;
2391 type
= LINKONCE_DISCARD
;
2393 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2398 c
= get_symbol_name (& s
);
2399 if (strcasecmp (s
, "discard") == 0)
2400 type
= LINKONCE_DISCARD
;
2401 else if (strcasecmp (s
, "one_only") == 0)
2402 type
= LINKONCE_ONE_ONLY
;
2403 else if (strcasecmp (s
, "same_size") == 0)
2404 type
= LINKONCE_SAME_SIZE
;
2405 else if (strcasecmp (s
, "same_contents") == 0)
2406 type
= LINKONCE_SAME_CONTENTS
;
2408 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2410 (void) restore_line_pointer (c
);
2413 #ifdef obj_handle_link_once
2414 obj_handle_link_once (type
);
2415 #else /* ! defined (obj_handle_link_once) */
2419 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2420 as_warn (_(".linkonce is not supported for this object file format"));
2422 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2423 flags
|= SEC_LINK_ONCE
;
2428 case LINKONCE_DISCARD
:
2429 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2431 case LINKONCE_ONE_ONLY
:
2432 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2434 case LINKONCE_SAME_SIZE
:
2435 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2437 case LINKONCE_SAME_CONTENTS
:
2438 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2441 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2442 as_bad (_("bfd_set_section_flags: %s"),
2443 bfd_errmsg (bfd_get_error ()));
2445 #endif /* ! defined (obj_handle_link_once) */
2447 demand_empty_rest_of_line ();
2451 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2454 segT current_seg
= now_seg
;
2455 subsegT current_subseg
= now_subseg
;
2456 segT bss_seg
= bss_section
;
2458 #if defined (TC_MIPS) || defined (TC_ALPHA)
2459 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2460 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2462 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2463 if (size
<= bfd_get_gp_size (stdoutput
))
2465 bss_seg
= subseg_new (".sbss", 1);
2466 seg_info (bss_seg
)->bss
= 1;
2467 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2468 as_warn (_("error setting flags for \".sbss\": %s"),
2469 bfd_errmsg (bfd_get_error ()));
2473 subseg_set (bss_seg
, 1);
2475 if (align
> OCTETS_PER_BYTE_POWER
)
2477 record_alignment (bss_seg
, align
);
2478 frag_align (align
, 0, 0);
2481 /* Detach from old frag. */
2482 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2483 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2485 symbol_set_frag (symbolP
, frag_now
);
2486 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2490 S_SET_SIZE (symbolP
, size
);
2492 S_SET_SEGMENT (symbolP
, bss_seg
);
2495 /* The symbol may already have been created with a preceding
2496 ".globl" directive -- be careful not to step on storage class
2497 in that case. Otherwise, set it to static. */
2498 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2499 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2500 #endif /* OBJ_COFF */
2502 subseg_set (current_seg
, current_subseg
);
2506 parse_align (int align_bytes
)
2512 if (*input_line_pointer
!= ',')
2515 as_bad (_("expected alignment after size"));
2516 ignore_rest_of_line ();
2520 input_line_pointer
++;
2523 align
= get_absolute_expr (&exp
);
2524 if (exp
.X_op
== O_absent
)
2527 if (!exp
.X_unsigned
)
2529 as_warn (_("alignment negative; 0 assumed"));
2533 if (align_bytes
&& align
!= 0)
2535 /* convert to a power of 2 alignment */
2536 unsigned int alignp2
= 0;
2537 while ((align
& 1) == 0)
2538 align
>>= 1, ++alignp2
;
2541 as_bad (_("alignment not a power of 2"));
2542 ignore_rest_of_line ();
2550 /* Called from s_comm_internal after symbol name and size have been
2551 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2552 1 if this was a ".bss" directive which has a 3rd argument
2553 (alignment as a power of 2), or 2 if this was a ".bss" directive
2554 with alignment in bytes. */
2557 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2563 align
= parse_align (needs_align
- 1);
2564 if (align
== (addressT
) -1)
2568 /* Assume some objects may require alignment on some systems. */
2569 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2571 bss_alloc (symbolP
, size
, align
);
2576 s_lcomm (int needs_align
)
2578 s_comm_internal (needs_align
, s_lcomm_internal
);
2582 s_lcomm_bytes (int needs_align
)
2584 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2588 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2594 /* We permit ANY defined expression: BSD4.2 demands constants. */
2595 if ((name
= read_symbol_name ()) == NULL
)
2598 if (*input_line_pointer
!= ',')
2600 as_bad (_("expected comma after \"%s\""), name
);
2604 input_line_pointer
++;
2605 expression_and_evaluate (&exp
);
2607 if (exp
.X_op
!= O_constant
2608 && exp
.X_op
!= O_register
)
2610 as_bad (_("bad expression"));
2614 symbolP
= symbol_find_or_make (name
);
2616 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2618 /* The name might be an undefined .global symbol; be sure to
2619 keep the "external" bit. */
2620 S_SET_SEGMENT (symbolP
,
2621 (exp
.X_op
== O_constant
2624 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2628 as_bad (_("symbol `%s' is already defined"), name
);
2631 demand_empty_rest_of_line ();
2636 ignore_rest_of_line ();
2641 /* Read a line into an sb. Returns the character that ended the line
2642 or zero if there are no more lines. */
2645 get_line_sb (sb
*line
, int in_macro
)
2649 if (input_line_pointer
[-1] == '\n')
2650 bump_line_counters ();
2652 if (input_line_pointer
>= buffer_limit
)
2654 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2655 if (buffer_limit
== 0)
2659 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2660 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2661 input_line_pointer
= eol
;
2663 /* Don't skip multiple end-of-line characters, because that breaks support
2664 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2665 characters but isn't. Instead just skip one end of line character and
2666 return the character skipped so that the caller can re-insert it if
2668 return *input_line_pointer
++;
2672 get_non_macro_line_sb (sb
*line
)
2674 return get_line_sb (line
, 0);
2678 get_macro_line_sb (sb
*line
)
2680 return get_line_sb (line
, 1);
2683 /* Define a macro. This is an interface to macro.c. */
2686 s_macro (int ignore ATTRIBUTE_UNUSED
)
2695 file
= as_where (&line
);
2697 eol
= find_end_of_line (input_line_pointer
, 0);
2698 sb_build (&s
, eol
- input_line_pointer
);
2699 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2700 input_line_pointer
= eol
;
2702 if (line_label
!= NULL
)
2707 name
= S_GET_NAME (line_label
);
2708 len
= strlen (name
);
2709 sb_build (&label
, len
);
2710 sb_add_buffer (&label
, name
, len
);
2711 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2715 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2717 as_bad_where (file
, line
, err
, name
);
2720 if (line_label
!= NULL
)
2722 S_SET_SEGMENT (line_label
, absolute_section
);
2723 S_SET_VALUE (line_label
, 0);
2724 symbol_set_frag (line_label
, &zero_address_frag
);
2727 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2728 && hash_find (po_hash
, name
) != NULL
)
2731 && hash_find (po_hash
, name
+ 1) != NULL
))
2732 as_warn_where (file
,
2734 _("attempt to redefine pseudo-op `%s' ignored"),
2741 /* Handle the .mexit pseudo-op, which immediately exits a macro
2745 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2749 cond_exit_macro (macro_nest
);
2750 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2753 as_warn (_("ignoring macro exit outside a macro definition."));
2756 /* Switch in and out of MRI mode. */
2759 s_mri (int ignore ATTRIBUTE_UNUSED
)
2762 #ifdef MRI_MODE_CHANGE
2766 on
= get_absolute_expression ();
2767 #ifdef MRI_MODE_CHANGE
2768 old_flag
= flag_mri
;
2787 /* Operator precedence changes in m68k MRI mode, so we need to
2788 update the operator rankings. */
2789 expr_set_precedence ();
2791 #ifdef MRI_MODE_CHANGE
2793 MRI_MODE_CHANGE (on
);
2796 demand_empty_rest_of_line ();
2799 /* Handle changing the location counter. */
2802 do_org (segT segment
, expressionS
*exp
, int fill
)
2804 if (segment
!= now_seg
2805 && segment
!= absolute_section
2806 && segment
!= expr_section
)
2807 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2809 if (now_seg
== absolute_section
)
2812 as_warn (_("ignoring fill value in absolute section"));
2813 if (exp
->X_op
!= O_constant
)
2815 as_bad (_("only constant offsets supported in absolute section"));
2816 exp
->X_add_number
= 0;
2818 abs_section_offset
= exp
->X_add_number
;
2823 symbolS
*sym
= exp
->X_add_symbol
;
2824 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2826 if (fill
&& in_bss ())
2827 as_warn (_("ignoring fill value in section `%s'"),
2828 segment_name (now_seg
));
2830 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2832 /* Handle complex expressions. */
2833 sym
= make_expr_symbol (exp
);
2837 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2843 s_org (int ignore ATTRIBUTE_UNUSED
)
2849 #ifdef md_flush_pending_output
2850 md_flush_pending_output ();
2853 /* The m68k MRI assembler has a different meaning for .org. It
2854 means to create an absolute section at a given address. We can't
2855 support that--use a linker script instead. */
2858 as_bad (_("MRI style ORG pseudo-op not supported"));
2859 ignore_rest_of_line ();
2863 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2864 thing as a sub-segment-relative origin. Any absolute origin is
2865 given a warning, then assumed to be segment-relative. Any
2866 segmented origin expression ("foo+42") had better be in the right
2867 segment or the .org is ignored.
2869 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2870 we never know sub-segment sizes when we are reading code. BSD
2871 will crash trying to emit negative numbers of filler bytes in
2872 certain .orgs. We don't crash, but see as-write for that code.
2874 Don't make frag if need_pass_2==1. */
2875 segment
= get_known_segmented_expression (&exp
);
2876 if (*input_line_pointer
== ',')
2878 input_line_pointer
++;
2879 temp_fill
= get_absolute_expression ();
2885 do_org (segment
, &exp
, temp_fill
);
2887 demand_empty_rest_of_line ();
2890 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2891 called by the obj-format routine which handles section changing
2892 when in MRI mode. It will create a new section, and return it. It
2893 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2894 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2897 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2907 name
= input_line_pointer
;
2908 if (!ISDIGIT (*name
))
2909 c
= get_symbol_name (& name
);
2914 ++input_line_pointer
;
2916 while (ISDIGIT (*input_line_pointer
));
2918 c
= *input_line_pointer
;
2919 *input_line_pointer
= '\0';
2922 name
= xstrdup (name
);
2924 c
= restore_line_pointer (c
);
2926 seg
= subseg_new (name
, 0);
2932 ++input_line_pointer
;
2933 align
= get_absolute_expression ();
2934 record_alignment (seg
, align
);
2938 if (*input_line_pointer
== ',')
2940 c
= *++input_line_pointer
;
2942 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2945 as_bad (_("unrecognized section type"));
2946 ++input_line_pointer
;
2951 flags
= SEC_NO_FLAGS
;
2953 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2954 else if (*type
== 'D' || *type
== 'M')
2955 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2956 else if (*type
== 'R')
2957 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2958 if (flags
!= SEC_NO_FLAGS
)
2960 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2961 as_warn (_("error setting flags for \"%s\": %s"),
2962 bfd_section_name (stdoutput
, seg
),
2963 bfd_errmsg (bfd_get_error ()));
2968 /* Ignore the HP type. */
2969 if (*input_line_pointer
== ',')
2970 input_line_pointer
+= 2;
2972 demand_empty_rest_of_line ();
2974 #else /* ! TC_M68K */
2975 /* The MRI assembler seems to use different forms of .sect for
2976 different targets. */
2977 as_bad ("MRI mode not supported for this target");
2978 ignore_rest_of_line ();
2979 #endif /* ! TC_M68K */
2982 /* Handle the .print pseudo-op. */
2985 s_print (int ignore ATTRIBUTE_UNUSED
)
2990 s
= demand_copy_C_string (&len
);
2993 demand_empty_rest_of_line ();
2996 /* Handle the .purgem pseudo-op. */
2999 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3001 if (is_it_end_of_statement ())
3003 demand_empty_rest_of_line ();
3013 c
= get_symbol_name (& name
);
3014 delete_macro (name
);
3015 *input_line_pointer
= c
;
3016 SKIP_WHITESPACE_AFTER_NAME ();
3018 while (*input_line_pointer
++ == ',');
3020 --input_line_pointer
;
3021 demand_empty_rest_of_line ();
3024 /* Handle the .endm/.endr pseudo-ops. */
3027 s_bad_end (int endr
)
3029 as_warn (_(".end%c encountered without preceding %s"),
3031 endr
? ".rept, .irp, or .irpc" : ".macro");
3032 demand_empty_rest_of_line ();
3035 /* Handle the .rept pseudo-op. */
3038 s_rept (int ignore ATTRIBUTE_UNUSED
)
3042 count
= (size_t) get_absolute_expression ();
3044 do_repeat (count
, "REPT", "ENDR");
3047 /* This function provides a generic repeat block implementation. It allows
3048 different directives to be used as the start/end keys. */
3051 do_repeat (size_t count
, const char *start
, const char *end
)
3056 if (((ssize_t
) count
) < 0)
3058 as_bad (_("negative count for %s - ignored"), start
);
3063 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3065 as_bad (_("%s without %s"), start
, end
);
3069 sb_build (&many
, count
* one
.len
);
3071 sb_add_sb (&many
, &one
);
3075 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3077 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3080 /* Like do_repeat except that any text matching EXPANDER in the
3081 block is replaced by the iteration count. */
3084 do_repeat_with_expander (size_t count
,
3087 const char * expander
)
3092 if (((ssize_t
) count
) < 0)
3094 as_bad (_("negative count for %s - ignored"), start
);
3099 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3101 as_bad (_("%s without %s"), start
, end
);
3107 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3109 while (count
-- > 0)
3115 sb_build (& processed
, one
.len
);
3116 sb_add_sb (& processed
, & one
);
3117 sub
= strstr (processed
.ptr
, expander
);
3118 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3119 gas_assert (len
< 8);
3120 strcpy (sub
+ len
, sub
+ 8);
3121 processed
.len
-= (8 - len
);
3122 sb_add_sb (& many
, & processed
);
3123 sb_kill (& processed
);
3128 sb_add_sb (&many
, &one
);
3132 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3134 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3137 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3138 input buffers to skip. Assumes that conditionals preceding the loop end
3139 are properly nested.
3141 This function makes it easier to implement a premature "break" out of the
3142 loop. The EXTRA arg accounts for other buffers we might have inserted,
3143 such as line substitutions. */
3146 end_repeat (int extra
)
3148 cond_exit_macro (macro_nest
);
3149 while (extra
-- >= 0)
3150 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3154 assign_symbol (char *name
, int mode
)
3158 if (name
[0] == '.' && name
[1] == '\0')
3160 /* Turn '. = mumble' into a .org mumble. */
3164 segment
= get_known_segmented_expression (&exp
);
3167 do_org (segment
, &exp
, 0);
3172 if ((symbolP
= symbol_find (name
)) == NULL
3173 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3175 symbolP
= symbol_find_or_make (name
);
3177 /* When doing symbol listings, play games with dummy fragments living
3178 outside the normal fragment chain to record the file and line info
3180 if (listing
& LISTING_SYMBOLS
)
3182 extern struct list_info_struct
*listing_tail
;
3183 fragS
*dummy_frag
= XCNEW (fragS
);
3184 dummy_frag
->line
= listing_tail
;
3185 dummy_frag
->fr_symbol
= symbolP
;
3186 symbol_set_frag (symbolP
, dummy_frag
);
3189 #if defined (OBJ_COFF) && !defined (TE_PE)
3190 /* "set" symbols are local unless otherwise specified. */
3191 SF_SET_LOCAL (symbolP
);
3195 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3197 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3198 && !S_CAN_BE_REDEFINED (symbolP
))
3200 as_bad (_("symbol `%s' is already defined"), name
);
3201 ignore_rest_of_line ();
3202 input_line_pointer
--;
3205 /* If the symbol is volatile, copy the symbol and replace the
3206 original with the copy, so that previous uses of the symbol will
3207 retain the value of the symbol at the point of use. */
3208 else if (S_IS_VOLATILE (symbolP
))
3209 symbolP
= symbol_clone (symbolP
, 1);
3213 S_SET_VOLATILE (symbolP
);
3215 S_SET_FORWARD_REF (symbolP
);
3217 pseudo_set (symbolP
);
3220 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3221 then this is .equiv, and it is an error if the symbol is already
3222 defined. If EQUIV is -1, the symbol additionally is a forward
3230 /* Especial apologies for the random logic:
3231 this just grew, and could be parsed much more simply!
3233 if ((name
= read_symbol_name ()) == NULL
)
3236 if (*input_line_pointer
!= ',')
3238 as_bad (_("expected comma after \"%s\""), name
);
3239 ignore_rest_of_line ();
3244 input_line_pointer
++;
3245 assign_symbol (name
, equiv
);
3246 demand_empty_rest_of_line ();
3260 #ifdef md_flush_pending_output
3261 md_flush_pending_output ();
3264 #ifdef md_cons_align
3269 stop
= mri_comment_field (&stopc
);
3271 /* In m68k MRI mode, we need to align to a word boundary, unless
3273 if (flag_m68k_mri
&& mult
> 1)
3275 if (now_seg
== absolute_section
)
3277 abs_section_offset
+= abs_section_offset
& 1;
3278 if (line_label
!= NULL
)
3279 S_SET_VALUE (line_label
, abs_section_offset
);
3281 else if (mri_common_symbol
!= NULL
)
3285 mri_val
= S_GET_VALUE (mri_common_symbol
);
3286 if ((mri_val
& 1) != 0)
3288 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3289 if (line_label
!= NULL
)
3291 expressionS
*symexp
;
3293 symexp
= symbol_get_value_expression (line_label
);
3294 know (symexp
->X_op
== O_symbol
);
3295 know (symexp
->X_add_symbol
== mri_common_symbol
);
3296 symexp
->X_add_number
+= 1;
3302 do_align (1, (char *) NULL
, 0, 0);
3303 if (line_label
!= NULL
)
3305 symbol_set_frag (line_label
, frag_now
);
3306 S_SET_VALUE (line_label
, frag_now_fix ());
3316 if (*input_line_pointer
== ',')
3318 ++input_line_pointer
;
3323 val
.X_op
= O_constant
;
3324 val
.X_add_number
= 0;
3327 if ((val
.X_op
!= O_constant
3328 || val
.X_add_number
< - 0x80
3329 || val
.X_add_number
> 0xff
3330 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3331 && (now_seg
!= absolute_section
&& !in_bss ()))
3333 resolve_expression (&exp
);
3334 if (exp
.X_op
!= O_constant
)
3335 as_bad (_("unsupported variable size or fill value"));
3340 /* PR 20901: Check for excessive values.
3341 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3342 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3343 as_bad (_("size value for space directive too large: %lx"),
3344 (long) exp
.X_add_number
);
3349 bytes
= mult
* exp
.X_add_number
;
3351 for (i
= 0; i
< exp
.X_add_number
; i
++)
3352 emit_expr (&val
, mult
);
3358 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3359 resolve_expression (&exp
);
3361 if (exp
.X_op
== O_constant
)
3365 repeat
= exp
.X_add_number
;
3372 as_warn (_(".space repeat count is zero, ignored"));
3373 else if (repeat
< 0)
3374 as_warn (_(".space repeat count is negative, ignored"));
3378 /* If we are in the absolute section, just bump the offset. */
3379 if (now_seg
== absolute_section
)
3381 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3382 as_warn (_("ignoring fill value in absolute section"));
3383 abs_section_offset
+= repeat
;
3387 /* If we are secretly in an MRI common section, then
3388 creating space just increases the size of the common
3390 if (mri_common_symbol
!= NULL
)
3392 S_SET_VALUE (mri_common_symbol
,
3393 S_GET_VALUE (mri_common_symbol
) + repeat
);
3398 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3399 (offsetT
) repeat
, (char *) 0);
3403 if (now_seg
== absolute_section
)
3405 as_bad (_("space allocation too complex in absolute section"));
3406 subseg_set (text_section
, 0);
3409 if (mri_common_symbol
!= NULL
)
3411 as_bad (_("space allocation too complex in common section"));
3412 mri_common_symbol
= NULL
;
3416 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3417 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3420 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3421 as_warn (_("ignoring fill value in section `%s'"),
3422 segment_name (now_seg
));
3424 *p
= val
.X_add_number
;
3429 /* In MRI mode, after an odd number of bytes, we must align to an
3430 even word boundary, unless the next instruction is a dc.b, ds.b
3432 if (flag_mri
&& (bytes
& 1) != 0)
3433 mri_pending_align
= 1;
3435 demand_empty_rest_of_line ();
3438 mri_comment_end (stop
, stopc
);
3442 s_nops (int ignore ATTRIBUTE_UNUSED
)
3447 #ifdef md_flush_pending_output
3448 md_flush_pending_output ();
3451 #ifdef md_cons_align
3457 if (*input_line_pointer
== ',')
3459 ++input_line_pointer
;
3464 val
.X_op
= O_constant
;
3465 val
.X_add_number
= 0;
3468 if (val
.X_op
== O_constant
)
3470 if (val
.X_add_number
< 0)
3472 as_warn (_("negative nop control byte, ignored"));
3473 val
.X_add_number
= 0;
3478 /* Store the no-op instruction control byte in the first byte
3481 symbolS
*sym
= make_expr_symbol (&exp
);
3482 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3483 sym
, (offsetT
) 0, (char *) 0);
3484 *p
= val
.X_add_number
;
3488 as_bad (_("unsupported variable nop control in .nops directive"));
3490 demand_empty_rest_of_line ();
3493 /* This is like s_space, but the value is a floating point number with
3494 the given precision. This is for the MRI dcb.s pseudo-op and
3498 s_float_space (int float_type
)
3502 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3506 #ifdef md_cons_align
3511 stop
= mri_comment_field (&stopc
);
3513 count
= get_absolute_expression ();
3516 if (*input_line_pointer
!= ',')
3518 as_bad (_("missing value"));
3519 ignore_rest_of_line ();
3521 mri_comment_end (stop
, stopc
);
3525 ++input_line_pointer
;
3529 /* Skip any 0{letter} that may be present. Don't even check if the
3530 * letter is legal. */
3531 if (input_line_pointer
[0] == '0'
3532 && ISALPHA (input_line_pointer
[1]))
3533 input_line_pointer
+= 2;
3535 /* Accept :xxxx, where the x's are hex digits, for a floating point
3536 with the exact digits specified. */
3537 if (input_line_pointer
[0] == ':')
3539 flen
= hex_float (float_type
, temp
);
3542 ignore_rest_of_line ();
3544 mri_comment_end (stop
, stopc
);
3552 err
= md_atof (float_type
, temp
, &flen
);
3553 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3554 know (err
!= NULL
|| flen
> 0);
3557 as_bad (_("bad floating literal: %s"), err
);
3558 ignore_rest_of_line ();
3560 mri_comment_end (stop
, stopc
);
3565 while (--count
>= 0)
3569 p
= frag_more (flen
);
3570 memcpy (p
, temp
, (unsigned int) flen
);
3573 demand_empty_rest_of_line ();
3576 mri_comment_end (stop
, stopc
);
3579 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3582 s_struct (int ignore ATTRIBUTE_UNUSED
)
3588 stop
= mri_comment_field (&stopc
);
3589 abs_section_offset
= get_absolute_expression ();
3590 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3591 /* The ELF backend needs to know that we are changing sections, so
3592 that .previous works correctly. */
3594 obj_elf_section_change_hook ();
3596 subseg_set (absolute_section
, 0);
3597 demand_empty_rest_of_line ();
3599 mri_comment_end (stop
, stopc
);
3603 s_text (int ignore ATTRIBUTE_UNUSED
)
3607 temp
= get_absolute_expression ();
3608 subseg_set (text_section
, (subsegT
) temp
);
3609 demand_empty_rest_of_line ();
3612 /* .weakref x, y sets x as an alias to y that, as long as y is not
3613 referenced directly, will cause y to become a weak symbol. */
3615 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3622 if ((name
= read_symbol_name ()) == NULL
)
3625 symbolP
= symbol_find_or_make (name
);
3627 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3629 if (!S_IS_VOLATILE (symbolP
))
3631 as_bad (_("symbol `%s' is already defined"), name
);
3634 symbolP
= symbol_clone (symbolP
, 1);
3635 S_CLEAR_VOLATILE (symbolP
);
3640 if (*input_line_pointer
!= ',')
3642 as_bad (_("expected comma after \"%s\""), name
);
3646 input_line_pointer
++;
3651 if ((name
= read_symbol_name ()) == NULL
)
3654 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3655 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3657 symbolP2
= symbol_find_or_make (name
);
3658 S_SET_WEAKREFD (symbolP2
);
3662 symbolS
*symp
= symbolP2
;
3664 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3666 expressionS
*expP
= symbol_get_value_expression (symp
);
3668 gas_assert (expP
->X_op
== O_symbol
3669 && expP
->X_add_number
== 0);
3670 symp
= expP
->X_add_symbol
;
3672 if (symp
== symbolP
)
3676 loop
= concat (S_GET_NAME (symbolP
),
3677 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3680 while (symp
!= symbolP
)
3682 char *old_loop
= loop
;
3684 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3685 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3686 (const char *) NULL
);
3690 as_bad (_("%s: would close weakref loop: %s"),
3691 S_GET_NAME (symbolP
), loop
);
3695 ignore_rest_of_line ();
3699 /* Short-circuiting instead of just checking here might speed
3700 things up a tiny little bit, but loop error messages would
3701 miss intermediate links. */
3702 /* symbolP2 = symp; */
3705 memset (&exp
, 0, sizeof (exp
));
3706 exp
.X_op
= O_symbol
;
3707 exp
.X_add_symbol
= symbolP2
;
3709 S_SET_SEGMENT (symbolP
, undefined_section
);
3710 symbol_set_value_expression (symbolP
, &exp
);
3711 symbol_set_frag (symbolP
, &zero_address_frag
);
3712 S_SET_WEAKREFR (symbolP
);
3714 demand_empty_rest_of_line ();
3719 ignore_rest_of_line ();
3725 /* Verify that we are at the end of a line. If not, issue an error and
3729 demand_empty_rest_of_line (void)
3732 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3733 input_line_pointer
++;
3736 if (ISPRINT (*input_line_pointer
))
3737 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3738 *input_line_pointer
);
3740 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3741 *input_line_pointer
);
3742 ignore_rest_of_line ();
3745 /* Return pointing just after end-of-line. */
3746 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3749 /* Silently advance to the end of line. Use this after already having
3750 issued an error about something bad. */
3753 ignore_rest_of_line (void)
3755 while (input_line_pointer
< buffer_limit
3756 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3757 input_line_pointer
++;
3759 input_line_pointer
++;
3761 /* Return pointing just after end-of-line. */
3762 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3765 /* Sets frag for given symbol to zero_address_frag, except when the
3766 symbol frag is already set to a dummy listing frag. */
3769 set_zero_frag (symbolS
*symbolP
)
3771 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3772 symbol_set_frag (symbolP
, &zero_address_frag
);
3775 /* In: Pointer to a symbol.
3776 Input_line_pointer->expression.
3778 Out: Input_line_pointer->just after any whitespace after expression.
3779 Tried to set symbol to value of expression.
3780 Will change symbols type, value, and frag; */
3783 pseudo_set (symbolS
*symbolP
)
3788 know (symbolP
); /* NULL pointer is logic error. */
3790 if (!S_IS_FORWARD_REF (symbolP
))
3791 (void) expression (&exp
);
3793 (void) deferred_expression (&exp
);
3795 if (exp
.X_op
== O_illegal
)
3796 as_bad (_("illegal expression"));
3797 else if (exp
.X_op
== O_absent
)
3798 as_bad (_("missing expression"));
3799 else if (exp
.X_op
== O_big
)
3801 if (exp
.X_add_number
> 0)
3802 as_bad (_("bignum invalid"));
3804 as_bad (_("floating point number invalid"));
3806 else if (exp
.X_op
== O_subtract
3807 && !S_IS_FORWARD_REF (symbolP
)
3808 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3809 && (symbol_get_frag (exp
.X_add_symbol
)
3810 == symbol_get_frag (exp
.X_op_symbol
)))
3812 exp
.X_op
= O_constant
;
3813 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3814 - S_GET_VALUE (exp
.X_op_symbol
));
3817 if (symbol_section_p (symbolP
))
3819 as_bad ("attempt to set value of section symbol");
3828 exp
.X_add_number
= 0;
3831 S_SET_SEGMENT (symbolP
, absolute_section
);
3832 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3833 set_zero_frag (symbolP
);
3837 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3838 if (S_IS_EXTERNAL (symbolP
))
3840 as_bad ("can't equate global symbol `%s' with register name",
3841 S_GET_NAME (symbolP
));
3845 S_SET_SEGMENT (symbolP
, reg_section
);
3846 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3847 set_zero_frag (symbolP
);
3848 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3852 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3853 /* For x=undef+const, create an expression symbol.
3854 For x=x+const, just update x except when x is an undefined symbol
3855 For x=defined+const, evaluate x. */
3856 if (symbolP
== exp
.X_add_symbol
3857 && (seg
!= undefined_section
3858 || !symbol_constant_p (symbolP
)))
3860 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3863 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3865 symbolS
*s
= exp
.X_add_symbol
;
3867 if (S_IS_COMMON (s
))
3868 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3869 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3871 S_SET_SEGMENT (symbolP
, seg
);
3872 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3873 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3874 copy_symbol_attributes (symbolP
, s
);
3877 S_SET_SEGMENT (symbolP
, undefined_section
);
3878 symbol_set_value_expression (symbolP
, &exp
);
3879 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3880 set_zero_frag (symbolP
);
3884 /* The value is some complex expression. */
3885 S_SET_SEGMENT (symbolP
, expr_section
);
3886 symbol_set_value_expression (symbolP
, &exp
);
3887 set_zero_frag (symbolP
);
3894 CONStruct more frag of .bytes, or .words etc.
3895 Should need_pass_2 be 1 then emit no frag(s).
3896 This understands EXPRESSIONS.
3900 This has a split personality. We use expression() to read the
3901 value. We can detect if the value won't fit in a byte or word.
3902 But we can't detect if expression() discarded significant digits
3903 in the case of a long. Not worth the crocks required to fix it. */
3905 /* Select a parser for cons expressions. */
3907 /* Some targets need to parse the expression in various fancy ways.
3908 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3909 (for example, the HPPA does this). Otherwise, you can define
3910 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3911 are defined, which is the normal case, then only simple expressions
3916 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3919 #ifndef TC_PARSE_CONS_EXPRESSION
3920 #ifdef REPEAT_CONS_EXPRESSIONS
3921 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3922 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3924 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3927 /* If we haven't gotten one yet, just call expression. */
3928 #ifndef TC_PARSE_CONS_EXPRESSION
3929 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3930 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3935 do_parse_cons_expression (expressionS
*exp
,
3936 int nbytes ATTRIBUTE_UNUSED
)
3938 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3942 /* Worker to do .byte etc statements.
3943 Clobbers input_line_pointer and checks end-of-line. */
3946 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3954 #ifdef md_flush_pending_output
3955 md_flush_pending_output ();
3959 stop
= mri_comment_field (&stopc
);
3961 if (is_it_end_of_statement ())
3963 demand_empty_rest_of_line ();
3965 mri_comment_end (stop
, stopc
);
3969 #ifdef TC_ADDRESS_BYTES
3971 nbytes
= TC_ADDRESS_BYTES ();
3974 #ifdef md_cons_align
3975 md_cons_align (nbytes
);
3981 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
3982 #ifdef TC_CONS_FIX_CHECK
3983 fixS
**cur_fix
= &frchain_now
->fix_tail
;
3985 if (*cur_fix
!= NULL
)
3986 cur_fix
= &(*cur_fix
)->fx_next
;
3991 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3996 if (*input_line_pointer
== '"')
3998 as_bad (_("unexpected `\"' in expression"));
3999 ignore_rest_of_line ();
4003 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4008 if (exp
.X_op
== O_symbol
)
4009 exp
.X_op
= O_symbol_rva
;
4011 as_fatal (_("rva without symbol"));
4013 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4014 #ifdef TC_CONS_FIX_CHECK
4015 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4019 while (*input_line_pointer
++ == ',');
4021 /* In MRI mode, after an odd number of bytes, we must align to an
4022 even word boundary, unless the next instruction is a dc.b, ds.b
4024 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4025 mri_pending_align
= 1;
4027 input_line_pointer
--; /* Put terminator back into stream. */
4029 demand_empty_rest_of_line ();
4032 mri_comment_end (stop
, stopc
);
4038 cons_worker (size
, 0);
4044 cons_worker (size
, 1);
4047 /* .reloc offset, reloc_name, symbol+addend. */
4050 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4057 struct reloc_list
*reloc
;
4058 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4059 static struct _bfd_rel bfd_relocs
[] =
4061 { "NONE", BFD_RELOC_NONE
},
4062 { "8", BFD_RELOC_8
},
4063 { "16", BFD_RELOC_16
},
4064 { "32", BFD_RELOC_32
},
4065 { "64", BFD_RELOC_64
}
4068 reloc
= XNEW (struct reloc_list
);
4071 stop
= mri_comment_field (&stopc
);
4080 as_bad (_("missing or bad offset expression"));
4083 exp
.X_add_symbol
= section_symbol (now_seg
);
4084 exp
.X_op
= O_symbol
;
4087 if (exp
.X_add_number
== 0)
4089 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4094 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4099 if (*input_line_pointer
!= ',')
4101 as_bad (_("missing reloc type"));
4105 ++input_line_pointer
;
4107 c
= get_symbol_name (& r_name
);
4108 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4112 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4113 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4115 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4116 bfd_relocs
[i
].code
);
4121 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4122 *input_line_pointer
= c
;
4123 if (reloc
->u
.a
.howto
== NULL
)
4125 as_bad (_("unrecognized reloc type"));
4129 exp
.X_op
= O_absent
;
4130 SKIP_WHITESPACE_AFTER_NAME ();
4131 if (*input_line_pointer
== ',')
4133 ++input_line_pointer
;
4141 as_bad (_("bad reloc expression"));
4143 ignore_rest_of_line ();
4146 mri_comment_end (stop
, stopc
);
4149 reloc
->u
.a
.sym
= NULL
;
4150 reloc
->u
.a
.addend
= 0;
4153 reloc
->u
.a
.sym
= NULL
;
4154 reloc
->u
.a
.addend
= exp
.X_add_number
;
4157 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4158 reloc
->u
.a
.addend
= exp
.X_add_number
;
4161 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4162 reloc
->u
.a
.addend
= 0;
4166 reloc
->file
= as_where (&reloc
->line
);
4167 reloc
->next
= reloc_list
;
4170 demand_empty_rest_of_line ();
4172 mri_comment_end (stop
, stopc
);
4175 /* Put the contents of expression EXP into the object file using
4176 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4179 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4181 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4185 emit_expr_with_reloc (expressionS
*exp
,
4186 unsigned int nbytes
,
4187 TC_PARSE_CONS_RETURN_TYPE reloc
)
4191 valueT extra_digit
= 0;
4193 /* Don't do anything if we are going to make another pass. */
4198 dot_value
= frag_now_fix ();
4199 dot_frag
= frag_now
;
4203 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4204 appear as a four byte positive constant in the .line section,
4205 followed by a 2 byte 0xffff. Look for that case here. */
4207 static int dwarf_line
= -1;
4209 if (strcmp (segment_name (now_seg
), ".line") != 0)
4211 else if (dwarf_line
>= 0
4213 && exp
->X_op
== O_constant
4214 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4215 listing_source_line ((unsigned int) dwarf_line
);
4216 else if (nbytes
== 4
4217 && exp
->X_op
== O_constant
4218 && exp
->X_add_number
>= 0)
4219 dwarf_line
= exp
->X_add_number
;
4224 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4225 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4226 AT_sibling (0x12) followed by a four byte address of the sibling
4227 followed by a 2 byte AT_name (0x38) followed by the name of the
4228 file. We look for that case here. */
4230 static int dwarf_file
= 0;
4232 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4234 else if (dwarf_file
== 0
4236 && exp
->X_op
== O_constant
4237 && exp
->X_add_number
== 0x11)
4239 else if (dwarf_file
== 1
4241 && exp
->X_op
== O_constant
4242 && exp
->X_add_number
== 0x12)
4244 else if (dwarf_file
== 2
4247 else if (dwarf_file
== 3
4249 && exp
->X_op
== O_constant
4250 && exp
->X_add_number
== 0x38)
4255 /* The variable dwarf_file_string tells stringer that the string
4256 may be the name of the source file. */
4257 if (dwarf_file
== 4)
4258 dwarf_file_string
= 1;
4260 dwarf_file_string
= 0;
4265 if (check_eh_frame (exp
, &nbytes
))
4270 /* Handle a negative bignum. */
4272 && exp
->X_add_number
== 0
4273 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4274 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4277 unsigned long carry
;
4279 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4281 /* Negate the bignum: one's complement each digit and add 1. */
4283 for (i
= 0; i
< exp
->X_add_number
; i
++)
4287 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4290 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4291 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4294 /* We can ignore any carry out, because it will be handled by
4295 extra_digit if it is needed. */
4297 extra_digit
= (valueT
) -1;
4301 if (op
== O_absent
|| op
== O_illegal
)
4303 as_warn (_("zero assumed for missing expression"));
4304 exp
->X_add_number
= 0;
4307 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4309 as_bad (_("floating point number invalid"));
4310 exp
->X_add_number
= 0;
4313 else if (op
== O_register
)
4315 as_warn (_("register value used as expression"));
4319 /* Allow `.word 0' in the absolute section. */
4320 if (now_seg
== absolute_section
)
4322 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4323 as_bad (_("attempt to store value in absolute section"));
4324 abs_section_offset
+= nbytes
;
4328 /* Allow `.word 0' in BSS style sections. */
4329 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4330 as_bad (_("attempt to store non-zero value in section `%s'"),
4331 segment_name (now_seg
));
4333 p
= frag_more ((int) nbytes
);
4335 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4337 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4341 #ifndef WORKING_DOT_WORD
4342 /* If we have the difference of two symbols in a word, save it on
4343 the broken_words list. See the code in write.c. */
4344 if (op
== O_subtract
&& nbytes
== 2)
4346 struct broken_word
*x
;
4348 x
= XNEW (struct broken_word
);
4349 x
->next_broken_word
= broken_words
;
4352 x
->subseg
= now_subseg
;
4354 x
->word_goes_here
= p
;
4356 x
->add
= exp
->X_add_symbol
;
4357 x
->sub
= exp
->X_op_symbol
;
4358 x
->addnum
= exp
->X_add_number
;
4366 /* If we have an integer, but the number of bytes is too large to
4367 pass to md_number_to_chars, handle it as a bignum. */
4368 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4370 extra_digit
= exp
->X_unsigned
? 0 : -1;
4371 convert_to_bignum (exp
, !exp
->X_unsigned
);
4375 if (op
== O_constant
)
4383 /* JF << of >= number of bits in the object is undefined. In
4384 particular SPARC (Sun 4) has problems. */
4385 if (nbytes
>= sizeof (valueT
))
4388 if (nbytes
> sizeof (valueT
))
4391 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4395 /* Don't store these bits. */
4396 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4397 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4400 unmask
= ~mask
; /* Do store these bits. */
4403 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4404 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4407 get
= exp
->X_add_number
;
4409 if ((get
& mask
) != 0
4410 && ((get
& mask
) != mask
4411 || (get
& hibit
) == 0))
4413 /* Leading bits contain both 0s & 1s. */
4414 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4416 as_warn (_("value 0x%llx truncated to 0x%llx"),
4417 (unsigned long long) get
, (unsigned long long) use
);
4419 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4420 (unsigned long long) get
, (unsigned long long) use
);
4423 as_warn (_("value 0x%lx truncated to 0x%lx"),
4424 (unsigned long) get
, (unsigned long) use
);
4427 /* Put bytes in right order. */
4428 md_number_to_chars (p
, use
, (int) nbytes
);
4430 else if (op
== O_big
)
4433 LITTLENUM_TYPE
*nums
;
4435 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4438 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4442 LITTLENUM_TYPE sign
= 0;
4443 if ((generic_bignum
[--i
]
4444 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4445 sign
= ~(LITTLENUM_TYPE
) 0;
4447 while (++i
< exp
->X_add_number
)
4448 if (generic_bignum
[i
] != sign
)
4451 else if (nbytes
== 1)
4453 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4454 Check that bits 8.. of generic_bignum[0] match bit 7
4455 and that they match all of generic_bignum[1..exp->X_add_number]. */
4456 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4457 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4459 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4461 while (++i
< exp
->X_add_number
)
4462 if (generic_bignum
[i
] != sign
)
4467 if (i
< exp
->X_add_number
)
4468 as_warn (ngettext ("bignum truncated to %d byte",
4469 "bignum truncated to %d bytes",
4477 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4480 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4482 if (target_big_endian
)
4484 while (nbytes
> size
)
4486 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4487 nbytes
-= CHARS_PER_LITTLENUM
;
4488 p
+= CHARS_PER_LITTLENUM
;
4491 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4492 while (size
>= CHARS_PER_LITTLENUM
)
4495 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4496 size
-= CHARS_PER_LITTLENUM
;
4497 p
+= CHARS_PER_LITTLENUM
;
4502 nums
= generic_bignum
;
4503 while (size
>= CHARS_PER_LITTLENUM
)
4505 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4507 size
-= CHARS_PER_LITTLENUM
;
4508 p
+= CHARS_PER_LITTLENUM
;
4509 nbytes
-= CHARS_PER_LITTLENUM
;
4512 while (nbytes
>= CHARS_PER_LITTLENUM
)
4514 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4515 nbytes
-= CHARS_PER_LITTLENUM
;
4516 p
+= CHARS_PER_LITTLENUM
;
4521 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4525 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4526 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4529 unsigned int size
= nbytes
;
4531 memset (p
, 0, size
);
4533 /* Generate a fixS to record the symbol value. */
4535 #ifdef TC_CONS_FIX_NEW
4536 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4538 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4540 reloc_howto_type
*reloc_howto
;
4542 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4543 size
= bfd_get_reloc_size (reloc_howto
);
4547 as_bad (ngettext ("%s relocations do not fit in %u byte",
4548 "%s relocations do not fit in %u bytes",
4550 reloc_howto
->name
, nbytes
);
4553 else if (target_big_endian
)
4554 offset
= nbytes
- size
;
4575 as_bad (_("unsupported BFD relocation size %u"), size
);
4578 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4583 /* Handle an MRI style string expression. */
4587 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4589 if (*input_line_pointer
!= '\''
4590 && (input_line_pointer
[1] != '\''
4591 || (*input_line_pointer
!= 'A'
4592 && *input_line_pointer
!= 'E')))
4593 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4597 unsigned int result
= 0;
4599 /* An MRI style string. Cut into as many bytes as will fit into
4600 a nbyte chunk, left justify if necessary, and separate with
4601 commas so we can try again later. */
4602 if (*input_line_pointer
== 'A')
4603 ++input_line_pointer
;
4604 else if (*input_line_pointer
== 'E')
4606 as_bad (_("EBCDIC constants are not supported"));
4607 ++input_line_pointer
;
4610 input_line_pointer
++;
4611 for (scan
= 0; scan
< nbytes
; scan
++)
4613 if (*input_line_pointer
== '\'')
4615 if (input_line_pointer
[1] == '\'')
4617 input_line_pointer
++;
4622 result
= (result
<< 8) | (*input_line_pointer
++);
4626 while (scan
< nbytes
)
4632 /* Create correct expression. */
4633 exp
->X_op
= O_constant
;
4634 exp
->X_add_number
= result
;
4636 /* Fake it so that we can read the next char too. */
4637 if (input_line_pointer
[0] != '\'' ||
4638 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4640 input_line_pointer
-= 2;
4641 input_line_pointer
[0] = ',';
4642 input_line_pointer
[1] = '\'';
4645 input_line_pointer
++;
4648 #endif /* TC_M68K */
4650 #ifdef REPEAT_CONS_EXPRESSIONS
4652 /* Parse a repeat expression for cons. This is used by the MIPS
4653 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4654 object file COUNT times.
4656 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4659 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4666 if (*input_line_pointer
!= ':')
4668 /* No repeat count. */
4672 ++input_line_pointer
;
4673 expression (&count
);
4674 if (count
.X_op
!= O_constant
4675 || count
.X_add_number
<= 0)
4677 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4681 /* The cons function is going to output this expression once. So we
4682 output it count - 1 times. */
4683 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4684 emit_expr (exp
, nbytes
);
4687 #endif /* REPEAT_CONS_EXPRESSIONS */
4689 /* Parse a floating point number represented as a hex constant. This
4690 permits users to specify the exact bits they want in the floating
4694 hex_float (int float_type
, char *bytes
)
4726 as_bad (_("unknown floating type type '%c'"), float_type
);
4730 /* It would be nice if we could go through expression to parse the
4731 hex constant, but if we get a bignum it's a pain to sort it into
4732 the buffer correctly. */
4734 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4738 /* The MRI assembler accepts arbitrary underscores strewn about
4739 through the hex constant, so we ignore them as well. */
4740 if (*input_line_pointer
== '_')
4742 ++input_line_pointer
;
4748 as_warn (_("floating point constant too large"));
4751 d
= hex_value (*input_line_pointer
) << 4;
4752 ++input_line_pointer
;
4753 while (*input_line_pointer
== '_')
4754 ++input_line_pointer
;
4755 if (hex_p (*input_line_pointer
))
4757 d
+= hex_value (*input_line_pointer
);
4758 ++input_line_pointer
;
4760 if (target_big_endian
)
4763 bytes
[length
- i
- 1] = d
;
4769 if (target_big_endian
)
4770 memset (bytes
+ i
, 0, length
- i
);
4772 memset (bytes
, 0, length
- i
);
4780 CONStruct some more frag chars of .floats .ffloats etc.
4781 Makes 0 or more new frags.
4782 If need_pass_2 == 1, no frags are emitted.
4783 This understands only floating literals, not expressions. Sorry.
4785 A floating constant is defined by atof_generic(), except it is preceded
4786 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4787 reading, I decided to be incompatible. This always tries to give you
4788 rounded bits to the precision of the pseudo-op. Former AS did premature
4789 truncation, restored noisy bits instead of trailing 0s AND gave you
4790 a choice of 2 flavours of noise according to which of 2 floating-point
4791 scanners you directed AS to use.
4793 In: input_line_pointer->whitespace before, or '0' of flonum. */
4796 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4797 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4800 int length
; /* Number of chars in an object. */
4801 const char *err
; /* Error from scanning floating literal. */
4802 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4804 if (is_it_end_of_statement ())
4806 demand_empty_rest_of_line ();
4810 if (now_seg
== absolute_section
)
4812 as_bad (_("attempt to store float in absolute section"));
4813 ignore_rest_of_line ();
4819 as_bad (_("attempt to store float in section `%s'"),
4820 segment_name (now_seg
));
4821 ignore_rest_of_line ();
4825 #ifdef md_flush_pending_output
4826 md_flush_pending_output ();
4829 #ifdef md_cons_align
4835 /* input_line_pointer->1st char of a flonum (we hope!). */
4838 /* Skip any 0{letter} that may be present. Don't even check if the
4839 letter is legal. Someone may invent a "z" format and this routine
4840 has no use for such information. Lusers beware: you get
4841 diagnostics if your input is ill-conditioned. */
4842 if (input_line_pointer
[0] == '0'
4843 && ISALPHA (input_line_pointer
[1]))
4844 input_line_pointer
+= 2;
4846 /* Accept :xxxx, where the x's are hex digits, for a floating
4847 point with the exact digits specified. */
4848 if (input_line_pointer
[0] == ':')
4850 ++input_line_pointer
;
4851 length
= hex_float (float_type
, temp
);
4854 ignore_rest_of_line ();
4860 err
= md_atof (float_type
, temp
, &length
);
4861 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4862 know (err
!= NULL
|| length
> 0);
4865 as_bad (_("bad floating literal: %s"), err
);
4866 ignore_rest_of_line ();
4877 #ifdef REPEAT_CONS_EXPRESSIONS
4878 if (*input_line_pointer
== ':')
4880 expressionS count_exp
;
4882 ++input_line_pointer
;
4883 expression (&count_exp
);
4885 if (count_exp
.X_op
!= O_constant
4886 || count_exp
.X_add_number
<= 0)
4887 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4889 count
= count_exp
.X_add_number
;
4893 while (--count
>= 0)
4895 p
= frag_more (length
);
4896 memcpy (p
, temp
, (unsigned int) length
);
4901 while (*input_line_pointer
++ == ',');
4903 /* Put terminator back into stream. */
4904 --input_line_pointer
;
4905 demand_empty_rest_of_line ();
4910 Note - we are using the DWARF standard's definition of LEB128 encoding
4911 where each 7-bit value is a stored in a byte, *not* an octet. This
4912 means that on targets where a byte contains multiple octets there is
4913 a *huge waste of space*. (This also means that we do not have to
4914 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4917 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4918 we would then have to consider whether multiple, successive LEB128
4919 values should be packed into the bytes without padding (bad idea) or
4920 whether each LEB128 number is padded out to a whole number of bytes.
4921 Plus you have to decide on the endianness of packing octets into a
4924 /* Return the size of a LEB128 value in bytes. */
4926 static inline unsigned int
4927 sizeof_sleb128 (offsetT value
)
4934 byte
= (value
& 0x7f);
4935 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4936 Fortunately, we can structure things so that the extra work reduces
4937 to a noop on systems that do things "properly". */
4938 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4941 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4942 || ((value
== -1) && ((byte
& 0x40) != 0))));
4947 static inline unsigned int
4948 sizeof_uleb128 (valueT value
)
4963 sizeof_leb128 (valueT value
, int sign
)
4966 return sizeof_sleb128 ((offsetT
) value
);
4968 return sizeof_uleb128 (value
);
4971 /* Output a LEB128 value. Returns the number of bytes used. */
4973 static inline unsigned int
4974 output_sleb128 (char *p
, offsetT value
)
4981 unsigned byte
= (value
& 0x7f);
4983 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4984 Fortunately, we can structure things so that the extra work reduces
4985 to a noop on systems that do things "properly". */
4986 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4988 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4989 || ((value
== -1) && ((byte
& 0x40) != 0))));
5000 static inline unsigned int
5001 output_uleb128 (char *p
, valueT value
)
5007 unsigned byte
= (value
& 0x7f);
5011 /* More bytes to follow. */
5022 output_leb128 (char *p
, valueT value
, int sign
)
5025 return output_sleb128 (p
, (offsetT
) value
);
5027 return output_uleb128 (p
, value
);
5030 /* Do the same for bignums. We combine sizeof with output here in that
5031 we don't output for NULL values of P. It isn't really as critical as
5032 for "normal" values that this be streamlined. Returns the number of
5035 static inline unsigned int
5036 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5043 /* Strip leading sign extensions off the bignum. */
5045 && bignum
[size
- 1] == LITTLENUM_MASK
5046 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5051 /* OR in the next part of the littlenum. */
5052 val
|= (*bignum
<< loaded
);
5053 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5057 /* Add bytes until there are less than 7 bits left in VAL
5058 or until every non-sign bit has been written. */
5065 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5072 while ((byte
& 0x80) != 0 && loaded
>= 7);
5076 /* Mop up any left-over bits (of which there will be less than 7). */
5077 if ((byte
& 0x80) != 0)
5079 /* Sign-extend VAL. */
5080 if (val
& (1 << (loaded
- 1)))
5081 val
|= ~0U << loaded
;
5090 static inline unsigned int
5091 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5098 /* Strip leading zeros off the bignum. */
5099 /* XXX: Is this needed? */
5100 while (size
> 0 && bignum
[size
- 1] == 0)
5105 if (loaded
< 7 && size
> 0)
5107 val
|= (*bignum
<< loaded
);
5108 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5117 if (size
> 0 || val
)
5124 while (byte
& 0x80);
5130 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5133 return output_big_sleb128 (p
, bignum
, size
);
5135 return output_big_uleb128 (p
, bignum
, size
);
5138 /* Generate the appropriate fragments for a given expression to emit a
5139 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5142 emit_leb128_expr (expressionS
*exp
, int sign
)
5144 operatorT op
= exp
->X_op
;
5145 unsigned int nbytes
;
5147 if (op
== O_absent
|| op
== O_illegal
)
5149 as_warn (_("zero assumed for missing expression"));
5150 exp
->X_add_number
= 0;
5153 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5155 as_bad (_("floating point number invalid"));
5156 exp
->X_add_number
= 0;
5159 else if (op
== O_register
)
5161 as_warn (_("register value used as expression"));
5164 else if (op
== O_constant
5166 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5168 /* We're outputting a signed leb128 and the sign of X_add_number
5169 doesn't reflect the sign of the original value. Convert EXP
5170 to a correctly-extended bignum instead. */
5171 convert_to_bignum (exp
, exp
->X_extrabit
);
5175 if (now_seg
== absolute_section
)
5177 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5178 as_bad (_("attempt to store value in absolute section"));
5179 abs_section_offset
++;
5183 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5184 as_bad (_("attempt to store non-zero value in section `%s'"),
5185 segment_name (now_seg
));
5187 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5188 a signal that this is leb128 data. It shouldn't optimize this away. */
5189 nbytes
= (unsigned int) -1;
5190 if (check_eh_frame (exp
, &nbytes
))
5193 /* Let the backend know that subsequent data may be byte aligned. */
5194 #ifdef md_cons_align
5198 if (op
== O_constant
)
5200 /* If we've got a constant, emit the thing directly right now. */
5202 valueT value
= exp
->X_add_number
;
5206 size
= sizeof_leb128 (value
, sign
);
5207 p
= frag_more (size
);
5208 if (output_leb128 (p
, value
, sign
) > size
)
5211 else if (op
== O_big
)
5213 /* O_big is a different sort of constant. */
5214 int nbr_digits
= exp
->X_add_number
;
5218 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5219 a signed number. Unary operators like - or ~ always extend the
5220 bignum to its largest size. */
5222 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5223 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5224 generic_bignum
[nbr_digits
++] = 0;
5226 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5227 p
= frag_more (size
);
5228 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5233 /* Otherwise, we have to create a variable sized fragment and
5234 resolve things later. */
5236 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5237 make_expr_symbol (exp
), 0, (char *) NULL
);
5241 /* Parse the .sleb128 and .uleb128 pseudos. */
5248 #ifdef md_flush_pending_output
5249 md_flush_pending_output ();
5254 deferred_expression (&exp
);
5255 emit_leb128_expr (&exp
, sign
);
5257 while (*input_line_pointer
++ == ',');
5259 input_line_pointer
--;
5260 demand_empty_rest_of_line ();
5264 stringer_append_char (int c
, int bitsize
)
5267 as_bad (_("attempt to store non-empty string in section `%s'"),
5268 segment_name (now_seg
));
5270 if (!target_big_endian
)
5271 FRAG_APPEND_1_CHAR (c
);
5276 FRAG_APPEND_1_CHAR (0);
5277 FRAG_APPEND_1_CHAR (0);
5278 FRAG_APPEND_1_CHAR (0);
5279 FRAG_APPEND_1_CHAR (0);
5282 FRAG_APPEND_1_CHAR (0);
5283 FRAG_APPEND_1_CHAR (0);
5286 FRAG_APPEND_1_CHAR (0);
5291 /* Called with invalid bitsize argument. */
5295 if (target_big_endian
)
5296 FRAG_APPEND_1_CHAR (c
);
5299 /* Worker to do .ascii etc statements.
5300 Reads 0 or more ',' separated, double-quoted strings.
5301 Caller should have checked need_pass_2 is FALSE because we don't
5303 Checks for end-of-line.
5304 BITS_APPENDZERO says how many bits are in a target char.
5305 The bottom bit is set if a NUL char should be appended to the strings. */
5308 stringer (int bits_appendzero
)
5310 const int bitsize
= bits_appendzero
& ~7;
5311 const int append_zero
= bits_appendzero
& 1;
5313 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5317 #ifdef md_flush_pending_output
5318 md_flush_pending_output ();
5321 #ifdef md_cons_align
5325 /* If we have been switched into the abs_section then we
5326 will not have an obstack onto which we can hang strings. */
5327 if (now_seg
== absolute_section
)
5329 as_bad (_("strings must be placed into a section"));
5330 ignore_rest_of_line ();
5334 /* The following awkward logic is to parse ZERO or more strings,
5335 comma separated. Recall a string expression includes spaces
5336 before the opening '\"' and spaces after the closing '\"'.
5337 We fake a leading ',' if there is (supposed to be)
5338 a 1st, expression. We keep demanding expressions for each ','. */
5339 if (is_it_end_of_statement ())
5341 c
= 0; /* Skip loop. */
5342 ++input_line_pointer
; /* Compensate for end of loop. */
5346 c
= ','; /* Do loop. */
5349 while (c
== ',' || c
== '<' || c
== '"')
5352 switch (*input_line_pointer
)
5355 ++input_line_pointer
; /*->1st char of string. */
5356 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5357 start
= input_line_pointer
;
5360 while (is_a_char (c
= next_char_of_string ()))
5361 stringer_append_char (c
, bitsize
);
5364 stringer_append_char (0, bitsize
);
5366 know (input_line_pointer
[-1] == '\"');
5368 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5369 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5370 will emit .string with a filename in the .debug section
5371 after a sequence of constants. See the comment in
5372 emit_expr for the sequence. emit_expr will set
5373 dwarf_file_string to non-zero if this string might be a
5374 source file name. */
5375 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5376 dwarf_file_string
= 0;
5377 else if (dwarf_file_string
)
5379 c
= input_line_pointer
[-1];
5380 input_line_pointer
[-1] = '\0';
5381 listing_source_file (start
);
5382 input_line_pointer
[-1] = c
;
5388 input_line_pointer
++;
5389 c
= get_single_number ();
5390 stringer_append_char (c
, bitsize
);
5391 if (*input_line_pointer
!= '>')
5392 as_bad (_("expected <nn>"));
5394 input_line_pointer
++;
5397 input_line_pointer
++;
5401 c
= *input_line_pointer
;
5404 demand_empty_rest_of_line ();
5407 /* FIXME-SOMEDAY: I had trouble here on characters with the
5408 high bits set. We'll probably also have trouble with
5409 multibyte chars, wide chars, etc. Also be careful about
5410 returning values bigger than 1 byte. xoxorich. */
5413 next_char_of_string (void)
5417 c
= *input_line_pointer
++ & CHAR_MASK
;
5421 /* PR 20902: Do not advance past the end of the buffer. */
5422 -- input_line_pointer
;
5431 as_warn (_("unterminated string; newline inserted"));
5432 bump_line_counters ();
5435 #ifndef NO_STRING_ESCAPES
5437 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5465 break; /* As itself. */
5481 for (i
= 0, number
= 0;
5482 ISDIGIT (c
) && i
< 3;
5483 c
= *input_line_pointer
++, i
++)
5485 number
= number
* 8 + c
- '0';
5488 c
= number
& CHAR_MASK
;
5490 --input_line_pointer
;
5499 c
= *input_line_pointer
++;
5500 while (ISXDIGIT (c
))
5503 number
= number
* 16 + c
- '0';
5504 else if (ISUPPER (c
))
5505 number
= number
* 16 + c
- 'A' + 10;
5507 number
= number
* 16 + c
- 'a' + 10;
5508 c
= *input_line_pointer
++;
5510 c
= number
& CHAR_MASK
;
5511 --input_line_pointer
;
5516 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5517 as_warn (_("unterminated string; newline inserted"));
5519 bump_line_counters ();
5523 /* Do not advance past the end of the buffer. */
5524 -- input_line_pointer
;
5530 #ifdef ONLY_STANDARD_ESCAPES
5531 as_bad (_("bad escaped character in string"));
5533 #endif /* ONLY_STANDARD_ESCAPES */
5538 #endif /* ! defined (NO_STRING_ESCAPES) */
5547 get_segmented_expression (expressionS
*expP
)
5551 retval
= expression (expP
);
5552 if (expP
->X_op
== O_illegal
5553 || expP
->X_op
== O_absent
5554 || expP
->X_op
== O_big
)
5556 as_bad (_("expected address expression"));
5557 expP
->X_op
= O_constant
;
5558 expP
->X_add_number
= 0;
5559 retval
= absolute_section
;
5565 get_known_segmented_expression (expressionS
*expP
)
5567 segT retval
= get_segmented_expression (expP
);
5569 if (retval
== undefined_section
)
5571 /* There is no easy way to extract the undefined symbol from the
5573 if (expP
->X_add_symbol
!= NULL
5574 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5575 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5576 S_GET_NAME (expP
->X_add_symbol
));
5578 as_warn (_("some symbol undefined; zero assumed"));
5579 retval
= absolute_section
;
5580 expP
->X_op
= O_constant
;
5581 expP
->X_add_number
= 0;
5586 char /* Return terminator. */
5587 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5589 /* FIXME: val_pointer should probably be offsetT *. */
5590 *val_pointer
= (long) get_absolute_expression ();
5591 return (*input_line_pointer
++);
5594 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5595 Give a warning if that happens. */
5598 demand_copy_C_string (int *len_pointer
)
5602 if ((s
= demand_copy_string (len_pointer
)) != 0)
5606 for (len
= *len_pointer
; len
> 0; len
--)
5613 as_bad (_("this string may not contain \'\\0\'"));
5621 /* Demand string, but return a safe (=private) copy of the string.
5622 Return NULL if we can't read a string here. */
5625 demand_copy_string (int *lenP
)
5633 if (*input_line_pointer
== '\"')
5635 input_line_pointer
++; /* Skip opening quote. */
5637 while (is_a_char (c
= next_char_of_string ()))
5639 obstack_1grow (¬es
, c
);
5642 /* JF this next line is so demand_copy_C_string will return a
5643 null terminated string. */
5644 obstack_1grow (¬es
, '\0');
5645 retval
= (char *) obstack_finish (¬es
);
5649 as_bad (_("missing string"));
5651 ignore_rest_of_line ();
5657 /* In: Input_line_pointer->next character.
5659 Do: Skip input_line_pointer over all whitespace.
5661 Out: 1 if input_line_pointer->end-of-line. */
5664 is_it_end_of_statement (void)
5667 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5671 equals (char *sym_name
, int reassign
)
5676 input_line_pointer
++;
5677 if (*input_line_pointer
== '=')
5678 input_line_pointer
++;
5679 if (reassign
< 0 && *input_line_pointer
== '=')
5680 input_line_pointer
++;
5682 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5683 input_line_pointer
++;
5686 stop
= mri_comment_field (&stopc
);
5688 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5692 demand_empty_rest_of_line ();
5693 mri_comment_end (stop
, stopc
);
5697 /* .incbin -- include a file verbatim at the current location. */
5700 s_incbin (int x ATTRIBUTE_UNUSED
)
5711 #ifdef md_flush_pending_output
5712 md_flush_pending_output ();
5715 #ifdef md_cons_align
5720 filename
= demand_copy_string (& len
);
5721 if (filename
== NULL
)
5726 /* Look for optional skip and count. */
5727 if (* input_line_pointer
== ',')
5729 ++ input_line_pointer
;
5730 skip
= get_absolute_expression ();
5734 if (* input_line_pointer
== ',')
5736 ++ input_line_pointer
;
5738 count
= get_absolute_expression ();
5740 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5746 demand_empty_rest_of_line ();
5748 /* Try opening absolute path first, then try include dirs. */
5749 binfile
= fopen (filename
, FOPEN_RB
);
5750 if (binfile
== NULL
)
5754 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5756 for (i
= 0; i
< include_dir_count
; i
++)
5758 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5760 binfile
= fopen (path
, FOPEN_RB
);
5761 if (binfile
!= NULL
)
5765 if (binfile
== NULL
)
5766 as_bad (_("file not found: %s"), filename
);
5769 path
= xstrdup (filename
);
5775 register_dependency (path
);
5777 /* Compute the length of the file. */
5778 if (fseek (binfile
, 0, SEEK_END
) != 0)
5780 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5783 file_len
= ftell (binfile
);
5785 /* If a count was not specified use the remainder of the file. */
5787 count
= file_len
- skip
;
5789 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5791 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5792 skip
, count
, file_len
);
5796 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5798 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5802 /* Allocate frag space and store file contents in it. */
5803 binfrag
= frag_more (count
);
5805 bytes
= fread (binfrag
, 1, count
, binfile
);
5807 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5808 path
, bytes
, count
);
5811 if (binfile
!= NULL
)
5817 /* .include -- include a file at this point. */
5820 s_include (int arg ATTRIBUTE_UNUSED
)
5829 filename
= demand_copy_string (&i
);
5830 if (filename
== NULL
)
5832 /* demand_copy_string has already printed an error and
5833 called ignore_rest_of_line. */
5841 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5842 && *input_line_pointer
!= ' '
5843 && *input_line_pointer
!= '\t')
5845 obstack_1grow (¬es
, *input_line_pointer
);
5846 ++input_line_pointer
;
5850 obstack_1grow (¬es
, '\0');
5851 filename
= (char *) obstack_finish (¬es
);
5852 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5853 ++input_line_pointer
;
5856 demand_empty_rest_of_line ();
5857 path
= XNEWVEC (char, (unsigned long) i
5858 + include_dir_maxlen
+ 5 /* slop */ );
5860 for (i
= 0; i
< include_dir_count
; i
++)
5862 strcpy (path
, include_dirs
[i
]);
5864 strcat (path
, filename
);
5865 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5875 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5876 register_dependency (path
);
5877 input_scrub_insert_file (path
);
5881 add_include_dir (char *path
)
5885 if (include_dir_count
== 0)
5887 include_dirs
= XNEWVEC (const char *, 2);
5888 include_dirs
[0] = "."; /* Current dir. */
5889 include_dir_count
= 2;
5893 include_dir_count
++;
5894 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5898 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5901 if (i
> include_dir_maxlen
)
5902 include_dir_maxlen
= i
;
5905 /* Output debugging information to denote the source file. */
5908 generate_file_debug (void)
5910 if (debug_type
== DEBUG_STABS
)
5911 stabs_generate_asm_file ();
5914 /* Output line number debugging information for the current source line. */
5917 generate_lineno_debug (void)
5921 case DEBUG_UNSPECIFIED
:
5926 stabs_generate_asm_lineno ();
5929 ecoff_generate_asm_lineno ();
5932 /* ??? We could here indicate to dwarf2dbg.c that something
5933 has changed. However, since there is additional backend
5934 support that is required (calling dwarf2_emit_insn), we
5935 let dwarf2dbg.c call as_where on its own. */
5940 /* Output debugging information to mark a function entry point or end point.
5941 END_P is zero for .func, and non-zero for .endfunc. */
5946 do_s_func (end_p
, NULL
);
5949 /* Subroutine of s_func so targets can choose a different default prefix.
5950 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5953 do_s_func (int end_p
, const char *default_prefix
)
5955 /* Record the current function so that we can issue an error message for
5956 misplaced .func,.endfunc, and also so that .endfunc needs no
5958 static char *current_name
;
5959 static char *current_label
;
5963 if (current_name
== NULL
)
5965 as_bad (_("missing .func"));
5966 ignore_rest_of_line ();
5970 if (debug_type
== DEBUG_STABS
)
5971 stabs_generate_asm_endfunc (current_name
, current_label
);
5973 current_name
= current_label
= NULL
;
5978 char delim1
, delim2
;
5980 if (current_name
!= NULL
)
5982 as_bad (_(".endfunc missing for previous .func"));
5983 ignore_rest_of_line ();
5987 delim1
= get_symbol_name (& name
);
5988 name
= xstrdup (name
);
5989 *input_line_pointer
= delim1
;
5990 SKIP_WHITESPACE_AFTER_NAME ();
5991 if (*input_line_pointer
!= ',')
5995 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5996 as_fatal ("%s", xstrerror (errno
));
6000 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6001 /* Missing entry point, use function's name with the leading
6005 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6006 as_fatal ("%s", xstrerror (errno
));
6014 ++input_line_pointer
;
6016 delim2
= get_symbol_name (& label
);
6017 label
= xstrdup (label
);
6018 restore_line_pointer (delim2
);
6021 if (debug_type
== DEBUG_STABS
)
6022 stabs_generate_asm_func (name
, label
);
6024 current_name
= name
;
6025 current_label
= label
;
6028 demand_empty_rest_of_line ();
6031 #ifdef HANDLE_BUNDLE
6034 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6036 unsigned int align
= get_absolute_expression ();
6038 demand_empty_rest_of_line ();
6040 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6041 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6042 (unsigned int) TC_ALIGN_LIMIT
);
6044 if (bundle_lock_frag
!= NULL
)
6046 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6050 bundle_align_p2
= align
;
6054 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6056 demand_empty_rest_of_line ();
6058 if (bundle_align_p2
== 0)
6060 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6064 if (bundle_lock_depth
== 0)
6066 bundle_lock_frchain
= frchain_now
;
6067 bundle_lock_frag
= start_bundle ();
6069 ++bundle_lock_depth
;
6073 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6077 demand_empty_rest_of_line ();
6079 if (bundle_lock_frag
== NULL
)
6081 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6085 gas_assert (bundle_align_p2
> 0);
6087 gas_assert (bundle_lock_depth
> 0);
6088 if (--bundle_lock_depth
> 0)
6091 size
= pending_bundle_size (bundle_lock_frag
);
6093 if (size
> 1U << bundle_align_p2
)
6094 as_bad (_(".bundle_lock sequence is %u bytes, "
6095 "but bundle size is only %u bytes"),
6096 size
, 1u << bundle_align_p2
);
6098 finish_bundle (bundle_lock_frag
, size
);
6100 bundle_lock_frag
= NULL
;
6101 bundle_lock_frchain
= NULL
;
6104 #endif /* HANDLE_BUNDLE */
6107 s_ignore (int arg ATTRIBUTE_UNUSED
)
6109 ignore_rest_of_line ();
6113 read_print_statistics (FILE *file
)
6115 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6118 /* Inserts the given line into the input stream.
6120 This call avoids macro/conditionals nesting checking, since the contents of
6121 the line are assumed to replace the contents of a line already scanned.
6123 An appropriate use of this function would be substitution of input lines when
6124 called by md_start_line_hook(). The given line is assumed to already be
6125 properly scrubbed. */
6128 input_scrub_insert_line (const char *line
)
6131 size_t len
= strlen (line
);
6132 sb_build (&newline
, len
);
6133 sb_add_buffer (&newline
, line
, len
);
6134 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6136 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6139 /* Insert a file into the input stream; the path must resolve to an actual
6140 file; no include path searching or dependency registering is performed. */
6143 input_scrub_insert_file (char *path
)
6145 input_scrub_include_file (path
, input_line_pointer
);
6146 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6149 /* Find the end of a line, considering quotation and escaping of quotes. */
6151 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6152 # define TC_SINGLE_QUOTE_STRINGS 1
6156 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6159 char inquote
= '\0';
6162 while (!is_end_of_line
[(unsigned char) *s
]
6163 || (inquote
&& !ISCNTRL (*s
))
6164 || (inquote
== '\'' && flag_mri
)
6165 #ifdef TC_EOL_IN_INSN
6166 || (insn
&& TC_EOL_IN_INSN (s
))
6168 /* PR 6926: When we are parsing the body of a macro the sequence
6169 \@ is special - it refers to the invocation count. If the @
6170 character happens to be registered as a line-separator character
6171 by the target, then the is_end_of_line[] test above will have
6172 returned true, but we need to ignore the line separating
6173 semantics in this particular case. */
6174 || (in_macro
&& inescape
&& *s
== '@')
6177 if (mri_string
&& *s
== '\'')
6181 else if (*s
== '\\')
6185 #ifdef TC_SINGLE_QUOTE_STRINGS
6186 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6193 as_warn (_("missing closing `%c'"), inquote
);
6194 if (inescape
&& !ignore_input ())
6195 as_warn (_("stray `\\'"));
6200 find_end_of_line (char *s
, int mri_string
)
6202 return _find_end_of_line (s
, mri_string
, 0, 0);
6205 static char *saved_ilp
= NULL
;
6206 static char *saved_limit
;
6208 /* Use BUF as a temporary input pointer for calling other functions in this
6209 file. BUF must be a C string, so that its end can be found by strlen.
6210 Also sets the buffer_limit variable (local to this file) so that buffer
6211 overruns should not occur. Saves the current input line pointer so that
6212 it can be restored by calling restore_ilp().
6214 Does not support recursion.
6216 FIXME: This function is currently only used by stabs.c but that
6217 should be extended to other files in the gas source directory. */
6220 temp_ilp (char *buf
)
6222 gas_assert (saved_ilp
== NULL
);
6223 gas_assert (buf
!= NULL
);
6225 saved_ilp
= input_line_pointer
;
6226 saved_limit
= buffer_limit
;
6227 /* Prevent the assert in restore_ilp from triggering if
6228 the input_line_pointer has not yet been initialised. */
6229 if (saved_ilp
== NULL
)
6230 saved_limit
= saved_ilp
= (char *) "";
6232 input_line_pointer
= buf
;
6233 buffer_limit
= buf
+ strlen (buf
);
6234 input_from_string
= TRUE
;
6237 /* Restore a saved input line pointer. */
6242 gas_assert (saved_ilp
!= NULL
);
6244 input_line_pointer
= saved_ilp
;
6245 buffer_limit
= saved_limit
;
6246 input_from_string
= FALSE
;