1 /* read.c - read a source file -
2 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
43 #ifndef TC_START_LABEL
44 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
47 /* Set by the object-format or the target. */
48 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
49 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
54 else if ((SIZE) >= 4) \
56 else if ((SIZE) >= 2) \
64 char *input_line_pointer
; /*->next char of source file to parse. */
65 bfd_boolean input_from_string
= FALSE
;
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
94 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
103 /* The Delta 68k assembler permits ~ at start of label names. */
107 /* Used by is_... macros. our ctype[]. */
108 char lex_type
[256] = {
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
111 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
113 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
114 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
115 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
128 Out: 1 if this character ends a line.
129 2 if this character is a line separator. */
130 char is_end_of_line
[256] = {
132 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string
[128];
157 /* Functions private to this file. */
159 static char *buffer
; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit
; /*->1 + last char in buffer. */
162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
163 in the tc-<CPU>.h file. See the "Porting GAS" section of the
165 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
167 /* Variables for handling include file directory table. */
169 /* Table of pointers to directories to search for .include's. */
170 const char **include_dirs
;
172 /* How many are in the table. */
173 int include_dir_count
;
175 /* Length of longest in table. */
176 int include_dir_maxlen
= 1;
178 #ifndef WORKING_DOT_WORD
179 struct broken_word
*broken_words
;
180 int new_broken_words
;
183 /* The current offset into the absolute section. We don't try to
184 build frags in the absolute section, since no data can be stored
185 there. We just keep track of the current offset. */
186 addressT abs_section_offset
;
188 /* If this line had an MRI style label, it is stored in this variable.
189 This is used by some of the MRI pseudo-ops. */
192 /* This global variable is used to support MRI common sections. We
193 translate such sections into a common symbol. This variable is
194 non-NULL when we are in an MRI common section. */
195 symbolS
*mri_common_symbol
;
197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
198 need to align to an even byte boundary unless the next pseudo-op is
199 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
201 static int mri_pending_align
;
205 /* This variable is set to be non-zero if the next string we see might
206 be the name of the source file in DWARF debugging information. See
207 the comment in emit_expr for the format we look for. */
208 static int dwarf_file_string
;
212 /* If the target defines the md_frag_max_var hook then we know
213 enough to implement the .bundle_align_mode features. */
214 #ifdef md_frag_max_var
215 # define HANDLE_BUNDLE
219 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
220 it's the exponent of the bundle size, and aligned instruction bundle
221 mode is in effect. */
222 static unsigned int bundle_align_p2
;
224 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
225 bundle_lock_frag to frag_now and then starts a new frag with
226 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
227 so that .bundle_unlock can verify that we didn't change segments.
228 .bundle_unlock resets both to NULL. If we detect a bundling violation,
229 then we reset bundle_lock_frchain to NULL as an indicator that we've
230 already diagnosed the error with as_bad and don't need a cascade of
231 redundant errors, but bundle_lock_frag remains set to indicate that
232 we are expecting to see .bundle_unlock. */
233 static fragS
*bundle_lock_frag
;
234 static frchainS
*bundle_lock_frchain
;
236 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
238 static unsigned int bundle_lock_depth
;
241 static void do_s_func (int end_p
, const char *default_prefix
);
242 static void s_align (int, int);
243 static void s_altmacro (int);
244 static void s_bad_end (int);
245 static void s_reloc (int);
246 static int hex_float (int, char *);
247 static segT
get_known_segmented_expression (expressionS
* expP
);
248 static void pobegin (void);
249 static size_t get_non_macro_line_sb (sb
*);
250 static void generate_file_debug (void);
251 static char *_find_end_of_line (char *, int, int, int);
259 obj_read_begin_hook ();
261 /* Something close -- but not too close -- to a multiple of 1024.
262 The debugging malloc I'm using has 24 bytes of overhead. */
263 obstack_begin (¬es
, chunksize
);
264 obstack_begin (&cond_obstack
, chunksize
);
266 #ifndef tc_line_separator_chars
267 #define tc_line_separator_chars line_separator_chars
269 /* Use machine dependent syntax. */
270 for (p
= tc_line_separator_chars
; *p
; p
++)
271 is_end_of_line
[(unsigned char) *p
] = 2;
272 /* Use more. FIXME-SOMEDAY. */
278 #ifndef TC_ADDRESS_BYTES
279 #define TC_ADDRESS_BYTES address_bytes
284 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
285 contain an address. */
286 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
294 /* Set up pseudo-op tables. */
296 static struct hash_control
*po_hash
;
298 static const pseudo_typeS potable
[] = {
299 {"abort", s_abort
, 0},
300 {"align", s_align_ptwo
, 0},
301 {"altmacro", s_altmacro
, 1},
302 {"ascii", stringer
, 8+0},
303 {"asciz", stringer
, 8+1},
304 {"balign", s_align_bytes
, 0},
305 {"balignw", s_align_bytes
, -2},
306 {"balignl", s_align_bytes
, -4},
309 {"bundle_align_mode", s_bundle_align_mode
, 0},
310 {"bundle_lock", s_bundle_lock
, 0},
311 {"bundle_unlock", s_bundle_unlock
, 0},
315 {"common", s_mri_common
, 0},
316 {"common.s", s_mri_common
, 1},
319 #ifdef TC_ADDRESS_BYTES
323 {"dc.d", float_cons
, 'd'},
325 {"dc.s", float_cons
, 'f'},
327 {"dc.x", float_cons
, 'x'},
329 {"dcb.b", s_space
, 1},
330 {"dcb.d", s_float_space
, 'd'},
331 {"dcb.l", s_space
, 4},
332 {"dcb.s", s_float_space
, 'f'},
333 {"dcb.w", s_space
, 2},
334 {"dcb.x", s_float_space
, 'x'},
336 {"ds.b", s_space
, 1},
337 {"ds.d", s_space
, 8},
338 {"ds.l", s_space
, 4},
339 {"ds.p", s_space
, 12},
340 {"ds.s", s_space
, 4},
341 {"ds.w", s_space
, 2},
342 {"ds.x", s_space
, 12},
343 {"debug", s_ignore
, 0},
348 {"double", float_cons
, 'd'},
350 {"eject", listing_eject
, 0}, /* Formfeed listing. */
352 {"elsec", s_else
, 0},
353 {"elseif", s_elseif
, (int) O_ne
},
355 {"endc", s_endif
, 0},
356 {"endfunc", s_func
, 1},
357 {"endif", s_endif
, 0},
358 {"endm", s_bad_end
, 0},
359 {"endr", s_bad_end
, 1},
365 {"error", s_errwarn
, 1},
366 {"exitm", s_mexit
, 0},
368 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
369 {"appfile", s_app_file
, 1},
370 {"appline", s_app_line
, 1},
372 {"file", s_app_file
, 0},
374 {"float", float_cons
, 'f'},
375 {"format", s_ignore
, 0},
377 {"global", s_globl
, 0},
378 {"globl", s_globl
, 0},
380 {"if", s_if
, (int) O_ne
},
383 {"ifdef", s_ifdef
, 0},
384 {"ifeq", s_if
, (int) O_eq
},
385 {"ifeqs", s_ifeqs
, 0},
386 {"ifge", s_if
, (int) O_ge
},
387 {"ifgt", s_if
, (int) O_gt
},
388 {"ifle", s_if
, (int) O_le
},
389 {"iflt", s_if
, (int) O_lt
},
392 {"ifndef", s_ifdef
, 1},
393 {"ifne", s_if
, (int) O_ne
},
394 {"ifnes", s_ifeqs
, 1},
395 {"ifnotdef", s_ifdef
, 1},
396 {"incbin", s_incbin
, 0},
397 {"include", s_include
, 0},
403 {"lcomm", s_lcomm
, 0},
404 {"lflags", s_ignore
, 0}, /* Listing flags. */
405 {"linefile", s_app_line
, 0},
406 {"linkonce", s_linkonce
, 0},
407 {"list", listing_list
, 1}, /* Turn listing on. */
408 {"llen", listing_psize
, 1},
411 {"macro", s_macro
, 0},
412 {"mexit", s_mexit
, 0},
414 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
415 {"name", s_ignore
, 0},
416 {"noaltmacro", s_altmacro
, 0},
417 {"noformat", s_ignore
, 0},
418 {"nolist", listing_list
, 0}, /* Turn listing off. */
419 {"nopage", listing_nopage
, 0},
422 {"offset", s_struct
, 0},
424 {"p2align", s_align_ptwo
, 0},
425 {"p2alignw", s_align_ptwo
, -2},
426 {"p2alignl", s_align_ptwo
, -4},
427 {"page", listing_eject
, 0},
428 {"plen", listing_psize
, 0},
429 {"print", s_print
, 0},
430 {"psize", listing_psize
, 0}, /* Set paper size. */
431 {"purgem", s_purgem
, 0},
433 {"reloc", s_reloc
, 0},
437 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
442 {"single", float_cons
, 'f'},
444 {"space", s_space
, 0},
445 {"skip", s_space
, 0},
446 {"sleb128", s_leb128
, 1},
447 {"spc", s_ignore
, 0},
448 {"stabd", s_stab
, 'd'},
449 {"stabn", s_stab
, 'n'},
450 {"stabs", s_stab
, 's'},
451 {"string", stringer
, 8+1},
452 {"string8", stringer
, 8+1},
453 {"string16", stringer
, 16+1},
454 {"string32", stringer
, 32+1},
455 {"string64", stringer
, 64+1},
456 {"struct", s_struct
, 0},
460 /* This is for gcc to use. It's only just been added (2/94), so gcc
461 won't be able to use it for a while -- probably a year or more.
462 But once this has been released, check with gcc maintainers
463 before deleting it or even changing the spelling. */
464 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
465 /* If we're folding case -- done for some targets, not necessarily
466 all -- the above string in an input file will be converted to
467 this one. Match it either way... */
468 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
470 {"title", listing_title
, 0}, /* Listing title. */
471 {"ttl", listing_title
, 0},
473 {"uleb128", s_leb128
, 0},
477 {"xdef", s_globl
, 0},
478 {"xref", s_ignore
, 0},
479 {"xstabs", s_xstab
, 's'},
480 {"warning", s_errwarn
, 0},
481 {"weakref", s_weakref
, 0},
483 {"zero", s_space
, 0},
484 {NULL
, NULL
, 0} /* End sentinel. */
488 get_absolute_expr (expressionS
*exp
)
490 expression_and_evaluate (exp
);
492 if (exp
->X_op
!= O_constant
)
494 if (exp
->X_op
!= O_absent
)
495 as_bad (_("bad or irreducible absolute expression"));
496 exp
->X_add_number
= 0;
498 return exp
->X_add_number
;
502 get_absolute_expression (void)
506 return get_absolute_expr (&exp
);
509 static int pop_override_ok
= 0;
510 static const char *pop_table_name
;
513 pop_insert (const pseudo_typeS
*table
)
516 const pseudo_typeS
*pop
;
517 for (pop
= table
; pop
->poc_name
; pop
++)
519 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
520 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
521 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
526 #ifndef md_pop_insert
527 #define md_pop_insert() pop_insert(md_pseudo_table)
530 #ifndef obj_pop_insert
531 #define obj_pop_insert() pop_insert(obj_pseudo_table)
534 #ifndef cfi_pop_insert
535 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
541 po_hash
= hash_new ();
543 /* Do the target-specific pseudo ops. */
544 pop_table_name
= "md";
547 /* Now object specific. Skip any that were in the target table. */
548 pop_table_name
= "obj";
552 /* Now portable ones. Skip any that we've seen already. */
553 pop_table_name
= "standard";
554 pop_insert (potable
);
557 pop_table_name
= "cfi";
562 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
563 if (ignore_input ()) \
565 char *eol = find_end_of_line (input_line_pointer - (num_read), \
567 input_line_pointer = (input_line_pointer <= buffer_limit \
568 && eol >= buffer_limit) \
574 /* This function is used when scrubbing the characters between #APP
577 static char *scrub_string
;
578 static char *scrub_string_end
;
581 scrub_from_string (char *buf
, size_t buflen
)
585 copy
= scrub_string_end
- scrub_string
;
588 memcpy (buf
, scrub_string
, copy
);
589 scrub_string
+= copy
;
593 /* Helper function of read_a_source_file, which tries to expand a macro. */
595 try_macro (char term
, const char *line
)
601 if (check_macro (line
, &out
, &err
, ¯o
))
605 *input_line_pointer
++ = term
;
606 input_scrub_include_sb (&out
,
607 input_line_pointer
, 1);
610 input_scrub_next_buffer (&input_line_pointer
);
612 md_macro_info (macro
);
620 /* Start a new instruction bundle. Returns the rs_align_code frag that
621 will be used to align the new bundle. */
625 fragS
*frag
= frag_now
;
627 frag_align_code (0, 0);
629 while (frag
->fr_type
!= rs_align_code
)
630 frag
= frag
->fr_next
;
632 gas_assert (frag
!= frag_now
);
637 /* Calculate the maximum size after relaxation of the region starting
638 at the given frag and extending through frag_now (which is unfinished). */
640 pending_bundle_size (fragS
*frag
)
642 unsigned int offset
= frag
->fr_fix
;
643 unsigned int size
= 0;
645 gas_assert (frag
!= frag_now
);
646 gas_assert (frag
->fr_type
== rs_align_code
);
648 while (frag
!= frag_now
)
650 /* This should only happen in what will later become an error case. */
654 size
+= frag
->fr_fix
;
655 if (frag
->fr_type
== rs_machine_dependent
)
656 size
+= md_frag_max_var (frag
);
658 frag
= frag
->fr_next
;
661 gas_assert (frag
== frag_now
);
662 size
+= frag_now_fix ();
663 if (frag
->fr_type
== rs_machine_dependent
)
664 size
+= md_frag_max_var (frag
);
666 gas_assert (size
>= offset
);
668 return size
- offset
;
671 /* Finish off the frag created to ensure bundle alignment. */
673 finish_bundle (fragS
*frag
, unsigned int size
)
675 gas_assert (bundle_align_p2
> 0);
676 gas_assert (frag
->fr_type
== rs_align_code
);
680 /* If there is more than a single byte, then we need to set up the
681 alignment frag. Otherwise we leave it at its initial state from
682 calling frag_align_code (0, 0), so that it does nothing. */
683 frag
->fr_offset
= bundle_align_p2
;
684 frag
->fr_subtype
= size
- 1;
687 /* We do this every time rather than just in s_bundle_align_mode
688 so that we catch any affected section without needing hooks all
689 over for all paths that do section changes. It's cheap enough. */
690 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
691 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
694 /* Assemble one instruction. This takes care of the bundle features
695 around calling md_assemble. */
697 assemble_one (char *line
)
699 fragS
*insn_start_frag
= NULL
;
701 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
703 as_bad (_("cannot change section or subsection inside .bundle_lock"));
704 /* Clearing this serves as a marker that we have already complained. */
705 bundle_lock_frchain
= NULL
;
708 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
709 insn_start_frag
= start_bundle ();
713 if (bundle_lock_frchain
!= NULL
)
715 /* Make sure this hasn't pushed the locked sequence
716 past the bundle size. */
717 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
718 if (bundle_size
> 1U << bundle_align_p2
)
719 as_bad (_ (".bundle_lock sequence at %u bytes, "
720 "but .bundle_align_mode limit is %u bytes"),
721 bundle_size
, 1U << bundle_align_p2
);
723 else if (bundle_align_p2
> 0)
725 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
727 if (insn_size
> 1U << bundle_align_p2
)
728 as_bad (_("single instruction is %u bytes long, "
729 "but .bundle_align_mode limit is %u bytes"),
730 insn_size
, 1U << bundle_align_p2
);
732 finish_bundle (insn_start_frag
, insn_size
);
736 #else /* !HANDLE_BUNDLE */
738 # define assemble_one(line) md_assemble(line)
740 #endif /* HANDLE_BUNDLE */
745 flagword flags
= bfd_get_section_flags (stdoutput
, now_seg
);
747 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
750 /* Guts of .align directive:
751 N is the power of two to which to align. A value of zero is accepted but
752 ignored: the default alignment of the section will be at least this.
753 FILL may be NULL, or it may point to the bytes of the fill pattern.
754 LEN is the length of whatever FILL points to, if anything. If LEN is zero
755 but FILL is not NULL then LEN is treated as if it were one.
756 MAX is the maximum number of characters to skip when doing the alignment,
757 or 0 if there is no maximum. */
760 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
762 if (now_seg
== absolute_section
|| in_bss ())
768 if (now_seg
== absolute_section
)
769 as_warn (_("ignoring fill value in absolute section"));
771 as_warn (_("ignoring fill value in section `%s'"),
772 segment_name (now_seg
));
779 #ifdef md_flush_pending_output
780 md_flush_pending_output ();
784 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
787 /* Only make a frag if we HAVE to... */
788 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
792 if (subseg_text_p (now_seg
))
793 frag_align_code (n
, max
);
795 frag_align (n
, 0, max
);
798 frag_align (n
, *fill
, max
);
800 frag_align_pattern (n
, fill
, len
, max
);
804 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
807 if (n
> OCTETS_PER_BYTE_POWER
)
808 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
811 /* We read the file, putting things into a web that represents what we
812 have been reading. */
814 read_a_source_file (const char *name
)
818 char *s
; /* String of symbol, '\0' appended. */
826 buffer
= input_scrub_new_file (name
);
829 listing_newline (NULL
);
830 register_dependency (name
);
832 /* Generate debugging information before we've read anything in to denote
833 this file as the "main" source file and not a subordinate one
834 (e.g. N_SO vs N_SOL in stabs). */
835 generate_file_debug ();
837 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
838 { /* We have another line to parse. */
840 /* In order to avoid listing macro expansion lines with labels
841 multiple times, keep track of which line was last issued. */
842 static char *last_eol
;
846 while (input_line_pointer
< buffer_limit
)
848 bfd_boolean was_new_line
;
849 /* We have more of this buffer to parse. */
851 /* We now have input_line_pointer->1st char of next line.
852 If input_line_pointer [-1] == '\n' then we just
853 scanned another line: so bump line counters. */
854 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
857 symbol_set_value_now (&dot_symbol
);
858 #ifdef md_start_line_hook
859 md_start_line_hook ();
861 if (input_line_pointer
[-1] == '\n')
862 bump_line_counters ();
866 /* If listing is on, and we are expanding a macro, then give
867 the listing code the contents of the expanded line. */
870 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
872 /* Find the end of the current expanded macro line. */
873 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
881 /* Copy it for safe keeping. Also give an indication of
882 how much macro nesting is involved at this point. */
883 len
= s
- input_line_pointer
;
884 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
885 memset (copy
, '>', macro_nest
);
886 copy
[macro_nest
] = ' ';
887 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
888 copy
[macro_nest
+ 1 + len
] = '\0';
890 /* Install the line with the listing facility. */
891 listing_newline (copy
);
895 listing_newline (NULL
);
902 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
904 next_char
= * input_line_pointer
;
905 /* Text at the start of a line must be a label, we
906 run down and stick a colon in. */
907 if (is_name_beginner (next_char
) || next_char
== '"')
912 HANDLE_CONDITIONAL_ASSEMBLY (0);
914 nul_char
= get_symbol_name (& line_start
);
915 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
917 /* In MRI mode, the EQU and MACRO pseudoops must
918 be handled specially. */
922 char *rest
= input_line_pointer
+ 1;
926 if (*rest
== ' ' || *rest
== '\t')
928 if ((strncasecmp (rest
, "EQU", 3) == 0
929 || strncasecmp (rest
, "SET", 3) == 0)
930 && (rest
[3] == ' ' || rest
[3] == '\t'))
932 input_line_pointer
= rest
+ 3;
934 strncasecmp (rest
, "SET", 3) == 0);
937 if (strncasecmp (rest
, "MACRO", 5) == 0
940 || is_end_of_line
[(unsigned char) rest
[5]]))
944 /* In MRI mode, we need to handle the MACRO
945 pseudo-op specially: we don't want to put the
946 symbol in the symbol table. */
948 #ifdef TC_START_LABEL_WITHOUT_COLON
949 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
952 line_label
= colon (line_start
);
954 line_label
= symbol_create (line_start
,
959 next_char
= restore_line_pointer (nul_char
);
960 if (next_char
== ':')
961 input_line_pointer
++;
966 /* We are at the beginning of a line, or similar place.
967 We expect a well-formed assembler statement.
968 A "symbol-name:" is a statement.
970 Depending on what compiler is used, the order of these tests
971 may vary to catch most common case 1st.
972 Each test is independent of all other tests at the (top)
975 nul_char
= next_char
= *input_line_pointer
++;
976 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
978 /* C is the 1st significant character.
979 Input_line_pointer points after that character. */
980 if (is_name_beginner (next_char
) || next_char
== '"')
984 /* Want user-defined label or pseudo/opcode. */
985 HANDLE_CONDITIONAL_ASSEMBLY (1);
987 --input_line_pointer
;
988 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
989 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
990 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
992 /* NEXT_CHAR is character after symbol.
993 The end of symbol in the input line is now '\0'.
994 S points to the beginning of the symbol.
995 [In case of pseudo-op, s->'.'.]
996 Input_line_pointer->'\0' where NUL_CHAR was. */
997 if (TC_START_LABEL (s
, nul_char
, next_char
))
1001 /* In MRI mode, \tsym: set 0 is permitted. */
1005 if (*rest
== ' ' || *rest
== '\t')
1008 if ((strncasecmp (rest
, "EQU", 3) == 0
1009 || strncasecmp (rest
, "SET", 3) == 0)
1010 && (rest
[3] == ' ' || rest
[3] == '\t'))
1012 input_line_pointer
= rest
+ 3;
1018 line_label
= colon (s
); /* User-defined label. */
1019 restore_line_pointer (nul_char
);
1020 ++ input_line_pointer
;
1021 #ifdef tc_check_label
1022 tc_check_label (line_label
);
1024 /* Input_line_pointer->after ':'. */
1027 else if ((next_char
== '=' && *rest
== '=')
1028 || ((next_char
== ' ' || next_char
== '\t')
1033 demand_empty_rest_of_line ();
1035 else if ((next_char
== '='
1036 || ((next_char
== ' ' || next_char
== '\t')
1038 #ifdef TC_EQUAL_IN_INSN
1039 && !TC_EQUAL_IN_INSN (next_char
, s
)
1044 demand_empty_rest_of_line ();
1048 /* Expect pseudo-op or machine instruction. */
1051 #ifndef TC_CASE_SENSITIVE
1055 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
1056 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1060 *s2
= TOLOWER (*s2
);
1065 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1067 /* The MRI assembler uses pseudo-ops without
1069 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
1070 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1075 || (!flag_m68k_mri
&& *s
== '.'))
1079 WARNING: next_char may be end-of-line.
1080 We lookup the pseudo-op table with s+1 because we
1081 already know that the pseudo-op begins with a '.'. */
1084 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1085 if (pop
&& !pop
->poc_handler
)
1088 /* In MRI mode, we may need to insert an
1089 automatic alignment directive. What a hack
1091 if (mri_pending_align
1093 || !((pop
->poc_handler
== cons
1094 && pop
->poc_val
== 1)
1095 || (pop
->poc_handler
== s_space
1096 && pop
->poc_val
== 1)
1097 #ifdef tc_conditional_pseudoop
1098 || tc_conditional_pseudoop (pop
)
1100 || pop
->poc_handler
== s_if
1101 || pop
->poc_handler
== s_ifdef
1102 || pop
->poc_handler
== s_ifc
1103 || pop
->poc_handler
== s_ifeqs
1104 || pop
->poc_handler
== s_else
1105 || pop
->poc_handler
== s_endif
1106 || pop
->poc_handler
== s_globl
1107 || pop
->poc_handler
== s_ignore
)))
1109 do_align (1, (char *) NULL
, 0, 0);
1110 mri_pending_align
= 0;
1112 if (line_label
!= NULL
)
1114 symbol_set_frag (line_label
, frag_now
);
1115 S_SET_VALUE (line_label
, frag_now_fix ());
1119 /* Print the error msg now, while we still can. */
1122 char *end
= input_line_pointer
;
1124 (void) restore_line_pointer (nul_char
);
1126 nul_char
= next_char
= *--input_line_pointer
;
1127 *input_line_pointer
= '\0';
1128 if (! macro_defined
|| ! try_macro (next_char
, s
))
1131 as_bad (_("unknown pseudo-op: `%s'"), s
);
1132 *input_line_pointer
++ = nul_char
;
1137 /* Put it back for error messages etc. */
1138 next_char
= restore_line_pointer (nul_char
);
1139 /* The following skip of whitespace is compulsory.
1140 A well shaped space is sometimes all that separates
1141 keyword from operands. */
1142 if (next_char
== ' ' || next_char
== '\t')
1143 input_line_pointer
++;
1145 /* Input_line is restored.
1146 Input_line_pointer->1st non-blank char
1147 after pseudo-operation. */
1148 (*pop
->poc_handler
) (pop
->poc_val
);
1150 /* If that was .end, just get out now. */
1151 if (pop
->poc_handler
== s_end
)
1156 /* WARNING: next_char may be end-of-line. */
1157 /* Also: input_line_pointer->`\0` where nul_char was. */
1158 (void) restore_line_pointer (nul_char
);
1159 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1160 next_char
= nul_char
= *input_line_pointer
;
1161 *input_line_pointer
= '\0';
1163 generate_lineno_debug ();
1165 if (macro_defined
&& try_macro (next_char
, s
))
1168 if (mri_pending_align
)
1170 do_align (1, (char *) NULL
, 0, 0);
1171 mri_pending_align
= 0;
1172 if (line_label
!= NULL
)
1174 symbol_set_frag (line_label
, frag_now
);
1175 S_SET_VALUE (line_label
, frag_now_fix ());
1179 assemble_one (s
); /* Assemble 1 instruction. */
1181 /* PR 19630: The backend may have set ilp to NULL
1182 if it encountered a catastrophic failure. */
1183 if (input_line_pointer
== NULL
)
1184 as_fatal (_("unable to continue with assembly."));
1186 *input_line_pointer
++ = nul_char
;
1188 /* We resume loop AFTER the end-of-line from
1189 this instruction. */
1195 /* Empty statement? */
1196 if (is_end_of_line
[(unsigned char) next_char
])
1199 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1201 /* local label ("4:") */
1202 char *backup
= input_line_pointer
;
1204 HANDLE_CONDITIONAL_ASSEMBLY (1);
1206 temp
= next_char
- '0';
1208 if (nul_char
== '"')
1209 ++ input_line_pointer
;
1211 /* Read the whole number. */
1212 while (ISDIGIT (*input_line_pointer
))
1214 temp
= (temp
* 10) + *input_line_pointer
- '0';
1215 ++input_line_pointer
;
1218 if (LOCAL_LABELS_DOLLAR
1219 && *input_line_pointer
== '$'
1220 && *(input_line_pointer
+ 1) == ':')
1222 input_line_pointer
+= 2;
1224 if (dollar_label_defined (temp
))
1226 as_fatal (_("label \"%d$\" redefined"), temp
);
1229 define_dollar_label (temp
);
1230 colon (dollar_label_name (temp
, 0));
1235 && *input_line_pointer
++ == ':')
1237 fb_label_instance_inc (temp
);
1238 colon (fb_label_name (temp
, 0));
1242 input_line_pointer
= backup
;
1245 if (next_char
&& strchr (line_comment_chars
, next_char
))
1246 { /* Its a comment. Better say APP or NO_APP. */
1251 unsigned int new_length
;
1254 s
= input_line_pointer
;
1255 if (strncmp (s
, "APP\n", 4))
1258 ignore_rest_of_line ();
1261 bump_line_counters ();
1264 ends
= strstr (s
, "#NO_APP\n");
1268 unsigned int tmp_len
;
1271 /* The end of the #APP wasn't in this buffer. We
1272 keep reading in buffers until we find the #NO_APP
1273 that goes with this #APP There is one. The specs
1275 tmp_len
= buffer_limit
- s
;
1276 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1277 memcpy (tmp_buf
, s
, tmp_len
);
1280 new_tmp
= input_scrub_next_buffer (&buffer
);
1284 buffer_limit
= new_tmp
;
1285 input_line_pointer
= buffer
;
1286 ends
= strstr (buffer
, "#NO_APP\n");
1288 num
= ends
- buffer
;
1290 num
= buffer_limit
- buffer
;
1292 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1293 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1298 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1306 input_line_pointer
= ends
+ 8;
1310 scrub_string_end
= ends
;
1312 new_length
= ends
- s
;
1313 new_buf
= XNEWVEC (char, new_length
);
1320 space
= (new_buf
+ new_length
) - new_tmp
;
1321 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1329 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1330 new_tmp
= new_buf
+ new_length
;
1337 /* We've "scrubbed" input to the preferred format. In the
1338 process we may have consumed the whole of the remaining
1339 file (and included files). We handle this formatted
1340 input similar to that of macro expansion, letting
1341 actual macro expansion (possibly nested) and other
1342 input expansion work. Beware that in messages, line
1343 numbers and possibly file names will be incorrect. */
1344 new_length
= strlen (new_buf
);
1345 sb_build (&sbuf
, new_length
);
1346 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1347 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1349 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1354 HANDLE_CONDITIONAL_ASSEMBLY (1);
1356 #ifdef tc_unrecognized_line
1357 if (tc_unrecognized_line (next_char
))
1360 input_line_pointer
--;
1361 /* Report unknown char as error. */
1362 demand_empty_rest_of_line ();
1367 symbol_set_value_now (&dot_symbol
);
1369 #ifdef HANDLE_BUNDLE
1370 if (bundle_lock_frag
!= NULL
)
1372 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1373 _(".bundle_lock with no matching .bundle_unlock"));
1374 bundle_lock_frag
= NULL
;
1375 bundle_lock_frchain
= NULL
;
1376 bundle_lock_depth
= 0;
1383 /* Close the input file. */
1384 input_scrub_close ();
1385 #ifdef WARN_COMMENTS
1387 if (warn_comment
&& found_comment
)
1388 as_warn_where (found_comment_file
, found_comment
,
1389 "first comment found here");
1394 /* Convert O_constant expression EXP into the equivalent O_big representation.
1395 Take the sign of the number from SIGN rather than X_add_number. */
1398 convert_to_bignum (expressionS
*exp
, int sign
)
1403 value
= exp
->X_add_number
;
1404 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1406 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1407 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1409 /* Add a sequence of sign bits if the top bit of X_add_number is not
1410 the sign of the original value. */
1411 if ((exp
->X_add_number
< 0) == !sign
)
1412 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1414 exp
->X_add_number
= i
;
1417 /* For most MRI pseudo-ops, the line actually ends at the first
1418 nonquoted space. This function looks for that point, stuffs a null
1419 in, and sets *STOPCP to the character that used to be there, and
1420 returns the location.
1422 Until I hear otherwise, I am going to assume that this is only true
1423 for the m68k MRI assembler. */
1426 mri_comment_field (char *stopcp
)
1432 know (flag_m68k_mri
);
1434 for (s
= input_line_pointer
;
1435 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1443 for (s
= input_line_pointer
;
1444 !is_end_of_line
[(unsigned char) *s
];
1454 /* Skip to the end of an MRI comment field. */
1457 mri_comment_end (char *stop
, int stopc
)
1461 input_line_pointer
= stop
;
1463 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1464 ++input_line_pointer
;
1468 s_abort (int ignore ATTRIBUTE_UNUSED
)
1470 as_fatal (_(".abort detected. Abandoning ship."));
1473 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1474 (in bytes). A negative ARG is the negative of the length of the
1475 fill pattern. BYTES_P is non-zero if the alignment value should be
1476 interpreted as the byte boundary, rather than the power of 2. */
1477 #ifndef TC_ALIGN_LIMIT
1478 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1482 s_align (signed int arg
, int bytes_p
)
1484 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1493 stop
= mri_comment_field (&stopc
);
1495 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1500 align
= arg
; /* Default value from pseudo-op table. */
1504 align
= get_absolute_expression ();
1507 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1508 if (arg
> 0 && align
== 0)
1515 /* Convert to a power of 2. */
1520 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1523 as_bad (_("alignment not a power of 2"));
1529 if (align
> align_limit
)
1531 align
= align_limit
;
1532 as_warn (_("alignment too large: %u assumed"), align
);
1535 if (*input_line_pointer
!= ',')
1542 ++input_line_pointer
;
1543 if (*input_line_pointer
== ',')
1547 fill
= get_absolute_expression ();
1552 if (*input_line_pointer
!= ',')
1556 ++input_line_pointer
;
1557 max
= get_absolute_expression ();
1564 as_warn (_("expected fill pattern missing"));
1565 do_align (align
, (char *) NULL
, 0, max
);
1569 unsigned int fill_len
;
1581 do_align (align
, &fill_char
, fill_len
, max
);
1587 if ((size_t) fill_len
> sizeof ab
)
1589 as_warn (_("fill pattern too long, truncating to %u"),
1590 (unsigned) sizeof ab
);
1591 fill_len
= sizeof ab
;
1594 md_number_to_chars (ab
, fill
, fill_len
);
1595 do_align (align
, ab
, fill_len
, max
);
1599 demand_empty_rest_of_line ();
1602 mri_comment_end (stop
, stopc
);
1605 /* Handle the .align pseudo-op on machines where ".align 4" means
1606 align to a 4 byte boundary. */
1609 s_align_bytes (int arg
)
1614 /* Handle the .align pseudo-op on machines where ".align 4" means align
1615 to a 2**4 boundary. */
1618 s_align_ptwo (int arg
)
1623 /* Switch in and out of alternate macro mode. */
1628 demand_empty_rest_of_line ();
1629 macro_set_alternate (on
);
1632 /* Read a symbol name from input_line_pointer.
1634 Stores the symbol name in a buffer and returns a pointer to this buffer.
1635 The buffer is xalloc'ed. It is the caller's responsibility to free
1638 The name is not left in the i_l_p buffer as it may need processing
1639 to handle escape characters.
1641 Advances i_l_p to the next non-whitespace character.
1643 If a symbol name could not be read, the routine issues an error
1644 messages, skips to the end of the line and returns NULL. */
1647 read_symbol_name (void)
1653 c
= *input_line_pointer
++;
1657 #define SYM_NAME_CHUNK_LEN 128
1658 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1662 start
= name
= XNEWVEC (char, len
+ 1);
1664 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1666 while (is_a_char (C
= next_char_of_string ()))
1668 if (name
>= name_end
)
1672 sofar
= name
- start
;
1673 len
+= SYM_NAME_CHUNK_LEN
;
1674 start
= XRESIZEVEC (char, start
, len
+ 1);
1675 name_end
= start
+ len
;
1676 name
= start
+ sofar
;
1683 /* Since quoted symbol names can contain non-ASCII characters,
1684 check the string and warn if it cannot be recognised by the
1685 current character set. */
1686 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1687 as_warn (_("symbol name not recognised in the current locale"));
1689 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1693 name
= input_line_pointer
- 1;
1695 /* We accept FAKE_LABEL_CHAR in a name in case this is
1696 being called with a constructed string. */
1697 while (is_part_of_name (c
= *input_line_pointer
++)
1698 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1701 len
= (input_line_pointer
- name
) - 1;
1702 start
= XNEWVEC (char, len
+ 1);
1704 memcpy (start
, name
, len
);
1707 /* Skip a name ender char if one is present. */
1708 if (! is_name_ender (c
))
1709 --input_line_pointer
;
1712 name
= start
= NULL
;
1716 as_bad (_("expected symbol name"));
1717 ignore_rest_of_line ();
1728 s_comm_internal (int param
,
1729 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1733 symbolS
*symbolP
= NULL
;
1739 stop
= mri_comment_field (&stopc
);
1741 if ((name
= read_symbol_name ()) == NULL
)
1744 /* Accept an optional comma after the name. The comma used to be
1745 required, but Irix 5 cc does not generate it for .lcomm. */
1746 if (*input_line_pointer
== ',')
1747 input_line_pointer
++;
1749 temp
= get_absolute_expr (&exp
);
1751 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1752 if (exp
.X_op
== O_absent
)
1754 as_bad (_("missing size expression"));
1755 ignore_rest_of_line ();
1758 else if (temp
!= size
|| !exp
.X_unsigned
)
1760 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1761 ignore_rest_of_line ();
1765 symbolP
= symbol_find_or_make (name
);
1766 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1767 && !S_IS_COMMON (symbolP
))
1769 if (!S_IS_VOLATILE (symbolP
))
1772 as_bad (_("symbol `%s' is already defined"), name
);
1773 ignore_rest_of_line ();
1776 symbolP
= symbol_clone (symbolP
, 1);
1777 S_SET_SEGMENT (symbolP
, undefined_section
);
1778 S_SET_VALUE (symbolP
, 0);
1779 symbol_set_frag (symbolP
, &zero_address_frag
);
1780 S_CLEAR_VOLATILE (symbolP
);
1783 size
= S_GET_VALUE (symbolP
);
1786 else if (size
!= temp
)
1787 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1788 name
, (long) size
, (long) temp
);
1790 if (comm_parse_extra
!= NULL
)
1791 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1794 S_SET_VALUE (symbolP
, (valueT
) size
);
1795 S_SET_EXTERNAL (symbolP
);
1796 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1799 demand_empty_rest_of_line ();
1802 mri_comment_end (stop
, stopc
);
1811 s_comm_internal (ignore
, NULL
);
1814 /* The MRI COMMON pseudo-op. We handle this by creating a common
1815 symbol with the appropriate name. We make s_space do the right
1816 thing by increasing the size. */
1819 s_mri_common (int small ATTRIBUTE_UNUSED
)
1835 stop
= mri_comment_field (&stopc
);
1839 name
= input_line_pointer
;
1840 if (!ISDIGIT (*name
))
1841 c
= get_symbol_name (& name
);
1846 ++input_line_pointer
;
1848 while (ISDIGIT (*input_line_pointer
));
1850 c
= *input_line_pointer
;
1851 *input_line_pointer
= '\0';
1853 if (line_label
!= NULL
)
1855 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1856 + (input_line_pointer
- name
) + 1);
1857 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1862 sym
= symbol_find_or_make (name
);
1863 c
= restore_line_pointer (c
);
1867 if (*input_line_pointer
!= ',')
1871 ++input_line_pointer
;
1872 align
= get_absolute_expression ();
1875 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1877 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1878 ignore_rest_of_line ();
1879 mri_comment_end (stop
, stopc
);
1883 S_SET_EXTERNAL (sym
);
1884 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1885 mri_common_symbol
= sym
;
1889 S_SET_ALIGN (sym
, align
);
1894 if (line_label
!= NULL
)
1897 exp
.X_op
= O_symbol
;
1898 exp
.X_add_symbol
= sym
;
1899 exp
.X_add_number
= 0;
1900 symbol_set_value_expression (line_label
, &exp
);
1901 symbol_set_frag (line_label
, &zero_address_frag
);
1902 S_SET_SEGMENT (line_label
, expr_section
);
1905 /* FIXME: We just ignore the small argument, which distinguishes
1906 COMMON and COMMON.S. I don't know what we can do about it. */
1908 /* Ignore the type and hptype. */
1909 if (*input_line_pointer
== ',')
1910 input_line_pointer
+= 2;
1911 if (*input_line_pointer
== ',')
1912 input_line_pointer
+= 2;
1914 demand_empty_rest_of_line ();
1916 mri_comment_end (stop
, stopc
);
1920 s_data (int ignore ATTRIBUTE_UNUSED
)
1925 temp
= get_absolute_expression ();
1926 if (flag_readonly_data_in_text
)
1928 section
= text_section
;
1932 section
= data_section
;
1934 subseg_set (section
, (subsegT
) temp
);
1936 demand_empty_rest_of_line ();
1939 /* Handle the .appfile pseudo-op. This is automatically generated by
1940 do_scrub_chars when a preprocessor # line comment is seen with a
1941 file name. This default definition may be overridden by the object
1942 or CPU specific pseudo-ops. This function is also the default
1943 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1947 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1951 listing_source_file (file
);
1953 register_dependency (file
);
1955 obj_app_file (file
, appfile
);
1960 s_app_file (int appfile
)
1965 /* Some assemblers tolerate immediately following '"'. */
1966 if ((s
= demand_copy_string (&length
)) != 0)
1969 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1971 /* In MRI mode, the preprocessor may have inserted an extraneous
1974 && *input_line_pointer
== '\''
1975 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1976 ++input_line_pointer
;
1978 demand_empty_rest_of_line ();
1980 s_app_file_string (s
, appfile
);
1985 get_linefile_number (int *flag
)
1989 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1992 *flag
= get_absolute_expression ();
1997 /* Handle the .appline pseudo-op. This is automatically generated by
1998 do_scrub_chars when a preprocessor # line comment is seen. This
1999 default definition may be overridden by the object or CPU specific
2003 s_app_line (int appline
)
2008 /* The given number is that of the next line. */
2010 l
= get_absolute_expression ();
2011 else if (!get_linefile_number (&l
))
2013 ignore_rest_of_line ();
2020 /* Some of the back ends can't deal with non-positive line numbers.
2021 Besides, it's silly. GCC however will generate a line number of
2022 zero when it is pre-processing builtins for assembler-with-cpp files:
2026 We do not want to barf on this, especially since such files are used
2027 in the GCC and GDB testsuites. So we check for negative line numbers
2028 rather than non-positive line numbers. */
2029 as_warn (_("line numbers must be positive; line number %d rejected"),
2040 if (*input_line_pointer
== '"')
2041 file
= demand_copy_string (&length
);
2047 while (get_linefile_number (&this_flag
))
2050 /* From GCC's cpp documentation:
2051 1: start of a new file.
2052 2: returning to a file after having included
2054 3: following text comes from a system header file.
2055 4: following text should be treated as extern "C".
2057 4 is nonsensical for the assembler; 3, we don't
2058 care about, so we ignore it just in case a
2059 system header file is included while
2060 preprocessing assembly. So 1 and 2 are all we
2061 care about, and they are mutually incompatible.
2062 new_logical_line_flags() demands this. */
2065 if (flags
&& flags
!= (1 << this_flag
))
2066 as_warn (_("incompatible flag %i in line directive"),
2069 flags
|= 1 << this_flag
;
2074 /* We ignore these. */
2078 as_warn (_("unsupported flag %i in line directive"),
2083 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2088 if (appline
|| file
)
2090 new_logical_line_flags (file
, l
, flags
);
2093 listing_source_line (l
);
2097 if (appline
|| file
)
2098 demand_empty_rest_of_line ();
2100 ignore_rest_of_line ();
2103 /* Handle the .end pseudo-op. Actually, the real work is done in
2104 read_a_source_file. */
2107 s_end (int ignore ATTRIBUTE_UNUSED
)
2111 /* The MRI assembler permits the start symbol to follow .end,
2112 but we don't support that. */
2114 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2115 && *input_line_pointer
!= '*'
2116 && *input_line_pointer
!= '!')
2117 as_warn (_("start address not supported"));
2121 /* Handle the .err pseudo-op. */
2124 s_err (int ignore ATTRIBUTE_UNUSED
)
2126 as_bad (_(".err encountered"));
2127 demand_empty_rest_of_line ();
2130 /* Handle the .error and .warning pseudo-ops. */
2136 /* The purpose for the conditional assignment is not to
2137 internationalize the directive itself, but that we need a
2138 self-contained message, one that can be passed like the
2139 demand_copy_C_string return value, and with no assumption on the
2140 location of the name of the directive within the message. */
2142 = (err
? _(".error directive invoked in source file")
2143 : _(".warning directive invoked in source file"));
2145 if (!is_it_end_of_statement ())
2147 if (*input_line_pointer
!= '\"')
2149 as_bad (_("%s argument must be a string"),
2150 err
? ".error" : ".warning");
2151 ignore_rest_of_line ();
2155 msg
= demand_copy_C_string (&len
);
2163 as_warn ("%s", msg
);
2164 demand_empty_rest_of_line ();
2167 /* Handle the MRI fail pseudo-op. */
2170 s_fail (int ignore ATTRIBUTE_UNUSED
)
2177 stop
= mri_comment_field (&stopc
);
2179 temp
= get_absolute_expression ();
2181 as_warn (_(".fail %ld encountered"), (long) temp
);
2183 as_bad (_(".fail %ld encountered"), (long) temp
);
2185 demand_empty_rest_of_line ();
2188 mri_comment_end (stop
, stopc
);
2192 s_fill (int ignore ATTRIBUTE_UNUSED
)
2194 expressionS rep_exp
;
2199 #ifdef md_flush_pending_output
2200 md_flush_pending_output ();
2203 #ifdef md_cons_align
2207 expression (&rep_exp
);
2208 if (*input_line_pointer
== ',')
2210 input_line_pointer
++;
2211 size
= get_absolute_expression ();
2212 if (*input_line_pointer
== ',')
2214 input_line_pointer
++;
2215 fill
= get_absolute_expression ();
2219 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2220 #define BSD_FILL_SIZE_CROCK_8 (8)
2221 if (size
> BSD_FILL_SIZE_CROCK_8
)
2223 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2224 size
= BSD_FILL_SIZE_CROCK_8
;
2228 as_warn (_("size negative; .fill ignored"));
2231 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2233 if (rep_exp
.X_add_number
< 0)
2234 as_warn (_("repeat < 0; .fill ignored"));
2238 if (size
&& !need_pass_2
)
2240 if (now_seg
== absolute_section
)
2242 if (rep_exp
.X_op
!= O_constant
)
2243 as_bad (_("non-constant fill count for absolute section"));
2244 else if (fill
&& rep_exp
.X_add_number
!= 0)
2245 as_bad (_("attempt to fill absolute section with non-zero value"));
2246 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2249 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2251 as_bad (_("attempt to fill section `%s' with non-zero value"),
2252 segment_name (now_seg
));
2254 if (rep_exp
.X_op
== O_constant
)
2256 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2257 (relax_substateT
) 0, (symbolS
*) 0,
2258 (offsetT
) rep_exp
.X_add_number
,
2263 /* We don't have a constant repeat count, so we can't use
2264 rs_fill. We can get the same results out of rs_space,
2265 but its argument is in bytes, so we must multiply the
2266 repeat count by size. */
2269 rep_sym
= make_expr_symbol (&rep_exp
);
2272 expressionS size_exp
;
2273 size_exp
.X_op
= O_constant
;
2274 size_exp
.X_add_number
= size
;
2276 rep_exp
.X_op
= O_multiply
;
2277 rep_exp
.X_add_symbol
= rep_sym
;
2278 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2279 rep_exp
.X_add_number
= 0;
2280 rep_sym
= make_expr_symbol (&rep_exp
);
2283 p
= frag_var (rs_space
, (int) size
, (int) size
,
2284 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2287 memset (p
, 0, (unsigned int) size
);
2289 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2290 flavoured AS. The following bizarre behaviour is to be
2291 compatible with above. I guess they tried to take up to 8
2292 bytes from a 4-byte expression and they forgot to sign
2294 #define BSD_FILL_SIZE_CROCK_4 (4)
2295 md_number_to_chars (p
, (valueT
) fill
,
2296 (size
> BSD_FILL_SIZE_CROCK_4
2297 ? BSD_FILL_SIZE_CROCK_4
2299 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2300 but emits no error message because it seems a legal thing to do.
2301 It is a degenerate case of .fill but could be emitted by a
2304 demand_empty_rest_of_line ();
2308 s_globl (int ignore ATTRIBUTE_UNUSED
)
2317 stop
= mri_comment_field (&stopc
);
2321 if ((name
= read_symbol_name ()) == NULL
)
2324 symbolP
= symbol_find_or_make (name
);
2325 S_SET_EXTERNAL (symbolP
);
2328 c
= *input_line_pointer
;
2331 input_line_pointer
++;
2333 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2341 demand_empty_rest_of_line ();
2344 mri_comment_end (stop
, stopc
);
2347 /* Handle the MRI IRP and IRPC pseudo-ops. */
2359 file
= as_where (&line
);
2361 eol
= find_end_of_line (input_line_pointer
, 0);
2362 sb_build (&s
, eol
- input_line_pointer
);
2363 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2364 input_line_pointer
= eol
;
2368 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2370 as_bad_where (file
, line
, "%s", err
);
2374 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2376 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2379 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2380 the section to only be linked once. However, this is not supported
2381 by most object file formats. This takes an optional argument,
2382 which is what to do about duplicates. */
2385 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2387 enum linkonce_type type
;
2391 type
= LINKONCE_DISCARD
;
2393 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2398 c
= get_symbol_name (& s
);
2399 if (strcasecmp (s
, "discard") == 0)
2400 type
= LINKONCE_DISCARD
;
2401 else if (strcasecmp (s
, "one_only") == 0)
2402 type
= LINKONCE_ONE_ONLY
;
2403 else if (strcasecmp (s
, "same_size") == 0)
2404 type
= LINKONCE_SAME_SIZE
;
2405 else if (strcasecmp (s
, "same_contents") == 0)
2406 type
= LINKONCE_SAME_CONTENTS
;
2408 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2410 (void) restore_line_pointer (c
);
2413 #ifdef obj_handle_link_once
2414 obj_handle_link_once (type
);
2415 #else /* ! defined (obj_handle_link_once) */
2419 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2420 as_warn (_(".linkonce is not supported for this object file format"));
2422 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2423 flags
|= SEC_LINK_ONCE
;
2428 case LINKONCE_DISCARD
:
2429 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2431 case LINKONCE_ONE_ONLY
:
2432 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2434 case LINKONCE_SAME_SIZE
:
2435 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2437 case LINKONCE_SAME_CONTENTS
:
2438 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2441 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2442 as_bad (_("bfd_set_section_flags: %s"),
2443 bfd_errmsg (bfd_get_error ()));
2445 #endif /* ! defined (obj_handle_link_once) */
2447 demand_empty_rest_of_line ();
2451 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2454 segT current_seg
= now_seg
;
2455 subsegT current_subseg
= now_subseg
;
2456 segT bss_seg
= bss_section
;
2458 #if defined (TC_MIPS) || defined (TC_ALPHA)
2459 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2460 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2462 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2463 if (size
<= bfd_get_gp_size (stdoutput
))
2465 bss_seg
= subseg_new (".sbss", 1);
2466 seg_info (bss_seg
)->bss
= 1;
2467 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2468 as_warn (_("error setting flags for \".sbss\": %s"),
2469 bfd_errmsg (bfd_get_error ()));
2473 subseg_set (bss_seg
, 1);
2475 if (align
> OCTETS_PER_BYTE_POWER
)
2477 record_alignment (bss_seg
, align
);
2478 frag_align (align
, 0, 0);
2481 /* Detach from old frag. */
2482 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2483 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2485 symbol_set_frag (symbolP
, frag_now
);
2486 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2490 S_SET_SIZE (symbolP
, size
);
2492 S_SET_SEGMENT (symbolP
, bss_seg
);
2495 /* The symbol may already have been created with a preceding
2496 ".globl" directive -- be careful not to step on storage class
2497 in that case. Otherwise, set it to static. */
2498 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2499 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2500 #endif /* OBJ_COFF */
2502 subseg_set (current_seg
, current_subseg
);
2506 parse_align (int align_bytes
)
2512 if (*input_line_pointer
!= ',')
2515 as_bad (_("expected alignment after size"));
2516 ignore_rest_of_line ();
2520 input_line_pointer
++;
2523 align
= get_absolute_expr (&exp
);
2524 if (exp
.X_op
== O_absent
)
2527 if (!exp
.X_unsigned
)
2529 as_warn (_("alignment negative; 0 assumed"));
2533 if (align_bytes
&& align
!= 0)
2535 /* convert to a power of 2 alignment */
2536 unsigned int alignp2
= 0;
2537 while ((align
& 1) == 0)
2538 align
>>= 1, ++alignp2
;
2541 as_bad (_("alignment not a power of 2"));
2542 ignore_rest_of_line ();
2550 /* Called from s_comm_internal after symbol name and size have been
2551 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2552 1 if this was a ".bss" directive which has a 3rd argument
2553 (alignment as a power of 2), or 2 if this was a ".bss" directive
2554 with alignment in bytes. */
2557 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2563 align
= parse_align (needs_align
- 1);
2564 if (align
== (addressT
) -1)
2568 /* Assume some objects may require alignment on some systems. */
2569 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2571 bss_alloc (symbolP
, size
, align
);
2576 s_lcomm (int needs_align
)
2578 s_comm_internal (needs_align
, s_lcomm_internal
);
2582 s_lcomm_bytes (int needs_align
)
2584 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2588 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2594 /* We permit ANY defined expression: BSD4.2 demands constants. */
2595 if ((name
= read_symbol_name ()) == NULL
)
2598 if (*input_line_pointer
!= ',')
2600 as_bad (_("expected comma after \"%s\""), name
);
2604 input_line_pointer
++;
2605 expression_and_evaluate (&exp
);
2607 if (exp
.X_op
!= O_constant
2608 && exp
.X_op
!= O_register
)
2610 as_bad (_("bad expression"));
2614 symbolP
= symbol_find_or_make (name
);
2616 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2618 /* The name might be an undefined .global symbol; be sure to
2619 keep the "external" bit. */
2620 S_SET_SEGMENT (symbolP
,
2621 (exp
.X_op
== O_constant
2624 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2628 as_bad (_("symbol `%s' is already defined"), name
);
2631 demand_empty_rest_of_line ();
2636 ignore_rest_of_line ();
2641 /* Read a line into an sb. Returns the character that ended the line
2642 or zero if there are no more lines. */
2645 get_line_sb (sb
*line
, int in_macro
)
2649 if (input_line_pointer
[-1] == '\n')
2650 bump_line_counters ();
2652 if (input_line_pointer
>= buffer_limit
)
2654 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2655 if (buffer_limit
== 0)
2659 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2660 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2661 input_line_pointer
= eol
;
2663 /* Don't skip multiple end-of-line characters, because that breaks support
2664 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2665 characters but isn't. Instead just skip one end of line character and
2666 return the character skipped so that the caller can re-insert it if
2668 return *input_line_pointer
++;
2672 get_non_macro_line_sb (sb
*line
)
2674 return get_line_sb (line
, 0);
2678 get_macro_line_sb (sb
*line
)
2680 return get_line_sb (line
, 1);
2683 /* Define a macro. This is an interface to macro.c. */
2686 s_macro (int ignore ATTRIBUTE_UNUSED
)
2695 file
= as_where (&line
);
2697 eol
= find_end_of_line (input_line_pointer
, 0);
2698 sb_build (&s
, eol
- input_line_pointer
);
2699 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2700 input_line_pointer
= eol
;
2702 if (line_label
!= NULL
)
2707 name
= S_GET_NAME (line_label
);
2708 len
= strlen (name
);
2709 sb_build (&label
, len
);
2710 sb_add_buffer (&label
, name
, len
);
2711 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2715 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2717 as_bad_where (file
, line
, err
, name
);
2720 if (line_label
!= NULL
)
2722 S_SET_SEGMENT (line_label
, absolute_section
);
2723 S_SET_VALUE (line_label
, 0);
2724 symbol_set_frag (line_label
, &zero_address_frag
);
2727 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2728 && hash_find (po_hash
, name
) != NULL
)
2731 && hash_find (po_hash
, name
+ 1) != NULL
))
2732 as_warn_where (file
,
2734 _("attempt to redefine pseudo-op `%s' ignored"),
2741 /* Handle the .mexit pseudo-op, which immediately exits a macro
2745 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2749 cond_exit_macro (macro_nest
);
2750 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2753 as_warn (_("ignoring macro exit outside a macro definition."));
2756 /* Switch in and out of MRI mode. */
2759 s_mri (int ignore ATTRIBUTE_UNUSED
)
2762 #ifdef MRI_MODE_CHANGE
2766 on
= get_absolute_expression ();
2767 #ifdef MRI_MODE_CHANGE
2768 old_flag
= flag_mri
;
2787 /* Operator precedence changes in m68k MRI mode, so we need to
2788 update the operator rankings. */
2789 expr_set_precedence ();
2791 #ifdef MRI_MODE_CHANGE
2793 MRI_MODE_CHANGE (on
);
2796 demand_empty_rest_of_line ();
2799 /* Handle changing the location counter. */
2802 do_org (segT segment
, expressionS
*exp
, int fill
)
2804 if (segment
!= now_seg
2805 && segment
!= absolute_section
2806 && segment
!= expr_section
)
2807 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2809 if (now_seg
== absolute_section
)
2812 as_warn (_("ignoring fill value in absolute section"));
2813 if (exp
->X_op
!= O_constant
)
2815 as_bad (_("only constant offsets supported in absolute section"));
2816 exp
->X_add_number
= 0;
2818 abs_section_offset
= exp
->X_add_number
;
2823 symbolS
*sym
= exp
->X_add_symbol
;
2824 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2826 if (fill
&& in_bss ())
2827 as_warn (_("ignoring fill value in section `%s'"),
2828 segment_name (now_seg
));
2830 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2832 /* Handle complex expressions. */
2833 sym
= make_expr_symbol (exp
);
2837 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2843 s_org (int ignore ATTRIBUTE_UNUSED
)
2849 #ifdef md_flush_pending_output
2850 md_flush_pending_output ();
2853 /* The m68k MRI assembler has a different meaning for .org. It
2854 means to create an absolute section at a given address. We can't
2855 support that--use a linker script instead. */
2858 as_bad (_("MRI style ORG pseudo-op not supported"));
2859 ignore_rest_of_line ();
2863 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2864 thing as a sub-segment-relative origin. Any absolute origin is
2865 given a warning, then assumed to be segment-relative. Any
2866 segmented origin expression ("foo+42") had better be in the right
2867 segment or the .org is ignored.
2869 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2870 we never know sub-segment sizes when we are reading code. BSD
2871 will crash trying to emit negative numbers of filler bytes in
2872 certain .orgs. We don't crash, but see as-write for that code.
2874 Don't make frag if need_pass_2==1. */
2875 segment
= get_known_segmented_expression (&exp
);
2876 if (*input_line_pointer
== ',')
2878 input_line_pointer
++;
2879 temp_fill
= get_absolute_expression ();
2885 do_org (segment
, &exp
, temp_fill
);
2887 demand_empty_rest_of_line ();
2890 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2891 called by the obj-format routine which handles section changing
2892 when in MRI mode. It will create a new section, and return it. It
2893 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2894 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2897 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2907 name
= input_line_pointer
;
2908 if (!ISDIGIT (*name
))
2909 c
= get_symbol_name (& name
);
2914 ++input_line_pointer
;
2916 while (ISDIGIT (*input_line_pointer
));
2918 c
= *input_line_pointer
;
2919 *input_line_pointer
= '\0';
2922 name
= xstrdup (name
);
2924 c
= restore_line_pointer (c
);
2926 seg
= subseg_new (name
, 0);
2932 ++input_line_pointer
;
2933 align
= get_absolute_expression ();
2934 record_alignment (seg
, align
);
2938 if (*input_line_pointer
== ',')
2940 c
= *++input_line_pointer
;
2942 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2945 as_bad (_("unrecognized section type"));
2946 ++input_line_pointer
;
2951 flags
= SEC_NO_FLAGS
;
2953 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2954 else if (*type
== 'D' || *type
== 'M')
2955 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2956 else if (*type
== 'R')
2957 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2958 if (flags
!= SEC_NO_FLAGS
)
2960 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2961 as_warn (_("error setting flags for \"%s\": %s"),
2962 bfd_section_name (stdoutput
, seg
),
2963 bfd_errmsg (bfd_get_error ()));
2968 /* Ignore the HP type. */
2969 if (*input_line_pointer
== ',')
2970 input_line_pointer
+= 2;
2972 demand_empty_rest_of_line ();
2974 #else /* ! TC_M68K */
2983 c
= get_symbol_name (& name
);
2985 name
= xstrdup (name
);
2987 c
= restore_line_pointer (c
);
2989 seg
= subseg_new (name
, 0);
2997 ++input_line_pointer
;
2999 c
= get_symbol_name (& sectype
);
3000 if (*sectype
== '\0')
3002 else if (strcasecmp (sectype
, "text") == 0)
3004 else if (strcasecmp (sectype
, "data") == 0)
3006 else if (strcasecmp (sectype
, "romdata") == 0)
3009 as_warn (_("unrecognized section type `%s'"), sectype
);
3010 (void) restore_line_pointer (c
);
3013 if (*input_line_pointer
== ',')
3017 ++input_line_pointer
;
3019 c
= get_symbol_name (& seccmd
);
3020 if (strcasecmp (seccmd
, "absolute") == 0)
3022 as_bad (_("absolute sections are not supported"));
3023 *input_line_pointer
= c
;
3024 ignore_rest_of_line ();
3027 else if (strcasecmp (seccmd
, "align") == 0)
3031 (void) restore_line_pointer (c
);
3032 align
= get_absolute_expression ();
3033 record_alignment (seg
, align
);
3037 as_warn (_("unrecognized section command `%s'"), seccmd
);
3038 (void) restore_line_pointer (c
);
3042 demand_empty_rest_of_line ();
3044 #else /* ! TC_I960 */
3045 /* The MRI assembler seems to use different forms of .sect for
3046 different targets. */
3047 as_bad ("MRI mode not supported for this target");
3048 ignore_rest_of_line ();
3049 #endif /* ! TC_I960 */
3050 #endif /* ! TC_M68K */
3053 /* Handle the .print pseudo-op. */
3056 s_print (int ignore ATTRIBUTE_UNUSED
)
3061 s
= demand_copy_C_string (&len
);
3064 demand_empty_rest_of_line ();
3067 /* Handle the .purgem pseudo-op. */
3070 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3072 if (is_it_end_of_statement ())
3074 demand_empty_rest_of_line ();
3084 c
= get_symbol_name (& name
);
3085 delete_macro (name
);
3086 *input_line_pointer
= c
;
3087 SKIP_WHITESPACE_AFTER_NAME ();
3089 while (*input_line_pointer
++ == ',');
3091 --input_line_pointer
;
3092 demand_empty_rest_of_line ();
3095 /* Handle the .endm/.endr pseudo-ops. */
3098 s_bad_end (int endr
)
3100 as_warn (_(".end%c encountered without preceding %s"),
3102 endr
? ".rept, .irp, or .irpc" : ".macro");
3103 demand_empty_rest_of_line ();
3106 /* Handle the .rept pseudo-op. */
3109 s_rept (int ignore ATTRIBUTE_UNUSED
)
3113 count
= (size_t) get_absolute_expression ();
3115 do_repeat (count
, "REPT", "ENDR");
3118 /* This function provides a generic repeat block implementation. It allows
3119 different directives to be used as the start/end keys. */
3122 do_repeat (size_t count
, const char *start
, const char *end
)
3127 if (((ssize_t
) count
) < 0)
3129 as_bad (_("negative count for %s - ignored"), start
);
3134 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3136 as_bad (_("%s without %s"), start
, end
);
3140 sb_build (&many
, count
* one
.len
);
3142 sb_add_sb (&many
, &one
);
3146 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3148 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3151 /* Like do_repeat except that any text matching EXPANDER in the
3152 block is replaced by the iteration count. */
3155 do_repeat_with_expander (size_t count
,
3158 const char * expander
)
3163 if (((ssize_t
) count
) < 0)
3165 as_bad (_("negative count for %s - ignored"), start
);
3170 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3172 as_bad (_("%s without %s"), start
, end
);
3178 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3180 while (count
-- > 0)
3186 sb_build (& processed
, one
.len
);
3187 sb_add_sb (& processed
, & one
);
3188 sub
= strstr (processed
.ptr
, expander
);
3189 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3190 gas_assert (len
< 8);
3191 strcpy (sub
+ len
, sub
+ 8);
3192 processed
.len
-= (8 - len
);
3193 sb_add_sb (& many
, & processed
);
3194 sb_kill (& processed
);
3199 sb_add_sb (&many
, &one
);
3203 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3205 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3208 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3209 input buffers to skip. Assumes that conditionals preceding the loop end
3210 are properly nested.
3212 This function makes it easier to implement a premature "break" out of the
3213 loop. The EXTRA arg accounts for other buffers we might have inserted,
3214 such as line substitutions. */
3217 end_repeat (int extra
)
3219 cond_exit_macro (macro_nest
);
3220 while (extra
-- >= 0)
3221 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3225 assign_symbol (char *name
, int mode
)
3229 if (name
[0] == '.' && name
[1] == '\0')
3231 /* Turn '. = mumble' into a .org mumble. */
3235 segment
= get_known_segmented_expression (&exp
);
3238 do_org (segment
, &exp
, 0);
3243 if ((symbolP
= symbol_find (name
)) == NULL
3244 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3246 symbolP
= symbol_find_or_make (name
);
3248 /* When doing symbol listings, play games with dummy fragments living
3249 outside the normal fragment chain to record the file and line info
3251 if (listing
& LISTING_SYMBOLS
)
3253 extern struct list_info_struct
*listing_tail
;
3254 fragS
*dummy_frag
= XCNEW (fragS
);
3255 dummy_frag
->line
= listing_tail
;
3256 dummy_frag
->fr_symbol
= symbolP
;
3257 symbol_set_frag (symbolP
, dummy_frag
);
3260 #if defined (OBJ_COFF) && !defined (TE_PE)
3261 /* "set" symbols are local unless otherwise specified. */
3262 SF_SET_LOCAL (symbolP
);
3266 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3268 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3269 && !S_CAN_BE_REDEFINED (symbolP
))
3271 as_bad (_("symbol `%s' is already defined"), name
);
3272 ignore_rest_of_line ();
3273 input_line_pointer
--;
3276 /* If the symbol is volatile, copy the symbol and replace the
3277 original with the copy, so that previous uses of the symbol will
3278 retain the value of the symbol at the point of use. */
3279 else if (S_IS_VOLATILE (symbolP
))
3280 symbolP
= symbol_clone (symbolP
, 1);
3284 S_SET_VOLATILE (symbolP
);
3286 S_SET_FORWARD_REF (symbolP
);
3288 pseudo_set (symbolP
);
3291 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3292 then this is .equiv, and it is an error if the symbol is already
3293 defined. If EQUIV is -1, the symbol additionally is a forward
3301 /* Especial apologies for the random logic:
3302 this just grew, and could be parsed much more simply!
3304 if ((name
= read_symbol_name ()) == NULL
)
3307 if (*input_line_pointer
!= ',')
3309 as_bad (_("expected comma after \"%s\""), name
);
3310 ignore_rest_of_line ();
3315 input_line_pointer
++;
3316 assign_symbol (name
, equiv
);
3317 demand_empty_rest_of_line ();
3331 #ifdef md_flush_pending_output
3332 md_flush_pending_output ();
3335 #ifdef md_cons_align
3340 stop
= mri_comment_field (&stopc
);
3342 /* In m68k MRI mode, we need to align to a word boundary, unless
3344 if (flag_m68k_mri
&& mult
> 1)
3346 if (now_seg
== absolute_section
)
3348 abs_section_offset
+= abs_section_offset
& 1;
3349 if (line_label
!= NULL
)
3350 S_SET_VALUE (line_label
, abs_section_offset
);
3352 else if (mri_common_symbol
!= NULL
)
3356 mri_val
= S_GET_VALUE (mri_common_symbol
);
3357 if ((mri_val
& 1) != 0)
3359 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3360 if (line_label
!= NULL
)
3362 expressionS
*symexp
;
3364 symexp
= symbol_get_value_expression (line_label
);
3365 know (symexp
->X_op
== O_symbol
);
3366 know (symexp
->X_add_symbol
== mri_common_symbol
);
3367 symexp
->X_add_number
+= 1;
3373 do_align (1, (char *) NULL
, 0, 0);
3374 if (line_label
!= NULL
)
3376 symbol_set_frag (line_label
, frag_now
);
3377 S_SET_VALUE (line_label
, frag_now_fix ());
3387 if (*input_line_pointer
== ',')
3389 ++input_line_pointer
;
3394 val
.X_op
= O_constant
;
3395 val
.X_add_number
= 0;
3398 if ((val
.X_op
!= O_constant
3399 || val
.X_add_number
< - 0x80
3400 || val
.X_add_number
> 0xff
3401 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3402 && (now_seg
!= absolute_section
&& !in_bss ()))
3404 resolve_expression (&exp
);
3405 if (exp
.X_op
!= O_constant
)
3406 as_bad (_("unsupported variable size or fill value"));
3411 /* PR 20901: Check for excessive values.
3412 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3413 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3414 as_bad (_("size value for space directive too large: %lx"),
3415 (long) exp
.X_add_number
);
3420 bytes
= mult
* exp
.X_add_number
;
3422 for (i
= 0; i
< exp
.X_add_number
; i
++)
3423 emit_expr (&val
, mult
);
3429 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3430 resolve_expression (&exp
);
3432 if (exp
.X_op
== O_constant
)
3436 repeat
= exp
.X_add_number
;
3443 as_warn (_(".space repeat count is zero, ignored"));
3444 else if (repeat
< 0)
3445 as_warn (_(".space repeat count is negative, ignored"));
3449 /* If we are in the absolute section, just bump the offset. */
3450 if (now_seg
== absolute_section
)
3452 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3453 as_warn (_("ignoring fill value in absolute section"));
3454 abs_section_offset
+= repeat
;
3458 /* If we are secretly in an MRI common section, then
3459 creating space just increases the size of the common
3461 if (mri_common_symbol
!= NULL
)
3463 S_SET_VALUE (mri_common_symbol
,
3464 S_GET_VALUE (mri_common_symbol
) + repeat
);
3469 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3470 (offsetT
) repeat
, (char *) 0);
3474 if (now_seg
== absolute_section
)
3476 as_bad (_("space allocation too complex in absolute section"));
3477 subseg_set (text_section
, 0);
3480 if (mri_common_symbol
!= NULL
)
3482 as_bad (_("space allocation too complex in common section"));
3483 mri_common_symbol
= NULL
;
3487 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3488 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3491 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3492 as_warn (_("ignoring fill value in section `%s'"),
3493 segment_name (now_seg
));
3495 *p
= val
.X_add_number
;
3500 /* In MRI mode, after an odd number of bytes, we must align to an
3501 even word boundary, unless the next instruction is a dc.b, ds.b
3503 if (flag_mri
&& (bytes
& 1) != 0)
3504 mri_pending_align
= 1;
3506 demand_empty_rest_of_line ();
3509 mri_comment_end (stop
, stopc
);
3513 s_nops (int ignore ATTRIBUTE_UNUSED
)
3518 #ifdef md_flush_pending_output
3519 md_flush_pending_output ();
3522 #ifdef md_cons_align
3528 if (*input_line_pointer
== ',')
3530 ++input_line_pointer
;
3535 val
.X_op
= O_constant
;
3536 val
.X_add_number
= 0;
3539 if (val
.X_op
== O_constant
)
3541 if (val
.X_add_number
< 0)
3543 as_warn (_("negative nop control byte, ignored"));
3544 val
.X_add_number
= 0;
3549 /* Store the no-op instruction control byte in the first byte
3552 symbolS
*sym
= make_expr_symbol (&exp
);
3553 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3554 sym
, (offsetT
) 0, (char *) 0);
3555 *p
= val
.X_add_number
;
3559 as_bad (_("unsupported variable nop control in .nops directive"));
3561 demand_empty_rest_of_line ();
3564 /* This is like s_space, but the value is a floating point number with
3565 the given precision. This is for the MRI dcb.s pseudo-op and
3569 s_float_space (int float_type
)
3573 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3577 #ifdef md_cons_align
3582 stop
= mri_comment_field (&stopc
);
3584 count
= get_absolute_expression ();
3587 if (*input_line_pointer
!= ',')
3589 as_bad (_("missing value"));
3590 ignore_rest_of_line ();
3592 mri_comment_end (stop
, stopc
);
3596 ++input_line_pointer
;
3600 /* Skip any 0{letter} that may be present. Don't even check if the
3601 * letter is legal. */
3602 if (input_line_pointer
[0] == '0'
3603 && ISALPHA (input_line_pointer
[1]))
3604 input_line_pointer
+= 2;
3606 /* Accept :xxxx, where the x's are hex digits, for a floating point
3607 with the exact digits specified. */
3608 if (input_line_pointer
[0] == ':')
3610 flen
= hex_float (float_type
, temp
);
3613 ignore_rest_of_line ();
3615 mri_comment_end (stop
, stopc
);
3623 err
= md_atof (float_type
, temp
, &flen
);
3624 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3625 know (err
!= NULL
|| flen
> 0);
3628 as_bad (_("bad floating literal: %s"), err
);
3629 ignore_rest_of_line ();
3631 mri_comment_end (stop
, stopc
);
3636 while (--count
>= 0)
3640 p
= frag_more (flen
);
3641 memcpy (p
, temp
, (unsigned int) flen
);
3644 demand_empty_rest_of_line ();
3647 mri_comment_end (stop
, stopc
);
3650 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3653 s_struct (int ignore ATTRIBUTE_UNUSED
)
3659 stop
= mri_comment_field (&stopc
);
3660 abs_section_offset
= get_absolute_expression ();
3661 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3662 /* The ELF backend needs to know that we are changing sections, so
3663 that .previous works correctly. */
3665 obj_elf_section_change_hook ();
3667 subseg_set (absolute_section
, 0);
3668 demand_empty_rest_of_line ();
3670 mri_comment_end (stop
, stopc
);
3674 s_text (int ignore ATTRIBUTE_UNUSED
)
3678 temp
= get_absolute_expression ();
3679 subseg_set (text_section
, (subsegT
) temp
);
3680 demand_empty_rest_of_line ();
3683 /* .weakref x, y sets x as an alias to y that, as long as y is not
3684 referenced directly, will cause y to become a weak symbol. */
3686 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3693 if ((name
= read_symbol_name ()) == NULL
)
3696 symbolP
= symbol_find_or_make (name
);
3698 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3700 if (!S_IS_VOLATILE (symbolP
))
3702 as_bad (_("symbol `%s' is already defined"), name
);
3705 symbolP
= symbol_clone (symbolP
, 1);
3706 S_CLEAR_VOLATILE (symbolP
);
3711 if (*input_line_pointer
!= ',')
3713 as_bad (_("expected comma after \"%s\""), name
);
3717 input_line_pointer
++;
3722 if ((name
= read_symbol_name ()) == NULL
)
3725 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3726 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3728 symbolP2
= symbol_find_or_make (name
);
3729 S_SET_WEAKREFD (symbolP2
);
3733 symbolS
*symp
= symbolP2
;
3735 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3737 expressionS
*expP
= symbol_get_value_expression (symp
);
3739 gas_assert (expP
->X_op
== O_symbol
3740 && expP
->X_add_number
== 0);
3741 symp
= expP
->X_add_symbol
;
3743 if (symp
== symbolP
)
3747 loop
= concat (S_GET_NAME (symbolP
),
3748 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3751 while (symp
!= symbolP
)
3753 char *old_loop
= loop
;
3755 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3756 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3757 (const char *) NULL
);
3761 as_bad (_("%s: would close weakref loop: %s"),
3762 S_GET_NAME (symbolP
), loop
);
3766 ignore_rest_of_line ();
3770 /* Short-circuiting instead of just checking here might speed
3771 things up a tiny little bit, but loop error messages would
3772 miss intermediate links. */
3773 /* symbolP2 = symp; */
3776 memset (&exp
, 0, sizeof (exp
));
3777 exp
.X_op
= O_symbol
;
3778 exp
.X_add_symbol
= symbolP2
;
3780 S_SET_SEGMENT (symbolP
, undefined_section
);
3781 symbol_set_value_expression (symbolP
, &exp
);
3782 symbol_set_frag (symbolP
, &zero_address_frag
);
3783 S_SET_WEAKREFR (symbolP
);
3785 demand_empty_rest_of_line ();
3790 ignore_rest_of_line ();
3796 /* Verify that we are at the end of a line. If not, issue an error and
3800 demand_empty_rest_of_line (void)
3803 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3804 input_line_pointer
++;
3807 if (ISPRINT (*input_line_pointer
))
3808 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3809 *input_line_pointer
);
3811 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3812 *input_line_pointer
);
3813 ignore_rest_of_line ();
3816 /* Return pointing just after end-of-line. */
3817 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3820 /* Silently advance to the end of line. Use this after already having
3821 issued an error about something bad. */
3824 ignore_rest_of_line (void)
3826 while (input_line_pointer
< buffer_limit
3827 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3828 input_line_pointer
++;
3830 input_line_pointer
++;
3832 /* Return pointing just after end-of-line. */
3833 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3836 /* Sets frag for given symbol to zero_address_frag, except when the
3837 symbol frag is already set to a dummy listing frag. */
3840 set_zero_frag (symbolS
*symbolP
)
3842 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3843 symbol_set_frag (symbolP
, &zero_address_frag
);
3846 /* In: Pointer to a symbol.
3847 Input_line_pointer->expression.
3849 Out: Input_line_pointer->just after any whitespace after expression.
3850 Tried to set symbol to value of expression.
3851 Will change symbols type, value, and frag; */
3854 pseudo_set (symbolS
*symbolP
)
3859 know (symbolP
); /* NULL pointer is logic error. */
3861 if (!S_IS_FORWARD_REF (symbolP
))
3862 (void) expression (&exp
);
3864 (void) deferred_expression (&exp
);
3866 if (exp
.X_op
== O_illegal
)
3867 as_bad (_("illegal expression"));
3868 else if (exp
.X_op
== O_absent
)
3869 as_bad (_("missing expression"));
3870 else if (exp
.X_op
== O_big
)
3872 if (exp
.X_add_number
> 0)
3873 as_bad (_("bignum invalid"));
3875 as_bad (_("floating point number invalid"));
3877 else if (exp
.X_op
== O_subtract
3878 && !S_IS_FORWARD_REF (symbolP
)
3879 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3880 && (symbol_get_frag (exp
.X_add_symbol
)
3881 == symbol_get_frag (exp
.X_op_symbol
)))
3883 exp
.X_op
= O_constant
;
3884 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3885 - S_GET_VALUE (exp
.X_op_symbol
));
3888 if (symbol_section_p (symbolP
))
3890 as_bad ("attempt to set value of section symbol");
3899 exp
.X_add_number
= 0;
3902 S_SET_SEGMENT (symbolP
, absolute_section
);
3903 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3904 set_zero_frag (symbolP
);
3908 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3909 if (S_IS_EXTERNAL (symbolP
))
3911 as_bad ("can't equate global symbol `%s' with register name",
3912 S_GET_NAME (symbolP
));
3916 S_SET_SEGMENT (symbolP
, reg_section
);
3917 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3918 set_zero_frag (symbolP
);
3919 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3923 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3924 /* For x=undef+const, create an expression symbol.
3925 For x=x+const, just update x except when x is an undefined symbol
3926 For x=defined+const, evaluate x. */
3927 if (symbolP
== exp
.X_add_symbol
3928 && (seg
!= undefined_section
3929 || !symbol_constant_p (symbolP
)))
3931 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3934 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3936 symbolS
*s
= exp
.X_add_symbol
;
3938 if (S_IS_COMMON (s
))
3939 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3940 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3942 S_SET_SEGMENT (symbolP
, seg
);
3943 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3944 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3945 copy_symbol_attributes (symbolP
, s
);
3948 S_SET_SEGMENT (symbolP
, undefined_section
);
3949 symbol_set_value_expression (symbolP
, &exp
);
3950 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3951 set_zero_frag (symbolP
);
3955 /* The value is some complex expression. */
3956 S_SET_SEGMENT (symbolP
, expr_section
);
3957 symbol_set_value_expression (symbolP
, &exp
);
3958 set_zero_frag (symbolP
);
3965 CONStruct more frag of .bytes, or .words etc.
3966 Should need_pass_2 be 1 then emit no frag(s).
3967 This understands EXPRESSIONS.
3971 This has a split personality. We use expression() to read the
3972 value. We can detect if the value won't fit in a byte or word.
3973 But we can't detect if expression() discarded significant digits
3974 in the case of a long. Not worth the crocks required to fix it. */
3976 /* Select a parser for cons expressions. */
3978 /* Some targets need to parse the expression in various fancy ways.
3979 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3980 (for example, the HPPA does this). Otherwise, you can define
3981 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3982 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3983 are defined, which is the normal case, then only simple expressions
3988 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3991 #ifndef TC_PARSE_CONS_EXPRESSION
3992 #ifdef BITFIELD_CONS_EXPRESSIONS
3993 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3994 (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3996 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3998 #ifdef REPEAT_CONS_EXPRESSIONS
3999 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4000 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
4002 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
4005 /* If we haven't gotten one yet, just call expression. */
4006 #ifndef TC_PARSE_CONS_EXPRESSION
4007 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
4008 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
4013 do_parse_cons_expression (expressionS
*exp
,
4014 int nbytes ATTRIBUTE_UNUSED
)
4016 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4020 /* Worker to do .byte etc statements.
4021 Clobbers input_line_pointer and checks end-of-line. */
4024 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4032 #ifdef md_flush_pending_output
4033 md_flush_pending_output ();
4037 stop
= mri_comment_field (&stopc
);
4039 if (is_it_end_of_statement ())
4041 demand_empty_rest_of_line ();
4043 mri_comment_end (stop
, stopc
);
4047 #ifdef TC_ADDRESS_BYTES
4049 nbytes
= TC_ADDRESS_BYTES ();
4052 #ifdef md_cons_align
4053 md_cons_align (nbytes
);
4059 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4060 #ifdef TC_CONS_FIX_CHECK
4061 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4063 if (*cur_fix
!= NULL
)
4064 cur_fix
= &(*cur_fix
)->fx_next
;
4069 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4074 if (*input_line_pointer
== '"')
4076 as_bad (_("unexpected `\"' in expression"));
4077 ignore_rest_of_line ();
4081 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4086 if (exp
.X_op
== O_symbol
)
4087 exp
.X_op
= O_symbol_rva
;
4089 as_fatal (_("rva without symbol"));
4091 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4092 #ifdef TC_CONS_FIX_CHECK
4093 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4097 while (*input_line_pointer
++ == ',');
4099 /* In MRI mode, after an odd number of bytes, we must align to an
4100 even word boundary, unless the next instruction is a dc.b, ds.b
4102 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4103 mri_pending_align
= 1;
4105 input_line_pointer
--; /* Put terminator back into stream. */
4107 demand_empty_rest_of_line ();
4110 mri_comment_end (stop
, stopc
);
4116 cons_worker (size
, 0);
4122 cons_worker (size
, 1);
4125 /* .reloc offset, reloc_name, symbol+addend. */
4128 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4135 struct reloc_list
*reloc
;
4136 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4137 static struct _bfd_rel bfd_relocs
[] =
4139 { "NONE", BFD_RELOC_NONE
},
4140 { "8", BFD_RELOC_8
},
4141 { "16", BFD_RELOC_16
},
4142 { "32", BFD_RELOC_32
},
4143 { "64", BFD_RELOC_64
}
4146 reloc
= XNEW (struct reloc_list
);
4149 stop
= mri_comment_field (&stopc
);
4158 as_bad (_("missing or bad offset expression"));
4161 exp
.X_add_symbol
= section_symbol (now_seg
);
4162 exp
.X_op
= O_symbol
;
4165 if (exp
.X_add_number
== 0)
4167 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4172 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4177 if (*input_line_pointer
!= ',')
4179 as_bad (_("missing reloc type"));
4183 ++input_line_pointer
;
4185 c
= get_symbol_name (& r_name
);
4186 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4190 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4191 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4193 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4194 bfd_relocs
[i
].code
);
4199 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4200 *input_line_pointer
= c
;
4201 if (reloc
->u
.a
.howto
== NULL
)
4203 as_bad (_("unrecognized reloc type"));
4207 exp
.X_op
= O_absent
;
4208 SKIP_WHITESPACE_AFTER_NAME ();
4209 if (*input_line_pointer
== ',')
4211 ++input_line_pointer
;
4219 as_bad (_("bad reloc expression"));
4221 ignore_rest_of_line ();
4224 mri_comment_end (stop
, stopc
);
4227 reloc
->u
.a
.sym
= NULL
;
4228 reloc
->u
.a
.addend
= 0;
4231 reloc
->u
.a
.sym
= NULL
;
4232 reloc
->u
.a
.addend
= exp
.X_add_number
;
4235 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4236 reloc
->u
.a
.addend
= exp
.X_add_number
;
4239 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4240 reloc
->u
.a
.addend
= 0;
4244 reloc
->file
= as_where (&reloc
->line
);
4245 reloc
->next
= reloc_list
;
4248 demand_empty_rest_of_line ();
4250 mri_comment_end (stop
, stopc
);
4253 /* Put the contents of expression EXP into the object file using
4254 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4257 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4259 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4263 emit_expr_with_reloc (expressionS
*exp
,
4264 unsigned int nbytes
,
4265 TC_PARSE_CONS_RETURN_TYPE reloc
)
4269 valueT extra_digit
= 0;
4271 /* Don't do anything if we are going to make another pass. */
4276 dot_value
= frag_now_fix ();
4277 dot_frag
= frag_now
;
4281 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4282 appear as a four byte positive constant in the .line section,
4283 followed by a 2 byte 0xffff. Look for that case here. */
4285 static int dwarf_line
= -1;
4287 if (strcmp (segment_name (now_seg
), ".line") != 0)
4289 else if (dwarf_line
>= 0
4291 && exp
->X_op
== O_constant
4292 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4293 listing_source_line ((unsigned int) dwarf_line
);
4294 else if (nbytes
== 4
4295 && exp
->X_op
== O_constant
4296 && exp
->X_add_number
>= 0)
4297 dwarf_line
= exp
->X_add_number
;
4302 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4303 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4304 AT_sibling (0x12) followed by a four byte address of the sibling
4305 followed by a 2 byte AT_name (0x38) followed by the name of the
4306 file. We look for that case here. */
4308 static int dwarf_file
= 0;
4310 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4312 else if (dwarf_file
== 0
4314 && exp
->X_op
== O_constant
4315 && exp
->X_add_number
== 0x11)
4317 else if (dwarf_file
== 1
4319 && exp
->X_op
== O_constant
4320 && exp
->X_add_number
== 0x12)
4322 else if (dwarf_file
== 2
4325 else if (dwarf_file
== 3
4327 && exp
->X_op
== O_constant
4328 && exp
->X_add_number
== 0x38)
4333 /* The variable dwarf_file_string tells stringer that the string
4334 may be the name of the source file. */
4335 if (dwarf_file
== 4)
4336 dwarf_file_string
= 1;
4338 dwarf_file_string
= 0;
4343 if (check_eh_frame (exp
, &nbytes
))
4348 /* Handle a negative bignum. */
4350 && exp
->X_add_number
== 0
4351 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4352 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4355 unsigned long carry
;
4357 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4359 /* Negate the bignum: one's complement each digit and add 1. */
4361 for (i
= 0; i
< exp
->X_add_number
; i
++)
4365 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4368 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4369 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4372 /* We can ignore any carry out, because it will be handled by
4373 extra_digit if it is needed. */
4375 extra_digit
= (valueT
) -1;
4379 if (op
== O_absent
|| op
== O_illegal
)
4381 as_warn (_("zero assumed for missing expression"));
4382 exp
->X_add_number
= 0;
4385 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4387 as_bad (_("floating point number invalid"));
4388 exp
->X_add_number
= 0;
4391 else if (op
== O_register
)
4393 as_warn (_("register value used as expression"));
4397 /* Allow `.word 0' in the absolute section. */
4398 if (now_seg
== absolute_section
)
4400 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4401 as_bad (_("attempt to store value in absolute section"));
4402 abs_section_offset
+= nbytes
;
4406 /* Allow `.word 0' in BSS style sections. */
4407 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4408 as_bad (_("attempt to store non-zero value in section `%s'"),
4409 segment_name (now_seg
));
4411 p
= frag_more ((int) nbytes
);
4413 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4415 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4419 #ifndef WORKING_DOT_WORD
4420 /* If we have the difference of two symbols in a word, save it on
4421 the broken_words list. See the code in write.c. */
4422 if (op
== O_subtract
&& nbytes
== 2)
4424 struct broken_word
*x
;
4426 x
= XNEW (struct broken_word
);
4427 x
->next_broken_word
= broken_words
;
4430 x
->subseg
= now_subseg
;
4432 x
->word_goes_here
= p
;
4434 x
->add
= exp
->X_add_symbol
;
4435 x
->sub
= exp
->X_op_symbol
;
4436 x
->addnum
= exp
->X_add_number
;
4444 /* If we have an integer, but the number of bytes is too large to
4445 pass to md_number_to_chars, handle it as a bignum. */
4446 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4448 extra_digit
= exp
->X_unsigned
? 0 : -1;
4449 convert_to_bignum (exp
, !exp
->X_unsigned
);
4453 if (op
== O_constant
)
4461 /* JF << of >= number of bits in the object is undefined. In
4462 particular SPARC (Sun 4) has problems. */
4463 if (nbytes
>= sizeof (valueT
))
4466 if (nbytes
> sizeof (valueT
))
4469 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4473 /* Don't store these bits. */
4474 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4475 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4478 unmask
= ~mask
; /* Do store these bits. */
4481 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4482 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4485 get
= exp
->X_add_number
;
4487 if ((get
& mask
) != 0
4488 && ((get
& mask
) != mask
4489 || (get
& hibit
) == 0))
4491 /* Leading bits contain both 0s & 1s. */
4492 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4494 as_warn (_("value 0x%llx truncated to 0x%llx"),
4495 (unsigned long long) get
, (unsigned long long) use
);
4497 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4498 (unsigned long long) get
, (unsigned long long) use
);
4501 as_warn (_("value 0x%lx truncated to 0x%lx"),
4502 (unsigned long) get
, (unsigned long) use
);
4505 /* Put bytes in right order. */
4506 md_number_to_chars (p
, use
, (int) nbytes
);
4508 else if (op
== O_big
)
4511 LITTLENUM_TYPE
*nums
;
4513 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4516 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4520 LITTLENUM_TYPE sign
= 0;
4521 if ((generic_bignum
[--i
]
4522 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4523 sign
= ~(LITTLENUM_TYPE
) 0;
4525 while (++i
< exp
->X_add_number
)
4526 if (generic_bignum
[i
] != sign
)
4529 else if (nbytes
== 1)
4531 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4532 Check that bits 8.. of generic_bignum[0] match bit 7
4533 and that they match all of generic_bignum[1..exp->X_add_number]. */
4534 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4535 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4537 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4539 while (++i
< exp
->X_add_number
)
4540 if (generic_bignum
[i
] != sign
)
4545 if (i
< exp
->X_add_number
)
4546 as_warn (ngettext ("bignum truncated to %d byte",
4547 "bignum truncated to %d bytes",
4555 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4558 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4560 if (target_big_endian
)
4562 while (nbytes
> size
)
4564 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4565 nbytes
-= CHARS_PER_LITTLENUM
;
4566 p
+= CHARS_PER_LITTLENUM
;
4569 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4570 while (size
>= CHARS_PER_LITTLENUM
)
4573 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4574 size
-= CHARS_PER_LITTLENUM
;
4575 p
+= CHARS_PER_LITTLENUM
;
4580 nums
= generic_bignum
;
4581 while (size
>= CHARS_PER_LITTLENUM
)
4583 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4585 size
-= CHARS_PER_LITTLENUM
;
4586 p
+= CHARS_PER_LITTLENUM
;
4587 nbytes
-= CHARS_PER_LITTLENUM
;
4590 while (nbytes
>= CHARS_PER_LITTLENUM
)
4592 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4593 nbytes
-= CHARS_PER_LITTLENUM
;
4594 p
+= CHARS_PER_LITTLENUM
;
4599 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4603 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4604 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4607 unsigned int size
= nbytes
;
4609 memset (p
, 0, size
);
4611 /* Generate a fixS to record the symbol value. */
4613 #ifdef TC_CONS_FIX_NEW
4614 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4616 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4618 reloc_howto_type
*reloc_howto
;
4620 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4621 size
= bfd_get_reloc_size (reloc_howto
);
4625 as_bad (ngettext ("%s relocations do not fit in %u byte",
4626 "%s relocations do not fit in %u bytes",
4628 reloc_howto
->name
, nbytes
);
4631 else if (target_big_endian
)
4632 offset
= nbytes
- size
;
4653 as_bad (_("unsupported BFD relocation size %u"), size
);
4656 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4661 #ifdef BITFIELD_CONS_EXPRESSIONS
4663 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4664 w:x,y:z, where w and y are bitwidths and x and y are values. They
4665 then pack them all together. We do a little better in that we allow
4666 them in words, longs, etc. and we'll pack them in target byte order
4669 The rules are: pack least significant bit first, if a field doesn't
4670 entirely fit, put it in the next unit. Overflowing the bitfield is
4671 explicitly *not* even a warning. The bitwidth should be considered
4674 To use this function the tc-XXX.h file should define
4675 BITFIELD_CONS_EXPRESSIONS. */
4678 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
)
4680 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4681 char *hold
= input_line_pointer
;
4683 (void) expression (exp
);
4685 if (*input_line_pointer
== ':')
4692 unsigned long width
;
4694 if (*input_line_pointer
!= ':')
4696 input_line_pointer
= hold
;
4698 } /* Next piece is not a bitfield. */
4700 /* In the general case, we can't allow
4701 full expressions with symbol
4702 differences and such. The relocation
4703 entries for symbols not defined in this
4704 assembly would require arbitrary field
4705 widths, positions, and masks which most
4706 of our current object formats don't
4709 In the specific case where a symbol
4710 *is* defined in this assembly, we
4711 *could* build fixups and track it, but
4712 this could lead to confusion for the
4713 backends. I'm lazy. I'll take any
4714 SEG_ABSOLUTE. I think that means that
4715 you can use a previous .set or
4716 .equ type symbol. xoxorich. */
4718 if (exp
->X_op
== O_absent
)
4720 as_warn (_("using a bit field width of zero"));
4721 exp
->X_add_number
= 0;
4722 exp
->X_op
= O_constant
;
4723 } /* Implied zero width bitfield. */
4725 if (exp
->X_op
!= O_constant
)
4727 *input_line_pointer
= '\0';
4728 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4729 *input_line_pointer
= ':';
4730 demand_empty_rest_of_line ();
4732 } /* Too complex. */
4734 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4736 as_warn (ngettext ("field width %lu too big to fit in %d byte:"
4737 " truncated to %d bits",
4738 "field width %lu too big to fit in %d bytes:"
4739 " truncated to %d bits",
4741 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4742 width
= BITS_PER_CHAR
* nbytes
;
4745 if (width
> bits_available
)
4747 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4748 input_line_pointer
= hold
;
4749 exp
->X_add_number
= value
;
4754 hold
= ++input_line_pointer
;
4756 (void) expression (exp
);
4757 if (exp
->X_op
!= O_constant
)
4759 char cache
= *input_line_pointer
;
4761 *input_line_pointer
= '\0';
4762 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4763 *input_line_pointer
= cache
;
4764 demand_empty_rest_of_line ();
4766 } /* Too complex. */
4768 value
|= ((~(-(1 << width
)) & exp
->X_add_number
)
4769 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4771 if ((bits_available
-= width
) == 0
4772 || is_it_end_of_statement ()
4773 || *input_line_pointer
!= ',')
4776 } /* All the bitfields we're gonna get. */
4778 hold
= ++input_line_pointer
;
4779 (void) expression (exp
);
4782 exp
->X_add_number
= value
;
4783 exp
->X_op
= O_constant
;
4784 exp
->X_unsigned
= 1;
4785 exp
->X_extrabit
= 0;
4789 #endif /* BITFIELD_CONS_EXPRESSIONS */
4791 /* Handle an MRI style string expression. */
4795 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4797 if (*input_line_pointer
!= '\''
4798 && (input_line_pointer
[1] != '\''
4799 || (*input_line_pointer
!= 'A'
4800 && *input_line_pointer
!= 'E')))
4801 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4805 unsigned int result
= 0;
4807 /* An MRI style string. Cut into as many bytes as will fit into
4808 a nbyte chunk, left justify if necessary, and separate with
4809 commas so we can try again later. */
4810 if (*input_line_pointer
== 'A')
4811 ++input_line_pointer
;
4812 else if (*input_line_pointer
== 'E')
4814 as_bad (_("EBCDIC constants are not supported"));
4815 ++input_line_pointer
;
4818 input_line_pointer
++;
4819 for (scan
= 0; scan
< nbytes
; scan
++)
4821 if (*input_line_pointer
== '\'')
4823 if (input_line_pointer
[1] == '\'')
4825 input_line_pointer
++;
4830 result
= (result
<< 8) | (*input_line_pointer
++);
4834 while (scan
< nbytes
)
4840 /* Create correct expression. */
4841 exp
->X_op
= O_constant
;
4842 exp
->X_add_number
= result
;
4844 /* Fake it so that we can read the next char too. */
4845 if (input_line_pointer
[0] != '\'' ||
4846 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4848 input_line_pointer
-= 2;
4849 input_line_pointer
[0] = ',';
4850 input_line_pointer
[1] = '\'';
4853 input_line_pointer
++;
4856 #endif /* TC_M68K */
4858 #ifdef REPEAT_CONS_EXPRESSIONS
4860 /* Parse a repeat expression for cons. This is used by the MIPS
4861 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4862 object file COUNT times.
4864 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4867 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4874 if (*input_line_pointer
!= ':')
4876 /* No repeat count. */
4880 ++input_line_pointer
;
4881 expression (&count
);
4882 if (count
.X_op
!= O_constant
4883 || count
.X_add_number
<= 0)
4885 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4889 /* The cons function is going to output this expression once. So we
4890 output it count - 1 times. */
4891 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4892 emit_expr (exp
, nbytes
);
4895 #endif /* REPEAT_CONS_EXPRESSIONS */
4897 /* Parse a floating point number represented as a hex constant. This
4898 permits users to specify the exact bits they want in the floating
4902 hex_float (int float_type
, char *bytes
)
4934 as_bad (_("unknown floating type type '%c'"), float_type
);
4938 /* It would be nice if we could go through expression to parse the
4939 hex constant, but if we get a bignum it's a pain to sort it into
4940 the buffer correctly. */
4942 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4946 /* The MRI assembler accepts arbitrary underscores strewn about
4947 through the hex constant, so we ignore them as well. */
4948 if (*input_line_pointer
== '_')
4950 ++input_line_pointer
;
4956 as_warn (_("floating point constant too large"));
4959 d
= hex_value (*input_line_pointer
) << 4;
4960 ++input_line_pointer
;
4961 while (*input_line_pointer
== '_')
4962 ++input_line_pointer
;
4963 if (hex_p (*input_line_pointer
))
4965 d
+= hex_value (*input_line_pointer
);
4966 ++input_line_pointer
;
4968 if (target_big_endian
)
4971 bytes
[length
- i
- 1] = d
;
4977 if (target_big_endian
)
4978 memset (bytes
+ i
, 0, length
- i
);
4980 memset (bytes
, 0, length
- i
);
4988 CONStruct some more frag chars of .floats .ffloats etc.
4989 Makes 0 or more new frags.
4990 If need_pass_2 == 1, no frags are emitted.
4991 This understands only floating literals, not expressions. Sorry.
4993 A floating constant is defined by atof_generic(), except it is preceded
4994 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4995 reading, I decided to be incompatible. This always tries to give you
4996 rounded bits to the precision of the pseudo-op. Former AS did premature
4997 truncation, restored noisy bits instead of trailing 0s AND gave you
4998 a choice of 2 flavours of noise according to which of 2 floating-point
4999 scanners you directed AS to use.
5001 In: input_line_pointer->whitespace before, or '0' of flonum. */
5004 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
5005 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
5008 int length
; /* Number of chars in an object. */
5009 const char *err
; /* Error from scanning floating literal. */
5010 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
5012 if (is_it_end_of_statement ())
5014 demand_empty_rest_of_line ();
5018 if (now_seg
== absolute_section
)
5020 as_bad (_("attempt to store float in absolute section"));
5021 ignore_rest_of_line ();
5027 as_bad (_("attempt to store float in section `%s'"),
5028 segment_name (now_seg
));
5029 ignore_rest_of_line ();
5033 #ifdef md_flush_pending_output
5034 md_flush_pending_output ();
5037 #ifdef md_cons_align
5043 /* input_line_pointer->1st char of a flonum (we hope!). */
5046 /* Skip any 0{letter} that may be present. Don't even check if the
5047 letter is legal. Someone may invent a "z" format and this routine
5048 has no use for such information. Lusers beware: you get
5049 diagnostics if your input is ill-conditioned. */
5050 if (input_line_pointer
[0] == '0'
5051 && ISALPHA (input_line_pointer
[1]))
5052 input_line_pointer
+= 2;
5054 /* Accept :xxxx, where the x's are hex digits, for a floating
5055 point with the exact digits specified. */
5056 if (input_line_pointer
[0] == ':')
5058 ++input_line_pointer
;
5059 length
= hex_float (float_type
, temp
);
5062 ignore_rest_of_line ();
5068 err
= md_atof (float_type
, temp
, &length
);
5069 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
5070 know (err
!= NULL
|| length
> 0);
5073 as_bad (_("bad floating literal: %s"), err
);
5074 ignore_rest_of_line ();
5085 #ifdef REPEAT_CONS_EXPRESSIONS
5086 if (*input_line_pointer
== ':')
5088 expressionS count_exp
;
5090 ++input_line_pointer
;
5091 expression (&count_exp
);
5093 if (count_exp
.X_op
!= O_constant
5094 || count_exp
.X_add_number
<= 0)
5095 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
5097 count
= count_exp
.X_add_number
;
5101 while (--count
>= 0)
5103 p
= frag_more (length
);
5104 memcpy (p
, temp
, (unsigned int) length
);
5109 while (*input_line_pointer
++ == ',');
5111 /* Put terminator back into stream. */
5112 --input_line_pointer
;
5113 demand_empty_rest_of_line ();
5118 Note - we are using the DWARF standard's definition of LEB128 encoding
5119 where each 7-bit value is a stored in a byte, *not* an octet. This
5120 means that on targets where a byte contains multiple octets there is
5121 a *huge waste of space*. (This also means that we do not have to
5122 have special versions of these functions for when OCTETS_PER_BYTE_POWER
5125 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
5126 we would then have to consider whether multiple, successive LEB128
5127 values should be packed into the bytes without padding (bad idea) or
5128 whether each LEB128 number is padded out to a whole number of bytes.
5129 Plus you have to decide on the endianness of packing octets into a
5132 /* Return the size of a LEB128 value in bytes. */
5134 static inline unsigned int
5135 sizeof_sleb128 (offsetT value
)
5142 byte
= (value
& 0x7f);
5143 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5144 Fortunately, we can structure things so that the extra work reduces
5145 to a noop on systems that do things "properly". */
5146 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5149 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5150 || ((value
== -1) && ((byte
& 0x40) != 0))));
5155 static inline unsigned int
5156 sizeof_uleb128 (valueT value
)
5171 sizeof_leb128 (valueT value
, int sign
)
5174 return sizeof_sleb128 ((offsetT
) value
);
5176 return sizeof_uleb128 (value
);
5179 /* Output a LEB128 value. Returns the number of bytes used. */
5181 static inline unsigned int
5182 output_sleb128 (char *p
, offsetT value
)
5189 unsigned byte
= (value
& 0x7f);
5191 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5192 Fortunately, we can structure things so that the extra work reduces
5193 to a noop on systems that do things "properly". */
5194 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5196 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5197 || ((value
== -1) && ((byte
& 0x40) != 0))));
5208 static inline unsigned int
5209 output_uleb128 (char *p
, valueT value
)
5215 unsigned byte
= (value
& 0x7f);
5219 /* More bytes to follow. */
5230 output_leb128 (char *p
, valueT value
, int sign
)
5233 return output_sleb128 (p
, (offsetT
) value
);
5235 return output_uleb128 (p
, value
);
5238 /* Do the same for bignums. We combine sizeof with output here in that
5239 we don't output for NULL values of P. It isn't really as critical as
5240 for "normal" values that this be streamlined. Returns the number of
5243 static inline unsigned int
5244 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5251 /* Strip leading sign extensions off the bignum. */
5253 && bignum
[size
- 1] == LITTLENUM_MASK
5254 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5259 /* OR in the next part of the littlenum. */
5260 val
|= (*bignum
<< loaded
);
5261 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5265 /* Add bytes until there are less than 7 bits left in VAL
5266 or until every non-sign bit has been written. */
5273 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5280 while ((byte
& 0x80) != 0 && loaded
>= 7);
5284 /* Mop up any left-over bits (of which there will be less than 7). */
5285 if ((byte
& 0x80) != 0)
5287 /* Sign-extend VAL. */
5288 if (val
& (1 << (loaded
- 1)))
5289 val
|= ~0U << loaded
;
5298 static inline unsigned int
5299 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5306 /* Strip leading zeros off the bignum. */
5307 /* XXX: Is this needed? */
5308 while (size
> 0 && bignum
[size
- 1] == 0)
5313 if (loaded
< 7 && size
> 0)
5315 val
|= (*bignum
<< loaded
);
5316 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5325 if (size
> 0 || val
)
5332 while (byte
& 0x80);
5338 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5341 return output_big_sleb128 (p
, bignum
, size
);
5343 return output_big_uleb128 (p
, bignum
, size
);
5346 /* Generate the appropriate fragments for a given expression to emit a
5347 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5350 emit_leb128_expr (expressionS
*exp
, int sign
)
5352 operatorT op
= exp
->X_op
;
5353 unsigned int nbytes
;
5355 if (op
== O_absent
|| op
== O_illegal
)
5357 as_warn (_("zero assumed for missing expression"));
5358 exp
->X_add_number
= 0;
5361 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5363 as_bad (_("floating point number invalid"));
5364 exp
->X_add_number
= 0;
5367 else if (op
== O_register
)
5369 as_warn (_("register value used as expression"));
5372 else if (op
== O_constant
5374 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5376 /* We're outputting a signed leb128 and the sign of X_add_number
5377 doesn't reflect the sign of the original value. Convert EXP
5378 to a correctly-extended bignum instead. */
5379 convert_to_bignum (exp
, exp
->X_extrabit
);
5383 if (now_seg
== absolute_section
)
5385 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5386 as_bad (_("attempt to store value in absolute section"));
5387 abs_section_offset
++;
5391 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5392 as_bad (_("attempt to store non-zero value in section `%s'"),
5393 segment_name (now_seg
));
5395 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5396 a signal that this is leb128 data. It shouldn't optimize this away. */
5397 nbytes
= (unsigned int) -1;
5398 if (check_eh_frame (exp
, &nbytes
))
5401 /* Let the backend know that subsequent data may be byte aligned. */
5402 #ifdef md_cons_align
5406 if (op
== O_constant
)
5408 /* If we've got a constant, emit the thing directly right now. */
5410 valueT value
= exp
->X_add_number
;
5414 size
= sizeof_leb128 (value
, sign
);
5415 p
= frag_more (size
);
5416 if (output_leb128 (p
, value
, sign
) > size
)
5419 else if (op
== O_big
)
5421 /* O_big is a different sort of constant. */
5422 int nbr_digits
= exp
->X_add_number
;
5426 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5427 a signed number. Unary operators like - or ~ always extend the
5428 bignum to its largest size. */
5430 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5431 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5432 generic_bignum
[nbr_digits
++] = 0;
5434 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5435 p
= frag_more (size
);
5436 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5441 /* Otherwise, we have to create a variable sized fragment and
5442 resolve things later. */
5444 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5445 make_expr_symbol (exp
), 0, (char *) NULL
);
5449 /* Parse the .sleb128 and .uleb128 pseudos. */
5456 #ifdef md_flush_pending_output
5457 md_flush_pending_output ();
5462 deferred_expression (&exp
);
5463 emit_leb128_expr (&exp
, sign
);
5465 while (*input_line_pointer
++ == ',');
5467 input_line_pointer
--;
5468 demand_empty_rest_of_line ();
5472 stringer_append_char (int c
, int bitsize
)
5475 as_bad (_("attempt to store non-empty string in section `%s'"),
5476 segment_name (now_seg
));
5478 if (!target_big_endian
)
5479 FRAG_APPEND_1_CHAR (c
);
5484 FRAG_APPEND_1_CHAR (0);
5485 FRAG_APPEND_1_CHAR (0);
5486 FRAG_APPEND_1_CHAR (0);
5487 FRAG_APPEND_1_CHAR (0);
5490 FRAG_APPEND_1_CHAR (0);
5491 FRAG_APPEND_1_CHAR (0);
5494 FRAG_APPEND_1_CHAR (0);
5499 /* Called with invalid bitsize argument. */
5503 if (target_big_endian
)
5504 FRAG_APPEND_1_CHAR (c
);
5507 /* Worker to do .ascii etc statements.
5508 Reads 0 or more ',' separated, double-quoted strings.
5509 Caller should have checked need_pass_2 is FALSE because we don't
5511 Checks for end-of-line.
5512 BITS_APPENDZERO says how many bits are in a target char.
5513 The bottom bit is set if a NUL char should be appended to the strings. */
5516 stringer (int bits_appendzero
)
5518 const int bitsize
= bits_appendzero
& ~7;
5519 const int append_zero
= bits_appendzero
& 1;
5521 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5525 #ifdef md_flush_pending_output
5526 md_flush_pending_output ();
5529 #ifdef md_cons_align
5533 /* If we have been switched into the abs_section then we
5534 will not have an obstack onto which we can hang strings. */
5535 if (now_seg
== absolute_section
)
5537 as_bad (_("strings must be placed into a section"));
5538 ignore_rest_of_line ();
5542 /* The following awkward logic is to parse ZERO or more strings,
5543 comma separated. Recall a string expression includes spaces
5544 before the opening '\"' and spaces after the closing '\"'.
5545 We fake a leading ',' if there is (supposed to be)
5546 a 1st, expression. We keep demanding expressions for each ','. */
5547 if (is_it_end_of_statement ())
5549 c
= 0; /* Skip loop. */
5550 ++input_line_pointer
; /* Compensate for end of loop. */
5554 c
= ','; /* Do loop. */
5557 while (c
== ',' || c
== '<' || c
== '"')
5560 switch (*input_line_pointer
)
5563 ++input_line_pointer
; /*->1st char of string. */
5564 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5565 start
= input_line_pointer
;
5568 while (is_a_char (c
= next_char_of_string ()))
5569 stringer_append_char (c
, bitsize
);
5572 stringer_append_char (0, bitsize
);
5574 know (input_line_pointer
[-1] == '\"');
5576 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5577 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5578 will emit .string with a filename in the .debug section
5579 after a sequence of constants. See the comment in
5580 emit_expr for the sequence. emit_expr will set
5581 dwarf_file_string to non-zero if this string might be a
5582 source file name. */
5583 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5584 dwarf_file_string
= 0;
5585 else if (dwarf_file_string
)
5587 c
= input_line_pointer
[-1];
5588 input_line_pointer
[-1] = '\0';
5589 listing_source_file (start
);
5590 input_line_pointer
[-1] = c
;
5596 input_line_pointer
++;
5597 c
= get_single_number ();
5598 stringer_append_char (c
, bitsize
);
5599 if (*input_line_pointer
!= '>')
5600 as_bad (_("expected <nn>"));
5602 input_line_pointer
++;
5605 input_line_pointer
++;
5609 c
= *input_line_pointer
;
5612 demand_empty_rest_of_line ();
5615 /* FIXME-SOMEDAY: I had trouble here on characters with the
5616 high bits set. We'll probably also have trouble with
5617 multibyte chars, wide chars, etc. Also be careful about
5618 returning values bigger than 1 byte. xoxorich. */
5621 next_char_of_string (void)
5625 c
= *input_line_pointer
++ & CHAR_MASK
;
5629 /* PR 20902: Do not advance past the end of the buffer. */
5630 -- input_line_pointer
;
5639 as_warn (_("unterminated string; newline inserted"));
5640 bump_line_counters ();
5643 #ifndef NO_STRING_ESCAPES
5645 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5673 break; /* As itself. */
5689 for (i
= 0, number
= 0;
5690 ISDIGIT (c
) && i
< 3;
5691 c
= *input_line_pointer
++, i
++)
5693 number
= number
* 8 + c
- '0';
5696 c
= number
& CHAR_MASK
;
5698 --input_line_pointer
;
5707 c
= *input_line_pointer
++;
5708 while (ISXDIGIT (c
))
5711 number
= number
* 16 + c
- '0';
5712 else if (ISUPPER (c
))
5713 number
= number
* 16 + c
- 'A' + 10;
5715 number
= number
* 16 + c
- 'a' + 10;
5716 c
= *input_line_pointer
++;
5718 c
= number
& CHAR_MASK
;
5719 --input_line_pointer
;
5724 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5725 as_warn (_("unterminated string; newline inserted"));
5727 bump_line_counters ();
5731 /* Do not advance past the end of the buffer. */
5732 -- input_line_pointer
;
5738 #ifdef ONLY_STANDARD_ESCAPES
5739 as_bad (_("bad escaped character in string"));
5741 #endif /* ONLY_STANDARD_ESCAPES */
5746 #endif /* ! defined (NO_STRING_ESCAPES) */
5755 get_segmented_expression (expressionS
*expP
)
5759 retval
= expression (expP
);
5760 if (expP
->X_op
== O_illegal
5761 || expP
->X_op
== O_absent
5762 || expP
->X_op
== O_big
)
5764 as_bad (_("expected address expression"));
5765 expP
->X_op
= O_constant
;
5766 expP
->X_add_number
= 0;
5767 retval
= absolute_section
;
5773 get_known_segmented_expression (expressionS
*expP
)
5775 segT retval
= get_segmented_expression (expP
);
5777 if (retval
== undefined_section
)
5779 /* There is no easy way to extract the undefined symbol from the
5781 if (expP
->X_add_symbol
!= NULL
5782 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5783 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5784 S_GET_NAME (expP
->X_add_symbol
));
5786 as_warn (_("some symbol undefined; zero assumed"));
5787 retval
= absolute_section
;
5788 expP
->X_op
= O_constant
;
5789 expP
->X_add_number
= 0;
5794 char /* Return terminator. */
5795 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5797 /* FIXME: val_pointer should probably be offsetT *. */
5798 *val_pointer
= (long) get_absolute_expression ();
5799 return (*input_line_pointer
++);
5802 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5803 Give a warning if that happens. */
5806 demand_copy_C_string (int *len_pointer
)
5810 if ((s
= demand_copy_string (len_pointer
)) != 0)
5814 for (len
= *len_pointer
; len
> 0; len
--)
5821 as_bad (_("this string may not contain \'\\0\'"));
5829 /* Demand string, but return a safe (=private) copy of the string.
5830 Return NULL if we can't read a string here. */
5833 demand_copy_string (int *lenP
)
5841 if (*input_line_pointer
== '\"')
5843 input_line_pointer
++; /* Skip opening quote. */
5845 while (is_a_char (c
= next_char_of_string ()))
5847 obstack_1grow (¬es
, c
);
5850 /* JF this next line is so demand_copy_C_string will return a
5851 null terminated string. */
5852 obstack_1grow (¬es
, '\0');
5853 retval
= (char *) obstack_finish (¬es
);
5857 as_bad (_("missing string"));
5859 ignore_rest_of_line ();
5865 /* In: Input_line_pointer->next character.
5867 Do: Skip input_line_pointer over all whitespace.
5869 Out: 1 if input_line_pointer->end-of-line. */
5872 is_it_end_of_statement (void)
5875 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5879 equals (char *sym_name
, int reassign
)
5884 input_line_pointer
++;
5885 if (*input_line_pointer
== '=')
5886 input_line_pointer
++;
5887 if (reassign
< 0 && *input_line_pointer
== '=')
5888 input_line_pointer
++;
5890 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5891 input_line_pointer
++;
5894 stop
= mri_comment_field (&stopc
);
5896 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5900 demand_empty_rest_of_line ();
5901 mri_comment_end (stop
, stopc
);
5905 /* .incbin -- include a file verbatim at the current location. */
5908 s_incbin (int x ATTRIBUTE_UNUSED
)
5919 #ifdef md_flush_pending_output
5920 md_flush_pending_output ();
5923 #ifdef md_cons_align
5928 filename
= demand_copy_string (& len
);
5929 if (filename
== NULL
)
5934 /* Look for optional skip and count. */
5935 if (* input_line_pointer
== ',')
5937 ++ input_line_pointer
;
5938 skip
= get_absolute_expression ();
5942 if (* input_line_pointer
== ',')
5944 ++ input_line_pointer
;
5946 count
= get_absolute_expression ();
5948 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5954 demand_empty_rest_of_line ();
5956 /* Try opening absolute path first, then try include dirs. */
5957 binfile
= fopen (filename
, FOPEN_RB
);
5958 if (binfile
== NULL
)
5962 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5964 for (i
= 0; i
< include_dir_count
; i
++)
5966 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5968 binfile
= fopen (path
, FOPEN_RB
);
5969 if (binfile
!= NULL
)
5973 if (binfile
== NULL
)
5974 as_bad (_("file not found: %s"), filename
);
5977 path
= xstrdup (filename
);
5983 register_dependency (path
);
5985 /* Compute the length of the file. */
5986 if (fseek (binfile
, 0, SEEK_END
) != 0)
5988 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5991 file_len
= ftell (binfile
);
5993 /* If a count was not specified use the remainder of the file. */
5995 count
= file_len
- skip
;
5997 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5999 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
6000 skip
, count
, file_len
);
6004 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
6006 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
6010 /* Allocate frag space and store file contents in it. */
6011 binfrag
= frag_more (count
);
6013 bytes
= fread (binfrag
, 1, count
, binfile
);
6015 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
6016 path
, bytes
, count
);
6019 if (binfile
!= NULL
)
6025 /* .include -- include a file at this point. */
6028 s_include (int arg ATTRIBUTE_UNUSED
)
6037 filename
= demand_copy_string (&i
);
6038 if (filename
== NULL
)
6040 /* demand_copy_string has already printed an error and
6041 called ignore_rest_of_line. */
6049 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
6050 && *input_line_pointer
!= ' '
6051 && *input_line_pointer
!= '\t')
6053 obstack_1grow (¬es
, *input_line_pointer
);
6054 ++input_line_pointer
;
6058 obstack_1grow (¬es
, '\0');
6059 filename
= (char *) obstack_finish (¬es
);
6060 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
6061 ++input_line_pointer
;
6064 demand_empty_rest_of_line ();
6065 path
= XNEWVEC (char, (unsigned long) i
6066 + include_dir_maxlen
+ 5 /* slop */ );
6068 for (i
= 0; i
< include_dir_count
; i
++)
6070 strcpy (path
, include_dirs
[i
]);
6072 strcat (path
, filename
);
6073 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
6083 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
6084 register_dependency (path
);
6085 input_scrub_insert_file (path
);
6089 add_include_dir (char *path
)
6093 if (include_dir_count
== 0)
6095 include_dirs
= XNEWVEC (const char *, 2);
6096 include_dirs
[0] = "."; /* Current dir. */
6097 include_dir_count
= 2;
6101 include_dir_count
++;
6102 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
6106 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
6109 if (i
> include_dir_maxlen
)
6110 include_dir_maxlen
= i
;
6113 /* Output debugging information to denote the source file. */
6116 generate_file_debug (void)
6118 if (debug_type
== DEBUG_STABS
)
6119 stabs_generate_asm_file ();
6122 /* Output line number debugging information for the current source line. */
6125 generate_lineno_debug (void)
6129 case DEBUG_UNSPECIFIED
:
6134 stabs_generate_asm_lineno ();
6137 ecoff_generate_asm_lineno ();
6140 /* ??? We could here indicate to dwarf2dbg.c that something
6141 has changed. However, since there is additional backend
6142 support that is required (calling dwarf2_emit_insn), we
6143 let dwarf2dbg.c call as_where on its own. */
6148 /* Output debugging information to mark a function entry point or end point.
6149 END_P is zero for .func, and non-zero for .endfunc. */
6154 do_s_func (end_p
, NULL
);
6157 /* Subroutine of s_func so targets can choose a different default prefix.
6158 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6161 do_s_func (int end_p
, const char *default_prefix
)
6163 /* Record the current function so that we can issue an error message for
6164 misplaced .func,.endfunc, and also so that .endfunc needs no
6166 static char *current_name
;
6167 static char *current_label
;
6171 if (current_name
== NULL
)
6173 as_bad (_("missing .func"));
6174 ignore_rest_of_line ();
6178 if (debug_type
== DEBUG_STABS
)
6179 stabs_generate_asm_endfunc (current_name
, current_label
);
6181 current_name
= current_label
= NULL
;
6186 char delim1
, delim2
;
6188 if (current_name
!= NULL
)
6190 as_bad (_(".endfunc missing for previous .func"));
6191 ignore_rest_of_line ();
6195 delim1
= get_symbol_name (& name
);
6196 name
= xstrdup (name
);
6197 *input_line_pointer
= delim1
;
6198 SKIP_WHITESPACE_AFTER_NAME ();
6199 if (*input_line_pointer
!= ',')
6203 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6204 as_fatal ("%s", xstrerror (errno
));
6208 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6209 /* Missing entry point, use function's name with the leading
6213 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6214 as_fatal ("%s", xstrerror (errno
));
6222 ++input_line_pointer
;
6224 delim2
= get_symbol_name (& label
);
6225 label
= xstrdup (label
);
6226 restore_line_pointer (delim2
);
6229 if (debug_type
== DEBUG_STABS
)
6230 stabs_generate_asm_func (name
, label
);
6232 current_name
= name
;
6233 current_label
= label
;
6236 demand_empty_rest_of_line ();
6239 #ifdef HANDLE_BUNDLE
6242 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6244 unsigned int align
= get_absolute_expression ();
6246 demand_empty_rest_of_line ();
6248 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6249 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6250 (unsigned int) TC_ALIGN_LIMIT
);
6252 if (bundle_lock_frag
!= NULL
)
6254 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6258 bundle_align_p2
= align
;
6262 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6264 demand_empty_rest_of_line ();
6266 if (bundle_align_p2
== 0)
6268 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6272 if (bundle_lock_depth
== 0)
6274 bundle_lock_frchain
= frchain_now
;
6275 bundle_lock_frag
= start_bundle ();
6277 ++bundle_lock_depth
;
6281 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6285 demand_empty_rest_of_line ();
6287 if (bundle_lock_frag
== NULL
)
6289 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6293 gas_assert (bundle_align_p2
> 0);
6295 gas_assert (bundle_lock_depth
> 0);
6296 if (--bundle_lock_depth
> 0)
6299 size
= pending_bundle_size (bundle_lock_frag
);
6301 if (size
> 1U << bundle_align_p2
)
6302 as_bad (_(".bundle_lock sequence is %u bytes, "
6303 "but bundle size is only %u bytes"),
6304 size
, 1u << bundle_align_p2
);
6306 finish_bundle (bundle_lock_frag
, size
);
6308 bundle_lock_frag
= NULL
;
6309 bundle_lock_frchain
= NULL
;
6312 #endif /* HANDLE_BUNDLE */
6315 s_ignore (int arg ATTRIBUTE_UNUSED
)
6317 ignore_rest_of_line ();
6321 read_print_statistics (FILE *file
)
6323 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6326 /* Inserts the given line into the input stream.
6328 This call avoids macro/conditionals nesting checking, since the contents of
6329 the line are assumed to replace the contents of a line already scanned.
6331 An appropriate use of this function would be substitution of input lines when
6332 called by md_start_line_hook(). The given line is assumed to already be
6333 properly scrubbed. */
6336 input_scrub_insert_line (const char *line
)
6339 size_t len
= strlen (line
);
6340 sb_build (&newline
, len
);
6341 sb_add_buffer (&newline
, line
, len
);
6342 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6344 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6347 /* Insert a file into the input stream; the path must resolve to an actual
6348 file; no include path searching or dependency registering is performed. */
6351 input_scrub_insert_file (char *path
)
6353 input_scrub_include_file (path
, input_line_pointer
);
6354 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6357 /* Find the end of a line, considering quotation and escaping of quotes. */
6359 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6360 # define TC_SINGLE_QUOTE_STRINGS 1
6364 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6367 char inquote
= '\0';
6370 while (!is_end_of_line
[(unsigned char) *s
]
6371 || (inquote
&& !ISCNTRL (*s
))
6372 || (inquote
== '\'' && flag_mri
)
6373 #ifdef TC_EOL_IN_INSN
6374 || (insn
&& TC_EOL_IN_INSN (s
))
6376 /* PR 6926: When we are parsing the body of a macro the sequence
6377 \@ is special - it refers to the invocation count. If the @
6378 character happens to be registered as a line-separator character
6379 by the target, then the is_end_of_line[] test above will have
6380 returned true, but we need to ignore the line separating
6381 semantics in this particular case. */
6382 || (in_macro
&& inescape
&& *s
== '@')
6385 if (mri_string
&& *s
== '\'')
6389 else if (*s
== '\\')
6393 #ifdef TC_SINGLE_QUOTE_STRINGS
6394 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6401 as_warn (_("missing closing `%c'"), inquote
);
6402 if (inescape
&& !ignore_input ())
6403 as_warn (_("stray `\\'"));
6408 find_end_of_line (char *s
, int mri_string
)
6410 return _find_end_of_line (s
, mri_string
, 0, 0);
6413 static char *saved_ilp
= NULL
;
6414 static char *saved_limit
;
6416 /* Use BUF as a temporary input pointer for calling other functions in this
6417 file. BUF must be a C string, so that its end can be found by strlen.
6418 Also sets the buffer_limit variable (local to this file) so that buffer
6419 overruns should not occur. Saves the current input line pointer so that
6420 it can be restored by calling restore_ilp().
6422 Does not support recursion.
6424 FIXME: This function is currently only used by stabs.c but that
6425 should be extended to other files in the gas source directory. */
6428 temp_ilp (char *buf
)
6430 gas_assert (saved_ilp
== NULL
);
6431 gas_assert (buf
!= NULL
);
6433 saved_ilp
= input_line_pointer
;
6434 saved_limit
= buffer_limit
;
6435 /* Prevent the assert in restore_ilp from triggering if
6436 the input_line_pointer has not yet been initialised. */
6437 if (saved_ilp
== NULL
)
6438 saved_limit
= saved_ilp
= (char *) "";
6440 input_line_pointer
= buf
;
6441 buffer_limit
= buf
+ strlen (buf
);
6442 input_from_string
= TRUE
;
6445 /* Restore a saved input line pointer. */
6450 gas_assert (saved_ilp
!= NULL
);
6452 input_line_pointer
= saved_ilp
;
6453 buffer_limit
= saved_limit
;
6454 input_from_string
= FALSE
;