1 /* read.c - read a source file -
2 Copyright (C) 1986-2020 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_section_flags (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
,
1056 sizeof (original_case_string
) - 1);
1057 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1061 *s2
= TOLOWER (*s2
);
1066 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1068 /* The MRI assembler uses pseudo-ops without
1070 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
1071 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1076 || (!flag_m68k_mri
&& *s
== '.'))
1080 WARNING: next_char may be end-of-line.
1081 We lookup the pseudo-op table with s+1 because we
1082 already know that the pseudo-op begins with a '.'. */
1085 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1086 if (pop
&& !pop
->poc_handler
)
1089 /* In MRI mode, we may need to insert an
1090 automatic alignment directive. What a hack
1092 if (mri_pending_align
1094 || !((pop
->poc_handler
== cons
1095 && pop
->poc_val
== 1)
1096 || (pop
->poc_handler
== s_space
1097 && pop
->poc_val
== 1)
1098 #ifdef tc_conditional_pseudoop
1099 || tc_conditional_pseudoop (pop
)
1101 || pop
->poc_handler
== s_if
1102 || pop
->poc_handler
== s_ifdef
1103 || pop
->poc_handler
== s_ifc
1104 || pop
->poc_handler
== s_ifeqs
1105 || pop
->poc_handler
== s_else
1106 || pop
->poc_handler
== s_endif
1107 || pop
->poc_handler
== s_globl
1108 || pop
->poc_handler
== s_ignore
)))
1110 do_align (1, (char *) NULL
, 0, 0);
1111 mri_pending_align
= 0;
1113 if (line_label
!= NULL
)
1115 symbol_set_frag (line_label
, frag_now
);
1116 S_SET_VALUE (line_label
, frag_now_fix ());
1120 /* Print the error msg now, while we still can. */
1123 char *end
= input_line_pointer
;
1125 (void) restore_line_pointer (nul_char
);
1127 nul_char
= next_char
= *--input_line_pointer
;
1128 *input_line_pointer
= '\0';
1129 if (! macro_defined
|| ! try_macro (next_char
, s
))
1132 as_bad (_("unknown pseudo-op: `%s'"), s
);
1133 *input_line_pointer
++ = nul_char
;
1138 /* Put it back for error messages etc. */
1139 next_char
= restore_line_pointer (nul_char
);
1140 /* The following skip of whitespace is compulsory.
1141 A well shaped space is sometimes all that separates
1142 keyword from operands. */
1143 if (next_char
== ' ' || next_char
== '\t')
1144 input_line_pointer
++;
1146 /* Input_line is restored.
1147 Input_line_pointer->1st non-blank char
1148 after pseudo-operation. */
1149 (*pop
->poc_handler
) (pop
->poc_val
);
1151 /* If that was .end, just get out now. */
1152 if (pop
->poc_handler
== s_end
)
1157 /* WARNING: next_char may be end-of-line. */
1158 /* Also: input_line_pointer->`\0` where nul_char was. */
1159 (void) restore_line_pointer (nul_char
);
1160 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1161 next_char
= nul_char
= *input_line_pointer
;
1162 *input_line_pointer
= '\0';
1164 generate_lineno_debug ();
1166 if (macro_defined
&& try_macro (next_char
, s
))
1169 if (mri_pending_align
)
1171 do_align (1, (char *) NULL
, 0, 0);
1172 mri_pending_align
= 0;
1173 if (line_label
!= NULL
)
1175 symbol_set_frag (line_label
, frag_now
);
1176 S_SET_VALUE (line_label
, frag_now_fix ());
1180 assemble_one (s
); /* Assemble 1 instruction. */
1182 /* PR 19630: The backend may have set ilp to NULL
1183 if it encountered a catastrophic failure. */
1184 if (input_line_pointer
== NULL
)
1185 as_fatal (_("unable to continue with assembly."));
1187 *input_line_pointer
++ = nul_char
;
1189 /* We resume loop AFTER the end-of-line from
1190 this instruction. */
1196 /* Empty statement? */
1197 if (is_end_of_line
[(unsigned char) next_char
])
1200 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1202 /* local label ("4:") */
1203 char *backup
= input_line_pointer
;
1205 HANDLE_CONDITIONAL_ASSEMBLY (1);
1207 temp
= next_char
- '0';
1209 if (nul_char
== '"')
1210 ++ input_line_pointer
;
1212 /* Read the whole number. */
1213 while (ISDIGIT (*input_line_pointer
))
1215 temp
= (temp
* 10) + *input_line_pointer
- '0';
1216 ++input_line_pointer
;
1219 if (LOCAL_LABELS_DOLLAR
1220 && *input_line_pointer
== '$'
1221 && *(input_line_pointer
+ 1) == ':')
1223 input_line_pointer
+= 2;
1225 if (dollar_label_defined (temp
))
1227 as_fatal (_("label \"%d$\" redefined"), temp
);
1230 define_dollar_label (temp
);
1231 colon (dollar_label_name (temp
, 0));
1236 && *input_line_pointer
++ == ':')
1238 fb_label_instance_inc (temp
);
1239 colon (fb_label_name (temp
, 0));
1243 input_line_pointer
= backup
;
1246 if (next_char
&& strchr (line_comment_chars
, next_char
))
1247 { /* Its a comment. Better say APP or NO_APP. */
1252 unsigned int new_length
;
1255 s
= input_line_pointer
;
1256 if (strncmp (s
, "APP\n", 4))
1259 ignore_rest_of_line ();
1262 bump_line_counters ();
1265 ends
= strstr (s
, "#NO_APP\n");
1269 unsigned int tmp_len
;
1272 /* The end of the #APP wasn't in this buffer. We
1273 keep reading in buffers until we find the #NO_APP
1274 that goes with this #APP There is one. The specs
1276 tmp_len
= buffer_limit
- s
;
1277 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1278 memcpy (tmp_buf
, s
, tmp_len
);
1281 new_tmp
= input_scrub_next_buffer (&buffer
);
1285 buffer_limit
= new_tmp
;
1286 input_line_pointer
= buffer
;
1287 ends
= strstr (buffer
, "#NO_APP\n");
1289 num
= ends
- buffer
;
1291 num
= buffer_limit
- buffer
;
1293 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1294 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1299 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1307 input_line_pointer
= ends
+ 8;
1311 scrub_string_end
= ends
;
1313 new_length
= ends
- s
;
1314 new_buf
= XNEWVEC (char, new_length
);
1321 space
= (new_buf
+ new_length
) - new_tmp
;
1322 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1330 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1331 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
);
1810 s_comm_internal (ignore
, NULL
);
1813 /* The MRI COMMON pseudo-op. We handle this by creating a common
1814 symbol with the appropriate name. We make s_space do the right
1815 thing by increasing the size. */
1818 s_mri_common (int small ATTRIBUTE_UNUSED
)
1834 stop
= mri_comment_field (&stopc
);
1838 name
= input_line_pointer
;
1839 if (!ISDIGIT (*name
))
1840 c
= get_symbol_name (& name
);
1845 ++input_line_pointer
;
1847 while (ISDIGIT (*input_line_pointer
));
1849 c
= *input_line_pointer
;
1850 *input_line_pointer
= '\0';
1852 if (line_label
!= NULL
)
1854 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1855 + (input_line_pointer
- name
) + 1);
1856 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1861 sym
= symbol_find_or_make (name
);
1862 c
= restore_line_pointer (c
);
1865 if (*input_line_pointer
!= ',')
1869 ++input_line_pointer
;
1870 align
= get_absolute_expression ();
1873 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1875 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1876 ignore_rest_of_line ();
1877 mri_comment_end (stop
, stopc
);
1881 S_SET_EXTERNAL (sym
);
1882 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1883 mri_common_symbol
= sym
;
1887 S_SET_ALIGN (sym
, align
);
1892 if (line_label
!= NULL
)
1895 exp
.X_op
= O_symbol
;
1896 exp
.X_add_symbol
= sym
;
1897 exp
.X_add_number
= 0;
1898 symbol_set_value_expression (line_label
, &exp
);
1899 symbol_set_frag (line_label
, &zero_address_frag
);
1900 S_SET_SEGMENT (line_label
, expr_section
);
1903 /* FIXME: We just ignore the small argument, which distinguishes
1904 COMMON and COMMON.S. I don't know what we can do about it. */
1906 /* Ignore the type and hptype. */
1907 if (*input_line_pointer
== ',')
1908 input_line_pointer
+= 2;
1909 if (*input_line_pointer
== ',')
1910 input_line_pointer
+= 2;
1912 demand_empty_rest_of_line ();
1914 mri_comment_end (stop
, stopc
);
1918 s_data (int ignore ATTRIBUTE_UNUSED
)
1923 temp
= get_absolute_expression ();
1924 if (flag_readonly_data_in_text
)
1926 section
= text_section
;
1930 section
= data_section
;
1932 subseg_set (section
, (subsegT
) temp
);
1934 demand_empty_rest_of_line ();
1937 /* Handle the .appfile pseudo-op. This is automatically generated by
1938 do_scrub_chars when a preprocessor # line comment is seen with a
1939 file name. This default definition may be overridden by the object
1940 or CPU specific pseudo-ops. This function is also the default
1941 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1945 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1949 listing_source_file (file
);
1951 register_dependency (file
);
1953 obj_app_file (file
, appfile
);
1958 s_app_file (int appfile
)
1963 /* Some assemblers tolerate immediately following '"'. */
1964 if ((s
= demand_copy_string (&length
)) != 0)
1967 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1969 /* In MRI mode, the preprocessor may have inserted an extraneous
1972 && *input_line_pointer
== '\''
1973 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1974 ++input_line_pointer
;
1976 demand_empty_rest_of_line ();
1978 s_app_file_string (s
, appfile
);
1983 get_linefile_number (int *flag
)
1987 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1990 *flag
= get_absolute_expression ();
1995 /* Handle the .appline pseudo-op. This is automatically generated by
1996 do_scrub_chars when a preprocessor # line comment is seen. This
1997 default definition may be overridden by the object or CPU specific
2001 s_app_line (int appline
)
2006 /* The given number is that of the next line. */
2008 l
= get_absolute_expression ();
2009 else if (!get_linefile_number (&l
))
2011 ignore_rest_of_line ();
2018 /* Some of the back ends can't deal with non-positive line numbers.
2019 Besides, it's silly. GCC however will generate a line number of
2020 zero when it is pre-processing builtins for assembler-with-cpp files:
2024 We do not want to barf on this, especially since such files are used
2025 in the GCC and GDB testsuites. So we check for negative line numbers
2026 rather than non-positive line numbers. */
2027 as_warn (_("line numbers must be positive; line number %d rejected"),
2038 if (*input_line_pointer
== '"')
2039 file
= demand_copy_string (&length
);
2045 while (get_linefile_number (&this_flag
))
2048 /* From GCC's cpp documentation:
2049 1: start of a new file.
2050 2: returning to a file after having included
2052 3: following text comes from a system header file.
2053 4: following text should be treated as extern "C".
2055 4 is nonsensical for the assembler; 3, we don't
2056 care about, so we ignore it just in case a
2057 system header file is included while
2058 preprocessing assembly. So 1 and 2 are all we
2059 care about, and they are mutually incompatible.
2060 new_logical_line_flags() demands this. */
2063 if (flags
&& flags
!= (1 << this_flag
))
2064 as_warn (_("incompatible flag %i in line directive"),
2067 flags
|= 1 << this_flag
;
2072 /* We ignore these. */
2076 as_warn (_("unsupported flag %i in line directive"),
2081 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2086 if (appline
|| file
)
2088 new_logical_line_flags (file
, l
, flags
);
2091 listing_source_line (l
);
2095 if (appline
|| file
)
2096 demand_empty_rest_of_line ();
2098 ignore_rest_of_line ();
2101 /* Handle the .end pseudo-op. Actually, the real work is done in
2102 read_a_source_file. */
2105 s_end (int ignore ATTRIBUTE_UNUSED
)
2109 /* The MRI assembler permits the start symbol to follow .end,
2110 but we don't support that. */
2112 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2113 && *input_line_pointer
!= '*'
2114 && *input_line_pointer
!= '!')
2115 as_warn (_("start address not supported"));
2119 /* Handle the .err pseudo-op. */
2122 s_err (int ignore ATTRIBUTE_UNUSED
)
2124 as_bad (_(".err encountered"));
2125 demand_empty_rest_of_line ();
2128 /* Handle the .error and .warning pseudo-ops. */
2134 /* The purpose for the conditional assignment is not to
2135 internationalize the directive itself, but that we need a
2136 self-contained message, one that can be passed like the
2137 demand_copy_C_string return value, and with no assumption on the
2138 location of the name of the directive within the message. */
2140 = (err
? _(".error directive invoked in source file")
2141 : _(".warning directive invoked in source file"));
2143 if (!is_it_end_of_statement ())
2145 if (*input_line_pointer
!= '\"')
2147 as_bad (_("%s argument must be a string"),
2148 err
? ".error" : ".warning");
2149 ignore_rest_of_line ();
2153 msg
= demand_copy_C_string (&len
);
2161 as_warn ("%s", msg
);
2162 demand_empty_rest_of_line ();
2165 /* Handle the MRI fail pseudo-op. */
2168 s_fail (int ignore ATTRIBUTE_UNUSED
)
2175 stop
= mri_comment_field (&stopc
);
2177 temp
= get_absolute_expression ();
2179 as_warn (_(".fail %ld encountered"), (long) temp
);
2181 as_bad (_(".fail %ld encountered"), (long) temp
);
2183 demand_empty_rest_of_line ();
2186 mri_comment_end (stop
, stopc
);
2190 s_fill (int ignore ATTRIBUTE_UNUSED
)
2192 expressionS rep_exp
;
2197 #ifdef md_flush_pending_output
2198 md_flush_pending_output ();
2201 #ifdef md_cons_align
2205 expression (&rep_exp
);
2206 if (*input_line_pointer
== ',')
2208 input_line_pointer
++;
2209 size
= get_absolute_expression ();
2210 if (*input_line_pointer
== ',')
2212 input_line_pointer
++;
2213 fill
= get_absolute_expression ();
2217 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2218 #define BSD_FILL_SIZE_CROCK_8 (8)
2219 if (size
> BSD_FILL_SIZE_CROCK_8
)
2221 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2222 size
= BSD_FILL_SIZE_CROCK_8
;
2226 as_warn (_("size negative; .fill ignored"));
2229 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2231 if (rep_exp
.X_add_number
< 0)
2232 as_warn (_("repeat < 0; .fill ignored"));
2236 if (size
&& !need_pass_2
)
2238 if (now_seg
== absolute_section
)
2240 if (rep_exp
.X_op
!= O_constant
)
2241 as_bad (_("non-constant fill count for absolute section"));
2242 else if (fill
&& rep_exp
.X_add_number
!= 0)
2243 as_bad (_("attempt to fill absolute section with non-zero value"));
2244 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2247 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2249 as_bad (_("attempt to fill section `%s' with non-zero value"),
2250 segment_name (now_seg
));
2252 if (rep_exp
.X_op
== O_constant
)
2254 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2255 (relax_substateT
) 0, (symbolS
*) 0,
2256 (offsetT
) rep_exp
.X_add_number
,
2261 /* We don't have a constant repeat count, so we can't use
2262 rs_fill. We can get the same results out of rs_space,
2263 but its argument is in bytes, so we must multiply the
2264 repeat count by size. */
2267 rep_sym
= make_expr_symbol (&rep_exp
);
2270 expressionS size_exp
;
2271 size_exp
.X_op
= O_constant
;
2272 size_exp
.X_add_number
= size
;
2274 rep_exp
.X_op
= O_multiply
;
2275 rep_exp
.X_add_symbol
= rep_sym
;
2276 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2277 rep_exp
.X_add_number
= 0;
2278 rep_sym
= make_expr_symbol (&rep_exp
);
2281 p
= frag_var (rs_space
, (int) size
, (int) size
,
2282 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2285 memset (p
, 0, (unsigned int) size
);
2287 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2288 flavoured AS. The following bizarre behaviour is to be
2289 compatible with above. I guess they tried to take up to 8
2290 bytes from a 4-byte expression and they forgot to sign
2292 #define BSD_FILL_SIZE_CROCK_4 (4)
2293 md_number_to_chars (p
, (valueT
) fill
,
2294 (size
> BSD_FILL_SIZE_CROCK_4
2295 ? BSD_FILL_SIZE_CROCK_4
2297 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2298 but emits no error message because it seems a legal thing to do.
2299 It is a degenerate case of .fill but could be emitted by a
2302 demand_empty_rest_of_line ();
2306 s_globl (int ignore ATTRIBUTE_UNUSED
)
2315 stop
= mri_comment_field (&stopc
);
2319 if ((name
= read_symbol_name ()) == NULL
)
2322 symbolP
= symbol_find_or_make (name
);
2323 S_SET_EXTERNAL (symbolP
);
2326 c
= *input_line_pointer
;
2329 input_line_pointer
++;
2331 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2339 demand_empty_rest_of_line ();
2342 mri_comment_end (stop
, stopc
);
2345 /* Handle the MRI IRP and IRPC pseudo-ops. */
2357 file
= as_where (&line
);
2359 eol
= find_end_of_line (input_line_pointer
, 0);
2360 sb_build (&s
, eol
- input_line_pointer
);
2361 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2362 input_line_pointer
= eol
;
2366 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2368 as_bad_where (file
, line
, "%s", err
);
2372 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2374 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2377 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2378 the section to only be linked once. However, this is not supported
2379 by most object file formats. This takes an optional argument,
2380 which is what to do about duplicates. */
2383 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2385 enum linkonce_type type
;
2389 type
= LINKONCE_DISCARD
;
2391 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2396 c
= get_symbol_name (& s
);
2397 if (strcasecmp (s
, "discard") == 0)
2398 type
= LINKONCE_DISCARD
;
2399 else if (strcasecmp (s
, "one_only") == 0)
2400 type
= LINKONCE_ONE_ONLY
;
2401 else if (strcasecmp (s
, "same_size") == 0)
2402 type
= LINKONCE_SAME_SIZE
;
2403 else if (strcasecmp (s
, "same_contents") == 0)
2404 type
= LINKONCE_SAME_CONTENTS
;
2406 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2408 (void) restore_line_pointer (c
);
2411 #ifdef obj_handle_link_once
2412 obj_handle_link_once (type
);
2413 #else /* ! defined (obj_handle_link_once) */
2417 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2418 as_warn (_(".linkonce is not supported for this object file format"));
2420 flags
= bfd_section_flags (now_seg
);
2421 flags
|= SEC_LINK_ONCE
;
2426 case LINKONCE_DISCARD
:
2427 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2429 case LINKONCE_ONE_ONLY
:
2430 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2432 case LINKONCE_SAME_SIZE
:
2433 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2435 case LINKONCE_SAME_CONTENTS
:
2436 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2439 if (!bfd_set_section_flags (now_seg
, flags
))
2440 as_bad (_("bfd_set_section_flags: %s"),
2441 bfd_errmsg (bfd_get_error ()));
2443 #endif /* ! defined (obj_handle_link_once) */
2445 demand_empty_rest_of_line ();
2449 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2452 segT current_seg
= now_seg
;
2453 subsegT current_subseg
= now_subseg
;
2454 segT bss_seg
= bss_section
;
2456 #if defined (TC_MIPS) || defined (TC_ALPHA)
2457 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2458 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2460 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2461 if (size
<= bfd_get_gp_size (stdoutput
))
2463 bss_seg
= subseg_new (".sbss", 1);
2464 seg_info (bss_seg
)->bss
= 1;
2465 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2466 as_warn (_("error setting flags for \".sbss\": %s"),
2467 bfd_errmsg (bfd_get_error ()));
2471 subseg_set (bss_seg
, 1);
2473 if (align
> OCTETS_PER_BYTE_POWER
)
2475 record_alignment (bss_seg
, align
);
2476 frag_align (align
, 0, 0);
2479 /* Detach from old frag. */
2480 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2481 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2483 symbol_set_frag (symbolP
, frag_now
);
2484 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2488 S_SET_SIZE (symbolP
, size
);
2490 S_SET_SEGMENT (symbolP
, bss_seg
);
2493 /* The symbol may already have been created with a preceding
2494 ".globl" directive -- be careful not to step on storage class
2495 in that case. Otherwise, set it to static. */
2496 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2497 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2498 #endif /* OBJ_COFF */
2500 subseg_set (current_seg
, current_subseg
);
2504 parse_align (int align_bytes
)
2510 if (*input_line_pointer
!= ',')
2513 as_bad (_("expected alignment after size"));
2514 ignore_rest_of_line ();
2518 input_line_pointer
++;
2521 align
= get_absolute_expr (&exp
);
2522 if (exp
.X_op
== O_absent
)
2525 if (!exp
.X_unsigned
)
2527 as_warn (_("alignment negative; 0 assumed"));
2531 if (align_bytes
&& align
!= 0)
2533 /* convert to a power of 2 alignment */
2534 unsigned int alignp2
= 0;
2535 while ((align
& 1) == 0)
2536 align
>>= 1, ++alignp2
;
2539 as_bad (_("alignment not a power of 2"));
2540 ignore_rest_of_line ();
2548 /* Called from s_comm_internal after symbol name and size have been
2549 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2550 1 if this was a ".bss" directive which has a 3rd argument
2551 (alignment as a power of 2), or 2 if this was a ".bss" directive
2552 with alignment in bytes. */
2555 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2561 align
= parse_align (needs_align
- 1);
2562 if (align
== (addressT
) -1)
2566 /* Assume some objects may require alignment on some systems. */
2567 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2569 bss_alloc (symbolP
, size
, align
);
2574 s_lcomm (int needs_align
)
2576 s_comm_internal (needs_align
, s_lcomm_internal
);
2580 s_lcomm_bytes (int needs_align
)
2582 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2586 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2592 /* We permit ANY defined expression: BSD4.2 demands constants. */
2593 if ((name
= read_symbol_name ()) == NULL
)
2596 if (*input_line_pointer
!= ',')
2598 as_bad (_("expected comma after \"%s\""), name
);
2602 input_line_pointer
++;
2603 expression_and_evaluate (&exp
);
2605 if (exp
.X_op
!= O_constant
2606 && exp
.X_op
!= O_register
)
2608 as_bad (_("bad expression"));
2612 symbolP
= symbol_find_or_make (name
);
2614 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2616 /* The name might be an undefined .global symbol; be sure to
2617 keep the "external" bit. */
2618 S_SET_SEGMENT (symbolP
,
2619 (exp
.X_op
== O_constant
2622 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2626 as_bad (_("symbol `%s' is already defined"), name
);
2629 demand_empty_rest_of_line ();
2634 ignore_rest_of_line ();
2639 /* Read a line into an sb. Returns the character that ended the line
2640 or zero if there are no more lines. */
2643 get_line_sb (sb
*line
, int in_macro
)
2647 if (input_line_pointer
[-1] == '\n')
2648 bump_line_counters ();
2650 if (input_line_pointer
>= buffer_limit
)
2652 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2653 if (buffer_limit
== 0)
2657 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2658 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2659 input_line_pointer
= eol
;
2661 /* Don't skip multiple end-of-line characters, because that breaks support
2662 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2663 characters but isn't. Instead just skip one end of line character and
2664 return the character skipped so that the caller can re-insert it if
2666 return *input_line_pointer
++;
2670 get_non_macro_line_sb (sb
*line
)
2672 return get_line_sb (line
, 0);
2676 get_macro_line_sb (sb
*line
)
2678 return get_line_sb (line
, 1);
2681 /* Define a macro. This is an interface to macro.c. */
2684 s_macro (int ignore ATTRIBUTE_UNUSED
)
2693 file
= as_where (&line
);
2695 eol
= find_end_of_line (input_line_pointer
, 0);
2696 sb_build (&s
, eol
- input_line_pointer
);
2697 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2698 input_line_pointer
= eol
;
2700 if (line_label
!= NULL
)
2705 name
= S_GET_NAME (line_label
);
2706 len
= strlen (name
);
2707 sb_build (&label
, len
);
2708 sb_add_buffer (&label
, name
, len
);
2709 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2713 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2715 as_bad_where (file
, line
, err
, name
);
2718 if (line_label
!= NULL
)
2720 S_SET_SEGMENT (line_label
, absolute_section
);
2721 S_SET_VALUE (line_label
, 0);
2722 symbol_set_frag (line_label
, &zero_address_frag
);
2725 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2726 && hash_find (po_hash
, name
) != NULL
)
2729 && hash_find (po_hash
, name
+ 1) != NULL
))
2730 as_warn_where (file
,
2732 _("attempt to redefine pseudo-op `%s' ignored"),
2739 /* Handle the .mexit pseudo-op, which immediately exits a macro
2743 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2747 cond_exit_macro (macro_nest
);
2748 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2751 as_warn (_("ignoring macro exit outside a macro definition."));
2754 /* Switch in and out of MRI mode. */
2757 s_mri (int ignore ATTRIBUTE_UNUSED
)
2760 #ifdef MRI_MODE_CHANGE
2764 on
= get_absolute_expression ();
2765 #ifdef MRI_MODE_CHANGE
2766 old_flag
= flag_mri
;
2785 /* Operator precedence changes in m68k MRI mode, so we need to
2786 update the operator rankings. */
2787 expr_set_precedence ();
2789 #ifdef MRI_MODE_CHANGE
2791 MRI_MODE_CHANGE (on
);
2794 demand_empty_rest_of_line ();
2797 /* Handle changing the location counter. */
2800 do_org (segT segment
, expressionS
*exp
, int fill
)
2802 if (segment
!= now_seg
2803 && segment
!= absolute_section
2804 && segment
!= expr_section
)
2805 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2807 if (now_seg
== absolute_section
)
2810 as_warn (_("ignoring fill value in absolute section"));
2811 if (exp
->X_op
!= O_constant
)
2813 as_bad (_("only constant offsets supported in absolute section"));
2814 exp
->X_add_number
= 0;
2816 abs_section_offset
= exp
->X_add_number
;
2821 symbolS
*sym
= exp
->X_add_symbol
;
2822 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2824 if (fill
&& in_bss ())
2825 as_warn (_("ignoring fill value in section `%s'"),
2826 segment_name (now_seg
));
2828 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2830 /* Handle complex expressions. */
2831 sym
= make_expr_symbol (exp
);
2835 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2841 s_org (int ignore ATTRIBUTE_UNUSED
)
2847 #ifdef md_flush_pending_output
2848 md_flush_pending_output ();
2851 /* The m68k MRI assembler has a different meaning for .org. It
2852 means to create an absolute section at a given address. We can't
2853 support that--use a linker script instead. */
2856 as_bad (_("MRI style ORG pseudo-op not supported"));
2857 ignore_rest_of_line ();
2861 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2862 thing as a sub-segment-relative origin. Any absolute origin is
2863 given a warning, then assumed to be segment-relative. Any
2864 segmented origin expression ("foo+42") had better be in the right
2865 segment or the .org is ignored.
2867 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2868 we never know sub-segment sizes when we are reading code. BSD
2869 will crash trying to emit negative numbers of filler bytes in
2870 certain .orgs. We don't crash, but see as-write for that code.
2872 Don't make frag if need_pass_2==1. */
2873 segment
= get_known_segmented_expression (&exp
);
2874 if (*input_line_pointer
== ',')
2876 input_line_pointer
++;
2877 temp_fill
= get_absolute_expression ();
2883 do_org (segment
, &exp
, temp_fill
);
2885 demand_empty_rest_of_line ();
2888 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2889 called by the obj-format routine which handles section changing
2890 when in MRI mode. It will create a new section, and return it. It
2891 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2892 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2895 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2905 name
= input_line_pointer
;
2906 if (!ISDIGIT (*name
))
2907 c
= get_symbol_name (& name
);
2912 ++input_line_pointer
;
2914 while (ISDIGIT (*input_line_pointer
));
2916 c
= *input_line_pointer
;
2917 *input_line_pointer
= '\0';
2920 name
= xstrdup (name
);
2922 c
= restore_line_pointer (c
);
2924 seg
= subseg_new (name
, 0);
2930 ++input_line_pointer
;
2931 align
= get_absolute_expression ();
2932 record_alignment (seg
, align
);
2936 if (*input_line_pointer
== ',')
2938 c
= *++input_line_pointer
;
2940 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2943 as_bad (_("unrecognized section type"));
2944 ++input_line_pointer
;
2949 flags
= SEC_NO_FLAGS
;
2951 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2952 else if (*type
== 'D' || *type
== 'M')
2953 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2954 else if (*type
== 'R')
2955 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2956 if (flags
!= SEC_NO_FLAGS
)
2958 if (!bfd_set_section_flags (seg
, flags
))
2959 as_warn (_("error setting flags for \"%s\": %s"),
2960 bfd_section_name (seg
),
2961 bfd_errmsg (bfd_get_error ()));
2966 /* Ignore the HP type. */
2967 if (*input_line_pointer
== ',')
2968 input_line_pointer
+= 2;
2970 demand_empty_rest_of_line ();
2972 #else /* ! TC_M68K */
2973 /* The MRI assembler seems to use different forms of .sect for
2974 different targets. */
2975 as_bad ("MRI mode not supported for this target");
2976 ignore_rest_of_line ();
2977 #endif /* ! TC_M68K */
2980 /* Handle the .print pseudo-op. */
2983 s_print (int ignore ATTRIBUTE_UNUSED
)
2988 s
= demand_copy_C_string (&len
);
2991 demand_empty_rest_of_line ();
2994 /* Handle the .purgem pseudo-op. */
2997 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2999 if (is_it_end_of_statement ())
3001 demand_empty_rest_of_line ();
3011 c
= get_symbol_name (& name
);
3012 delete_macro (name
);
3013 *input_line_pointer
= c
;
3014 SKIP_WHITESPACE_AFTER_NAME ();
3016 while (*input_line_pointer
++ == ',');
3018 --input_line_pointer
;
3019 demand_empty_rest_of_line ();
3022 /* Handle the .endm/.endr pseudo-ops. */
3025 s_bad_end (int endr
)
3027 as_warn (_(".end%c encountered without preceding %s"),
3029 endr
? ".rept, .irp, or .irpc" : ".macro");
3030 demand_empty_rest_of_line ();
3033 /* Handle the .rept pseudo-op. */
3036 s_rept (int ignore ATTRIBUTE_UNUSED
)
3040 count
= (size_t) get_absolute_expression ();
3042 do_repeat (count
, "REPT", "ENDR");
3045 /* This function provides a generic repeat block implementation. It allows
3046 different directives to be used as the start/end keys. */
3049 do_repeat (size_t count
, const char *start
, const char *end
)
3054 if (((ssize_t
) count
) < 0)
3056 as_bad (_("negative count for %s - ignored"), start
);
3061 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3063 as_bad (_("%s without %s"), start
, end
);
3067 sb_build (&many
, count
* one
.len
);
3069 sb_add_sb (&many
, &one
);
3073 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3075 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3078 /* Like do_repeat except that any text matching EXPANDER in the
3079 block is replaced by the iteration count. */
3082 do_repeat_with_expander (size_t count
,
3085 const char * expander
)
3090 if (((ssize_t
) count
) < 0)
3092 as_bad (_("negative count for %s - ignored"), start
);
3097 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3099 as_bad (_("%s without %s"), start
, end
);
3105 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3107 while (count
-- > 0)
3113 sb_build (& processed
, one
.len
);
3114 sb_add_sb (& processed
, & one
);
3115 sub
= strstr (processed
.ptr
, expander
);
3116 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3117 gas_assert (len
< 8);
3118 memmove (sub
+ len
, sub
+ 8,
3119 processed
.ptr
+ processed
.len
- (sub
+ 8));
3120 processed
.len
-= (8 - len
);
3121 sb_add_sb (& many
, & processed
);
3122 sb_kill (& processed
);
3127 sb_add_sb (&many
, &one
);
3131 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3133 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3136 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3137 input buffers to skip. Assumes that conditionals preceding the loop end
3138 are properly nested.
3140 This function makes it easier to implement a premature "break" out of the
3141 loop. The EXTRA arg accounts for other buffers we might have inserted,
3142 such as line substitutions. */
3145 end_repeat (int extra
)
3147 cond_exit_macro (macro_nest
);
3148 while (extra
-- >= 0)
3149 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3153 assign_symbol (char *name
, int mode
)
3157 if (name
[0] == '.' && name
[1] == '\0')
3159 /* Turn '. = mumble' into a .org mumble. */
3163 segment
= get_known_segmented_expression (&exp
);
3166 do_org (segment
, &exp
, 0);
3171 if ((symbolP
= symbol_find (name
)) == NULL
3172 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3174 symbolP
= symbol_find_or_make (name
);
3176 /* When doing symbol listings, play games with dummy fragments living
3177 outside the normal fragment chain to record the file and line info
3179 if (listing
& LISTING_SYMBOLS
)
3181 extern struct list_info_struct
*listing_tail
;
3182 fragS
*dummy_frag
= XCNEW (fragS
);
3183 dummy_frag
->line
= listing_tail
;
3184 dummy_frag
->fr_symbol
= symbolP
;
3185 symbol_set_frag (symbolP
, dummy_frag
);
3188 #if defined (OBJ_COFF) && !defined (TE_PE)
3189 /* "set" symbols are local unless otherwise specified. */
3190 SF_SET_LOCAL (symbolP
);
3194 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3196 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3197 && !S_CAN_BE_REDEFINED (symbolP
))
3199 as_bad (_("symbol `%s' is already defined"), name
);
3200 ignore_rest_of_line ();
3201 input_line_pointer
--;
3204 /* If the symbol is volatile, copy the symbol and replace the
3205 original with the copy, so that previous uses of the symbol will
3206 retain the value of the symbol at the point of use. */
3207 else if (S_IS_VOLATILE (symbolP
))
3208 symbolP
= symbol_clone (symbolP
, 1);
3212 S_SET_VOLATILE (symbolP
);
3214 S_SET_FORWARD_REF (symbolP
);
3216 pseudo_set (symbolP
);
3219 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3220 then this is .equiv, and it is an error if the symbol is already
3221 defined. If EQUIV is -1, the symbol additionally is a forward
3229 /* Especial apologies for the random logic:
3230 this just grew, and could be parsed much more simply!
3232 if ((name
= read_symbol_name ()) == NULL
)
3235 if (*input_line_pointer
!= ',')
3237 as_bad (_("expected comma after \"%s\""), name
);
3238 ignore_rest_of_line ();
3243 input_line_pointer
++;
3244 assign_symbol (name
, equiv
);
3245 demand_empty_rest_of_line ();
3259 #ifdef md_flush_pending_output
3260 md_flush_pending_output ();
3263 #ifdef md_cons_align
3268 stop
= mri_comment_field (&stopc
);
3270 /* In m68k MRI mode, we need to align to a word boundary, unless
3272 if (flag_m68k_mri
&& mult
> 1)
3274 if (now_seg
== absolute_section
)
3276 abs_section_offset
+= abs_section_offset
& 1;
3277 if (line_label
!= NULL
)
3278 S_SET_VALUE (line_label
, abs_section_offset
);
3280 else if (mri_common_symbol
!= NULL
)
3284 mri_val
= S_GET_VALUE (mri_common_symbol
);
3285 if ((mri_val
& 1) != 0)
3287 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3288 if (line_label
!= NULL
)
3290 expressionS
*symexp
;
3292 symexp
= symbol_get_value_expression (line_label
);
3293 know (symexp
->X_op
== O_symbol
);
3294 know (symexp
->X_add_symbol
== mri_common_symbol
);
3295 symexp
->X_add_number
+= 1;
3301 do_align (1, (char *) NULL
, 0, 0);
3302 if (line_label
!= NULL
)
3304 symbol_set_frag (line_label
, frag_now
);
3305 S_SET_VALUE (line_label
, frag_now_fix ());
3315 if (*input_line_pointer
== ',')
3317 ++input_line_pointer
;
3322 val
.X_op
= O_constant
;
3323 val
.X_add_number
= 0;
3326 if ((val
.X_op
!= O_constant
3327 || val
.X_add_number
< - 0x80
3328 || val
.X_add_number
> 0xff
3329 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3330 && (now_seg
!= absolute_section
&& !in_bss ()))
3332 resolve_expression (&exp
);
3333 if (exp
.X_op
!= O_constant
)
3334 as_bad (_("unsupported variable size or fill value"));
3339 /* PR 20901: Check for excessive values.
3340 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3341 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3342 as_bad (_("size value for space directive too large: %lx"),
3343 (long) exp
.X_add_number
);
3348 bytes
= mult
* exp
.X_add_number
;
3350 for (i
= 0; i
< exp
.X_add_number
; i
++)
3351 emit_expr (&val
, mult
);
3357 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3358 resolve_expression (&exp
);
3360 if (exp
.X_op
== O_constant
)
3364 repeat
= exp
.X_add_number
;
3371 as_warn (_(".space repeat count is zero, ignored"));
3372 else if (repeat
< 0)
3373 as_warn (_(".space repeat count is negative, ignored"));
3377 /* If we are in the absolute section, just bump the offset. */
3378 if (now_seg
== absolute_section
)
3380 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3381 as_warn (_("ignoring fill value in absolute section"));
3382 abs_section_offset
+= repeat
;
3386 /* If we are secretly in an MRI common section, then
3387 creating space just increases the size of the common
3389 if (mri_common_symbol
!= NULL
)
3391 S_SET_VALUE (mri_common_symbol
,
3392 S_GET_VALUE (mri_common_symbol
) + repeat
);
3397 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3398 (offsetT
) repeat
, (char *) 0);
3402 if (now_seg
== absolute_section
)
3404 as_bad (_("space allocation too complex in absolute section"));
3405 subseg_set (text_section
, 0);
3408 if (mri_common_symbol
!= NULL
)
3410 as_bad (_("space allocation too complex in common section"));
3411 mri_common_symbol
= NULL
;
3415 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3416 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3419 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3420 as_warn (_("ignoring fill value in section `%s'"),
3421 segment_name (now_seg
));
3423 *p
= val
.X_add_number
;
3428 /* In MRI mode, after an odd number of bytes, we must align to an
3429 even word boundary, unless the next instruction is a dc.b, ds.b
3431 if (flag_mri
&& (bytes
& 1) != 0)
3432 mri_pending_align
= 1;
3434 demand_empty_rest_of_line ();
3437 mri_comment_end (stop
, stopc
);
3441 s_nops (int ignore ATTRIBUTE_UNUSED
)
3446 #ifdef md_flush_pending_output
3447 md_flush_pending_output ();
3450 #ifdef md_cons_align
3456 if (*input_line_pointer
== ',')
3458 ++input_line_pointer
;
3463 val
.X_op
= O_constant
;
3464 val
.X_add_number
= 0;
3467 if (val
.X_op
== O_constant
)
3469 if (val
.X_add_number
< 0)
3471 as_warn (_("negative nop control byte, ignored"));
3472 val
.X_add_number
= 0;
3477 /* Store the no-op instruction control byte in the first byte
3480 symbolS
*sym
= make_expr_symbol (&exp
);
3481 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3482 sym
, (offsetT
) 0, (char *) 0);
3483 *p
= val
.X_add_number
;
3487 as_bad (_("unsupported variable nop control in .nops directive"));
3489 demand_empty_rest_of_line ();
3492 /* This is like s_space, but the value is a floating point number with
3493 the given precision. This is for the MRI dcb.s pseudo-op and
3497 s_float_space (int float_type
)
3501 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3505 #ifdef md_cons_align
3510 stop
= mri_comment_field (&stopc
);
3512 count
= get_absolute_expression ();
3515 if (*input_line_pointer
!= ',')
3517 as_bad (_("missing value"));
3518 ignore_rest_of_line ();
3520 mri_comment_end (stop
, stopc
);
3524 ++input_line_pointer
;
3528 /* Skip any 0{letter} that may be present. Don't even check if the
3529 * letter is legal. */
3530 if (input_line_pointer
[0] == '0'
3531 && ISALPHA (input_line_pointer
[1]))
3532 input_line_pointer
+= 2;
3534 /* Accept :xxxx, where the x's are hex digits, for a floating point
3535 with the exact digits specified. */
3536 if (input_line_pointer
[0] == ':')
3538 flen
= hex_float (float_type
, temp
);
3541 ignore_rest_of_line ();
3543 mri_comment_end (stop
, stopc
);
3551 err
= md_atof (float_type
, temp
, &flen
);
3552 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3553 know (err
!= NULL
|| flen
> 0);
3556 as_bad (_("bad floating literal: %s"), err
);
3557 ignore_rest_of_line ();
3559 mri_comment_end (stop
, stopc
);
3564 while (--count
>= 0)
3568 p
= frag_more (flen
);
3569 memcpy (p
, temp
, (unsigned int) flen
);
3572 demand_empty_rest_of_line ();
3575 mri_comment_end (stop
, stopc
);
3578 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3581 s_struct (int ignore ATTRIBUTE_UNUSED
)
3587 stop
= mri_comment_field (&stopc
);
3588 abs_section_offset
= get_absolute_expression ();
3589 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3590 /* The ELF backend needs to know that we are changing sections, so
3591 that .previous works correctly. */
3593 obj_elf_section_change_hook ();
3595 subseg_set (absolute_section
, 0);
3596 demand_empty_rest_of_line ();
3598 mri_comment_end (stop
, stopc
);
3602 s_text (int ignore ATTRIBUTE_UNUSED
)
3606 temp
= get_absolute_expression ();
3607 subseg_set (text_section
, (subsegT
) temp
);
3608 demand_empty_rest_of_line ();
3611 /* .weakref x, y sets x as an alias to y that, as long as y is not
3612 referenced directly, will cause y to become a weak symbol. */
3614 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3621 if ((name
= read_symbol_name ()) == NULL
)
3624 symbolP
= symbol_find_or_make (name
);
3626 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3628 if (!S_IS_VOLATILE (symbolP
))
3630 as_bad (_("symbol `%s' is already defined"), name
);
3633 symbolP
= symbol_clone (symbolP
, 1);
3634 S_CLEAR_VOLATILE (symbolP
);
3639 if (*input_line_pointer
!= ',')
3641 as_bad (_("expected comma after \"%s\""), name
);
3645 input_line_pointer
++;
3650 if ((name
= read_symbol_name ()) == NULL
)
3653 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3654 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3656 symbolP2
= symbol_find_or_make (name
);
3657 S_SET_WEAKREFD (symbolP2
);
3661 symbolS
*symp
= symbolP2
;
3663 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3665 expressionS
*expP
= symbol_get_value_expression (symp
);
3667 gas_assert (expP
->X_op
== O_symbol
3668 && expP
->X_add_number
== 0);
3669 symp
= expP
->X_add_symbol
;
3671 if (symp
== symbolP
)
3675 loop
= concat (S_GET_NAME (symbolP
),
3676 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3679 while (symp
!= symbolP
)
3681 char *old_loop
= loop
;
3683 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3684 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3685 (const char *) NULL
);
3689 as_bad (_("%s: would close weakref loop: %s"),
3690 S_GET_NAME (symbolP
), loop
);
3694 ignore_rest_of_line ();
3698 /* Short-circuiting instead of just checking here might speed
3699 things up a tiny little bit, but loop error messages would
3700 miss intermediate links. */
3701 /* symbolP2 = symp; */
3704 memset (&exp
, 0, sizeof (exp
));
3705 exp
.X_op
= O_symbol
;
3706 exp
.X_add_symbol
= symbolP2
;
3708 S_SET_SEGMENT (symbolP
, undefined_section
);
3709 symbol_set_value_expression (symbolP
, &exp
);
3710 symbol_set_frag (symbolP
, &zero_address_frag
);
3711 S_SET_WEAKREFR (symbolP
);
3713 demand_empty_rest_of_line ();
3718 ignore_rest_of_line ();
3724 /* Verify that we are at the end of a line. If not, issue an error and
3728 demand_empty_rest_of_line (void)
3731 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3732 input_line_pointer
++;
3735 if (ISPRINT (*input_line_pointer
))
3736 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3737 *input_line_pointer
);
3739 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3740 *input_line_pointer
);
3741 ignore_rest_of_line ();
3744 /* Return pointing just after end-of-line. */
3745 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3748 /* Silently advance to the end of line. Use this after already having
3749 issued an error about something bad. */
3752 ignore_rest_of_line (void)
3754 while (input_line_pointer
< buffer_limit
3755 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3756 input_line_pointer
++;
3758 input_line_pointer
++;
3760 /* Return pointing just after end-of-line. */
3761 if (input_line_pointer
<= buffer_limit
)
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 ();
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 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5367 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5368 will emit .string with a filename in the .debug section
5369 after a sequence of constants. See the comment in
5370 emit_expr for the sequence. emit_expr will set
5371 dwarf_file_string to non-zero if this string might be a
5372 source file name. */
5373 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5374 dwarf_file_string
= 0;
5375 else if (dwarf_file_string
)
5377 c
= input_line_pointer
[-1];
5378 input_line_pointer
[-1] = '\0';
5379 listing_source_file (start
);
5380 input_line_pointer
[-1] = c
;
5386 input_line_pointer
++;
5387 c
= get_single_number ();
5388 stringer_append_char (c
, bitsize
);
5389 if (*input_line_pointer
!= '>')
5391 as_bad (_("expected <nn>"));
5392 ignore_rest_of_line ();
5395 input_line_pointer
++;
5398 input_line_pointer
++;
5402 c
= *input_line_pointer
;
5405 demand_empty_rest_of_line ();
5408 /* FIXME-SOMEDAY: I had trouble here on characters with the
5409 high bits set. We'll probably also have trouble with
5410 multibyte chars, wide chars, etc. Also be careful about
5411 returning values bigger than 1 byte. xoxorich. */
5414 next_char_of_string (void)
5418 c
= *input_line_pointer
++ & CHAR_MASK
;
5422 /* PR 20902: Do not advance past the end of the buffer. */
5423 -- input_line_pointer
;
5432 as_warn (_("unterminated string; newline inserted"));
5433 bump_line_counters ();
5437 if (!TC_STRING_ESCAPES
)
5439 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5467 break; /* As itself. */
5483 for (i
= 0, number
= 0;
5484 ISDIGIT (c
) && i
< 3;
5485 c
= *input_line_pointer
++, i
++)
5487 number
= number
* 8 + c
- '0';
5490 c
= number
& CHAR_MASK
;
5492 --input_line_pointer
;
5501 c
= *input_line_pointer
++;
5502 while (ISXDIGIT (c
))
5505 number
= number
* 16 + c
- '0';
5506 else if (ISUPPER (c
))
5507 number
= number
* 16 + c
- 'A' + 10;
5509 number
= number
* 16 + c
- 'a' + 10;
5510 c
= *input_line_pointer
++;
5512 c
= number
& CHAR_MASK
;
5513 --input_line_pointer
;
5518 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5519 as_warn (_("unterminated string; newline inserted"));
5521 bump_line_counters ();
5525 /* Do not advance past the end of the buffer. */
5526 -- input_line_pointer
;
5532 #ifdef ONLY_STANDARD_ESCAPES
5533 as_bad (_("bad escaped character in string"));
5535 #endif /* ONLY_STANDARD_ESCAPES */
5548 get_segmented_expression (expressionS
*expP
)
5552 retval
= expression (expP
);
5553 if (expP
->X_op
== O_illegal
5554 || expP
->X_op
== O_absent
5555 || expP
->X_op
== O_big
)
5557 as_bad (_("expected address expression"));
5558 expP
->X_op
= O_constant
;
5559 expP
->X_add_number
= 0;
5560 retval
= absolute_section
;
5566 get_known_segmented_expression (expressionS
*expP
)
5568 segT retval
= get_segmented_expression (expP
);
5570 if (retval
== undefined_section
)
5572 /* There is no easy way to extract the undefined symbol from the
5574 if (expP
->X_add_symbol
!= NULL
5575 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5576 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5577 S_GET_NAME (expP
->X_add_symbol
));
5579 as_warn (_("some symbol undefined; zero assumed"));
5580 retval
= absolute_section
;
5581 expP
->X_op
= O_constant
;
5582 expP
->X_add_number
= 0;
5587 char /* Return terminator. */
5588 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5590 /* FIXME: val_pointer should probably be offsetT *. */
5591 *val_pointer
= (long) get_absolute_expression ();
5592 return (*input_line_pointer
++);
5595 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5596 Give a warning if that happens. */
5599 demand_copy_C_string (int *len_pointer
)
5603 if ((s
= demand_copy_string (len_pointer
)) != 0)
5607 for (len
= *len_pointer
; len
> 0; len
--)
5614 as_bad (_("this string may not contain \'\\0\'"));
5622 /* Demand string, but return a safe (=private) copy of the string.
5623 Return NULL if we can't read a string here. */
5626 demand_copy_string (int *lenP
)
5634 if (*input_line_pointer
== '\"')
5636 input_line_pointer
++; /* Skip opening quote. */
5638 while (is_a_char (c
= next_char_of_string ()))
5640 obstack_1grow (¬es
, c
);
5643 /* JF this next line is so demand_copy_C_string will return a
5644 null terminated string. */
5645 obstack_1grow (¬es
, '\0');
5646 retval
= (char *) obstack_finish (¬es
);
5650 as_bad (_("missing string"));
5652 ignore_rest_of_line ();
5658 /* In: Input_line_pointer->next character.
5660 Do: Skip input_line_pointer over all whitespace.
5662 Out: 1 if input_line_pointer->end-of-line. */
5665 is_it_end_of_statement (void)
5668 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5672 equals (char *sym_name
, int reassign
)
5677 input_line_pointer
++;
5678 if (*input_line_pointer
== '=')
5679 input_line_pointer
++;
5680 if (reassign
< 0 && *input_line_pointer
== '=')
5681 input_line_pointer
++;
5683 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5684 input_line_pointer
++;
5687 stop
= mri_comment_field (&stopc
);
5689 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5693 demand_empty_rest_of_line ();
5694 mri_comment_end (stop
, stopc
);
5698 /* .incbin -- include a file verbatim at the current location. */
5701 s_incbin (int x ATTRIBUTE_UNUSED
)
5712 #ifdef md_flush_pending_output
5713 md_flush_pending_output ();
5716 #ifdef md_cons_align
5721 filename
= demand_copy_string (& len
);
5722 if (filename
== NULL
)
5727 /* Look for optional skip and count. */
5728 if (* input_line_pointer
== ',')
5730 ++ input_line_pointer
;
5731 skip
= get_absolute_expression ();
5735 if (* input_line_pointer
== ',')
5737 ++ input_line_pointer
;
5739 count
= get_absolute_expression ();
5741 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5747 demand_empty_rest_of_line ();
5749 /* Try opening absolute path first, then try include dirs. */
5750 binfile
= fopen (filename
, FOPEN_RB
);
5751 if (binfile
== NULL
)
5755 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5757 for (i
= 0; i
< include_dir_count
; i
++)
5759 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5761 binfile
= fopen (path
, FOPEN_RB
);
5762 if (binfile
!= NULL
)
5766 if (binfile
== NULL
)
5767 as_bad (_("file not found: %s"), filename
);
5770 path
= xstrdup (filename
);
5776 register_dependency (path
);
5778 /* Compute the length of the file. */
5779 if (fseek (binfile
, 0, SEEK_END
) != 0)
5781 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5784 file_len
= ftell (binfile
);
5786 /* If a count was not specified use the remainder of the file. */
5788 count
= file_len
- skip
;
5790 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5792 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5793 skip
, count
, file_len
);
5797 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5799 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5803 /* Allocate frag space and store file contents in it. */
5804 binfrag
= frag_more (count
);
5806 bytes
= fread (binfrag
, 1, count
, binfile
);
5808 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5809 path
, bytes
, count
);
5812 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. */
6217 temp_ilp (char *buf
)
6219 gas_assert (saved_ilp
== NULL
);
6220 gas_assert (buf
!= NULL
);
6222 saved_ilp
= input_line_pointer
;
6223 saved_limit
= buffer_limit
;
6224 /* Prevent the assert in restore_ilp from triggering if
6225 the input_line_pointer has not yet been initialised. */
6226 if (saved_ilp
== NULL
)
6227 saved_limit
= saved_ilp
= (char *) "";
6229 input_line_pointer
= buf
;
6230 buffer_limit
= buf
+ strlen (buf
);
6231 input_from_string
= TRUE
;
6234 /* Restore a saved input line pointer. */
6239 gas_assert (saved_ilp
!= NULL
);
6241 input_line_pointer
= saved_ilp
;
6242 buffer_limit
= saved_limit
;
6243 input_from_string
= FALSE
;