1 /* read.c - read a source file -
2 Copyright (C) 1986-2015 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(num_read) \
561 if (ignore_input ()) \
563 char *eol = find_end_of_line (input_line_pointer - (num_read), \
565 input_line_pointer = (input_line_pointer <= buffer_limit \
566 && eol >= buffer_limit) \
572 /* This function is used when scrubbing the characters between #APP
575 static char *scrub_string
;
576 static char *scrub_string_end
;
579 scrub_from_string (char *buf
, size_t buflen
)
583 copy
= scrub_string_end
- scrub_string
;
586 memcpy (buf
, scrub_string
, copy
);
587 scrub_string
+= copy
;
591 /* Helper function of read_a_source_file, which tries to expand a macro. */
593 try_macro (char term
, const char *line
)
599 if (check_macro (line
, &out
, &err
, ¯o
))
603 *input_line_pointer
++ = term
;
604 input_scrub_include_sb (&out
,
605 input_line_pointer
, 1);
608 input_scrub_next_buffer (&input_line_pointer
);
610 md_macro_info (macro
);
618 /* Start a new instruction bundle. Returns the rs_align_code frag that
619 will be used to align the new bundle. */
623 fragS
*frag
= frag_now
;
625 frag_align_code (0, 0);
627 while (frag
->fr_type
!= rs_align_code
)
628 frag
= frag
->fr_next
;
630 gas_assert (frag
!= frag_now
);
635 /* Calculate the maximum size after relaxation of the region starting
636 at the given frag and extending through frag_now (which is unfinished). */
638 pending_bundle_size (fragS
*frag
)
640 unsigned int offset
= frag
->fr_fix
;
641 unsigned int size
= 0;
643 gas_assert (frag
!= frag_now
);
644 gas_assert (frag
->fr_type
== rs_align_code
);
646 while (frag
!= frag_now
)
648 /* This should only happen in what will later become an error case. */
652 size
+= frag
->fr_fix
;
653 if (frag
->fr_type
== rs_machine_dependent
)
654 size
+= md_frag_max_var (frag
);
656 frag
= frag
->fr_next
;
659 gas_assert (frag
== frag_now
);
660 size
+= frag_now_fix ();
661 if (frag
->fr_type
== rs_machine_dependent
)
662 size
+= md_frag_max_var (frag
);
664 gas_assert (size
>= offset
);
666 return size
- offset
;
669 /* Finish off the frag created to ensure bundle alignment. */
671 finish_bundle (fragS
*frag
, unsigned int size
)
673 gas_assert (bundle_align_p2
> 0);
674 gas_assert (frag
->fr_type
== rs_align_code
);
678 /* If there is more than a single byte, then we need to set up the
679 alignment frag. Otherwise we leave it at its initial state from
680 calling frag_align_code (0, 0), so that it does nothing. */
681 frag
->fr_offset
= bundle_align_p2
;
682 frag
->fr_subtype
= size
- 1;
685 /* We do this every time rather than just in s_bundle_align_mode
686 so that we catch any affected section without needing hooks all
687 over for all paths that do section changes. It's cheap enough. */
688 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
691 /* Assemble one instruction. This takes care of the bundle features
692 around calling md_assemble. */
694 assemble_one (char *line
)
696 fragS
*insn_start_frag
= NULL
;
698 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
700 as_bad (_("cannot change section or subsection inside .bundle_lock"));
701 /* Clearing this serves as a marker that we have already complained. */
702 bundle_lock_frchain
= NULL
;
705 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
706 insn_start_frag
= start_bundle ();
710 if (bundle_lock_frchain
!= NULL
)
712 /* Make sure this hasn't pushed the locked sequence
713 past the bundle size. */
714 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
715 if (bundle_size
> (1U << bundle_align_p2
))
717 .bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"),
718 bundle_size
, 1U << bundle_align_p2
);
720 else if (bundle_align_p2
> 0)
722 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
724 if (insn_size
> (1U << bundle_align_p2
))
726 single instruction is %u bytes long but .bundle_align_mode limit is %u"),
727 (unsigned int) insn_size
, 1U << bundle_align_p2
);
729 finish_bundle (insn_start_frag
, insn_size
);
733 #else /* !HANDLE_BUNDLE */
735 # define assemble_one(line) md_assemble(line)
737 #endif /* HANDLE_BUNDLE */
739 /* We read the file, putting things into a web that represents what we
740 have been reading. */
742 read_a_source_file (char *name
)
746 char *s
; /* String of symbol, '\0' appended. */
754 buffer
= input_scrub_new_file (name
);
757 listing_newline (NULL
);
758 register_dependency (name
);
760 /* Generate debugging information before we've read anything in to denote
761 this file as the "main" source file and not a subordinate one
762 (e.g. N_SO vs N_SOL in stabs). */
763 generate_file_debug ();
765 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
766 { /* We have another line to parse. */
768 /* In order to avoid listing macro expansion lines with labels
769 multiple times, keep track of which line was last issued. */
770 static char *last_eol
;
774 while (input_line_pointer
< buffer_limit
)
776 bfd_boolean was_new_line
;
777 /* We have more of this buffer to parse. */
779 /* We now have input_line_pointer->1st char of next line.
780 If input_line_pointer [-1] == '\n' then we just
781 scanned another line: so bump line counters. */
782 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
785 symbol_set_value_now (&dot_symbol
);
786 #ifdef md_start_line_hook
787 md_start_line_hook ();
789 if (input_line_pointer
[-1] == '\n')
790 bump_line_counters ();
794 /* If listing is on, and we are expanding a macro, then give
795 the listing code the contents of the expanded line. */
798 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
800 /* Find the end of the current expanded macro line. */
801 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
809 /* Copy it for safe keeping. Also give an indication of
810 how much macro nesting is involved at this point. */
811 len
= s
- input_line_pointer
;
812 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
813 memset (copy
, '>', macro_nest
);
814 copy
[macro_nest
] = ' ';
815 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
816 copy
[macro_nest
+ 1 + len
] = '\0';
818 /* Install the line with the listing facility. */
819 listing_newline (copy
);
823 listing_newline (NULL
);
830 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
832 next_char
= * input_line_pointer
;
833 /* Text at the start of a line must be a label, we
834 run down and stick a colon in. */
835 if (is_name_beginner (next_char
) || next_char
== '"')
840 HANDLE_CONDITIONAL_ASSEMBLY (0);
842 nul_char
= get_symbol_name (& line_start
);
843 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
845 /* In MRI mode, the EQU and MACRO pseudoops must
846 be handled specially. */
850 char *rest
= input_line_pointer
+ 1;
854 if (*rest
== ' ' || *rest
== '\t')
856 if ((strncasecmp (rest
, "EQU", 3) == 0
857 || strncasecmp (rest
, "SET", 3) == 0)
858 && (rest
[3] == ' ' || rest
[3] == '\t'))
860 input_line_pointer
= rest
+ 3;
862 strncasecmp (rest
, "SET", 3) == 0);
865 if (strncasecmp (rest
, "MACRO", 5) == 0
868 || is_end_of_line
[(unsigned char) rest
[5]]))
872 /* In MRI mode, we need to handle the MACRO
873 pseudo-op specially: we don't want to put the
874 symbol in the symbol table. */
876 #ifdef TC_START_LABEL_WITHOUT_COLON
877 && TC_START_LABEL_WITHOUT_COLON (next_char
,
881 line_label
= colon (line_start
);
883 line_label
= symbol_create (line_start
,
888 next_char
= restore_line_pointer (nul_char
);
889 if (next_char
== ':')
890 input_line_pointer
++;
895 /* We are at the beginning of a line, or similar place.
896 We expect a well-formed assembler statement.
897 A "symbol-name:" is a statement.
899 Depending on what compiler is used, the order of these tests
900 may vary to catch most common case 1st.
901 Each test is independent of all other tests at the (top)
904 nul_char
= next_char
= *input_line_pointer
++;
905 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
907 /* C is the 1st significant character.
908 Input_line_pointer points after that character. */
909 if (is_name_beginner (next_char
) || next_char
== '"')
913 /* Want user-defined label or pseudo/opcode. */
914 HANDLE_CONDITIONAL_ASSEMBLY (1);
916 --input_line_pointer
;
917 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
918 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
919 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
921 /* NEXT_CHAR is character after symbol.
922 The end of symbol in the input line is now '\0'.
923 S points to the beginning of the symbol.
924 [In case of pseudo-op, s->'.'.]
925 Input_line_pointer->'\0' where NUL_CHAR was. */
926 if (TC_START_LABEL (next_char
, s
, input_line_pointer
))
930 /* In MRI mode, \tsym: set 0 is permitted. */
934 if (*rest
== ' ' || *rest
== '\t')
937 if ((strncasecmp (rest
, "EQU", 3) == 0
938 || strncasecmp (rest
, "SET", 3) == 0)
939 && (rest
[3] == ' ' || rest
[3] == '\t'))
941 input_line_pointer
= rest
+ 3;
947 line_label
= colon (s
); /* User-defined label. */
948 restore_line_pointer (nul_char
);
949 ++ input_line_pointer
;
950 #ifdef tc_check_label
951 tc_check_label (line_label
);
953 /* Input_line_pointer->after ':'. */
956 else if ((next_char
== '=' && *rest
== '=')
957 || ((next_char
== ' ' || next_char
== '\t')
962 demand_empty_rest_of_line ();
964 else if ((next_char
== '='
965 || ((next_char
== ' ' || next_char
== '\t')
967 #ifdef TC_EQUAL_IN_INSN
968 && !TC_EQUAL_IN_INSN (next_char
, s
)
973 demand_empty_rest_of_line ();
977 /* Expect pseudo-op or machine instruction. */
980 #ifndef TC_CASE_SENSITIVE
984 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
985 original_case_string
[sizeof (original_case_string
) - 1] = 0;
994 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
996 /* The MRI assembler uses pseudo-ops without
998 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
999 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1004 || (!flag_m68k_mri
&& *s
== '.'))
1008 WARNING: next_char may be end-of-line.
1009 We lookup the pseudo-op table with s+1 because we
1010 already know that the pseudo-op begins with a '.'. */
1013 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1014 if (pop
&& !pop
->poc_handler
)
1017 /* In MRI mode, we may need to insert an
1018 automatic alignment directive. What a hack
1020 if (mri_pending_align
1022 || !((pop
->poc_handler
== cons
1023 && pop
->poc_val
== 1)
1024 || (pop
->poc_handler
== s_space
1025 && pop
->poc_val
== 1)
1026 #ifdef tc_conditional_pseudoop
1027 || tc_conditional_pseudoop (pop
)
1029 || pop
->poc_handler
== s_if
1030 || pop
->poc_handler
== s_ifdef
1031 || pop
->poc_handler
== s_ifc
1032 || pop
->poc_handler
== s_ifeqs
1033 || pop
->poc_handler
== s_else
1034 || pop
->poc_handler
== s_endif
1035 || pop
->poc_handler
== s_globl
1036 || pop
->poc_handler
== s_ignore
)))
1038 do_align (1, (char *) NULL
, 0, 0);
1039 mri_pending_align
= 0;
1041 if (line_label
!= NULL
)
1043 symbol_set_frag (line_label
, frag_now
);
1044 S_SET_VALUE (line_label
, frag_now_fix ());
1048 /* Print the error msg now, while we still can. */
1051 char *end
= input_line_pointer
;
1053 (void) restore_line_pointer (nul_char
);
1055 nul_char
= next_char
= *--input_line_pointer
;
1056 *input_line_pointer
= '\0';
1057 if (! macro_defined
|| ! try_macro (next_char
, s
))
1060 as_bad (_("unknown pseudo-op: `%s'"), s
);
1061 *input_line_pointer
++ = nul_char
;
1066 /* Put it back for error messages etc. */
1067 next_char
= restore_line_pointer (nul_char
);
1068 /* The following skip of whitespace is compulsory.
1069 A well shaped space is sometimes all that separates
1070 keyword from operands. */
1071 if (next_char
== ' ' || next_char
== '\t')
1072 input_line_pointer
++;
1074 /* Input_line is restored.
1075 Input_line_pointer->1st non-blank char
1076 after pseudo-operation. */
1077 (*pop
->poc_handler
) (pop
->poc_val
);
1079 /* If that was .end, just get out now. */
1080 if (pop
->poc_handler
== s_end
)
1085 /* WARNING: next_char may be end-of-line. */
1086 /* Also: input_line_pointer->`\0` where nul_char was. */
1087 (void) restore_line_pointer (nul_char
);
1088 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1089 next_char
= nul_char
= *input_line_pointer
;
1090 *input_line_pointer
= '\0';
1092 generate_lineno_debug ();
1094 if (macro_defined
&& try_macro (next_char
, s
))
1097 if (mri_pending_align
)
1099 do_align (1, (char *) NULL
, 0, 0);
1100 mri_pending_align
= 0;
1101 if (line_label
!= NULL
)
1103 symbol_set_frag (line_label
, frag_now
);
1104 S_SET_VALUE (line_label
, frag_now_fix ());
1108 assemble_one (s
); /* Assemble 1 instruction. */
1110 *input_line_pointer
++ = nul_char
;
1112 /* We resume loop AFTER the end-of-line from
1113 this instruction. */
1119 /* Empty statement? */
1120 if (is_end_of_line
[(unsigned char) next_char
])
1123 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1125 /* local label ("4:") */
1126 char *backup
= input_line_pointer
;
1128 HANDLE_CONDITIONAL_ASSEMBLY (1);
1130 temp
= next_char
- '0';
1132 if (nul_char
== '"')
1133 ++ input_line_pointer
;
1135 /* Read the whole number. */
1136 while (ISDIGIT (*input_line_pointer
))
1138 temp
= (temp
* 10) + *input_line_pointer
- '0';
1139 ++input_line_pointer
;
1142 if (LOCAL_LABELS_DOLLAR
1143 && *input_line_pointer
== '$'
1144 && *(input_line_pointer
+ 1) == ':')
1146 input_line_pointer
+= 2;
1148 if (dollar_label_defined (temp
))
1150 as_fatal (_("label \"%d$\" redefined"), temp
);
1153 define_dollar_label (temp
);
1154 colon (dollar_label_name (temp
, 0));
1159 && *input_line_pointer
++ == ':')
1161 fb_label_instance_inc (temp
);
1162 colon (fb_label_name (temp
, 0));
1166 input_line_pointer
= backup
;
1169 if (next_char
&& strchr (line_comment_chars
, next_char
))
1170 { /* Its a comment. Better say APP or NO_APP. */
1175 unsigned int new_length
;
1178 s
= input_line_pointer
;
1179 if (strncmp (s
, "APP\n", 4))
1182 ignore_rest_of_line ();
1185 bump_line_counters ();
1188 ends
= strstr (s
, "#NO_APP\n");
1192 unsigned int tmp_len
;
1195 /* The end of the #APP wasn't in this buffer. We
1196 keep reading in buffers until we find the #NO_APP
1197 that goes with this #APP There is one. The specs
1199 tmp_len
= buffer_limit
- s
;
1200 tmp_buf
= (char *) xmalloc (tmp_len
+ 1);
1201 memcpy (tmp_buf
, s
, tmp_len
);
1204 new_tmp
= input_scrub_next_buffer (&buffer
);
1208 buffer_limit
= new_tmp
;
1209 input_line_pointer
= buffer
;
1210 ends
= strstr (buffer
, "#NO_APP\n");
1212 num
= ends
- buffer
;
1214 num
= buffer_limit
- buffer
;
1216 tmp_buf
= (char *) xrealloc (tmp_buf
, tmp_len
+ num
);
1217 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1222 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1230 input_line_pointer
= ends
+ 8;
1234 scrub_string_end
= ends
;
1236 new_length
= ends
- s
;
1237 new_buf
= (char *) xmalloc (new_length
);
1244 space
= (new_buf
+ new_length
) - new_tmp
;
1245 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1253 new_buf
= (char *) xrealloc (new_buf
, new_length
+ 100);
1254 new_tmp
= new_buf
+ new_length
;
1261 /* We've "scrubbed" input to the preferred format. In the
1262 process we may have consumed the whole of the remaining
1263 file (and included files). We handle this formatted
1264 input similar to that of macro expansion, letting
1265 actual macro expansion (possibly nested) and other
1266 input expansion work. Beware that in messages, line
1267 numbers and possibly file names will be incorrect. */
1268 new_length
= strlen (new_buf
);
1269 sb_build (&sbuf
, new_length
);
1270 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1271 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1273 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1278 HANDLE_CONDITIONAL_ASSEMBLY (1);
1280 #ifdef tc_unrecognized_line
1281 if (tc_unrecognized_line (next_char
))
1284 input_line_pointer
--;
1285 /* Report unknown char as error. */
1286 demand_empty_rest_of_line ();
1291 symbol_set_value_now (&dot_symbol
);
1293 #ifdef HANDLE_BUNDLE
1294 if (bundle_lock_frag
!= NULL
)
1296 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1297 _(".bundle_lock with no matching .bundle_unlock"));
1298 bundle_lock_frag
= NULL
;
1299 bundle_lock_frchain
= NULL
;
1300 bundle_lock_depth
= 0;
1307 /* Close the input file. */
1308 input_scrub_close ();
1309 #ifdef WARN_COMMENTS
1311 if (warn_comment
&& found_comment
)
1312 as_warn_where (found_comment_file
, found_comment
,
1313 "first comment found here");
1318 /* Convert O_constant expression EXP into the equivalent O_big representation.
1319 Take the sign of the number from SIGN rather than X_add_number. */
1322 convert_to_bignum (expressionS
*exp
, int sign
)
1327 value
= exp
->X_add_number
;
1328 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1330 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1331 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1333 /* Add a sequence of sign bits if the top bit of X_add_number is not
1334 the sign of the original value. */
1335 if ((exp
->X_add_number
< 0) == !sign
)
1336 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1338 exp
->X_add_number
= i
;
1341 /* For most MRI pseudo-ops, the line actually ends at the first
1342 nonquoted space. This function looks for that point, stuffs a null
1343 in, and sets *STOPCP to the character that used to be there, and
1344 returns the location.
1346 Until I hear otherwise, I am going to assume that this is only true
1347 for the m68k MRI assembler. */
1350 mri_comment_field (char *stopcp
)
1356 know (flag_m68k_mri
);
1358 for (s
= input_line_pointer
;
1359 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1367 for (s
= input_line_pointer
;
1368 !is_end_of_line
[(unsigned char) *s
];
1378 /* Skip to the end of an MRI comment field. */
1381 mri_comment_end (char *stop
, int stopc
)
1385 input_line_pointer
= stop
;
1387 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1388 ++input_line_pointer
;
1392 s_abort (int ignore ATTRIBUTE_UNUSED
)
1394 as_fatal (_(".abort detected. Abandoning ship."));
1397 /* Guts of .align directive. N is the power of two to which to align.
1398 FILL may be NULL, or it may point to the bytes of the fill pattern.
1399 LEN is the length of whatever FILL points to, if anything. MAX is
1400 the maximum number of characters to skip when doing the alignment,
1401 or 0 if there is no maximum. */
1404 do_align (int n
, char *fill
, int len
, int max
)
1406 if (now_seg
== absolute_section
)
1410 if (*fill
++ != '\0')
1412 as_warn (_("ignoring fill value in absolute section"));
1419 #ifdef md_flush_pending_output
1420 md_flush_pending_output ();
1423 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1426 /* Only make a frag if we HAVE to... */
1427 if (n
!= 0 && !need_pass_2
)
1431 if (subseg_text_p (now_seg
))
1432 frag_align_code (n
, max
);
1434 frag_align (n
, 0, max
);
1437 frag_align (n
, *fill
, max
);
1439 frag_align_pattern (n
, fill
, len
, max
);
1443 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
1446 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
1449 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1450 (in bytes). A negative ARG is the negative of the length of the
1451 fill pattern. BYTES_P is non-zero if the alignment value should be
1452 interpreted as the byte boundary, rather than the power of 2. */
1453 #ifndef TC_ALIGN_LIMIT
1454 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1458 s_align (int arg
, int bytes_p
)
1460 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1469 stop
= mri_comment_field (&stopc
);
1471 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1476 align
= arg
; /* Default value from pseudo-op table. */
1480 align
= get_absolute_expression ();
1483 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1484 if (arg
> 0 && align
== 0)
1491 /* Convert to a power of 2. */
1496 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1499 as_bad (_("alignment not a power of 2"));
1505 if (align
> align_limit
)
1507 align
= align_limit
;
1508 as_warn (_("alignment too large: %u assumed"), align
);
1511 if (*input_line_pointer
!= ',')
1518 ++input_line_pointer
;
1519 if (*input_line_pointer
== ',')
1523 fill
= get_absolute_expression ();
1528 if (*input_line_pointer
!= ',')
1532 ++input_line_pointer
;
1533 max
= get_absolute_expression ();
1540 as_warn (_("expected fill pattern missing"));
1541 do_align (align
, (char *) NULL
, 0, max
);
1556 do_align (align
, &fill_char
, fill_len
, max
);
1562 if ((size_t) fill_len
> sizeof ab
)
1564 md_number_to_chars (ab
, fill
, fill_len
);
1565 do_align (align
, ab
, fill_len
, max
);
1569 demand_empty_rest_of_line ();
1572 mri_comment_end (stop
, stopc
);
1575 /* Handle the .align pseudo-op on machines where ".align 4" means
1576 align to a 4 byte boundary. */
1579 s_align_bytes (int arg
)
1584 /* Handle the .align pseudo-op on machines where ".align 4" means align
1585 to a 2**4 boundary. */
1588 s_align_ptwo (int arg
)
1593 /* Switch in and out of alternate macro mode. */
1598 demand_empty_rest_of_line ();
1599 macro_set_alternate (on
);
1602 /* Read a symbol name from input_line_pointer.
1604 Stores the symbol name in a buffer and returns a pointer to this buffer.
1605 The buffer is xalloc'ed. It is the caller's responsibility to free
1608 The name is not left in the i_l_p buffer as it may need processing
1609 to handle escape characters.
1611 Advances i_l_p to the next non-whitespace character.
1613 If a symbol name could not be read, the routine issues an error
1614 messages, skips to the end of the line and returns NULL. */
1617 read_symbol_name (void)
1623 c
= *input_line_pointer
++;
1627 #define SYM_NAME_CHUNK_LEN 128
1628 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1632 start
= name
= xmalloc (len
+ 1);
1634 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1636 while (is_a_char (C
= next_char_of_string ()))
1638 if (name
>= name_end
)
1642 sofar
= name
- start
;
1643 len
+= SYM_NAME_CHUNK_LEN
;
1644 start
= xrealloc (start
, len
+ 1);
1645 name_end
= start
+ len
;
1646 name
= start
+ sofar
;
1653 /* Since quoted symbol names can contain non-ASCII characters,
1654 check the string and warn if it cannot be recognised by the
1655 current character set. */
1656 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1657 as_warn (_("symbol name not recognised in the current locale"));
1659 else if (is_name_beginner (c
) || c
== '\001')
1663 name
= input_line_pointer
- 1;
1665 /* We accept \001 in a name in case this is
1666 being called with a constructed string. */
1667 while (is_part_of_name (c
= *input_line_pointer
++)
1671 len
= (input_line_pointer
- name
) - 1;
1672 start
= xmalloc (len
+ 1);
1674 memcpy (start
, name
, len
);
1677 /* Skip a name ender char if one is present. */
1678 if (! is_name_ender (c
))
1679 --input_line_pointer
;
1682 name
= start
= NULL
;
1686 as_bad (_("expected symbol name"));
1687 ignore_rest_of_line ();
1698 s_comm_internal (int param
,
1699 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1703 symbolS
*symbolP
= NULL
;
1709 stop
= mri_comment_field (&stopc
);
1711 if ((name
= read_symbol_name ()) == NULL
)
1714 /* Accept an optional comma after the name. The comma used to be
1715 required, but Irix 5 cc does not generate it for .lcomm. */
1716 if (*input_line_pointer
== ',')
1717 input_line_pointer
++;
1719 temp
= get_absolute_expr (&exp
);
1721 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1722 if (exp
.X_op
== O_absent
)
1724 as_bad (_("missing size expression"));
1725 ignore_rest_of_line ();
1728 else if (temp
!= size
|| !exp
.X_unsigned
)
1730 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1731 ignore_rest_of_line ();
1735 symbolP
= symbol_find_or_make (name
);
1736 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1737 && !S_IS_COMMON (symbolP
))
1739 if (!S_IS_VOLATILE (symbolP
))
1742 as_bad (_("symbol `%s' is already defined"), name
);
1743 ignore_rest_of_line ();
1746 symbolP
= symbol_clone (symbolP
, 1);
1747 S_SET_SEGMENT (symbolP
, undefined_section
);
1748 S_SET_VALUE (symbolP
, 0);
1749 symbol_set_frag (symbolP
, &zero_address_frag
);
1750 S_CLEAR_VOLATILE (symbolP
);
1753 size
= S_GET_VALUE (symbolP
);
1756 else if (size
!= temp
)
1757 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1758 name
, (long) size
, (long) temp
);
1760 if (comm_parse_extra
!= NULL
)
1761 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1764 S_SET_VALUE (symbolP
, (valueT
) size
);
1765 S_SET_EXTERNAL (symbolP
);
1766 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1769 demand_empty_rest_of_line ();
1772 mri_comment_end (stop
, stopc
);
1781 s_comm_internal (ignore
, NULL
);
1784 /* The MRI COMMON pseudo-op. We handle this by creating a common
1785 symbol with the appropriate name. We make s_space do the right
1786 thing by increasing the size. */
1789 s_mri_common (int small ATTRIBUTE_UNUSED
)
1805 stop
= mri_comment_field (&stopc
);
1809 name
= input_line_pointer
;
1810 if (!ISDIGIT (*name
))
1811 c
= get_symbol_name (& name
);
1816 ++input_line_pointer
;
1818 while (ISDIGIT (*input_line_pointer
));
1820 c
= *input_line_pointer
;
1821 *input_line_pointer
= '\0';
1823 if (line_label
!= NULL
)
1825 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1826 + (input_line_pointer
- name
)
1828 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1833 sym
= symbol_find_or_make (name
);
1834 c
= restore_line_pointer (c
);
1838 if (*input_line_pointer
!= ',')
1842 ++input_line_pointer
;
1843 align
= get_absolute_expression ();
1846 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1848 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1849 ignore_rest_of_line ();
1850 mri_comment_end (stop
, stopc
);
1854 S_SET_EXTERNAL (sym
);
1855 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1856 mri_common_symbol
= sym
;
1860 S_SET_ALIGN (sym
, align
);
1865 if (line_label
!= NULL
)
1868 exp
.X_op
= O_symbol
;
1869 exp
.X_add_symbol
= sym
;
1870 exp
.X_add_number
= 0;
1871 symbol_set_value_expression (line_label
, &exp
);
1872 symbol_set_frag (line_label
, &zero_address_frag
);
1873 S_SET_SEGMENT (line_label
, expr_section
);
1876 /* FIXME: We just ignore the small argument, which distinguishes
1877 COMMON and COMMON.S. I don't know what we can do about it. */
1879 /* Ignore the type and hptype. */
1880 if (*input_line_pointer
== ',')
1881 input_line_pointer
+= 2;
1882 if (*input_line_pointer
== ',')
1883 input_line_pointer
+= 2;
1885 demand_empty_rest_of_line ();
1887 mri_comment_end (stop
, stopc
);
1891 s_data (int ignore ATTRIBUTE_UNUSED
)
1896 temp
= get_absolute_expression ();
1897 if (flag_readonly_data_in_text
)
1899 section
= text_section
;
1903 section
= data_section
;
1905 subseg_set (section
, (subsegT
) temp
);
1907 demand_empty_rest_of_line ();
1910 /* Handle the .appfile pseudo-op. This is automatically generated by
1911 do_scrub_chars when a preprocessor # line comment is seen with a
1912 file name. This default definition may be overridden by the object
1913 or CPU specific pseudo-ops. This function is also the default
1914 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1918 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1922 listing_source_file (file
);
1924 register_dependency (file
);
1926 obj_app_file (file
, appfile
);
1931 s_app_file (int appfile
)
1936 /* Some assemblers tolerate immediately following '"'. */
1937 if ((s
= demand_copy_string (&length
)) != 0)
1940 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1942 /* In MRI mode, the preprocessor may have inserted an extraneous
1945 && *input_line_pointer
== '\''
1946 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1947 ++input_line_pointer
;
1949 demand_empty_rest_of_line ();
1951 s_app_file_string (s
, appfile
);
1956 get_linefile_number (int *flag
)
1960 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1963 *flag
= get_absolute_expression ();
1968 /* Handle the .appline pseudo-op. This is automatically generated by
1969 do_scrub_chars when a preprocessor # line comment is seen. This
1970 default definition may be overridden by the object or CPU specific
1974 s_app_line (int appline
)
1979 /* The given number is that of the next line. */
1981 l
= get_absolute_expression ();
1982 else if (!get_linefile_number (&l
))
1984 ignore_rest_of_line ();
1991 /* Some of the back ends can't deal with non-positive line numbers.
1992 Besides, it's silly. GCC however will generate a line number of
1993 zero when it is pre-processing builtins for assembler-with-cpp files:
1997 We do not want to barf on this, especially since such files are used
1998 in the GCC and GDB testsuites. So we check for negative line numbers
1999 rather than non-positive line numbers. */
2000 as_warn (_("line numbers must be positive; line number %d rejected"),
2011 if (*input_line_pointer
== '"')
2012 file
= demand_copy_string (&length
);
2018 while (get_linefile_number (&this_flag
))
2021 /* From GCC's cpp documentation:
2022 1: start of a new file.
2023 2: returning to a file after having included
2025 3: following text comes from a system header file.
2026 4: following text should be treated as extern "C".
2028 4 is nonsensical for the assembler; 3, we don't
2029 care about, so we ignore it just in case a
2030 system header file is included while
2031 preprocessing assembly. So 1 and 2 are all we
2032 care about, and they are mutually incompatible.
2033 new_logical_line_flags() demands this. */
2036 if (flags
&& flags
!= (1 << this_flag
))
2037 as_warn (_("incompatible flag %i in line directive"),
2040 flags
|= 1 << this_flag
;
2045 /* We ignore these. */
2049 as_warn (_("unsupported flag %i in line directive"),
2054 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2059 if (appline
|| file
)
2061 new_logical_line_flags (file
, l
, flags
);
2064 listing_source_line (l
);
2068 if (appline
|| file
)
2069 demand_empty_rest_of_line ();
2071 ignore_rest_of_line ();
2074 /* Handle the .end pseudo-op. Actually, the real work is done in
2075 read_a_source_file. */
2078 s_end (int ignore ATTRIBUTE_UNUSED
)
2082 /* The MRI assembler permits the start symbol to follow .end,
2083 but we don't support that. */
2085 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2086 && *input_line_pointer
!= '*'
2087 && *input_line_pointer
!= '!')
2088 as_warn (_("start address not supported"));
2092 /* Handle the .err pseudo-op. */
2095 s_err (int ignore ATTRIBUTE_UNUSED
)
2097 as_bad (_(".err encountered"));
2098 demand_empty_rest_of_line ();
2101 /* Handle the .error and .warning pseudo-ops. */
2107 /* The purpose for the conditional assignment is not to
2108 internationalize the directive itself, but that we need a
2109 self-contained message, one that can be passed like the
2110 demand_copy_C_string return value, and with no assumption on the
2111 location of the name of the directive within the message. */
2113 = (err
? _(".error directive invoked in source file")
2114 : _(".warning directive invoked in source file"));
2116 if (!is_it_end_of_statement ())
2118 if (*input_line_pointer
!= '\"')
2120 as_bad (_("%s argument must be a string"),
2121 err
? ".error" : ".warning");
2122 ignore_rest_of_line ();
2126 msg
= demand_copy_C_string (&len
);
2134 as_warn ("%s", msg
);
2135 demand_empty_rest_of_line ();
2138 /* Handle the MRI fail pseudo-op. */
2141 s_fail (int ignore ATTRIBUTE_UNUSED
)
2148 stop
= mri_comment_field (&stopc
);
2150 temp
= get_absolute_expression ();
2152 as_warn (_(".fail %ld encountered"), (long) temp
);
2154 as_bad (_(".fail %ld encountered"), (long) temp
);
2156 demand_empty_rest_of_line ();
2159 mri_comment_end (stop
, stopc
);
2163 s_fill (int ignore ATTRIBUTE_UNUSED
)
2165 expressionS rep_exp
;
2170 #ifdef md_flush_pending_output
2171 md_flush_pending_output ();
2174 #ifdef md_cons_align
2178 get_known_segmented_expression (&rep_exp
);
2179 if (*input_line_pointer
== ',')
2181 input_line_pointer
++;
2182 size
= get_absolute_expression ();
2183 if (*input_line_pointer
== ',')
2185 input_line_pointer
++;
2186 fill
= get_absolute_expression ();
2190 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2191 #define BSD_FILL_SIZE_CROCK_8 (8)
2192 if (size
> BSD_FILL_SIZE_CROCK_8
)
2194 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2195 size
= BSD_FILL_SIZE_CROCK_8
;
2199 as_warn (_("size negative; .fill ignored"));
2202 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2204 if (rep_exp
.X_add_number
< 0)
2205 as_warn (_("repeat < 0; .fill ignored"));
2209 if (size
&& !need_pass_2
)
2211 if (rep_exp
.X_op
== O_constant
)
2213 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2214 (relax_substateT
) 0, (symbolS
*) 0,
2215 (offsetT
) rep_exp
.X_add_number
,
2220 /* We don't have a constant repeat count, so we can't use
2221 rs_fill. We can get the same results out of rs_space,
2222 but its argument is in bytes, so we must multiply the
2223 repeat count by size. */
2226 rep_sym
= make_expr_symbol (&rep_exp
);
2229 expressionS size_exp
;
2230 size_exp
.X_op
= O_constant
;
2231 size_exp
.X_add_number
= size
;
2233 rep_exp
.X_op
= O_multiply
;
2234 rep_exp
.X_add_symbol
= rep_sym
;
2235 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2236 rep_exp
.X_add_number
= 0;
2237 rep_sym
= make_expr_symbol (&rep_exp
);
2240 p
= frag_var (rs_space
, (int) size
, (int) size
,
2241 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2244 memset (p
, 0, (unsigned int) size
);
2246 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2247 flavoured AS. The following bizarre behaviour is to be
2248 compatible with above. I guess they tried to take up to 8
2249 bytes from a 4-byte expression and they forgot to sign
2251 #define BSD_FILL_SIZE_CROCK_4 (4)
2252 md_number_to_chars (p
, (valueT
) fill
,
2253 (size
> BSD_FILL_SIZE_CROCK_4
2254 ? BSD_FILL_SIZE_CROCK_4
2256 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2257 but emits no error message because it seems a legal thing to do.
2258 It is a degenerate case of .fill but could be emitted by a
2261 demand_empty_rest_of_line ();
2265 s_globl (int ignore ATTRIBUTE_UNUSED
)
2274 stop
= mri_comment_field (&stopc
);
2278 if ((name
= read_symbol_name ()) == NULL
)
2281 symbolP
= symbol_find_or_make (name
);
2282 S_SET_EXTERNAL (symbolP
);
2285 c
= *input_line_pointer
;
2288 input_line_pointer
++;
2290 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2298 demand_empty_rest_of_line ();
2301 mri_comment_end (stop
, stopc
);
2304 /* Handle the MRI IRP and IRPC pseudo-ops. */
2315 as_where (&file
, &line
);
2317 eol
= find_end_of_line (input_line_pointer
, 0);
2318 sb_build (&s
, eol
- input_line_pointer
);
2319 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2320 input_line_pointer
= eol
;
2324 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2326 as_bad_where (file
, line
, "%s", err
);
2330 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2332 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2335 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2336 the section to only be linked once. However, this is not supported
2337 by most object file formats. This takes an optional argument,
2338 which is what to do about duplicates. */
2341 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2343 enum linkonce_type type
;
2347 type
= LINKONCE_DISCARD
;
2349 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2354 c
= get_symbol_name (& s
);
2355 if (strcasecmp (s
, "discard") == 0)
2356 type
= LINKONCE_DISCARD
;
2357 else if (strcasecmp (s
, "one_only") == 0)
2358 type
= LINKONCE_ONE_ONLY
;
2359 else if (strcasecmp (s
, "same_size") == 0)
2360 type
= LINKONCE_SAME_SIZE
;
2361 else if (strcasecmp (s
, "same_contents") == 0)
2362 type
= LINKONCE_SAME_CONTENTS
;
2364 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2366 (void) restore_line_pointer (c
);
2369 #ifdef obj_handle_link_once
2370 obj_handle_link_once (type
);
2371 #else /* ! defined (obj_handle_link_once) */
2375 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2376 as_warn (_(".linkonce is not supported for this object file format"));
2378 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2379 flags
|= SEC_LINK_ONCE
;
2384 case LINKONCE_DISCARD
:
2385 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2387 case LINKONCE_ONE_ONLY
:
2388 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2390 case LINKONCE_SAME_SIZE
:
2391 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2393 case LINKONCE_SAME_CONTENTS
:
2394 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2397 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2398 as_bad (_("bfd_set_section_flags: %s"),
2399 bfd_errmsg (bfd_get_error ()));
2401 #endif /* ! defined (obj_handle_link_once) */
2403 demand_empty_rest_of_line ();
2407 bss_alloc (symbolS
*symbolP
, addressT size
, int align
)
2410 segT current_seg
= now_seg
;
2411 subsegT current_subseg
= now_subseg
;
2412 segT bss_seg
= bss_section
;
2414 #if defined (TC_MIPS) || defined (TC_ALPHA)
2415 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2416 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2418 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2419 if (size
<= bfd_get_gp_size (stdoutput
))
2421 bss_seg
= subseg_new (".sbss", 1);
2422 seg_info (bss_seg
)->bss
= 1;
2423 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2424 as_warn (_("error setting flags for \".sbss\": %s"),
2425 bfd_errmsg (bfd_get_error ()));
2429 subseg_set (bss_seg
, 1);
2433 record_alignment (bss_seg
, align
);
2434 frag_align (align
, 0, 0);
2437 /* Detach from old frag. */
2438 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2439 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2441 symbol_set_frag (symbolP
, frag_now
);
2442 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2446 S_SET_SIZE (symbolP
, size
);
2448 S_SET_SEGMENT (symbolP
, bss_seg
);
2451 /* The symbol may already have been created with a preceding
2452 ".globl" directive -- be careful not to step on storage class
2453 in that case. Otherwise, set it to static. */
2454 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2455 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2456 #endif /* OBJ_COFF */
2458 subseg_set (current_seg
, current_subseg
);
2462 parse_align (int align_bytes
)
2468 if (*input_line_pointer
!= ',')
2471 as_bad (_("expected alignment after size"));
2472 ignore_rest_of_line ();
2476 input_line_pointer
++;
2479 align
= get_absolute_expr (&exp
);
2480 if (exp
.X_op
== O_absent
)
2483 if (!exp
.X_unsigned
)
2485 as_warn (_("alignment negative; 0 assumed"));
2489 if (align_bytes
&& align
!= 0)
2491 /* convert to a power of 2 alignment */
2492 unsigned int alignp2
= 0;
2493 while ((align
& 1) == 0)
2494 align
>>= 1, ++alignp2
;
2497 as_bad (_("alignment not a power of 2"));
2498 ignore_rest_of_line ();
2506 /* Called from s_comm_internal after symbol name and size have been
2507 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2508 1 if this was a ".bss" directive which has a 3rd argument
2509 (alignment as a power of 2), or 2 if this was a ".bss" directive
2510 with alignment in bytes. */
2513 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2519 align
= parse_align (needs_align
- 1);
2520 if (align
== (addressT
) -1)
2524 /* Assume some objects may require alignment on some systems. */
2525 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2527 bss_alloc (symbolP
, size
, align
);
2532 s_lcomm (int needs_align
)
2534 s_comm_internal (needs_align
, s_lcomm_internal
);
2538 s_lcomm_bytes (int needs_align
)
2540 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2544 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2550 /* We permit ANY defined expression: BSD4.2 demands constants. */
2551 if ((name
= read_symbol_name ()) == NULL
)
2554 if (*input_line_pointer
!= ',')
2556 as_bad (_("expected comma after \"%s\""), name
);
2560 input_line_pointer
++;
2561 expression_and_evaluate (&exp
);
2563 if (exp
.X_op
!= O_constant
2564 && exp
.X_op
!= O_register
)
2566 as_bad (_("bad expression"));
2570 symbolP
= symbol_find_or_make (name
);
2572 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2574 /* The name might be an undefined .global symbol; be sure to
2575 keep the "external" bit. */
2576 S_SET_SEGMENT (symbolP
,
2577 (exp
.X_op
== O_constant
2580 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2584 as_bad (_("symbol `%s' is already defined"), name
);
2587 demand_empty_rest_of_line ();
2592 ignore_rest_of_line ();
2597 /* Read a line into an sb. Returns the character that ended the line
2598 or zero if there are no more lines. */
2601 get_line_sb (sb
*line
, int in_macro
)
2605 if (input_line_pointer
[-1] == '\n')
2606 bump_line_counters ();
2608 if (input_line_pointer
>= buffer_limit
)
2610 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2611 if (buffer_limit
== 0)
2615 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2616 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2617 input_line_pointer
= eol
;
2619 /* Don't skip multiple end-of-line characters, because that breaks support
2620 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2621 characters but isn't. Instead just skip one end of line character and
2622 return the character skipped so that the caller can re-insert it if
2624 return *input_line_pointer
++;
2628 get_non_macro_line_sb (sb
*line
)
2630 return get_line_sb (line
, 0);
2634 get_macro_line_sb (sb
*line
)
2636 return get_line_sb (line
, 1);
2639 /* Define a macro. This is an interface to macro.c. */
2642 s_macro (int ignore ATTRIBUTE_UNUSED
)
2650 as_where (&file
, &line
);
2652 eol
= find_end_of_line (input_line_pointer
, 0);
2653 sb_build (&s
, eol
- input_line_pointer
);
2654 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2655 input_line_pointer
= eol
;
2657 if (line_label
!= NULL
)
2662 name
= S_GET_NAME (line_label
);
2663 len
= strlen (name
);
2664 sb_build (&label
, len
);
2665 sb_add_buffer (&label
, name
, len
);
2666 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2670 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2672 as_bad_where (file
, line
, err
, name
);
2675 if (line_label
!= NULL
)
2677 S_SET_SEGMENT (line_label
, absolute_section
);
2678 S_SET_VALUE (line_label
, 0);
2679 symbol_set_frag (line_label
, &zero_address_frag
);
2682 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2683 && hash_find (po_hash
, name
) != NULL
)
2686 && hash_find (po_hash
, name
+ 1) != NULL
))
2687 as_warn_where (file
,
2689 _("attempt to redefine pseudo-op `%s' ignored"),
2696 /* Handle the .mexit pseudo-op, which immediately exits a macro
2700 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2704 cond_exit_macro (macro_nest
);
2705 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2708 as_warn (_("ignoring macro exit outside a macro definition."));
2711 /* Switch in and out of MRI mode. */
2714 s_mri (int ignore ATTRIBUTE_UNUSED
)
2717 #ifdef MRI_MODE_CHANGE
2721 on
= get_absolute_expression ();
2722 #ifdef MRI_MODE_CHANGE
2723 old_flag
= flag_mri
;
2742 /* Operator precedence changes in m68k MRI mode, so we need to
2743 update the operator rankings. */
2744 expr_set_precedence ();
2746 #ifdef MRI_MODE_CHANGE
2748 MRI_MODE_CHANGE (on
);
2751 demand_empty_rest_of_line ();
2754 /* Handle changing the location counter. */
2757 do_org (segT segment
, expressionS
*exp
, int fill
)
2759 if (segment
!= now_seg
2760 && segment
!= absolute_section
2761 && segment
!= expr_section
)
2762 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2764 if (now_seg
== absolute_section
)
2767 as_warn (_("ignoring fill value in absolute section"));
2768 if (exp
->X_op
!= O_constant
)
2770 as_bad (_("only constant offsets supported in absolute section"));
2771 exp
->X_add_number
= 0;
2773 abs_section_offset
= exp
->X_add_number
;
2778 symbolS
*sym
= exp
->X_add_symbol
;
2779 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2781 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2783 /* Handle complex expressions. */
2784 sym
= make_expr_symbol (exp
);
2788 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2794 s_org (int ignore ATTRIBUTE_UNUSED
)
2800 #ifdef md_flush_pending_output
2801 md_flush_pending_output ();
2804 /* The m68k MRI assembler has a different meaning for .org. It
2805 means to create an absolute section at a given address. We can't
2806 support that--use a linker script instead. */
2809 as_bad (_("MRI style ORG pseudo-op not supported"));
2810 ignore_rest_of_line ();
2814 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2815 thing as a sub-segment-relative origin. Any absolute origin is
2816 given a warning, then assumed to be segment-relative. Any
2817 segmented origin expression ("foo+42") had better be in the right
2818 segment or the .org is ignored.
2820 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2821 we never know sub-segment sizes when we are reading code. BSD
2822 will crash trying to emit negative numbers of filler bytes in
2823 certain .orgs. We don't crash, but see as-write for that code.
2825 Don't make frag if need_pass_2==1. */
2826 segment
= get_known_segmented_expression (&exp
);
2827 if (*input_line_pointer
== ',')
2829 input_line_pointer
++;
2830 temp_fill
= get_absolute_expression ();
2836 do_org (segment
, &exp
, temp_fill
);
2838 demand_empty_rest_of_line ();
2841 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2842 called by the obj-format routine which handles section changing
2843 when in MRI mode. It will create a new section, and return it. It
2844 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2845 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2848 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2858 name
= input_line_pointer
;
2859 if (!ISDIGIT (*name
))
2860 c
= get_symbol_name (& name
);
2865 ++input_line_pointer
;
2867 while (ISDIGIT (*input_line_pointer
));
2869 c
= *input_line_pointer
;
2870 *input_line_pointer
= '\0';
2873 name
= xstrdup (name
);
2875 c
= restore_line_pointer (c
);
2877 seg
= subseg_new (name
, 0);
2883 ++input_line_pointer
;
2884 align
= get_absolute_expression ();
2885 record_alignment (seg
, align
);
2889 if (*input_line_pointer
== ',')
2891 c
= *++input_line_pointer
;
2893 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2896 as_bad (_("unrecognized section type"));
2897 ++input_line_pointer
;
2902 flags
= SEC_NO_FLAGS
;
2904 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2905 else if (*type
== 'D' || *type
== 'M')
2906 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2907 else if (*type
== 'R')
2908 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2909 if (flags
!= SEC_NO_FLAGS
)
2911 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2912 as_warn (_("error setting flags for \"%s\": %s"),
2913 bfd_section_name (stdoutput
, seg
),
2914 bfd_errmsg (bfd_get_error ()));
2919 /* Ignore the HP type. */
2920 if (*input_line_pointer
== ',')
2921 input_line_pointer
+= 2;
2923 demand_empty_rest_of_line ();
2925 #else /* ! TC_M68K */
2934 c
= get_symbol_name (& name
);
2936 name
= xstrdup (name
);
2938 c
= restore_line_pointer (c
);
2940 seg
= subseg_new (name
, 0);
2948 ++input_line_pointer
;
2950 c
= get_symbol_name (& sectype
);
2951 if (*sectype
== '\0')
2953 else if (strcasecmp (sectype
, "text") == 0)
2955 else if (strcasecmp (sectype
, "data") == 0)
2957 else if (strcasecmp (sectype
, "romdata") == 0)
2960 as_warn (_("unrecognized section type `%s'"), sectype
);
2961 (void) restore_line_pointer (c
);
2964 if (*input_line_pointer
== ',')
2968 ++input_line_pointer
;
2970 c
= get_symbol_name (& seccmd
);
2971 if (strcasecmp (seccmd
, "absolute") == 0)
2973 as_bad (_("absolute sections are not supported"));
2974 *input_line_pointer
= c
;
2975 ignore_rest_of_line ();
2978 else if (strcasecmp (seccmd
, "align") == 0)
2982 (void) restore_line_pointer (c
);
2983 align
= get_absolute_expression ();
2984 record_alignment (seg
, align
);
2988 as_warn (_("unrecognized section command `%s'"), seccmd
);
2989 (void) restore_line_pointer (c
);
2993 demand_empty_rest_of_line ();
2995 #else /* ! TC_I960 */
2996 /* The MRI assembler seems to use different forms of .sect for
2997 different targets. */
2998 as_bad ("MRI mode not supported for this target");
2999 ignore_rest_of_line ();
3000 #endif /* ! TC_I960 */
3001 #endif /* ! TC_M68K */
3004 /* Handle the .print pseudo-op. */
3007 s_print (int ignore ATTRIBUTE_UNUSED
)
3012 s
= demand_copy_C_string (&len
);
3015 demand_empty_rest_of_line ();
3018 /* Handle the .purgem pseudo-op. */
3021 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3023 if (is_it_end_of_statement ())
3025 demand_empty_rest_of_line ();
3035 c
= get_symbol_name (& name
);
3036 delete_macro (name
);
3037 *input_line_pointer
= c
;
3038 SKIP_WHITESPACE_AFTER_NAME ();
3040 while (*input_line_pointer
++ == ',');
3042 --input_line_pointer
;
3043 demand_empty_rest_of_line ();
3046 /* Handle the .endm/.endr pseudo-ops. */
3049 s_bad_end (int endr
)
3051 as_warn (_(".end%c encountered without preceding %s"),
3053 endr
? ".rept, .irp, or .irpc" : ".macro");
3054 demand_empty_rest_of_line ();
3057 /* Handle the .rept pseudo-op. */
3060 s_rept (int ignore ATTRIBUTE_UNUSED
)
3064 count
= get_absolute_expression ();
3066 do_repeat (count
, "REPT", "ENDR");
3069 /* This function provides a generic repeat block implementation. It allows
3070 different directives to be used as the start/end keys. */
3073 do_repeat (int count
, const char *start
, const char *end
)
3079 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3081 as_bad (_("%s without %s"), start
, end
);
3085 sb_build (&many
, count
* one
.len
);
3087 sb_add_sb (&many
, &one
);
3091 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3093 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3096 /* Like do_repeat except that any text matching EXPANDER in the
3097 block is replaced by the itteration count. */
3100 do_repeat_with_expander (int count
,
3103 const char * expander
)
3109 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3111 as_bad (_("%s without %s"), start
, end
);
3117 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3119 while (count
-- > 0)
3125 sb_build (& processed
, one
.len
);
3126 sb_add_sb (& processed
, & one
);
3127 sub
= strstr (processed
.ptr
, expander
);
3128 len
= sprintf (sub
, "%d", count
);
3129 gas_assert (len
< 8);
3130 strcpy (sub
+ len
, sub
+ 8);
3131 processed
.len
-= (8 - len
);
3132 sb_add_sb (& many
, & processed
);
3133 sb_kill (& processed
);
3138 sb_add_sb (&many
, &one
);
3142 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3144 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3147 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3148 input buffers to skip. Assumes that conditionals preceding the loop end
3149 are properly nested.
3151 This function makes it easier to implement a premature "break" out of the
3152 loop. The EXTRA arg accounts for other buffers we might have inserted,
3153 such as line substitutions. */
3156 end_repeat (int extra
)
3158 cond_exit_macro (macro_nest
);
3159 while (extra
-- >= 0)
3160 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3164 assign_symbol (char *name
, int mode
)
3168 if (name
[0] == '.' && name
[1] == '\0')
3170 /* Turn '. = mumble' into a .org mumble. */
3174 segment
= get_known_segmented_expression (&exp
);
3177 do_org (segment
, &exp
, 0);
3182 if ((symbolP
= symbol_find (name
)) == NULL
3183 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3185 symbolP
= symbol_find_or_make (name
);
3187 /* When doing symbol listings, play games with dummy fragments living
3188 outside the normal fragment chain to record the file and line info
3190 if (listing
& LISTING_SYMBOLS
)
3192 extern struct list_info_struct
*listing_tail
;
3193 fragS
*dummy_frag
= (fragS
*) xcalloc (1, sizeof (fragS
));
3194 dummy_frag
->line
= listing_tail
;
3195 dummy_frag
->fr_symbol
= symbolP
;
3196 symbol_set_frag (symbolP
, dummy_frag
);
3199 #if defined (OBJ_COFF) && !defined (TE_PE)
3200 /* "set" symbols are local unless otherwise specified. */
3201 SF_SET_LOCAL (symbolP
);
3205 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3207 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3208 && !S_CAN_BE_REDEFINED (symbolP
))
3210 as_bad (_("symbol `%s' is already defined"), name
);
3211 symbolP
= symbol_clone (symbolP
, 0);
3213 /* If the symbol is volatile, copy the symbol and replace the
3214 original with the copy, so that previous uses of the symbol will
3215 retain the value of the symbol at the point of use. */
3216 else if (S_IS_VOLATILE (symbolP
))
3217 symbolP
= symbol_clone (symbolP
, 1);
3221 S_SET_VOLATILE (symbolP
);
3223 S_SET_FORWARD_REF (symbolP
);
3225 pseudo_set (symbolP
);
3228 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3229 then this is .equiv, and it is an error if the symbol is already
3230 defined. If EQUIV is -1, the symbol additionally is a forward
3238 /* Especial apologies for the random logic:
3239 this just grew, and could be parsed much more simply!
3241 if ((name
= read_symbol_name ()) == NULL
)
3244 if (*input_line_pointer
!= ',')
3246 as_bad (_("expected comma after \"%s\""), name
);
3247 ignore_rest_of_line ();
3252 input_line_pointer
++;
3253 assign_symbol (name
, equiv
);
3254 demand_empty_rest_of_line ();
3268 #ifdef md_flush_pending_output
3269 md_flush_pending_output ();
3272 #ifdef md_cons_align
3277 stop
= mri_comment_field (&stopc
);
3279 /* In m68k MRI mode, we need to align to a word boundary, unless
3281 if (flag_m68k_mri
&& mult
> 1)
3283 if (now_seg
== absolute_section
)
3285 abs_section_offset
+= abs_section_offset
& 1;
3286 if (line_label
!= NULL
)
3287 S_SET_VALUE (line_label
, abs_section_offset
);
3289 else if (mri_common_symbol
!= NULL
)
3293 mri_val
= S_GET_VALUE (mri_common_symbol
);
3294 if ((mri_val
& 1) != 0)
3296 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3297 if (line_label
!= NULL
)
3299 expressionS
*symexp
;
3301 symexp
= symbol_get_value_expression (line_label
);
3302 know (symexp
->X_op
== O_symbol
);
3303 know (symexp
->X_add_symbol
== mri_common_symbol
);
3304 symexp
->X_add_number
+= 1;
3310 do_align (1, (char *) NULL
, 0, 0);
3311 if (line_label
!= NULL
)
3313 symbol_set_frag (line_label
, frag_now
);
3314 S_SET_VALUE (line_label
, frag_now_fix ());
3324 if (*input_line_pointer
== ',')
3326 ++input_line_pointer
;
3331 val
.X_op
= O_constant
;
3332 val
.X_add_number
= 0;
3335 if (val
.X_op
!= O_constant
3336 || val
.X_add_number
< - 0x80
3337 || val
.X_add_number
> 0xff
3338 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3340 resolve_expression (&exp
);
3341 if (exp
.X_op
!= O_constant
)
3342 as_bad (_("unsupported variable size or fill value"));
3349 bytes
= mult
* exp
.X_add_number
;
3350 for (i
= 0; i
< exp
.X_add_number
; i
++)
3351 emit_expr (&val
, mult
);
3356 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3357 resolve_expression (&exp
);
3359 if (exp
.X_op
== O_constant
)
3363 repeat
= exp
.X_add_number
;
3370 as_warn (_(".space repeat count is zero, ignored"));
3371 else if (repeat
< 0)
3372 as_warn (_(".space repeat count is negative, ignored"));
3376 /* If we are in the absolute section, just bump the offset. */
3377 if (now_seg
== absolute_section
)
3379 abs_section_offset
+= repeat
;
3383 /* If we are secretly in an MRI common section, then
3384 creating space just increases the size of the common
3386 if (mri_common_symbol
!= NULL
)
3388 S_SET_VALUE (mri_common_symbol
,
3389 S_GET_VALUE (mri_common_symbol
) + repeat
);
3394 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3395 (offsetT
) repeat
, (char *) 0);
3399 if (now_seg
== absolute_section
)
3401 as_bad (_("space allocation too complex in absolute section"));
3402 subseg_set (text_section
, 0);
3405 if (mri_common_symbol
!= NULL
)
3407 as_bad (_("space allocation too complex in common section"));
3408 mri_common_symbol
= NULL
;
3412 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3413 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3417 *p
= val
.X_add_number
;
3422 /* In MRI mode, after an odd number of bytes, we must align to an
3423 even word boundary, unless the next instruction is a dc.b, ds.b
3425 if (flag_mri
&& (bytes
& 1) != 0)
3426 mri_pending_align
= 1;
3428 demand_empty_rest_of_line ();
3431 mri_comment_end (stop
, stopc
);
3434 /* This is like s_space, but the value is a floating point number with
3435 the given precision. This is for the MRI dcb.s pseudo-op and
3439 s_float_space (int float_type
)
3443 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3447 #ifdef md_cons_align
3452 stop
= mri_comment_field (&stopc
);
3454 count
= get_absolute_expression ();
3457 if (*input_line_pointer
!= ',')
3459 as_bad (_("missing value"));
3460 ignore_rest_of_line ();
3462 mri_comment_end (stop
, stopc
);
3466 ++input_line_pointer
;
3470 /* Skip any 0{letter} that may be present. Don't even check if the
3471 * letter is legal. */
3472 if (input_line_pointer
[0] == '0'
3473 && ISALPHA (input_line_pointer
[1]))
3474 input_line_pointer
+= 2;
3476 /* Accept :xxxx, where the x's are hex digits, for a floating point
3477 with the exact digits specified. */
3478 if (input_line_pointer
[0] == ':')
3480 flen
= hex_float (float_type
, temp
);
3483 ignore_rest_of_line ();
3485 mri_comment_end (stop
, stopc
);
3493 err
= md_atof (float_type
, temp
, &flen
);
3494 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3495 know (err
!= NULL
|| flen
> 0);
3498 as_bad (_("bad floating literal: %s"), err
);
3499 ignore_rest_of_line ();
3501 mri_comment_end (stop
, stopc
);
3506 while (--count
>= 0)
3510 p
= frag_more (flen
);
3511 memcpy (p
, temp
, (unsigned int) flen
);
3514 demand_empty_rest_of_line ();
3517 mri_comment_end (stop
, stopc
);
3520 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3523 s_struct (int ignore ATTRIBUTE_UNUSED
)
3529 stop
= mri_comment_field (&stopc
);
3530 abs_section_offset
= get_absolute_expression ();
3531 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3532 /* The ELF backend needs to know that we are changing sections, so
3533 that .previous works correctly. */
3535 obj_elf_section_change_hook ();
3537 subseg_set (absolute_section
, 0);
3538 demand_empty_rest_of_line ();
3540 mri_comment_end (stop
, stopc
);
3544 s_text (int ignore ATTRIBUTE_UNUSED
)
3548 temp
= get_absolute_expression ();
3549 subseg_set (text_section
, (subsegT
) temp
);
3550 demand_empty_rest_of_line ();
3553 /* .weakref x, y sets x as an alias to y that, as long as y is not
3554 referenced directly, will cause y to become a weak symbol. */
3556 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3563 if ((name
= read_symbol_name ()) == NULL
)
3566 symbolP
= symbol_find_or_make (name
);
3568 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3570 if (!S_IS_VOLATILE (symbolP
))
3572 as_bad (_("symbol `%s' is already defined"), name
);
3575 symbolP
= symbol_clone (symbolP
, 1);
3576 S_CLEAR_VOLATILE (symbolP
);
3581 if (*input_line_pointer
!= ',')
3583 as_bad (_("expected comma after \"%s\""), name
);
3587 input_line_pointer
++;
3592 if ((name
= read_symbol_name ()) == NULL
)
3595 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3596 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3598 symbolP2
= symbol_find_or_make (name
);
3599 S_SET_WEAKREFD (symbolP2
);
3603 symbolS
*symp
= symbolP2
;
3605 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3607 expressionS
*expP
= symbol_get_value_expression (symp
);
3609 gas_assert (expP
->X_op
== O_symbol
3610 && expP
->X_add_number
== 0);
3611 symp
= expP
->X_add_symbol
;
3613 if (symp
== symbolP
)
3617 loop
= concat (S_GET_NAME (symbolP
),
3618 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3621 while (symp
!= symbolP
)
3623 char *old_loop
= loop
;
3625 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3626 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3627 (const char *) NULL
);
3631 as_bad (_("%s: would close weakref loop: %s"),
3632 S_GET_NAME (symbolP
), loop
);
3636 ignore_rest_of_line ();
3640 /* Short-circuiting instead of just checking here might speed
3641 things up a tiny little bit, but loop error messages would
3642 miss intermediate links. */
3643 /* symbolP2 = symp; */
3646 memset (&exp
, 0, sizeof (exp
));
3647 exp
.X_op
= O_symbol
;
3648 exp
.X_add_symbol
= symbolP2
;
3650 S_SET_SEGMENT (symbolP
, undefined_section
);
3651 symbol_set_value_expression (symbolP
, &exp
);
3652 symbol_set_frag (symbolP
, &zero_address_frag
);
3653 S_SET_WEAKREFR (symbolP
);
3655 demand_empty_rest_of_line ();
3660 ignore_rest_of_line ();
3666 /* Verify that we are at the end of a line. If not, issue an error and
3670 demand_empty_rest_of_line (void)
3673 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3674 input_line_pointer
++;
3677 if (ISPRINT (*input_line_pointer
))
3678 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3679 *input_line_pointer
);
3681 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3682 *input_line_pointer
);
3683 ignore_rest_of_line ();
3686 /* Return pointing just after end-of-line. */
3687 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3690 /* Silently advance to the end of line. Use this after already having
3691 issued an error about something bad. */
3694 ignore_rest_of_line (void)
3696 while (input_line_pointer
< buffer_limit
3697 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3698 input_line_pointer
++;
3700 input_line_pointer
++;
3702 /* Return pointing just after end-of-line. */
3703 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3706 /* Sets frag for given symbol to zero_address_frag, except when the
3707 symbol frag is already set to a dummy listing frag. */
3710 set_zero_frag (symbolS
*symbolP
)
3712 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3713 symbol_set_frag (symbolP
, &zero_address_frag
);
3716 /* In: Pointer to a symbol.
3717 Input_line_pointer->expression.
3719 Out: Input_line_pointer->just after any whitespace after expression.
3720 Tried to set symbol to value of expression.
3721 Will change symbols type, value, and frag; */
3724 pseudo_set (symbolS
*symbolP
)
3729 know (symbolP
); /* NULL pointer is logic error. */
3731 if (!S_IS_FORWARD_REF (symbolP
))
3732 (void) expression (&exp
);
3734 (void) deferred_expression (&exp
);
3736 if (exp
.X_op
== O_illegal
)
3737 as_bad (_("illegal expression"));
3738 else if (exp
.X_op
== O_absent
)
3739 as_bad (_("missing expression"));
3740 else if (exp
.X_op
== O_big
)
3742 if (exp
.X_add_number
> 0)
3743 as_bad (_("bignum invalid"));
3745 as_bad (_("floating point number invalid"));
3747 else if (exp
.X_op
== O_subtract
3748 && !S_IS_FORWARD_REF (symbolP
)
3749 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3750 && (symbol_get_frag (exp
.X_add_symbol
)
3751 == symbol_get_frag (exp
.X_op_symbol
)))
3753 exp
.X_op
= O_constant
;
3754 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3755 - S_GET_VALUE (exp
.X_op_symbol
));
3758 if (symbol_section_p (symbolP
))
3760 as_bad ("attempt to set value of section symbol");
3769 exp
.X_add_number
= 0;
3772 S_SET_SEGMENT (symbolP
, absolute_section
);
3773 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3774 set_zero_frag (symbolP
);
3778 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3779 if (S_IS_EXTERNAL (symbolP
))
3781 as_bad ("can't equate global symbol `%s' with register name",
3782 S_GET_NAME (symbolP
));
3786 S_SET_SEGMENT (symbolP
, reg_section
);
3787 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3788 set_zero_frag (symbolP
);
3789 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3793 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3794 /* For x=undef+const, create an expression symbol.
3795 For x=x+const, just update x except when x is an undefined symbol
3796 For x=defined+const, evaluate x. */
3797 if (symbolP
== exp
.X_add_symbol
3798 && (seg
!= undefined_section
3799 || !symbol_constant_p (symbolP
)))
3801 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3804 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3806 symbolS
*s
= exp
.X_add_symbol
;
3808 if (S_IS_COMMON (s
))
3809 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3810 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3812 S_SET_SEGMENT (symbolP
, seg
);
3813 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3814 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3815 copy_symbol_attributes (symbolP
, s
);
3818 S_SET_SEGMENT (symbolP
, undefined_section
);
3819 symbol_set_value_expression (symbolP
, &exp
);
3820 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3821 set_zero_frag (symbolP
);
3825 /* The value is some complex expression. */
3826 S_SET_SEGMENT (symbolP
, expr_section
);
3827 symbol_set_value_expression (symbolP
, &exp
);
3828 set_zero_frag (symbolP
);
3835 CONStruct more frag of .bytes, or .words etc.
3836 Should need_pass_2 be 1 then emit no frag(s).
3837 This understands EXPRESSIONS.
3841 This has a split personality. We use expression() to read the
3842 value. We can detect if the value won't fit in a byte or word.
3843 But we can't detect if expression() discarded significant digits
3844 in the case of a long. Not worth the crocks required to fix it. */
3846 /* Select a parser for cons expressions. */
3848 /* Some targets need to parse the expression in various fancy ways.
3849 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3850 (for example, the HPPA does this). Otherwise, you can define
3851 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3852 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3853 are defined, which is the normal case, then only simple expressions
3858 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3861 #ifndef TC_PARSE_CONS_EXPRESSION
3862 #ifdef BITFIELD_CONS_EXPRESSIONS
3863 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3864 (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3866 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3868 #ifdef REPEAT_CONS_EXPRESSIONS
3869 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3870 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3872 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3875 /* If we haven't gotten one yet, just call expression. */
3876 #ifndef TC_PARSE_CONS_EXPRESSION
3877 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3878 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3883 do_parse_cons_expression (expressionS
*exp
,
3884 int nbytes ATTRIBUTE_UNUSED
)
3886 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3890 /* Worker to do .byte etc statements.
3891 Clobbers input_line_pointer and checks end-of-line. */
3894 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3902 #ifdef md_flush_pending_output
3903 md_flush_pending_output ();
3907 stop
= mri_comment_field (&stopc
);
3909 if (is_it_end_of_statement ())
3911 demand_empty_rest_of_line ();
3913 mri_comment_end (stop
, stopc
);
3917 #ifdef TC_ADDRESS_BYTES
3919 nbytes
= TC_ADDRESS_BYTES ();
3922 #ifdef md_cons_align
3923 md_cons_align (nbytes
);
3929 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
3930 #ifdef TC_CONS_FIX_CHECK
3931 fixS
**cur_fix
= &frchain_now
->fix_tail
;
3933 if (*cur_fix
!= NULL
)
3934 cur_fix
= &(*cur_fix
)->fx_next
;
3939 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3944 if (*input_line_pointer
== '"')
3946 as_bad (_("unexpected `\"' in expression"));
3947 ignore_rest_of_line ();
3951 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3956 if (exp
.X_op
== O_symbol
)
3957 exp
.X_op
= O_symbol_rva
;
3959 as_fatal (_("rva without symbol"));
3961 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
3962 #ifdef TC_CONS_FIX_CHECK
3963 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
3967 while (*input_line_pointer
++ == ',');
3969 /* In MRI mode, after an odd number of bytes, we must align to an
3970 even word boundary, unless the next instruction is a dc.b, ds.b
3972 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3973 mri_pending_align
= 1;
3975 input_line_pointer
--; /* Put terminator back into stream. */
3977 demand_empty_rest_of_line ();
3980 mri_comment_end (stop
, stopc
);
3986 cons_worker (size
, 0);
3992 cons_worker (size
, 1);
3995 /* .reloc offset, reloc_name, symbol+addend. */
3998 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4005 struct reloc_list
*reloc
;
4006 struct _bfd_rel
{ char *name
; bfd_reloc_code_real_type code
; };
4007 static struct _bfd_rel bfd_relocs
[] = {
4008 { "NONE", BFD_RELOC_NONE
},
4009 { "8", BFD_RELOC_8
},
4010 { "16", BFD_RELOC_16
},
4011 { "32", BFD_RELOC_32
},
4012 { "64", BFD_RELOC_64
}
4015 reloc
= (struct reloc_list
*) xmalloc (sizeof (*reloc
));
4018 stop
= mri_comment_field (&stopc
);
4027 as_bad (_("missing or bad offset expression"));
4030 exp
.X_add_symbol
= section_symbol (now_seg
);
4031 exp
.X_op
= O_symbol
;
4034 if (exp
.X_add_number
== 0)
4036 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4041 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4046 if (*input_line_pointer
!= ',')
4048 as_bad (_("missing reloc type"));
4052 ++input_line_pointer
;
4054 c
= get_symbol_name (& r_name
);
4055 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4059 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4060 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4062 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4063 bfd_relocs
[i
].code
);
4068 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4069 *input_line_pointer
= c
;
4070 if (reloc
->u
.a
.howto
== NULL
)
4072 as_bad (_("unrecognized reloc type"));
4076 exp
.X_op
= O_absent
;
4077 SKIP_WHITESPACE_AFTER_NAME ();
4078 if (*input_line_pointer
== ',')
4080 ++input_line_pointer
;
4088 as_bad (_("bad reloc expression"));
4090 ignore_rest_of_line ();
4093 mri_comment_end (stop
, stopc
);
4096 reloc
->u
.a
.sym
= NULL
;
4097 reloc
->u
.a
.addend
= 0;
4100 reloc
->u
.a
.sym
= NULL
;
4101 reloc
->u
.a
.addend
= exp
.X_add_number
;
4104 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4105 reloc
->u
.a
.addend
= exp
.X_add_number
;
4108 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4109 reloc
->u
.a
.addend
= 0;
4113 as_where (&reloc
->file
, &reloc
->line
);
4114 reloc
->next
= reloc_list
;
4117 demand_empty_rest_of_line ();
4119 mri_comment_end (stop
, stopc
);
4122 /* Put the contents of expression EXP into the object file using
4123 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4126 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4128 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4132 emit_expr_with_reloc (expressionS
*exp
,
4133 unsigned int nbytes
,
4134 TC_PARSE_CONS_RETURN_TYPE reloc
)
4138 valueT extra_digit
= 0;
4140 /* Don't do anything if we are going to make another pass. */
4145 dot_value
= frag_now_fix ();
4146 dot_frag
= frag_now
;
4150 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4151 appear as a four byte positive constant in the .line section,
4152 followed by a 2 byte 0xffff. Look for that case here. */
4154 static int dwarf_line
= -1;
4156 if (strcmp (segment_name (now_seg
), ".line") != 0)
4158 else if (dwarf_line
>= 0
4160 && exp
->X_op
== O_constant
4161 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4162 listing_source_line ((unsigned int) dwarf_line
);
4163 else if (nbytes
== 4
4164 && exp
->X_op
== O_constant
4165 && exp
->X_add_number
>= 0)
4166 dwarf_line
= exp
->X_add_number
;
4171 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4172 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4173 AT_sibling (0x12) followed by a four byte address of the sibling
4174 followed by a 2 byte AT_name (0x38) followed by the name of the
4175 file. We look for that case here. */
4177 static int dwarf_file
= 0;
4179 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4181 else if (dwarf_file
== 0
4183 && exp
->X_op
== O_constant
4184 && exp
->X_add_number
== 0x11)
4186 else if (dwarf_file
== 1
4188 && exp
->X_op
== O_constant
4189 && exp
->X_add_number
== 0x12)
4191 else if (dwarf_file
== 2
4194 else if (dwarf_file
== 3
4196 && exp
->X_op
== O_constant
4197 && exp
->X_add_number
== 0x38)
4202 /* The variable dwarf_file_string tells stringer that the string
4203 may be the name of the source file. */
4204 if (dwarf_file
== 4)
4205 dwarf_file_string
= 1;
4207 dwarf_file_string
= 0;
4212 if (check_eh_frame (exp
, &nbytes
))
4217 /* Allow `.word 0' in the absolute section. */
4218 if (now_seg
== absolute_section
)
4220 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4221 as_bad (_("attempt to store value in absolute section"));
4222 abs_section_offset
+= nbytes
;
4226 /* Handle a negative bignum. */
4228 && exp
->X_add_number
== 0
4229 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4230 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4233 unsigned long carry
;
4235 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4237 /* Negate the bignum: one's complement each digit and add 1. */
4239 for (i
= 0; i
< exp
->X_add_number
; i
++)
4243 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4246 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4247 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4250 /* We can ignore any carry out, because it will be handled by
4251 extra_digit if it is needed. */
4253 extra_digit
= (valueT
) -1;
4257 if (op
== O_absent
|| op
== O_illegal
)
4259 as_warn (_("zero assumed for missing expression"));
4260 exp
->X_add_number
= 0;
4263 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4265 as_bad (_("floating point number invalid"));
4266 exp
->X_add_number
= 0;
4269 else if (op
== O_register
)
4271 as_warn (_("register value used as expression"));
4275 p
= frag_more ((int) nbytes
);
4277 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4279 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4283 #ifndef WORKING_DOT_WORD
4284 /* If we have the difference of two symbols in a word, save it on
4285 the broken_words list. See the code in write.c. */
4286 if (op
== O_subtract
&& nbytes
== 2)
4288 struct broken_word
*x
;
4290 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
4291 x
->next_broken_word
= broken_words
;
4294 x
->subseg
= now_subseg
;
4296 x
->word_goes_here
= p
;
4298 x
->add
= exp
->X_add_symbol
;
4299 x
->sub
= exp
->X_op_symbol
;
4300 x
->addnum
= exp
->X_add_number
;
4308 /* If we have an integer, but the number of bytes is too large to
4309 pass to md_number_to_chars, handle it as a bignum. */
4310 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4312 extra_digit
= exp
->X_unsigned
? 0 : -1;
4313 convert_to_bignum (exp
, !exp
->X_unsigned
);
4317 if (op
== O_constant
)
4325 /* JF << of >= number of bits in the object is undefined. In
4326 particular SPARC (Sun 4) has problems. */
4327 if (nbytes
>= sizeof (valueT
))
4330 if (nbytes
> sizeof (valueT
))
4333 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4337 /* Don't store these bits. */
4338 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4339 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4342 unmask
= ~mask
; /* Do store these bits. */
4345 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4346 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4349 get
= exp
->X_add_number
;
4351 if ((get
& mask
) != 0
4352 && ((get
& mask
) != mask
4353 || (get
& hibit
) == 0))
4354 { /* Leading bits contain both 0s & 1s. */
4355 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4357 as_warn (_("value 0x%llx truncated to 0x%llx"),
4358 (unsigned long long) get
, (unsigned long long) use
);
4360 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4361 (unsigned long long) get
, (unsigned long long) use
);
4364 as_warn (_("value 0x%lx truncated to 0x%lx"),
4365 (unsigned long) get
, (unsigned long) use
);
4368 /* Put bytes in right order. */
4369 md_number_to_chars (p
, use
, (int) nbytes
);
4371 else if (op
== O_big
)
4374 LITTLENUM_TYPE
*nums
;
4376 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4379 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4382 LITTLENUM_TYPE sign
= 0;
4383 if ((generic_bignum
[--i
]
4384 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4385 sign
= ~(LITTLENUM_TYPE
) 0;
4386 while (++i
< exp
->X_add_number
)
4387 if (generic_bignum
[i
] != sign
)
4390 if (i
< exp
->X_add_number
)
4391 as_warn (_("bignum truncated to %d bytes"), nbytes
);
4397 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4400 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4402 if (target_big_endian
)
4404 while (nbytes
> size
)
4406 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4407 nbytes
-= CHARS_PER_LITTLENUM
;
4408 p
+= CHARS_PER_LITTLENUM
;
4411 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4412 while (size
>= CHARS_PER_LITTLENUM
)
4415 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4416 size
-= CHARS_PER_LITTLENUM
;
4417 p
+= CHARS_PER_LITTLENUM
;
4422 nums
= generic_bignum
;
4423 while (size
>= CHARS_PER_LITTLENUM
)
4425 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4427 size
-= CHARS_PER_LITTLENUM
;
4428 p
+= CHARS_PER_LITTLENUM
;
4429 nbytes
-= CHARS_PER_LITTLENUM
;
4432 while (nbytes
>= CHARS_PER_LITTLENUM
)
4434 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4435 nbytes
-= CHARS_PER_LITTLENUM
;
4436 p
+= CHARS_PER_LITTLENUM
;
4441 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4445 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4446 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4449 unsigned int size
= nbytes
;
4451 memset (p
, 0, size
);
4453 /* Generate a fixS to record the symbol value. */
4455 #ifdef TC_CONS_FIX_NEW
4456 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4458 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4460 reloc_howto_type
*reloc_howto
;
4462 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4463 size
= bfd_get_reloc_size (reloc_howto
);
4467 as_bad (_("%s relocations do not fit in %u bytes\n"),
4468 reloc_howto
->name
, nbytes
);
4471 else if (target_big_endian
)
4472 offset
= nbytes
- size
;
4493 as_bad (_("unsupported BFD relocation size %u"), size
);
4496 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4501 #ifdef BITFIELD_CONS_EXPRESSIONS
4503 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4504 w:x,y:z, where w and y are bitwidths and x and y are values. They
4505 then pack them all together. We do a little better in that we allow
4506 them in words, longs, etc. and we'll pack them in target byte order
4509 The rules are: pack least significant bit first, if a field doesn't
4510 entirely fit, put it in the next unit. Overflowing the bitfield is
4511 explicitly *not* even a warning. The bitwidth should be considered
4514 To use this function the tc-XXX.h file should define
4515 BITFIELD_CONS_EXPRESSIONS. */
4518 parse_bitfield_cons (exp
, nbytes
)
4520 unsigned int nbytes
;
4522 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4523 char *hold
= input_line_pointer
;
4525 (void) expression (exp
);
4527 if (*input_line_pointer
== ':')
4534 unsigned long width
;
4536 if (*input_line_pointer
!= ':')
4538 input_line_pointer
= hold
;
4540 } /* Next piece is not a bitfield. */
4542 /* In the general case, we can't allow
4543 full expressions with symbol
4544 differences and such. The relocation
4545 entries for symbols not defined in this
4546 assembly would require arbitrary field
4547 widths, positions, and masks which most
4548 of our current object formats don't
4551 In the specific case where a symbol
4552 *is* defined in this assembly, we
4553 *could* build fixups and track it, but
4554 this could lead to confusion for the
4555 backends. I'm lazy. I'll take any
4556 SEG_ABSOLUTE. I think that means that
4557 you can use a previous .set or
4558 .equ type symbol. xoxorich. */
4560 if (exp
->X_op
== O_absent
)
4562 as_warn (_("using a bit field width of zero"));
4563 exp
->X_add_number
= 0;
4564 exp
->X_op
= O_constant
;
4565 } /* Implied zero width bitfield. */
4567 if (exp
->X_op
!= O_constant
)
4569 *input_line_pointer
= '\0';
4570 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4571 *input_line_pointer
= ':';
4572 demand_empty_rest_of_line ();
4574 } /* Too complex. */
4576 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4578 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4579 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4580 width
= BITS_PER_CHAR
* nbytes
;
4583 if (width
> bits_available
)
4585 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4586 input_line_pointer
= hold
;
4587 exp
->X_add_number
= value
;
4592 hold
= ++input_line_pointer
;
4594 (void) expression (exp
);
4595 if (exp
->X_op
!= O_constant
)
4597 char cache
= *input_line_pointer
;
4599 *input_line_pointer
= '\0';
4600 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4601 *input_line_pointer
= cache
;
4602 demand_empty_rest_of_line ();
4604 } /* Too complex. */
4606 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4607 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4609 if ((bits_available
-= width
) == 0
4610 || is_it_end_of_statement ()
4611 || *input_line_pointer
!= ',')
4614 } /* All the bitfields we're gonna get. */
4616 hold
= ++input_line_pointer
;
4617 (void) expression (exp
);
4620 exp
->X_add_number
= value
;
4621 exp
->X_op
= O_constant
;
4622 exp
->X_unsigned
= 1;
4623 exp
->X_extrabit
= 0;
4627 #endif /* BITFIELD_CONS_EXPRESSIONS */
4629 /* Handle an MRI style string expression. */
4633 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4635 if (*input_line_pointer
!= '\''
4636 && (input_line_pointer
[1] != '\''
4637 || (*input_line_pointer
!= 'A'
4638 && *input_line_pointer
!= 'E')))
4639 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4643 unsigned int result
= 0;
4645 /* An MRI style string. Cut into as many bytes as will fit into
4646 a nbyte chunk, left justify if necessary, and separate with
4647 commas so we can try again later. */
4648 if (*input_line_pointer
== 'A')
4649 ++input_line_pointer
;
4650 else if (*input_line_pointer
== 'E')
4652 as_bad (_("EBCDIC constants are not supported"));
4653 ++input_line_pointer
;
4656 input_line_pointer
++;
4657 for (scan
= 0; scan
< nbytes
; scan
++)
4659 if (*input_line_pointer
== '\'')
4661 if (input_line_pointer
[1] == '\'')
4663 input_line_pointer
++;
4668 result
= (result
<< 8) | (*input_line_pointer
++);
4672 while (scan
< nbytes
)
4678 /* Create correct expression. */
4679 exp
->X_op
= O_constant
;
4680 exp
->X_add_number
= result
;
4682 /* Fake it so that we can read the next char too. */
4683 if (input_line_pointer
[0] != '\'' ||
4684 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4686 input_line_pointer
-= 2;
4687 input_line_pointer
[0] = ',';
4688 input_line_pointer
[1] = '\'';
4691 input_line_pointer
++;
4694 #endif /* TC_M68K */
4696 #ifdef REPEAT_CONS_EXPRESSIONS
4698 /* Parse a repeat expression for cons. This is used by the MIPS
4699 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4700 object file COUNT times.
4702 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4705 parse_repeat_cons (exp
, nbytes
)
4707 unsigned int nbytes
;
4714 if (*input_line_pointer
!= ':')
4716 /* No repeat count. */
4720 ++input_line_pointer
;
4721 expression (&count
);
4722 if (count
.X_op
!= O_constant
4723 || count
.X_add_number
<= 0)
4725 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4729 /* The cons function is going to output this expression once. So we
4730 output it count - 1 times. */
4731 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4732 emit_expr (exp
, nbytes
);
4735 #endif /* REPEAT_CONS_EXPRESSIONS */
4737 /* Parse a floating point number represented as a hex constant. This
4738 permits users to specify the exact bits they want in the floating
4742 hex_float (int float_type
, char *bytes
)
4774 as_bad (_("unknown floating type type '%c'"), float_type
);
4778 /* It would be nice if we could go through expression to parse the
4779 hex constant, but if we get a bignum it's a pain to sort it into
4780 the buffer correctly. */
4782 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4786 /* The MRI assembler accepts arbitrary underscores strewn about
4787 through the hex constant, so we ignore them as well. */
4788 if (*input_line_pointer
== '_')
4790 ++input_line_pointer
;
4796 as_warn (_("floating point constant too large"));
4799 d
= hex_value (*input_line_pointer
) << 4;
4800 ++input_line_pointer
;
4801 while (*input_line_pointer
== '_')
4802 ++input_line_pointer
;
4803 if (hex_p (*input_line_pointer
))
4805 d
+= hex_value (*input_line_pointer
);
4806 ++input_line_pointer
;
4808 if (target_big_endian
)
4811 bytes
[length
- i
- 1] = d
;
4817 if (target_big_endian
)
4818 memset (bytes
+ i
, 0, length
- i
);
4820 memset (bytes
, 0, length
- i
);
4828 CONStruct some more frag chars of .floats .ffloats etc.
4829 Makes 0 or more new frags.
4830 If need_pass_2 == 1, no frags are emitted.
4831 This understands only floating literals, not expressions. Sorry.
4833 A floating constant is defined by atof_generic(), except it is preceded
4834 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4835 reading, I decided to be incompatible. This always tries to give you
4836 rounded bits to the precision of the pseudo-op. Former AS did premature
4837 truncation, restored noisy bits instead of trailing 0s AND gave you
4838 a choice of 2 flavours of noise according to which of 2 floating-point
4839 scanners you directed AS to use.
4841 In: input_line_pointer->whitespace before, or '0' of flonum. */
4844 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4845 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4848 int length
; /* Number of chars in an object. */
4849 char *err
; /* Error from scanning floating literal. */
4850 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4852 if (is_it_end_of_statement ())
4854 demand_empty_rest_of_line ();
4858 #ifdef md_flush_pending_output
4859 md_flush_pending_output ();
4862 #ifdef md_cons_align
4868 /* input_line_pointer->1st char of a flonum (we hope!). */
4871 /* Skip any 0{letter} that may be present. Don't even check if the
4872 letter is legal. Someone may invent a "z" format and this routine
4873 has no use for such information. Lusers beware: you get
4874 diagnostics if your input is ill-conditioned. */
4875 if (input_line_pointer
[0] == '0'
4876 && ISALPHA (input_line_pointer
[1]))
4877 input_line_pointer
+= 2;
4879 /* Accept :xxxx, where the x's are hex digits, for a floating
4880 point with the exact digits specified. */
4881 if (input_line_pointer
[0] == ':')
4883 ++input_line_pointer
;
4884 length
= hex_float (float_type
, temp
);
4887 ignore_rest_of_line ();
4893 err
= md_atof (float_type
, temp
, &length
);
4894 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4895 know (err
!= NULL
|| length
> 0);
4898 as_bad (_("bad floating literal: %s"), err
);
4899 ignore_rest_of_line ();
4910 #ifdef REPEAT_CONS_EXPRESSIONS
4911 if (*input_line_pointer
== ':')
4913 expressionS count_exp
;
4915 ++input_line_pointer
;
4916 expression (&count_exp
);
4918 if (count_exp
.X_op
!= O_constant
4919 || count_exp
.X_add_number
<= 0)
4920 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4922 count
= count_exp
.X_add_number
;
4926 while (--count
>= 0)
4928 p
= frag_more (length
);
4929 memcpy (p
, temp
, (unsigned int) length
);
4934 while (*input_line_pointer
++ == ',');
4936 /* Put terminator back into stream. */
4937 --input_line_pointer
;
4938 demand_empty_rest_of_line ();
4941 /* Return the size of a LEB128 value. */
4944 sizeof_sleb128 (offsetT value
)
4951 byte
= (value
& 0x7f);
4952 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4953 Fortunately, we can structure things so that the extra work reduces
4954 to a noop on systems that do things "properly". */
4955 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4958 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4959 || ((value
== -1) && ((byte
& 0x40) != 0))));
4965 sizeof_uleb128 (valueT value
)
4980 sizeof_leb128 (valueT value
, int sign
)
4983 return sizeof_sleb128 ((offsetT
) value
);
4985 return sizeof_uleb128 (value
);
4988 /* Output a LEB128 value. */
4991 output_sleb128 (char *p
, offsetT value
)
4998 unsigned byte
= (value
& 0x7f);
5000 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
5001 Fortunately, we can structure things so that the extra work reduces
5002 to a noop on systems that do things "properly". */
5003 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5005 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5006 || ((value
== -1) && ((byte
& 0x40) != 0))));
5018 output_uleb128 (char *p
, valueT value
)
5024 unsigned byte
= (value
& 0x7f);
5027 /* More bytes to follow. */
5038 output_leb128 (char *p
, valueT value
, int sign
)
5041 return output_sleb128 (p
, (offsetT
) value
);
5043 return output_uleb128 (p
, value
);
5046 /* Do the same for bignums. We combine sizeof with output here in that
5047 we don't output for NULL values of P. It isn't really as critical as
5048 for "normal" values that this be streamlined. */
5051 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
5058 /* Strip leading sign extensions off the bignum. */
5060 && bignum
[size
- 1] == LITTLENUM_MASK
5061 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5066 /* OR in the next part of the littlenum. */
5067 val
|= (*bignum
<< loaded
);
5068 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5072 /* Add bytes until there are less than 7 bits left in VAL
5073 or until every non-sign bit has been written. */
5080 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5087 while ((byte
& 0x80) != 0 && loaded
>= 7);
5091 /* Mop up any left-over bits (of which there will be less than 7). */
5092 if ((byte
& 0x80) != 0)
5094 /* Sign-extend VAL. */
5095 if (val
& (1 << (loaded
- 1)))
5096 val
|= ~0U << loaded
;
5106 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
5113 /* Strip leading zeros off the bignum. */
5114 /* XXX: Is this needed? */
5115 while (size
> 0 && bignum
[size
- 1] == 0)
5120 if (loaded
< 7 && size
> 0)
5122 val
|= (*bignum
<< loaded
);
5123 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5132 if (size
> 0 || val
)
5139 while (byte
& 0x80);
5145 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
5148 return output_big_sleb128 (p
, bignum
, size
);
5150 return output_big_uleb128 (p
, bignum
, size
);
5153 /* Generate the appropriate fragments for a given expression to emit a
5157 emit_leb128_expr (expressionS
*exp
, int sign
)
5159 operatorT op
= exp
->X_op
;
5160 unsigned int nbytes
;
5162 if (op
== O_absent
|| op
== O_illegal
)
5164 as_warn (_("zero assumed for missing expression"));
5165 exp
->X_add_number
= 0;
5168 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5170 as_bad (_("floating point number invalid"));
5171 exp
->X_add_number
= 0;
5174 else if (op
== O_register
)
5176 as_warn (_("register value used as expression"));
5179 else if (op
== O_constant
5181 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5183 /* We're outputting a signed leb128 and the sign of X_add_number
5184 doesn't reflect the sign of the original value. Convert EXP
5185 to a correctly-extended bignum instead. */
5186 convert_to_bignum (exp
, exp
->X_extrabit
);
5190 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5191 a signal that this is leb128 data. It shouldn't optimize this away. */
5192 nbytes
= (unsigned int) -1;
5193 if (check_eh_frame (exp
, &nbytes
))
5196 /* Let the backend know that subsequent data may be byte aligned. */
5197 #ifdef md_cons_align
5201 if (op
== O_constant
)
5203 /* If we've got a constant, emit the thing directly right now. */
5205 valueT value
= exp
->X_add_number
;
5209 size
= sizeof_leb128 (value
, sign
);
5210 p
= frag_more (size
);
5211 output_leb128 (p
, value
, sign
);
5213 else if (op
== O_big
)
5215 /* O_big is a different sort of constant. */
5220 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
5221 p
= frag_more (size
);
5222 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
5226 /* Otherwise, we have to create a variable sized fragment and
5227 resolve things later. */
5229 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5230 make_expr_symbol (exp
), 0, (char *) NULL
);
5234 /* Parse the .sleb128 and .uleb128 pseudos. */
5241 #ifdef md_flush_pending_output
5242 md_flush_pending_output ();
5248 emit_leb128_expr (&exp
, sign
);
5250 while (*input_line_pointer
++ == ',');
5252 input_line_pointer
--;
5253 demand_empty_rest_of_line ();
5257 stringer_append_char (int c
, int bitsize
)
5259 if (!target_big_endian
)
5260 FRAG_APPEND_1_CHAR (c
);
5265 FRAG_APPEND_1_CHAR (0);
5266 FRAG_APPEND_1_CHAR (0);
5267 FRAG_APPEND_1_CHAR (0);
5268 FRAG_APPEND_1_CHAR (0);
5271 FRAG_APPEND_1_CHAR (0);
5272 FRAG_APPEND_1_CHAR (0);
5275 FRAG_APPEND_1_CHAR (0);
5280 /* Called with invalid bitsize argument. */
5284 if (target_big_endian
)
5285 FRAG_APPEND_1_CHAR (c
);
5288 /* Worker to do .ascii etc statements.
5289 Reads 0 or more ',' separated, double-quoted strings.
5290 Caller should have checked need_pass_2 is FALSE because we don't
5292 Checks for end-of-line.
5293 BITS_APPENDZERO says how many bits are in a target char.
5294 The bottom bit is set if a NUL char should be appended to the strings. */
5297 stringer (int bits_appendzero
)
5299 const int bitsize
= bits_appendzero
& ~7;
5300 const int append_zero
= bits_appendzero
& 1;
5302 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5306 #ifdef md_flush_pending_output
5307 md_flush_pending_output ();
5310 #ifdef md_cons_align
5314 /* The following awkward logic is to parse ZERO or more strings,
5315 comma separated. Recall a string expression includes spaces
5316 before the opening '\"' and spaces after the closing '\"'.
5317 We fake a leading ',' if there is (supposed to be)
5318 a 1st, expression. We keep demanding expressions for each ','. */
5319 if (is_it_end_of_statement ())
5321 c
= 0; /* Skip loop. */
5322 ++input_line_pointer
; /* Compensate for end of loop. */
5326 c
= ','; /* Do loop. */
5328 /* If we have been switched into the abs_section then we
5329 will not have an obstack onto which we can hang strings. */
5330 if (now_seg
== absolute_section
)
5332 as_bad (_("strings must be placed into a section"));
5334 ignore_rest_of_line ();
5337 while (c
== ',' || c
== '<' || c
== '"')
5340 switch (*input_line_pointer
)
5343 ++input_line_pointer
; /*->1st char of string. */
5344 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5345 start
= input_line_pointer
;
5348 while (is_a_char (c
= next_char_of_string ()))
5349 stringer_append_char (c
, bitsize
);
5352 stringer_append_char (0, bitsize
);
5354 know (input_line_pointer
[-1] == '\"');
5356 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5357 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5358 will emit .string with a filename in the .debug section
5359 after a sequence of constants. See the comment in
5360 emit_expr for the sequence. emit_expr will set
5361 dwarf_file_string to non-zero if this string might be a
5362 source file name. */
5363 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5364 dwarf_file_string
= 0;
5365 else if (dwarf_file_string
)
5367 c
= input_line_pointer
[-1];
5368 input_line_pointer
[-1] = '\0';
5369 listing_source_file (start
);
5370 input_line_pointer
[-1] = c
;
5376 input_line_pointer
++;
5377 c
= get_single_number ();
5378 stringer_append_char (c
, bitsize
);
5379 if (*input_line_pointer
!= '>')
5380 as_bad (_("expected <nn>"));
5382 input_line_pointer
++;
5385 input_line_pointer
++;
5389 c
= *input_line_pointer
;
5392 demand_empty_rest_of_line ();
5395 /* FIXME-SOMEDAY: I had trouble here on characters with the
5396 high bits set. We'll probably also have trouble with
5397 multibyte chars, wide chars, etc. Also be careful about
5398 returning values bigger than 1 byte. xoxorich. */
5401 next_char_of_string (void)
5405 c
= *input_line_pointer
++ & CHAR_MASK
;
5413 as_warn (_("unterminated string; newline inserted"));
5414 bump_line_counters ();
5417 #ifndef NO_STRING_ESCAPES
5419 switch (c
= *input_line_pointer
++)
5447 break; /* As itself. */
5463 for (i
= 0, number
= 0;
5464 ISDIGIT (c
) && i
< 3;
5465 c
= *input_line_pointer
++, i
++)
5467 number
= number
* 8 + c
- '0';
5472 --input_line_pointer
;
5481 c
= *input_line_pointer
++;
5482 while (ISXDIGIT (c
))
5485 number
= number
* 16 + c
- '0';
5486 else if (ISUPPER (c
))
5487 number
= number
* 16 + c
- 'A' + 10;
5489 number
= number
* 16 + c
- 'a' + 10;
5490 c
= *input_line_pointer
++;
5493 --input_line_pointer
;
5498 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5499 as_warn (_("unterminated string; newline inserted"));
5501 bump_line_counters ();
5506 #ifdef ONLY_STANDARD_ESCAPES
5507 as_bad (_("bad escaped character in string"));
5509 #endif /* ONLY_STANDARD_ESCAPES */
5514 #endif /* ! defined (NO_STRING_ESCAPES) */
5523 get_segmented_expression (expressionS
*expP
)
5527 retval
= expression (expP
);
5528 if (expP
->X_op
== O_illegal
5529 || expP
->X_op
== O_absent
5530 || expP
->X_op
== O_big
)
5532 as_bad (_("expected address expression"));
5533 expP
->X_op
= O_constant
;
5534 expP
->X_add_number
= 0;
5535 retval
= absolute_section
;
5541 get_known_segmented_expression (expressionS
*expP
)
5543 segT retval
= get_segmented_expression (expP
);
5545 if (retval
== undefined_section
)
5547 /* There is no easy way to extract the undefined symbol from the
5549 if (expP
->X_add_symbol
!= NULL
5550 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5551 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5552 S_GET_NAME (expP
->X_add_symbol
));
5554 as_warn (_("some symbol undefined; zero assumed"));
5555 retval
= absolute_section
;
5556 expP
->X_op
= O_constant
;
5557 expP
->X_add_number
= 0;
5562 char /* Return terminator. */
5563 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5565 /* FIXME: val_pointer should probably be offsetT *. */
5566 *val_pointer
= (long) get_absolute_expression ();
5567 return (*input_line_pointer
++);
5570 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5571 Give a warning if that happens. */
5574 demand_copy_C_string (int *len_pointer
)
5578 if ((s
= demand_copy_string (len_pointer
)) != 0)
5582 for (len
= *len_pointer
; len
> 0; len
--)
5589 as_bad (_("this string may not contain \'\\0\'"));
5597 /* Demand string, but return a safe (=private) copy of the string.
5598 Return NULL if we can't read a string here. */
5601 demand_copy_string (int *lenP
)
5609 if (*input_line_pointer
== '\"')
5611 input_line_pointer
++; /* Skip opening quote. */
5613 while (is_a_char (c
= next_char_of_string ()))
5615 obstack_1grow (¬es
, c
);
5618 /* JF this next line is so demand_copy_C_string will return a
5619 null terminated string. */
5620 obstack_1grow (¬es
, '\0');
5621 retval
= (char *) obstack_finish (¬es
);
5625 as_bad (_("missing string"));
5627 ignore_rest_of_line ();
5633 /* In: Input_line_pointer->next character.
5635 Do: Skip input_line_pointer over all whitespace.
5637 Out: 1 if input_line_pointer->end-of-line. */
5640 is_it_end_of_statement (void)
5643 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5647 equals (char *sym_name
, int reassign
)
5652 input_line_pointer
++;
5653 if (*input_line_pointer
== '=')
5654 input_line_pointer
++;
5655 if (reassign
< 0 && *input_line_pointer
== '=')
5656 input_line_pointer
++;
5658 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5659 input_line_pointer
++;
5662 stop
= mri_comment_field (&stopc
);
5664 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5668 demand_empty_rest_of_line ();
5669 mri_comment_end (stop
, stopc
);
5673 /* .incbin -- include a file verbatim at the current location. */
5676 s_incbin (int x ATTRIBUTE_UNUSED
)
5687 #ifdef md_flush_pending_output
5688 md_flush_pending_output ();
5691 #ifdef md_cons_align
5696 filename
= demand_copy_string (& len
);
5697 if (filename
== NULL
)
5702 /* Look for optional skip and count. */
5703 if (* input_line_pointer
== ',')
5705 ++ input_line_pointer
;
5706 skip
= get_absolute_expression ();
5710 if (* input_line_pointer
== ',')
5712 ++ input_line_pointer
;
5714 count
= get_absolute_expression ();
5716 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5722 demand_empty_rest_of_line ();
5724 /* Try opening absolute path first, then try include dirs. */
5725 binfile
= fopen (filename
, FOPEN_RB
);
5726 if (binfile
== NULL
)
5730 path
= (char *) xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5732 for (i
= 0; i
< include_dir_count
; i
++)
5734 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5736 binfile
= fopen (path
, FOPEN_RB
);
5737 if (binfile
!= NULL
)
5741 if (binfile
== NULL
)
5742 as_bad (_("file not found: %s"), filename
);
5745 path
= xstrdup (filename
);
5751 register_dependency (path
);
5753 /* Compute the length of the file. */
5754 if (fseek (binfile
, 0, SEEK_END
) != 0)
5756 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5759 file_len
= ftell (binfile
);
5761 /* If a count was not specified use the remainder of the file. */
5763 count
= file_len
- skip
;
5765 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5767 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5768 skip
, count
, file_len
);
5772 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5774 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5778 /* Allocate frag space and store file contents in it. */
5779 binfrag
= frag_more (count
);
5781 bytes
= fread (binfrag
, 1, count
, binfile
);
5783 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5784 path
, bytes
, count
);
5787 if (binfile
!= NULL
)
5793 /* .include -- include a file at this point. */
5796 s_include (int arg ATTRIBUTE_UNUSED
)
5805 filename
= demand_copy_string (&i
);
5806 if (filename
== NULL
)
5808 /* demand_copy_string has already printed an error and
5809 called ignore_rest_of_line. */
5817 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5818 && *input_line_pointer
!= ' '
5819 && *input_line_pointer
!= '\t')
5821 obstack_1grow (¬es
, *input_line_pointer
);
5822 ++input_line_pointer
;
5826 obstack_1grow (¬es
, '\0');
5827 filename
= (char *) obstack_finish (¬es
);
5828 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5829 ++input_line_pointer
;
5832 demand_empty_rest_of_line ();
5833 path
= (char *) xmalloc ((unsigned long) i
5834 + include_dir_maxlen
+ 5 /* slop */ );
5836 for (i
= 0; i
< include_dir_count
; i
++)
5838 strcpy (path
, include_dirs
[i
]);
5840 strcat (path
, filename
);
5841 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5851 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5852 register_dependency (path
);
5853 input_scrub_insert_file (path
);
5857 add_include_dir (char *path
)
5861 if (include_dir_count
== 0)
5863 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5864 include_dirs
[0] = "."; /* Current dir. */
5865 include_dir_count
= 2;
5869 include_dir_count
++;
5871 (char **) xrealloc (include_dirs
,
5872 include_dir_count
* sizeof (*include_dirs
));
5875 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5878 if (i
> include_dir_maxlen
)
5879 include_dir_maxlen
= i
;
5882 /* Output debugging information to denote the source file. */
5885 generate_file_debug (void)
5887 if (debug_type
== DEBUG_STABS
)
5888 stabs_generate_asm_file ();
5891 /* Output line number debugging information for the current source line. */
5894 generate_lineno_debug (void)
5898 case DEBUG_UNSPECIFIED
:
5903 stabs_generate_asm_lineno ();
5906 ecoff_generate_asm_lineno ();
5909 /* ??? We could here indicate to dwarf2dbg.c that something
5910 has changed. However, since there is additional backend
5911 support that is required (calling dwarf2_emit_insn), we
5912 let dwarf2dbg.c call as_where on its own. */
5917 /* Output debugging information to mark a function entry point or end point.
5918 END_P is zero for .func, and non-zero for .endfunc. */
5923 do_s_func (end_p
, NULL
);
5926 /* Subroutine of s_func so targets can choose a different default prefix.
5927 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5930 do_s_func (int end_p
, const char *default_prefix
)
5932 /* Record the current function so that we can issue an error message for
5933 misplaced .func,.endfunc, and also so that .endfunc needs no
5935 static char *current_name
;
5936 static char *current_label
;
5940 if (current_name
== NULL
)
5942 as_bad (_("missing .func"));
5943 ignore_rest_of_line ();
5947 if (debug_type
== DEBUG_STABS
)
5948 stabs_generate_asm_endfunc (current_name
, current_label
);
5950 current_name
= current_label
= NULL
;
5955 char delim1
, delim2
;
5957 if (current_name
!= NULL
)
5959 as_bad (_(".endfunc missing for previous .func"));
5960 ignore_rest_of_line ();
5964 delim1
= get_symbol_name (& name
);
5965 name
= xstrdup (name
);
5966 *input_line_pointer
= delim1
;
5967 SKIP_WHITESPACE_AFTER_NAME ();
5968 if (*input_line_pointer
!= ',')
5972 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5973 as_fatal ("%s", xstrerror (errno
));
5977 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5978 /* Missing entry point, use function's name with the leading
5982 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
5983 as_fatal ("%s", xstrerror (errno
));
5991 ++input_line_pointer
;
5993 delim2
= get_symbol_name (& label
);
5994 label
= xstrdup (label
);
5995 restore_line_pointer (delim2
);
5998 if (debug_type
== DEBUG_STABS
)
5999 stabs_generate_asm_func (name
, label
);
6001 current_name
= name
;
6002 current_label
= label
;
6005 demand_empty_rest_of_line ();
6008 #ifdef HANDLE_BUNDLE
6011 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6013 unsigned int align
= get_absolute_expression ();
6015 demand_empty_rest_of_line ();
6017 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6018 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6019 (unsigned int) TC_ALIGN_LIMIT
);
6021 if (bundle_lock_frag
!= NULL
)
6023 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6027 bundle_align_p2
= align
;
6031 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6033 demand_empty_rest_of_line ();
6035 if (bundle_align_p2
== 0)
6037 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6041 if (bundle_lock_depth
== 0)
6043 bundle_lock_frchain
= frchain_now
;
6044 bundle_lock_frag
= start_bundle ();
6046 ++bundle_lock_depth
;
6050 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6054 demand_empty_rest_of_line ();
6056 if (bundle_lock_frag
== NULL
)
6058 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6062 gas_assert (bundle_align_p2
> 0);
6064 gas_assert (bundle_lock_depth
> 0);
6065 if (--bundle_lock_depth
> 0)
6068 size
= pending_bundle_size (bundle_lock_frag
);
6070 if (size
> (1U << bundle_align_p2
))
6071 as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
6072 size
, 1 << bundle_align_p2
);
6074 finish_bundle (bundle_lock_frag
, size
);
6076 bundle_lock_frag
= NULL
;
6077 bundle_lock_frchain
= NULL
;
6080 #endif /* HANDLE_BUNDLE */
6083 s_ignore (int arg ATTRIBUTE_UNUSED
)
6085 ignore_rest_of_line ();
6089 read_print_statistics (FILE *file
)
6091 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6094 /* Inserts the given line into the input stream.
6096 This call avoids macro/conditionals nesting checking, since the contents of
6097 the line are assumed to replace the contents of a line already scanned.
6099 An appropriate use of this function would be substitution of input lines when
6100 called by md_start_line_hook(). The given line is assumed to already be
6101 properly scrubbed. */
6104 input_scrub_insert_line (const char *line
)
6107 size_t len
= strlen (line
);
6108 sb_build (&newline
, len
);
6109 sb_add_buffer (&newline
, line
, len
);
6110 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6112 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6115 /* Insert a file into the input stream; the path must resolve to an actual
6116 file; no include path searching or dependency registering is performed. */
6119 input_scrub_insert_file (char *path
)
6121 input_scrub_include_file (path
, input_line_pointer
);
6122 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6125 /* Find the end of a line, considering quotation and escaping of quotes. */
6127 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6128 # define TC_SINGLE_QUOTE_STRINGS 1
6132 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6135 char inquote
= '\0';
6138 while (!is_end_of_line
[(unsigned char) *s
]
6139 || (inquote
&& !ISCNTRL (*s
))
6140 || (inquote
== '\'' && flag_mri
)
6141 #ifdef TC_EOL_IN_INSN
6142 || (insn
&& TC_EOL_IN_INSN (s
))
6144 /* PR 6926: When we are parsing the body of a macro the sequence
6145 \@ is special - it refers to the invocation count. If the @
6146 character happens to be registered as a line-separator character
6147 by the target, then the is_end_of_line[] test above will have
6148 returned true, but we need to ignore the line separating
6149 semantics in this particular case. */
6150 || (in_macro
&& inescape
&& *s
== '@')
6153 if (mri_string
&& *s
== '\'')
6157 else if (*s
== '\\')
6161 #ifdef TC_SINGLE_QUOTE_STRINGS
6162 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6169 as_warn (_("missing closing `%c'"), inquote
);
6170 if (inescape
&& !ignore_input ())
6171 as_warn (_("stray `\\'"));
6176 find_end_of_line (char *s
, int mri_string
)
6178 return _find_end_of_line (s
, mri_string
, 0, 0);