1 /* read.c - read a source file -
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer
; /*->next char of source file to parse. */
67 bfd_boolean input_from_string
= FALSE
;
69 #if BITS_PER_CHAR != 8
70 /* The following table is indexed by[(char)] and will break if
71 a char does not have exactly 256 states (hopefully 0:255!)! */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The Delta 68k assembler permits ~ at start of label names. */
109 /* Used by is_... macros. our ctype[]. */
110 char lex_type
[256] = {
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
113 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
115 LEX_AT
, 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
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
117 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
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,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
130 Out: 1 if this character ends a line.
131 2 if this character is a line separator. */
132 char is_end_of_line
[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
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, /* 0123456789:;<=>? */
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, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string
[128];
159 /* Functions private to this file. */
161 static char *buffer
; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit
; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
172 const char **include_dirs
;
174 /* How many are in the table. */
175 int include_dir_count
;
177 /* Length of longest in table. */
178 int include_dir_maxlen
= 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string
;
214 /* If the target defines the md_frag_max_var hook then we know
215 enough to implement the .bundle_align_mode features. */
216 #ifdef md_frag_max_var
217 # define HANDLE_BUNDLE
221 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
222 it's the exponent of the bundle size, and aligned instruction bundle
223 mode is in effect. */
224 static unsigned int bundle_align_p2
;
226 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
227 bundle_lock_frag to frag_now and then starts a new frag with
228 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
229 so that .bundle_unlock can verify that we didn't change segments.
230 .bundle_unlock resets both to NULL. If we detect a bundling violation,
231 then we reset bundle_lock_frchain to NULL as an indicator that we've
232 already diagnosed the error with as_bad and don't need a cascade of
233 redundant errors, but bundle_lock_frag remains set to indicate that
234 we are expecting to see .bundle_unlock. */
235 static fragS
*bundle_lock_frag
;
236 static frchainS
*bundle_lock_frchain
;
238 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
240 static unsigned int bundle_lock_depth
;
243 static void do_s_func (int end_p
, const char *default_prefix
);
244 static void s_align (int, int);
245 static void s_altmacro (int);
246 static void s_bad_end (int);
247 static void s_reloc (int);
248 static int hex_float (int, char *);
249 static segT
get_known_segmented_expression (expressionS
* expP
);
250 static void pobegin (void);
251 static size_t get_non_macro_line_sb (sb
*);
252 static void generate_file_debug (void);
253 static char *_find_end_of_line (char *, int, int, int);
261 obj_read_begin_hook ();
263 /* Something close -- but not too close -- to a multiple of 1024.
264 The debugging malloc I'm using has 24 bytes of overhead. */
265 obstack_begin (¬es
, chunksize
);
266 obstack_begin (&cond_obstack
, chunksize
);
268 #ifndef tc_line_separator_chars
269 #define tc_line_separator_chars line_separator_chars
271 /* Use machine dependent syntax. */
272 for (p
= tc_line_separator_chars
; *p
; p
++)
273 is_end_of_line
[(unsigned char) *p
] = 2;
274 /* Use more. FIXME-SOMEDAY. */
280 #ifndef TC_ADDRESS_BYTES
281 #define TC_ADDRESS_BYTES address_bytes
286 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
287 contain an address. */
288 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
296 /* Set up pseudo-op tables. */
300 const char *poc_name
;
302 const pseudo_typeS
*pop
;
305 typedef struct po_entry po_entry_t
;
307 /* Hash function for a po_entry. */
310 hash_po_entry (const void *e
)
312 const po_entry_t
*entry
= (const po_entry_t
*) e
;
313 return htab_hash_string (entry
->poc_name
);
316 /* Equality function for a po_entry. */
319 eq_po_entry (const void *a
, const void *b
)
321 const po_entry_t
*ea
= (const po_entry_t
*) a
;
322 const po_entry_t
*eb
= (const po_entry_t
*) b
;
324 return strcmp (ea
->poc_name
, eb
->poc_name
) == 0;
328 po_entry_alloc (const char *poc_name
, const pseudo_typeS
*pop
)
330 po_entry_t
*entry
= XNEW (po_entry_t
);
331 entry
->poc_name
= poc_name
;
336 static const pseudo_typeS
*
337 po_entry_find (htab_t table
, const char *poc_name
)
339 po_entry_t needle
= { poc_name
, NULL
};
340 po_entry_t
*entry
= htab_find (table
, &needle
);
341 return entry
!= NULL
? entry
->pop
: NULL
;
344 static struct htab
*po_hash
;
346 static const pseudo_typeS potable
[] = {
347 {"abort", s_abort
, 0},
348 {"align", s_align_ptwo
, 0},
349 {"altmacro", s_altmacro
, 1},
350 {"ascii", stringer
, 8+0},
351 {"asciz", stringer
, 8+1},
352 {"balign", s_align_bytes
, 0},
353 {"balignw", s_align_bytes
, -2},
354 {"balignl", s_align_bytes
, -4},
357 {"bundle_align_mode", s_bundle_align_mode
, 0},
358 {"bundle_lock", s_bundle_lock
, 0},
359 {"bundle_unlock", s_bundle_unlock
, 0},
363 {"common", s_mri_common
, 0},
364 {"common.s", s_mri_common
, 1},
367 #ifdef TC_ADDRESS_BYTES
371 {"dc.d", float_cons
, 'd'},
373 {"dc.s", float_cons
, 'f'},
375 {"dc.x", float_cons
, 'x'},
377 {"dcb.b", s_space
, 1},
378 {"dcb.d", s_float_space
, 'd'},
379 {"dcb.l", s_space
, 4},
380 {"dcb.s", s_float_space
, 'f'},
381 {"dcb.w", s_space
, 2},
382 {"dcb.x", s_float_space
, 'x'},
384 {"ds.b", s_space
, 1},
385 {"ds.d", s_space
, 8},
386 {"ds.l", s_space
, 4},
387 {"ds.p", s_space
, 12},
388 {"ds.s", s_space
, 4},
389 {"ds.w", s_space
, 2},
390 {"ds.x", s_space
, 12},
391 {"debug", s_ignore
, 0},
396 {"double", float_cons
, 'd'},
398 {"eject", listing_eject
, 0}, /* Formfeed listing. */
400 {"elsec", s_else
, 0},
401 {"elseif", s_elseif
, (int) O_ne
},
403 {"endc", s_endif
, 0},
404 {"endfunc", s_func
, 1},
405 {"endif", s_endif
, 0},
406 {"endm", s_bad_end
, 0},
407 {"endr", s_bad_end
, 1},
413 {"error", s_errwarn
, 1},
414 {"exitm", s_mexit
, 0},
416 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
417 {"appfile", s_app_file
, 1},
418 {"appline", s_app_line
, 1},
420 {"file", s_app_file
, 0},
422 {"float", float_cons
, 'f'},
423 {"format", s_ignore
, 0},
425 {"global", s_globl
, 0},
426 {"globl", s_globl
, 0},
428 {"if", s_if
, (int) O_ne
},
431 {"ifdef", s_ifdef
, 0},
432 {"ifeq", s_if
, (int) O_eq
},
433 {"ifeqs", s_ifeqs
, 0},
434 {"ifge", s_if
, (int) O_ge
},
435 {"ifgt", s_if
, (int) O_gt
},
436 {"ifle", s_if
, (int) O_le
},
437 {"iflt", s_if
, (int) O_lt
},
440 {"ifndef", s_ifdef
, 1},
441 {"ifne", s_if
, (int) O_ne
},
442 {"ifnes", s_ifeqs
, 1},
443 {"ifnotdef", s_ifdef
, 1},
444 {"incbin", s_incbin
, 0},
445 {"include", s_include
, 0},
451 {"lcomm", s_lcomm
, 0},
452 {"lflags", s_ignore
, 0}, /* Listing flags. */
453 {"linefile", s_app_line
, 0},
454 {"linkonce", s_linkonce
, 0},
455 {"list", listing_list
, 1}, /* Turn listing on. */
456 {"llen", listing_psize
, 1},
459 {"macro", s_macro
, 0},
460 {"mexit", s_mexit
, 0},
462 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
463 {"name", s_ignore
, 0},
464 {"noaltmacro", s_altmacro
, 0},
465 {"noformat", s_ignore
, 0},
466 {"nolist", listing_list
, 0}, /* Turn listing off. */
467 {"nopage", listing_nopage
, 0},
470 {"offset", s_struct
, 0},
472 {"p2align", s_align_ptwo
, 0},
473 {"p2alignw", s_align_ptwo
, -2},
474 {"p2alignl", s_align_ptwo
, -4},
475 {"page", listing_eject
, 0},
476 {"plen", listing_psize
, 0},
477 {"print", s_print
, 0},
478 {"psize", listing_psize
, 0}, /* Set paper size. */
479 {"purgem", s_purgem
, 0},
481 {"reloc", s_reloc
, 0},
485 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
490 {"single", float_cons
, 'f'},
492 {"space", s_space
, 0},
493 {"skip", s_space
, 0},
494 {"sleb128", s_leb128
, 1},
495 {"spc", s_ignore
, 0},
496 {"stabd", s_stab
, 'd'},
497 {"stabn", s_stab
, 'n'},
498 {"stabs", s_stab
, 's'},
499 {"string", stringer
, 8+1},
500 {"string8", stringer
, 8+1},
501 {"string16", stringer
, 16+1},
502 {"string32", stringer
, 32+1},
503 {"string64", stringer
, 64+1},
504 {"struct", s_struct
, 0},
508 /* This is for gcc to use. It's only just been added (2/94), so gcc
509 won't be able to use it for a while -- probably a year or more.
510 But once this has been released, check with gcc maintainers
511 before deleting it or even changing the spelling. */
512 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
513 /* If we're folding case -- done for some targets, not necessarily
514 all -- the above string in an input file will be converted to
515 this one. Match it either way... */
516 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
518 {"title", listing_title
, 0}, /* Listing title. */
519 {"ttl", listing_title
, 0},
521 {"uleb128", s_leb128
, 0},
525 {"xdef", s_globl
, 0},
526 {"xref", s_ignore
, 0},
527 {"xstabs", s_xstab
, 's'},
528 {"warning", s_errwarn
, 0},
529 {"weakref", s_weakref
, 0},
531 {"zero", s_space
, 0},
532 {NULL
, NULL
, 0} /* End sentinel. */
536 get_absolute_expr (expressionS
*exp
)
538 expression_and_evaluate (exp
);
540 if (exp
->X_op
!= O_constant
)
542 if (exp
->X_op
!= O_absent
)
543 as_bad (_("bad or irreducible absolute expression"));
544 exp
->X_add_number
= 0;
546 return exp
->X_add_number
;
550 get_absolute_expression (void)
554 return get_absolute_expr (&exp
);
557 static int pop_override_ok
= 0;
558 static const char *pop_table_name
;
561 pop_insert (const pseudo_typeS
*table
)
563 const pseudo_typeS
*pop
;
564 for (pop
= table
; pop
->poc_name
; pop
++)
566 int exists
= po_entry_find (po_hash
, pop
->poc_name
) != NULL
;
567 if (!pop_override_ok
&& exists
)
568 as_fatal (_("error constructing %s pseudo-op table"), pop_table_name
);
570 htab_insert (po_hash
, po_entry_alloc (pop
->poc_name
, pop
));
574 #ifndef md_pop_insert
575 #define md_pop_insert() pop_insert(md_pseudo_table)
578 #ifndef obj_pop_insert
579 #define obj_pop_insert() pop_insert(obj_pseudo_table)
582 #ifndef cfi_pop_insert
583 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
589 po_hash
= htab_create_alloc (16, hash_po_entry
, eq_po_entry
, NULL
,
592 /* Do the target-specific pseudo ops. */
593 pop_table_name
= "md";
596 /* Now object specific. Skip any that were in the target table. */
597 pop_table_name
= "obj";
601 /* Now portable ones. Skip any that we've seen already. */
602 pop_table_name
= "standard";
603 pop_insert (potable
);
606 pop_table_name
= "cfi";
611 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
612 if (ignore_input ()) \
614 char *eol = find_end_of_line (input_line_pointer - (num_read), \
616 input_line_pointer = (input_line_pointer <= buffer_limit \
617 && eol >= buffer_limit) \
623 /* This function is used when scrubbing the characters between #APP
626 static char *scrub_string
;
627 static char *scrub_string_end
;
630 scrub_from_string (char *buf
, size_t buflen
)
634 copy
= scrub_string_end
- scrub_string
;
637 memcpy (buf
, scrub_string
, copy
);
638 scrub_string
+= copy
;
642 /* Helper function of read_a_source_file, which tries to expand a macro. */
644 try_macro (char term
, const char *line
)
650 if (check_macro (line
, &out
, &err
, ¯o
))
654 *input_line_pointer
++ = term
;
655 input_scrub_include_sb (&out
,
656 input_line_pointer
, 1);
659 input_scrub_next_buffer (&input_line_pointer
);
661 md_macro_info (macro
);
669 /* Start a new instruction bundle. Returns the rs_align_code frag that
670 will be used to align the new bundle. */
674 fragS
*frag
= frag_now
;
676 frag_align_code (0, 0);
678 while (frag
->fr_type
!= rs_align_code
)
679 frag
= frag
->fr_next
;
681 gas_assert (frag
!= frag_now
);
686 /* Calculate the maximum size after relaxation of the region starting
687 at the given frag and extending through frag_now (which is unfinished). */
689 pending_bundle_size (fragS
*frag
)
691 unsigned int offset
= frag
->fr_fix
;
692 unsigned int size
= 0;
694 gas_assert (frag
!= frag_now
);
695 gas_assert (frag
->fr_type
== rs_align_code
);
697 while (frag
!= frag_now
)
699 /* This should only happen in what will later become an error case. */
703 size
+= frag
->fr_fix
;
704 if (frag
->fr_type
== rs_machine_dependent
)
705 size
+= md_frag_max_var (frag
);
707 frag
= frag
->fr_next
;
710 gas_assert (frag
== frag_now
);
711 size
+= frag_now_fix ();
712 if (frag
->fr_type
== rs_machine_dependent
)
713 size
+= md_frag_max_var (frag
);
715 gas_assert (size
>= offset
);
717 return size
- offset
;
720 /* Finish off the frag created to ensure bundle alignment. */
722 finish_bundle (fragS
*frag
, unsigned int size
)
724 gas_assert (bundle_align_p2
> 0);
725 gas_assert (frag
->fr_type
== rs_align_code
);
729 /* If there is more than a single byte, then we need to set up the
730 alignment frag. Otherwise we leave it at its initial state from
731 calling frag_align_code (0, 0), so that it does nothing. */
732 frag
->fr_offset
= bundle_align_p2
;
733 frag
->fr_subtype
= size
- 1;
736 /* We do this every time rather than just in s_bundle_align_mode
737 so that we catch any affected section without needing hooks all
738 over for all paths that do section changes. It's cheap enough. */
739 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
740 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
743 /* Assemble one instruction. This takes care of the bundle features
744 around calling md_assemble. */
746 assemble_one (char *line
)
748 fragS
*insn_start_frag
= NULL
;
750 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
752 as_bad (_("cannot change section or subsection inside .bundle_lock"));
753 /* Clearing this serves as a marker that we have already complained. */
754 bundle_lock_frchain
= NULL
;
757 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
758 insn_start_frag
= start_bundle ();
762 if (bundle_lock_frchain
!= NULL
)
764 /* Make sure this hasn't pushed the locked sequence
765 past the bundle size. */
766 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
767 if (bundle_size
> 1U << bundle_align_p2
)
768 as_bad (_ (".bundle_lock sequence at %u bytes, "
769 "but .bundle_align_mode limit is %u bytes"),
770 bundle_size
, 1U << bundle_align_p2
);
772 else if (bundle_align_p2
> 0)
774 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
776 if (insn_size
> 1U << bundle_align_p2
)
777 as_bad (_("single instruction is %u bytes long, "
778 "but .bundle_align_mode limit is %u bytes"),
779 insn_size
, 1U << bundle_align_p2
);
781 finish_bundle (insn_start_frag
, insn_size
);
785 #else /* !HANDLE_BUNDLE */
787 # define assemble_one(line) md_assemble(line)
789 #endif /* HANDLE_BUNDLE */
794 flagword flags
= bfd_section_flags (now_seg
);
796 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
799 /* Guts of .align directive:
800 N is the power of two to which to align. A value of zero is accepted but
801 ignored: the default alignment of the section will be at least this.
802 FILL may be NULL, or it may point to the bytes of the fill pattern.
803 LEN is the length of whatever FILL points to, if anything. If LEN is zero
804 but FILL is not NULL then LEN is treated as if it were one.
805 MAX is the maximum number of characters to skip when doing the alignment,
806 or 0 if there is no maximum. */
809 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
811 if (now_seg
== absolute_section
|| in_bss ())
817 if (now_seg
== absolute_section
)
818 as_warn (_("ignoring fill value in absolute section"));
820 as_warn (_("ignoring fill value in section `%s'"),
821 segment_name (now_seg
));
828 #ifdef md_flush_pending_output
829 md_flush_pending_output ();
833 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
836 /* Only make a frag if we HAVE to... */
837 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
841 if (subseg_text_p (now_seg
))
842 frag_align_code (n
, max
);
844 frag_align (n
, 0, max
);
847 frag_align (n
, *fill
, max
);
849 frag_align_pattern (n
, fill
, len
, max
);
853 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
856 if (n
> OCTETS_PER_BYTE_POWER
)
857 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
860 /* We read the file, putting things into a web that represents what we
861 have been reading. */
863 read_a_source_file (const char *name
)
867 char *s
; /* String of symbol, '\0' appended. */
869 const pseudo_typeS
*pop
;
875 buffer
= input_scrub_new_file (name
);
878 listing_newline (NULL
);
879 register_dependency (name
);
881 /* Generate debugging information before we've read anything in to denote
882 this file as the "main" source file and not a subordinate one
883 (e.g. N_SO vs N_SOL in stabs). */
884 generate_file_debug ();
886 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
887 { /* We have another line to parse. */
889 /* In order to avoid listing macro expansion lines with labels
890 multiple times, keep track of which line was last issued. */
891 static char *last_eol
;
895 while (input_line_pointer
< buffer_limit
)
897 bfd_boolean was_new_line
;
898 /* We have more of this buffer to parse. */
900 /* We now have input_line_pointer->1st char of next line.
901 If input_line_pointer [-1] == '\n' then we just
902 scanned another line: so bump line counters. */
903 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
906 symbol_set_value_now (&dot_symbol
);
907 #ifdef md_start_line_hook
908 md_start_line_hook ();
910 if (input_line_pointer
[-1] == '\n')
911 bump_line_counters ();
915 /* If listing is on, and we are expanding a macro, then give
916 the listing code the contents of the expanded line. */
919 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
921 /* Find the end of the current expanded macro line. */
922 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
930 /* Copy it for safe keeping. Also give an indication of
931 how much macro nesting is involved at this point. */
932 len
= s
- input_line_pointer
;
933 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
934 memset (copy
, '>', macro_nest
);
935 copy
[macro_nest
] = ' ';
936 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
937 copy
[macro_nest
+ 1 + len
] = '\0';
939 /* Install the line with the listing facility. */
940 listing_newline (copy
);
944 listing_newline (NULL
);
951 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
953 next_char
= * input_line_pointer
;
954 /* Text at the start of a line must be a label, we
955 run down and stick a colon in. */
956 if (is_name_beginner (next_char
) || next_char
== '"')
961 HANDLE_CONDITIONAL_ASSEMBLY (0);
963 nul_char
= get_symbol_name (& line_start
);
964 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
966 /* In MRI mode, the EQU and MACRO pseudoops must
967 be handled specially. */
971 char *rest
= input_line_pointer
+ 1;
975 if (*rest
== ' ' || *rest
== '\t')
977 if ((strncasecmp (rest
, "EQU", 3) == 0
978 || strncasecmp (rest
, "SET", 3) == 0)
979 && (rest
[3] == ' ' || rest
[3] == '\t'))
981 input_line_pointer
= rest
+ 3;
983 strncasecmp (rest
, "SET", 3) == 0);
986 if (strncasecmp (rest
, "MACRO", 5) == 0
989 || is_end_of_line
[(unsigned char) rest
[5]]))
993 /* In MRI mode, we need to handle the MACRO
994 pseudo-op specially: we don't want to put the
995 symbol in the symbol table. */
997 #ifdef TC_START_LABEL_WITHOUT_COLON
998 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
1001 line_label
= colon (line_start
);
1003 line_label
= symbol_create (line_start
,
1005 &zero_address_frag
, 0);
1007 next_char
= restore_line_pointer (nul_char
);
1008 if (next_char
== ':')
1009 input_line_pointer
++;
1014 /* We are at the beginning of a line, or similar place.
1015 We expect a well-formed assembler statement.
1016 A "symbol-name:" is a statement.
1018 Depending on what compiler is used, the order of these tests
1019 may vary to catch most common case 1st.
1020 Each test is independent of all other tests at the (top)
1023 nul_char
= next_char
= *input_line_pointer
++;
1024 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
1026 /* C is the 1st significant character.
1027 Input_line_pointer points after that character. */
1028 if (is_name_beginner (next_char
) || next_char
== '"')
1032 /* Want user-defined label or pseudo/opcode. */
1033 HANDLE_CONDITIONAL_ASSEMBLY (1);
1035 --input_line_pointer
;
1036 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
1037 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
1038 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
1040 /* NEXT_CHAR is character after symbol.
1041 The end of symbol in the input line is now '\0'.
1042 S points to the beginning of the symbol.
1043 [In case of pseudo-op, s->'.'.]
1044 Input_line_pointer->'\0' where NUL_CHAR was. */
1045 if (TC_START_LABEL (s
, nul_char
, next_char
))
1049 /* In MRI mode, \tsym: set 0 is permitted. */
1053 if (*rest
== ' ' || *rest
== '\t')
1056 if ((strncasecmp (rest
, "EQU", 3) == 0
1057 || strncasecmp (rest
, "SET", 3) == 0)
1058 && (rest
[3] == ' ' || rest
[3] == '\t'))
1060 input_line_pointer
= rest
+ 3;
1066 line_label
= colon (s
); /* User-defined label. */
1067 restore_line_pointer (nul_char
);
1068 ++ input_line_pointer
;
1069 #ifdef tc_check_label
1070 tc_check_label (line_label
);
1072 /* Input_line_pointer->after ':'. */
1075 else if ((next_char
== '=' && *rest
== '=')
1076 || ((next_char
== ' ' || next_char
== '\t')
1081 demand_empty_rest_of_line ();
1083 else if ((next_char
== '='
1084 || ((next_char
== ' ' || next_char
== '\t')
1086 #ifdef TC_EQUAL_IN_INSN
1087 && !TC_EQUAL_IN_INSN (next_char
, s
)
1092 demand_empty_rest_of_line ();
1096 /* Expect pseudo-op or machine instruction. */
1099 #ifndef TC_CASE_SENSITIVE
1103 strncpy (original_case_string
, s2
,
1104 sizeof (original_case_string
) - 1);
1105 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1109 *s2
= TOLOWER (*s2
);
1114 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1116 /* The MRI assembler uses pseudo-ops without
1118 pop
= po_entry_find (po_hash
, s
);
1119 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1124 || (!flag_m68k_mri
&& *s
== '.'))
1128 WARNING: next_char may be end-of-line.
1129 We lookup the pseudo-op table with s+1 because we
1130 already know that the pseudo-op begins with a '.'. */
1133 pop
= po_entry_find (po_hash
, s
+ 1);
1134 if (pop
&& !pop
->poc_handler
)
1137 /* In MRI mode, we may need to insert an
1138 automatic alignment directive. What a hack
1140 if (mri_pending_align
1142 || !((pop
->poc_handler
== cons
1143 && pop
->poc_val
== 1)
1144 || (pop
->poc_handler
== s_space
1145 && pop
->poc_val
== 1)
1146 #ifdef tc_conditional_pseudoop
1147 || tc_conditional_pseudoop (pop
)
1149 || pop
->poc_handler
== s_if
1150 || pop
->poc_handler
== s_ifdef
1151 || pop
->poc_handler
== s_ifc
1152 || pop
->poc_handler
== s_ifeqs
1153 || pop
->poc_handler
== s_else
1154 || pop
->poc_handler
== s_endif
1155 || pop
->poc_handler
== s_globl
1156 || pop
->poc_handler
== s_ignore
)))
1158 do_align (1, (char *) NULL
, 0, 0);
1159 mri_pending_align
= 0;
1161 if (line_label
!= NULL
)
1163 symbol_set_frag (line_label
, frag_now
);
1164 S_SET_VALUE (line_label
, frag_now_fix ());
1168 /* Print the error msg now, while we still can. */
1171 char *end
= input_line_pointer
;
1173 (void) restore_line_pointer (nul_char
);
1175 nul_char
= next_char
= *--input_line_pointer
;
1176 *input_line_pointer
= '\0';
1177 if (! macro_defined
|| ! try_macro (next_char
, s
))
1180 as_bad (_("unknown pseudo-op: `%s'"), s
);
1181 *input_line_pointer
++ = nul_char
;
1186 /* Put it back for error messages etc. */
1187 next_char
= restore_line_pointer (nul_char
);
1188 /* The following skip of whitespace is compulsory.
1189 A well shaped space is sometimes all that separates
1190 keyword from operands. */
1191 if (next_char
== ' ' || next_char
== '\t')
1192 input_line_pointer
++;
1194 /* Input_line is restored.
1195 Input_line_pointer->1st non-blank char
1196 after pseudo-operation. */
1197 (*pop
->poc_handler
) (pop
->poc_val
);
1199 /* If that was .end, just get out now. */
1200 if (pop
->poc_handler
== s_end
)
1205 /* WARNING: next_char may be end-of-line. */
1206 /* Also: input_line_pointer->`\0` where nul_char was. */
1207 (void) restore_line_pointer (nul_char
);
1208 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1209 next_char
= nul_char
= *input_line_pointer
;
1210 *input_line_pointer
= '\0';
1212 generate_lineno_debug ();
1214 if (macro_defined
&& try_macro (next_char
, s
))
1217 if (mri_pending_align
)
1219 do_align (1, (char *) NULL
, 0, 0);
1220 mri_pending_align
= 0;
1221 if (line_label
!= NULL
)
1223 symbol_set_frag (line_label
, frag_now
);
1224 S_SET_VALUE (line_label
, frag_now_fix ());
1228 assemble_one (s
); /* Assemble 1 instruction. */
1230 /* PR 19630: The backend may have set ilp to NULL
1231 if it encountered a catastrophic failure. */
1232 if (input_line_pointer
== NULL
)
1233 as_fatal (_("unable to continue with assembly."));
1235 *input_line_pointer
++ = nul_char
;
1237 /* We resume loop AFTER the end-of-line from
1238 this instruction. */
1244 /* Empty statement? */
1245 if (is_end_of_line
[(unsigned char) next_char
])
1248 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1250 /* local label ("4:") */
1251 char *backup
= input_line_pointer
;
1253 HANDLE_CONDITIONAL_ASSEMBLY (1);
1255 temp
= next_char
- '0';
1257 if (nul_char
== '"')
1258 ++ input_line_pointer
;
1260 /* Read the whole number. */
1261 while (ISDIGIT (*input_line_pointer
))
1263 const long digit
= *input_line_pointer
- '0';
1264 if (temp
> (LONG_MAX
- digit
) / 10)
1266 as_bad (_("local label too large near %s"), backup
);
1270 temp
= temp
* 10 + digit
;
1271 ++input_line_pointer
;
1274 /* Overflow: stop processing the label. */
1277 ignore_rest_of_line ();
1281 if (LOCAL_LABELS_DOLLAR
1282 && *input_line_pointer
== '$'
1283 && *(input_line_pointer
+ 1) == ':')
1285 input_line_pointer
+= 2;
1287 if (dollar_label_defined (temp
))
1289 as_fatal (_("label \"%ld$\" redefined"), temp
);
1292 define_dollar_label (temp
);
1293 colon (dollar_label_name (temp
, 0));
1298 && *input_line_pointer
++ == ':')
1300 fb_label_instance_inc (temp
);
1301 colon (fb_label_name (temp
, 0));
1305 input_line_pointer
= backup
;
1308 if (next_char
&& strchr (line_comment_chars
, next_char
))
1309 { /* Its a comment. Better say APP or NO_APP. */
1314 unsigned int new_length
;
1317 s
= input_line_pointer
;
1318 if (strncmp (s
, "APP\n", 4))
1321 ignore_rest_of_line ();
1324 bump_line_counters ();
1327 ends
= strstr (s
, "#NO_APP\n");
1331 unsigned int tmp_len
;
1334 /* The end of the #APP wasn't in this buffer. We
1335 keep reading in buffers until we find the #NO_APP
1336 that goes with this #APP There is one. The specs
1338 tmp_len
= buffer_limit
- s
;
1339 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1340 memcpy (tmp_buf
, s
, tmp_len
);
1343 new_tmp
= input_scrub_next_buffer (&buffer
);
1347 buffer_limit
= new_tmp
;
1348 input_line_pointer
= buffer
;
1349 ends
= strstr (buffer
, "#NO_APP\n");
1351 num
= ends
- buffer
;
1353 num
= buffer_limit
- buffer
;
1355 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1356 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1361 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1369 input_line_pointer
= ends
+ 8;
1373 scrub_string_end
= ends
;
1375 new_length
= ends
- s
;
1376 new_buf
= XNEWVEC (char, new_length
);
1383 space
= (new_buf
+ new_length
) - new_tmp
;
1384 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1392 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1393 new_tmp
= new_buf
+ new_length
;
1399 /* We've "scrubbed" input to the preferred format. In the
1400 process we may have consumed the whole of the remaining
1401 file (and included files). We handle this formatted
1402 input similar to that of macro expansion, letting
1403 actual macro expansion (possibly nested) and other
1404 input expansion work. Beware that in messages, line
1405 numbers and possibly file names will be incorrect. */
1406 new_length
= strlen (new_buf
);
1407 sb_build (&sbuf
, new_length
);
1408 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1409 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1411 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1416 HANDLE_CONDITIONAL_ASSEMBLY (1);
1418 #ifdef tc_unrecognized_line
1419 if (tc_unrecognized_line (next_char
))
1422 input_line_pointer
--;
1423 /* Report unknown char as error. */
1424 demand_empty_rest_of_line ();
1429 symbol_set_value_now (&dot_symbol
);
1431 #ifdef HANDLE_BUNDLE
1432 if (bundle_lock_frag
!= NULL
)
1434 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1435 _(".bundle_lock with no matching .bundle_unlock"));
1436 bundle_lock_frag
= NULL
;
1437 bundle_lock_frchain
= NULL
;
1438 bundle_lock_depth
= 0;
1445 /* Close the input file. */
1446 input_scrub_close ();
1447 #ifdef WARN_COMMENTS
1449 if (warn_comment
&& found_comment
)
1450 as_warn_where (found_comment_file
, found_comment
,
1451 "first comment found here");
1456 /* Convert O_constant expression EXP into the equivalent O_big representation.
1457 Take the sign of the number from SIGN rather than X_add_number. */
1460 convert_to_bignum (expressionS
*exp
, int sign
)
1465 value
= exp
->X_add_number
;
1466 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1468 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1469 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1471 /* Add a sequence of sign bits if the top bit of X_add_number is not
1472 the sign of the original value. */
1473 if ((exp
->X_add_number
< 0) == !sign
)
1474 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1476 exp
->X_add_number
= i
;
1479 /* For most MRI pseudo-ops, the line actually ends at the first
1480 nonquoted space. This function looks for that point, stuffs a null
1481 in, and sets *STOPCP to the character that used to be there, and
1482 returns the location.
1484 Until I hear otherwise, I am going to assume that this is only true
1485 for the m68k MRI assembler. */
1488 mri_comment_field (char *stopcp
)
1494 know (flag_m68k_mri
);
1496 for (s
= input_line_pointer
;
1497 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1505 for (s
= input_line_pointer
;
1506 !is_end_of_line
[(unsigned char) *s
];
1516 /* Skip to the end of an MRI comment field. */
1519 mri_comment_end (char *stop
, int stopc
)
1523 input_line_pointer
= stop
;
1525 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1526 ++input_line_pointer
;
1530 s_abort (int ignore ATTRIBUTE_UNUSED
)
1532 as_fatal (_(".abort detected. Abandoning ship."));
1535 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1536 (in bytes). A negative ARG is the negative of the length of the
1537 fill pattern. BYTES_P is non-zero if the alignment value should be
1538 interpreted as the byte boundary, rather than the power of 2. */
1539 #ifndef TC_ALIGN_LIMIT
1540 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1544 s_align (signed int arg
, int bytes_p
)
1546 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1555 stop
= mri_comment_field (&stopc
);
1557 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1562 align
= arg
; /* Default value from pseudo-op table. */
1566 align
= get_absolute_expression ();
1569 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1570 if (arg
> 0 && align
== 0)
1577 /* Convert to a power of 2. */
1582 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1585 as_bad (_("alignment not a power of 2"));
1591 if (align
> align_limit
)
1593 align
= align_limit
;
1594 as_warn (_("alignment too large: %u assumed"), align
);
1597 if (*input_line_pointer
!= ',')
1604 ++input_line_pointer
;
1605 if (*input_line_pointer
== ',')
1609 fill
= get_absolute_expression ();
1614 if (*input_line_pointer
!= ',')
1618 ++input_line_pointer
;
1619 max
= get_absolute_expression ();
1626 as_warn (_("expected fill pattern missing"));
1627 do_align (align
, (char *) NULL
, 0, max
);
1631 unsigned int fill_len
;
1643 do_align (align
, &fill_char
, fill_len
, max
);
1649 if ((size_t) fill_len
> sizeof ab
)
1651 as_warn (_("fill pattern too long, truncating to %u"),
1652 (unsigned) sizeof ab
);
1653 fill_len
= sizeof ab
;
1656 md_number_to_chars (ab
, fill
, fill_len
);
1657 do_align (align
, ab
, fill_len
, max
);
1661 demand_empty_rest_of_line ();
1664 mri_comment_end (stop
, stopc
);
1667 /* Handle the .align pseudo-op on machines where ".align 4" means
1668 align to a 4 byte boundary. */
1671 s_align_bytes (int arg
)
1676 /* Handle the .align pseudo-op on machines where ".align 4" means align
1677 to a 2**4 boundary. */
1680 s_align_ptwo (int arg
)
1685 /* Switch in and out of alternate macro mode. */
1690 demand_empty_rest_of_line ();
1691 macro_set_alternate (on
);
1694 /* Read a symbol name from input_line_pointer.
1696 Stores the symbol name in a buffer and returns a pointer to this buffer.
1697 The buffer is xalloc'ed. It is the caller's responsibility to free
1700 The name is not left in the i_l_p buffer as it may need processing
1701 to handle escape characters.
1703 Advances i_l_p to the next non-whitespace character.
1705 If a symbol name could not be read, the routine issues an error
1706 messages, skips to the end of the line and returns NULL. */
1709 read_symbol_name (void)
1715 c
= *input_line_pointer
++;
1719 #define SYM_NAME_CHUNK_LEN 128
1720 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1724 start
= name
= XNEWVEC (char, len
+ 1);
1726 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1728 while (is_a_char (C
= next_char_of_string ()))
1730 if (name
>= name_end
)
1734 sofar
= name
- start
;
1735 len
+= SYM_NAME_CHUNK_LEN
;
1736 start
= XRESIZEVEC (char, start
, len
+ 1);
1737 name_end
= start
+ len
;
1738 name
= start
+ sofar
;
1745 /* Since quoted symbol names can contain non-ASCII characters,
1746 check the string and warn if it cannot be recognised by the
1747 current character set. */
1748 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1749 as_warn (_("symbol name not recognised in the current locale"));
1751 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1755 name
= input_line_pointer
- 1;
1757 /* We accept FAKE_LABEL_CHAR in a name in case this is
1758 being called with a constructed string. */
1759 while (is_part_of_name (c
= *input_line_pointer
++)
1760 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1763 len
= (input_line_pointer
- name
) - 1;
1764 start
= XNEWVEC (char, len
+ 1);
1766 memcpy (start
, name
, len
);
1769 /* Skip a name ender char if one is present. */
1770 if (! is_name_ender (c
))
1771 --input_line_pointer
;
1774 name
= start
= NULL
;
1778 as_bad (_("expected symbol name"));
1779 ignore_rest_of_line ();
1790 s_comm_internal (int param
,
1791 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1795 symbolS
*symbolP
= NULL
;
1801 stop
= mri_comment_field (&stopc
);
1803 if ((name
= read_symbol_name ()) == NULL
)
1806 /* Accept an optional comma after the name. The comma used to be
1807 required, but Irix 5 cc does not generate it for .lcomm. */
1808 if (*input_line_pointer
== ',')
1809 input_line_pointer
++;
1811 temp
= get_absolute_expr (&exp
);
1813 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1814 if (exp
.X_op
== O_absent
)
1816 as_bad (_("missing size expression"));
1817 ignore_rest_of_line ();
1820 else if (temp
!= size
|| !exp
.X_unsigned
)
1822 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1823 ignore_rest_of_line ();
1827 symbolP
= symbol_find_or_make (name
);
1828 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1829 && !S_IS_COMMON (symbolP
))
1831 if (!S_IS_VOLATILE (symbolP
))
1834 as_bad (_("symbol `%s' is already defined"), name
);
1835 ignore_rest_of_line ();
1838 symbolP
= symbol_clone (symbolP
, 1);
1839 S_SET_SEGMENT (symbolP
, undefined_section
);
1840 S_SET_VALUE (symbolP
, 0);
1841 symbol_set_frag (symbolP
, &zero_address_frag
);
1842 S_CLEAR_VOLATILE (symbolP
);
1845 size
= S_GET_VALUE (symbolP
);
1848 else if (size
!= temp
)
1849 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1850 name
, (long) size
, (long) temp
);
1852 if (comm_parse_extra
!= NULL
)
1853 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1856 S_SET_VALUE (symbolP
, (valueT
) size
);
1857 S_SET_EXTERNAL (symbolP
);
1858 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1861 demand_empty_rest_of_line ();
1864 mri_comment_end (stop
, stopc
);
1872 s_comm_internal (ignore
, NULL
);
1875 /* The MRI COMMON pseudo-op. We handle this by creating a common
1876 symbol with the appropriate name. We make s_space do the right
1877 thing by increasing the size. */
1880 s_mri_common (int small ATTRIBUTE_UNUSED
)
1896 stop
= mri_comment_field (&stopc
);
1900 name
= input_line_pointer
;
1901 if (!ISDIGIT (*name
))
1902 c
= get_symbol_name (& name
);
1907 ++input_line_pointer
;
1909 while (ISDIGIT (*input_line_pointer
));
1911 c
= *input_line_pointer
;
1912 *input_line_pointer
= '\0';
1914 if (line_label
!= NULL
)
1916 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1917 + (input_line_pointer
- name
) + 1);
1918 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1923 sym
= symbol_find_or_make (name
);
1924 c
= restore_line_pointer (c
);
1927 if (*input_line_pointer
!= ',')
1931 ++input_line_pointer
;
1932 align
= get_absolute_expression ();
1935 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1937 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1938 ignore_rest_of_line ();
1939 mri_comment_end (stop
, stopc
);
1943 S_SET_EXTERNAL (sym
);
1944 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1945 mri_common_symbol
= sym
;
1949 S_SET_ALIGN (sym
, align
);
1954 if (line_label
!= NULL
)
1957 exp
.X_op
= O_symbol
;
1958 exp
.X_add_symbol
= sym
;
1959 exp
.X_add_number
= 0;
1960 symbol_set_value_expression (line_label
, &exp
);
1961 symbol_set_frag (line_label
, &zero_address_frag
);
1962 S_SET_SEGMENT (line_label
, expr_section
);
1965 /* FIXME: We just ignore the small argument, which distinguishes
1966 COMMON and COMMON.S. I don't know what we can do about it. */
1968 /* Ignore the type and hptype. */
1969 if (*input_line_pointer
== ',')
1970 input_line_pointer
+= 2;
1971 if (*input_line_pointer
== ',')
1972 input_line_pointer
+= 2;
1974 demand_empty_rest_of_line ();
1976 mri_comment_end (stop
, stopc
);
1980 s_data (int ignore ATTRIBUTE_UNUSED
)
1985 temp
= get_absolute_expression ();
1986 if (flag_readonly_data_in_text
)
1988 section
= text_section
;
1992 section
= data_section
;
1994 subseg_set (section
, (subsegT
) temp
);
1996 demand_empty_rest_of_line ();
1999 /* Handle the .appfile pseudo-op. This is automatically generated by
2000 do_scrub_chars when a preprocessor # line comment is seen with a
2001 file name. This default definition may be overridden by the object
2002 or CPU specific pseudo-ops. This function is also the default
2003 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
2007 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
2011 listing_source_file (file
);
2013 register_dependency (file
);
2015 obj_app_file (file
, appfile
);
2020 s_app_file (int appfile
)
2025 /* Some assemblers tolerate immediately following '"'. */
2026 if ((s
= demand_copy_string (&length
)) != 0)
2029 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
2031 /* In MRI mode, the preprocessor may have inserted an extraneous
2034 && *input_line_pointer
== '\''
2035 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2036 ++input_line_pointer
;
2038 demand_empty_rest_of_line ();
2040 s_app_file_string (s
, appfile
);
2045 get_linefile_number (int *flag
)
2049 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2052 *flag
= get_absolute_expression ();
2057 /* Handle the .appline pseudo-op. This is automatically generated by
2058 do_scrub_chars when a preprocessor # line comment is seen. This
2059 default definition may be overridden by the object or CPU specific
2063 s_app_line (int appline
)
2068 /* The given number is that of the next line. */
2070 l
= get_absolute_expression ();
2071 else if (!get_linefile_number (&l
))
2073 ignore_rest_of_line ();
2080 /* Some of the back ends can't deal with non-positive line numbers.
2081 Besides, it's silly. GCC however will generate a line number of
2082 zero when it is pre-processing builtins for assembler-with-cpp files:
2086 We do not want to barf on this, especially since such files are used
2087 in the GCC and GDB testsuites. So we check for negative line numbers
2088 rather than non-positive line numbers. */
2089 as_warn (_("line numbers must be positive; line number %d rejected"),
2100 if (*input_line_pointer
== '"')
2101 file
= demand_copy_string (&length
);
2107 while (get_linefile_number (&this_flag
))
2110 /* From GCC's cpp documentation:
2111 1: start of a new file.
2112 2: returning to a file after having included
2114 3: following text comes from a system header file.
2115 4: following text should be treated as extern "C".
2117 4 is nonsensical for the assembler; 3, we don't
2118 care about, so we ignore it just in case a
2119 system header file is included while
2120 preprocessing assembly. So 1 and 2 are all we
2121 care about, and they are mutually incompatible.
2122 new_logical_line_flags() demands this. */
2125 if (flags
&& flags
!= (1 << this_flag
))
2126 as_warn (_("incompatible flag %i in line directive"),
2129 flags
|= 1 << this_flag
;
2134 /* We ignore these. */
2138 as_warn (_("unsupported flag %i in line directive"),
2143 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2148 if (appline
|| file
)
2150 new_logical_line_flags (file
, l
, flags
);
2153 listing_source_line (l
);
2157 if (appline
|| file
)
2158 demand_empty_rest_of_line ();
2160 ignore_rest_of_line ();
2163 /* Handle the .end pseudo-op. Actually, the real work is done in
2164 read_a_source_file. */
2167 s_end (int ignore ATTRIBUTE_UNUSED
)
2171 /* The MRI assembler permits the start symbol to follow .end,
2172 but we don't support that. */
2174 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2175 && *input_line_pointer
!= '*'
2176 && *input_line_pointer
!= '!')
2177 as_warn (_("start address not supported"));
2181 /* Handle the .err pseudo-op. */
2184 s_err (int ignore ATTRIBUTE_UNUSED
)
2186 as_bad (_(".err encountered"));
2187 demand_empty_rest_of_line ();
2190 /* Handle the .error and .warning pseudo-ops. */
2196 /* The purpose for the conditional assignment is not to
2197 internationalize the directive itself, but that we need a
2198 self-contained message, one that can be passed like the
2199 demand_copy_C_string return value, and with no assumption on the
2200 location of the name of the directive within the message. */
2202 = (err
? _(".error directive invoked in source file")
2203 : _(".warning directive invoked in source file"));
2205 if (!is_it_end_of_statement ())
2207 if (*input_line_pointer
!= '\"')
2209 as_bad (_("%s argument must be a string"),
2210 err
? ".error" : ".warning");
2211 ignore_rest_of_line ();
2215 msg
= demand_copy_C_string (&len
);
2223 as_warn ("%s", msg
);
2224 demand_empty_rest_of_line ();
2227 /* Handle the MRI fail pseudo-op. */
2230 s_fail (int ignore ATTRIBUTE_UNUSED
)
2237 stop
= mri_comment_field (&stopc
);
2239 temp
= get_absolute_expression ();
2241 as_warn (_(".fail %ld encountered"), (long) temp
);
2243 as_bad (_(".fail %ld encountered"), (long) temp
);
2245 demand_empty_rest_of_line ();
2248 mri_comment_end (stop
, stopc
);
2252 s_fill (int ignore ATTRIBUTE_UNUSED
)
2254 expressionS rep_exp
;
2259 #ifdef md_flush_pending_output
2260 md_flush_pending_output ();
2263 #ifdef md_cons_align
2267 expression (&rep_exp
);
2268 if (*input_line_pointer
== ',')
2270 input_line_pointer
++;
2271 size
= get_absolute_expression ();
2272 if (*input_line_pointer
== ',')
2274 input_line_pointer
++;
2275 fill
= get_absolute_expression ();
2279 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2280 #define BSD_FILL_SIZE_CROCK_8 (8)
2281 if (size
> BSD_FILL_SIZE_CROCK_8
)
2283 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2284 size
= BSD_FILL_SIZE_CROCK_8
;
2288 as_warn (_("size negative; .fill ignored"));
2291 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2293 if (rep_exp
.X_add_number
< 0)
2294 as_warn (_("repeat < 0; .fill ignored"));
2298 if (size
&& !need_pass_2
)
2300 if (now_seg
== absolute_section
)
2302 if (rep_exp
.X_op
!= O_constant
)
2303 as_bad (_("non-constant fill count for absolute section"));
2304 else if (fill
&& rep_exp
.X_add_number
!= 0)
2305 as_bad (_("attempt to fill absolute section with non-zero value"));
2306 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2309 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2311 as_bad (_("attempt to fill section `%s' with non-zero value"),
2312 segment_name (now_seg
));
2314 if (rep_exp
.X_op
== O_constant
)
2316 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2317 (relax_substateT
) 0, (symbolS
*) 0,
2318 (offsetT
) rep_exp
.X_add_number
,
2323 /* We don't have a constant repeat count, so we can't use
2324 rs_fill. We can get the same results out of rs_space,
2325 but its argument is in bytes, so we must multiply the
2326 repeat count by size. */
2329 rep_sym
= make_expr_symbol (&rep_exp
);
2332 expressionS size_exp
;
2333 size_exp
.X_op
= O_constant
;
2334 size_exp
.X_add_number
= size
;
2336 rep_exp
.X_op
= O_multiply
;
2337 rep_exp
.X_add_symbol
= rep_sym
;
2338 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2339 rep_exp
.X_add_number
= 0;
2340 rep_sym
= make_expr_symbol (&rep_exp
);
2343 p
= frag_var (rs_space
, (int) size
, (int) size
,
2344 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2347 memset (p
, 0, (unsigned int) size
);
2349 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2350 flavoured AS. The following bizarre behaviour is to be
2351 compatible with above. I guess they tried to take up to 8
2352 bytes from a 4-byte expression and they forgot to sign
2354 #define BSD_FILL_SIZE_CROCK_4 (4)
2355 md_number_to_chars (p
, (valueT
) fill
,
2356 (size
> BSD_FILL_SIZE_CROCK_4
2357 ? BSD_FILL_SIZE_CROCK_4
2359 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2360 but emits no error message because it seems a legal thing to do.
2361 It is a degenerate case of .fill but could be emitted by a
2364 demand_empty_rest_of_line ();
2368 s_globl (int ignore ATTRIBUTE_UNUSED
)
2377 stop
= mri_comment_field (&stopc
);
2381 if ((name
= read_symbol_name ()) == NULL
)
2384 symbolP
= symbol_find_or_make (name
);
2385 S_SET_EXTERNAL (symbolP
);
2388 c
= *input_line_pointer
;
2391 input_line_pointer
++;
2393 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2401 demand_empty_rest_of_line ();
2404 mri_comment_end (stop
, stopc
);
2407 /* Handle the MRI IRP and IRPC pseudo-ops. */
2419 file
= as_where (&line
);
2421 eol
= find_end_of_line (input_line_pointer
, 0);
2422 sb_build (&s
, eol
- input_line_pointer
);
2423 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2424 input_line_pointer
= eol
;
2428 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2430 as_bad_where (file
, line
, "%s", err
);
2434 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2436 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2439 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2440 the section to only be linked once. However, this is not supported
2441 by most object file formats. This takes an optional argument,
2442 which is what to do about duplicates. */
2445 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2447 enum linkonce_type type
;
2451 type
= LINKONCE_DISCARD
;
2453 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2458 c
= get_symbol_name (& s
);
2459 if (strcasecmp (s
, "discard") == 0)
2460 type
= LINKONCE_DISCARD
;
2461 else if (strcasecmp (s
, "one_only") == 0)
2462 type
= LINKONCE_ONE_ONLY
;
2463 else if (strcasecmp (s
, "same_size") == 0)
2464 type
= LINKONCE_SAME_SIZE
;
2465 else if (strcasecmp (s
, "same_contents") == 0)
2466 type
= LINKONCE_SAME_CONTENTS
;
2468 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2470 (void) restore_line_pointer (c
);
2473 #ifdef obj_handle_link_once
2474 obj_handle_link_once (type
);
2475 #else /* ! defined (obj_handle_link_once) */
2479 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2480 as_warn (_(".linkonce is not supported for this object file format"));
2482 flags
= bfd_section_flags (now_seg
);
2483 flags
|= SEC_LINK_ONCE
;
2488 case LINKONCE_DISCARD
:
2489 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2491 case LINKONCE_ONE_ONLY
:
2492 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2494 case LINKONCE_SAME_SIZE
:
2495 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2497 case LINKONCE_SAME_CONTENTS
:
2498 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2501 if (!bfd_set_section_flags (now_seg
, flags
))
2502 as_bad (_("bfd_set_section_flags: %s"),
2503 bfd_errmsg (bfd_get_error ()));
2505 #endif /* ! defined (obj_handle_link_once) */
2507 demand_empty_rest_of_line ();
2511 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2514 segT current_seg
= now_seg
;
2515 subsegT current_subseg
= now_subseg
;
2516 segT bss_seg
= bss_section
;
2518 #if defined (TC_MIPS) || defined (TC_ALPHA)
2519 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2520 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2522 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2523 if (size
<= bfd_get_gp_size (stdoutput
))
2525 bss_seg
= subseg_new (".sbss", 1);
2526 seg_info (bss_seg
)->bss
= 1;
2527 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2528 as_warn (_("error setting flags for \".sbss\": %s"),
2529 bfd_errmsg (bfd_get_error ()));
2533 subseg_set (bss_seg
, 1);
2535 if (align
> OCTETS_PER_BYTE_POWER
)
2537 record_alignment (bss_seg
, align
);
2538 frag_align (align
, 0, 0);
2541 /* Detach from old frag. */
2542 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2543 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2545 symbol_set_frag (symbolP
, frag_now
);
2546 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2550 S_SET_SIZE (symbolP
, size
);
2552 S_SET_SEGMENT (symbolP
, bss_seg
);
2555 /* The symbol may already have been created with a preceding
2556 ".globl" directive -- be careful not to step on storage class
2557 in that case. Otherwise, set it to static. */
2558 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2559 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2560 #endif /* OBJ_COFF */
2562 subseg_set (current_seg
, current_subseg
);
2566 parse_align (int align_bytes
)
2572 if (*input_line_pointer
!= ',')
2575 as_bad (_("expected alignment after size"));
2576 ignore_rest_of_line ();
2580 input_line_pointer
++;
2583 align
= get_absolute_expr (&exp
);
2584 if (exp
.X_op
== O_absent
)
2587 if (!exp
.X_unsigned
)
2589 as_warn (_("alignment negative; 0 assumed"));
2593 if (align_bytes
&& align
!= 0)
2595 /* convert to a power of 2 alignment */
2596 unsigned int alignp2
= 0;
2597 while ((align
& 1) == 0)
2598 align
>>= 1, ++alignp2
;
2601 as_bad (_("alignment not a power of 2"));
2602 ignore_rest_of_line ();
2610 /* Called from s_comm_internal after symbol name and size have been
2611 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2612 1 if this was a ".bss" directive which has a 3rd argument
2613 (alignment as a power of 2), or 2 if this was a ".bss" directive
2614 with alignment in bytes. */
2617 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2623 align
= parse_align (needs_align
- 1);
2624 if (align
== (addressT
) -1)
2628 /* Assume some objects may require alignment on some systems. */
2629 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2631 bss_alloc (symbolP
, size
, align
);
2636 s_lcomm (int needs_align
)
2638 s_comm_internal (needs_align
, s_lcomm_internal
);
2642 s_lcomm_bytes (int needs_align
)
2644 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2648 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2654 /* We permit ANY defined expression: BSD4.2 demands constants. */
2655 if ((name
= read_symbol_name ()) == NULL
)
2658 if (*input_line_pointer
!= ',')
2660 as_bad (_("expected comma after \"%s\""), name
);
2664 input_line_pointer
++;
2665 expression_and_evaluate (&exp
);
2667 if (exp
.X_op
!= O_constant
2668 && exp
.X_op
!= O_register
)
2670 as_bad (_("bad expression"));
2674 symbolP
= symbol_find_or_make (name
);
2676 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2678 /* The name might be an undefined .global symbol; be sure to
2679 keep the "external" bit. */
2680 S_SET_SEGMENT (symbolP
,
2681 (exp
.X_op
== O_constant
2684 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2688 as_bad (_("symbol `%s' is already defined"), name
);
2691 demand_empty_rest_of_line ();
2696 ignore_rest_of_line ();
2701 /* Read a line into an sb. Returns the character that ended the line
2702 or zero if there are no more lines. */
2705 get_line_sb (sb
*line
, int in_macro
)
2709 if (input_line_pointer
[-1] == '\n')
2710 bump_line_counters ();
2712 if (input_line_pointer
>= buffer_limit
)
2714 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2715 if (buffer_limit
== 0)
2719 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2720 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2721 input_line_pointer
= eol
;
2723 /* Don't skip multiple end-of-line characters, because that breaks support
2724 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2725 characters but isn't. Instead just skip one end of line character and
2726 return the character skipped so that the caller can re-insert it if
2728 return *input_line_pointer
++;
2732 get_non_macro_line_sb (sb
*line
)
2734 return get_line_sb (line
, 0);
2738 get_macro_line_sb (sb
*line
)
2740 return get_line_sb (line
, 1);
2743 /* Define a macro. This is an interface to macro.c. */
2746 s_macro (int ignore ATTRIBUTE_UNUSED
)
2755 file
= as_where (&line
);
2757 eol
= find_end_of_line (input_line_pointer
, 0);
2758 sb_build (&s
, eol
- input_line_pointer
);
2759 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2760 input_line_pointer
= eol
;
2762 if (line_label
!= NULL
)
2767 name
= S_GET_NAME (line_label
);
2768 len
= strlen (name
);
2769 sb_build (&label
, len
);
2770 sb_add_buffer (&label
, name
, len
);
2771 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2775 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2777 as_bad_where (file
, line
, err
, name
);
2780 if (line_label
!= NULL
)
2782 S_SET_SEGMENT (line_label
, absolute_section
);
2783 S_SET_VALUE (line_label
, 0);
2784 symbol_set_frag (line_label
, &zero_address_frag
);
2787 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2788 && po_entry_find (po_hash
, name
) != NULL
)
2791 && po_entry_find (po_hash
, name
+ 1) != NULL
))
2792 as_warn_where (file
,
2794 _("attempt to redefine pseudo-op `%s' ignored"),
2801 /* Handle the .mexit pseudo-op, which immediately exits a macro
2805 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2809 cond_exit_macro (macro_nest
);
2810 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2813 as_warn (_("ignoring macro exit outside a macro definition."));
2816 /* Switch in and out of MRI mode. */
2819 s_mri (int ignore ATTRIBUTE_UNUSED
)
2822 #ifdef MRI_MODE_CHANGE
2826 on
= get_absolute_expression ();
2827 #ifdef MRI_MODE_CHANGE
2828 old_flag
= flag_mri
;
2847 /* Operator precedence changes in m68k MRI mode, so we need to
2848 update the operator rankings. */
2849 expr_set_precedence ();
2851 #ifdef MRI_MODE_CHANGE
2853 MRI_MODE_CHANGE (on
);
2856 demand_empty_rest_of_line ();
2859 /* Handle changing the location counter. */
2862 do_org (segT segment
, expressionS
*exp
, int fill
)
2864 if (segment
!= now_seg
2865 && segment
!= absolute_section
2866 && segment
!= expr_section
)
2867 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2869 if (now_seg
== absolute_section
)
2872 as_warn (_("ignoring fill value in absolute section"));
2873 if (exp
->X_op
!= O_constant
)
2875 as_bad (_("only constant offsets supported in absolute section"));
2876 exp
->X_add_number
= 0;
2878 abs_section_offset
= exp
->X_add_number
;
2883 symbolS
*sym
= exp
->X_add_symbol
;
2884 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2886 if (fill
&& in_bss ())
2887 as_warn (_("ignoring fill value in section `%s'"),
2888 segment_name (now_seg
));
2890 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2892 /* Handle complex expressions. */
2893 sym
= make_expr_symbol (exp
);
2897 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2903 s_org (int ignore ATTRIBUTE_UNUSED
)
2909 #ifdef md_flush_pending_output
2910 md_flush_pending_output ();
2913 /* The m68k MRI assembler has a different meaning for .org. It
2914 means to create an absolute section at a given address. We can't
2915 support that--use a linker script instead. */
2918 as_bad (_("MRI style ORG pseudo-op not supported"));
2919 ignore_rest_of_line ();
2923 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2924 thing as a sub-segment-relative origin. Any absolute origin is
2925 given a warning, then assumed to be segment-relative. Any
2926 segmented origin expression ("foo+42") had better be in the right
2927 segment or the .org is ignored.
2929 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2930 we never know sub-segment sizes when we are reading code. BSD
2931 will crash trying to emit negative numbers of filler bytes in
2932 certain .orgs. We don't crash, but see as-write for that code.
2934 Don't make frag if need_pass_2==1. */
2935 segment
= get_known_segmented_expression (&exp
);
2936 if (*input_line_pointer
== ',')
2938 input_line_pointer
++;
2939 temp_fill
= get_absolute_expression ();
2945 do_org (segment
, &exp
, temp_fill
);
2947 demand_empty_rest_of_line ();
2950 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2951 called by the obj-format routine which handles section changing
2952 when in MRI mode. It will create a new section, and return it. It
2953 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2954 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2957 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2967 name
= input_line_pointer
;
2968 if (!ISDIGIT (*name
))
2969 c
= get_symbol_name (& name
);
2974 ++input_line_pointer
;
2976 while (ISDIGIT (*input_line_pointer
));
2978 c
= *input_line_pointer
;
2979 *input_line_pointer
= '\0';
2982 name
= xstrdup (name
);
2984 c
= restore_line_pointer (c
);
2986 seg
= subseg_new (name
, 0);
2992 ++input_line_pointer
;
2993 align
= get_absolute_expression ();
2994 record_alignment (seg
, align
);
2998 if (*input_line_pointer
== ',')
3000 c
= *++input_line_pointer
;
3002 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
3005 as_bad (_("unrecognized section type"));
3006 ++input_line_pointer
;
3011 flags
= SEC_NO_FLAGS
;
3013 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
3014 else if (*type
== 'D' || *type
== 'M')
3015 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
3016 else if (*type
== 'R')
3017 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
3018 if (flags
!= SEC_NO_FLAGS
)
3020 if (!bfd_set_section_flags (seg
, flags
))
3021 as_warn (_("error setting flags for \"%s\": %s"),
3022 bfd_section_name (seg
),
3023 bfd_errmsg (bfd_get_error ()));
3028 /* Ignore the HP type. */
3029 if (*input_line_pointer
== ',')
3030 input_line_pointer
+= 2;
3032 demand_empty_rest_of_line ();
3034 #else /* ! TC_M68K */
3035 /* The MRI assembler seems to use different forms of .sect for
3036 different targets. */
3037 as_bad ("MRI mode not supported for this target");
3038 ignore_rest_of_line ();
3039 #endif /* ! TC_M68K */
3042 /* Handle the .print pseudo-op. */
3045 s_print (int ignore ATTRIBUTE_UNUSED
)
3050 s
= demand_copy_C_string (&len
);
3053 demand_empty_rest_of_line ();
3056 /* Handle the .purgem pseudo-op. */
3059 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3061 if (is_it_end_of_statement ())
3063 demand_empty_rest_of_line ();
3073 c
= get_symbol_name (& name
);
3074 delete_macro (name
);
3075 *input_line_pointer
= c
;
3076 SKIP_WHITESPACE_AFTER_NAME ();
3078 while (*input_line_pointer
++ == ',');
3080 --input_line_pointer
;
3081 demand_empty_rest_of_line ();
3084 /* Handle the .endm/.endr pseudo-ops. */
3087 s_bad_end (int endr
)
3089 as_warn (_(".end%c encountered without preceding %s"),
3091 endr
? ".rept, .irp, or .irpc" : ".macro");
3092 demand_empty_rest_of_line ();
3095 /* Handle the .rept pseudo-op. */
3098 s_rept (int ignore ATTRIBUTE_UNUSED
)
3102 count
= (size_t) get_absolute_expression ();
3104 do_repeat (count
, "REPT", "ENDR");
3107 /* This function provides a generic repeat block implementation. It allows
3108 different directives to be used as the start/end keys. */
3111 do_repeat (size_t count
, const char *start
, const char *end
)
3116 if (((ssize_t
) count
) < 0)
3118 as_bad (_("negative count for %s - ignored"), start
);
3123 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3125 as_bad (_("%s without %s"), start
, end
);
3129 sb_build (&many
, count
* one
.len
);
3131 sb_add_sb (&many
, &one
);
3135 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3137 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3140 /* Like do_repeat except that any text matching EXPANDER in the
3141 block is replaced by the iteration count. */
3144 do_repeat_with_expander (size_t count
,
3147 const char * expander
)
3152 if (((ssize_t
) count
) < 0)
3154 as_bad (_("negative count for %s - ignored"), start
);
3159 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3161 as_bad (_("%s without %s"), start
, end
);
3167 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3169 while (count
-- > 0)
3175 sb_build (& processed
, one
.len
);
3176 sb_add_sb (& processed
, & one
);
3177 sub
= strstr (processed
.ptr
, expander
);
3178 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3179 gas_assert (len
< 8);
3180 memmove (sub
+ len
, sub
+ 8,
3181 processed
.ptr
+ processed
.len
- (sub
+ 8));
3182 processed
.len
-= (8 - len
);
3183 sb_add_sb (& many
, & processed
);
3184 sb_kill (& processed
);
3189 sb_add_sb (&many
, &one
);
3193 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3195 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3198 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3199 input buffers to skip. Assumes that conditionals preceding the loop end
3200 are properly nested.
3202 This function makes it easier to implement a premature "break" out of the
3203 loop. The EXTRA arg accounts for other buffers we might have inserted,
3204 such as line substitutions. */
3207 end_repeat (int extra
)
3209 cond_exit_macro (macro_nest
);
3210 while (extra
-- >= 0)
3211 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3215 assign_symbol (char *name
, int mode
)
3219 if (name
[0] == '.' && name
[1] == '\0')
3221 /* Turn '. = mumble' into a .org mumble. */
3225 segment
= get_known_segmented_expression (&exp
);
3228 do_org (segment
, &exp
, 0);
3233 if ((symbolP
= symbol_find (name
)) == NULL
3234 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3236 symbolP
= symbol_find_or_make (name
);
3238 /* When doing symbol listings, play games with dummy fragments living
3239 outside the normal fragment chain to record the file and line info
3241 if (listing
& LISTING_SYMBOLS
)
3243 extern struct list_info_struct
*listing_tail
;
3244 fragS
*dummy_frag
= XCNEW (fragS
);
3245 dummy_frag
->line
= listing_tail
;
3246 dummy_frag
->fr_symbol
= symbolP
;
3247 symbol_set_frag (symbolP
, dummy_frag
);
3250 #if defined (OBJ_COFF) && !defined (TE_PE)
3251 /* "set" symbols are local unless otherwise specified. */
3252 SF_SET_LOCAL (symbolP
);
3256 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3258 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3259 && !S_CAN_BE_REDEFINED (symbolP
))
3261 as_bad (_("symbol `%s' is already defined"), name
);
3262 ignore_rest_of_line ();
3263 input_line_pointer
--;
3266 /* If the symbol is volatile, copy the symbol and replace the
3267 original with the copy, so that previous uses of the symbol will
3268 retain the value of the symbol at the point of use. */
3269 else if (S_IS_VOLATILE (symbolP
))
3270 symbolP
= symbol_clone (symbolP
, 1);
3274 S_SET_VOLATILE (symbolP
);
3276 S_SET_FORWARD_REF (symbolP
);
3278 pseudo_set (symbolP
);
3281 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3282 then this is .equiv, and it is an error if the symbol is already
3283 defined. If EQUIV is -1, the symbol additionally is a forward
3291 /* Especial apologies for the random logic:
3292 this just grew, and could be parsed much more simply!
3294 if ((name
= read_symbol_name ()) == NULL
)
3297 if (*input_line_pointer
!= ',')
3299 as_bad (_("expected comma after \"%s\""), name
);
3300 ignore_rest_of_line ();
3305 input_line_pointer
++;
3306 assign_symbol (name
, equiv
);
3307 demand_empty_rest_of_line ();
3321 #ifdef md_flush_pending_output
3322 md_flush_pending_output ();
3325 #ifdef md_cons_align
3330 stop
= mri_comment_field (&stopc
);
3332 /* In m68k MRI mode, we need to align to a word boundary, unless
3334 if (flag_m68k_mri
&& mult
> 1)
3336 if (now_seg
== absolute_section
)
3338 abs_section_offset
+= abs_section_offset
& 1;
3339 if (line_label
!= NULL
)
3340 S_SET_VALUE (line_label
, abs_section_offset
);
3342 else if (mri_common_symbol
!= NULL
)
3346 mri_val
= S_GET_VALUE (mri_common_symbol
);
3347 if ((mri_val
& 1) != 0)
3349 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3350 if (line_label
!= NULL
)
3352 expressionS
*symexp
;
3354 symexp
= symbol_get_value_expression (line_label
);
3355 know (symexp
->X_op
== O_symbol
);
3356 know (symexp
->X_add_symbol
== mri_common_symbol
);
3357 symexp
->X_add_number
+= 1;
3363 do_align (1, (char *) NULL
, 0, 0);
3364 if (line_label
!= NULL
)
3366 symbol_set_frag (line_label
, frag_now
);
3367 S_SET_VALUE (line_label
, frag_now_fix ());
3377 if (*input_line_pointer
== ',')
3379 ++input_line_pointer
;
3384 val
.X_op
= O_constant
;
3385 val
.X_add_number
= 0;
3388 if ((val
.X_op
!= O_constant
3389 || val
.X_add_number
< - 0x80
3390 || val
.X_add_number
> 0xff
3391 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3392 && (now_seg
!= absolute_section
&& !in_bss ()))
3394 resolve_expression (&exp
);
3395 if (exp
.X_op
!= O_constant
)
3396 as_bad (_("unsupported variable size or fill value"));
3401 /* PR 20901: Check for excessive values.
3402 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3403 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3404 as_bad (_("size value for space directive too large: %lx"),
3405 (long) exp
.X_add_number
);
3410 bytes
= mult
* exp
.X_add_number
;
3412 for (i
= 0; i
< exp
.X_add_number
; i
++)
3413 emit_expr (&val
, mult
);
3419 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3420 resolve_expression (&exp
);
3422 if (exp
.X_op
== O_constant
)
3426 repeat
= exp
.X_add_number
;
3433 as_warn (_(".space repeat count is zero, ignored"));
3434 else if (repeat
< 0)
3435 as_warn (_(".space repeat count is negative, ignored"));
3439 /* If we are in the absolute section, just bump the offset. */
3440 if (now_seg
== absolute_section
)
3442 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3443 as_warn (_("ignoring fill value in absolute section"));
3444 abs_section_offset
+= repeat
;
3448 /* If we are secretly in an MRI common section, then
3449 creating space just increases the size of the common
3451 if (mri_common_symbol
!= NULL
)
3453 S_SET_VALUE (mri_common_symbol
,
3454 S_GET_VALUE (mri_common_symbol
) + repeat
);
3459 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3460 (offsetT
) repeat
, (char *) 0);
3464 if (now_seg
== absolute_section
)
3466 as_bad (_("space allocation too complex in absolute section"));
3467 subseg_set (text_section
, 0);
3470 if (mri_common_symbol
!= NULL
)
3472 as_bad (_("space allocation too complex in common section"));
3473 mri_common_symbol
= NULL
;
3477 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3478 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3481 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3482 as_warn (_("ignoring fill value in section `%s'"),
3483 segment_name (now_seg
));
3485 *p
= val
.X_add_number
;
3490 /* In MRI mode, after an odd number of bytes, we must align to an
3491 even word boundary, unless the next instruction is a dc.b, ds.b
3493 if (flag_mri
&& (bytes
& 1) != 0)
3494 mri_pending_align
= 1;
3496 demand_empty_rest_of_line ();
3499 mri_comment_end (stop
, stopc
);
3503 s_nops (int ignore ATTRIBUTE_UNUSED
)
3508 #ifdef md_flush_pending_output
3509 md_flush_pending_output ();
3512 #ifdef md_cons_align
3518 if (*input_line_pointer
== ',')
3520 ++input_line_pointer
;
3525 val
.X_op
= O_constant
;
3526 val
.X_add_number
= 0;
3529 if (val
.X_op
== O_constant
)
3531 if (val
.X_add_number
< 0)
3533 as_warn (_("negative nop control byte, ignored"));
3534 val
.X_add_number
= 0;
3539 /* Store the no-op instruction control byte in the first byte
3542 symbolS
*sym
= make_expr_symbol (&exp
);
3543 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3544 sym
, (offsetT
) 0, (char *) 0);
3545 *p
= val
.X_add_number
;
3549 as_bad (_("unsupported variable nop control in .nops directive"));
3551 demand_empty_rest_of_line ();
3554 /* This is like s_space, but the value is a floating point number with
3555 the given precision. This is for the MRI dcb.s pseudo-op and
3559 s_float_space (int float_type
)
3563 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3567 #ifdef md_cons_align
3572 stop
= mri_comment_field (&stopc
);
3574 count
= get_absolute_expression ();
3577 if (*input_line_pointer
!= ',')
3579 as_bad (_("missing value"));
3580 ignore_rest_of_line ();
3582 mri_comment_end (stop
, stopc
);
3586 ++input_line_pointer
;
3590 /* Skip any 0{letter} that may be present. Don't even check if the
3591 * letter is legal. */
3592 if (input_line_pointer
[0] == '0'
3593 && ISALPHA (input_line_pointer
[1]))
3594 input_line_pointer
+= 2;
3596 /* Accept :xxxx, where the x's are hex digits, for a floating point
3597 with the exact digits specified. */
3598 if (input_line_pointer
[0] == ':')
3600 flen
= hex_float (float_type
, temp
);
3603 ignore_rest_of_line ();
3605 mri_comment_end (stop
, stopc
);
3613 err
= md_atof (float_type
, temp
, &flen
);
3614 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3615 know (err
!= NULL
|| flen
> 0);
3618 as_bad (_("bad floating literal: %s"), err
);
3619 ignore_rest_of_line ();
3621 mri_comment_end (stop
, stopc
);
3626 while (--count
>= 0)
3630 p
= frag_more (flen
);
3631 memcpy (p
, temp
, (unsigned int) flen
);
3634 demand_empty_rest_of_line ();
3637 mri_comment_end (stop
, stopc
);
3640 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3643 s_struct (int ignore ATTRIBUTE_UNUSED
)
3649 stop
= mri_comment_field (&stopc
);
3650 abs_section_offset
= get_absolute_expression ();
3651 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3652 /* The ELF backend needs to know that we are changing sections, so
3653 that .previous works correctly. */
3655 obj_elf_section_change_hook ();
3657 subseg_set (absolute_section
, 0);
3658 demand_empty_rest_of_line ();
3660 mri_comment_end (stop
, stopc
);
3664 s_text (int ignore ATTRIBUTE_UNUSED
)
3668 temp
= get_absolute_expression ();
3669 subseg_set (text_section
, (subsegT
) temp
);
3670 demand_empty_rest_of_line ();
3673 /* .weakref x, y sets x as an alias to y that, as long as y is not
3674 referenced directly, will cause y to become a weak symbol. */
3676 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3683 if ((name
= read_symbol_name ()) == NULL
)
3686 symbolP
= symbol_find_or_make (name
);
3688 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3690 if (!S_IS_VOLATILE (symbolP
))
3692 as_bad (_("symbol `%s' is already defined"), name
);
3695 symbolP
= symbol_clone (symbolP
, 1);
3696 S_CLEAR_VOLATILE (symbolP
);
3701 if (*input_line_pointer
!= ',')
3703 as_bad (_("expected comma after \"%s\""), name
);
3707 input_line_pointer
++;
3712 if ((name
= read_symbol_name ()) == NULL
)
3715 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3716 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3718 symbolP2
= symbol_find_or_make (name
);
3719 S_SET_WEAKREFD (symbolP2
);
3723 symbolS
*symp
= symbolP2
;
3725 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3727 expressionS
*expP
= symbol_get_value_expression (symp
);
3729 gas_assert (expP
->X_op
== O_symbol
3730 && expP
->X_add_number
== 0);
3731 symp
= expP
->X_add_symbol
;
3733 if (symp
== symbolP
)
3737 loop
= concat (S_GET_NAME (symbolP
),
3738 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3741 while (symp
!= symbolP
)
3743 char *old_loop
= loop
;
3745 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3746 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3747 (const char *) NULL
);
3751 as_bad (_("%s: would close weakref loop: %s"),
3752 S_GET_NAME (symbolP
), loop
);
3756 ignore_rest_of_line ();
3760 /* Short-circuiting instead of just checking here might speed
3761 things up a tiny little bit, but loop error messages would
3762 miss intermediate links. */
3763 /* symbolP2 = symp; */
3766 memset (&exp
, 0, sizeof (exp
));
3767 exp
.X_op
= O_symbol
;
3768 exp
.X_add_symbol
= symbolP2
;
3770 S_SET_SEGMENT (symbolP
, undefined_section
);
3771 symbol_set_value_expression (symbolP
, &exp
);
3772 symbol_set_frag (symbolP
, &zero_address_frag
);
3773 S_SET_WEAKREFR (symbolP
);
3775 demand_empty_rest_of_line ();
3780 ignore_rest_of_line ();
3786 /* Verify that we are at the end of a line. If not, issue an error and
3790 demand_empty_rest_of_line (void)
3793 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3794 input_line_pointer
++;
3797 if (ISPRINT (*input_line_pointer
))
3798 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3799 *input_line_pointer
);
3801 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3802 *input_line_pointer
);
3803 ignore_rest_of_line ();
3806 /* Return pointing just after end-of-line. */
3807 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3810 /* Silently advance to the end of line. Use this after already having
3811 issued an error about something bad. */
3814 ignore_rest_of_line (void)
3816 while (input_line_pointer
< buffer_limit
3817 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3818 input_line_pointer
++;
3820 input_line_pointer
++;
3822 /* Return pointing just after end-of-line. */
3823 if (input_line_pointer
<= buffer_limit
)
3824 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3827 /* Sets frag for given symbol to zero_address_frag, except when the
3828 symbol frag is already set to a dummy listing frag. */
3831 set_zero_frag (symbolS
*symbolP
)
3833 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3834 symbol_set_frag (symbolP
, &zero_address_frag
);
3837 /* In: Pointer to a symbol.
3838 Input_line_pointer->expression.
3840 Out: Input_line_pointer->just after any whitespace after expression.
3841 Tried to set symbol to value of expression.
3842 Will change symbols type, value, and frag; */
3845 pseudo_set (symbolS
*symbolP
)
3850 know (symbolP
); /* NULL pointer is logic error. */
3852 if (!S_IS_FORWARD_REF (symbolP
))
3853 (void) expression (&exp
);
3855 (void) deferred_expression (&exp
);
3857 if (exp
.X_op
== O_illegal
)
3858 as_bad (_("illegal expression"));
3859 else if (exp
.X_op
== O_absent
)
3860 as_bad (_("missing expression"));
3861 else if (exp
.X_op
== O_big
)
3863 if (exp
.X_add_number
> 0)
3864 as_bad (_("bignum invalid"));
3866 as_bad (_("floating point number invalid"));
3868 else if (exp
.X_op
== O_subtract
3869 && !S_IS_FORWARD_REF (symbolP
)
3870 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3871 && (symbol_get_frag (exp
.X_add_symbol
)
3872 == symbol_get_frag (exp
.X_op_symbol
)))
3874 exp
.X_op
= O_constant
;
3875 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3876 - S_GET_VALUE (exp
.X_op_symbol
));
3879 if (symbol_section_p (symbolP
))
3881 as_bad ("attempt to set value of section symbol");
3890 exp
.X_add_number
= 0;
3893 S_SET_SEGMENT (symbolP
, absolute_section
);
3894 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3895 set_zero_frag (symbolP
);
3899 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3900 if (S_IS_EXTERNAL (symbolP
))
3902 as_bad ("can't equate global symbol `%s' with register name",
3903 S_GET_NAME (symbolP
));
3907 S_SET_SEGMENT (symbolP
, reg_section
);
3908 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3909 set_zero_frag (symbolP
);
3910 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3914 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3915 /* For x=undef+const, create an expression symbol.
3916 For x=x+const, just update x except when x is an undefined symbol
3917 For x=defined+const, evaluate x. */
3918 if (symbolP
== exp
.X_add_symbol
3919 && (seg
!= undefined_section
3920 || !symbol_constant_p (symbolP
)))
3922 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3925 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3927 symbolS
*s
= exp
.X_add_symbol
;
3929 if (S_IS_COMMON (s
))
3930 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3931 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3933 S_SET_SEGMENT (symbolP
, seg
);
3934 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3935 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3936 copy_symbol_attributes (symbolP
, s
);
3939 S_SET_SEGMENT (symbolP
, undefined_section
);
3940 symbol_set_value_expression (symbolP
, &exp
);
3941 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3942 set_zero_frag (symbolP
);
3946 /* The value is some complex expression. */
3947 S_SET_SEGMENT (symbolP
, expr_section
);
3948 symbol_set_value_expression (symbolP
, &exp
);
3949 set_zero_frag (symbolP
);
3956 CONStruct more frag of .bytes, or .words etc.
3957 Should need_pass_2 be 1 then emit no frag(s).
3958 This understands EXPRESSIONS.
3962 This has a split personality. We use expression() to read the
3963 value. We can detect if the value won't fit in a byte or word.
3964 But we can't detect if expression() discarded significant digits
3965 in the case of a long. Not worth the crocks required to fix it. */
3967 /* Select a parser for cons expressions. */
3969 /* Some targets need to parse the expression in various fancy ways.
3970 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3971 (for example, the HPPA does this). Otherwise, you can define
3972 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3973 are defined, which is the normal case, then only simple expressions
3978 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3981 #ifndef TC_PARSE_CONS_EXPRESSION
3982 #ifdef REPEAT_CONS_EXPRESSIONS
3983 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3984 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3986 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3989 /* If we haven't gotten one yet, just call expression. */
3990 #ifndef TC_PARSE_CONS_EXPRESSION
3991 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3992 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3997 do_parse_cons_expression (expressionS
*exp
,
3998 int nbytes ATTRIBUTE_UNUSED
)
4000 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4004 /* Worker to do .byte etc statements.
4005 Clobbers input_line_pointer and checks end-of-line. */
4008 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
4016 #ifdef md_flush_pending_output
4017 md_flush_pending_output ();
4021 stop
= mri_comment_field (&stopc
);
4023 if (is_it_end_of_statement ())
4025 demand_empty_rest_of_line ();
4027 mri_comment_end (stop
, stopc
);
4031 #ifdef TC_ADDRESS_BYTES
4033 nbytes
= TC_ADDRESS_BYTES ();
4036 #ifdef md_cons_align
4037 md_cons_align (nbytes
);
4043 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
4044 #ifdef TC_CONS_FIX_CHECK
4045 fixS
**cur_fix
= &frchain_now
->fix_tail
;
4047 if (*cur_fix
!= NULL
)
4048 cur_fix
= &(*cur_fix
)->fx_next
;
4053 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4058 if (*input_line_pointer
== '"')
4060 as_bad (_("unexpected `\"' in expression"));
4061 ignore_rest_of_line ();
4065 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4070 if (exp
.X_op
== O_symbol
)
4071 exp
.X_op
= O_symbol_rva
;
4073 as_fatal (_("rva without symbol"));
4075 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4076 #ifdef TC_CONS_FIX_CHECK
4077 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4081 while (*input_line_pointer
++ == ',');
4083 /* In MRI mode, after an odd number of bytes, we must align to an
4084 even word boundary, unless the next instruction is a dc.b, ds.b
4086 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4087 mri_pending_align
= 1;
4089 input_line_pointer
--; /* Put terminator back into stream. */
4091 demand_empty_rest_of_line ();
4094 mri_comment_end (stop
, stopc
);
4100 cons_worker (size
, 0);
4106 cons_worker (size
, 1);
4109 /* .reloc offset, reloc_name, symbol+addend. */
4112 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4119 struct reloc_list
*reloc
;
4120 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4121 static struct _bfd_rel bfd_relocs
[] =
4123 { "NONE", BFD_RELOC_NONE
},
4124 { "8", BFD_RELOC_8
},
4125 { "16", BFD_RELOC_16
},
4126 { "32", BFD_RELOC_32
},
4127 { "64", BFD_RELOC_64
}
4130 reloc
= XNEW (struct reloc_list
);
4133 stop
= mri_comment_field (&stopc
);
4142 as_bad (_("missing or bad offset expression"));
4145 exp
.X_add_symbol
= section_symbol (now_seg
);
4146 exp
.X_op
= O_symbol
;
4149 if (exp
.X_add_number
== 0)
4151 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4156 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4161 if (*input_line_pointer
!= ',')
4163 as_bad (_("missing reloc type"));
4167 ++input_line_pointer
;
4169 c
= get_symbol_name (& r_name
);
4170 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4174 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4175 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4177 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4178 bfd_relocs
[i
].code
);
4183 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4184 *input_line_pointer
= c
;
4185 if (reloc
->u
.a
.howto
== NULL
)
4187 as_bad (_("unrecognized reloc type"));
4191 exp
.X_op
= O_absent
;
4192 SKIP_WHITESPACE_AFTER_NAME ();
4193 if (*input_line_pointer
== ',')
4195 ++input_line_pointer
;
4203 as_bad (_("bad reloc expression"));
4205 ignore_rest_of_line ();
4208 mri_comment_end (stop
, stopc
);
4211 reloc
->u
.a
.sym
= NULL
;
4212 reloc
->u
.a
.addend
= 0;
4215 reloc
->u
.a
.sym
= NULL
;
4216 reloc
->u
.a
.addend
= exp
.X_add_number
;
4219 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4220 reloc
->u
.a
.addend
= exp
.X_add_number
;
4223 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4224 reloc
->u
.a
.addend
= 0;
4228 reloc
->file
= as_where (&reloc
->line
);
4229 reloc
->next
= reloc_list
;
4232 demand_empty_rest_of_line ();
4234 mri_comment_end (stop
, stopc
);
4237 /* Put the contents of expression EXP into the object file using
4238 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4241 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4243 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4247 emit_expr_with_reloc (expressionS
*exp
,
4248 unsigned int nbytes
,
4249 TC_PARSE_CONS_RETURN_TYPE reloc
)
4253 valueT extra_digit
= 0;
4255 /* Don't do anything if we are going to make another pass. */
4260 dot_value
= frag_now_fix ();
4261 dot_frag
= frag_now
;
4265 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4266 appear as a four byte positive constant in the .line section,
4267 followed by a 2 byte 0xffff. Look for that case here. */
4269 static int dwarf_line
= -1;
4271 if (strcmp (segment_name (now_seg
), ".line") != 0)
4273 else if (dwarf_line
>= 0
4275 && exp
->X_op
== O_constant
4276 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4277 listing_source_line ((unsigned int) dwarf_line
);
4278 else if (nbytes
== 4
4279 && exp
->X_op
== O_constant
4280 && exp
->X_add_number
>= 0)
4281 dwarf_line
= exp
->X_add_number
;
4286 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4287 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4288 AT_sibling (0x12) followed by a four byte address of the sibling
4289 followed by a 2 byte AT_name (0x38) followed by the name of the
4290 file. We look for that case here. */
4292 static int dwarf_file
= 0;
4294 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4296 else if (dwarf_file
== 0
4298 && exp
->X_op
== O_constant
4299 && exp
->X_add_number
== 0x11)
4301 else if (dwarf_file
== 1
4303 && exp
->X_op
== O_constant
4304 && exp
->X_add_number
== 0x12)
4306 else if (dwarf_file
== 2
4309 else if (dwarf_file
== 3
4311 && exp
->X_op
== O_constant
4312 && exp
->X_add_number
== 0x38)
4317 /* The variable dwarf_file_string tells stringer that the string
4318 may be the name of the source file. */
4319 if (dwarf_file
== 4)
4320 dwarf_file_string
= 1;
4322 dwarf_file_string
= 0;
4327 if (check_eh_frame (exp
, &nbytes
))
4332 /* Handle a negative bignum. */
4334 && exp
->X_add_number
== 0
4335 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4336 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4339 unsigned long carry
;
4341 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4343 /* Negate the bignum: one's complement each digit and add 1. */
4345 for (i
= 0; i
< exp
->X_add_number
; i
++)
4349 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4352 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4353 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4356 /* We can ignore any carry out, because it will be handled by
4357 extra_digit if it is needed. */
4359 extra_digit
= (valueT
) -1;
4363 if (op
== O_absent
|| op
== O_illegal
)
4365 as_warn (_("zero assumed for missing expression"));
4366 exp
->X_add_number
= 0;
4369 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4371 as_bad (_("floating point number invalid"));
4372 exp
->X_add_number
= 0;
4375 else if (op
== O_register
)
4377 as_warn (_("register value used as expression"));
4381 /* Allow `.word 0' in the absolute section. */
4382 if (now_seg
== absolute_section
)
4384 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4385 as_bad (_("attempt to store value in absolute section"));
4386 abs_section_offset
+= nbytes
;
4390 /* Allow `.word 0' in BSS style sections. */
4391 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4392 as_bad (_("attempt to store non-zero value in section `%s'"),
4393 segment_name (now_seg
));
4395 p
= frag_more ((int) nbytes
);
4397 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4399 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4403 #ifndef WORKING_DOT_WORD
4404 /* If we have the difference of two symbols in a word, save it on
4405 the broken_words list. See the code in write.c. */
4406 if (op
== O_subtract
&& nbytes
== 2)
4408 struct broken_word
*x
;
4410 x
= XNEW (struct broken_word
);
4411 x
->next_broken_word
= broken_words
;
4414 x
->subseg
= now_subseg
;
4416 x
->word_goes_here
= p
;
4418 x
->add
= exp
->X_add_symbol
;
4419 x
->sub
= exp
->X_op_symbol
;
4420 x
->addnum
= exp
->X_add_number
;
4428 /* If we have an integer, but the number of bytes is too large to
4429 pass to md_number_to_chars, handle it as a bignum. */
4430 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4432 extra_digit
= exp
->X_unsigned
? 0 : -1;
4433 convert_to_bignum (exp
, !exp
->X_unsigned
);
4437 if (op
== O_constant
)
4445 /* JF << of >= number of bits in the object is undefined. In
4446 particular SPARC (Sun 4) has problems. */
4447 if (nbytes
>= sizeof (valueT
))
4450 if (nbytes
> sizeof (valueT
))
4453 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4457 /* Don't store these bits. */
4458 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4459 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4462 unmask
= ~mask
; /* Do store these bits. */
4465 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4466 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4469 get
= exp
->X_add_number
;
4471 if ((get
& mask
) != 0
4472 && ((get
& mask
) != mask
4473 || (get
& hibit
) == 0))
4475 /* Leading bits contain both 0s & 1s. */
4476 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4478 as_warn (_("value 0x%llx truncated to 0x%llx"),
4479 (unsigned long long) get
, (unsigned long long) use
);
4481 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4482 (unsigned long long) get
, (unsigned long long) use
);
4485 as_warn (_("value 0x%lx truncated to 0x%lx"),
4486 (unsigned long) get
, (unsigned long) use
);
4489 /* Put bytes in right order. */
4490 md_number_to_chars (p
, use
, (int) nbytes
);
4492 else if (op
== O_big
)
4495 LITTLENUM_TYPE
*nums
;
4497 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4500 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4504 LITTLENUM_TYPE sign
= 0;
4505 if ((generic_bignum
[--i
]
4506 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4507 sign
= ~(LITTLENUM_TYPE
) 0;
4509 while (++i
< exp
->X_add_number
)
4510 if (generic_bignum
[i
] != sign
)
4513 else if (nbytes
== 1)
4515 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4516 Check that bits 8.. of generic_bignum[0] match bit 7
4517 and that they match all of generic_bignum[1..exp->X_add_number]. */
4518 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4519 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4521 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4523 while (++i
< exp
->X_add_number
)
4524 if (generic_bignum
[i
] != sign
)
4529 if (i
< exp
->X_add_number
)
4530 as_warn (ngettext ("bignum truncated to %d byte",
4531 "bignum truncated to %d bytes",
4539 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4542 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4544 if (target_big_endian
)
4546 while (nbytes
> size
)
4548 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4549 nbytes
-= CHARS_PER_LITTLENUM
;
4550 p
+= CHARS_PER_LITTLENUM
;
4553 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4554 while (size
>= CHARS_PER_LITTLENUM
)
4557 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4558 size
-= CHARS_PER_LITTLENUM
;
4559 p
+= CHARS_PER_LITTLENUM
;
4564 nums
= generic_bignum
;
4565 while (size
>= CHARS_PER_LITTLENUM
)
4567 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4569 size
-= CHARS_PER_LITTLENUM
;
4570 p
+= CHARS_PER_LITTLENUM
;
4571 nbytes
-= CHARS_PER_LITTLENUM
;
4574 while (nbytes
>= CHARS_PER_LITTLENUM
)
4576 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4577 nbytes
-= CHARS_PER_LITTLENUM
;
4578 p
+= CHARS_PER_LITTLENUM
;
4583 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4587 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4588 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4591 unsigned int size
= nbytes
;
4593 memset (p
, 0, size
);
4595 /* Generate a fixS to record the symbol value. */
4597 #ifdef TC_CONS_FIX_NEW
4598 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4600 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4602 reloc_howto_type
*reloc_howto
;
4604 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4605 size
= bfd_get_reloc_size (reloc_howto
);
4609 as_bad (ngettext ("%s relocations do not fit in %u byte",
4610 "%s relocations do not fit in %u bytes",
4612 reloc_howto
->name
, nbytes
);
4615 else if (target_big_endian
)
4616 offset
= nbytes
- size
;
4637 as_bad (_("unsupported BFD relocation size %u"), size
);
4640 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4645 /* Handle an MRI style string expression. */
4649 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4651 if (*input_line_pointer
!= '\''
4652 && (input_line_pointer
[1] != '\''
4653 || (*input_line_pointer
!= 'A'
4654 && *input_line_pointer
!= 'E')))
4655 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4659 unsigned int result
= 0;
4661 /* An MRI style string. Cut into as many bytes as will fit into
4662 a nbyte chunk, left justify if necessary, and separate with
4663 commas so we can try again later. */
4664 if (*input_line_pointer
== 'A')
4665 ++input_line_pointer
;
4666 else if (*input_line_pointer
== 'E')
4668 as_bad (_("EBCDIC constants are not supported"));
4669 ++input_line_pointer
;
4672 input_line_pointer
++;
4673 for (scan
= 0; scan
< nbytes
; scan
++)
4675 if (*input_line_pointer
== '\'')
4677 if (input_line_pointer
[1] == '\'')
4679 input_line_pointer
++;
4684 result
= (result
<< 8) | (*input_line_pointer
++);
4688 while (scan
< nbytes
)
4694 /* Create correct expression. */
4695 exp
->X_op
= O_constant
;
4696 exp
->X_add_number
= result
;
4698 /* Fake it so that we can read the next char too. */
4699 if (input_line_pointer
[0] != '\'' ||
4700 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4702 input_line_pointer
-= 2;
4703 input_line_pointer
[0] = ',';
4704 input_line_pointer
[1] = '\'';
4707 input_line_pointer
++;
4710 #endif /* TC_M68K */
4712 #ifdef REPEAT_CONS_EXPRESSIONS
4714 /* Parse a repeat expression for cons. This is used by the MIPS
4715 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4716 object file COUNT times.
4718 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4721 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4728 if (*input_line_pointer
!= ':')
4730 /* No repeat count. */
4734 ++input_line_pointer
;
4735 expression (&count
);
4736 if (count
.X_op
!= O_constant
4737 || count
.X_add_number
<= 0)
4739 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4743 /* The cons function is going to output this expression once. So we
4744 output it count - 1 times. */
4745 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4746 emit_expr (exp
, nbytes
);
4749 #endif /* REPEAT_CONS_EXPRESSIONS */
4751 /* Parse a floating point number represented as a hex constant. This
4752 permits users to specify the exact bits they want in the floating
4756 hex_float (int float_type
, char *bytes
)
4788 as_bad (_("unknown floating type type '%c'"), float_type
);
4792 /* It would be nice if we could go through expression to parse the
4793 hex constant, but if we get a bignum it's a pain to sort it into
4794 the buffer correctly. */
4796 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4800 /* The MRI assembler accepts arbitrary underscores strewn about
4801 through the hex constant, so we ignore them as well. */
4802 if (*input_line_pointer
== '_')
4804 ++input_line_pointer
;
4810 as_warn (_("floating point constant too large"));
4813 d
= hex_value (*input_line_pointer
) << 4;
4814 ++input_line_pointer
;
4815 while (*input_line_pointer
== '_')
4816 ++input_line_pointer
;
4817 if (hex_p (*input_line_pointer
))
4819 d
+= hex_value (*input_line_pointer
);
4820 ++input_line_pointer
;
4822 if (target_big_endian
)
4825 bytes
[length
- i
- 1] = d
;
4831 if (target_big_endian
)
4832 memset (bytes
+ i
, 0, length
- i
);
4834 memset (bytes
, 0, length
- i
);
4842 CONStruct some more frag chars of .floats .ffloats etc.
4843 Makes 0 or more new frags.
4844 If need_pass_2 == 1, no frags are emitted.
4845 This understands only floating literals, not expressions. Sorry.
4847 A floating constant is defined by atof_generic(), except it is preceded
4848 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4849 reading, I decided to be incompatible. This always tries to give you
4850 rounded bits to the precision of the pseudo-op. Former AS did premature
4851 truncation, restored noisy bits instead of trailing 0s AND gave you
4852 a choice of 2 flavours of noise according to which of 2 floating-point
4853 scanners you directed AS to use.
4855 In: input_line_pointer->whitespace before, or '0' of flonum. */
4858 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4859 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4862 int length
; /* Number of chars in an object. */
4863 const char *err
; /* Error from scanning floating literal. */
4864 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4866 if (is_it_end_of_statement ())
4868 demand_empty_rest_of_line ();
4872 if (now_seg
== absolute_section
)
4874 as_bad (_("attempt to store float in absolute section"));
4875 ignore_rest_of_line ();
4881 as_bad (_("attempt to store float in section `%s'"),
4882 segment_name (now_seg
));
4883 ignore_rest_of_line ();
4887 #ifdef md_flush_pending_output
4888 md_flush_pending_output ();
4891 #ifdef md_cons_align
4897 /* input_line_pointer->1st char of a flonum (we hope!). */
4900 /* Skip any 0{letter} that may be present. Don't even check if the
4901 letter is legal. Someone may invent a "z" format and this routine
4902 has no use for such information. Lusers beware: you get
4903 diagnostics if your input is ill-conditioned. */
4904 if (input_line_pointer
[0] == '0'
4905 && ISALPHA (input_line_pointer
[1]))
4906 input_line_pointer
+= 2;
4908 /* Accept :xxxx, where the x's are hex digits, for a floating
4909 point with the exact digits specified. */
4910 if (input_line_pointer
[0] == ':')
4912 ++input_line_pointer
;
4913 length
= hex_float (float_type
, temp
);
4916 ignore_rest_of_line ();
4922 err
= md_atof (float_type
, temp
, &length
);
4923 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4924 know (err
!= NULL
|| length
> 0);
4927 as_bad (_("bad floating literal: %s"), err
);
4928 ignore_rest_of_line ();
4939 #ifdef REPEAT_CONS_EXPRESSIONS
4940 if (*input_line_pointer
== ':')
4942 expressionS count_exp
;
4944 ++input_line_pointer
;
4945 expression (&count_exp
);
4947 if (count_exp
.X_op
!= O_constant
4948 || count_exp
.X_add_number
<= 0)
4949 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4951 count
= count_exp
.X_add_number
;
4955 while (--count
>= 0)
4957 p
= frag_more (length
);
4958 memcpy (p
, temp
, (unsigned int) length
);
4963 while (*input_line_pointer
++ == ',');
4965 /* Put terminator back into stream. */
4966 --input_line_pointer
;
4967 demand_empty_rest_of_line ();
4972 Note - we are using the DWARF standard's definition of LEB128 encoding
4973 where each 7-bit value is a stored in a byte, *not* an octet. This
4974 means that on targets where a byte contains multiple octets there is
4975 a *huge waste of space*. (This also means that we do not have to
4976 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4979 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4980 we would then have to consider whether multiple, successive LEB128
4981 values should be packed into the bytes without padding (bad idea) or
4982 whether each LEB128 number is padded out to a whole number of bytes.
4983 Plus you have to decide on the endianness of packing octets into a
4986 /* Return the size of a LEB128 value in bytes. */
4988 static inline unsigned int
4989 sizeof_sleb128 (offsetT value
)
4996 byte
= (value
& 0x7f);
4997 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4998 Fortunately, we can structure things so that the extra work reduces
4999 to a noop on systems that do things "properly". */
5000 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5003 while (!(((value
== 0) && ((byte
& 0x40) == 0))
5004 || ((value
== -1) && ((byte
& 0x40) != 0))));
5009 static inline unsigned int
5010 sizeof_uleb128 (valueT value
)
5025 sizeof_leb128 (valueT value
, int sign
)
5028 return sizeof_sleb128 ((offsetT
) value
);
5030 return sizeof_uleb128 (value
);
5033 /* Output a LEB128 value. Returns the number of bytes used. */
5035 static inline unsigned int
5036 output_sleb128 (char *p
, offsetT value
)
5043 unsigned byte
= (value
& 0x7f);
5045 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5046 Fortunately, we can structure things so that the extra work reduces
5047 to a noop on systems that do things "properly". */
5048 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5050 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5051 || ((value
== -1) && ((byte
& 0x40) != 0))));
5062 static inline unsigned int
5063 output_uleb128 (char *p
, valueT value
)
5069 unsigned byte
= (value
& 0x7f);
5073 /* More bytes to follow. */
5084 output_leb128 (char *p
, valueT value
, int sign
)
5087 return output_sleb128 (p
, (offsetT
) value
);
5089 return output_uleb128 (p
, value
);
5092 /* Do the same for bignums. We combine sizeof with output here in that
5093 we don't output for NULL values of P. It isn't really as critical as
5094 for "normal" values that this be streamlined. Returns the number of
5097 static inline unsigned int
5098 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5105 /* Strip leading sign extensions off the bignum. */
5107 && bignum
[size
- 1] == LITTLENUM_MASK
5108 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5113 /* OR in the next part of the littlenum. */
5114 val
|= (*bignum
<< loaded
);
5115 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5119 /* Add bytes until there are less than 7 bits left in VAL
5120 or until every non-sign bit has been written. */
5127 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5134 while ((byte
& 0x80) != 0 && loaded
>= 7);
5138 /* Mop up any left-over bits (of which there will be less than 7). */
5139 if ((byte
& 0x80) != 0)
5141 /* Sign-extend VAL. */
5142 if (val
& (1 << (loaded
- 1)))
5143 val
|= ~0U << loaded
;
5152 static inline unsigned int
5153 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5160 /* Strip leading zeros off the bignum. */
5161 /* XXX: Is this needed? */
5162 while (size
> 0 && bignum
[size
- 1] == 0)
5167 if (loaded
< 7 && size
> 0)
5169 val
|= (*bignum
<< loaded
);
5170 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5179 if (size
> 0 || val
)
5186 while (byte
& 0x80);
5192 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5195 return output_big_sleb128 (p
, bignum
, size
);
5197 return output_big_uleb128 (p
, bignum
, size
);
5200 /* Generate the appropriate fragments for a given expression to emit a
5201 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5204 emit_leb128_expr (expressionS
*exp
, int sign
)
5206 operatorT op
= exp
->X_op
;
5207 unsigned int nbytes
;
5209 if (op
== O_absent
|| op
== O_illegal
)
5211 as_warn (_("zero assumed for missing expression"));
5212 exp
->X_add_number
= 0;
5215 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5217 as_bad (_("floating point number invalid"));
5218 exp
->X_add_number
= 0;
5221 else if (op
== O_register
)
5223 as_warn (_("register value used as expression"));
5226 else if (op
== O_constant
5228 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5230 /* We're outputting a signed leb128 and the sign of X_add_number
5231 doesn't reflect the sign of the original value. Convert EXP
5232 to a correctly-extended bignum instead. */
5233 convert_to_bignum (exp
, exp
->X_extrabit
);
5237 if (now_seg
== absolute_section
)
5239 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5240 as_bad (_("attempt to store value in absolute section"));
5241 abs_section_offset
++;
5245 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5246 as_bad (_("attempt to store non-zero value in section `%s'"),
5247 segment_name (now_seg
));
5249 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5250 a signal that this is leb128 data. It shouldn't optimize this away. */
5251 nbytes
= (unsigned int) -1;
5252 if (check_eh_frame (exp
, &nbytes
))
5255 /* Let the backend know that subsequent data may be byte aligned. */
5256 #ifdef md_cons_align
5260 if (op
== O_constant
)
5262 /* If we've got a constant, emit the thing directly right now. */
5264 valueT value
= exp
->X_add_number
;
5268 size
= sizeof_leb128 (value
, sign
);
5269 p
= frag_more (size
);
5270 if (output_leb128 (p
, value
, sign
) > size
)
5273 else if (op
== O_big
)
5275 /* O_big is a different sort of constant. */
5276 int nbr_digits
= exp
->X_add_number
;
5280 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5281 a signed number. Unary operators like - or ~ always extend the
5282 bignum to its largest size. */
5284 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5285 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5286 generic_bignum
[nbr_digits
++] = 0;
5288 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5289 p
= frag_more (size
);
5290 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5295 /* Otherwise, we have to create a variable sized fragment and
5296 resolve things later. */
5298 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5299 make_expr_symbol (exp
), 0, (char *) NULL
);
5303 /* Parse the .sleb128 and .uleb128 pseudos. */
5310 #ifdef md_flush_pending_output
5311 md_flush_pending_output ();
5317 emit_leb128_expr (&exp
, sign
);
5319 while (*input_line_pointer
++ == ',');
5321 input_line_pointer
--;
5322 demand_empty_rest_of_line ();
5326 stringer_append_char (int c
, int bitsize
)
5329 as_bad (_("attempt to store non-empty string in section `%s'"),
5330 segment_name (now_seg
));
5332 if (!target_big_endian
)
5333 FRAG_APPEND_1_CHAR (c
);
5338 FRAG_APPEND_1_CHAR (0);
5339 FRAG_APPEND_1_CHAR (0);
5340 FRAG_APPEND_1_CHAR (0);
5341 FRAG_APPEND_1_CHAR (0);
5344 FRAG_APPEND_1_CHAR (0);
5345 FRAG_APPEND_1_CHAR (0);
5348 FRAG_APPEND_1_CHAR (0);
5353 /* Called with invalid bitsize argument. */
5357 if (target_big_endian
)
5358 FRAG_APPEND_1_CHAR (c
);
5361 /* Worker to do .ascii etc statements.
5362 Reads 0 or more ',' separated, double-quoted strings.
5363 Caller should have checked need_pass_2 is FALSE because we don't
5365 Checks for end-of-line.
5366 BITS_APPENDZERO says how many bits are in a target char.
5367 The bottom bit is set if a NUL char should be appended to the strings. */
5370 stringer (int bits_appendzero
)
5372 const int bitsize
= bits_appendzero
& ~7;
5373 const int append_zero
= bits_appendzero
& 1;
5375 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5379 #ifdef md_flush_pending_output
5380 md_flush_pending_output ();
5383 #ifdef md_cons_align
5387 /* If we have been switched into the abs_section then we
5388 will not have an obstack onto which we can hang strings. */
5389 if (now_seg
== absolute_section
)
5391 as_bad (_("strings must be placed into a section"));
5392 ignore_rest_of_line ();
5396 /* The following awkward logic is to parse ZERO or more strings,
5397 comma separated. Recall a string expression includes spaces
5398 before the opening '\"' and spaces after the closing '\"'.
5399 We fake a leading ',' if there is (supposed to be)
5400 a 1st, expression. We keep demanding expressions for each ','. */
5401 if (is_it_end_of_statement ())
5403 c
= 0; /* Skip loop. */
5404 ++input_line_pointer
; /* Compensate for end of loop. */
5408 c
= ','; /* Do loop. */
5411 while (c
== ',' || c
== '<' || c
== '"')
5414 switch (*input_line_pointer
)
5417 ++input_line_pointer
; /*->1st char of string. */
5418 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5419 start
= input_line_pointer
;
5422 while (is_a_char (c
= next_char_of_string ()))
5423 stringer_append_char (c
, bitsize
);
5426 stringer_append_char (0, bitsize
);
5428 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5429 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5430 will emit .string with a filename in the .debug section
5431 after a sequence of constants. See the comment in
5432 emit_expr for the sequence. emit_expr will set
5433 dwarf_file_string to non-zero if this string might be a
5434 source file name. */
5435 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5436 dwarf_file_string
= 0;
5437 else if (dwarf_file_string
)
5439 c
= input_line_pointer
[-1];
5440 input_line_pointer
[-1] = '\0';
5441 listing_source_file (start
);
5442 input_line_pointer
[-1] = c
;
5448 input_line_pointer
++;
5449 c
= get_single_number ();
5450 stringer_append_char (c
, bitsize
);
5451 if (*input_line_pointer
!= '>')
5453 as_bad (_("expected <nn>"));
5454 ignore_rest_of_line ();
5457 input_line_pointer
++;
5460 input_line_pointer
++;
5464 c
= *input_line_pointer
;
5467 demand_empty_rest_of_line ();
5470 /* FIXME-SOMEDAY: I had trouble here on characters with the
5471 high bits set. We'll probably also have trouble with
5472 multibyte chars, wide chars, etc. Also be careful about
5473 returning values bigger than 1 byte. xoxorich. */
5476 next_char_of_string (void)
5480 c
= *input_line_pointer
++ & CHAR_MASK
;
5484 /* PR 20902: Do not advance past the end of the buffer. */
5485 -- input_line_pointer
;
5494 as_warn (_("unterminated string; newline inserted"));
5495 bump_line_counters ();
5499 if (!TC_STRING_ESCAPES
)
5501 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5529 break; /* As itself. */
5545 for (i
= 0, number
= 0;
5546 ISDIGIT (c
) && i
< 3;
5547 c
= *input_line_pointer
++, i
++)
5549 number
= number
* 8 + c
- '0';
5552 c
= number
& CHAR_MASK
;
5554 --input_line_pointer
;
5563 c
= *input_line_pointer
++;
5564 while (ISXDIGIT (c
))
5567 number
= number
* 16 + c
- '0';
5568 else if (ISUPPER (c
))
5569 number
= number
* 16 + c
- 'A' + 10;
5571 number
= number
* 16 + c
- 'a' + 10;
5572 c
= *input_line_pointer
++;
5574 c
= number
& CHAR_MASK
;
5575 --input_line_pointer
;
5580 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5581 as_warn (_("unterminated string; newline inserted"));
5583 bump_line_counters ();
5587 /* Do not advance past the end of the buffer. */
5588 -- input_line_pointer
;
5594 #ifdef ONLY_STANDARD_ESCAPES
5595 as_bad (_("bad escaped character in string"));
5597 #endif /* ONLY_STANDARD_ESCAPES */
5610 get_segmented_expression (expressionS
*expP
)
5614 retval
= expression (expP
);
5615 if (expP
->X_op
== O_illegal
5616 || expP
->X_op
== O_absent
5617 || expP
->X_op
== O_big
)
5619 as_bad (_("expected address expression"));
5620 expP
->X_op
= O_constant
;
5621 expP
->X_add_number
= 0;
5622 retval
= absolute_section
;
5628 get_known_segmented_expression (expressionS
*expP
)
5630 segT retval
= get_segmented_expression (expP
);
5632 if (retval
== undefined_section
)
5634 /* There is no easy way to extract the undefined symbol from the
5636 if (expP
->X_add_symbol
!= NULL
5637 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5638 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5639 S_GET_NAME (expP
->X_add_symbol
));
5641 as_warn (_("some symbol undefined; zero assumed"));
5642 retval
= absolute_section
;
5643 expP
->X_op
= O_constant
;
5644 expP
->X_add_number
= 0;
5649 char /* Return terminator. */
5650 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5652 /* FIXME: val_pointer should probably be offsetT *. */
5653 *val_pointer
= (long) get_absolute_expression ();
5654 return (*input_line_pointer
++);
5657 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5658 Give a warning if that happens. */
5661 demand_copy_C_string (int *len_pointer
)
5665 if ((s
= demand_copy_string (len_pointer
)) != 0)
5669 for (len
= *len_pointer
; len
> 0; len
--)
5676 as_bad (_("this string may not contain \'\\0\'"));
5684 /* Demand string, but return a safe (=private) copy of the string.
5685 Return NULL if we can't read a string here. */
5688 demand_copy_string (int *lenP
)
5696 if (*input_line_pointer
== '\"')
5698 input_line_pointer
++; /* Skip opening quote. */
5700 while (is_a_char (c
= next_char_of_string ()))
5702 obstack_1grow (¬es
, c
);
5705 /* JF this next line is so demand_copy_C_string will return a
5706 null terminated string. */
5707 obstack_1grow (¬es
, '\0');
5708 retval
= (char *) obstack_finish (¬es
);
5712 as_bad (_("missing string"));
5714 ignore_rest_of_line ();
5720 /* In: Input_line_pointer->next character.
5722 Do: Skip input_line_pointer over all whitespace.
5724 Out: 1 if input_line_pointer->end-of-line. */
5727 is_it_end_of_statement (void)
5730 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5734 equals (char *sym_name
, int reassign
)
5739 input_line_pointer
++;
5740 if (*input_line_pointer
== '=')
5741 input_line_pointer
++;
5742 if (reassign
< 0 && *input_line_pointer
== '=')
5743 input_line_pointer
++;
5745 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5746 input_line_pointer
++;
5749 stop
= mri_comment_field (&stopc
);
5751 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5755 demand_empty_rest_of_line ();
5756 mri_comment_end (stop
, stopc
);
5760 /* .incbin -- include a file verbatim at the current location. */
5763 s_incbin (int x ATTRIBUTE_UNUSED
)
5774 #ifdef md_flush_pending_output
5775 md_flush_pending_output ();
5778 #ifdef md_cons_align
5783 filename
= demand_copy_string (& len
);
5784 if (filename
== NULL
)
5789 /* Look for optional skip and count. */
5790 if (* input_line_pointer
== ',')
5792 ++ input_line_pointer
;
5793 skip
= get_absolute_expression ();
5797 if (* input_line_pointer
== ',')
5799 ++ input_line_pointer
;
5801 count
= get_absolute_expression ();
5803 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5809 demand_empty_rest_of_line ();
5811 /* Try opening absolute path first, then try include dirs. */
5812 binfile
= fopen (filename
, FOPEN_RB
);
5813 if (binfile
== NULL
)
5817 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5819 for (i
= 0; i
< include_dir_count
; i
++)
5821 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5823 binfile
= fopen (path
, FOPEN_RB
);
5824 if (binfile
!= NULL
)
5828 if (binfile
== NULL
)
5829 as_bad (_("file not found: %s"), filename
);
5832 path
= xstrdup (filename
);
5838 register_dependency (path
);
5840 /* Compute the length of the file. */
5841 if (fseek (binfile
, 0, SEEK_END
) != 0)
5843 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5846 file_len
= ftell (binfile
);
5848 /* If a count was not specified use the remainder of the file. */
5850 count
= file_len
- skip
;
5852 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5854 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5855 skip
, count
, file_len
);
5859 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5861 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5865 /* Allocate frag space and store file contents in it. */
5866 binfrag
= frag_more (count
);
5868 bytes
= fread (binfrag
, 1, count
, binfile
);
5870 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5871 path
, bytes
, count
);
5874 if (binfile
!= NULL
)
5879 /* .include -- include a file at this point. */
5882 s_include (int arg ATTRIBUTE_UNUSED
)
5891 filename
= demand_copy_string (&i
);
5892 if (filename
== NULL
)
5894 /* demand_copy_string has already printed an error and
5895 called ignore_rest_of_line. */
5903 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5904 && *input_line_pointer
!= ' '
5905 && *input_line_pointer
!= '\t')
5907 obstack_1grow (¬es
, *input_line_pointer
);
5908 ++input_line_pointer
;
5912 obstack_1grow (¬es
, '\0');
5913 filename
= (char *) obstack_finish (¬es
);
5914 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5915 ++input_line_pointer
;
5918 demand_empty_rest_of_line ();
5919 path
= XNEWVEC (char, (unsigned long) i
5920 + include_dir_maxlen
+ 5 /* slop */ );
5922 for (i
= 0; i
< include_dir_count
; i
++)
5924 strcpy (path
, include_dirs
[i
]);
5926 strcat (path
, filename
);
5927 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5937 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5938 register_dependency (path
);
5939 input_scrub_insert_file (path
);
5943 add_include_dir (char *path
)
5947 if (include_dir_count
== 0)
5949 include_dirs
= XNEWVEC (const char *, 2);
5950 include_dirs
[0] = "."; /* Current dir. */
5951 include_dir_count
= 2;
5955 include_dir_count
++;
5956 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5960 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5963 if (i
> include_dir_maxlen
)
5964 include_dir_maxlen
= i
;
5967 /* Output debugging information to denote the source file. */
5970 generate_file_debug (void)
5972 if (debug_type
== DEBUG_STABS
)
5973 stabs_generate_asm_file ();
5976 /* Output line number debugging information for the current source line. */
5979 generate_lineno_debug (void)
5983 case DEBUG_UNSPECIFIED
:
5988 stabs_generate_asm_lineno ();
5991 ecoff_generate_asm_lineno ();
5994 /* ??? We could here indicate to dwarf2dbg.c that something
5995 has changed. However, since there is additional backend
5996 support that is required (calling dwarf2_emit_insn), we
5997 let dwarf2dbg.c call as_where on its own. */
6002 /* Output debugging information to mark a function entry point or end point.
6003 END_P is zero for .func, and non-zero for .endfunc. */
6008 do_s_func (end_p
, NULL
);
6011 /* Subroutine of s_func so targets can choose a different default prefix.
6012 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
6015 do_s_func (int end_p
, const char *default_prefix
)
6017 /* Record the current function so that we can issue an error message for
6018 misplaced .func,.endfunc, and also so that .endfunc needs no
6020 static char *current_name
;
6021 static char *current_label
;
6025 if (current_name
== NULL
)
6027 as_bad (_("missing .func"));
6028 ignore_rest_of_line ();
6032 if (debug_type
== DEBUG_STABS
)
6033 stabs_generate_asm_endfunc (current_name
, current_label
);
6035 current_name
= current_label
= NULL
;
6040 char delim1
, delim2
;
6042 if (current_name
!= NULL
)
6044 as_bad (_(".endfunc missing for previous .func"));
6045 ignore_rest_of_line ();
6049 delim1
= get_symbol_name (& name
);
6050 name
= xstrdup (name
);
6051 *input_line_pointer
= delim1
;
6052 SKIP_WHITESPACE_AFTER_NAME ();
6053 if (*input_line_pointer
!= ',')
6057 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6058 as_fatal ("%s", xstrerror (errno
));
6062 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6063 /* Missing entry point, use function's name with the leading
6067 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6068 as_fatal ("%s", xstrerror (errno
));
6076 ++input_line_pointer
;
6078 delim2
= get_symbol_name (& label
);
6079 label
= xstrdup (label
);
6080 restore_line_pointer (delim2
);
6083 if (debug_type
== DEBUG_STABS
)
6084 stabs_generate_asm_func (name
, label
);
6086 current_name
= name
;
6087 current_label
= label
;
6090 demand_empty_rest_of_line ();
6093 #ifdef HANDLE_BUNDLE
6096 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6098 unsigned int align
= get_absolute_expression ();
6100 demand_empty_rest_of_line ();
6102 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6103 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6104 (unsigned int) TC_ALIGN_LIMIT
);
6106 if (bundle_lock_frag
!= NULL
)
6108 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6112 bundle_align_p2
= align
;
6116 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6118 demand_empty_rest_of_line ();
6120 if (bundle_align_p2
== 0)
6122 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6126 if (bundle_lock_depth
== 0)
6128 bundle_lock_frchain
= frchain_now
;
6129 bundle_lock_frag
= start_bundle ();
6131 ++bundle_lock_depth
;
6135 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6139 demand_empty_rest_of_line ();
6141 if (bundle_lock_frag
== NULL
)
6143 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6147 gas_assert (bundle_align_p2
> 0);
6149 gas_assert (bundle_lock_depth
> 0);
6150 if (--bundle_lock_depth
> 0)
6153 size
= pending_bundle_size (bundle_lock_frag
);
6155 if (size
> 1U << bundle_align_p2
)
6156 as_bad (_(".bundle_lock sequence is %u bytes, "
6157 "but bundle size is only %u bytes"),
6158 size
, 1u << bundle_align_p2
);
6160 finish_bundle (bundle_lock_frag
, size
);
6162 bundle_lock_frag
= NULL
;
6163 bundle_lock_frchain
= NULL
;
6166 #endif /* HANDLE_BUNDLE */
6169 s_ignore (int arg ATTRIBUTE_UNUSED
)
6171 ignore_rest_of_line ();
6175 read_print_statistics (FILE *file
)
6177 htab_print_statistics (file
, "pseudo-op table", po_hash
);
6180 /* Inserts the given line into the input stream.
6182 This call avoids macro/conditionals nesting checking, since the contents of
6183 the line are assumed to replace the contents of a line already scanned.
6185 An appropriate use of this function would be substitution of input lines when
6186 called by md_start_line_hook(). The given line is assumed to already be
6187 properly scrubbed. */
6190 input_scrub_insert_line (const char *line
)
6193 size_t len
= strlen (line
);
6194 sb_build (&newline
, len
);
6195 sb_add_buffer (&newline
, line
, len
);
6196 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6198 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6201 /* Insert a file into the input stream; the path must resolve to an actual
6202 file; no include path searching or dependency registering is performed. */
6205 input_scrub_insert_file (char *path
)
6207 input_scrub_include_file (path
, input_line_pointer
);
6208 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6211 /* Find the end of a line, considering quotation and escaping of quotes. */
6213 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6214 # define TC_SINGLE_QUOTE_STRINGS 1
6218 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6221 char inquote
= '\0';
6224 while (!is_end_of_line
[(unsigned char) *s
]
6225 || (inquote
&& !ISCNTRL (*s
))
6226 || (inquote
== '\'' && flag_mri
)
6227 #ifdef TC_EOL_IN_INSN
6228 || (insn
&& TC_EOL_IN_INSN (s
))
6230 /* PR 6926: When we are parsing the body of a macro the sequence
6231 \@ is special - it refers to the invocation count. If the @
6232 character happens to be registered as a line-separator character
6233 by the target, then the is_end_of_line[] test above will have
6234 returned true, but we need to ignore the line separating
6235 semantics in this particular case. */
6236 || (in_macro
&& inescape
&& *s
== '@')
6239 if (mri_string
&& *s
== '\'')
6243 else if (*s
== '\\')
6247 #ifdef TC_SINGLE_QUOTE_STRINGS
6248 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6255 as_warn (_("missing closing `%c'"), inquote
);
6256 if (inescape
&& !ignore_input ())
6257 as_warn (_("stray `\\'"));
6262 find_end_of_line (char *s
, int mri_string
)
6264 return _find_end_of_line (s
, mri_string
, 0, 0);
6267 static char *saved_ilp
= NULL
;
6268 static char *saved_limit
;
6270 /* Use BUF as a temporary input pointer for calling other functions in this
6271 file. BUF must be a C string, so that its end can be found by strlen.
6272 Also sets the buffer_limit variable (local to this file) so that buffer
6273 overruns should not occur. Saves the current input line pointer so that
6274 it can be restored by calling restore_ilp().
6276 Does not support recursion. */
6279 temp_ilp (char *buf
)
6281 gas_assert (saved_ilp
== NULL
);
6282 gas_assert (buf
!= NULL
);
6284 saved_ilp
= input_line_pointer
;
6285 saved_limit
= buffer_limit
;
6286 /* Prevent the assert in restore_ilp from triggering if
6287 the input_line_pointer has not yet been initialised. */
6288 if (saved_ilp
== NULL
)
6289 saved_limit
= saved_ilp
= (char *) "";
6291 input_line_pointer
= buf
;
6292 buffer_limit
= buf
+ strlen (buf
);
6293 input_from_string
= TRUE
;
6296 /* Restore a saved input line pointer. */
6301 gas_assert (saved_ilp
!= NULL
);
6303 input_line_pointer
= saved_ilp
;
6304 buffer_limit
= saved_limit
;
6305 input_from_string
= FALSE
;