1 /* read.c - read a source file -
2 Copyright (C) 1986-2014 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 spozed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
43 #ifndef TC_START_LABEL
44 #define TC_START_LABEL(x,y,z) (x == ':')
47 /* Set by the object-format or the target. */
48 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
49 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
54 else if ((SIZE) >= 4) \
56 else if ((SIZE) >= 2) \
64 char *input_line_pointer
; /*->next char of source file to parse. */
66 #if BITS_PER_CHAR != 8
67 /* The following table is indexed by[(char)] and will break if
68 a char does not have exactly 256 states (hopefully 0:255!)! */
77 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
82 /* The Delta 68k assembler permits % inside label names. */
87 /* The PowerPC Windows NT assemblers permits ? inside label names. */
92 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
93 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
102 /* The Delta 68k assembler permits ~ at start of label names. */
106 /* Used by is_... macros. our ctype[]. */
107 char lex_type
[256] = {
108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
110 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
112 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
113 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
114 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
115 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
127 Out: 1 if this character ends a line.
128 2 if this character is a line separator. */
129 char is_end_of_line
[256] = {
131 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
133 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
135 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
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, /* */
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 /* */
152 #ifndef TC_CASE_SENSITIVE
153 char original_case_string
[128];
156 /* Functions private to this file. */
158 static char *buffer
; /* 1st char of each buffer of lines is here. */
159 static char *buffer_limit
; /*->1 + last char in buffer. */
161 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
162 in the tc-<CPU>.h file. See the "Porting GAS" section of the
164 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
166 /* Variables for handling include file directory table. */
168 /* Table of pointers to directories to search for .include's. */
171 /* How many are in the table. */
172 int include_dir_count
;
174 /* Length of longest in table. */
175 int include_dir_maxlen
= 1;
177 #ifndef WORKING_DOT_WORD
178 struct broken_word
*broken_words
;
179 int new_broken_words
;
182 /* The current offset into the absolute section. We don't try to
183 build frags in the absolute section, since no data can be stored
184 there. We just keep track of the current offset. */
185 addressT abs_section_offset
;
187 /* If this line had an MRI style label, it is stored in this variable.
188 This is used by some of the MRI pseudo-ops. */
191 /* This global variable is used to support MRI common sections. We
192 translate such sections into a common symbol. This variable is
193 non-NULL when we are in an MRI common section. */
194 symbolS
*mri_common_symbol
;
196 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
197 need to align to an even byte boundary unless the next pseudo-op is
198 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
200 static int mri_pending_align
;
204 /* This variable is set to be non-zero if the next string we see might
205 be the name of the source file in DWARF debugging information. See
206 the comment in emit_expr for the format we look for. */
207 static int dwarf_file_string
;
211 /* If the target defines the md_frag_max_var hook then we know
212 enough to implement the .bundle_align_mode features. */
213 #ifdef md_frag_max_var
214 # define HANDLE_BUNDLE
218 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
219 it's the exponent of the bundle size, and aligned instruction bundle
220 mode is in effect. */
221 static unsigned int bundle_align_p2
;
223 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
224 bundle_lock_frag to frag_now and then starts a new frag with
225 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
226 so that .bundle_unlock can verify that we didn't change segments.
227 .bundle_unlock resets both to NULL. If we detect a bundling violation,
228 then we reset bundle_lock_frchain to NULL as an indicator that we've
229 already diagnosed the error with as_bad and don't need a cascade of
230 redundant errors, but bundle_lock_frag remains set to indicate that
231 we are expecting to see .bundle_unlock. */
232 static fragS
*bundle_lock_frag
;
233 static frchainS
*bundle_lock_frchain
;
235 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
237 static unsigned int bundle_lock_depth
;
240 static void do_s_func (int end_p
, const char *default_prefix
);
241 static void do_align (int, char *, int, int);
242 static void s_align (int, int);
243 static void s_altmacro (int);
244 static void s_bad_end (int);
245 static void s_reloc (int);
246 static int hex_float (int, char *);
247 static segT
get_known_segmented_expression (expressionS
* expP
);
248 static void pobegin (void);
249 static size_t get_non_macro_line_sb (sb
*);
250 static void generate_file_debug (void);
251 static char *_find_end_of_line (char *, int, int, int);
259 obj_read_begin_hook ();
261 /* Something close -- but not too close -- to a multiple of 1024.
262 The debugging malloc I'm using has 24 bytes of overhead. */
263 obstack_begin (¬es
, chunksize
);
264 obstack_begin (&cond_obstack
, chunksize
);
266 #ifndef tc_line_separator_chars
267 #define tc_line_separator_chars line_separator_chars
269 /* Use machine dependent syntax. */
270 for (p
= tc_line_separator_chars
; *p
; p
++)
271 is_end_of_line
[(unsigned char) *p
] = 2;
272 /* Use more. FIXME-SOMEDAY. */
278 #ifndef TC_ADDRESS_BYTES
279 #define TC_ADDRESS_BYTES address_bytes
284 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
285 contain an address. */
286 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
294 /* Set up pseudo-op tables. */
296 static struct hash_control
*po_hash
;
298 static const pseudo_typeS potable
[] = {
299 {"abort", s_abort
, 0},
300 {"align", s_align_ptwo
, 0},
301 {"altmacro", s_altmacro
, 1},
302 {"ascii", stringer
, 8+0},
303 {"asciz", stringer
, 8+1},
304 {"balign", s_align_bytes
, 0},
305 {"balignw", s_align_bytes
, -2},
306 {"balignl", s_align_bytes
, -4},
309 {"bundle_align_mode", s_bundle_align_mode
, 0},
310 {"bundle_lock", s_bundle_lock
, 0},
311 {"bundle_unlock", s_bundle_unlock
, 0},
315 {"common", s_mri_common
, 0},
316 {"common.s", s_mri_common
, 1},
319 #ifdef TC_ADDRESS_BYTES
323 {"dc.d", float_cons
, 'd'},
325 {"dc.s", float_cons
, 'f'},
327 {"dc.x", float_cons
, 'x'},
329 {"dcb.b", s_space
, 1},
330 {"dcb.d", s_float_space
, 'd'},
331 {"dcb.l", s_space
, 4},
332 {"dcb.s", s_float_space
, 'f'},
333 {"dcb.w", s_space
, 2},
334 {"dcb.x", s_float_space
, 'x'},
336 {"ds.b", s_space
, 1},
337 {"ds.d", s_space
, 8},
338 {"ds.l", s_space
, 4},
339 {"ds.p", s_space
, 12},
340 {"ds.s", s_space
, 4},
341 {"ds.w", s_space
, 2},
342 {"ds.x", s_space
, 12},
343 {"debug", s_ignore
, 0},
348 {"double", float_cons
, 'd'},
350 {"eject", listing_eject
, 0}, /* Formfeed listing. */
352 {"elsec", s_else
, 0},
353 {"elseif", s_elseif
, (int) O_ne
},
355 {"endc", s_endif
, 0},
356 {"endfunc", s_func
, 1},
357 {"endif", s_endif
, 0},
358 {"endm", s_bad_end
, 0},
359 {"endr", s_bad_end
, 1},
365 {"error", s_errwarn
, 1},
366 {"exitm", s_mexit
, 0},
368 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
369 {"appfile", s_app_file
, 1},
370 {"appline", s_app_line
, 1},
372 {"file", s_app_file
, 0},
374 {"float", float_cons
, 'f'},
375 {"format", s_ignore
, 0},
377 {"global", s_globl
, 0},
378 {"globl", s_globl
, 0},
380 {"if", s_if
, (int) O_ne
},
383 {"ifdef", s_ifdef
, 0},
384 {"ifeq", s_if
, (int) O_eq
},
385 {"ifeqs", s_ifeqs
, 0},
386 {"ifge", s_if
, (int) O_ge
},
387 {"ifgt", s_if
, (int) O_gt
},
388 {"ifle", s_if
, (int) O_le
},
389 {"iflt", s_if
, (int) O_lt
},
392 {"ifndef", s_ifdef
, 1},
393 {"ifne", s_if
, (int) O_ne
},
394 {"ifnes", s_ifeqs
, 1},
395 {"ifnotdef", s_ifdef
, 1},
396 {"incbin", s_incbin
, 0},
397 {"include", s_include
, 0},
403 {"lcomm", s_lcomm
, 0},
404 {"lflags", s_ignore
, 0}, /* Listing flags. */
405 {"linefile", s_app_line
, 0},
406 {"linkonce", s_linkonce
, 0},
407 {"list", listing_list
, 1}, /* Turn listing on. */
408 {"llen", listing_psize
, 1},
411 {"macro", s_macro
, 0},
412 {"mexit", s_mexit
, 0},
414 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
415 {"name", s_ignore
, 0},
416 {"noaltmacro", s_altmacro
, 0},
417 {"noformat", s_ignore
, 0},
418 {"nolist", listing_list
, 0}, /* Turn listing off. */
419 {"nopage", listing_nopage
, 0},
421 {"offset", s_struct
, 0},
423 {"p2align", s_align_ptwo
, 0},
424 {"p2alignw", s_align_ptwo
, -2},
425 {"p2alignl", s_align_ptwo
, -4},
426 {"page", listing_eject
, 0},
427 {"plen", listing_psize
, 0},
428 {"print", s_print
, 0},
429 {"psize", listing_psize
, 0}, /* Set paper size. */
430 {"purgem", s_purgem
, 0},
432 {"reloc", s_reloc
, 0},
436 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
441 {"single", float_cons
, 'f'},
443 {"space", s_space
, 0},
444 {"skip", s_space
, 0},
445 {"sleb128", s_leb128
, 1},
446 {"spc", s_ignore
, 0},
447 {"stabd", s_stab
, 'd'},
448 {"stabn", s_stab
, 'n'},
449 {"stabs", s_stab
, 's'},
450 {"string", stringer
, 8+1},
451 {"string8", stringer
, 8+1},
452 {"string16", stringer
, 16+1},
453 {"string32", stringer
, 32+1},
454 {"string64", stringer
, 64+1},
455 {"struct", s_struct
, 0},
459 /* This is for gcc to use. It's only just been added (2/94), so gcc
460 won't be able to use it for a while -- probably a year or more.
461 But once this has been released, check with gcc maintainers
462 before deleting it or even changing the spelling. */
463 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
464 /* If we're folding case -- done for some targets, not necessarily
465 all -- the above string in an input file will be converted to
466 this one. Match it either way... */
467 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
469 {"title", listing_title
, 0}, /* Listing title. */
470 {"ttl", listing_title
, 0},
472 {"uleb128", s_leb128
, 0},
476 {"xdef", s_globl
, 0},
477 {"xref", s_ignore
, 0},
478 {"xstabs", s_xstab
, 's'},
479 {"warning", s_errwarn
, 0},
480 {"weakref", s_weakref
, 0},
482 {"zero", s_space
, 0},
483 {NULL
, NULL
, 0} /* End sentinel. */
487 get_absolute_expr (expressionS
*exp
)
489 expression_and_evaluate (exp
);
490 if (exp
->X_op
!= O_constant
)
492 if (exp
->X_op
!= O_absent
)
493 as_bad (_("bad or irreducible absolute expression"));
494 exp
->X_add_number
= 0;
496 return exp
->X_add_number
;
500 get_absolute_expression (void)
504 return get_absolute_expr (&exp
);
507 static int pop_override_ok
= 0;
508 static const char *pop_table_name
;
511 pop_insert (const pseudo_typeS
*table
)
514 const pseudo_typeS
*pop
;
515 for (pop
= table
; pop
->poc_name
; pop
++)
517 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
518 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
519 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
524 #ifndef md_pop_insert
525 #define md_pop_insert() pop_insert(md_pseudo_table)
528 #ifndef obj_pop_insert
529 #define obj_pop_insert() pop_insert(obj_pseudo_table)
532 #ifndef cfi_pop_insert
533 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
539 po_hash
= hash_new ();
541 /* Do the target-specific pseudo ops. */
542 pop_table_name
= "md";
545 /* Now object specific. Skip any that were in the target table. */
546 pop_table_name
= "obj";
550 /* Now portable ones. Skip any that we've seen already. */
551 pop_table_name
= "standard";
552 pop_insert (potable
);
555 pop_table_name
= "cfi";
560 #define HANDLE_CONDITIONAL_ASSEMBLY() \
561 if (ignore_input ()) \
563 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
564 input_line_pointer = (input_line_pointer <= buffer_limit \
565 && eol >= buffer_limit) \
571 /* This function is used when scrubbing the characters between #APP
574 static char *scrub_string
;
575 static char *scrub_string_end
;
578 scrub_from_string (char *buf
, size_t buflen
)
582 copy
= scrub_string_end
- scrub_string
;
585 memcpy (buf
, scrub_string
, copy
);
586 scrub_string
+= copy
;
590 /* Helper function of read_a_source_file, which tries to expand a macro. */
592 try_macro (char term
, const char *line
)
598 if (check_macro (line
, &out
, &err
, ¯o
))
602 *input_line_pointer
++ = term
;
603 input_scrub_include_sb (&out
,
604 input_line_pointer
, 1);
607 input_scrub_next_buffer (&input_line_pointer
);
609 md_macro_info (macro
);
617 /* Start a new instruction bundle. Returns the rs_align_code frag that
618 will be used to align the new bundle. */
622 fragS
*frag
= frag_now
;
624 frag_align_code (0, 0);
626 while (frag
->fr_type
!= rs_align_code
)
627 frag
= frag
->fr_next
;
629 gas_assert (frag
!= frag_now
);
634 /* Calculate the maximum size after relaxation of the region starting
635 at the given frag and extending through frag_now (which is unfinished). */
637 pending_bundle_size (fragS
*frag
)
639 unsigned int offset
= frag
->fr_fix
;
640 unsigned int size
= 0;
642 gas_assert (frag
!= frag_now
);
643 gas_assert (frag
->fr_type
== rs_align_code
);
645 while (frag
!= frag_now
)
647 /* This should only happen in what will later become an error case. */
651 size
+= frag
->fr_fix
;
652 if (frag
->fr_type
== rs_machine_dependent
)
653 size
+= md_frag_max_var (frag
);
655 frag
= frag
->fr_next
;
658 gas_assert (frag
== frag_now
);
659 size
+= frag_now_fix ();
660 if (frag
->fr_type
== rs_machine_dependent
)
661 size
+= md_frag_max_var (frag
);
663 gas_assert (size
>= offset
);
665 return size
- offset
;
668 /* Finish off the frag created to ensure bundle alignment. */
670 finish_bundle (fragS
*frag
, unsigned int size
)
672 gas_assert (bundle_align_p2
> 0);
673 gas_assert (frag
->fr_type
== rs_align_code
);
677 /* If there is more than a single byte, then we need to set up the
678 alignment frag. Otherwise we leave it at its initial state from
679 calling frag_align_code (0, 0), so that it does nothing. */
680 frag
->fr_offset
= bundle_align_p2
;
681 frag
->fr_subtype
= size
- 1;
684 /* We do this every time rather than just in s_bundle_align_mode
685 so that we catch any affected section without needing hooks all
686 over for all paths that do section changes. It's cheap enough. */
687 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
690 /* Assemble one instruction. This takes care of the bundle features
691 around calling md_assemble. */
693 assemble_one (char *line
)
695 fragS
*insn_start_frag
= NULL
;
697 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
699 as_bad (_("cannot change section or subsection inside .bundle_lock"));
700 /* Clearing this serves as a marker that we have already complained. */
701 bundle_lock_frchain
= NULL
;
704 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
705 insn_start_frag
= start_bundle ();
709 if (bundle_lock_frchain
!= NULL
)
711 /* Make sure this hasn't pushed the locked sequence
712 past the bundle size. */
713 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
714 if (bundle_size
> (1U << bundle_align_p2
))
716 .bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"),
717 bundle_size
, 1U << bundle_align_p2
);
719 else if (bundle_align_p2
> 0)
721 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
723 if (insn_size
> (1U << bundle_align_p2
))
725 single instruction is %u bytes long but .bundle_align_mode limit is %u"),
726 (unsigned int) insn_size
, 1U << bundle_align_p2
);
728 finish_bundle (insn_start_frag
, insn_size
);
732 #else /* !HANDLE_BUNDLE */
734 # define assemble_one(line) md_assemble(line)
736 #endif /* HANDLE_BUNDLE */
738 /* We read the file, putting things into a web that represents what we
739 have been reading. */
741 read_a_source_file (char *name
)
744 char *s
; /* String of symbol, '\0' appended. */
752 buffer
= input_scrub_new_file (name
);
755 listing_newline (NULL
);
756 register_dependency (name
);
758 /* Generate debugging information before we've read anything in to denote
759 this file as the "main" source file and not a subordinate one
760 (e.g. N_SO vs N_SOL in stabs). */
761 generate_file_debug ();
763 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
764 { /* We have another line to parse. */
766 /* In order to avoid listing macro expansion lines with labels
767 multiple times, keep track of which line was last issued. */
768 static char *last_eol
;
772 while (input_line_pointer
< buffer_limit
)
774 bfd_boolean was_new_line
;
775 /* We have more of this buffer to parse. */
777 /* We now have input_line_pointer->1st char of next line.
778 If input_line_pointer [-1] == '\n' then we just
779 scanned another line: so bump line counters. */
780 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
783 symbol_set_value_now (&dot_symbol
);
784 #ifdef md_start_line_hook
785 md_start_line_hook ();
787 if (input_line_pointer
[-1] == '\n')
788 bump_line_counters ();
792 /* If listing is on, and we are expanding a macro, then give
793 the listing code the contents of the expanded line. */
796 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
798 /* Find the end of the current expanded macro line. */
799 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
807 /* Copy it for safe keeping. Also give an indication of
808 how much macro nesting is involved at this point. */
809 len
= s
- input_line_pointer
;
810 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
811 memset (copy
, '>', macro_nest
);
812 copy
[macro_nest
] = ' ';
813 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
814 copy
[macro_nest
+ 1 + len
] = '\0';
816 /* Install the line with the listing facility. */
817 listing_newline (copy
);
821 listing_newline (NULL
);
828 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
830 /* Text at the start of a line must be a label, we
831 run down and stick a colon in. */
832 if (is_name_beginner (*input_line_pointer
))
834 char *line_start
= input_line_pointer
;
837 HANDLE_CONDITIONAL_ASSEMBLY ();
839 c
= get_symbol_end ();
841 /* In MRI mode, the EQU and MACRO pseudoops must
842 be handled specially. */
846 char *rest
= input_line_pointer
+ 1;
850 if (*rest
== ' ' || *rest
== '\t')
852 if ((strncasecmp (rest
, "EQU", 3) == 0
853 || strncasecmp (rest
, "SET", 3) == 0)
854 && (rest
[3] == ' ' || rest
[3] == '\t'))
856 input_line_pointer
= rest
+ 3;
858 strncasecmp (rest
, "SET", 3) == 0);
861 if (strncasecmp (rest
, "MACRO", 5) == 0
864 || is_end_of_line
[(unsigned char) rest
[5]]))
868 /* In MRI mode, we need to handle the MACRO
869 pseudo-op specially: we don't want to put the
870 symbol in the symbol table. */
872 #ifdef TC_START_LABEL_WITHOUT_COLON
873 && TC_START_LABEL_WITHOUT_COLON(c
,
877 line_label
= colon (line_start
);
879 line_label
= symbol_create (line_start
,
884 *input_line_pointer
= c
;
886 input_line_pointer
++;
891 /* We are at the beginning of a line, or similar place.
892 We expect a well-formed assembler statement.
893 A "symbol-name:" is a statement.
895 Depending on what compiler is used, the order of these tests
896 may vary to catch most common case 1st.
897 Each test is independent of all other tests at the (top)
900 c
= *input_line_pointer
++;
901 while (c
== '\t' || c
== ' ' || c
== '\f');
903 /* C is the 1st significant character.
904 Input_line_pointer points after that character. */
905 if (is_name_beginner (c
))
907 /* Want user-defined label or pseudo/opcode. */
908 HANDLE_CONDITIONAL_ASSEMBLY ();
910 s
= --input_line_pointer
;
911 c
= get_symbol_end (); /* name's delimiter. */
913 /* C is character after symbol.
914 That character's place in the input line is now '\0'.
915 S points to the beginning of the symbol.
916 [In case of pseudo-op, s->'.'.]
917 Input_line_pointer->'\0' where c was. */
918 if (TC_START_LABEL (c
, s
, input_line_pointer
))
922 char *rest
= input_line_pointer
+ 1;
924 /* In MRI mode, \tsym: set 0 is permitted. */
928 if (*rest
== ' ' || *rest
== '\t')
931 if ((strncasecmp (rest
, "EQU", 3) == 0
932 || strncasecmp (rest
, "SET", 3) == 0)
933 && (rest
[3] == ' ' || rest
[3] == '\t'))
935 input_line_pointer
= rest
+ 3;
941 line_label
= colon (s
); /* User-defined label. */
942 /* Put ':' back for error messages' sake. */
943 *input_line_pointer
++ = ':';
944 #ifdef tc_check_label
945 tc_check_label (line_label
);
947 /* Input_line_pointer->after ':'. */
950 else if ((c
== '=' && input_line_pointer
[1] == '=')
951 || ((c
== ' ' || c
== '\t')
952 && input_line_pointer
[1] == '='
953 && input_line_pointer
[2] == '='))
956 demand_empty_rest_of_line ();
959 || ((c
== ' ' || c
== '\t')
960 && input_line_pointer
[1] == '='))
961 #ifdef TC_EQUAL_IN_INSN
962 && !TC_EQUAL_IN_INSN (c
, s
)
967 demand_empty_rest_of_line ();
971 /* Expect pseudo-op or machine instruction. */
974 #ifndef TC_CASE_SENSITIVE
978 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
979 original_case_string
[sizeof (original_case_string
) - 1] = 0;
988 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
990 /* The MRI assembler uses pseudo-ops without
992 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
993 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
998 || (!flag_m68k_mri
&& *s
== '.'))
1002 WARNING: c has next char, which may be end-of-line.
1003 We lookup the pseudo-op table with s+1 because we
1004 already know that the pseudo-op begins with a '.'. */
1007 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1008 if (pop
&& !pop
->poc_handler
)
1011 /* In MRI mode, we may need to insert an
1012 automatic alignment directive. What a hack
1014 if (mri_pending_align
1016 || !((pop
->poc_handler
== cons
1017 && pop
->poc_val
== 1)
1018 || (pop
->poc_handler
== s_space
1019 && pop
->poc_val
== 1)
1020 #ifdef tc_conditional_pseudoop
1021 || tc_conditional_pseudoop (pop
)
1023 || pop
->poc_handler
== s_if
1024 || pop
->poc_handler
== s_ifdef
1025 || pop
->poc_handler
== s_ifc
1026 || pop
->poc_handler
== s_ifeqs
1027 || pop
->poc_handler
== s_else
1028 || pop
->poc_handler
== s_endif
1029 || pop
->poc_handler
== s_globl
1030 || pop
->poc_handler
== s_ignore
)))
1032 do_align (1, (char *) NULL
, 0, 0);
1033 mri_pending_align
= 0;
1035 if (line_label
!= NULL
)
1037 symbol_set_frag (line_label
, frag_now
);
1038 S_SET_VALUE (line_label
, frag_now_fix ());
1042 /* Print the error msg now, while we still can. */
1045 char *end
= input_line_pointer
;
1047 *input_line_pointer
= c
;
1049 c
= *--input_line_pointer
;
1050 *input_line_pointer
= '\0';
1051 if (! macro_defined
|| ! try_macro (c
, s
))
1054 as_bad (_("unknown pseudo-op: `%s'"), s
);
1055 *input_line_pointer
++ = c
;
1060 /* Put it back for error messages etc. */
1061 *input_line_pointer
= c
;
1062 /* The following skip of whitespace is compulsory.
1063 A well shaped space is sometimes all that separates
1064 keyword from operands. */
1065 if (c
== ' ' || c
== '\t')
1066 input_line_pointer
++;
1068 /* Input_line is restored.
1069 Input_line_pointer->1st non-blank char
1070 after pseudo-operation. */
1071 (*pop
->poc_handler
) (pop
->poc_val
);
1073 /* If that was .end, just get out now. */
1074 if (pop
->poc_handler
== s_end
)
1079 /* WARNING: c has char, which may be end-of-line. */
1080 /* Also: input_line_pointer->`\0` where c was. */
1081 *input_line_pointer
= c
;
1082 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1083 c
= *input_line_pointer
;
1084 *input_line_pointer
= '\0';
1086 generate_lineno_debug ();
1088 if (macro_defined
&& try_macro (c
, s
))
1091 if (mri_pending_align
)
1093 do_align (1, (char *) NULL
, 0, 0);
1094 mri_pending_align
= 0;
1095 if (line_label
!= NULL
)
1097 symbol_set_frag (line_label
, frag_now
);
1098 S_SET_VALUE (line_label
, frag_now_fix ());
1102 assemble_one (s
); /* Assemble 1 instruction. */
1104 *input_line_pointer
++ = c
;
1106 /* We resume loop AFTER the end-of-line from
1107 this instruction. */
1113 /* Empty statement? */
1114 if (is_end_of_line
[(unsigned char) c
])
1117 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (c
))
1119 /* local label ("4:") */
1120 char *backup
= input_line_pointer
;
1122 HANDLE_CONDITIONAL_ASSEMBLY ();
1126 /* Read the whole number. */
1127 while (ISDIGIT (*input_line_pointer
))
1129 temp
= (temp
* 10) + *input_line_pointer
- '0';
1130 ++input_line_pointer
;
1133 if (LOCAL_LABELS_DOLLAR
1134 && *input_line_pointer
== '$'
1135 && *(input_line_pointer
+ 1) == ':')
1137 input_line_pointer
+= 2;
1139 if (dollar_label_defined (temp
))
1141 as_fatal (_("label \"%d$\" redefined"), temp
);
1144 define_dollar_label (temp
);
1145 colon (dollar_label_name (temp
, 0));
1150 && *input_line_pointer
++ == ':')
1152 fb_label_instance_inc (temp
);
1153 colon (fb_label_name (temp
, 0));
1157 input_line_pointer
= backup
;
1158 } /* local label ("4:") */
1160 if (c
&& strchr (line_comment_chars
, c
))
1161 { /* Its a comment. Better say APP or NO_APP. */
1166 unsigned int new_length
;
1169 s
= input_line_pointer
;
1170 if (strncmp (s
, "APP\n", 4))
1173 ignore_rest_of_line ();
1176 bump_line_counters ();
1179 ends
= strstr (s
, "#NO_APP\n");
1183 unsigned int tmp_len
;
1186 /* The end of the #APP wasn't in this buffer. We
1187 keep reading in buffers until we find the #NO_APP
1188 that goes with this #APP There is one. The specs
1190 tmp_len
= buffer_limit
- s
;
1191 tmp_buf
= (char *) xmalloc (tmp_len
+ 1);
1192 memcpy (tmp_buf
, s
, tmp_len
);
1195 new_tmp
= input_scrub_next_buffer (&buffer
);
1199 buffer_limit
= new_tmp
;
1200 input_line_pointer
= buffer
;
1201 ends
= strstr (buffer
, "#NO_APP\n");
1203 num
= ends
- buffer
;
1205 num
= buffer_limit
- buffer
;
1207 tmp_buf
= (char *) xrealloc (tmp_buf
, tmp_len
+ num
);
1208 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1213 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1221 input_line_pointer
= ends
+ 8;
1225 scrub_string_end
= ends
;
1227 new_length
= ends
- s
;
1228 new_buf
= (char *) xmalloc (new_length
);
1235 space
= (new_buf
+ new_length
) - new_tmp
;
1236 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1244 new_buf
= (char *) xrealloc (new_buf
, new_length
+ 100);
1245 new_tmp
= new_buf
+ new_length
;
1252 /* We've "scrubbed" input to the preferred format. In the
1253 process we may have consumed the whole of the remaining
1254 file (and included files). We handle this formatted
1255 input similar to that of macro expansion, letting
1256 actual macro expansion (possibly nested) and other
1257 input expansion work. Beware that in messages, line
1258 numbers and possibly file names will be incorrect. */
1259 new_length
= strlen (new_buf
);
1260 sb_build (&sbuf
, new_length
);
1261 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1262 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1264 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1269 HANDLE_CONDITIONAL_ASSEMBLY ();
1271 #ifdef tc_unrecognized_line
1272 if (tc_unrecognized_line (c
))
1275 input_line_pointer
--;
1276 /* Report unknown char as error. */
1277 demand_empty_rest_of_line ();
1282 symbol_set_value_now (&dot_symbol
);
1284 #ifdef HANDLE_BUNDLE
1285 if (bundle_lock_frag
!= NULL
)
1287 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1288 _(".bundle_lock with no matching .bundle_unlock"));
1289 bundle_lock_frag
= NULL
;
1290 bundle_lock_frchain
= NULL
;
1291 bundle_lock_depth
= 0;
1298 /* Close the input file. */
1299 input_scrub_close ();
1300 #ifdef WARN_COMMENTS
1302 if (warn_comment
&& found_comment
)
1303 as_warn_where (found_comment_file
, found_comment
,
1304 "first comment found here");
1309 /* Convert O_constant expression EXP into the equivalent O_big representation.
1310 Take the sign of the number from SIGN rather than X_add_number. */
1313 convert_to_bignum (expressionS
*exp
, int sign
)
1318 value
= exp
->X_add_number
;
1319 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1321 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1322 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1324 /* Add a sequence of sign bits if the top bit of X_add_number is not
1325 the sign of the original value. */
1326 if ((exp
->X_add_number
< 0) == !sign
)
1327 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1329 exp
->X_add_number
= i
;
1332 /* For most MRI pseudo-ops, the line actually ends at the first
1333 nonquoted space. This function looks for that point, stuffs a null
1334 in, and sets *STOPCP to the character that used to be there, and
1335 returns the location.
1337 Until I hear otherwise, I am going to assume that this is only true
1338 for the m68k MRI assembler. */
1341 mri_comment_field (char *stopcp
)
1347 know (flag_m68k_mri
);
1349 for (s
= input_line_pointer
;
1350 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1358 for (s
= input_line_pointer
;
1359 !is_end_of_line
[(unsigned char) *s
];
1369 /* Skip to the end of an MRI comment field. */
1372 mri_comment_end (char *stop
, int stopc
)
1376 input_line_pointer
= stop
;
1378 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1379 ++input_line_pointer
;
1383 s_abort (int ignore ATTRIBUTE_UNUSED
)
1385 as_fatal (_(".abort detected. Abandoning ship."));
1388 /* Guts of .align directive. N is the power of two to which to align.
1389 FILL may be NULL, or it may point to the bytes of the fill pattern.
1390 LEN is the length of whatever FILL points to, if anything. MAX is
1391 the maximum number of characters to skip when doing the alignment,
1392 or 0 if there is no maximum. */
1395 do_align (int n
, char *fill
, int len
, int max
)
1397 if (now_seg
== absolute_section
)
1401 if (*fill
++ != '\0')
1403 as_warn (_("ignoring fill value in absolute section"));
1410 #ifdef md_flush_pending_output
1411 md_flush_pending_output ();
1414 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1417 /* Only make a frag if we HAVE to... */
1418 if (n
!= 0 && !need_pass_2
)
1422 if (subseg_text_p (now_seg
))
1423 frag_align_code (n
, max
);
1425 frag_align (n
, 0, max
);
1428 frag_align (n
, *fill
, max
);
1430 frag_align_pattern (n
, fill
, len
, max
);
1434 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
1437 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
1440 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1441 (in bytes). A negative ARG is the negative of the length of the
1442 fill pattern. BYTES_P is non-zero if the alignment value should be
1443 interpreted as the byte boundary, rather than the power of 2. */
1444 #ifndef TC_ALIGN_LIMIT
1445 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1449 s_align (int arg
, int bytes_p
)
1451 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1460 stop
= mri_comment_field (&stopc
);
1462 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1467 align
= arg
; /* Default value from pseudo-op table. */
1471 align
= get_absolute_expression ();
1477 /* Convert to a power of 2. */
1482 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1485 as_bad (_("alignment not a power of 2"));
1491 if (align
> align_limit
)
1493 align
= align_limit
;
1494 as_warn (_("alignment too large: %u assumed"), align
);
1497 if (*input_line_pointer
!= ',')
1504 ++input_line_pointer
;
1505 if (*input_line_pointer
== ',')
1509 fill
= get_absolute_expression ();
1514 if (*input_line_pointer
!= ',')
1518 ++input_line_pointer
;
1519 max
= get_absolute_expression ();
1526 as_warn (_("expected fill pattern missing"));
1527 do_align (align
, (char *) NULL
, 0, max
);
1542 do_align (align
, &fill_char
, fill_len
, max
);
1548 if ((size_t) fill_len
> sizeof ab
)
1550 md_number_to_chars (ab
, fill
, fill_len
);
1551 do_align (align
, ab
, fill_len
, max
);
1555 demand_empty_rest_of_line ();
1558 mri_comment_end (stop
, stopc
);
1561 /* Handle the .align pseudo-op on machines where ".align 4" means
1562 align to a 4 byte boundary. */
1565 s_align_bytes (int arg
)
1570 /* Handle the .align pseudo-op on machines where ".align 4" means align
1571 to a 2**4 boundary. */
1574 s_align_ptwo (int arg
)
1579 /* Switch in and out of alternate macro mode. */
1584 demand_empty_rest_of_line ();
1585 macro_set_alternate (on
);
1588 /* Read a symbol name from input_line_pointer.
1590 Stores the symbol name in a buffer and returns a pointer to this buffer.
1591 The buffer is xalloc'ed. It is the caller's responsibility to free
1594 The name is not left in the i_l_p buffer as it may need processing
1595 to handle escape characters.
1597 Advances i_l_p to the next non-whitespace character.
1599 If a symbol name could not be read, the routine issues an error
1600 messages, skips to the end of the line and returns NULL. */
1603 read_symbol_name (void)
1609 c
= *input_line_pointer
++;
1613 #define SYM_NAME_CHUNK_LEN 128
1614 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1618 start
= name
= xmalloc (len
+ 1);
1620 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1622 while (is_a_char (C
= next_char_of_string ()))
1624 if (name
>= name_end
)
1628 sofar
= name
- start
;
1629 len
+= SYM_NAME_CHUNK_LEN
;
1630 start
= xrealloc (start
, len
+ 1);
1631 name_end
= start
+ len
;
1632 name
= start
+ sofar
;
1639 /* Since quoted symbol names can contain non-ASCII characters,
1640 check the string and warn if it cannot be recognised by the
1641 current character set. */
1642 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1643 as_warn (_("symbol name not recognised in the current locale"));
1645 else if (is_name_beginner (c
) || c
== '\001')
1649 name
= input_line_pointer
- 1;
1651 /* We accept \001 in a name in case this is
1652 being called with a constructed string. */
1653 while (is_part_of_name (c
= *input_line_pointer
++)
1657 len
= (input_line_pointer
- name
) - 1;
1658 start
= xmalloc (len
+ 1);
1660 memcpy (start
, name
, len
);
1663 /* Skip a name ender char if one is present. */
1664 if (! is_name_ender (c
))
1665 --input_line_pointer
;
1668 name
= start
= NULL
;
1672 as_bad (_("expected symbol name"));
1673 ignore_rest_of_line ();
1684 s_comm_internal (int param
,
1685 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1689 symbolS
*symbolP
= NULL
;
1695 stop
= mri_comment_field (&stopc
);
1697 if ((name
= read_symbol_name ()) == NULL
)
1700 /* Accept an optional comma after the name. The comma used to be
1701 required, but Irix 5 cc does not generate it for .lcomm. */
1702 if (*input_line_pointer
== ',')
1703 input_line_pointer
++;
1705 temp
= get_absolute_expr (&exp
);
1707 size
&= ((offsetT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1708 if (exp
.X_op
== O_absent
)
1710 as_bad (_("missing size expression"));
1711 ignore_rest_of_line ();
1714 else if (temp
!= size
|| !exp
.X_unsigned
)
1716 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1717 ignore_rest_of_line ();
1721 symbolP
= symbol_find_or_make (name
);
1722 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1723 && !S_IS_COMMON (symbolP
))
1725 if (!S_IS_VOLATILE (symbolP
))
1728 as_bad (_("symbol `%s' is already defined"), name
);
1729 ignore_rest_of_line ();
1732 symbolP
= symbol_clone (symbolP
, 1);
1733 S_SET_SEGMENT (symbolP
, undefined_section
);
1734 S_SET_VALUE (symbolP
, 0);
1735 symbol_set_frag (symbolP
, &zero_address_frag
);
1736 S_CLEAR_VOLATILE (symbolP
);
1739 size
= S_GET_VALUE (symbolP
);
1742 else if (size
!= temp
)
1743 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1744 name
, (long) size
, (long) temp
);
1746 if (comm_parse_extra
!= NULL
)
1747 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1750 S_SET_VALUE (symbolP
, (valueT
) size
);
1751 S_SET_EXTERNAL (symbolP
);
1752 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1755 demand_empty_rest_of_line ();
1758 mri_comment_end (stop
, stopc
);
1767 s_comm_internal (ignore
, NULL
);
1770 /* The MRI COMMON pseudo-op. We handle this by creating a common
1771 symbol with the appropriate name. We make s_space do the right
1772 thing by increasing the size. */
1775 s_mri_common (int small ATTRIBUTE_UNUSED
)
1791 stop
= mri_comment_field (&stopc
);
1795 name
= input_line_pointer
;
1796 if (!ISDIGIT (*name
))
1797 c
= get_symbol_end ();
1802 ++input_line_pointer
;
1804 while (ISDIGIT (*input_line_pointer
));
1806 c
= *input_line_pointer
;
1807 *input_line_pointer
= '\0';
1809 if (line_label
!= NULL
)
1811 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1812 + (input_line_pointer
- name
)
1814 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1819 sym
= symbol_find_or_make (name
);
1820 *input_line_pointer
= c
;
1824 if (*input_line_pointer
!= ',')
1828 ++input_line_pointer
;
1829 align
= get_absolute_expression ();
1832 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1834 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1835 ignore_rest_of_line ();
1836 mri_comment_end (stop
, stopc
);
1840 S_SET_EXTERNAL (sym
);
1841 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1842 mri_common_symbol
= sym
;
1846 S_SET_ALIGN (sym
, align
);
1851 if (line_label
!= NULL
)
1854 exp
.X_op
= O_symbol
;
1855 exp
.X_add_symbol
= sym
;
1856 exp
.X_add_number
= 0;
1857 symbol_set_value_expression (line_label
, &exp
);
1858 symbol_set_frag (line_label
, &zero_address_frag
);
1859 S_SET_SEGMENT (line_label
, expr_section
);
1862 /* FIXME: We just ignore the small argument, which distinguishes
1863 COMMON and COMMON.S. I don't know what we can do about it. */
1865 /* Ignore the type and hptype. */
1866 if (*input_line_pointer
== ',')
1867 input_line_pointer
+= 2;
1868 if (*input_line_pointer
== ',')
1869 input_line_pointer
+= 2;
1871 demand_empty_rest_of_line ();
1873 mri_comment_end (stop
, stopc
);
1877 s_data (int ignore ATTRIBUTE_UNUSED
)
1882 temp
= get_absolute_expression ();
1883 if (flag_readonly_data_in_text
)
1885 section
= text_section
;
1889 section
= data_section
;
1891 subseg_set (section
, (subsegT
) temp
);
1893 demand_empty_rest_of_line ();
1896 /* Handle the .appfile pseudo-op. This is automatically generated by
1897 do_scrub_chars when a preprocessor # line comment is seen with a
1898 file name. This default definition may be overridden by the object
1899 or CPU specific pseudo-ops. This function is also the default
1900 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1904 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1908 listing_source_file (file
);
1910 register_dependency (file
);
1912 obj_app_file (file
, appfile
);
1917 s_app_file (int appfile
)
1922 /* Some assemblers tolerate immediately following '"'. */
1923 if ((s
= demand_copy_string (&length
)) != 0)
1926 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1928 /* In MRI mode, the preprocessor may have inserted an extraneous
1931 && *input_line_pointer
== '\''
1932 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1933 ++input_line_pointer
;
1935 demand_empty_rest_of_line ();
1937 s_app_file_string (s
, appfile
);
1942 get_linefile_number (int *flag
)
1946 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1949 *flag
= get_absolute_expression ();
1954 /* Handle the .appline pseudo-op. This is automatically generated by
1955 do_scrub_chars when a preprocessor # line comment is seen. This
1956 default definition may be overridden by the object or CPU specific
1960 s_app_line (int appline
)
1965 /* The given number is that of the next line. */
1967 l
= get_absolute_expression ();
1968 else if (!get_linefile_number (&l
))
1970 ignore_rest_of_line ();
1977 /* Some of the back ends can't deal with non-positive line numbers.
1978 Besides, it's silly. GCC however will generate a line number of
1979 zero when it is pre-processing builtins for assembler-with-cpp files:
1983 We do not want to barf on this, especially since such files are used
1984 in the GCC and GDB testsuites. So we check for negative line numbers
1985 rather than non-positive line numbers. */
1986 as_warn (_("line numbers must be positive; line number %d rejected"),
1997 if (*input_line_pointer
== '"')
1998 file
= demand_copy_string (&length
);
2004 while (get_linefile_number (&this_flag
))
2007 /* From GCC's cpp documentation:
2008 1: start of a new file.
2009 2: returning to a file after having included
2011 3: following text comes from a system header file.
2012 4: following text should be treated as extern "C".
2014 4 is nonsensical for the assembler; 3, we don't
2015 care about, so we ignore it just in case a
2016 system header file is included while
2017 preprocessing assembly. So 1 and 2 are all we
2018 care about, and they are mutually incompatible.
2019 new_logical_line_flags() demands this. */
2022 if (flags
&& flags
!= (1 << this_flag
))
2023 as_warn (_("incompatible flag %i in line directive"),
2026 flags
|= 1 << this_flag
;
2031 /* We ignore these. */
2035 as_warn (_("unsupported flag %i in line directive"),
2040 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2045 if (appline
|| file
)
2047 new_logical_line_flags (file
, l
, flags
);
2050 listing_source_line (l
);
2054 if (appline
|| file
)
2055 demand_empty_rest_of_line ();
2057 ignore_rest_of_line ();
2060 /* Handle the .end pseudo-op. Actually, the real work is done in
2061 read_a_source_file. */
2064 s_end (int ignore ATTRIBUTE_UNUSED
)
2068 /* The MRI assembler permits the start symbol to follow .end,
2069 but we don't support that. */
2071 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2072 && *input_line_pointer
!= '*'
2073 && *input_line_pointer
!= '!')
2074 as_warn (_("start address not supported"));
2078 /* Handle the .err pseudo-op. */
2081 s_err (int ignore ATTRIBUTE_UNUSED
)
2083 as_bad (_(".err encountered"));
2084 demand_empty_rest_of_line ();
2087 /* Handle the .error and .warning pseudo-ops. */
2093 /* The purpose for the conditional assignment is not to
2094 internationalize the directive itself, but that we need a
2095 self-contained message, one that can be passed like the
2096 demand_copy_C_string return value, and with no assumption on the
2097 location of the name of the directive within the message. */
2099 = (err
? _(".error directive invoked in source file")
2100 : _(".warning directive invoked in source file"));
2102 if (!is_it_end_of_statement ())
2104 if (*input_line_pointer
!= '\"')
2106 as_bad (_("%s argument must be a string"),
2107 err
? ".error" : ".warning");
2108 ignore_rest_of_line ();
2112 msg
= demand_copy_C_string (&len
);
2120 as_warn ("%s", msg
);
2121 demand_empty_rest_of_line ();
2124 /* Handle the MRI fail pseudo-op. */
2127 s_fail (int ignore ATTRIBUTE_UNUSED
)
2134 stop
= mri_comment_field (&stopc
);
2136 temp
= get_absolute_expression ();
2138 as_warn (_(".fail %ld encountered"), (long) temp
);
2140 as_bad (_(".fail %ld encountered"), (long) temp
);
2142 demand_empty_rest_of_line ();
2145 mri_comment_end (stop
, stopc
);
2149 s_fill (int ignore ATTRIBUTE_UNUSED
)
2151 expressionS rep_exp
;
2156 #ifdef md_flush_pending_output
2157 md_flush_pending_output ();
2160 #ifdef md_cons_align
2164 get_known_segmented_expression (&rep_exp
);
2165 if (*input_line_pointer
== ',')
2167 input_line_pointer
++;
2168 size
= get_absolute_expression ();
2169 if (*input_line_pointer
== ',')
2171 input_line_pointer
++;
2172 fill
= get_absolute_expression ();
2176 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2177 #define BSD_FILL_SIZE_CROCK_8 (8)
2178 if (size
> BSD_FILL_SIZE_CROCK_8
)
2180 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2181 size
= BSD_FILL_SIZE_CROCK_8
;
2185 as_warn (_("size negative; .fill ignored"));
2188 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2190 if (rep_exp
.X_add_number
< 0)
2191 as_warn (_("repeat < 0; .fill ignored"));
2195 if (size
&& !need_pass_2
)
2197 if (rep_exp
.X_op
== O_constant
)
2199 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2200 (relax_substateT
) 0, (symbolS
*) 0,
2201 (offsetT
) rep_exp
.X_add_number
,
2206 /* We don't have a constant repeat count, so we can't use
2207 rs_fill. We can get the same results out of rs_space,
2208 but its argument is in bytes, so we must multiply the
2209 repeat count by size. */
2212 rep_sym
= make_expr_symbol (&rep_exp
);
2215 expressionS size_exp
;
2216 size_exp
.X_op
= O_constant
;
2217 size_exp
.X_add_number
= size
;
2219 rep_exp
.X_op
= O_multiply
;
2220 rep_exp
.X_add_symbol
= rep_sym
;
2221 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2222 rep_exp
.X_add_number
= 0;
2223 rep_sym
= make_expr_symbol (&rep_exp
);
2226 p
= frag_var (rs_space
, (int) size
, (int) size
,
2227 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2230 memset (p
, 0, (unsigned int) size
);
2232 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2233 flavoured AS. The following bizarre behaviour is to be
2234 compatible with above. I guess they tried to take up to 8
2235 bytes from a 4-byte expression and they forgot to sign
2237 #define BSD_FILL_SIZE_CROCK_4 (4)
2238 md_number_to_chars (p
, (valueT
) fill
,
2239 (size
> BSD_FILL_SIZE_CROCK_4
2240 ? BSD_FILL_SIZE_CROCK_4
2242 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2243 but emits no error message because it seems a legal thing to do.
2244 It is a degenerate case of .fill but could be emitted by a
2247 demand_empty_rest_of_line ();
2251 s_globl (int ignore ATTRIBUTE_UNUSED
)
2260 stop
= mri_comment_field (&stopc
);
2264 if ((name
= read_symbol_name ()) == NULL
)
2267 symbolP
= symbol_find_or_make (name
);
2268 S_SET_EXTERNAL (symbolP
);
2271 c
= *input_line_pointer
;
2274 input_line_pointer
++;
2276 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2284 demand_empty_rest_of_line ();
2287 mri_comment_end (stop
, stopc
);
2290 /* Handle the MRI IRP and IRPC pseudo-ops. */
2301 as_where (&file
, &line
);
2303 eol
= find_end_of_line (input_line_pointer
, 0);
2304 sb_build (&s
, eol
- input_line_pointer
);
2305 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2306 input_line_pointer
= eol
;
2310 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2312 as_bad_where (file
, line
, "%s", err
);
2316 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2318 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2321 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2322 the section to only be linked once. However, this is not supported
2323 by most object file formats. This takes an optional argument,
2324 which is what to do about duplicates. */
2327 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2329 enum linkonce_type type
;
2333 type
= LINKONCE_DISCARD
;
2335 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2340 s
= input_line_pointer
;
2341 c
= get_symbol_end ();
2342 if (strcasecmp (s
, "discard") == 0)
2343 type
= LINKONCE_DISCARD
;
2344 else if (strcasecmp (s
, "one_only") == 0)
2345 type
= LINKONCE_ONE_ONLY
;
2346 else if (strcasecmp (s
, "same_size") == 0)
2347 type
= LINKONCE_SAME_SIZE
;
2348 else if (strcasecmp (s
, "same_contents") == 0)
2349 type
= LINKONCE_SAME_CONTENTS
;
2351 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2353 *input_line_pointer
= c
;
2356 #ifdef obj_handle_link_once
2357 obj_handle_link_once (type
);
2358 #else /* ! defined (obj_handle_link_once) */
2362 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2363 as_warn (_(".linkonce is not supported for this object file format"));
2365 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2366 flags
|= SEC_LINK_ONCE
;
2371 case LINKONCE_DISCARD
:
2372 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2374 case LINKONCE_ONE_ONLY
:
2375 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2377 case LINKONCE_SAME_SIZE
:
2378 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2380 case LINKONCE_SAME_CONTENTS
:
2381 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2384 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2385 as_bad (_("bfd_set_section_flags: %s"),
2386 bfd_errmsg (bfd_get_error ()));
2388 #endif /* ! defined (obj_handle_link_once) */
2390 demand_empty_rest_of_line ();
2394 bss_alloc (symbolS
*symbolP
, addressT size
, int align
)
2397 segT current_seg
= now_seg
;
2398 subsegT current_subseg
= now_subseg
;
2399 segT bss_seg
= bss_section
;
2401 #if defined (TC_MIPS) || defined (TC_ALPHA)
2402 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2403 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2405 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2406 if (size
<= bfd_get_gp_size (stdoutput
))
2408 bss_seg
= subseg_new (".sbss", 1);
2409 seg_info (bss_seg
)->bss
= 1;
2410 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2411 as_warn (_("error setting flags for \".sbss\": %s"),
2412 bfd_errmsg (bfd_get_error ()));
2416 subseg_set (bss_seg
, 1);
2420 record_alignment (bss_seg
, align
);
2421 frag_align (align
, 0, 0);
2424 /* Detach from old frag. */
2425 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2426 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2428 symbol_set_frag (symbolP
, frag_now
);
2429 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2433 S_SET_SIZE (symbolP
, size
);
2435 S_SET_SEGMENT (symbolP
, bss_seg
);
2438 /* The symbol may already have been created with a preceding
2439 ".globl" directive -- be careful not to step on storage class
2440 in that case. Otherwise, set it to static. */
2441 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2442 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2443 #endif /* OBJ_COFF */
2445 subseg_set (current_seg
, current_subseg
);
2449 parse_align (int align_bytes
)
2455 if (*input_line_pointer
!= ',')
2458 as_bad (_("expected alignment after size"));
2459 ignore_rest_of_line ();
2463 input_line_pointer
++;
2466 align
= get_absolute_expr (&exp
);
2467 if (exp
.X_op
== O_absent
)
2470 if (!exp
.X_unsigned
)
2472 as_warn (_("alignment negative; 0 assumed"));
2476 if (align_bytes
&& align
!= 0)
2478 /* convert to a power of 2 alignment */
2479 unsigned int alignp2
= 0;
2480 while ((align
& 1) == 0)
2481 align
>>= 1, ++alignp2
;
2484 as_bad (_("alignment not a power of 2"));
2485 ignore_rest_of_line ();
2493 /* Called from s_comm_internal after symbol name and size have been
2494 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2495 1 if this was a ".bss" directive which has a 3rd argument
2496 (alignment as a power of 2), or 2 if this was a ".bss" directive
2497 with alignment in bytes. */
2500 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2506 align
= parse_align (needs_align
- 1);
2507 if (align
== (addressT
) -1)
2511 /* Assume some objects may require alignment on some systems. */
2512 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2514 bss_alloc (symbolP
, size
, align
);
2519 s_lcomm (int needs_align
)
2521 s_comm_internal (needs_align
, s_lcomm_internal
);
2525 s_lcomm_bytes (int needs_align
)
2527 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2531 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2537 /* We permit ANY defined expression: BSD4.2 demands constants. */
2538 if ((name
= read_symbol_name ()) == NULL
)
2541 if (*input_line_pointer
!= ',')
2543 as_bad (_("expected comma after \"%s\""), name
);
2547 input_line_pointer
++;
2548 expression_and_evaluate (&exp
);
2550 if (exp
.X_op
!= O_constant
2551 && exp
.X_op
!= O_register
)
2553 as_bad (_("bad expression"));
2557 symbolP
= symbol_find_or_make (name
);
2559 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2561 /* The name might be an undefined .global symbol; be sure to
2562 keep the "external" bit. */
2563 S_SET_SEGMENT (symbolP
,
2564 (exp
.X_op
== O_constant
2567 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2571 as_bad (_("symbol `%s' is already defined"), name
);
2574 demand_empty_rest_of_line ();
2579 ignore_rest_of_line ();
2584 /* Read a line into an sb. Returns the character that ended the line
2585 or zero if there are no more lines. */
2588 get_line_sb (sb
*line
, int in_macro
)
2592 if (input_line_pointer
[-1] == '\n')
2593 bump_line_counters ();
2595 if (input_line_pointer
>= buffer_limit
)
2597 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2598 if (buffer_limit
== 0)
2602 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2603 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2604 input_line_pointer
= eol
;
2606 /* Don't skip multiple end-of-line characters, because that breaks support
2607 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2608 characters but isn't. Instead just skip one end of line character and
2609 return the character skipped so that the caller can re-insert it if
2611 return *input_line_pointer
++;
2615 get_non_macro_line_sb (sb
*line
)
2617 return get_line_sb (line
, 0);
2621 get_macro_line_sb (sb
*line
)
2623 return get_line_sb (line
, 1);
2626 /* Define a macro. This is an interface to macro.c. */
2629 s_macro (int ignore ATTRIBUTE_UNUSED
)
2637 as_where (&file
, &line
);
2639 eol
= find_end_of_line (input_line_pointer
, 0);
2640 sb_build (&s
, eol
- input_line_pointer
);
2641 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2642 input_line_pointer
= eol
;
2644 if (line_label
!= NULL
)
2649 name
= S_GET_NAME (line_label
);
2650 len
= strlen (name
);
2651 sb_build (&label
, len
);
2652 sb_add_buffer (&label
, name
, len
);
2653 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2657 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2659 as_bad_where (file
, line
, err
, name
);
2662 if (line_label
!= NULL
)
2664 S_SET_SEGMENT (line_label
, absolute_section
);
2665 S_SET_VALUE (line_label
, 0);
2666 symbol_set_frag (line_label
, &zero_address_frag
);
2669 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2670 && hash_find (po_hash
, name
) != NULL
)
2673 && hash_find (po_hash
, name
+ 1) != NULL
))
2674 as_warn_where (file
,
2676 _("attempt to redefine pseudo-op `%s' ignored"),
2683 /* Handle the .mexit pseudo-op, which immediately exits a macro
2687 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2691 cond_exit_macro (macro_nest
);
2692 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2695 as_warn (_("ignoring macro exit outside a macro definition."));
2698 /* Switch in and out of MRI mode. */
2701 s_mri (int ignore ATTRIBUTE_UNUSED
)
2704 #ifdef MRI_MODE_CHANGE
2708 on
= get_absolute_expression ();
2709 #ifdef MRI_MODE_CHANGE
2710 old_flag
= flag_mri
;
2729 /* Operator precedence changes in m68k MRI mode, so we need to
2730 update the operator rankings. */
2731 expr_set_precedence ();
2733 #ifdef MRI_MODE_CHANGE
2735 MRI_MODE_CHANGE (on
);
2738 demand_empty_rest_of_line ();
2741 /* Handle changing the location counter. */
2744 do_org (segT segment
, expressionS
*exp
, int fill
)
2746 if (segment
!= now_seg
2747 && segment
!= absolute_section
2748 && segment
!= expr_section
)
2749 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2751 if (now_seg
== absolute_section
)
2754 as_warn (_("ignoring fill value in absolute section"));
2755 if (exp
->X_op
!= O_constant
)
2757 as_bad (_("only constant offsets supported in absolute section"));
2758 exp
->X_add_number
= 0;
2760 abs_section_offset
= exp
->X_add_number
;
2765 symbolS
*sym
= exp
->X_add_symbol
;
2766 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2768 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2770 /* Handle complex expressions. */
2771 sym
= make_expr_symbol (exp
);
2775 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2781 s_org (int ignore ATTRIBUTE_UNUSED
)
2787 #ifdef md_flush_pending_output
2788 md_flush_pending_output ();
2791 /* The m68k MRI assembler has a different meaning for .org. It
2792 means to create an absolute section at a given address. We can't
2793 support that--use a linker script instead. */
2796 as_bad (_("MRI style ORG pseudo-op not supported"));
2797 ignore_rest_of_line ();
2801 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2802 thing as a sub-segment-relative origin. Any absolute origin is
2803 given a warning, then assumed to be segment-relative. Any
2804 segmented origin expression ("foo+42") had better be in the right
2805 segment or the .org is ignored.
2807 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2808 we never know sub-segment sizes when we are reading code. BSD
2809 will crash trying to emit negative numbers of filler bytes in
2810 certain .orgs. We don't crash, but see as-write for that code.
2812 Don't make frag if need_pass_2==1. */
2813 segment
= get_known_segmented_expression (&exp
);
2814 if (*input_line_pointer
== ',')
2816 input_line_pointer
++;
2817 temp_fill
= get_absolute_expression ();
2823 do_org (segment
, &exp
, temp_fill
);
2825 demand_empty_rest_of_line ();
2828 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2829 called by the obj-format routine which handles section changing
2830 when in MRI mode. It will create a new section, and return it. It
2831 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2832 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2835 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2845 name
= input_line_pointer
;
2846 if (!ISDIGIT (*name
))
2847 c
= get_symbol_end ();
2852 ++input_line_pointer
;
2854 while (ISDIGIT (*input_line_pointer
));
2856 c
= *input_line_pointer
;
2857 *input_line_pointer
= '\0';
2860 name
= xstrdup (name
);
2862 *input_line_pointer
= c
;
2864 seg
= subseg_new (name
, 0);
2866 if (*input_line_pointer
== ',')
2870 ++input_line_pointer
;
2871 align
= get_absolute_expression ();
2872 record_alignment (seg
, align
);
2876 if (*input_line_pointer
== ',')
2878 c
= *++input_line_pointer
;
2880 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2883 as_bad (_("unrecognized section type"));
2884 ++input_line_pointer
;
2889 flags
= SEC_NO_FLAGS
;
2891 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2892 else if (*type
== 'D' || *type
== 'M')
2893 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2894 else if (*type
== 'R')
2895 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2896 if (flags
!= SEC_NO_FLAGS
)
2898 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2899 as_warn (_("error setting flags for \"%s\": %s"),
2900 bfd_section_name (stdoutput
, seg
),
2901 bfd_errmsg (bfd_get_error ()));
2906 /* Ignore the HP type. */
2907 if (*input_line_pointer
== ',')
2908 input_line_pointer
+= 2;
2910 demand_empty_rest_of_line ();
2912 #else /* ! TC_M68K */
2921 name
= input_line_pointer
;
2922 c
= get_symbol_end ();
2924 name
= xstrdup (name
);
2926 *input_line_pointer
= c
;
2928 seg
= subseg_new (name
, 0);
2930 if (*input_line_pointer
!= ',')
2936 ++input_line_pointer
;
2938 sectype
= input_line_pointer
;
2939 c
= get_symbol_end ();
2940 if (*sectype
== '\0')
2942 else if (strcasecmp (sectype
, "text") == 0)
2944 else if (strcasecmp (sectype
, "data") == 0)
2946 else if (strcasecmp (sectype
, "romdata") == 0)
2949 as_warn (_("unrecognized section type `%s'"), sectype
);
2950 *input_line_pointer
= c
;
2953 if (*input_line_pointer
== ',')
2957 ++input_line_pointer
;
2959 seccmd
= input_line_pointer
;
2960 c
= get_symbol_end ();
2961 if (strcasecmp (seccmd
, "absolute") == 0)
2963 as_bad (_("absolute sections are not supported"));
2964 *input_line_pointer
= c
;
2965 ignore_rest_of_line ();
2968 else if (strcasecmp (seccmd
, "align") == 0)
2972 *input_line_pointer
= c
;
2973 align
= get_absolute_expression ();
2974 record_alignment (seg
, align
);
2978 as_warn (_("unrecognized section command `%s'"), seccmd
);
2979 *input_line_pointer
= c
;
2983 demand_empty_rest_of_line ();
2985 #else /* ! TC_I960 */
2986 /* The MRI assembler seems to use different forms of .sect for
2987 different targets. */
2988 as_bad ("MRI mode not supported for this target");
2989 ignore_rest_of_line ();
2990 #endif /* ! TC_I960 */
2991 #endif /* ! TC_M68K */
2994 /* Handle the .print pseudo-op. */
2997 s_print (int ignore ATTRIBUTE_UNUSED
)
3002 s
= demand_copy_C_string (&len
);
3005 demand_empty_rest_of_line ();
3008 /* Handle the .purgem pseudo-op. */
3011 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3013 if (is_it_end_of_statement ())
3015 demand_empty_rest_of_line ();
3025 name
= input_line_pointer
;
3026 c
= get_symbol_end ();
3027 delete_macro (name
);
3028 *input_line_pointer
= c
;
3031 while (*input_line_pointer
++ == ',');
3033 --input_line_pointer
;
3034 demand_empty_rest_of_line ();
3037 /* Handle the .endm/.endr pseudo-ops. */
3040 s_bad_end (int endr
)
3042 as_warn (_(".end%c encountered without preceding %s"),
3044 endr
? ".rept, .irp, or .irpc" : ".macro");
3045 demand_empty_rest_of_line ();
3048 /* Handle the .rept pseudo-op. */
3051 s_rept (int ignore ATTRIBUTE_UNUSED
)
3055 count
= get_absolute_expression ();
3057 do_repeat (count
, "REPT", "ENDR");
3060 /* This function provides a generic repeat block implementation. It allows
3061 different directives to be used as the start/end keys. */
3064 do_repeat (int count
, const char *start
, const char *end
)
3070 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3072 as_bad (_("%s without %s"), start
, end
);
3076 sb_build (&many
, count
* one
.len
);
3078 sb_add_sb (&many
, &one
);
3082 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3084 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3087 /* Like do_repeat except that any text matching EXPANDER in the
3088 block is replaced by the itteration count. */
3091 do_repeat_with_expander (int count
,
3094 const char * expander
)
3100 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3102 as_bad (_("%s without %s"), start
, end
);
3108 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3110 while (count
-- > 0)
3116 sb_build (& processed
, one
.len
);
3117 sb_add_sb (& processed
, & one
);
3118 sub
= strstr (processed
.ptr
, expander
);
3119 len
= sprintf (sub
, "%d", count
);
3120 gas_assert (len
< 8);
3121 strcpy (sub
+ len
, sub
+ 8);
3122 processed
.len
-= (8 - len
);
3123 sb_add_sb (& many
, & processed
);
3124 sb_kill (& processed
);
3129 sb_add_sb (&many
, &one
);
3133 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3135 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3138 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3139 input buffers to skip. Assumes that conditionals preceding the loop end
3140 are properly nested.
3142 This function makes it easier to implement a premature "break" out of the
3143 loop. The EXTRA arg accounts for other buffers we might have inserted,
3144 such as line substitutions. */
3147 end_repeat (int extra
)
3149 cond_exit_macro (macro_nest
);
3150 while (extra
-- >= 0)
3151 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3155 assign_symbol (char *name
, int mode
)
3159 if (name
[0] == '.' && name
[1] == '\0')
3161 /* Turn '. = mumble' into a .org mumble. */
3165 segment
= get_known_segmented_expression (&exp
);
3168 do_org (segment
, &exp
, 0);
3173 if ((symbolP
= symbol_find (name
)) == NULL
3174 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3176 symbolP
= symbol_find_or_make (name
);
3178 /* When doing symbol listings, play games with dummy fragments living
3179 outside the normal fragment chain to record the file and line info
3181 if (listing
& LISTING_SYMBOLS
)
3183 extern struct list_info_struct
*listing_tail
;
3184 fragS
*dummy_frag
= (fragS
*) xcalloc (1, sizeof (fragS
));
3185 dummy_frag
->line
= listing_tail
;
3186 dummy_frag
->fr_symbol
= symbolP
;
3187 symbol_set_frag (symbolP
, dummy_frag
);
3191 /* "set" symbols are local unless otherwise specified. */
3192 SF_SET_LOCAL (symbolP
);
3196 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3198 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3199 && !S_CAN_BE_REDEFINED (symbolP
))
3201 as_bad (_("symbol `%s' is already defined"), name
);
3202 symbolP
= symbol_clone (symbolP
, 0);
3204 /* If the symbol is volatile, copy the symbol and replace the
3205 original with the copy, so that previous uses of the symbol will
3206 retain the value of the symbol at the point of use. */
3207 else if (S_IS_VOLATILE (symbolP
))
3208 symbolP
= symbol_clone (symbolP
, 1);
3212 S_SET_VOLATILE (symbolP
);
3214 S_SET_FORWARD_REF (symbolP
);
3216 pseudo_set (symbolP
);
3219 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3220 then this is .equiv, and it is an error if the symbol is already
3221 defined. If EQUIV is -1, the symbol additionally is a forward
3229 /* Especial apologies for the random logic:
3230 this just grew, and could be parsed much more simply!
3232 if ((name
= read_symbol_name ()) == NULL
)
3235 if (*input_line_pointer
!= ',')
3237 as_bad (_("expected comma after \"%s\""), name
);
3238 ignore_rest_of_line ();
3243 input_line_pointer
++;
3244 assign_symbol (name
, equiv
);
3245 demand_empty_rest_of_line ();
3259 #ifdef md_flush_pending_output
3260 md_flush_pending_output ();
3263 #ifdef md_cons_align
3268 stop
= mri_comment_field (&stopc
);
3270 /* In m68k MRI mode, we need to align to a word boundary, unless
3272 if (flag_m68k_mri
&& mult
> 1)
3274 if (now_seg
== absolute_section
)
3276 abs_section_offset
+= abs_section_offset
& 1;
3277 if (line_label
!= NULL
)
3278 S_SET_VALUE (line_label
, abs_section_offset
);
3280 else if (mri_common_symbol
!= NULL
)
3284 mri_val
= S_GET_VALUE (mri_common_symbol
);
3285 if ((mri_val
& 1) != 0)
3287 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3288 if (line_label
!= NULL
)
3290 expressionS
*symexp
;
3292 symexp
= symbol_get_value_expression (line_label
);
3293 know (symexp
->X_op
== O_symbol
);
3294 know (symexp
->X_add_symbol
== mri_common_symbol
);
3295 symexp
->X_add_number
+= 1;
3301 do_align (1, (char *) NULL
, 0, 0);
3302 if (line_label
!= NULL
)
3304 symbol_set_frag (line_label
, frag_now
);
3305 S_SET_VALUE (line_label
, frag_now_fix ());
3315 if (*input_line_pointer
== ',')
3317 ++input_line_pointer
;
3322 val
.X_op
= O_constant
;
3323 val
.X_add_number
= 0;
3326 if (val
.X_op
!= O_constant
3327 || val
.X_add_number
< - 0x80
3328 || val
.X_add_number
> 0xff
3329 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3331 resolve_expression (&exp
);
3332 if (exp
.X_op
!= O_constant
)
3333 as_bad (_("unsupported variable size or fill value"));
3340 bytes
= mult
* exp
.X_add_number
;
3341 for (i
= 0; i
< exp
.X_add_number
; i
++)
3342 emit_expr (&val
, mult
);
3347 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3348 resolve_expression (&exp
);
3350 if (exp
.X_op
== O_constant
)
3354 repeat
= exp
.X_add_number
;
3361 as_warn (_(".space repeat count is zero, ignored"));
3362 else if (repeat
< 0)
3363 as_warn (_(".space repeat count is negative, ignored"));
3367 /* If we are in the absolute section, just bump the offset. */
3368 if (now_seg
== absolute_section
)
3370 abs_section_offset
+= repeat
;
3374 /* If we are secretly in an MRI common section, then
3375 creating space just increases the size of the common
3377 if (mri_common_symbol
!= NULL
)
3379 S_SET_VALUE (mri_common_symbol
,
3380 S_GET_VALUE (mri_common_symbol
) + repeat
);
3385 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3386 (offsetT
) repeat
, (char *) 0);
3390 if (now_seg
== absolute_section
)
3392 as_bad (_("space allocation too complex in absolute section"));
3393 subseg_set (text_section
, 0);
3396 if (mri_common_symbol
!= NULL
)
3398 as_bad (_("space allocation too complex in common section"));
3399 mri_common_symbol
= NULL
;
3403 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3404 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3408 *p
= val
.X_add_number
;
3413 /* In MRI mode, after an odd number of bytes, we must align to an
3414 even word boundary, unless the next instruction is a dc.b, ds.b
3416 if (flag_mri
&& (bytes
& 1) != 0)
3417 mri_pending_align
= 1;
3419 demand_empty_rest_of_line ();
3422 mri_comment_end (stop
, stopc
);
3425 /* This is like s_space, but the value is a floating point number with
3426 the given precision. This is for the MRI dcb.s pseudo-op and
3430 s_float_space (int float_type
)
3434 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3438 #ifdef md_cons_align
3443 stop
= mri_comment_field (&stopc
);
3445 count
= get_absolute_expression ();
3448 if (*input_line_pointer
!= ',')
3450 as_bad (_("missing value"));
3451 ignore_rest_of_line ();
3453 mri_comment_end (stop
, stopc
);
3457 ++input_line_pointer
;
3461 /* Skip any 0{letter} that may be present. Don't even check if the
3462 * letter is legal. */
3463 if (input_line_pointer
[0] == '0'
3464 && ISALPHA (input_line_pointer
[1]))
3465 input_line_pointer
+= 2;
3467 /* Accept :xxxx, where the x's are hex digits, for a floating point
3468 with the exact digits specified. */
3469 if (input_line_pointer
[0] == ':')
3471 flen
= hex_float (float_type
, temp
);
3474 ignore_rest_of_line ();
3476 mri_comment_end (stop
, stopc
);
3484 err
= md_atof (float_type
, temp
, &flen
);
3485 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3486 know (err
!= NULL
|| flen
> 0);
3489 as_bad (_("bad floating literal: %s"), err
);
3490 ignore_rest_of_line ();
3492 mri_comment_end (stop
, stopc
);
3497 while (--count
>= 0)
3501 p
= frag_more (flen
);
3502 memcpy (p
, temp
, (unsigned int) flen
);
3505 demand_empty_rest_of_line ();
3508 mri_comment_end (stop
, stopc
);
3511 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3514 s_struct (int ignore ATTRIBUTE_UNUSED
)
3520 stop
= mri_comment_field (&stopc
);
3521 abs_section_offset
= get_absolute_expression ();
3522 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3523 /* The ELF backend needs to know that we are changing sections, so
3524 that .previous works correctly. */
3526 obj_elf_section_change_hook ();
3528 subseg_set (absolute_section
, 0);
3529 demand_empty_rest_of_line ();
3531 mri_comment_end (stop
, stopc
);
3535 s_text (int ignore ATTRIBUTE_UNUSED
)
3539 temp
= get_absolute_expression ();
3540 subseg_set (text_section
, (subsegT
) temp
);
3541 demand_empty_rest_of_line ();
3544 /* .weakref x, y sets x as an alias to y that, as long as y is not
3545 referenced directly, will cause y to become a weak symbol. */
3547 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3554 if ((name
= read_symbol_name ()) == NULL
)
3557 symbolP
= symbol_find_or_make (name
);
3559 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3561 if (!S_IS_VOLATILE (symbolP
))
3563 as_bad (_("symbol `%s' is already defined"), name
);
3566 symbolP
= symbol_clone (symbolP
, 1);
3567 S_CLEAR_VOLATILE (symbolP
);
3572 if (*input_line_pointer
!= ',')
3574 as_bad (_("expected comma after \"%s\""), name
);
3578 input_line_pointer
++;
3583 if ((name
= read_symbol_name ()) == NULL
)
3586 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3587 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3589 symbolP2
= symbol_find_or_make (name
);
3590 S_SET_WEAKREFD (symbolP2
);
3594 symbolS
*symp
= symbolP2
;
3596 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3598 expressionS
*expP
= symbol_get_value_expression (symp
);
3600 gas_assert (expP
->X_op
== O_symbol
3601 && expP
->X_add_number
== 0);
3602 symp
= expP
->X_add_symbol
;
3604 if (symp
== symbolP
)
3608 loop
= concat (S_GET_NAME (symbolP
),
3609 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3612 while (symp
!= symbolP
)
3614 char *old_loop
= loop
;
3616 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3617 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3618 (const char *) NULL
);
3622 as_bad (_("%s: would close weakref loop: %s"),
3623 S_GET_NAME (symbolP
), loop
);
3627 ignore_rest_of_line ();
3631 /* Short-circuiting instead of just checking here might speed
3632 things up a tiny little bit, but loop error messages would
3633 miss intermediate links. */
3634 /* symbolP2 = symp; */
3637 memset (&exp
, 0, sizeof (exp
));
3638 exp
.X_op
= O_symbol
;
3639 exp
.X_add_symbol
= symbolP2
;
3641 S_SET_SEGMENT (symbolP
, undefined_section
);
3642 symbol_set_value_expression (symbolP
, &exp
);
3643 symbol_set_frag (symbolP
, &zero_address_frag
);
3644 S_SET_WEAKREFR (symbolP
);
3646 demand_empty_rest_of_line ();
3651 ignore_rest_of_line ();
3657 /* Verify that we are at the end of a line. If not, issue an error and
3661 demand_empty_rest_of_line (void)
3664 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3665 input_line_pointer
++;
3668 if (ISPRINT (*input_line_pointer
))
3669 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3670 *input_line_pointer
);
3672 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3673 *input_line_pointer
);
3674 ignore_rest_of_line ();
3677 /* Return pointing just after end-of-line. */
3678 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3681 /* Silently advance to the end of line. Use this after already having
3682 issued an error about something bad. */
3685 ignore_rest_of_line (void)
3687 while (input_line_pointer
< buffer_limit
3688 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3689 input_line_pointer
++;
3691 input_line_pointer
++;
3693 /* Return pointing just after end-of-line. */
3694 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3697 /* Sets frag for given symbol to zero_address_frag, except when the
3698 symbol frag is already set to a dummy listing frag. */
3701 set_zero_frag (symbolS
*symbolP
)
3703 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3704 symbol_set_frag (symbolP
, &zero_address_frag
);
3707 /* In: Pointer to a symbol.
3708 Input_line_pointer->expression.
3710 Out: Input_line_pointer->just after any whitespace after expression.
3711 Tried to set symbol to value of expression.
3712 Will change symbols type, value, and frag; */
3715 pseudo_set (symbolS
*symbolP
)
3720 know (symbolP
); /* NULL pointer is logic error. */
3722 if (!S_IS_FORWARD_REF (symbolP
))
3723 (void) expression (&exp
);
3725 (void) deferred_expression (&exp
);
3727 if (exp
.X_op
== O_illegal
)
3728 as_bad (_("illegal expression"));
3729 else if (exp
.X_op
== O_absent
)
3730 as_bad (_("missing expression"));
3731 else if (exp
.X_op
== O_big
)
3733 if (exp
.X_add_number
> 0)
3734 as_bad (_("bignum invalid"));
3736 as_bad (_("floating point number invalid"));
3738 else if (exp
.X_op
== O_subtract
3739 && !S_IS_FORWARD_REF (symbolP
)
3740 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3741 && (symbol_get_frag (exp
.X_add_symbol
)
3742 == symbol_get_frag (exp
.X_op_symbol
)))
3744 exp
.X_op
= O_constant
;
3745 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3746 - S_GET_VALUE (exp
.X_op_symbol
));
3749 if (symbol_section_p (symbolP
))
3751 as_bad ("attempt to set value of section symbol");
3760 exp
.X_add_number
= 0;
3763 S_SET_SEGMENT (symbolP
, absolute_section
);
3764 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3765 set_zero_frag (symbolP
);
3769 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3770 if (S_IS_EXTERNAL (symbolP
))
3772 as_bad ("can't equate global symbol `%s' with register name",
3773 S_GET_NAME (symbolP
));
3777 S_SET_SEGMENT (symbolP
, reg_section
);
3778 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3779 set_zero_frag (symbolP
);
3780 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3784 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3785 /* For x=undef+const, create an expression symbol.
3786 For x=x+const, just update x except when x is an undefined symbol
3787 For x=defined+const, evaluate x. */
3788 if (symbolP
== exp
.X_add_symbol
3789 && (seg
!= undefined_section
3790 || !symbol_constant_p (symbolP
)))
3792 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3795 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3797 symbolS
*s
= exp
.X_add_symbol
;
3799 if (S_IS_COMMON (s
))
3800 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3801 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3803 S_SET_SEGMENT (symbolP
, seg
);
3804 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3805 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3806 copy_symbol_attributes (symbolP
, s
);
3809 S_SET_SEGMENT (symbolP
, undefined_section
);
3810 symbol_set_value_expression (symbolP
, &exp
);
3811 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3812 set_zero_frag (symbolP
);
3816 /* The value is some complex expression. */
3817 S_SET_SEGMENT (symbolP
, expr_section
);
3818 symbol_set_value_expression (symbolP
, &exp
);
3819 set_zero_frag (symbolP
);
3826 CONStruct more frag of .bytes, or .words etc.
3827 Should need_pass_2 be 1 then emit no frag(s).
3828 This understands EXPRESSIONS.
3832 This has a split personality. We use expression() to read the
3833 value. We can detect if the value won't fit in a byte or word.
3834 But we can't detect if expression() discarded significant digits
3835 in the case of a long. Not worth the crocks required to fix it. */
3837 /* Select a parser for cons expressions. */
3839 /* Some targets need to parse the expression in various fancy ways.
3840 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3841 (for example, the HPPA does this). Otherwise, you can define
3842 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3843 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3844 are defined, which is the normal case, then only simple expressions
3849 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3852 #ifndef TC_PARSE_CONS_EXPRESSION
3853 #ifdef BITFIELD_CONS_EXPRESSIONS
3854 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3856 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3858 #ifdef REPEAT_CONS_EXPRESSIONS
3859 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3861 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3864 /* If we haven't gotten one yet, just call expression. */
3865 #ifndef TC_PARSE_CONS_EXPRESSION
3866 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3871 do_parse_cons_expression (expressionS
*exp
,
3872 int nbytes ATTRIBUTE_UNUSED
)
3874 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3878 /* Worker to do .byte etc statements.
3879 Clobbers input_line_pointer and checks end-of-line. */
3882 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3890 #ifdef md_flush_pending_output
3891 md_flush_pending_output ();
3895 stop
= mri_comment_field (&stopc
);
3897 if (is_it_end_of_statement ())
3899 demand_empty_rest_of_line ();
3901 mri_comment_end (stop
, stopc
);
3905 #ifdef TC_ADDRESS_BYTES
3907 nbytes
= TC_ADDRESS_BYTES ();
3910 #ifdef md_cons_align
3911 md_cons_align (nbytes
);
3919 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3923 if (*input_line_pointer
== '"')
3925 as_bad (_("unexpected `\"' in expression"));
3926 ignore_rest_of_line ();
3929 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3934 if (exp
.X_op
== O_symbol
)
3935 exp
.X_op
= O_symbol_rva
;
3937 as_fatal (_("rva without symbol"));
3939 emit_expr (&exp
, (unsigned int) nbytes
);
3942 while (*input_line_pointer
++ == ',');
3944 /* In MRI mode, after an odd number of bytes, we must align to an
3945 even word boundary, unless the next instruction is a dc.b, ds.b
3947 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3948 mri_pending_align
= 1;
3950 input_line_pointer
--; /* Put terminator back into stream. */
3952 demand_empty_rest_of_line ();
3955 mri_comment_end (stop
, stopc
);
3961 cons_worker (size
, 0);
3967 cons_worker (size
, 1);
3970 /* .reloc offset, reloc_name, symbol+addend. */
3973 s_reloc (int ignore ATTRIBUTE_UNUSED
)
3980 struct reloc_list
*reloc
;
3982 reloc
= (struct reloc_list
*) xmalloc (sizeof (*reloc
));
3985 stop
= mri_comment_field (&stopc
);
3994 as_bad (_("missing or bad offset expression"));
3997 exp
.X_add_symbol
= section_symbol (now_seg
);
3998 exp
.X_op
= O_symbol
;
4001 if (exp
.X_add_number
== 0)
4003 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4008 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4013 if (*input_line_pointer
!= ',')
4015 as_bad (_("missing reloc type"));
4019 ++input_line_pointer
;
4021 r_name
= input_line_pointer
;
4022 c
= get_symbol_end ();
4023 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4024 *input_line_pointer
= c
;
4025 if (reloc
->u
.a
.howto
== NULL
)
4027 as_bad (_("unrecognized reloc type"));
4031 exp
.X_op
= O_absent
;
4033 if (*input_line_pointer
== ',')
4035 ++input_line_pointer
;
4043 as_bad (_("bad reloc expression"));
4045 ignore_rest_of_line ();
4048 mri_comment_end (stop
, stopc
);
4051 reloc
->u
.a
.sym
= NULL
;
4052 reloc
->u
.a
.addend
= 0;
4055 reloc
->u
.a
.sym
= NULL
;
4056 reloc
->u
.a
.addend
= exp
.X_add_number
;
4059 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4060 reloc
->u
.a
.addend
= exp
.X_add_number
;
4063 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4064 reloc
->u
.a
.addend
= 0;
4068 as_where (&reloc
->file
, &reloc
->line
);
4069 reloc
->next
= reloc_list
;
4072 demand_empty_rest_of_line ();
4074 mri_comment_end (stop
, stopc
);
4077 /* Put the contents of expression EXP into the object file using
4078 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4081 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4085 valueT extra_digit
= 0;
4087 /* Don't do anything if we are going to make another pass. */
4092 dot_value
= frag_now_fix ();
4093 dot_frag
= frag_now
;
4097 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4098 appear as a four byte positive constant in the .line section,
4099 followed by a 2 byte 0xffff. Look for that case here. */
4101 static int dwarf_line
= -1;
4103 if (strcmp (segment_name (now_seg
), ".line") != 0)
4105 else if (dwarf_line
>= 0
4107 && exp
->X_op
== O_constant
4108 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4109 listing_source_line ((unsigned int) dwarf_line
);
4110 else if (nbytes
== 4
4111 && exp
->X_op
== O_constant
4112 && exp
->X_add_number
>= 0)
4113 dwarf_line
= exp
->X_add_number
;
4118 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4119 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4120 AT_sibling (0x12) followed by a four byte address of the sibling
4121 followed by a 2 byte AT_name (0x38) followed by the name of the
4122 file. We look for that case here. */
4124 static int dwarf_file
= 0;
4126 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4128 else if (dwarf_file
== 0
4130 && exp
->X_op
== O_constant
4131 && exp
->X_add_number
== 0x11)
4133 else if (dwarf_file
== 1
4135 && exp
->X_op
== O_constant
4136 && exp
->X_add_number
== 0x12)
4138 else if (dwarf_file
== 2
4141 else if (dwarf_file
== 3
4143 && exp
->X_op
== O_constant
4144 && exp
->X_add_number
== 0x38)
4149 /* The variable dwarf_file_string tells stringer that the string
4150 may be the name of the source file. */
4151 if (dwarf_file
== 4)
4152 dwarf_file_string
= 1;
4154 dwarf_file_string
= 0;
4159 if (check_eh_frame (exp
, &nbytes
))
4164 /* Allow `.word 0' in the absolute section. */
4165 if (now_seg
== absolute_section
)
4167 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4168 as_bad (_("attempt to store value in absolute section"));
4169 abs_section_offset
+= nbytes
;
4173 /* Handle a negative bignum. */
4175 && exp
->X_add_number
== 0
4176 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4177 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4180 unsigned long carry
;
4182 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4184 /* Negate the bignum: one's complement each digit and add 1. */
4186 for (i
= 0; i
< exp
->X_add_number
; i
++)
4190 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4193 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4194 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4197 /* We can ignore any carry out, because it will be handled by
4198 extra_digit if it is needed. */
4200 extra_digit
= (valueT
) -1;
4204 if (op
== O_absent
|| op
== O_illegal
)
4206 as_warn (_("zero assumed for missing expression"));
4207 exp
->X_add_number
= 0;
4210 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4212 as_bad (_("floating point number invalid"));
4213 exp
->X_add_number
= 0;
4216 else if (op
== O_register
)
4218 as_warn (_("register value used as expression"));
4222 p
= frag_more ((int) nbytes
);
4224 #ifndef WORKING_DOT_WORD
4225 /* If we have the difference of two symbols in a word, save it on
4226 the broken_words list. See the code in write.c. */
4227 if (op
== O_subtract
&& nbytes
== 2)
4229 struct broken_word
*x
;
4231 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
4232 x
->next_broken_word
= broken_words
;
4235 x
->subseg
= now_subseg
;
4237 x
->word_goes_here
= p
;
4239 x
->add
= exp
->X_add_symbol
;
4240 x
->sub
= exp
->X_op_symbol
;
4241 x
->addnum
= exp
->X_add_number
;
4249 /* If we have an integer, but the number of bytes is too large to
4250 pass to md_number_to_chars, handle it as a bignum. */
4251 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4253 extra_digit
= exp
->X_unsigned
? 0 : -1;
4254 convert_to_bignum (exp
, !exp
->X_unsigned
);
4258 if (op
== O_constant
)
4266 /* JF << of >= number of bits in the object is undefined. In
4267 particular SPARC (Sun 4) has problems. */
4268 if (nbytes
>= sizeof (valueT
))
4271 if (nbytes
> sizeof (valueT
))
4274 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4278 /* Don't store these bits. */
4279 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4280 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4283 unmask
= ~mask
; /* Do store these bits. */
4286 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4287 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4290 get
= exp
->X_add_number
;
4292 if ((get
& mask
) != 0
4293 && ((get
& mask
) != mask
4294 || (get
& hibit
) == 0))
4295 { /* Leading bits contain both 0s & 1s. */
4296 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4298 as_warn (_("value 0x%llx truncated to 0x%llx"),
4299 (unsigned long long) get
, (unsigned long long) use
);
4301 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4302 (unsigned long long) get
, (unsigned long long) use
);
4305 as_warn (_("value 0x%lx truncated to 0x%lx"),
4306 (unsigned long) get
, (unsigned long) use
);
4309 /* Put bytes in right order. */
4310 md_number_to_chars (p
, use
, (int) nbytes
);
4312 else if (op
== O_big
)
4315 LITTLENUM_TYPE
*nums
;
4317 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4320 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4323 LITTLENUM_TYPE sign
= 0;
4324 if ((generic_bignum
[--i
]
4325 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4326 sign
= ~(LITTLENUM_TYPE
) 0;
4327 while (++i
< exp
->X_add_number
)
4328 if (generic_bignum
[i
] != sign
)
4331 if (i
< exp
->X_add_number
)
4332 as_warn (_("bignum truncated to %d bytes"), nbytes
);
4338 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4341 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4343 if (target_big_endian
)
4345 while (nbytes
> size
)
4347 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4348 nbytes
-= CHARS_PER_LITTLENUM
;
4349 p
+= CHARS_PER_LITTLENUM
;
4352 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4353 while (size
>= CHARS_PER_LITTLENUM
)
4356 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4357 size
-= CHARS_PER_LITTLENUM
;
4358 p
+= CHARS_PER_LITTLENUM
;
4363 nums
= generic_bignum
;
4364 while (size
>= CHARS_PER_LITTLENUM
)
4366 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4368 size
-= CHARS_PER_LITTLENUM
;
4369 p
+= CHARS_PER_LITTLENUM
;
4370 nbytes
-= CHARS_PER_LITTLENUM
;
4373 while (nbytes
>= CHARS_PER_LITTLENUM
)
4375 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4376 nbytes
-= CHARS_PER_LITTLENUM
;
4377 p
+= CHARS_PER_LITTLENUM
;
4382 emit_expr_fix (exp
, nbytes
, frag_now
, p
);
4386 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
)
4388 memset (p
, 0, nbytes
);
4390 /* Generate a fixS to record the symbol value. */
4392 #ifdef TC_CONS_FIX_NEW
4393 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
, nbytes
, exp
);
4396 bfd_reloc_code_real_type r
;
4416 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
4420 fix_new_exp (frag
, p
- frag
->fr_literal
, (int) nbytes
, exp
,
4426 #ifdef BITFIELD_CONS_EXPRESSIONS
4428 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4429 w:x,y:z, where w and y are bitwidths and x and y are values. They
4430 then pack them all together. We do a little better in that we allow
4431 them in words, longs, etc. and we'll pack them in target byte order
4434 The rules are: pack least significant bit first, if a field doesn't
4435 entirely fit, put it in the next unit. Overflowing the bitfield is
4436 explicitly *not* even a warning. The bitwidth should be considered
4439 To use this function the tc-XXX.h file should define
4440 BITFIELD_CONS_EXPRESSIONS. */
4443 parse_bitfield_cons (exp
, nbytes
)
4445 unsigned int nbytes
;
4447 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4448 char *hold
= input_line_pointer
;
4450 (void) expression (exp
);
4452 if (*input_line_pointer
== ':')
4459 unsigned long width
;
4461 if (*input_line_pointer
!= ':')
4463 input_line_pointer
= hold
;
4465 } /* Next piece is not a bitfield. */
4467 /* In the general case, we can't allow
4468 full expressions with symbol
4469 differences and such. The relocation
4470 entries for symbols not defined in this
4471 assembly would require arbitrary field
4472 widths, positions, and masks which most
4473 of our current object formats don't
4476 In the specific case where a symbol
4477 *is* defined in this assembly, we
4478 *could* build fixups and track it, but
4479 this could lead to confusion for the
4480 backends. I'm lazy. I'll take any
4481 SEG_ABSOLUTE. I think that means that
4482 you can use a previous .set or
4483 .equ type symbol. xoxorich. */
4485 if (exp
->X_op
== O_absent
)
4487 as_warn (_("using a bit field width of zero"));
4488 exp
->X_add_number
= 0;
4489 exp
->X_op
= O_constant
;
4490 } /* Implied zero width bitfield. */
4492 if (exp
->X_op
!= O_constant
)
4494 *input_line_pointer
= '\0';
4495 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4496 *input_line_pointer
= ':';
4497 demand_empty_rest_of_line ();
4499 } /* Too complex. */
4501 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4503 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4504 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4505 width
= BITS_PER_CHAR
* nbytes
;
4508 if (width
> bits_available
)
4510 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4511 input_line_pointer
= hold
;
4512 exp
->X_add_number
= value
;
4517 hold
= ++input_line_pointer
;
4519 (void) expression (exp
);
4520 if (exp
->X_op
!= O_constant
)
4522 char cache
= *input_line_pointer
;
4524 *input_line_pointer
= '\0';
4525 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4526 *input_line_pointer
= cache
;
4527 demand_empty_rest_of_line ();
4529 } /* Too complex. */
4531 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4532 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4534 if ((bits_available
-= width
) == 0
4535 || is_it_end_of_statement ()
4536 || *input_line_pointer
!= ',')
4539 } /* All the bitfields we're gonna get. */
4541 hold
= ++input_line_pointer
;
4542 (void) expression (exp
);
4545 exp
->X_add_number
= value
;
4546 exp
->X_op
= O_constant
;
4547 exp
->X_unsigned
= 1;
4548 exp
->X_extrabit
= 0;
4552 #endif /* BITFIELD_CONS_EXPRESSIONS */
4554 /* Handle an MRI style string expression. */
4558 parse_mri_cons (exp
, nbytes
)
4560 unsigned int nbytes
;
4562 if (*input_line_pointer
!= '\''
4563 && (input_line_pointer
[1] != '\''
4564 || (*input_line_pointer
!= 'A'
4565 && *input_line_pointer
!= 'E')))
4566 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4570 unsigned int result
= 0;
4572 /* An MRI style string. Cut into as many bytes as will fit into
4573 a nbyte chunk, left justify if necessary, and separate with
4574 commas so we can try again later. */
4575 if (*input_line_pointer
== 'A')
4576 ++input_line_pointer
;
4577 else if (*input_line_pointer
== 'E')
4579 as_bad (_("EBCDIC constants are not supported"));
4580 ++input_line_pointer
;
4583 input_line_pointer
++;
4584 for (scan
= 0; scan
< nbytes
; scan
++)
4586 if (*input_line_pointer
== '\'')
4588 if (input_line_pointer
[1] == '\'')
4590 input_line_pointer
++;
4595 result
= (result
<< 8) | (*input_line_pointer
++);
4599 while (scan
< nbytes
)
4605 /* Create correct expression. */
4606 exp
->X_op
= O_constant
;
4607 exp
->X_add_number
= result
;
4609 /* Fake it so that we can read the next char too. */
4610 if (input_line_pointer
[0] != '\'' ||
4611 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4613 input_line_pointer
-= 2;
4614 input_line_pointer
[0] = ',';
4615 input_line_pointer
[1] = '\'';
4618 input_line_pointer
++;
4621 #endif /* TC_M68K */
4623 #ifdef REPEAT_CONS_EXPRESSIONS
4625 /* Parse a repeat expression for cons. This is used by the MIPS
4626 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4627 object file COUNT times.
4629 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4632 parse_repeat_cons (exp
, nbytes
)
4634 unsigned int nbytes
;
4641 if (*input_line_pointer
!= ':')
4643 /* No repeat count. */
4647 ++input_line_pointer
;
4648 expression (&count
);
4649 if (count
.X_op
!= O_constant
4650 || count
.X_add_number
<= 0)
4652 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4656 /* The cons function is going to output this expression once. So we
4657 output it count - 1 times. */
4658 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4659 emit_expr (exp
, nbytes
);
4662 #endif /* REPEAT_CONS_EXPRESSIONS */
4664 /* Parse a floating point number represented as a hex constant. This
4665 permits users to specify the exact bits they want in the floating
4669 hex_float (int float_type
, char *bytes
)
4701 as_bad (_("unknown floating type type '%c'"), float_type
);
4705 /* It would be nice if we could go through expression to parse the
4706 hex constant, but if we get a bignum it's a pain to sort it into
4707 the buffer correctly. */
4709 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4713 /* The MRI assembler accepts arbitrary underscores strewn about
4714 through the hex constant, so we ignore them as well. */
4715 if (*input_line_pointer
== '_')
4717 ++input_line_pointer
;
4723 as_warn (_("floating point constant too large"));
4726 d
= hex_value (*input_line_pointer
) << 4;
4727 ++input_line_pointer
;
4728 while (*input_line_pointer
== '_')
4729 ++input_line_pointer
;
4730 if (hex_p (*input_line_pointer
))
4732 d
+= hex_value (*input_line_pointer
);
4733 ++input_line_pointer
;
4735 if (target_big_endian
)
4738 bytes
[length
- i
- 1] = d
;
4744 if (target_big_endian
)
4745 memset (bytes
+ i
, 0, length
- i
);
4747 memset (bytes
, 0, length
- i
);
4755 CONStruct some more frag chars of .floats .ffloats etc.
4756 Makes 0 or more new frags.
4757 If need_pass_2 == 1, no frags are emitted.
4758 This understands only floating literals, not expressions. Sorry.
4760 A floating constant is defined by atof_generic(), except it is preceded
4761 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4762 reading, I decided to be incompatible. This always tries to give you
4763 rounded bits to the precision of the pseudo-op. Former AS did premature
4764 truncation, restored noisy bits instead of trailing 0s AND gave you
4765 a choice of 2 flavours of noise according to which of 2 floating-point
4766 scanners you directed AS to use.
4768 In: input_line_pointer->whitespace before, or '0' of flonum. */
4771 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4772 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4775 int length
; /* Number of chars in an object. */
4776 char *err
; /* Error from scanning floating literal. */
4777 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4779 if (is_it_end_of_statement ())
4781 demand_empty_rest_of_line ();
4785 #ifdef md_flush_pending_output
4786 md_flush_pending_output ();
4789 #ifdef md_cons_align
4795 /* input_line_pointer->1st char of a flonum (we hope!). */
4798 /* Skip any 0{letter} that may be present. Don't even check if the
4799 letter is legal. Someone may invent a "z" format and this routine
4800 has no use for such information. Lusers beware: you get
4801 diagnostics if your input is ill-conditioned. */
4802 if (input_line_pointer
[0] == '0'
4803 && ISALPHA (input_line_pointer
[1]))
4804 input_line_pointer
+= 2;
4806 /* Accept :xxxx, where the x's are hex digits, for a floating
4807 point with the exact digits specified. */
4808 if (input_line_pointer
[0] == ':')
4810 ++input_line_pointer
;
4811 length
= hex_float (float_type
, temp
);
4814 ignore_rest_of_line ();
4820 err
= md_atof (float_type
, temp
, &length
);
4821 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4822 know (err
!= NULL
|| length
> 0);
4825 as_bad (_("bad floating literal: %s"), err
);
4826 ignore_rest_of_line ();
4837 #ifdef REPEAT_CONS_EXPRESSIONS
4838 if (*input_line_pointer
== ':')
4840 expressionS count_exp
;
4842 ++input_line_pointer
;
4843 expression (&count_exp
);
4845 if (count_exp
.X_op
!= O_constant
4846 || count_exp
.X_add_number
<= 0)
4847 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4849 count
= count_exp
.X_add_number
;
4853 while (--count
>= 0)
4855 p
= frag_more (length
);
4856 memcpy (p
, temp
, (unsigned int) length
);
4861 while (*input_line_pointer
++ == ',');
4863 /* Put terminator back into stream. */
4864 --input_line_pointer
;
4865 demand_empty_rest_of_line ();
4868 /* Return the size of a LEB128 value. */
4871 sizeof_sleb128 (offsetT value
)
4878 byte
= (value
& 0x7f);
4879 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4880 Fortunately, we can structure things so that the extra work reduces
4881 to a noop on systems that do things "properly". */
4882 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4885 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4886 || ((value
== -1) && ((byte
& 0x40) != 0))));
4892 sizeof_uleb128 (valueT value
)
4907 sizeof_leb128 (valueT value
, int sign
)
4910 return sizeof_sleb128 ((offsetT
) value
);
4912 return sizeof_uleb128 (value
);
4915 /* Output a LEB128 value. */
4918 output_sleb128 (char *p
, offsetT value
)
4925 unsigned byte
= (value
& 0x7f);
4927 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4928 Fortunately, we can structure things so that the extra work reduces
4929 to a noop on systems that do things "properly". */
4930 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4932 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4933 || ((value
== -1) && ((byte
& 0x40) != 0))));
4945 output_uleb128 (char *p
, valueT value
)
4951 unsigned byte
= (value
& 0x7f);
4954 /* More bytes to follow. */
4965 output_leb128 (char *p
, valueT value
, int sign
)
4968 return output_sleb128 (p
, (offsetT
) value
);
4970 return output_uleb128 (p
, value
);
4973 /* Do the same for bignums. We combine sizeof with output here in that
4974 we don't output for NULL values of P. It isn't really as critical as
4975 for "normal" values that this be streamlined. */
4978 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4985 /* Strip leading sign extensions off the bignum. */
4987 && bignum
[size
- 1] == LITTLENUM_MASK
4988 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
4993 /* OR in the next part of the littlenum. */
4994 val
|= (*bignum
<< loaded
);
4995 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
4999 /* Add bytes until there are less than 7 bits left in VAL
5000 or until every non-sign bit has been written. */
5007 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5014 while ((byte
& 0x80) != 0 && loaded
>= 7);
5018 /* Mop up any left-over bits (of which there will be less than 7). */
5019 if ((byte
& 0x80) != 0)
5021 /* Sign-extend VAL. */
5022 if (val
& (1 << (loaded
- 1)))
5023 val
|= ~0 << loaded
;
5033 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
5040 /* Strip leading zeros off the bignum. */
5041 /* XXX: Is this needed? */
5042 while (size
> 0 && bignum
[size
- 1] == 0)
5047 if (loaded
< 7 && size
> 0)
5049 val
|= (*bignum
<< loaded
);
5050 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5059 if (size
> 0 || val
)
5066 while (byte
& 0x80);
5072 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
5075 return output_big_sleb128 (p
, bignum
, size
);
5077 return output_big_uleb128 (p
, bignum
, size
);
5080 /* Generate the appropriate fragments for a given expression to emit a
5084 emit_leb128_expr (expressionS
*exp
, int sign
)
5086 operatorT op
= exp
->X_op
;
5087 unsigned int nbytes
;
5089 if (op
== O_absent
|| op
== O_illegal
)
5091 as_warn (_("zero assumed for missing expression"));
5092 exp
->X_add_number
= 0;
5095 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5097 as_bad (_("floating point number invalid"));
5098 exp
->X_add_number
= 0;
5101 else if (op
== O_register
)
5103 as_warn (_("register value used as expression"));
5106 else if (op
== O_constant
5108 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5110 /* We're outputting a signed leb128 and the sign of X_add_number
5111 doesn't reflect the sign of the original value. Convert EXP
5112 to a correctly-extended bignum instead. */
5113 convert_to_bignum (exp
, exp
->X_extrabit
);
5117 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5118 a signal that this is leb128 data. It shouldn't optimize this away. */
5119 nbytes
= (unsigned int) -1;
5120 if (check_eh_frame (exp
, &nbytes
))
5123 /* Let the backend know that subsequent data may be byte aligned. */
5124 #ifdef md_cons_align
5128 if (op
== O_constant
)
5130 /* If we've got a constant, emit the thing directly right now. */
5132 valueT value
= exp
->X_add_number
;
5136 size
= sizeof_leb128 (value
, sign
);
5137 p
= frag_more (size
);
5138 output_leb128 (p
, value
, sign
);
5140 else if (op
== O_big
)
5142 /* O_big is a different sort of constant. */
5147 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
5148 p
= frag_more (size
);
5149 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
5153 /* Otherwise, we have to create a variable sized fragment and
5154 resolve things later. */
5156 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5157 make_expr_symbol (exp
), 0, (char *) NULL
);
5161 /* Parse the .sleb128 and .uleb128 pseudos. */
5168 #ifdef md_flush_pending_output
5169 md_flush_pending_output ();
5175 emit_leb128_expr (&exp
, sign
);
5177 while (*input_line_pointer
++ == ',');
5179 input_line_pointer
--;
5180 demand_empty_rest_of_line ();
5184 stringer_append_char (int c
, int bitsize
)
5186 if (!target_big_endian
)
5187 FRAG_APPEND_1_CHAR (c
);
5192 FRAG_APPEND_1_CHAR (0);
5193 FRAG_APPEND_1_CHAR (0);
5194 FRAG_APPEND_1_CHAR (0);
5195 FRAG_APPEND_1_CHAR (0);
5198 FRAG_APPEND_1_CHAR (0);
5199 FRAG_APPEND_1_CHAR (0);
5202 FRAG_APPEND_1_CHAR (0);
5207 /* Called with invalid bitsize argument. */
5211 if (target_big_endian
)
5212 FRAG_APPEND_1_CHAR (c
);
5215 /* Worker to do .ascii etc statements.
5216 Reads 0 or more ',' separated, double-quoted strings.
5217 Caller should have checked need_pass_2 is FALSE because we don't
5219 Checks for end-of-line.
5220 BITS_APPENDZERO says how many bits are in a target char.
5221 The bottom bit is set if a NUL char should be appended to the strings. */
5224 stringer (int bits_appendzero
)
5226 const int bitsize
= bits_appendzero
& ~7;
5227 const int append_zero
= bits_appendzero
& 1;
5229 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5233 #ifdef md_flush_pending_output
5234 md_flush_pending_output ();
5237 #ifdef md_cons_align
5241 /* The following awkward logic is to parse ZERO or more strings,
5242 comma separated. Recall a string expression includes spaces
5243 before the opening '\"' and spaces after the closing '\"'.
5244 We fake a leading ',' if there is (supposed to be)
5245 a 1st, expression. We keep demanding expressions for each ','. */
5246 if (is_it_end_of_statement ())
5248 c
= 0; /* Skip loop. */
5249 ++input_line_pointer
; /* Compensate for end of loop. */
5253 c
= ','; /* Do loop. */
5255 /* If we have been switched into the abs_section then we
5256 will not have an obstack onto which we can hang strings. */
5257 if (now_seg
== absolute_section
)
5259 as_bad (_("strings must be placed into a section"));
5261 ignore_rest_of_line ();
5264 while (c
== ',' || c
== '<' || c
== '"')
5267 switch (*input_line_pointer
)
5270 ++input_line_pointer
; /*->1st char of string. */
5271 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5272 start
= input_line_pointer
;
5275 while (is_a_char (c
= next_char_of_string ()))
5276 stringer_append_char (c
, bitsize
);
5279 stringer_append_char (0, bitsize
);
5281 know (input_line_pointer
[-1] == '\"');
5283 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5284 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5285 will emit .string with a filename in the .debug section
5286 after a sequence of constants. See the comment in
5287 emit_expr for the sequence. emit_expr will set
5288 dwarf_file_string to non-zero if this string might be a
5289 source file name. */
5290 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5291 dwarf_file_string
= 0;
5292 else if (dwarf_file_string
)
5294 c
= input_line_pointer
[-1];
5295 input_line_pointer
[-1] = '\0';
5296 listing_source_file (start
);
5297 input_line_pointer
[-1] = c
;
5303 input_line_pointer
++;
5304 c
= get_single_number ();
5305 stringer_append_char (c
, bitsize
);
5306 if (*input_line_pointer
!= '>')
5307 as_bad (_("expected <nn>"));
5309 input_line_pointer
++;
5312 input_line_pointer
++;
5316 c
= *input_line_pointer
;
5319 demand_empty_rest_of_line ();
5322 /* FIXME-SOMEDAY: I had trouble here on characters with the
5323 high bits set. We'll probably also have trouble with
5324 multibyte chars, wide chars, etc. Also be careful about
5325 returning values bigger than 1 byte. xoxorich. */
5328 next_char_of_string (void)
5332 c
= *input_line_pointer
++ & CHAR_MASK
;
5340 as_warn (_("unterminated string; newline inserted"));
5341 bump_line_counters ();
5344 #ifndef NO_STRING_ESCAPES
5346 switch (c
= *input_line_pointer
++)
5374 break; /* As itself. */
5390 for (i
= 0, number
= 0;
5391 ISDIGIT (c
) && i
< 3;
5392 c
= *input_line_pointer
++, i
++)
5394 number
= number
* 8 + c
- '0';
5399 --input_line_pointer
;
5408 c
= *input_line_pointer
++;
5409 while (ISXDIGIT (c
))
5412 number
= number
* 16 + c
- '0';
5413 else if (ISUPPER (c
))
5414 number
= number
* 16 + c
- 'A' + 10;
5416 number
= number
* 16 + c
- 'a' + 10;
5417 c
= *input_line_pointer
++;
5420 --input_line_pointer
;
5425 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5426 as_warn (_("unterminated string; newline inserted"));
5428 bump_line_counters ();
5433 #ifdef ONLY_STANDARD_ESCAPES
5434 as_bad (_("bad escaped character in string"));
5436 #endif /* ONLY_STANDARD_ESCAPES */
5441 #endif /* ! defined (NO_STRING_ESCAPES) */
5450 get_segmented_expression (expressionS
*expP
)
5454 retval
= expression (expP
);
5455 if (expP
->X_op
== O_illegal
5456 || expP
->X_op
== O_absent
5457 || expP
->X_op
== O_big
)
5459 as_bad (_("expected address expression"));
5460 expP
->X_op
= O_constant
;
5461 expP
->X_add_number
= 0;
5462 retval
= absolute_section
;
5468 get_known_segmented_expression (expressionS
*expP
)
5470 segT retval
= get_segmented_expression (expP
);
5472 if (retval
== undefined_section
)
5474 /* There is no easy way to extract the undefined symbol from the
5476 if (expP
->X_add_symbol
!= NULL
5477 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5478 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5479 S_GET_NAME (expP
->X_add_symbol
));
5481 as_warn (_("some symbol undefined; zero assumed"));
5482 retval
= absolute_section
;
5483 expP
->X_op
= O_constant
;
5484 expP
->X_add_number
= 0;
5489 char /* Return terminator. */
5490 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5492 /* FIXME: val_pointer should probably be offsetT *. */
5493 *val_pointer
= (long) get_absolute_expression ();
5494 return (*input_line_pointer
++);
5497 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5498 Give a warning if that happens. */
5501 demand_copy_C_string (int *len_pointer
)
5505 if ((s
= demand_copy_string (len_pointer
)) != 0)
5509 for (len
= *len_pointer
; len
> 0; len
--)
5516 as_bad (_("this string may not contain \'\\0\'"));
5524 /* Demand string, but return a safe (=private) copy of the string.
5525 Return NULL if we can't read a string here. */
5528 demand_copy_string (int *lenP
)
5536 if (*input_line_pointer
== '\"')
5538 input_line_pointer
++; /* Skip opening quote. */
5540 while (is_a_char (c
= next_char_of_string ()))
5542 obstack_1grow (¬es
, c
);
5545 /* JF this next line is so demand_copy_C_string will return a
5546 null terminated string. */
5547 obstack_1grow (¬es
, '\0');
5548 retval
= (char *) obstack_finish (¬es
);
5552 as_bad (_("missing string"));
5554 ignore_rest_of_line ();
5560 /* In: Input_line_pointer->next character.
5562 Do: Skip input_line_pointer over all whitespace.
5564 Out: 1 if input_line_pointer->end-of-line. */
5567 is_it_end_of_statement (void)
5570 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5574 equals (char *sym_name
, int reassign
)
5579 input_line_pointer
++;
5580 if (*input_line_pointer
== '=')
5581 input_line_pointer
++;
5582 if (reassign
< 0 && *input_line_pointer
== '=')
5583 input_line_pointer
++;
5585 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5586 input_line_pointer
++;
5589 stop
= mri_comment_field (&stopc
);
5591 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5595 demand_empty_rest_of_line ();
5596 mri_comment_end (stop
, stopc
);
5600 /* .incbin -- include a file verbatim at the current location. */
5603 s_incbin (int x ATTRIBUTE_UNUSED
)
5614 #ifdef md_flush_pending_output
5615 md_flush_pending_output ();
5618 #ifdef md_cons_align
5623 filename
= demand_copy_string (& len
);
5624 if (filename
== NULL
)
5629 /* Look for optional skip and count. */
5630 if (* input_line_pointer
== ',')
5632 ++ input_line_pointer
;
5633 skip
= get_absolute_expression ();
5637 if (* input_line_pointer
== ',')
5639 ++ input_line_pointer
;
5641 count
= get_absolute_expression ();
5643 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5649 demand_empty_rest_of_line ();
5651 /* Try opening absolute path first, then try include dirs. */
5652 binfile
= fopen (filename
, FOPEN_RB
);
5653 if (binfile
== NULL
)
5657 path
= (char *) xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5659 for (i
= 0; i
< include_dir_count
; i
++)
5661 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5663 binfile
= fopen (path
, FOPEN_RB
);
5664 if (binfile
!= NULL
)
5668 if (binfile
== NULL
)
5669 as_bad (_("file not found: %s"), filename
);
5672 path
= xstrdup (filename
);
5678 register_dependency (path
);
5680 /* Compute the length of the file. */
5681 if (fseek (binfile
, 0, SEEK_END
) != 0)
5683 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5686 file_len
= ftell (binfile
);
5688 /* If a count was not specified use the remainder of the file. */
5690 count
= file_len
- skip
;
5692 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5694 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5695 skip
, count
, file_len
);
5699 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5701 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5705 /* Allocate frag space and store file contents in it. */
5706 binfrag
= frag_more (count
);
5708 bytes
= fread (binfrag
, 1, count
, binfile
);
5710 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5711 path
, bytes
, count
);
5714 if (binfile
!= NULL
)
5720 /* .include -- include a file at this point. */
5723 s_include (int arg ATTRIBUTE_UNUSED
)
5732 filename
= demand_copy_string (&i
);
5733 if (filename
== NULL
)
5735 /* demand_copy_string has already printed an error and
5736 called ignore_rest_of_line. */
5744 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5745 && *input_line_pointer
!= ' '
5746 && *input_line_pointer
!= '\t')
5748 obstack_1grow (¬es
, *input_line_pointer
);
5749 ++input_line_pointer
;
5753 obstack_1grow (¬es
, '\0');
5754 filename
= (char *) obstack_finish (¬es
);
5755 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5756 ++input_line_pointer
;
5759 demand_empty_rest_of_line ();
5760 path
= (char *) xmalloc ((unsigned long) i
5761 + include_dir_maxlen
+ 5 /* slop */ );
5763 for (i
= 0; i
< include_dir_count
; i
++)
5765 strcpy (path
, include_dirs
[i
]);
5767 strcat (path
, filename
);
5768 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5778 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5779 register_dependency (path
);
5780 input_scrub_insert_file (path
);
5784 add_include_dir (char *path
)
5788 if (include_dir_count
== 0)
5790 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5791 include_dirs
[0] = "."; /* Current dir. */
5792 include_dir_count
= 2;
5796 include_dir_count
++;
5798 (char **) xrealloc (include_dirs
,
5799 include_dir_count
* sizeof (*include_dirs
));
5802 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5805 if (i
> include_dir_maxlen
)
5806 include_dir_maxlen
= i
;
5809 /* Output debugging information to denote the source file. */
5812 generate_file_debug (void)
5814 if (debug_type
== DEBUG_STABS
)
5815 stabs_generate_asm_file ();
5818 /* Output line number debugging information for the current source line. */
5821 generate_lineno_debug (void)
5825 case DEBUG_UNSPECIFIED
:
5830 stabs_generate_asm_lineno ();
5833 ecoff_generate_asm_lineno ();
5836 /* ??? We could here indicate to dwarf2dbg.c that something
5837 has changed. However, since there is additional backend
5838 support that is required (calling dwarf2_emit_insn), we
5839 let dwarf2dbg.c call as_where on its own. */
5844 /* Output debugging information to mark a function entry point or end point.
5845 END_P is zero for .func, and non-zero for .endfunc. */
5850 do_s_func (end_p
, NULL
);
5853 /* Subroutine of s_func so targets can choose a different default prefix.
5854 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5857 do_s_func (int end_p
, const char *default_prefix
)
5859 /* Record the current function so that we can issue an error message for
5860 misplaced .func,.endfunc, and also so that .endfunc needs no
5862 static char *current_name
;
5863 static char *current_label
;
5867 if (current_name
== NULL
)
5869 as_bad (_("missing .func"));
5870 ignore_rest_of_line ();
5874 if (debug_type
== DEBUG_STABS
)
5875 stabs_generate_asm_endfunc (current_name
, current_label
);
5877 current_name
= current_label
= NULL
;
5882 char delim1
, delim2
;
5884 if (current_name
!= NULL
)
5886 as_bad (_(".endfunc missing for previous .func"));
5887 ignore_rest_of_line ();
5891 name
= input_line_pointer
;
5892 delim1
= get_symbol_end ();
5893 name
= xstrdup (name
);
5894 *input_line_pointer
= delim1
;
5896 if (*input_line_pointer
!= ',')
5900 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5901 as_fatal ("%s", xstrerror (errno
));
5905 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5906 /* Missing entry point, use function's name with the leading
5910 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
5911 as_fatal ("%s", xstrerror (errno
));
5919 ++input_line_pointer
;
5921 label
= input_line_pointer
;
5922 delim2
= get_symbol_end ();
5923 label
= xstrdup (label
);
5924 *input_line_pointer
= delim2
;
5927 if (debug_type
== DEBUG_STABS
)
5928 stabs_generate_asm_func (name
, label
);
5930 current_name
= name
;
5931 current_label
= label
;
5934 demand_empty_rest_of_line ();
5937 #ifdef HANDLE_BUNDLE
5940 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
5942 unsigned int align
= get_absolute_expression ();
5944 demand_empty_rest_of_line ();
5946 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
5947 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
5948 (unsigned int) TC_ALIGN_LIMIT
);
5950 if (bundle_lock_frag
!= NULL
)
5952 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
5956 bundle_align_p2
= align
;
5960 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
5962 demand_empty_rest_of_line ();
5964 if (bundle_align_p2
== 0)
5966 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
5970 if (bundle_lock_depth
== 0)
5972 bundle_lock_frchain
= frchain_now
;
5973 bundle_lock_frag
= start_bundle ();
5975 ++bundle_lock_depth
;
5979 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
5983 demand_empty_rest_of_line ();
5985 if (bundle_lock_frag
== NULL
)
5987 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
5991 gas_assert (bundle_align_p2
> 0);
5993 gas_assert (bundle_lock_depth
> 0);
5994 if (--bundle_lock_depth
> 0)
5997 size
= pending_bundle_size (bundle_lock_frag
);
5999 if (size
> (1U << bundle_align_p2
))
6000 as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
6001 size
, 1 << bundle_align_p2
);
6003 finish_bundle (bundle_lock_frag
, size
);
6005 bundle_lock_frag
= NULL
;
6006 bundle_lock_frchain
= NULL
;
6009 #endif /* HANDLE_BUNDLE */
6012 s_ignore (int arg ATTRIBUTE_UNUSED
)
6014 ignore_rest_of_line ();
6018 read_print_statistics (FILE *file
)
6020 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6023 /* Inserts the given line into the input stream.
6025 This call avoids macro/conditionals nesting checking, since the contents of
6026 the line are assumed to replace the contents of a line already scanned.
6028 An appropriate use of this function would be substitution of input lines when
6029 called by md_start_line_hook(). The given line is assumed to already be
6030 properly scrubbed. */
6033 input_scrub_insert_line (const char *line
)
6036 size_t len
= strlen (line
);
6037 sb_build (&newline
, len
);
6038 sb_add_buffer (&newline
, line
, len
);
6039 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6041 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6044 /* Insert a file into the input stream; the path must resolve to an actual
6045 file; no include path searching or dependency registering is performed. */
6048 input_scrub_insert_file (char *path
)
6050 input_scrub_include_file (path
, input_line_pointer
);
6051 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6054 /* Find the end of a line, considering quotation and escaping of quotes. */
6056 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6057 # define TC_SINGLE_QUOTE_STRINGS 1
6061 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6064 char inquote
= '\0';
6067 while (!is_end_of_line
[(unsigned char) *s
]
6068 || (inquote
&& !ISCNTRL (*s
))
6069 || (inquote
== '\'' && flag_mri
)
6070 #ifdef TC_EOL_IN_INSN
6071 || (insn
&& TC_EOL_IN_INSN (s
))
6073 /* PR 6926: When we are parsing the body of a macro the sequence
6074 \@ is special - it refers to the invocation count. If the @
6075 character happens to be registered as a line-separator character
6076 by the target, then the is_end_of_line[] test above will have
6077 returned true, but we need to ignore the line separating
6078 semantics in this particular case. */
6079 || (in_macro
&& inescape
&& *s
== '@')
6082 if (mri_string
&& *s
== '\'')
6086 else if (*s
== '\\')
6090 #ifdef TC_SINGLE_QUOTE_STRINGS
6091 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6098 as_warn (_("missing closing `%c'"), inquote
);
6100 as_warn (_("stray `\\'"));
6105 find_end_of_line (char *s
, int mri_string
)
6107 return _find_end_of_line (s
, mri_string
, 0, 0);