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) \
3855 (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3857 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3859 #ifdef REPEAT_CONS_EXPRESSIONS
3860 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3861 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3863 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3866 /* If we haven't gotten one yet, just call expression. */
3867 #ifndef TC_PARSE_CONS_EXPRESSION
3868 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3869 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3874 do_parse_cons_expression (expressionS
*exp
,
3875 int nbytes ATTRIBUTE_UNUSED
)
3877 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3881 /* Worker to do .byte etc statements.
3882 Clobbers input_line_pointer and checks end-of-line. */
3885 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3893 #ifdef md_flush_pending_output
3894 md_flush_pending_output ();
3898 stop
= mri_comment_field (&stopc
);
3900 if (is_it_end_of_statement ())
3902 demand_empty_rest_of_line ();
3904 mri_comment_end (stop
, stopc
);
3908 #ifdef TC_ADDRESS_BYTES
3910 nbytes
= TC_ADDRESS_BYTES ();
3913 #ifdef md_cons_align
3914 md_cons_align (nbytes
);
3920 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
3924 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3928 if (*input_line_pointer
== '"')
3930 as_bad (_("unexpected `\"' in expression"));
3931 ignore_rest_of_line ();
3934 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3939 if (exp
.X_op
== O_symbol
)
3940 exp
.X_op
= O_symbol_rva
;
3942 as_fatal (_("rva without symbol"));
3944 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
3947 while (*input_line_pointer
++ == ',');
3949 /* In MRI mode, after an odd number of bytes, we must align to an
3950 even word boundary, unless the next instruction is a dc.b, ds.b
3952 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3953 mri_pending_align
= 1;
3955 input_line_pointer
--; /* Put terminator back into stream. */
3957 demand_empty_rest_of_line ();
3960 mri_comment_end (stop
, stopc
);
3966 cons_worker (size
, 0);
3972 cons_worker (size
, 1);
3975 /* .reloc offset, reloc_name, symbol+addend. */
3978 s_reloc (int ignore ATTRIBUTE_UNUSED
)
3985 struct reloc_list
*reloc
;
3987 reloc
= (struct reloc_list
*) xmalloc (sizeof (*reloc
));
3990 stop
= mri_comment_field (&stopc
);
3999 as_bad (_("missing or bad offset expression"));
4002 exp
.X_add_symbol
= section_symbol (now_seg
);
4003 exp
.X_op
= O_symbol
;
4006 if (exp
.X_add_number
== 0)
4008 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4013 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4018 if (*input_line_pointer
!= ',')
4020 as_bad (_("missing reloc type"));
4024 ++input_line_pointer
;
4026 r_name
= input_line_pointer
;
4027 c
= get_symbol_end ();
4028 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4029 *input_line_pointer
= c
;
4030 if (reloc
->u
.a
.howto
== NULL
)
4032 as_bad (_("unrecognized reloc type"));
4036 exp
.X_op
= O_absent
;
4038 if (*input_line_pointer
== ',')
4040 ++input_line_pointer
;
4048 as_bad (_("bad reloc expression"));
4050 ignore_rest_of_line ();
4053 mri_comment_end (stop
, stopc
);
4056 reloc
->u
.a
.sym
= NULL
;
4057 reloc
->u
.a
.addend
= 0;
4060 reloc
->u
.a
.sym
= NULL
;
4061 reloc
->u
.a
.addend
= exp
.X_add_number
;
4064 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4065 reloc
->u
.a
.addend
= exp
.X_add_number
;
4068 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4069 reloc
->u
.a
.addend
= 0;
4073 as_where (&reloc
->file
, &reloc
->line
);
4074 reloc
->next
= reloc_list
;
4077 demand_empty_rest_of_line ();
4079 mri_comment_end (stop
, stopc
);
4082 /* Put the contents of expression EXP into the object file using
4083 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4086 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4088 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4092 emit_expr_with_reloc (expressionS
*exp
,
4093 unsigned int nbytes
,
4094 TC_PARSE_CONS_RETURN_TYPE reloc
)
4098 valueT extra_digit
= 0;
4100 /* Don't do anything if we are going to make another pass. */
4105 dot_value
= frag_now_fix ();
4106 dot_frag
= frag_now
;
4110 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4111 appear as a four byte positive constant in the .line section,
4112 followed by a 2 byte 0xffff. Look for that case here. */
4114 static int dwarf_line
= -1;
4116 if (strcmp (segment_name (now_seg
), ".line") != 0)
4118 else if (dwarf_line
>= 0
4120 && exp
->X_op
== O_constant
4121 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4122 listing_source_line ((unsigned int) dwarf_line
);
4123 else if (nbytes
== 4
4124 && exp
->X_op
== O_constant
4125 && exp
->X_add_number
>= 0)
4126 dwarf_line
= exp
->X_add_number
;
4131 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4132 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4133 AT_sibling (0x12) followed by a four byte address of the sibling
4134 followed by a 2 byte AT_name (0x38) followed by the name of the
4135 file. We look for that case here. */
4137 static int dwarf_file
= 0;
4139 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4141 else if (dwarf_file
== 0
4143 && exp
->X_op
== O_constant
4144 && exp
->X_add_number
== 0x11)
4146 else if (dwarf_file
== 1
4148 && exp
->X_op
== O_constant
4149 && exp
->X_add_number
== 0x12)
4151 else if (dwarf_file
== 2
4154 else if (dwarf_file
== 3
4156 && exp
->X_op
== O_constant
4157 && exp
->X_add_number
== 0x38)
4162 /* The variable dwarf_file_string tells stringer that the string
4163 may be the name of the source file. */
4164 if (dwarf_file
== 4)
4165 dwarf_file_string
= 1;
4167 dwarf_file_string
= 0;
4172 if (check_eh_frame (exp
, &nbytes
))
4177 /* Allow `.word 0' in the absolute section. */
4178 if (now_seg
== absolute_section
)
4180 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4181 as_bad (_("attempt to store value in absolute section"));
4182 abs_section_offset
+= nbytes
;
4186 /* Handle a negative bignum. */
4188 && exp
->X_add_number
== 0
4189 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4190 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4193 unsigned long carry
;
4195 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4197 /* Negate the bignum: one's complement each digit and add 1. */
4199 for (i
= 0; i
< exp
->X_add_number
; i
++)
4203 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4206 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4207 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4210 /* We can ignore any carry out, because it will be handled by
4211 extra_digit if it is needed. */
4213 extra_digit
= (valueT
) -1;
4217 if (op
== O_absent
|| op
== O_illegal
)
4219 as_warn (_("zero assumed for missing expression"));
4220 exp
->X_add_number
= 0;
4223 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4225 as_bad (_("floating point number invalid"));
4226 exp
->X_add_number
= 0;
4229 else if (op
== O_register
)
4231 as_warn (_("register value used as expression"));
4235 p
= frag_more ((int) nbytes
);
4237 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4239 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4243 #ifndef WORKING_DOT_WORD
4244 /* If we have the difference of two symbols in a word, save it on
4245 the broken_words list. See the code in write.c. */
4246 if (op
== O_subtract
&& nbytes
== 2)
4248 struct broken_word
*x
;
4250 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
4251 x
->next_broken_word
= broken_words
;
4254 x
->subseg
= now_subseg
;
4256 x
->word_goes_here
= p
;
4258 x
->add
= exp
->X_add_symbol
;
4259 x
->sub
= exp
->X_op_symbol
;
4260 x
->addnum
= exp
->X_add_number
;
4268 /* If we have an integer, but the number of bytes is too large to
4269 pass to md_number_to_chars, handle it as a bignum. */
4270 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4272 extra_digit
= exp
->X_unsigned
? 0 : -1;
4273 convert_to_bignum (exp
, !exp
->X_unsigned
);
4277 if (op
== O_constant
)
4285 /* JF << of >= number of bits in the object is undefined. In
4286 particular SPARC (Sun 4) has problems. */
4287 if (nbytes
>= sizeof (valueT
))
4290 if (nbytes
> sizeof (valueT
))
4293 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4297 /* Don't store these bits. */
4298 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4299 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4302 unmask
= ~mask
; /* Do store these bits. */
4305 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4306 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4309 get
= exp
->X_add_number
;
4311 if ((get
& mask
) != 0
4312 && ((get
& mask
) != mask
4313 || (get
& hibit
) == 0))
4314 { /* Leading bits contain both 0s & 1s. */
4315 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4317 as_warn (_("value 0x%llx truncated to 0x%llx"),
4318 (unsigned long long) get
, (unsigned long long) use
);
4320 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4321 (unsigned long long) get
, (unsigned long long) use
);
4324 as_warn (_("value 0x%lx truncated to 0x%lx"),
4325 (unsigned long) get
, (unsigned long) use
);
4328 /* Put bytes in right order. */
4329 md_number_to_chars (p
, use
, (int) nbytes
);
4331 else if (op
== O_big
)
4334 LITTLENUM_TYPE
*nums
;
4336 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4339 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4342 LITTLENUM_TYPE sign
= 0;
4343 if ((generic_bignum
[--i
]
4344 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4345 sign
= ~(LITTLENUM_TYPE
) 0;
4346 while (++i
< exp
->X_add_number
)
4347 if (generic_bignum
[i
] != sign
)
4350 if (i
< exp
->X_add_number
)
4351 as_warn (_("bignum truncated to %d bytes"), nbytes
);
4357 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4360 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4362 if (target_big_endian
)
4364 while (nbytes
> size
)
4366 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4367 nbytes
-= CHARS_PER_LITTLENUM
;
4368 p
+= CHARS_PER_LITTLENUM
;
4371 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4372 while (size
>= CHARS_PER_LITTLENUM
)
4375 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4376 size
-= CHARS_PER_LITTLENUM
;
4377 p
+= CHARS_PER_LITTLENUM
;
4382 nums
= generic_bignum
;
4383 while (size
>= CHARS_PER_LITTLENUM
)
4385 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4387 size
-= CHARS_PER_LITTLENUM
;
4388 p
+= CHARS_PER_LITTLENUM
;
4389 nbytes
-= CHARS_PER_LITTLENUM
;
4392 while (nbytes
>= CHARS_PER_LITTLENUM
)
4394 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4395 nbytes
-= CHARS_PER_LITTLENUM
;
4396 p
+= CHARS_PER_LITTLENUM
;
4401 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4405 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4406 TC_PARSE_CONS_RETURN_TYPE r
)
4409 unsigned int size
= nbytes
;
4411 memset (p
, 0, size
);
4413 /* Generate a fixS to record the symbol value. */
4415 #ifdef TC_CONS_FIX_NEW
4416 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4418 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4420 reloc_howto_type
*reloc_howto
;
4422 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4423 size
= bfd_get_reloc_size (reloc_howto
);
4427 as_bad (_("%s relocations do not fit in %u bytes\n"),
4428 reloc_howto
->name
, nbytes
);
4431 else if (target_big_endian
)
4432 offset
= nbytes
- size
;
4453 as_bad (_("unsupported BFD relocation size %u"), size
);
4456 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4461 #ifdef BITFIELD_CONS_EXPRESSIONS
4463 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4464 w:x,y:z, where w and y are bitwidths and x and y are values. They
4465 then pack them all together. We do a little better in that we allow
4466 them in words, longs, etc. and we'll pack them in target byte order
4469 The rules are: pack least significant bit first, if a field doesn't
4470 entirely fit, put it in the next unit. Overflowing the bitfield is
4471 explicitly *not* even a warning. The bitwidth should be considered
4474 To use this function the tc-XXX.h file should define
4475 BITFIELD_CONS_EXPRESSIONS. */
4478 parse_bitfield_cons (exp
, nbytes
)
4480 unsigned int nbytes
;
4482 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4483 char *hold
= input_line_pointer
;
4485 (void) expression (exp
);
4487 if (*input_line_pointer
== ':')
4494 unsigned long width
;
4496 if (*input_line_pointer
!= ':')
4498 input_line_pointer
= hold
;
4500 } /* Next piece is not a bitfield. */
4502 /* In the general case, we can't allow
4503 full expressions with symbol
4504 differences and such. The relocation
4505 entries for symbols not defined in this
4506 assembly would require arbitrary field
4507 widths, positions, and masks which most
4508 of our current object formats don't
4511 In the specific case where a symbol
4512 *is* defined in this assembly, we
4513 *could* build fixups and track it, but
4514 this could lead to confusion for the
4515 backends. I'm lazy. I'll take any
4516 SEG_ABSOLUTE. I think that means that
4517 you can use a previous .set or
4518 .equ type symbol. xoxorich. */
4520 if (exp
->X_op
== O_absent
)
4522 as_warn (_("using a bit field width of zero"));
4523 exp
->X_add_number
= 0;
4524 exp
->X_op
= O_constant
;
4525 } /* Implied zero width bitfield. */
4527 if (exp
->X_op
!= O_constant
)
4529 *input_line_pointer
= '\0';
4530 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4531 *input_line_pointer
= ':';
4532 demand_empty_rest_of_line ();
4534 } /* Too complex. */
4536 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4538 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4539 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4540 width
= BITS_PER_CHAR
* nbytes
;
4543 if (width
> bits_available
)
4545 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4546 input_line_pointer
= hold
;
4547 exp
->X_add_number
= value
;
4552 hold
= ++input_line_pointer
;
4554 (void) expression (exp
);
4555 if (exp
->X_op
!= O_constant
)
4557 char cache
= *input_line_pointer
;
4559 *input_line_pointer
= '\0';
4560 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4561 *input_line_pointer
= cache
;
4562 demand_empty_rest_of_line ();
4564 } /* Too complex. */
4566 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4567 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4569 if ((bits_available
-= width
) == 0
4570 || is_it_end_of_statement ()
4571 || *input_line_pointer
!= ',')
4574 } /* All the bitfields we're gonna get. */
4576 hold
= ++input_line_pointer
;
4577 (void) expression (exp
);
4580 exp
->X_add_number
= value
;
4581 exp
->X_op
= O_constant
;
4582 exp
->X_unsigned
= 1;
4583 exp
->X_extrabit
= 0;
4587 #endif /* BITFIELD_CONS_EXPRESSIONS */
4589 /* Handle an MRI style string expression. */
4593 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4595 if (*input_line_pointer
!= '\''
4596 && (input_line_pointer
[1] != '\''
4597 || (*input_line_pointer
!= 'A'
4598 && *input_line_pointer
!= 'E')))
4599 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4603 unsigned int result
= 0;
4605 /* An MRI style string. Cut into as many bytes as will fit into
4606 a nbyte chunk, left justify if necessary, and separate with
4607 commas so we can try again later. */
4608 if (*input_line_pointer
== 'A')
4609 ++input_line_pointer
;
4610 else if (*input_line_pointer
== 'E')
4612 as_bad (_("EBCDIC constants are not supported"));
4613 ++input_line_pointer
;
4616 input_line_pointer
++;
4617 for (scan
= 0; scan
< nbytes
; scan
++)
4619 if (*input_line_pointer
== '\'')
4621 if (input_line_pointer
[1] == '\'')
4623 input_line_pointer
++;
4628 result
= (result
<< 8) | (*input_line_pointer
++);
4632 while (scan
< nbytes
)
4638 /* Create correct expression. */
4639 exp
->X_op
= O_constant
;
4640 exp
->X_add_number
= result
;
4642 /* Fake it so that we can read the next char too. */
4643 if (input_line_pointer
[0] != '\'' ||
4644 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4646 input_line_pointer
-= 2;
4647 input_line_pointer
[0] = ',';
4648 input_line_pointer
[1] = '\'';
4651 input_line_pointer
++;
4654 #endif /* TC_M68K */
4656 #ifdef REPEAT_CONS_EXPRESSIONS
4658 /* Parse a repeat expression for cons. This is used by the MIPS
4659 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4660 object file COUNT times.
4662 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4665 parse_repeat_cons (exp
, nbytes
)
4667 unsigned int nbytes
;
4674 if (*input_line_pointer
!= ':')
4676 /* No repeat count. */
4680 ++input_line_pointer
;
4681 expression (&count
);
4682 if (count
.X_op
!= O_constant
4683 || count
.X_add_number
<= 0)
4685 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4689 /* The cons function is going to output this expression once. So we
4690 output it count - 1 times. */
4691 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4692 emit_expr (exp
, nbytes
);
4695 #endif /* REPEAT_CONS_EXPRESSIONS */
4697 /* Parse a floating point number represented as a hex constant. This
4698 permits users to specify the exact bits they want in the floating
4702 hex_float (int float_type
, char *bytes
)
4734 as_bad (_("unknown floating type type '%c'"), float_type
);
4738 /* It would be nice if we could go through expression to parse the
4739 hex constant, but if we get a bignum it's a pain to sort it into
4740 the buffer correctly. */
4742 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4746 /* The MRI assembler accepts arbitrary underscores strewn about
4747 through the hex constant, so we ignore them as well. */
4748 if (*input_line_pointer
== '_')
4750 ++input_line_pointer
;
4756 as_warn (_("floating point constant too large"));
4759 d
= hex_value (*input_line_pointer
) << 4;
4760 ++input_line_pointer
;
4761 while (*input_line_pointer
== '_')
4762 ++input_line_pointer
;
4763 if (hex_p (*input_line_pointer
))
4765 d
+= hex_value (*input_line_pointer
);
4766 ++input_line_pointer
;
4768 if (target_big_endian
)
4771 bytes
[length
- i
- 1] = d
;
4777 if (target_big_endian
)
4778 memset (bytes
+ i
, 0, length
- i
);
4780 memset (bytes
, 0, length
- i
);
4788 CONStruct some more frag chars of .floats .ffloats etc.
4789 Makes 0 or more new frags.
4790 If need_pass_2 == 1, no frags are emitted.
4791 This understands only floating literals, not expressions. Sorry.
4793 A floating constant is defined by atof_generic(), except it is preceded
4794 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4795 reading, I decided to be incompatible. This always tries to give you
4796 rounded bits to the precision of the pseudo-op. Former AS did premature
4797 truncation, restored noisy bits instead of trailing 0s AND gave you
4798 a choice of 2 flavours of noise according to which of 2 floating-point
4799 scanners you directed AS to use.
4801 In: input_line_pointer->whitespace before, or '0' of flonum. */
4804 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4805 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4808 int length
; /* Number of chars in an object. */
4809 char *err
; /* Error from scanning floating literal. */
4810 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4812 if (is_it_end_of_statement ())
4814 demand_empty_rest_of_line ();
4818 #ifdef md_flush_pending_output
4819 md_flush_pending_output ();
4822 #ifdef md_cons_align
4828 /* input_line_pointer->1st char of a flonum (we hope!). */
4831 /* Skip any 0{letter} that may be present. Don't even check if the
4832 letter is legal. Someone may invent a "z" format and this routine
4833 has no use for such information. Lusers beware: you get
4834 diagnostics if your input is ill-conditioned. */
4835 if (input_line_pointer
[0] == '0'
4836 && ISALPHA (input_line_pointer
[1]))
4837 input_line_pointer
+= 2;
4839 /* Accept :xxxx, where the x's are hex digits, for a floating
4840 point with the exact digits specified. */
4841 if (input_line_pointer
[0] == ':')
4843 ++input_line_pointer
;
4844 length
= hex_float (float_type
, temp
);
4847 ignore_rest_of_line ();
4853 err
= md_atof (float_type
, temp
, &length
);
4854 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4855 know (err
!= NULL
|| length
> 0);
4858 as_bad (_("bad floating literal: %s"), err
);
4859 ignore_rest_of_line ();
4870 #ifdef REPEAT_CONS_EXPRESSIONS
4871 if (*input_line_pointer
== ':')
4873 expressionS count_exp
;
4875 ++input_line_pointer
;
4876 expression (&count_exp
);
4878 if (count_exp
.X_op
!= O_constant
4879 || count_exp
.X_add_number
<= 0)
4880 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4882 count
= count_exp
.X_add_number
;
4886 while (--count
>= 0)
4888 p
= frag_more (length
);
4889 memcpy (p
, temp
, (unsigned int) length
);
4894 while (*input_line_pointer
++ == ',');
4896 /* Put terminator back into stream. */
4897 --input_line_pointer
;
4898 demand_empty_rest_of_line ();
4901 /* Return the size of a LEB128 value. */
4904 sizeof_sleb128 (offsetT value
)
4911 byte
= (value
& 0x7f);
4912 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4913 Fortunately, we can structure things so that the extra work reduces
4914 to a noop on systems that do things "properly". */
4915 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4918 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4919 || ((value
== -1) && ((byte
& 0x40) != 0))));
4925 sizeof_uleb128 (valueT value
)
4940 sizeof_leb128 (valueT value
, int sign
)
4943 return sizeof_sleb128 ((offsetT
) value
);
4945 return sizeof_uleb128 (value
);
4948 /* Output a LEB128 value. */
4951 output_sleb128 (char *p
, offsetT value
)
4958 unsigned byte
= (value
& 0x7f);
4960 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4961 Fortunately, we can structure things so that the extra work reduces
4962 to a noop on systems that do things "properly". */
4963 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4965 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4966 || ((value
== -1) && ((byte
& 0x40) != 0))));
4978 output_uleb128 (char *p
, valueT value
)
4984 unsigned byte
= (value
& 0x7f);
4987 /* More bytes to follow. */
4998 output_leb128 (char *p
, valueT value
, int sign
)
5001 return output_sleb128 (p
, (offsetT
) value
);
5003 return output_uleb128 (p
, value
);
5006 /* Do the same for bignums. We combine sizeof with output here in that
5007 we don't output for NULL values of P. It isn't really as critical as
5008 for "normal" values that this be streamlined. */
5011 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
5018 /* Strip leading sign extensions off the bignum. */
5020 && bignum
[size
- 1] == LITTLENUM_MASK
5021 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5026 /* OR in the next part of the littlenum. */
5027 val
|= (*bignum
<< loaded
);
5028 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5032 /* Add bytes until there are less than 7 bits left in VAL
5033 or until every non-sign bit has been written. */
5040 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5047 while ((byte
& 0x80) != 0 && loaded
>= 7);
5051 /* Mop up any left-over bits (of which there will be less than 7). */
5052 if ((byte
& 0x80) != 0)
5054 /* Sign-extend VAL. */
5055 if (val
& (1 << (loaded
- 1)))
5056 val
|= ~0 << loaded
;
5066 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
5073 /* Strip leading zeros off the bignum. */
5074 /* XXX: Is this needed? */
5075 while (size
> 0 && bignum
[size
- 1] == 0)
5080 if (loaded
< 7 && size
> 0)
5082 val
|= (*bignum
<< loaded
);
5083 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5092 if (size
> 0 || val
)
5099 while (byte
& 0x80);
5105 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
5108 return output_big_sleb128 (p
, bignum
, size
);
5110 return output_big_uleb128 (p
, bignum
, size
);
5113 /* Generate the appropriate fragments for a given expression to emit a
5117 emit_leb128_expr (expressionS
*exp
, int sign
)
5119 operatorT op
= exp
->X_op
;
5120 unsigned int nbytes
;
5122 if (op
== O_absent
|| op
== O_illegal
)
5124 as_warn (_("zero assumed for missing expression"));
5125 exp
->X_add_number
= 0;
5128 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5130 as_bad (_("floating point number invalid"));
5131 exp
->X_add_number
= 0;
5134 else if (op
== O_register
)
5136 as_warn (_("register value used as expression"));
5139 else if (op
== O_constant
5141 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5143 /* We're outputting a signed leb128 and the sign of X_add_number
5144 doesn't reflect the sign of the original value. Convert EXP
5145 to a correctly-extended bignum instead. */
5146 convert_to_bignum (exp
, exp
->X_extrabit
);
5150 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5151 a signal that this is leb128 data. It shouldn't optimize this away. */
5152 nbytes
= (unsigned int) -1;
5153 if (check_eh_frame (exp
, &nbytes
))
5156 /* Let the backend know that subsequent data may be byte aligned. */
5157 #ifdef md_cons_align
5161 if (op
== O_constant
)
5163 /* If we've got a constant, emit the thing directly right now. */
5165 valueT value
= exp
->X_add_number
;
5169 size
= sizeof_leb128 (value
, sign
);
5170 p
= frag_more (size
);
5171 output_leb128 (p
, value
, sign
);
5173 else if (op
== O_big
)
5175 /* O_big is a different sort of constant. */
5180 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
5181 p
= frag_more (size
);
5182 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
5186 /* Otherwise, we have to create a variable sized fragment and
5187 resolve things later. */
5189 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5190 make_expr_symbol (exp
), 0, (char *) NULL
);
5194 /* Parse the .sleb128 and .uleb128 pseudos. */
5201 #ifdef md_flush_pending_output
5202 md_flush_pending_output ();
5208 emit_leb128_expr (&exp
, sign
);
5210 while (*input_line_pointer
++ == ',');
5212 input_line_pointer
--;
5213 demand_empty_rest_of_line ();
5217 stringer_append_char (int c
, int bitsize
)
5219 if (!target_big_endian
)
5220 FRAG_APPEND_1_CHAR (c
);
5225 FRAG_APPEND_1_CHAR (0);
5226 FRAG_APPEND_1_CHAR (0);
5227 FRAG_APPEND_1_CHAR (0);
5228 FRAG_APPEND_1_CHAR (0);
5231 FRAG_APPEND_1_CHAR (0);
5232 FRAG_APPEND_1_CHAR (0);
5235 FRAG_APPEND_1_CHAR (0);
5240 /* Called with invalid bitsize argument. */
5244 if (target_big_endian
)
5245 FRAG_APPEND_1_CHAR (c
);
5248 /* Worker to do .ascii etc statements.
5249 Reads 0 or more ',' separated, double-quoted strings.
5250 Caller should have checked need_pass_2 is FALSE because we don't
5252 Checks for end-of-line.
5253 BITS_APPENDZERO says how many bits are in a target char.
5254 The bottom bit is set if a NUL char should be appended to the strings. */
5257 stringer (int bits_appendzero
)
5259 const int bitsize
= bits_appendzero
& ~7;
5260 const int append_zero
= bits_appendzero
& 1;
5262 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5266 #ifdef md_flush_pending_output
5267 md_flush_pending_output ();
5270 #ifdef md_cons_align
5274 /* The following awkward logic is to parse ZERO or more strings,
5275 comma separated. Recall a string expression includes spaces
5276 before the opening '\"' and spaces after the closing '\"'.
5277 We fake a leading ',' if there is (supposed to be)
5278 a 1st, expression. We keep demanding expressions for each ','. */
5279 if (is_it_end_of_statement ())
5281 c
= 0; /* Skip loop. */
5282 ++input_line_pointer
; /* Compensate for end of loop. */
5286 c
= ','; /* Do loop. */
5288 /* If we have been switched into the abs_section then we
5289 will not have an obstack onto which we can hang strings. */
5290 if (now_seg
== absolute_section
)
5292 as_bad (_("strings must be placed into a section"));
5294 ignore_rest_of_line ();
5297 while (c
== ',' || c
== '<' || c
== '"')
5300 switch (*input_line_pointer
)
5303 ++input_line_pointer
; /*->1st char of string. */
5304 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5305 start
= input_line_pointer
;
5308 while (is_a_char (c
= next_char_of_string ()))
5309 stringer_append_char (c
, bitsize
);
5312 stringer_append_char (0, bitsize
);
5314 know (input_line_pointer
[-1] == '\"');
5316 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5317 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5318 will emit .string with a filename in the .debug section
5319 after a sequence of constants. See the comment in
5320 emit_expr for the sequence. emit_expr will set
5321 dwarf_file_string to non-zero if this string might be a
5322 source file name. */
5323 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5324 dwarf_file_string
= 0;
5325 else if (dwarf_file_string
)
5327 c
= input_line_pointer
[-1];
5328 input_line_pointer
[-1] = '\0';
5329 listing_source_file (start
);
5330 input_line_pointer
[-1] = c
;
5336 input_line_pointer
++;
5337 c
= get_single_number ();
5338 stringer_append_char (c
, bitsize
);
5339 if (*input_line_pointer
!= '>')
5340 as_bad (_("expected <nn>"));
5342 input_line_pointer
++;
5345 input_line_pointer
++;
5349 c
= *input_line_pointer
;
5352 demand_empty_rest_of_line ();
5355 /* FIXME-SOMEDAY: I had trouble here on characters with the
5356 high bits set. We'll probably also have trouble with
5357 multibyte chars, wide chars, etc. Also be careful about
5358 returning values bigger than 1 byte. xoxorich. */
5361 next_char_of_string (void)
5365 c
= *input_line_pointer
++ & CHAR_MASK
;
5373 as_warn (_("unterminated string; newline inserted"));
5374 bump_line_counters ();
5377 #ifndef NO_STRING_ESCAPES
5379 switch (c
= *input_line_pointer
++)
5407 break; /* As itself. */
5423 for (i
= 0, number
= 0;
5424 ISDIGIT (c
) && i
< 3;
5425 c
= *input_line_pointer
++, i
++)
5427 number
= number
* 8 + c
- '0';
5432 --input_line_pointer
;
5441 c
= *input_line_pointer
++;
5442 while (ISXDIGIT (c
))
5445 number
= number
* 16 + c
- '0';
5446 else if (ISUPPER (c
))
5447 number
= number
* 16 + c
- 'A' + 10;
5449 number
= number
* 16 + c
- 'a' + 10;
5450 c
= *input_line_pointer
++;
5453 --input_line_pointer
;
5458 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5459 as_warn (_("unterminated string; newline inserted"));
5461 bump_line_counters ();
5466 #ifdef ONLY_STANDARD_ESCAPES
5467 as_bad (_("bad escaped character in string"));
5469 #endif /* ONLY_STANDARD_ESCAPES */
5474 #endif /* ! defined (NO_STRING_ESCAPES) */
5483 get_segmented_expression (expressionS
*expP
)
5487 retval
= expression (expP
);
5488 if (expP
->X_op
== O_illegal
5489 || expP
->X_op
== O_absent
5490 || expP
->X_op
== O_big
)
5492 as_bad (_("expected address expression"));
5493 expP
->X_op
= O_constant
;
5494 expP
->X_add_number
= 0;
5495 retval
= absolute_section
;
5501 get_known_segmented_expression (expressionS
*expP
)
5503 segT retval
= get_segmented_expression (expP
);
5505 if (retval
== undefined_section
)
5507 /* There is no easy way to extract the undefined symbol from the
5509 if (expP
->X_add_symbol
!= NULL
5510 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5511 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5512 S_GET_NAME (expP
->X_add_symbol
));
5514 as_warn (_("some symbol undefined; zero assumed"));
5515 retval
= absolute_section
;
5516 expP
->X_op
= O_constant
;
5517 expP
->X_add_number
= 0;
5522 char /* Return terminator. */
5523 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5525 /* FIXME: val_pointer should probably be offsetT *. */
5526 *val_pointer
= (long) get_absolute_expression ();
5527 return (*input_line_pointer
++);
5530 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5531 Give a warning if that happens. */
5534 demand_copy_C_string (int *len_pointer
)
5538 if ((s
= demand_copy_string (len_pointer
)) != 0)
5542 for (len
= *len_pointer
; len
> 0; len
--)
5549 as_bad (_("this string may not contain \'\\0\'"));
5557 /* Demand string, but return a safe (=private) copy of the string.
5558 Return NULL if we can't read a string here. */
5561 demand_copy_string (int *lenP
)
5569 if (*input_line_pointer
== '\"')
5571 input_line_pointer
++; /* Skip opening quote. */
5573 while (is_a_char (c
= next_char_of_string ()))
5575 obstack_1grow (¬es
, c
);
5578 /* JF this next line is so demand_copy_C_string will return a
5579 null terminated string. */
5580 obstack_1grow (¬es
, '\0');
5581 retval
= (char *) obstack_finish (¬es
);
5585 as_bad (_("missing string"));
5587 ignore_rest_of_line ();
5593 /* In: Input_line_pointer->next character.
5595 Do: Skip input_line_pointer over all whitespace.
5597 Out: 1 if input_line_pointer->end-of-line. */
5600 is_it_end_of_statement (void)
5603 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5607 equals (char *sym_name
, int reassign
)
5612 input_line_pointer
++;
5613 if (*input_line_pointer
== '=')
5614 input_line_pointer
++;
5615 if (reassign
< 0 && *input_line_pointer
== '=')
5616 input_line_pointer
++;
5618 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5619 input_line_pointer
++;
5622 stop
= mri_comment_field (&stopc
);
5624 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5628 demand_empty_rest_of_line ();
5629 mri_comment_end (stop
, stopc
);
5633 /* .incbin -- include a file verbatim at the current location. */
5636 s_incbin (int x ATTRIBUTE_UNUSED
)
5647 #ifdef md_flush_pending_output
5648 md_flush_pending_output ();
5651 #ifdef md_cons_align
5656 filename
= demand_copy_string (& len
);
5657 if (filename
== NULL
)
5662 /* Look for optional skip and count. */
5663 if (* input_line_pointer
== ',')
5665 ++ input_line_pointer
;
5666 skip
= get_absolute_expression ();
5670 if (* input_line_pointer
== ',')
5672 ++ input_line_pointer
;
5674 count
= get_absolute_expression ();
5676 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5682 demand_empty_rest_of_line ();
5684 /* Try opening absolute path first, then try include dirs. */
5685 binfile
= fopen (filename
, FOPEN_RB
);
5686 if (binfile
== NULL
)
5690 path
= (char *) xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5692 for (i
= 0; i
< include_dir_count
; i
++)
5694 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5696 binfile
= fopen (path
, FOPEN_RB
);
5697 if (binfile
!= NULL
)
5701 if (binfile
== NULL
)
5702 as_bad (_("file not found: %s"), filename
);
5705 path
= xstrdup (filename
);
5711 register_dependency (path
);
5713 /* Compute the length of the file. */
5714 if (fseek (binfile
, 0, SEEK_END
) != 0)
5716 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5719 file_len
= ftell (binfile
);
5721 /* If a count was not specified use the remainder of the file. */
5723 count
= file_len
- skip
;
5725 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5727 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5728 skip
, count
, file_len
);
5732 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5734 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5738 /* Allocate frag space and store file contents in it. */
5739 binfrag
= frag_more (count
);
5741 bytes
= fread (binfrag
, 1, count
, binfile
);
5743 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5744 path
, bytes
, count
);
5747 if (binfile
!= NULL
)
5753 /* .include -- include a file at this point. */
5756 s_include (int arg ATTRIBUTE_UNUSED
)
5765 filename
= demand_copy_string (&i
);
5766 if (filename
== NULL
)
5768 /* demand_copy_string has already printed an error and
5769 called ignore_rest_of_line. */
5777 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5778 && *input_line_pointer
!= ' '
5779 && *input_line_pointer
!= '\t')
5781 obstack_1grow (¬es
, *input_line_pointer
);
5782 ++input_line_pointer
;
5786 obstack_1grow (¬es
, '\0');
5787 filename
= (char *) obstack_finish (¬es
);
5788 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5789 ++input_line_pointer
;
5792 demand_empty_rest_of_line ();
5793 path
= (char *) xmalloc ((unsigned long) i
5794 + include_dir_maxlen
+ 5 /* slop */ );
5796 for (i
= 0; i
< include_dir_count
; i
++)
5798 strcpy (path
, include_dirs
[i
]);
5800 strcat (path
, filename
);
5801 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5811 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5812 register_dependency (path
);
5813 input_scrub_insert_file (path
);
5817 add_include_dir (char *path
)
5821 if (include_dir_count
== 0)
5823 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5824 include_dirs
[0] = "."; /* Current dir. */
5825 include_dir_count
= 2;
5829 include_dir_count
++;
5831 (char **) xrealloc (include_dirs
,
5832 include_dir_count
* sizeof (*include_dirs
));
5835 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5838 if (i
> include_dir_maxlen
)
5839 include_dir_maxlen
= i
;
5842 /* Output debugging information to denote the source file. */
5845 generate_file_debug (void)
5847 if (debug_type
== DEBUG_STABS
)
5848 stabs_generate_asm_file ();
5851 /* Output line number debugging information for the current source line. */
5854 generate_lineno_debug (void)
5858 case DEBUG_UNSPECIFIED
:
5863 stabs_generate_asm_lineno ();
5866 ecoff_generate_asm_lineno ();
5869 /* ??? We could here indicate to dwarf2dbg.c that something
5870 has changed. However, since there is additional backend
5871 support that is required (calling dwarf2_emit_insn), we
5872 let dwarf2dbg.c call as_where on its own. */
5877 /* Output debugging information to mark a function entry point or end point.
5878 END_P is zero for .func, and non-zero for .endfunc. */
5883 do_s_func (end_p
, NULL
);
5886 /* Subroutine of s_func so targets can choose a different default prefix.
5887 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5890 do_s_func (int end_p
, const char *default_prefix
)
5892 /* Record the current function so that we can issue an error message for
5893 misplaced .func,.endfunc, and also so that .endfunc needs no
5895 static char *current_name
;
5896 static char *current_label
;
5900 if (current_name
== NULL
)
5902 as_bad (_("missing .func"));
5903 ignore_rest_of_line ();
5907 if (debug_type
== DEBUG_STABS
)
5908 stabs_generate_asm_endfunc (current_name
, current_label
);
5910 current_name
= current_label
= NULL
;
5915 char delim1
, delim2
;
5917 if (current_name
!= NULL
)
5919 as_bad (_(".endfunc missing for previous .func"));
5920 ignore_rest_of_line ();
5924 name
= input_line_pointer
;
5925 delim1
= get_symbol_end ();
5926 name
= xstrdup (name
);
5927 *input_line_pointer
= delim1
;
5929 if (*input_line_pointer
!= ',')
5933 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5934 as_fatal ("%s", xstrerror (errno
));
5938 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5939 /* Missing entry point, use function's name with the leading
5943 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
5944 as_fatal ("%s", xstrerror (errno
));
5952 ++input_line_pointer
;
5954 label
= input_line_pointer
;
5955 delim2
= get_symbol_end ();
5956 label
= xstrdup (label
);
5957 *input_line_pointer
= delim2
;
5960 if (debug_type
== DEBUG_STABS
)
5961 stabs_generate_asm_func (name
, label
);
5963 current_name
= name
;
5964 current_label
= label
;
5967 demand_empty_rest_of_line ();
5970 #ifdef HANDLE_BUNDLE
5973 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
5975 unsigned int align
= get_absolute_expression ();
5977 demand_empty_rest_of_line ();
5979 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
5980 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
5981 (unsigned int) TC_ALIGN_LIMIT
);
5983 if (bundle_lock_frag
!= NULL
)
5985 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
5989 bundle_align_p2
= align
;
5993 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
5995 demand_empty_rest_of_line ();
5997 if (bundle_align_p2
== 0)
5999 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6003 if (bundle_lock_depth
== 0)
6005 bundle_lock_frchain
= frchain_now
;
6006 bundle_lock_frag
= start_bundle ();
6008 ++bundle_lock_depth
;
6012 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6016 demand_empty_rest_of_line ();
6018 if (bundle_lock_frag
== NULL
)
6020 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6024 gas_assert (bundle_align_p2
> 0);
6026 gas_assert (bundle_lock_depth
> 0);
6027 if (--bundle_lock_depth
> 0)
6030 size
= pending_bundle_size (bundle_lock_frag
);
6032 if (size
> (1U << bundle_align_p2
))
6033 as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
6034 size
, 1 << bundle_align_p2
);
6036 finish_bundle (bundle_lock_frag
, size
);
6038 bundle_lock_frag
= NULL
;
6039 bundle_lock_frchain
= NULL
;
6042 #endif /* HANDLE_BUNDLE */
6045 s_ignore (int arg ATTRIBUTE_UNUSED
)
6047 ignore_rest_of_line ();
6051 read_print_statistics (FILE *file
)
6053 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6056 /* Inserts the given line into the input stream.
6058 This call avoids macro/conditionals nesting checking, since the contents of
6059 the line are assumed to replace the contents of a line already scanned.
6061 An appropriate use of this function would be substitution of input lines when
6062 called by md_start_line_hook(). The given line is assumed to already be
6063 properly scrubbed. */
6066 input_scrub_insert_line (const char *line
)
6069 size_t len
= strlen (line
);
6070 sb_build (&newline
, len
);
6071 sb_add_buffer (&newline
, line
, len
);
6072 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6074 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6077 /* Insert a file into the input stream; the path must resolve to an actual
6078 file; no include path searching or dependency registering is performed. */
6081 input_scrub_insert_file (char *path
)
6083 input_scrub_include_file (path
, input_line_pointer
);
6084 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6087 /* Find the end of a line, considering quotation and escaping of quotes. */
6089 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6090 # define TC_SINGLE_QUOTE_STRINGS 1
6094 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6097 char inquote
= '\0';
6100 while (!is_end_of_line
[(unsigned char) *s
]
6101 || (inquote
&& !ISCNTRL (*s
))
6102 || (inquote
== '\'' && flag_mri
)
6103 #ifdef TC_EOL_IN_INSN
6104 || (insn
&& TC_EOL_IN_INSN (s
))
6106 /* PR 6926: When we are parsing the body of a macro the sequence
6107 \@ is special - it refers to the invocation count. If the @
6108 character happens to be registered as a line-separator character
6109 by the target, then the is_end_of_line[] test above will have
6110 returned true, but we need to ignore the line separating
6111 semantics in this particular case. */
6112 || (in_macro
&& inescape
&& *s
== '@')
6115 if (mri_string
&& *s
== '\'')
6119 else if (*s
== '\\')
6123 #ifdef TC_SINGLE_QUOTE_STRINGS
6124 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6131 as_warn (_("missing closing `%c'"), inquote
);
6133 as_warn (_("stray `\\'"));
6138 find_end_of_line (char *s
, int mri_string
)
6140 return _find_end_of_line (s
, mri_string
, 0, 0);