1 /* read.c - read a source file -
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
22 But then, GNU isn't supposed to run on your machine anyway.
23 (RMS is so shortsighted sometimes.) */
24 #define MASK_CHAR ((int)(unsigned char) -1)
26 /* This is the largest known floating point format (for now). It will
27 grow when we do 4361 style flonums. */
28 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
30 /* Routines that read assembler source text to build spaghetti in memory.
31 Another group of these functions is in the expr.c module. */
34 #include "safe-ctype.h"
40 #include "dw2gencfi.h"
45 #ifndef TC_START_LABEL
46 #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
49 /* Set by the object-format or the target. */
50 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
51 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
56 else if ((SIZE) >= 4) \
58 else if ((SIZE) >= 2) \
66 char *input_line_pointer
; /*->next char of source file to parse. */
67 bfd_boolean input_from_string
= FALSE
;
69 #if BITS_PER_CHAR != 8
70 /* The following table is indexed by[(char)] and will break if
71 a char does not have exactly 256 states (hopefully 0:255!)! */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
96 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The Delta 68k assembler permits ~ at start of label names. */
109 /* Used by is_... macros. our ctype[]. */
110 char lex_type
[256] = {
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
113 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
115 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
117 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
130 Out: 1 if this character ends a line.
131 2 if this character is a line separator. */
132 char is_end_of_line
[256] = {
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
136 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
155 #ifndef TC_CASE_SENSITIVE
156 char original_case_string
[128];
159 /* Functions private to this file. */
161 static char *buffer
; /* 1st char of each buffer of lines is here. */
162 static char *buffer_limit
; /*->1 + last char in buffer. */
164 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
165 in the tc-<CPU>.h file. See the "Porting GAS" section of the
167 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
169 /* Variables for handling include file directory table. */
171 /* Table of pointers to directories to search for .include's. */
172 const char **include_dirs
;
174 /* How many are in the table. */
175 int include_dir_count
;
177 /* Length of longest in table. */
178 int include_dir_maxlen
= 1;
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
207 /* This variable is set to be non-zero if the next string we see might
208 be the name of the source file in DWARF debugging information. See
209 the comment in emit_expr for the format we look for. */
210 static int dwarf_file_string
;
214 /* If the target defines the md_frag_max_var hook then we know
215 enough to implement the .bundle_align_mode features. */
216 #ifdef md_frag_max_var
217 # define HANDLE_BUNDLE
221 /* .bundle_align_mode sets this. Normally it's zero. When nonzero,
222 it's the exponent of the bundle size, and aligned instruction bundle
223 mode is in effect. */
224 static unsigned int bundle_align_p2
;
226 /* These are set by .bundle_lock and .bundle_unlock. .bundle_lock sets
227 bundle_lock_frag to frag_now and then starts a new frag with
228 frag_align_code. At the same time, bundle_lock_frain gets frchain_now,
229 so that .bundle_unlock can verify that we didn't change segments.
230 .bundle_unlock resets both to NULL. If we detect a bundling violation,
231 then we reset bundle_lock_frchain to NULL as an indicator that we've
232 already diagnosed the error with as_bad and don't need a cascade of
233 redundant errors, but bundle_lock_frag remains set to indicate that
234 we are expecting to see .bundle_unlock. */
235 static fragS
*bundle_lock_frag
;
236 static frchainS
*bundle_lock_frchain
;
238 /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
240 static unsigned int bundle_lock_depth
;
243 static void do_s_func (int end_p
, const char *default_prefix
);
244 static void s_align (int, int);
245 static void s_altmacro (int);
246 static void s_bad_end (int);
247 static void s_reloc (int);
248 static int hex_float (int, char *);
249 static segT
get_known_segmented_expression (expressionS
* expP
);
250 static void pobegin (void);
251 static size_t get_non_macro_line_sb (sb
*);
252 static void generate_file_debug (void);
253 static char *_find_end_of_line (char *, int, int, int);
261 obj_read_begin_hook ();
263 /* Something close -- but not too close -- to a multiple of 1024.
264 The debugging malloc I'm using has 24 bytes of overhead. */
265 obstack_begin (¬es
, chunksize
);
266 obstack_begin (&cond_obstack
, chunksize
);
268 #ifndef tc_line_separator_chars
269 #define tc_line_separator_chars line_separator_chars
271 /* Use machine dependent syntax. */
272 for (p
= tc_line_separator_chars
; *p
; p
++)
273 is_end_of_line
[(unsigned char) *p
] = 2;
274 /* Use more. FIXME-SOMEDAY. */
280 #ifndef TC_ADDRESS_BYTES
281 #define TC_ADDRESS_BYTES address_bytes
286 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
287 contain an address. */
288 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
296 /* Set up pseudo-op tables. */
298 static struct hash_control
*po_hash
;
300 static const pseudo_typeS potable
[] = {
301 {"abort", s_abort
, 0},
302 {"align", s_align_ptwo
, 0},
303 {"altmacro", s_altmacro
, 1},
304 {"ascii", stringer
, 8+0},
305 {"asciz", stringer
, 8+1},
306 {"balign", s_align_bytes
, 0},
307 {"balignw", s_align_bytes
, -2},
308 {"balignl", s_align_bytes
, -4},
311 {"bundle_align_mode", s_bundle_align_mode
, 0},
312 {"bundle_lock", s_bundle_lock
, 0},
313 {"bundle_unlock", s_bundle_unlock
, 0},
317 {"common", s_mri_common
, 0},
318 {"common.s", s_mri_common
, 1},
321 #ifdef TC_ADDRESS_BYTES
325 {"dc.d", float_cons
, 'd'},
327 {"dc.s", float_cons
, 'f'},
329 {"dc.x", float_cons
, 'x'},
331 {"dcb.b", s_space
, 1},
332 {"dcb.d", s_float_space
, 'd'},
333 {"dcb.l", s_space
, 4},
334 {"dcb.s", s_float_space
, 'f'},
335 {"dcb.w", s_space
, 2},
336 {"dcb.x", s_float_space
, 'x'},
338 {"ds.b", s_space
, 1},
339 {"ds.d", s_space
, 8},
340 {"ds.l", s_space
, 4},
341 {"ds.p", s_space
, 12},
342 {"ds.s", s_space
, 4},
343 {"ds.w", s_space
, 2},
344 {"ds.x", s_space
, 12},
345 {"debug", s_ignore
, 0},
350 {"double", float_cons
, 'd'},
352 {"eject", listing_eject
, 0}, /* Formfeed listing. */
354 {"elsec", s_else
, 0},
355 {"elseif", s_elseif
, (int) O_ne
},
357 {"endc", s_endif
, 0},
358 {"endfunc", s_func
, 1},
359 {"endif", s_endif
, 0},
360 {"endm", s_bad_end
, 0},
361 {"endr", s_bad_end
, 1},
367 {"error", s_errwarn
, 1},
368 {"exitm", s_mexit
, 0},
370 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
371 {"appfile", s_app_file
, 1},
372 {"appline", s_app_line
, 1},
374 {"file", s_app_file
, 0},
376 {"float", float_cons
, 'f'},
377 {"format", s_ignore
, 0},
379 {"global", s_globl
, 0},
380 {"globl", s_globl
, 0},
382 {"if", s_if
, (int) O_ne
},
385 {"ifdef", s_ifdef
, 0},
386 {"ifeq", s_if
, (int) O_eq
},
387 {"ifeqs", s_ifeqs
, 0},
388 {"ifge", s_if
, (int) O_ge
},
389 {"ifgt", s_if
, (int) O_gt
},
390 {"ifle", s_if
, (int) O_le
},
391 {"iflt", s_if
, (int) O_lt
},
394 {"ifndef", s_ifdef
, 1},
395 {"ifne", s_if
, (int) O_ne
},
396 {"ifnes", s_ifeqs
, 1},
397 {"ifnotdef", s_ifdef
, 1},
398 {"incbin", s_incbin
, 0},
399 {"include", s_include
, 0},
405 {"lcomm", s_lcomm
, 0},
406 {"lflags", s_ignore
, 0}, /* Listing flags. */
407 {"linefile", s_app_line
, 0},
408 {"linkonce", s_linkonce
, 0},
409 {"list", listing_list
, 1}, /* Turn listing on. */
410 {"llen", listing_psize
, 1},
413 {"macro", s_macro
, 0},
414 {"mexit", s_mexit
, 0},
416 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
417 {"name", s_ignore
, 0},
418 {"noaltmacro", s_altmacro
, 0},
419 {"noformat", s_ignore
, 0},
420 {"nolist", listing_list
, 0}, /* Turn listing off. */
421 {"nopage", listing_nopage
, 0},
424 {"offset", s_struct
, 0},
426 {"p2align", s_align_ptwo
, 0},
427 {"p2alignw", s_align_ptwo
, -2},
428 {"p2alignl", s_align_ptwo
, -4},
429 {"page", listing_eject
, 0},
430 {"plen", listing_psize
, 0},
431 {"print", s_print
, 0},
432 {"psize", listing_psize
, 0}, /* Set paper size. */
433 {"purgem", s_purgem
, 0},
435 {"reloc", s_reloc
, 0},
439 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
444 {"single", float_cons
, 'f'},
446 {"space", s_space
, 0},
447 {"skip", s_space
, 0},
448 {"sleb128", s_leb128
, 1},
449 {"spc", s_ignore
, 0},
450 {"stabd", s_stab
, 'd'},
451 {"stabn", s_stab
, 'n'},
452 {"stabs", s_stab
, 's'},
453 {"string", stringer
, 8+1},
454 {"string8", stringer
, 8+1},
455 {"string16", stringer
, 16+1},
456 {"string32", stringer
, 32+1},
457 {"string64", stringer
, 64+1},
458 {"struct", s_struct
, 0},
462 /* This is for gcc to use. It's only just been added (2/94), so gcc
463 won't be able to use it for a while -- probably a year or more.
464 But once this has been released, check with gcc maintainers
465 before deleting it or even changing the spelling. */
466 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
467 /* If we're folding case -- done for some targets, not necessarily
468 all -- the above string in an input file will be converted to
469 this one. Match it either way... */
470 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
472 {"title", listing_title
, 0}, /* Listing title. */
473 {"ttl", listing_title
, 0},
475 {"uleb128", s_leb128
, 0},
479 {"xdef", s_globl
, 0},
480 {"xref", s_ignore
, 0},
481 {"xstabs", s_xstab
, 's'},
482 {"warning", s_errwarn
, 0},
483 {"weakref", s_weakref
, 0},
485 {"zero", s_space
, 0},
486 {NULL
, NULL
, 0} /* End sentinel. */
490 get_absolute_expr (expressionS
*exp
)
492 expression_and_evaluate (exp
);
494 if (exp
->X_op
!= O_constant
)
496 if (exp
->X_op
!= O_absent
)
497 as_bad (_("bad or irreducible absolute expression"));
498 exp
->X_add_number
= 0;
500 return exp
->X_add_number
;
504 get_absolute_expression (void)
508 return get_absolute_expr (&exp
);
511 static int pop_override_ok
= 0;
512 static const char *pop_table_name
;
515 pop_insert (const pseudo_typeS
*table
)
518 const pseudo_typeS
*pop
;
519 for (pop
= table
; pop
->poc_name
; pop
++)
521 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
522 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
523 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
528 #ifndef md_pop_insert
529 #define md_pop_insert() pop_insert(md_pseudo_table)
532 #ifndef obj_pop_insert
533 #define obj_pop_insert() pop_insert(obj_pseudo_table)
536 #ifndef cfi_pop_insert
537 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
543 po_hash
= hash_new ();
545 /* Do the target-specific pseudo ops. */
546 pop_table_name
= "md";
549 /* Now object specific. Skip any that were in the target table. */
550 pop_table_name
= "obj";
554 /* Now portable ones. Skip any that we've seen already. */
555 pop_table_name
= "standard";
556 pop_insert (potable
);
559 pop_table_name
= "cfi";
564 #define HANDLE_CONDITIONAL_ASSEMBLY(num_read) \
565 if (ignore_input ()) \
567 char *eol = find_end_of_line (input_line_pointer - (num_read), \
569 input_line_pointer = (input_line_pointer <= buffer_limit \
570 && eol >= buffer_limit) \
576 /* This function is used when scrubbing the characters between #APP
579 static char *scrub_string
;
580 static char *scrub_string_end
;
583 scrub_from_string (char *buf
, size_t buflen
)
587 copy
= scrub_string_end
- scrub_string
;
590 memcpy (buf
, scrub_string
, copy
);
591 scrub_string
+= copy
;
595 /* Helper function of read_a_source_file, which tries to expand a macro. */
597 try_macro (char term
, const char *line
)
603 if (check_macro (line
, &out
, &err
, ¯o
))
607 *input_line_pointer
++ = term
;
608 input_scrub_include_sb (&out
,
609 input_line_pointer
, 1);
612 input_scrub_next_buffer (&input_line_pointer
);
614 md_macro_info (macro
);
622 /* Start a new instruction bundle. Returns the rs_align_code frag that
623 will be used to align the new bundle. */
627 fragS
*frag
= frag_now
;
629 frag_align_code (0, 0);
631 while (frag
->fr_type
!= rs_align_code
)
632 frag
= frag
->fr_next
;
634 gas_assert (frag
!= frag_now
);
639 /* Calculate the maximum size after relaxation of the region starting
640 at the given frag and extending through frag_now (which is unfinished). */
642 pending_bundle_size (fragS
*frag
)
644 unsigned int offset
= frag
->fr_fix
;
645 unsigned int size
= 0;
647 gas_assert (frag
!= frag_now
);
648 gas_assert (frag
->fr_type
== rs_align_code
);
650 while (frag
!= frag_now
)
652 /* This should only happen in what will later become an error case. */
656 size
+= frag
->fr_fix
;
657 if (frag
->fr_type
== rs_machine_dependent
)
658 size
+= md_frag_max_var (frag
);
660 frag
= frag
->fr_next
;
663 gas_assert (frag
== frag_now
);
664 size
+= frag_now_fix ();
665 if (frag
->fr_type
== rs_machine_dependent
)
666 size
+= md_frag_max_var (frag
);
668 gas_assert (size
>= offset
);
670 return size
- offset
;
673 /* Finish off the frag created to ensure bundle alignment. */
675 finish_bundle (fragS
*frag
, unsigned int size
)
677 gas_assert (bundle_align_p2
> 0);
678 gas_assert (frag
->fr_type
== rs_align_code
);
682 /* If there is more than a single byte, then we need to set up the
683 alignment frag. Otherwise we leave it at its initial state from
684 calling frag_align_code (0, 0), so that it does nothing. */
685 frag
->fr_offset
= bundle_align_p2
;
686 frag
->fr_subtype
= size
- 1;
689 /* We do this every time rather than just in s_bundle_align_mode
690 so that we catch any affected section without needing hooks all
691 over for all paths that do section changes. It's cheap enough. */
692 if (bundle_align_p2
> OCTETS_PER_BYTE_POWER
)
693 record_alignment (now_seg
, bundle_align_p2
- OCTETS_PER_BYTE_POWER
);
696 /* Assemble one instruction. This takes care of the bundle features
697 around calling md_assemble. */
699 assemble_one (char *line
)
701 fragS
*insn_start_frag
= NULL
;
703 if (bundle_lock_frchain
!= NULL
&& bundle_lock_frchain
!= frchain_now
)
705 as_bad (_("cannot change section or subsection inside .bundle_lock"));
706 /* Clearing this serves as a marker that we have already complained. */
707 bundle_lock_frchain
= NULL
;
710 if (bundle_lock_frchain
== NULL
&& bundle_align_p2
> 0)
711 insn_start_frag
= start_bundle ();
715 if (bundle_lock_frchain
!= NULL
)
717 /* Make sure this hasn't pushed the locked sequence
718 past the bundle size. */
719 unsigned int bundle_size
= pending_bundle_size (bundle_lock_frag
);
720 if (bundle_size
> 1U << bundle_align_p2
)
721 as_bad (_ (".bundle_lock sequence at %u bytes, "
722 "but .bundle_align_mode limit is %u bytes"),
723 bundle_size
, 1U << bundle_align_p2
);
725 else if (bundle_align_p2
> 0)
727 unsigned int insn_size
= pending_bundle_size (insn_start_frag
);
729 if (insn_size
> 1U << bundle_align_p2
)
730 as_bad (_("single instruction is %u bytes long, "
731 "but .bundle_align_mode limit is %u bytes"),
732 insn_size
, 1U << bundle_align_p2
);
734 finish_bundle (insn_start_frag
, insn_size
);
738 #else /* !HANDLE_BUNDLE */
740 # define assemble_one(line) md_assemble(line)
742 #endif /* HANDLE_BUNDLE */
747 flagword flags
= bfd_section_flags (now_seg
);
749 return (flags
& SEC_ALLOC
) && !(flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
));
752 /* Guts of .align directive:
753 N is the power of two to which to align. A value of zero is accepted but
754 ignored: the default alignment of the section will be at least this.
755 FILL may be NULL, or it may point to the bytes of the fill pattern.
756 LEN is the length of whatever FILL points to, if anything. If LEN is zero
757 but FILL is not NULL then LEN is treated as if it were one.
758 MAX is the maximum number of characters to skip when doing the alignment,
759 or 0 if there is no maximum. */
762 do_align (unsigned int n
, char *fill
, unsigned int len
, unsigned int max
)
764 if (now_seg
== absolute_section
|| in_bss ())
770 if (now_seg
== absolute_section
)
771 as_warn (_("ignoring fill value in absolute section"));
773 as_warn (_("ignoring fill value in section `%s'"),
774 segment_name (now_seg
));
781 #ifdef md_flush_pending_output
782 md_flush_pending_output ();
786 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
789 /* Only make a frag if we HAVE to... */
790 if ((n
> OCTETS_PER_BYTE_POWER
) && !need_pass_2
)
794 if (subseg_text_p (now_seg
))
795 frag_align_code (n
, max
);
797 frag_align (n
, 0, max
);
800 frag_align (n
, *fill
, max
);
802 frag_align_pattern (n
, fill
, len
, max
);
806 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
809 if (n
> OCTETS_PER_BYTE_POWER
)
810 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
813 /* We read the file, putting things into a web that represents what we
814 have been reading. */
816 read_a_source_file (const char *name
)
820 char *s
; /* String of symbol, '\0' appended. */
828 buffer
= input_scrub_new_file (name
);
831 listing_newline (NULL
);
832 register_dependency (name
);
834 /* Generate debugging information before we've read anything in to denote
835 this file as the "main" source file and not a subordinate one
836 (e.g. N_SO vs N_SOL in stabs). */
837 generate_file_debug ();
839 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
840 { /* We have another line to parse. */
842 /* In order to avoid listing macro expansion lines with labels
843 multiple times, keep track of which line was last issued. */
844 static char *last_eol
;
848 while (input_line_pointer
< buffer_limit
)
850 bfd_boolean was_new_line
;
851 /* We have more of this buffer to parse. */
853 /* We now have input_line_pointer->1st char of next line.
854 If input_line_pointer [-1] == '\n' then we just
855 scanned another line: so bump line counters. */
856 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
859 symbol_set_value_now (&dot_symbol
);
860 #ifdef md_start_line_hook
861 md_start_line_hook ();
863 if (input_line_pointer
[-1] == '\n')
864 bump_line_counters ();
868 /* If listing is on, and we are expanding a macro, then give
869 the listing code the contents of the expanded line. */
872 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
874 /* Find the end of the current expanded macro line. */
875 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
883 /* Copy it for safe keeping. Also give an indication of
884 how much macro nesting is involved at this point. */
885 len
= s
- input_line_pointer
;
886 copy
= XNEWVEC (char, len
+ macro_nest
+ 2);
887 memset (copy
, '>', macro_nest
);
888 copy
[macro_nest
] = ' ';
889 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
890 copy
[macro_nest
+ 1 + len
] = '\0';
892 /* Install the line with the listing facility. */
893 listing_newline (copy
);
897 listing_newline (NULL
);
904 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
906 next_char
= * input_line_pointer
;
907 /* Text at the start of a line must be a label, we
908 run down and stick a colon in. */
909 if (is_name_beginner (next_char
) || next_char
== '"')
914 HANDLE_CONDITIONAL_ASSEMBLY (0);
916 nul_char
= get_symbol_name (& line_start
);
917 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
919 /* In MRI mode, the EQU and MACRO pseudoops must
920 be handled specially. */
924 char *rest
= input_line_pointer
+ 1;
928 if (*rest
== ' ' || *rest
== '\t')
930 if ((strncasecmp (rest
, "EQU", 3) == 0
931 || strncasecmp (rest
, "SET", 3) == 0)
932 && (rest
[3] == ' ' || rest
[3] == '\t'))
934 input_line_pointer
= rest
+ 3;
936 strncasecmp (rest
, "SET", 3) == 0);
939 if (strncasecmp (rest
, "MACRO", 5) == 0
942 || is_end_of_line
[(unsigned char) rest
[5]]))
946 /* In MRI mode, we need to handle the MACRO
947 pseudo-op specially: we don't want to put the
948 symbol in the symbol table. */
950 #ifdef TC_START_LABEL_WITHOUT_COLON
951 && TC_START_LABEL_WITHOUT_COLON (nul_char
, next_char
)
954 line_label
= colon (line_start
);
956 line_label
= symbol_create (line_start
,
961 next_char
= restore_line_pointer (nul_char
);
962 if (next_char
== ':')
963 input_line_pointer
++;
968 /* We are at the beginning of a line, or similar place.
969 We expect a well-formed assembler statement.
970 A "symbol-name:" is a statement.
972 Depending on what compiler is used, the order of these tests
973 may vary to catch most common case 1st.
974 Each test is independent of all other tests at the (top)
977 nul_char
= next_char
= *input_line_pointer
++;
978 while (next_char
== '\t' || next_char
== ' ' || next_char
== '\f');
980 /* C is the 1st significant character.
981 Input_line_pointer points after that character. */
982 if (is_name_beginner (next_char
) || next_char
== '"')
986 /* Want user-defined label or pseudo/opcode. */
987 HANDLE_CONDITIONAL_ASSEMBLY (1);
989 --input_line_pointer
;
990 nul_char
= get_symbol_name (& s
); /* name's delimiter. */
991 next_char
= (nul_char
== '"' ? input_line_pointer
[1] : nul_char
);
992 rest
= input_line_pointer
+ (nul_char
== '"' ? 2 : 1);
994 /* NEXT_CHAR is character after symbol.
995 The end of symbol in the input line is now '\0'.
996 S points to the beginning of the symbol.
997 [In case of pseudo-op, s->'.'.]
998 Input_line_pointer->'\0' where NUL_CHAR was. */
999 if (TC_START_LABEL (s
, nul_char
, next_char
))
1003 /* In MRI mode, \tsym: set 0 is permitted. */
1007 if (*rest
== ' ' || *rest
== '\t')
1010 if ((strncasecmp (rest
, "EQU", 3) == 0
1011 || strncasecmp (rest
, "SET", 3) == 0)
1012 && (rest
[3] == ' ' || rest
[3] == '\t'))
1014 input_line_pointer
= rest
+ 3;
1020 line_label
= colon (s
); /* User-defined label. */
1021 restore_line_pointer (nul_char
);
1022 ++ input_line_pointer
;
1023 #ifdef tc_check_label
1024 tc_check_label (line_label
);
1026 /* Input_line_pointer->after ':'. */
1029 else if ((next_char
== '=' && *rest
== '=')
1030 || ((next_char
== ' ' || next_char
== '\t')
1035 demand_empty_rest_of_line ();
1037 else if ((next_char
== '='
1038 || ((next_char
== ' ' || next_char
== '\t')
1040 #ifdef TC_EQUAL_IN_INSN
1041 && !TC_EQUAL_IN_INSN (next_char
, s
)
1046 demand_empty_rest_of_line ();
1050 /* Expect pseudo-op or machine instruction. */
1053 #ifndef TC_CASE_SENSITIVE
1057 strncpy (original_case_string
, s2
,
1058 sizeof (original_case_string
) - 1);
1059 original_case_string
[sizeof (original_case_string
) - 1] = 0;
1063 *s2
= TOLOWER (*s2
);
1068 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
1070 /* The MRI assembler uses pseudo-ops without
1072 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
1073 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
1078 || (!flag_m68k_mri
&& *s
== '.'))
1082 WARNING: next_char may be end-of-line.
1083 We lookup the pseudo-op table with s+1 because we
1084 already know that the pseudo-op begins with a '.'. */
1087 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
1088 if (pop
&& !pop
->poc_handler
)
1091 /* In MRI mode, we may need to insert an
1092 automatic alignment directive. What a hack
1094 if (mri_pending_align
1096 || !((pop
->poc_handler
== cons
1097 && pop
->poc_val
== 1)
1098 || (pop
->poc_handler
== s_space
1099 && pop
->poc_val
== 1)
1100 #ifdef tc_conditional_pseudoop
1101 || tc_conditional_pseudoop (pop
)
1103 || pop
->poc_handler
== s_if
1104 || pop
->poc_handler
== s_ifdef
1105 || pop
->poc_handler
== s_ifc
1106 || pop
->poc_handler
== s_ifeqs
1107 || pop
->poc_handler
== s_else
1108 || pop
->poc_handler
== s_endif
1109 || pop
->poc_handler
== s_globl
1110 || pop
->poc_handler
== s_ignore
)))
1112 do_align (1, (char *) NULL
, 0, 0);
1113 mri_pending_align
= 0;
1115 if (line_label
!= NULL
)
1117 symbol_set_frag (line_label
, frag_now
);
1118 S_SET_VALUE (line_label
, frag_now_fix ());
1122 /* Print the error msg now, while we still can. */
1125 char *end
= input_line_pointer
;
1127 (void) restore_line_pointer (nul_char
);
1129 nul_char
= next_char
= *--input_line_pointer
;
1130 *input_line_pointer
= '\0';
1131 if (! macro_defined
|| ! try_macro (next_char
, s
))
1134 as_bad (_("unknown pseudo-op: `%s'"), s
);
1135 *input_line_pointer
++ = nul_char
;
1140 /* Put it back for error messages etc. */
1141 next_char
= restore_line_pointer (nul_char
);
1142 /* The following skip of whitespace is compulsory.
1143 A well shaped space is sometimes all that separates
1144 keyword from operands. */
1145 if (next_char
== ' ' || next_char
== '\t')
1146 input_line_pointer
++;
1148 /* Input_line is restored.
1149 Input_line_pointer->1st non-blank char
1150 after pseudo-operation. */
1151 (*pop
->poc_handler
) (pop
->poc_val
);
1153 /* If that was .end, just get out now. */
1154 if (pop
->poc_handler
== s_end
)
1159 /* WARNING: next_char may be end-of-line. */
1160 /* Also: input_line_pointer->`\0` where nul_char was. */
1161 (void) restore_line_pointer (nul_char
);
1162 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
1163 next_char
= nul_char
= *input_line_pointer
;
1164 *input_line_pointer
= '\0';
1166 generate_lineno_debug ();
1168 if (macro_defined
&& try_macro (next_char
, s
))
1171 if (mri_pending_align
)
1173 do_align (1, (char *) NULL
, 0, 0);
1174 mri_pending_align
= 0;
1175 if (line_label
!= NULL
)
1177 symbol_set_frag (line_label
, frag_now
);
1178 S_SET_VALUE (line_label
, frag_now_fix ());
1182 assemble_one (s
); /* Assemble 1 instruction. */
1184 /* PR 19630: The backend may have set ilp to NULL
1185 if it encountered a catastrophic failure. */
1186 if (input_line_pointer
== NULL
)
1187 as_fatal (_("unable to continue with assembly."));
1189 *input_line_pointer
++ = nul_char
;
1191 /* We resume loop AFTER the end-of-line from
1192 this instruction. */
1198 /* Empty statement? */
1199 if (is_end_of_line
[(unsigned char) next_char
])
1202 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (next_char
))
1204 /* local label ("4:") */
1205 char *backup
= input_line_pointer
;
1207 HANDLE_CONDITIONAL_ASSEMBLY (1);
1209 temp
= next_char
- '0';
1211 if (nul_char
== '"')
1212 ++ input_line_pointer
;
1214 /* Read the whole number. */
1215 while (ISDIGIT (*input_line_pointer
))
1217 const long digit
= *input_line_pointer
- '0';
1218 if (temp
> (LONG_MAX
- digit
) / 10)
1220 as_bad (_("local label too large near %s"), backup
);
1224 temp
= temp
* 10 + digit
;
1225 ++input_line_pointer
;
1228 /* Overflow: stop processing the label. */
1232 if (LOCAL_LABELS_DOLLAR
1233 && *input_line_pointer
== '$'
1234 && *(input_line_pointer
+ 1) == ':')
1236 input_line_pointer
+= 2;
1238 if (dollar_label_defined (temp
))
1240 as_fatal (_("label \"%ld$\" redefined"), temp
);
1243 define_dollar_label (temp
);
1244 colon (dollar_label_name (temp
, 0));
1249 && *input_line_pointer
++ == ':')
1251 fb_label_instance_inc (temp
);
1252 colon (fb_label_name (temp
, 0));
1256 input_line_pointer
= backup
;
1259 if (next_char
&& strchr (line_comment_chars
, next_char
))
1260 { /* Its a comment. Better say APP or NO_APP. */
1265 unsigned int new_length
;
1268 s
= input_line_pointer
;
1269 if (strncmp (s
, "APP\n", 4))
1272 ignore_rest_of_line ();
1275 bump_line_counters ();
1278 ends
= strstr (s
, "#NO_APP\n");
1282 unsigned int tmp_len
;
1285 /* The end of the #APP wasn't in this buffer. We
1286 keep reading in buffers until we find the #NO_APP
1287 that goes with this #APP There is one. The specs
1289 tmp_len
= buffer_limit
- s
;
1290 tmp_buf
= XNEWVEC (char, tmp_len
+ 1);
1291 memcpy (tmp_buf
, s
, tmp_len
);
1294 new_tmp
= input_scrub_next_buffer (&buffer
);
1298 buffer_limit
= new_tmp
;
1299 input_line_pointer
= buffer
;
1300 ends
= strstr (buffer
, "#NO_APP\n");
1302 num
= ends
- buffer
;
1304 num
= buffer_limit
- buffer
;
1306 tmp_buf
= XRESIZEVEC (char, tmp_buf
, tmp_len
+ num
);
1307 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1312 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1320 input_line_pointer
= ends
+ 8;
1324 scrub_string_end
= ends
;
1326 new_length
= ends
- s
;
1327 new_buf
= XNEWVEC (char, new_length
);
1334 space
= (new_buf
+ new_length
) - new_tmp
;
1335 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1343 new_buf
= XRESIZEVEC (char, new_buf
, new_length
+ 100);
1344 new_tmp
= new_buf
+ new_length
;
1350 /* We've "scrubbed" input to the preferred format. In the
1351 process we may have consumed the whole of the remaining
1352 file (and included files). We handle this formatted
1353 input similar to that of macro expansion, letting
1354 actual macro expansion (possibly nested) and other
1355 input expansion work. Beware that in messages, line
1356 numbers and possibly file names will be incorrect. */
1357 new_length
= strlen (new_buf
);
1358 sb_build (&sbuf
, new_length
);
1359 sb_add_buffer (&sbuf
, new_buf
, new_length
);
1360 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1362 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1367 HANDLE_CONDITIONAL_ASSEMBLY (1);
1369 #ifdef tc_unrecognized_line
1370 if (tc_unrecognized_line (next_char
))
1373 input_line_pointer
--;
1374 /* Report unknown char as error. */
1375 demand_empty_rest_of_line ();
1380 symbol_set_value_now (&dot_symbol
);
1382 #ifdef HANDLE_BUNDLE
1383 if (bundle_lock_frag
!= NULL
)
1385 as_bad_where (bundle_lock_frag
->fr_file
, bundle_lock_frag
->fr_line
,
1386 _(".bundle_lock with no matching .bundle_unlock"));
1387 bundle_lock_frag
= NULL
;
1388 bundle_lock_frchain
= NULL
;
1389 bundle_lock_depth
= 0;
1396 /* Close the input file. */
1397 input_scrub_close ();
1398 #ifdef WARN_COMMENTS
1400 if (warn_comment
&& found_comment
)
1401 as_warn_where (found_comment_file
, found_comment
,
1402 "first comment found here");
1407 /* Convert O_constant expression EXP into the equivalent O_big representation.
1408 Take the sign of the number from SIGN rather than X_add_number. */
1411 convert_to_bignum (expressionS
*exp
, int sign
)
1416 value
= exp
->X_add_number
;
1417 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1419 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1420 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1422 /* Add a sequence of sign bits if the top bit of X_add_number is not
1423 the sign of the original value. */
1424 if ((exp
->X_add_number
< 0) == !sign
)
1425 generic_bignum
[i
++] = sign
? LITTLENUM_MASK
: 0;
1427 exp
->X_add_number
= i
;
1430 /* For most MRI pseudo-ops, the line actually ends at the first
1431 nonquoted space. This function looks for that point, stuffs a null
1432 in, and sets *STOPCP to the character that used to be there, and
1433 returns the location.
1435 Until I hear otherwise, I am going to assume that this is only true
1436 for the m68k MRI assembler. */
1439 mri_comment_field (char *stopcp
)
1445 know (flag_m68k_mri
);
1447 for (s
= input_line_pointer
;
1448 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1456 for (s
= input_line_pointer
;
1457 !is_end_of_line
[(unsigned char) *s
];
1467 /* Skip to the end of an MRI comment field. */
1470 mri_comment_end (char *stop
, int stopc
)
1474 input_line_pointer
= stop
;
1476 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1477 ++input_line_pointer
;
1481 s_abort (int ignore ATTRIBUTE_UNUSED
)
1483 as_fatal (_(".abort detected. Abandoning ship."));
1486 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1487 (in bytes). A negative ARG is the negative of the length of the
1488 fill pattern. BYTES_P is non-zero if the alignment value should be
1489 interpreted as the byte boundary, rather than the power of 2. */
1490 #ifndef TC_ALIGN_LIMIT
1491 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1495 s_align (signed int arg
, int bytes_p
)
1497 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1506 stop
= mri_comment_field (&stopc
);
1508 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1513 align
= arg
; /* Default value from pseudo-op table. */
1517 align
= get_absolute_expression ();
1520 #ifdef TC_ALIGN_ZERO_IS_DEFAULT
1521 if (arg
> 0 && align
== 0)
1528 /* Convert to a power of 2. */
1533 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1536 as_bad (_("alignment not a power of 2"));
1542 if (align
> align_limit
)
1544 align
= align_limit
;
1545 as_warn (_("alignment too large: %u assumed"), align
);
1548 if (*input_line_pointer
!= ',')
1555 ++input_line_pointer
;
1556 if (*input_line_pointer
== ',')
1560 fill
= get_absolute_expression ();
1565 if (*input_line_pointer
!= ',')
1569 ++input_line_pointer
;
1570 max
= get_absolute_expression ();
1577 as_warn (_("expected fill pattern missing"));
1578 do_align (align
, (char *) NULL
, 0, max
);
1582 unsigned int fill_len
;
1594 do_align (align
, &fill_char
, fill_len
, max
);
1600 if ((size_t) fill_len
> sizeof ab
)
1602 as_warn (_("fill pattern too long, truncating to %u"),
1603 (unsigned) sizeof ab
);
1604 fill_len
= sizeof ab
;
1607 md_number_to_chars (ab
, fill
, fill_len
);
1608 do_align (align
, ab
, fill_len
, max
);
1612 demand_empty_rest_of_line ();
1615 mri_comment_end (stop
, stopc
);
1618 /* Handle the .align pseudo-op on machines where ".align 4" means
1619 align to a 4 byte boundary. */
1622 s_align_bytes (int arg
)
1627 /* Handle the .align pseudo-op on machines where ".align 4" means align
1628 to a 2**4 boundary. */
1631 s_align_ptwo (int arg
)
1636 /* Switch in and out of alternate macro mode. */
1641 demand_empty_rest_of_line ();
1642 macro_set_alternate (on
);
1645 /* Read a symbol name from input_line_pointer.
1647 Stores the symbol name in a buffer and returns a pointer to this buffer.
1648 The buffer is xalloc'ed. It is the caller's responsibility to free
1651 The name is not left in the i_l_p buffer as it may need processing
1652 to handle escape characters.
1654 Advances i_l_p to the next non-whitespace character.
1656 If a symbol name could not be read, the routine issues an error
1657 messages, skips to the end of the line and returns NULL. */
1660 read_symbol_name (void)
1666 c
= *input_line_pointer
++;
1670 #define SYM_NAME_CHUNK_LEN 128
1671 ptrdiff_t len
= SYM_NAME_CHUNK_LEN
;
1675 start
= name
= XNEWVEC (char, len
+ 1);
1677 name_end
= name
+ SYM_NAME_CHUNK_LEN
;
1679 while (is_a_char (C
= next_char_of_string ()))
1681 if (name
>= name_end
)
1685 sofar
= name
- start
;
1686 len
+= SYM_NAME_CHUNK_LEN
;
1687 start
= XRESIZEVEC (char, start
, len
+ 1);
1688 name_end
= start
+ len
;
1689 name
= start
+ sofar
;
1696 /* Since quoted symbol names can contain non-ASCII characters,
1697 check the string and warn if it cannot be recognised by the
1698 current character set. */
1699 if (mbstowcs (NULL
, name
, len
) == (size_t) -1)
1700 as_warn (_("symbol name not recognised in the current locale"));
1702 else if (is_name_beginner (c
) || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1706 name
= input_line_pointer
- 1;
1708 /* We accept FAKE_LABEL_CHAR in a name in case this is
1709 being called with a constructed string. */
1710 while (is_part_of_name (c
= *input_line_pointer
++)
1711 || (input_from_string
&& c
== FAKE_LABEL_CHAR
))
1714 len
= (input_line_pointer
- name
) - 1;
1715 start
= XNEWVEC (char, len
+ 1);
1717 memcpy (start
, name
, len
);
1720 /* Skip a name ender char if one is present. */
1721 if (! is_name_ender (c
))
1722 --input_line_pointer
;
1725 name
= start
= NULL
;
1729 as_bad (_("expected symbol name"));
1730 ignore_rest_of_line ();
1741 s_comm_internal (int param
,
1742 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1746 symbolS
*symbolP
= NULL
;
1752 stop
= mri_comment_field (&stopc
);
1754 if ((name
= read_symbol_name ()) == NULL
)
1757 /* Accept an optional comma after the name. The comma used to be
1758 required, but Irix 5 cc does not generate it for .lcomm. */
1759 if (*input_line_pointer
== ',')
1760 input_line_pointer
++;
1762 temp
= get_absolute_expr (&exp
);
1764 size
&= ((addressT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1765 if (exp
.X_op
== O_absent
)
1767 as_bad (_("missing size expression"));
1768 ignore_rest_of_line ();
1771 else if (temp
!= size
|| !exp
.X_unsigned
)
1773 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1774 ignore_rest_of_line ();
1778 symbolP
= symbol_find_or_make (name
);
1779 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1780 && !S_IS_COMMON (symbolP
))
1782 if (!S_IS_VOLATILE (symbolP
))
1785 as_bad (_("symbol `%s' is already defined"), name
);
1786 ignore_rest_of_line ();
1789 symbolP
= symbol_clone (symbolP
, 1);
1790 S_SET_SEGMENT (symbolP
, undefined_section
);
1791 S_SET_VALUE (symbolP
, 0);
1792 symbol_set_frag (symbolP
, &zero_address_frag
);
1793 S_CLEAR_VOLATILE (symbolP
);
1796 size
= S_GET_VALUE (symbolP
);
1799 else if (size
!= temp
)
1800 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1801 name
, (long) size
, (long) temp
);
1803 if (comm_parse_extra
!= NULL
)
1804 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1807 S_SET_VALUE (symbolP
, (valueT
) size
);
1808 S_SET_EXTERNAL (symbolP
);
1809 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1812 demand_empty_rest_of_line ();
1815 mri_comment_end (stop
, stopc
);
1823 s_comm_internal (ignore
, NULL
);
1826 /* The MRI COMMON pseudo-op. We handle this by creating a common
1827 symbol with the appropriate name. We make s_space do the right
1828 thing by increasing the size. */
1831 s_mri_common (int small ATTRIBUTE_UNUSED
)
1847 stop
= mri_comment_field (&stopc
);
1851 name
= input_line_pointer
;
1852 if (!ISDIGIT (*name
))
1853 c
= get_symbol_name (& name
);
1858 ++input_line_pointer
;
1860 while (ISDIGIT (*input_line_pointer
));
1862 c
= *input_line_pointer
;
1863 *input_line_pointer
= '\0';
1865 if (line_label
!= NULL
)
1867 alc
= XNEWVEC (char, strlen (S_GET_NAME (line_label
))
1868 + (input_line_pointer
- name
) + 1);
1869 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1874 sym
= symbol_find_or_make (name
);
1875 c
= restore_line_pointer (c
);
1878 if (*input_line_pointer
!= ',')
1882 ++input_line_pointer
;
1883 align
= get_absolute_expression ();
1886 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1888 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1889 ignore_rest_of_line ();
1890 mri_comment_end (stop
, stopc
);
1894 S_SET_EXTERNAL (sym
);
1895 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1896 mri_common_symbol
= sym
;
1900 S_SET_ALIGN (sym
, align
);
1905 if (line_label
!= NULL
)
1908 exp
.X_op
= O_symbol
;
1909 exp
.X_add_symbol
= sym
;
1910 exp
.X_add_number
= 0;
1911 symbol_set_value_expression (line_label
, &exp
);
1912 symbol_set_frag (line_label
, &zero_address_frag
);
1913 S_SET_SEGMENT (line_label
, expr_section
);
1916 /* FIXME: We just ignore the small argument, which distinguishes
1917 COMMON and COMMON.S. I don't know what we can do about it. */
1919 /* Ignore the type and hptype. */
1920 if (*input_line_pointer
== ',')
1921 input_line_pointer
+= 2;
1922 if (*input_line_pointer
== ',')
1923 input_line_pointer
+= 2;
1925 demand_empty_rest_of_line ();
1927 mri_comment_end (stop
, stopc
);
1931 s_data (int ignore ATTRIBUTE_UNUSED
)
1936 temp
= get_absolute_expression ();
1937 if (flag_readonly_data_in_text
)
1939 section
= text_section
;
1943 section
= data_section
;
1945 subseg_set (section
, (subsegT
) temp
);
1947 demand_empty_rest_of_line ();
1950 /* Handle the .appfile pseudo-op. This is automatically generated by
1951 do_scrub_chars when a preprocessor # line comment is seen with a
1952 file name. This default definition may be overridden by the object
1953 or CPU specific pseudo-ops. This function is also the default
1954 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1958 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1962 listing_source_file (file
);
1964 register_dependency (file
);
1966 obj_app_file (file
, appfile
);
1971 s_app_file (int appfile
)
1976 /* Some assemblers tolerate immediately following '"'. */
1977 if ((s
= demand_copy_string (&length
)) != 0)
1980 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1982 /* In MRI mode, the preprocessor may have inserted an extraneous
1985 && *input_line_pointer
== '\''
1986 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1987 ++input_line_pointer
;
1989 demand_empty_rest_of_line ();
1991 s_app_file_string (s
, appfile
);
1996 get_linefile_number (int *flag
)
2000 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
2003 *flag
= get_absolute_expression ();
2008 /* Handle the .appline pseudo-op. This is automatically generated by
2009 do_scrub_chars when a preprocessor # line comment is seen. This
2010 default definition may be overridden by the object or CPU specific
2014 s_app_line (int appline
)
2019 /* The given number is that of the next line. */
2021 l
= get_absolute_expression ();
2022 else if (!get_linefile_number (&l
))
2024 ignore_rest_of_line ();
2031 /* Some of the back ends can't deal with non-positive line numbers.
2032 Besides, it's silly. GCC however will generate a line number of
2033 zero when it is pre-processing builtins for assembler-with-cpp files:
2037 We do not want to barf on this, especially since such files are used
2038 in the GCC and GDB testsuites. So we check for negative line numbers
2039 rather than non-positive line numbers. */
2040 as_warn (_("line numbers must be positive; line number %d rejected"),
2051 if (*input_line_pointer
== '"')
2052 file
= demand_copy_string (&length
);
2058 while (get_linefile_number (&this_flag
))
2061 /* From GCC's cpp documentation:
2062 1: start of a new file.
2063 2: returning to a file after having included
2065 3: following text comes from a system header file.
2066 4: following text should be treated as extern "C".
2068 4 is nonsensical for the assembler; 3, we don't
2069 care about, so we ignore it just in case a
2070 system header file is included while
2071 preprocessing assembly. So 1 and 2 are all we
2072 care about, and they are mutually incompatible.
2073 new_logical_line_flags() demands this. */
2076 if (flags
&& flags
!= (1 << this_flag
))
2077 as_warn (_("incompatible flag %i in line directive"),
2080 flags
|= 1 << this_flag
;
2085 /* We ignore these. */
2089 as_warn (_("unsupported flag %i in line directive"),
2094 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
2099 if (appline
|| file
)
2101 new_logical_line_flags (file
, l
, flags
);
2104 listing_source_line (l
);
2108 if (appline
|| file
)
2109 demand_empty_rest_of_line ();
2111 ignore_rest_of_line ();
2114 /* Handle the .end pseudo-op. Actually, the real work is done in
2115 read_a_source_file. */
2118 s_end (int ignore ATTRIBUTE_UNUSED
)
2122 /* The MRI assembler permits the start symbol to follow .end,
2123 but we don't support that. */
2125 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
2126 && *input_line_pointer
!= '*'
2127 && *input_line_pointer
!= '!')
2128 as_warn (_("start address not supported"));
2132 /* Handle the .err pseudo-op. */
2135 s_err (int ignore ATTRIBUTE_UNUSED
)
2137 as_bad (_(".err encountered"));
2138 demand_empty_rest_of_line ();
2141 /* Handle the .error and .warning pseudo-ops. */
2147 /* The purpose for the conditional assignment is not to
2148 internationalize the directive itself, but that we need a
2149 self-contained message, one that can be passed like the
2150 demand_copy_C_string return value, and with no assumption on the
2151 location of the name of the directive within the message. */
2153 = (err
? _(".error directive invoked in source file")
2154 : _(".warning directive invoked in source file"));
2156 if (!is_it_end_of_statement ())
2158 if (*input_line_pointer
!= '\"')
2160 as_bad (_("%s argument must be a string"),
2161 err
? ".error" : ".warning");
2162 ignore_rest_of_line ();
2166 msg
= demand_copy_C_string (&len
);
2174 as_warn ("%s", msg
);
2175 demand_empty_rest_of_line ();
2178 /* Handle the MRI fail pseudo-op. */
2181 s_fail (int ignore ATTRIBUTE_UNUSED
)
2188 stop
= mri_comment_field (&stopc
);
2190 temp
= get_absolute_expression ();
2192 as_warn (_(".fail %ld encountered"), (long) temp
);
2194 as_bad (_(".fail %ld encountered"), (long) temp
);
2196 demand_empty_rest_of_line ();
2199 mri_comment_end (stop
, stopc
);
2203 s_fill (int ignore ATTRIBUTE_UNUSED
)
2205 expressionS rep_exp
;
2210 #ifdef md_flush_pending_output
2211 md_flush_pending_output ();
2214 #ifdef md_cons_align
2218 expression (&rep_exp
);
2219 if (*input_line_pointer
== ',')
2221 input_line_pointer
++;
2222 size
= get_absolute_expression ();
2223 if (*input_line_pointer
== ',')
2225 input_line_pointer
++;
2226 fill
= get_absolute_expression ();
2230 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
2231 #define BSD_FILL_SIZE_CROCK_8 (8)
2232 if (size
> BSD_FILL_SIZE_CROCK_8
)
2234 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
2235 size
= BSD_FILL_SIZE_CROCK_8
;
2239 as_warn (_("size negative; .fill ignored"));
2242 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
2244 if (rep_exp
.X_add_number
< 0)
2245 as_warn (_("repeat < 0; .fill ignored"));
2249 if (size
&& !need_pass_2
)
2251 if (now_seg
== absolute_section
)
2253 if (rep_exp
.X_op
!= O_constant
)
2254 as_bad (_("non-constant fill count for absolute section"));
2255 else if (fill
&& rep_exp
.X_add_number
!= 0)
2256 as_bad (_("attempt to fill absolute section with non-zero value"));
2257 abs_section_offset
+= rep_exp
.X_add_number
* size
;
2260 && (rep_exp
.X_op
!= O_constant
|| rep_exp
.X_add_number
!= 0)
2262 as_bad (_("attempt to fill section `%s' with non-zero value"),
2263 segment_name (now_seg
));
2265 if (rep_exp
.X_op
== O_constant
)
2267 p
= frag_var (rs_fill
, (int) size
, (int) size
,
2268 (relax_substateT
) 0, (symbolS
*) 0,
2269 (offsetT
) rep_exp
.X_add_number
,
2274 /* We don't have a constant repeat count, so we can't use
2275 rs_fill. We can get the same results out of rs_space,
2276 but its argument is in bytes, so we must multiply the
2277 repeat count by size. */
2280 rep_sym
= make_expr_symbol (&rep_exp
);
2283 expressionS size_exp
;
2284 size_exp
.X_op
= O_constant
;
2285 size_exp
.X_add_number
= size
;
2287 rep_exp
.X_op
= O_multiply
;
2288 rep_exp
.X_add_symbol
= rep_sym
;
2289 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
2290 rep_exp
.X_add_number
= 0;
2291 rep_sym
= make_expr_symbol (&rep_exp
);
2294 p
= frag_var (rs_space
, (int) size
, (int) size
,
2295 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
2298 memset (p
, 0, (unsigned int) size
);
2300 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2301 flavoured AS. The following bizarre behaviour is to be
2302 compatible with above. I guess they tried to take up to 8
2303 bytes from a 4-byte expression and they forgot to sign
2305 #define BSD_FILL_SIZE_CROCK_4 (4)
2306 md_number_to_chars (p
, (valueT
) fill
,
2307 (size
> BSD_FILL_SIZE_CROCK_4
2308 ? BSD_FILL_SIZE_CROCK_4
2310 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2311 but emits no error message because it seems a legal thing to do.
2312 It is a degenerate case of .fill but could be emitted by a
2315 demand_empty_rest_of_line ();
2319 s_globl (int ignore ATTRIBUTE_UNUSED
)
2328 stop
= mri_comment_field (&stopc
);
2332 if ((name
= read_symbol_name ()) == NULL
)
2335 symbolP
= symbol_find_or_make (name
);
2336 S_SET_EXTERNAL (symbolP
);
2339 c
= *input_line_pointer
;
2342 input_line_pointer
++;
2344 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2352 demand_empty_rest_of_line ();
2355 mri_comment_end (stop
, stopc
);
2358 /* Handle the MRI IRP and IRPC pseudo-ops. */
2370 file
= as_where (&line
);
2372 eol
= find_end_of_line (input_line_pointer
, 0);
2373 sb_build (&s
, eol
- input_line_pointer
);
2374 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2375 input_line_pointer
= eol
;
2379 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2381 as_bad_where (file
, line
, "%s", err
);
2385 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2387 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2390 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2391 the section to only be linked once. However, this is not supported
2392 by most object file formats. This takes an optional argument,
2393 which is what to do about duplicates. */
2396 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2398 enum linkonce_type type
;
2402 type
= LINKONCE_DISCARD
;
2404 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2409 c
= get_symbol_name (& s
);
2410 if (strcasecmp (s
, "discard") == 0)
2411 type
= LINKONCE_DISCARD
;
2412 else if (strcasecmp (s
, "one_only") == 0)
2413 type
= LINKONCE_ONE_ONLY
;
2414 else if (strcasecmp (s
, "same_size") == 0)
2415 type
= LINKONCE_SAME_SIZE
;
2416 else if (strcasecmp (s
, "same_contents") == 0)
2417 type
= LINKONCE_SAME_CONTENTS
;
2419 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2421 (void) restore_line_pointer (c
);
2424 #ifdef obj_handle_link_once
2425 obj_handle_link_once (type
);
2426 #else /* ! defined (obj_handle_link_once) */
2430 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2431 as_warn (_(".linkonce is not supported for this object file format"));
2433 flags
= bfd_section_flags (now_seg
);
2434 flags
|= SEC_LINK_ONCE
;
2439 case LINKONCE_DISCARD
:
2440 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2442 case LINKONCE_ONE_ONLY
:
2443 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2445 case LINKONCE_SAME_SIZE
:
2446 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2448 case LINKONCE_SAME_CONTENTS
:
2449 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2452 if (!bfd_set_section_flags (now_seg
, flags
))
2453 as_bad (_("bfd_set_section_flags: %s"),
2454 bfd_errmsg (bfd_get_error ()));
2456 #endif /* ! defined (obj_handle_link_once) */
2458 demand_empty_rest_of_line ();
2462 bss_alloc (symbolS
*symbolP
, addressT size
, unsigned int align
)
2465 segT current_seg
= now_seg
;
2466 subsegT current_subseg
= now_subseg
;
2467 segT bss_seg
= bss_section
;
2469 #if defined (TC_MIPS) || defined (TC_ALPHA)
2470 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2471 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2473 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2474 if (size
<= bfd_get_gp_size (stdoutput
))
2476 bss_seg
= subseg_new (".sbss", 1);
2477 seg_info (bss_seg
)->bss
= 1;
2478 if (!bfd_set_section_flags (bss_seg
, SEC_ALLOC
| SEC_SMALL_DATA
))
2479 as_warn (_("error setting flags for \".sbss\": %s"),
2480 bfd_errmsg (bfd_get_error ()));
2484 subseg_set (bss_seg
, 1);
2486 if (align
> OCTETS_PER_BYTE_POWER
)
2488 record_alignment (bss_seg
, align
);
2489 frag_align (align
, 0, 0);
2492 /* Detach from old frag. */
2493 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2494 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2496 symbol_set_frag (symbolP
, frag_now
);
2497 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2501 S_SET_SIZE (symbolP
, size
);
2503 S_SET_SEGMENT (symbolP
, bss_seg
);
2506 /* The symbol may already have been created with a preceding
2507 ".globl" directive -- be careful not to step on storage class
2508 in that case. Otherwise, set it to static. */
2509 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2510 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2511 #endif /* OBJ_COFF */
2513 subseg_set (current_seg
, current_subseg
);
2517 parse_align (int align_bytes
)
2523 if (*input_line_pointer
!= ',')
2526 as_bad (_("expected alignment after size"));
2527 ignore_rest_of_line ();
2531 input_line_pointer
++;
2534 align
= get_absolute_expr (&exp
);
2535 if (exp
.X_op
== O_absent
)
2538 if (!exp
.X_unsigned
)
2540 as_warn (_("alignment negative; 0 assumed"));
2544 if (align_bytes
&& align
!= 0)
2546 /* convert to a power of 2 alignment */
2547 unsigned int alignp2
= 0;
2548 while ((align
& 1) == 0)
2549 align
>>= 1, ++alignp2
;
2552 as_bad (_("alignment not a power of 2"));
2553 ignore_rest_of_line ();
2561 /* Called from s_comm_internal after symbol name and size have been
2562 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2563 1 if this was a ".bss" directive which has a 3rd argument
2564 (alignment as a power of 2), or 2 if this was a ".bss" directive
2565 with alignment in bytes. */
2568 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2574 align
= parse_align (needs_align
- 1);
2575 if (align
== (addressT
) -1)
2579 /* Assume some objects may require alignment on some systems. */
2580 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2582 bss_alloc (symbolP
, size
, align
);
2587 s_lcomm (int needs_align
)
2589 s_comm_internal (needs_align
, s_lcomm_internal
);
2593 s_lcomm_bytes (int needs_align
)
2595 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2599 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2605 /* We permit ANY defined expression: BSD4.2 demands constants. */
2606 if ((name
= read_symbol_name ()) == NULL
)
2609 if (*input_line_pointer
!= ',')
2611 as_bad (_("expected comma after \"%s\""), name
);
2615 input_line_pointer
++;
2616 expression_and_evaluate (&exp
);
2618 if (exp
.X_op
!= O_constant
2619 && exp
.X_op
!= O_register
)
2621 as_bad (_("bad expression"));
2625 symbolP
= symbol_find_or_make (name
);
2627 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2629 /* The name might be an undefined .global symbol; be sure to
2630 keep the "external" bit. */
2631 S_SET_SEGMENT (symbolP
,
2632 (exp
.X_op
== O_constant
2635 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2639 as_bad (_("symbol `%s' is already defined"), name
);
2642 demand_empty_rest_of_line ();
2647 ignore_rest_of_line ();
2652 /* Read a line into an sb. Returns the character that ended the line
2653 or zero if there are no more lines. */
2656 get_line_sb (sb
*line
, int in_macro
)
2660 if (input_line_pointer
[-1] == '\n')
2661 bump_line_counters ();
2663 if (input_line_pointer
>= buffer_limit
)
2665 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2666 if (buffer_limit
== 0)
2670 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2671 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2672 input_line_pointer
= eol
;
2674 /* Don't skip multiple end-of-line characters, because that breaks support
2675 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2676 characters but isn't. Instead just skip one end of line character and
2677 return the character skipped so that the caller can re-insert it if
2679 return *input_line_pointer
++;
2683 get_non_macro_line_sb (sb
*line
)
2685 return get_line_sb (line
, 0);
2689 get_macro_line_sb (sb
*line
)
2691 return get_line_sb (line
, 1);
2694 /* Define a macro. This is an interface to macro.c. */
2697 s_macro (int ignore ATTRIBUTE_UNUSED
)
2706 file
= as_where (&line
);
2708 eol
= find_end_of_line (input_line_pointer
, 0);
2709 sb_build (&s
, eol
- input_line_pointer
);
2710 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2711 input_line_pointer
= eol
;
2713 if (line_label
!= NULL
)
2718 name
= S_GET_NAME (line_label
);
2719 len
= strlen (name
);
2720 sb_build (&label
, len
);
2721 sb_add_buffer (&label
, name
, len
);
2722 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2726 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2728 as_bad_where (file
, line
, err
, name
);
2731 if (line_label
!= NULL
)
2733 S_SET_SEGMENT (line_label
, absolute_section
);
2734 S_SET_VALUE (line_label
, 0);
2735 symbol_set_frag (line_label
, &zero_address_frag
);
2738 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2739 && hash_find (po_hash
, name
) != NULL
)
2742 && hash_find (po_hash
, name
+ 1) != NULL
))
2743 as_warn_where (file
,
2745 _("attempt to redefine pseudo-op `%s' ignored"),
2752 /* Handle the .mexit pseudo-op, which immediately exits a macro
2756 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2760 cond_exit_macro (macro_nest
);
2761 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2764 as_warn (_("ignoring macro exit outside a macro definition."));
2767 /* Switch in and out of MRI mode. */
2770 s_mri (int ignore ATTRIBUTE_UNUSED
)
2773 #ifdef MRI_MODE_CHANGE
2777 on
= get_absolute_expression ();
2778 #ifdef MRI_MODE_CHANGE
2779 old_flag
= flag_mri
;
2798 /* Operator precedence changes in m68k MRI mode, so we need to
2799 update the operator rankings. */
2800 expr_set_precedence ();
2802 #ifdef MRI_MODE_CHANGE
2804 MRI_MODE_CHANGE (on
);
2807 demand_empty_rest_of_line ();
2810 /* Handle changing the location counter. */
2813 do_org (segT segment
, expressionS
*exp
, int fill
)
2815 if (segment
!= now_seg
2816 && segment
!= absolute_section
2817 && segment
!= expr_section
)
2818 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2820 if (now_seg
== absolute_section
)
2823 as_warn (_("ignoring fill value in absolute section"));
2824 if (exp
->X_op
!= O_constant
)
2826 as_bad (_("only constant offsets supported in absolute section"));
2827 exp
->X_add_number
= 0;
2829 abs_section_offset
= exp
->X_add_number
;
2834 symbolS
*sym
= exp
->X_add_symbol
;
2835 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2837 if (fill
&& in_bss ())
2838 as_warn (_("ignoring fill value in section `%s'"),
2839 segment_name (now_seg
));
2841 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2843 /* Handle complex expressions. */
2844 sym
= make_expr_symbol (exp
);
2848 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2854 s_org (int ignore ATTRIBUTE_UNUSED
)
2860 #ifdef md_flush_pending_output
2861 md_flush_pending_output ();
2864 /* The m68k MRI assembler has a different meaning for .org. It
2865 means to create an absolute section at a given address. We can't
2866 support that--use a linker script instead. */
2869 as_bad (_("MRI style ORG pseudo-op not supported"));
2870 ignore_rest_of_line ();
2874 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2875 thing as a sub-segment-relative origin. Any absolute origin is
2876 given a warning, then assumed to be segment-relative. Any
2877 segmented origin expression ("foo+42") had better be in the right
2878 segment or the .org is ignored.
2880 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2881 we never know sub-segment sizes when we are reading code. BSD
2882 will crash trying to emit negative numbers of filler bytes in
2883 certain .orgs. We don't crash, but see as-write for that code.
2885 Don't make frag if need_pass_2==1. */
2886 segment
= get_known_segmented_expression (&exp
);
2887 if (*input_line_pointer
== ',')
2889 input_line_pointer
++;
2890 temp_fill
= get_absolute_expression ();
2896 do_org (segment
, &exp
, temp_fill
);
2898 demand_empty_rest_of_line ();
2901 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2902 called by the obj-format routine which handles section changing
2903 when in MRI mode. It will create a new section, and return it. It
2904 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2905 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2908 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2918 name
= input_line_pointer
;
2919 if (!ISDIGIT (*name
))
2920 c
= get_symbol_name (& name
);
2925 ++input_line_pointer
;
2927 while (ISDIGIT (*input_line_pointer
));
2929 c
= *input_line_pointer
;
2930 *input_line_pointer
= '\0';
2933 name
= xstrdup (name
);
2935 c
= restore_line_pointer (c
);
2937 seg
= subseg_new (name
, 0);
2943 ++input_line_pointer
;
2944 align
= get_absolute_expression ();
2945 record_alignment (seg
, align
);
2949 if (*input_line_pointer
== ',')
2951 c
= *++input_line_pointer
;
2953 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2956 as_bad (_("unrecognized section type"));
2957 ++input_line_pointer
;
2962 flags
= SEC_NO_FLAGS
;
2964 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2965 else if (*type
== 'D' || *type
== 'M')
2966 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2967 else if (*type
== 'R')
2968 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2969 if (flags
!= SEC_NO_FLAGS
)
2971 if (!bfd_set_section_flags (seg
, flags
))
2972 as_warn (_("error setting flags for \"%s\": %s"),
2973 bfd_section_name (seg
),
2974 bfd_errmsg (bfd_get_error ()));
2979 /* Ignore the HP type. */
2980 if (*input_line_pointer
== ',')
2981 input_line_pointer
+= 2;
2983 demand_empty_rest_of_line ();
2985 #else /* ! TC_M68K */
2986 /* The MRI assembler seems to use different forms of .sect for
2987 different targets. */
2988 as_bad ("MRI mode not supported for this target");
2989 ignore_rest_of_line ();
2990 #endif /* ! TC_M68K */
2993 /* Handle the .print pseudo-op. */
2996 s_print (int ignore ATTRIBUTE_UNUSED
)
3001 s
= demand_copy_C_string (&len
);
3004 demand_empty_rest_of_line ();
3007 /* Handle the .purgem pseudo-op. */
3010 s_purgem (int ignore ATTRIBUTE_UNUSED
)
3012 if (is_it_end_of_statement ())
3014 demand_empty_rest_of_line ();
3024 c
= get_symbol_name (& name
);
3025 delete_macro (name
);
3026 *input_line_pointer
= c
;
3027 SKIP_WHITESPACE_AFTER_NAME ();
3029 while (*input_line_pointer
++ == ',');
3031 --input_line_pointer
;
3032 demand_empty_rest_of_line ();
3035 /* Handle the .endm/.endr pseudo-ops. */
3038 s_bad_end (int endr
)
3040 as_warn (_(".end%c encountered without preceding %s"),
3042 endr
? ".rept, .irp, or .irpc" : ".macro");
3043 demand_empty_rest_of_line ();
3046 /* Handle the .rept pseudo-op. */
3049 s_rept (int ignore ATTRIBUTE_UNUSED
)
3053 count
= (size_t) get_absolute_expression ();
3055 do_repeat (count
, "REPT", "ENDR");
3058 /* This function provides a generic repeat block implementation. It allows
3059 different directives to be used as the start/end keys. */
3062 do_repeat (size_t count
, const char *start
, const char *end
)
3067 if (((ssize_t
) count
) < 0)
3069 as_bad (_("negative count for %s - ignored"), start
);
3074 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3076 as_bad (_("%s without %s"), start
, end
);
3080 sb_build (&many
, count
* one
.len
);
3082 sb_add_sb (&many
, &one
);
3086 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3088 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3091 /* Like do_repeat except that any text matching EXPANDER in the
3092 block is replaced by the iteration count. */
3095 do_repeat_with_expander (size_t count
,
3098 const char * expander
)
3103 if (((ssize_t
) count
) < 0)
3105 as_bad (_("negative count for %s - ignored"), start
);
3110 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3112 as_bad (_("%s without %s"), start
, end
);
3118 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3120 while (count
-- > 0)
3126 sb_build (& processed
, one
.len
);
3127 sb_add_sb (& processed
, & one
);
3128 sub
= strstr (processed
.ptr
, expander
);
3129 len
= sprintf (sub
, "%lu", (unsigned long) count
);
3130 gas_assert (len
< 8);
3131 memmove (sub
+ len
, sub
+ 8,
3132 processed
.ptr
+ processed
.len
- (sub
+ 8));
3133 processed
.len
-= (8 - len
);
3134 sb_add_sb (& many
, & processed
);
3135 sb_kill (& processed
);
3140 sb_add_sb (&many
, &one
);
3144 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3146 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3149 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3150 input buffers to skip. Assumes that conditionals preceding the loop end
3151 are properly nested.
3153 This function makes it easier to implement a premature "break" out of the
3154 loop. The EXTRA arg accounts for other buffers we might have inserted,
3155 such as line substitutions. */
3158 end_repeat (int extra
)
3160 cond_exit_macro (macro_nest
);
3161 while (extra
-- >= 0)
3162 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3166 assign_symbol (char *name
, int mode
)
3170 if (name
[0] == '.' && name
[1] == '\0')
3172 /* Turn '. = mumble' into a .org mumble. */
3176 segment
= get_known_segmented_expression (&exp
);
3179 do_org (segment
, &exp
, 0);
3184 if ((symbolP
= symbol_find (name
)) == NULL
3185 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3187 symbolP
= symbol_find_or_make (name
);
3189 /* When doing symbol listings, play games with dummy fragments living
3190 outside the normal fragment chain to record the file and line info
3192 if (listing
& LISTING_SYMBOLS
)
3194 extern struct list_info_struct
*listing_tail
;
3195 fragS
*dummy_frag
= XCNEW (fragS
);
3196 dummy_frag
->line
= listing_tail
;
3197 dummy_frag
->fr_symbol
= symbolP
;
3198 symbol_set_frag (symbolP
, dummy_frag
);
3201 #if defined (OBJ_COFF) && !defined (TE_PE)
3202 /* "set" symbols are local unless otherwise specified. */
3203 SF_SET_LOCAL (symbolP
);
3207 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3209 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3210 && !S_CAN_BE_REDEFINED (symbolP
))
3212 as_bad (_("symbol `%s' is already defined"), name
);
3213 ignore_rest_of_line ();
3214 input_line_pointer
--;
3217 /* If the symbol is volatile, copy the symbol and replace the
3218 original with the copy, so that previous uses of the symbol will
3219 retain the value of the symbol at the point of use. */
3220 else if (S_IS_VOLATILE (symbolP
))
3221 symbolP
= symbol_clone (symbolP
, 1);
3225 S_SET_VOLATILE (symbolP
);
3227 S_SET_FORWARD_REF (symbolP
);
3229 pseudo_set (symbolP
);
3232 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3233 then this is .equiv, and it is an error if the symbol is already
3234 defined. If EQUIV is -1, the symbol additionally is a forward
3242 /* Especial apologies for the random logic:
3243 this just grew, and could be parsed much more simply!
3245 if ((name
= read_symbol_name ()) == NULL
)
3248 if (*input_line_pointer
!= ',')
3250 as_bad (_("expected comma after \"%s\""), name
);
3251 ignore_rest_of_line ();
3256 input_line_pointer
++;
3257 assign_symbol (name
, equiv
);
3258 demand_empty_rest_of_line ();
3272 #ifdef md_flush_pending_output
3273 md_flush_pending_output ();
3276 #ifdef md_cons_align
3281 stop
= mri_comment_field (&stopc
);
3283 /* In m68k MRI mode, we need to align to a word boundary, unless
3285 if (flag_m68k_mri
&& mult
> 1)
3287 if (now_seg
== absolute_section
)
3289 abs_section_offset
+= abs_section_offset
& 1;
3290 if (line_label
!= NULL
)
3291 S_SET_VALUE (line_label
, abs_section_offset
);
3293 else if (mri_common_symbol
!= NULL
)
3297 mri_val
= S_GET_VALUE (mri_common_symbol
);
3298 if ((mri_val
& 1) != 0)
3300 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3301 if (line_label
!= NULL
)
3303 expressionS
*symexp
;
3305 symexp
= symbol_get_value_expression (line_label
);
3306 know (symexp
->X_op
== O_symbol
);
3307 know (symexp
->X_add_symbol
== mri_common_symbol
);
3308 symexp
->X_add_number
+= 1;
3314 do_align (1, (char *) NULL
, 0, 0);
3315 if (line_label
!= NULL
)
3317 symbol_set_frag (line_label
, frag_now
);
3318 S_SET_VALUE (line_label
, frag_now_fix ());
3328 if (*input_line_pointer
== ',')
3330 ++input_line_pointer
;
3335 val
.X_op
= O_constant
;
3336 val
.X_add_number
= 0;
3339 if ((val
.X_op
!= O_constant
3340 || val
.X_add_number
< - 0x80
3341 || val
.X_add_number
> 0xff
3342 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3343 && (now_seg
!= absolute_section
&& !in_bss ()))
3345 resolve_expression (&exp
);
3346 if (exp
.X_op
!= O_constant
)
3347 as_bad (_("unsupported variable size or fill value"));
3352 /* PR 20901: Check for excessive values.
3353 FIXME: 1<<10 is an arbitrary limit. Maybe use maxpagesize instead ? */
3354 if (exp
.X_add_number
< 0 || exp
.X_add_number
> (1 << 10))
3355 as_bad (_("size value for space directive too large: %lx"),
3356 (long) exp
.X_add_number
);
3361 bytes
= mult
* exp
.X_add_number
;
3363 for (i
= 0; i
< exp
.X_add_number
; i
++)
3364 emit_expr (&val
, mult
);
3370 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3371 resolve_expression (&exp
);
3373 if (exp
.X_op
== O_constant
)
3377 repeat
= exp
.X_add_number
;
3384 as_warn (_(".space repeat count is zero, ignored"));
3385 else if (repeat
< 0)
3386 as_warn (_(".space repeat count is negative, ignored"));
3390 /* If we are in the absolute section, just bump the offset. */
3391 if (now_seg
== absolute_section
)
3393 if (val
.X_op
!= O_constant
|| val
.X_add_number
!= 0)
3394 as_warn (_("ignoring fill value in absolute section"));
3395 abs_section_offset
+= repeat
;
3399 /* If we are secretly in an MRI common section, then
3400 creating space just increases the size of the common
3402 if (mri_common_symbol
!= NULL
)
3404 S_SET_VALUE (mri_common_symbol
,
3405 S_GET_VALUE (mri_common_symbol
) + repeat
);
3410 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3411 (offsetT
) repeat
, (char *) 0);
3415 if (now_seg
== absolute_section
)
3417 as_bad (_("space allocation too complex in absolute section"));
3418 subseg_set (text_section
, 0);
3421 if (mri_common_symbol
!= NULL
)
3423 as_bad (_("space allocation too complex in common section"));
3424 mri_common_symbol
= NULL
;
3428 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3429 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3432 if ((val
.X_op
!= O_constant
|| val
.X_add_number
!= 0) && in_bss ())
3433 as_warn (_("ignoring fill value in section `%s'"),
3434 segment_name (now_seg
));
3436 *p
= val
.X_add_number
;
3441 /* In MRI mode, after an odd number of bytes, we must align to an
3442 even word boundary, unless the next instruction is a dc.b, ds.b
3444 if (flag_mri
&& (bytes
& 1) != 0)
3445 mri_pending_align
= 1;
3447 demand_empty_rest_of_line ();
3450 mri_comment_end (stop
, stopc
);
3454 s_nops (int ignore ATTRIBUTE_UNUSED
)
3459 #ifdef md_flush_pending_output
3460 md_flush_pending_output ();
3463 #ifdef md_cons_align
3469 if (*input_line_pointer
== ',')
3471 ++input_line_pointer
;
3476 val
.X_op
= O_constant
;
3477 val
.X_add_number
= 0;
3480 if (val
.X_op
== O_constant
)
3482 if (val
.X_add_number
< 0)
3484 as_warn (_("negative nop control byte, ignored"));
3485 val
.X_add_number
= 0;
3490 /* Store the no-op instruction control byte in the first byte
3493 symbolS
*sym
= make_expr_symbol (&exp
);
3494 p
= frag_var (rs_space_nop
, 1, 1, (relax_substateT
) 0,
3495 sym
, (offsetT
) 0, (char *) 0);
3496 *p
= val
.X_add_number
;
3500 as_bad (_("unsupported variable nop control in .nops directive"));
3502 demand_empty_rest_of_line ();
3505 /* This is like s_space, but the value is a floating point number with
3506 the given precision. This is for the MRI dcb.s pseudo-op and
3510 s_float_space (int float_type
)
3514 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3518 #ifdef md_cons_align
3523 stop
= mri_comment_field (&stopc
);
3525 count
= get_absolute_expression ();
3528 if (*input_line_pointer
!= ',')
3530 as_bad (_("missing value"));
3531 ignore_rest_of_line ();
3533 mri_comment_end (stop
, stopc
);
3537 ++input_line_pointer
;
3541 /* Skip any 0{letter} that may be present. Don't even check if the
3542 * letter is legal. */
3543 if (input_line_pointer
[0] == '0'
3544 && ISALPHA (input_line_pointer
[1]))
3545 input_line_pointer
+= 2;
3547 /* Accept :xxxx, where the x's are hex digits, for a floating point
3548 with the exact digits specified. */
3549 if (input_line_pointer
[0] == ':')
3551 flen
= hex_float (float_type
, temp
);
3554 ignore_rest_of_line ();
3556 mri_comment_end (stop
, stopc
);
3564 err
= md_atof (float_type
, temp
, &flen
);
3565 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3566 know (err
!= NULL
|| flen
> 0);
3569 as_bad (_("bad floating literal: %s"), err
);
3570 ignore_rest_of_line ();
3572 mri_comment_end (stop
, stopc
);
3577 while (--count
>= 0)
3581 p
= frag_more (flen
);
3582 memcpy (p
, temp
, (unsigned int) flen
);
3585 demand_empty_rest_of_line ();
3588 mri_comment_end (stop
, stopc
);
3591 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3594 s_struct (int ignore ATTRIBUTE_UNUSED
)
3600 stop
= mri_comment_field (&stopc
);
3601 abs_section_offset
= get_absolute_expression ();
3602 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3603 /* The ELF backend needs to know that we are changing sections, so
3604 that .previous works correctly. */
3606 obj_elf_section_change_hook ();
3608 subseg_set (absolute_section
, 0);
3609 demand_empty_rest_of_line ();
3611 mri_comment_end (stop
, stopc
);
3615 s_text (int ignore ATTRIBUTE_UNUSED
)
3619 temp
= get_absolute_expression ();
3620 subseg_set (text_section
, (subsegT
) temp
);
3621 demand_empty_rest_of_line ();
3624 /* .weakref x, y sets x as an alias to y that, as long as y is not
3625 referenced directly, will cause y to become a weak symbol. */
3627 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3634 if ((name
= read_symbol_name ()) == NULL
)
3637 symbolP
= symbol_find_or_make (name
);
3639 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3641 if (!S_IS_VOLATILE (symbolP
))
3643 as_bad (_("symbol `%s' is already defined"), name
);
3646 symbolP
= symbol_clone (symbolP
, 1);
3647 S_CLEAR_VOLATILE (symbolP
);
3652 if (*input_line_pointer
!= ',')
3654 as_bad (_("expected comma after \"%s\""), name
);
3658 input_line_pointer
++;
3663 if ((name
= read_symbol_name ()) == NULL
)
3666 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3667 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3669 symbolP2
= symbol_find_or_make (name
);
3670 S_SET_WEAKREFD (symbolP2
);
3674 symbolS
*symp
= symbolP2
;
3676 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3678 expressionS
*expP
= symbol_get_value_expression (symp
);
3680 gas_assert (expP
->X_op
== O_symbol
3681 && expP
->X_add_number
== 0);
3682 symp
= expP
->X_add_symbol
;
3684 if (symp
== symbolP
)
3688 loop
= concat (S_GET_NAME (symbolP
),
3689 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3692 while (symp
!= symbolP
)
3694 char *old_loop
= loop
;
3696 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3697 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3698 (const char *) NULL
);
3702 as_bad (_("%s: would close weakref loop: %s"),
3703 S_GET_NAME (symbolP
), loop
);
3707 ignore_rest_of_line ();
3711 /* Short-circuiting instead of just checking here might speed
3712 things up a tiny little bit, but loop error messages would
3713 miss intermediate links. */
3714 /* symbolP2 = symp; */
3717 memset (&exp
, 0, sizeof (exp
));
3718 exp
.X_op
= O_symbol
;
3719 exp
.X_add_symbol
= symbolP2
;
3721 S_SET_SEGMENT (symbolP
, undefined_section
);
3722 symbol_set_value_expression (symbolP
, &exp
);
3723 symbol_set_frag (symbolP
, &zero_address_frag
);
3724 S_SET_WEAKREFR (symbolP
);
3726 demand_empty_rest_of_line ();
3731 ignore_rest_of_line ();
3737 /* Verify that we are at the end of a line. If not, issue an error and
3741 demand_empty_rest_of_line (void)
3744 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3745 input_line_pointer
++;
3748 if (ISPRINT (*input_line_pointer
))
3749 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3750 *input_line_pointer
);
3752 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3753 *input_line_pointer
);
3754 ignore_rest_of_line ();
3757 /* Return pointing just after end-of-line. */
3758 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3761 /* Silently advance to the end of line. Use this after already having
3762 issued an error about something bad. */
3765 ignore_rest_of_line (void)
3767 while (input_line_pointer
< buffer_limit
3768 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3769 input_line_pointer
++;
3771 input_line_pointer
++;
3773 /* Return pointing just after end-of-line. */
3774 if (input_line_pointer
<= buffer_limit
)
3775 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3778 /* Sets frag for given symbol to zero_address_frag, except when the
3779 symbol frag is already set to a dummy listing frag. */
3782 set_zero_frag (symbolS
*symbolP
)
3784 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3785 symbol_set_frag (symbolP
, &zero_address_frag
);
3788 /* In: Pointer to a symbol.
3789 Input_line_pointer->expression.
3791 Out: Input_line_pointer->just after any whitespace after expression.
3792 Tried to set symbol to value of expression.
3793 Will change symbols type, value, and frag; */
3796 pseudo_set (symbolS
*symbolP
)
3801 know (symbolP
); /* NULL pointer is logic error. */
3803 if (!S_IS_FORWARD_REF (symbolP
))
3804 (void) expression (&exp
);
3806 (void) deferred_expression (&exp
);
3808 if (exp
.X_op
== O_illegal
)
3809 as_bad (_("illegal expression"));
3810 else if (exp
.X_op
== O_absent
)
3811 as_bad (_("missing expression"));
3812 else if (exp
.X_op
== O_big
)
3814 if (exp
.X_add_number
> 0)
3815 as_bad (_("bignum invalid"));
3817 as_bad (_("floating point number invalid"));
3819 else if (exp
.X_op
== O_subtract
3820 && !S_IS_FORWARD_REF (symbolP
)
3821 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3822 && (symbol_get_frag (exp
.X_add_symbol
)
3823 == symbol_get_frag (exp
.X_op_symbol
)))
3825 exp
.X_op
= O_constant
;
3826 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3827 - S_GET_VALUE (exp
.X_op_symbol
));
3830 if (symbol_section_p (symbolP
))
3832 as_bad ("attempt to set value of section symbol");
3841 exp
.X_add_number
= 0;
3844 S_SET_SEGMENT (symbolP
, absolute_section
);
3845 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3846 set_zero_frag (symbolP
);
3850 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3851 if (S_IS_EXTERNAL (symbolP
))
3853 as_bad ("can't equate global symbol `%s' with register name",
3854 S_GET_NAME (symbolP
));
3858 S_SET_SEGMENT (symbolP
, reg_section
);
3859 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3860 set_zero_frag (symbolP
);
3861 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3865 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3866 /* For x=undef+const, create an expression symbol.
3867 For x=x+const, just update x except when x is an undefined symbol
3868 For x=defined+const, evaluate x. */
3869 if (symbolP
== exp
.X_add_symbol
3870 && (seg
!= undefined_section
3871 || !symbol_constant_p (symbolP
)))
3873 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3876 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3878 symbolS
*s
= exp
.X_add_symbol
;
3880 if (S_IS_COMMON (s
))
3881 as_bad (_("`%s' can't be equated to common symbol `%s'"),
3882 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3884 S_SET_SEGMENT (symbolP
, seg
);
3885 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3886 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3887 copy_symbol_attributes (symbolP
, s
);
3890 S_SET_SEGMENT (symbolP
, undefined_section
);
3891 symbol_set_value_expression (symbolP
, &exp
);
3892 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3893 set_zero_frag (symbolP
);
3897 /* The value is some complex expression. */
3898 S_SET_SEGMENT (symbolP
, expr_section
);
3899 symbol_set_value_expression (symbolP
, &exp
);
3900 set_zero_frag (symbolP
);
3907 CONStruct more frag of .bytes, or .words etc.
3908 Should need_pass_2 be 1 then emit no frag(s).
3909 This understands EXPRESSIONS.
3913 This has a split personality. We use expression() to read the
3914 value. We can detect if the value won't fit in a byte or word.
3915 But we can't detect if expression() discarded significant digits
3916 in the case of a long. Not worth the crocks required to fix it. */
3918 /* Select a parser for cons expressions. */
3920 /* Some targets need to parse the expression in various fancy ways.
3921 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3922 (for example, the HPPA does this). Otherwise, you can define
3923 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3924 are defined, which is the normal case, then only simple expressions
3929 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3932 #ifndef TC_PARSE_CONS_EXPRESSION
3933 #ifdef REPEAT_CONS_EXPRESSIONS
3934 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3935 (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
3937 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3940 /* If we haven't gotten one yet, just call expression. */
3941 #ifndef TC_PARSE_CONS_EXPRESSION
3942 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
3943 (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
3948 do_parse_cons_expression (expressionS
*exp
,
3949 int nbytes ATTRIBUTE_UNUSED
)
3951 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3955 /* Worker to do .byte etc statements.
3956 Clobbers input_line_pointer and checks end-of-line. */
3959 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3967 #ifdef md_flush_pending_output
3968 md_flush_pending_output ();
3972 stop
= mri_comment_field (&stopc
);
3974 if (is_it_end_of_statement ())
3976 demand_empty_rest_of_line ();
3978 mri_comment_end (stop
, stopc
);
3982 #ifdef TC_ADDRESS_BYTES
3984 nbytes
= TC_ADDRESS_BYTES ();
3987 #ifdef md_cons_align
3988 md_cons_align (nbytes
);
3994 TC_PARSE_CONS_RETURN_TYPE ret
= TC_PARSE_CONS_RETURN_NONE
;
3995 #ifdef TC_CONS_FIX_CHECK
3996 fixS
**cur_fix
= &frchain_now
->fix_tail
;
3998 if (*cur_fix
!= NULL
)
3999 cur_fix
= &(*cur_fix
)->fx_next
;
4004 parse_mri_cons (&exp
, (unsigned int) nbytes
);
4009 if (*input_line_pointer
== '"')
4011 as_bad (_("unexpected `\"' in expression"));
4012 ignore_rest_of_line ();
4016 ret
= TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
4021 if (exp
.X_op
== O_symbol
)
4022 exp
.X_op
= O_symbol_rva
;
4024 as_fatal (_("rva without symbol"));
4026 emit_expr_with_reloc (&exp
, (unsigned int) nbytes
, ret
);
4027 #ifdef TC_CONS_FIX_CHECK
4028 TC_CONS_FIX_CHECK (&exp
, nbytes
, *cur_fix
);
4032 while (*input_line_pointer
++ == ',');
4034 /* In MRI mode, after an odd number of bytes, we must align to an
4035 even word boundary, unless the next instruction is a dc.b, ds.b
4037 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
4038 mri_pending_align
= 1;
4040 input_line_pointer
--; /* Put terminator back into stream. */
4042 demand_empty_rest_of_line ();
4045 mri_comment_end (stop
, stopc
);
4051 cons_worker (size
, 0);
4057 cons_worker (size
, 1);
4060 /* .reloc offset, reloc_name, symbol+addend. */
4063 s_reloc (int ignore ATTRIBUTE_UNUSED
)
4070 struct reloc_list
*reloc
;
4071 struct _bfd_rel
{ const char * name
; bfd_reloc_code_real_type code
; };
4072 static struct _bfd_rel bfd_relocs
[] =
4074 { "NONE", BFD_RELOC_NONE
},
4075 { "8", BFD_RELOC_8
},
4076 { "16", BFD_RELOC_16
},
4077 { "32", BFD_RELOC_32
},
4078 { "64", BFD_RELOC_64
}
4081 reloc
= XNEW (struct reloc_list
);
4084 stop
= mri_comment_field (&stopc
);
4093 as_bad (_("missing or bad offset expression"));
4096 exp
.X_add_symbol
= section_symbol (now_seg
);
4097 exp
.X_op
= O_symbol
;
4100 if (exp
.X_add_number
== 0)
4102 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
4107 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
4112 if (*input_line_pointer
!= ',')
4114 as_bad (_("missing reloc type"));
4118 ++input_line_pointer
;
4120 c
= get_symbol_name (& r_name
);
4121 if (strncasecmp (r_name
, "BFD_RELOC_", 10) == 0)
4125 for (reloc
->u
.a
.howto
= NULL
, i
= 0; i
< ARRAY_SIZE (bfd_relocs
); i
++)
4126 if (strcasecmp (r_name
+ 10, bfd_relocs
[i
].name
) == 0)
4128 reloc
->u
.a
.howto
= bfd_reloc_type_lookup (stdoutput
,
4129 bfd_relocs
[i
].code
);
4134 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
4135 *input_line_pointer
= c
;
4136 if (reloc
->u
.a
.howto
== NULL
)
4138 as_bad (_("unrecognized reloc type"));
4142 exp
.X_op
= O_absent
;
4143 SKIP_WHITESPACE_AFTER_NAME ();
4144 if (*input_line_pointer
== ',')
4146 ++input_line_pointer
;
4154 as_bad (_("bad reloc expression"));
4156 ignore_rest_of_line ();
4159 mri_comment_end (stop
, stopc
);
4162 reloc
->u
.a
.sym
= NULL
;
4163 reloc
->u
.a
.addend
= 0;
4166 reloc
->u
.a
.sym
= NULL
;
4167 reloc
->u
.a
.addend
= exp
.X_add_number
;
4170 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4171 reloc
->u
.a
.addend
= exp
.X_add_number
;
4174 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4175 reloc
->u
.a
.addend
= 0;
4179 reloc
->file
= as_where (&reloc
->line
);
4180 reloc
->next
= reloc_list
;
4183 demand_empty_rest_of_line ();
4185 mri_comment_end (stop
, stopc
);
4188 /* Put the contents of expression EXP into the object file using
4189 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4192 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4194 emit_expr_with_reloc (exp
, nbytes
, TC_PARSE_CONS_RETURN_NONE
);
4198 emit_expr_with_reloc (expressionS
*exp
,
4199 unsigned int nbytes
,
4200 TC_PARSE_CONS_RETURN_TYPE reloc
)
4204 valueT extra_digit
= 0;
4206 /* Don't do anything if we are going to make another pass. */
4211 dot_value
= frag_now_fix ();
4212 dot_frag
= frag_now
;
4216 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4217 appear as a four byte positive constant in the .line section,
4218 followed by a 2 byte 0xffff. Look for that case here. */
4220 static int dwarf_line
= -1;
4222 if (strcmp (segment_name (now_seg
), ".line") != 0)
4224 else if (dwarf_line
>= 0
4226 && exp
->X_op
== O_constant
4227 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4228 listing_source_line ((unsigned int) dwarf_line
);
4229 else if (nbytes
== 4
4230 && exp
->X_op
== O_constant
4231 && exp
->X_add_number
>= 0)
4232 dwarf_line
= exp
->X_add_number
;
4237 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4238 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4239 AT_sibling (0x12) followed by a four byte address of the sibling
4240 followed by a 2 byte AT_name (0x38) followed by the name of the
4241 file. We look for that case here. */
4243 static int dwarf_file
= 0;
4245 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4247 else if (dwarf_file
== 0
4249 && exp
->X_op
== O_constant
4250 && exp
->X_add_number
== 0x11)
4252 else if (dwarf_file
== 1
4254 && exp
->X_op
== O_constant
4255 && exp
->X_add_number
== 0x12)
4257 else if (dwarf_file
== 2
4260 else if (dwarf_file
== 3
4262 && exp
->X_op
== O_constant
4263 && exp
->X_add_number
== 0x38)
4268 /* The variable dwarf_file_string tells stringer that the string
4269 may be the name of the source file. */
4270 if (dwarf_file
== 4)
4271 dwarf_file_string
= 1;
4273 dwarf_file_string
= 0;
4278 if (check_eh_frame (exp
, &nbytes
))
4283 /* Handle a negative bignum. */
4285 && exp
->X_add_number
== 0
4286 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4287 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4290 unsigned long carry
;
4292 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4294 /* Negate the bignum: one's complement each digit and add 1. */
4296 for (i
= 0; i
< exp
->X_add_number
; i
++)
4300 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4303 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4304 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4307 /* We can ignore any carry out, because it will be handled by
4308 extra_digit if it is needed. */
4310 extra_digit
= (valueT
) -1;
4314 if (op
== O_absent
|| op
== O_illegal
)
4316 as_warn (_("zero assumed for missing expression"));
4317 exp
->X_add_number
= 0;
4320 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4322 as_bad (_("floating point number invalid"));
4323 exp
->X_add_number
= 0;
4326 else if (op
== O_register
)
4328 as_warn (_("register value used as expression"));
4332 /* Allow `.word 0' in the absolute section. */
4333 if (now_seg
== absolute_section
)
4335 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4336 as_bad (_("attempt to store value in absolute section"));
4337 abs_section_offset
+= nbytes
;
4341 /* Allow `.word 0' in BSS style sections. */
4342 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
4343 as_bad (_("attempt to store non-zero value in section `%s'"),
4344 segment_name (now_seg
));
4346 p
= frag_more ((int) nbytes
);
4348 if (reloc
!= TC_PARSE_CONS_RETURN_NONE
)
4350 emit_expr_fix (exp
, nbytes
, frag_now
, p
, reloc
);
4354 #ifndef WORKING_DOT_WORD
4355 /* If we have the difference of two symbols in a word, save it on
4356 the broken_words list. See the code in write.c. */
4357 if (op
== O_subtract
&& nbytes
== 2)
4359 struct broken_word
*x
;
4361 x
= XNEW (struct broken_word
);
4362 x
->next_broken_word
= broken_words
;
4365 x
->subseg
= now_subseg
;
4367 x
->word_goes_here
= p
;
4369 x
->add
= exp
->X_add_symbol
;
4370 x
->sub
= exp
->X_op_symbol
;
4371 x
->addnum
= exp
->X_add_number
;
4379 /* If we have an integer, but the number of bytes is too large to
4380 pass to md_number_to_chars, handle it as a bignum. */
4381 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4383 extra_digit
= exp
->X_unsigned
? 0 : -1;
4384 convert_to_bignum (exp
, !exp
->X_unsigned
);
4388 if (op
== O_constant
)
4396 /* JF << of >= number of bits in the object is undefined. In
4397 particular SPARC (Sun 4) has problems. */
4398 if (nbytes
>= sizeof (valueT
))
4401 if (nbytes
> sizeof (valueT
))
4404 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4408 /* Don't store these bits. */
4409 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4410 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4413 unmask
= ~mask
; /* Do store these bits. */
4416 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4417 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4420 get
= exp
->X_add_number
;
4422 if ((get
& mask
) != 0
4423 && ((get
& mask
) != mask
4424 || (get
& hibit
) == 0))
4426 /* Leading bits contain both 0s & 1s. */
4427 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4429 as_warn (_("value 0x%llx truncated to 0x%llx"),
4430 (unsigned long long) get
, (unsigned long long) use
);
4432 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4433 (unsigned long long) get
, (unsigned long long) use
);
4436 as_warn (_("value 0x%lx truncated to 0x%lx"),
4437 (unsigned long) get
, (unsigned long) use
);
4440 /* Put bytes in right order. */
4441 md_number_to_chars (p
, use
, (int) nbytes
);
4443 else if (op
== O_big
)
4446 LITTLENUM_TYPE
*nums
;
4448 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4451 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4455 LITTLENUM_TYPE sign
= 0;
4456 if ((generic_bignum
[--i
]
4457 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4458 sign
= ~(LITTLENUM_TYPE
) 0;
4460 while (++i
< exp
->X_add_number
)
4461 if (generic_bignum
[i
] != sign
)
4464 else if (nbytes
== 1)
4466 /* We have nbytes == 1 and CHARS_PER_LITTLENUM == 2 (probably).
4467 Check that bits 8.. of generic_bignum[0] match bit 7
4468 and that they match all of generic_bignum[1..exp->X_add_number]. */
4469 LITTLENUM_TYPE sign
= (generic_bignum
[0] & (1 << 7)) ? -1 : 0;
4470 LITTLENUM_TYPE himask
= LITTLENUM_MASK
& ~ 0xFF;
4472 if ((generic_bignum
[0] & himask
) == (sign
& himask
))
4474 while (++i
< exp
->X_add_number
)
4475 if (generic_bignum
[i
] != sign
)
4480 if (i
< exp
->X_add_number
)
4481 as_warn (ngettext ("bignum truncated to %d byte",
4482 "bignum truncated to %d bytes",
4490 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4493 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4495 if (target_big_endian
)
4497 while (nbytes
> size
)
4499 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4500 nbytes
-= CHARS_PER_LITTLENUM
;
4501 p
+= CHARS_PER_LITTLENUM
;
4504 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4505 while (size
>= CHARS_PER_LITTLENUM
)
4508 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4509 size
-= CHARS_PER_LITTLENUM
;
4510 p
+= CHARS_PER_LITTLENUM
;
4515 nums
= generic_bignum
;
4516 while (size
>= CHARS_PER_LITTLENUM
)
4518 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4520 size
-= CHARS_PER_LITTLENUM
;
4521 p
+= CHARS_PER_LITTLENUM
;
4522 nbytes
-= CHARS_PER_LITTLENUM
;
4525 while (nbytes
>= CHARS_PER_LITTLENUM
)
4527 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4528 nbytes
-= CHARS_PER_LITTLENUM
;
4529 p
+= CHARS_PER_LITTLENUM
;
4534 emit_expr_fix (exp
, nbytes
, frag_now
, p
, TC_PARSE_CONS_RETURN_NONE
);
4538 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
,
4539 TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED
)
4542 unsigned int size
= nbytes
;
4544 memset (p
, 0, size
);
4546 /* Generate a fixS to record the symbol value. */
4548 #ifdef TC_CONS_FIX_NEW
4549 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
+ offset
, size
, exp
, r
);
4551 if (r
!= TC_PARSE_CONS_RETURN_NONE
)
4553 reloc_howto_type
*reloc_howto
;
4555 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, r
);
4556 size
= bfd_get_reloc_size (reloc_howto
);
4560 as_bad (ngettext ("%s relocations do not fit in %u byte",
4561 "%s relocations do not fit in %u bytes",
4563 reloc_howto
->name
, nbytes
);
4566 else if (target_big_endian
)
4567 offset
= nbytes
- size
;
4588 as_bad (_("unsupported BFD relocation size %u"), size
);
4591 fix_new_exp (frag
, p
- frag
->fr_literal
+ offset
, size
,
4596 /* Handle an MRI style string expression. */
4600 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
)
4602 if (*input_line_pointer
!= '\''
4603 && (input_line_pointer
[1] != '\''
4604 || (*input_line_pointer
!= 'A'
4605 && *input_line_pointer
!= 'E')))
4606 (void) TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4610 unsigned int result
= 0;
4612 /* An MRI style string. Cut into as many bytes as will fit into
4613 a nbyte chunk, left justify if necessary, and separate with
4614 commas so we can try again later. */
4615 if (*input_line_pointer
== 'A')
4616 ++input_line_pointer
;
4617 else if (*input_line_pointer
== 'E')
4619 as_bad (_("EBCDIC constants are not supported"));
4620 ++input_line_pointer
;
4623 input_line_pointer
++;
4624 for (scan
= 0; scan
< nbytes
; scan
++)
4626 if (*input_line_pointer
== '\'')
4628 if (input_line_pointer
[1] == '\'')
4630 input_line_pointer
++;
4635 result
= (result
<< 8) | (*input_line_pointer
++);
4639 while (scan
< nbytes
)
4645 /* Create correct expression. */
4646 exp
->X_op
= O_constant
;
4647 exp
->X_add_number
= result
;
4649 /* Fake it so that we can read the next char too. */
4650 if (input_line_pointer
[0] != '\'' ||
4651 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4653 input_line_pointer
-= 2;
4654 input_line_pointer
[0] = ',';
4655 input_line_pointer
[1] = '\'';
4658 input_line_pointer
++;
4661 #endif /* TC_M68K */
4663 #ifdef REPEAT_CONS_EXPRESSIONS
4665 /* Parse a repeat expression for cons. This is used by the MIPS
4666 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4667 object file COUNT times.
4669 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4672 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
)
4679 if (*input_line_pointer
!= ':')
4681 /* No repeat count. */
4685 ++input_line_pointer
;
4686 expression (&count
);
4687 if (count
.X_op
!= O_constant
4688 || count
.X_add_number
<= 0)
4690 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4694 /* The cons function is going to output this expression once. So we
4695 output it count - 1 times. */
4696 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4697 emit_expr (exp
, nbytes
);
4700 #endif /* REPEAT_CONS_EXPRESSIONS */
4702 /* Parse a floating point number represented as a hex constant. This
4703 permits users to specify the exact bits they want in the floating
4707 hex_float (int float_type
, char *bytes
)
4739 as_bad (_("unknown floating type type '%c'"), float_type
);
4743 /* It would be nice if we could go through expression to parse the
4744 hex constant, but if we get a bignum it's a pain to sort it into
4745 the buffer correctly. */
4747 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4751 /* The MRI assembler accepts arbitrary underscores strewn about
4752 through the hex constant, so we ignore them as well. */
4753 if (*input_line_pointer
== '_')
4755 ++input_line_pointer
;
4761 as_warn (_("floating point constant too large"));
4764 d
= hex_value (*input_line_pointer
) << 4;
4765 ++input_line_pointer
;
4766 while (*input_line_pointer
== '_')
4767 ++input_line_pointer
;
4768 if (hex_p (*input_line_pointer
))
4770 d
+= hex_value (*input_line_pointer
);
4771 ++input_line_pointer
;
4773 if (target_big_endian
)
4776 bytes
[length
- i
- 1] = d
;
4782 if (target_big_endian
)
4783 memset (bytes
+ i
, 0, length
- i
);
4785 memset (bytes
, 0, length
- i
);
4793 CONStruct some more frag chars of .floats .ffloats etc.
4794 Makes 0 or more new frags.
4795 If need_pass_2 == 1, no frags are emitted.
4796 This understands only floating literals, not expressions. Sorry.
4798 A floating constant is defined by atof_generic(), except it is preceded
4799 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4800 reading, I decided to be incompatible. This always tries to give you
4801 rounded bits to the precision of the pseudo-op. Former AS did premature
4802 truncation, restored noisy bits instead of trailing 0s AND gave you
4803 a choice of 2 flavours of noise according to which of 2 floating-point
4804 scanners you directed AS to use.
4806 In: input_line_pointer->whitespace before, or '0' of flonum. */
4809 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4810 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4813 int length
; /* Number of chars in an object. */
4814 const char *err
; /* Error from scanning floating literal. */
4815 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4817 if (is_it_end_of_statement ())
4819 demand_empty_rest_of_line ();
4823 if (now_seg
== absolute_section
)
4825 as_bad (_("attempt to store float in absolute section"));
4826 ignore_rest_of_line ();
4832 as_bad (_("attempt to store float in section `%s'"),
4833 segment_name (now_seg
));
4834 ignore_rest_of_line ();
4838 #ifdef md_flush_pending_output
4839 md_flush_pending_output ();
4842 #ifdef md_cons_align
4848 /* input_line_pointer->1st char of a flonum (we hope!). */
4851 /* Skip any 0{letter} that may be present. Don't even check if the
4852 letter is legal. Someone may invent a "z" format and this routine
4853 has no use for such information. Lusers beware: you get
4854 diagnostics if your input is ill-conditioned. */
4855 if (input_line_pointer
[0] == '0'
4856 && ISALPHA (input_line_pointer
[1]))
4857 input_line_pointer
+= 2;
4859 /* Accept :xxxx, where the x's are hex digits, for a floating
4860 point with the exact digits specified. */
4861 if (input_line_pointer
[0] == ':')
4863 ++input_line_pointer
;
4864 length
= hex_float (float_type
, temp
);
4867 ignore_rest_of_line ();
4873 err
= md_atof (float_type
, temp
, &length
);
4874 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4875 know (err
!= NULL
|| length
> 0);
4878 as_bad (_("bad floating literal: %s"), err
);
4879 ignore_rest_of_line ();
4890 #ifdef REPEAT_CONS_EXPRESSIONS
4891 if (*input_line_pointer
== ':')
4893 expressionS count_exp
;
4895 ++input_line_pointer
;
4896 expression (&count_exp
);
4898 if (count_exp
.X_op
!= O_constant
4899 || count_exp
.X_add_number
<= 0)
4900 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4902 count
= count_exp
.X_add_number
;
4906 while (--count
>= 0)
4908 p
= frag_more (length
);
4909 memcpy (p
, temp
, (unsigned int) length
);
4914 while (*input_line_pointer
++ == ',');
4916 /* Put terminator back into stream. */
4917 --input_line_pointer
;
4918 demand_empty_rest_of_line ();
4923 Note - we are using the DWARF standard's definition of LEB128 encoding
4924 where each 7-bit value is a stored in a byte, *not* an octet. This
4925 means that on targets where a byte contains multiple octets there is
4926 a *huge waste of space*. (This also means that we do not have to
4927 have special versions of these functions for when OCTETS_PER_BYTE_POWER
4930 If the 7-bit values were to be packed into N-bit bytes (where N > 8)
4931 we would then have to consider whether multiple, successive LEB128
4932 values should be packed into the bytes without padding (bad idea) or
4933 whether each LEB128 number is padded out to a whole number of bytes.
4934 Plus you have to decide on the endianness of packing octets into a
4937 /* Return the size of a LEB128 value in bytes. */
4939 static inline unsigned int
4940 sizeof_sleb128 (offsetT value
)
4947 byte
= (value
& 0x7f);
4948 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4949 Fortunately, we can structure things so that the extra work reduces
4950 to a noop on systems that do things "properly". */
4951 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4954 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4955 || ((value
== -1) && ((byte
& 0x40) != 0))));
4960 static inline unsigned int
4961 sizeof_uleb128 (valueT value
)
4976 sizeof_leb128 (valueT value
, int sign
)
4979 return sizeof_sleb128 ((offsetT
) value
);
4981 return sizeof_uleb128 (value
);
4984 /* Output a LEB128 value. Returns the number of bytes used. */
4986 static inline unsigned int
4987 output_sleb128 (char *p
, offsetT value
)
4994 unsigned byte
= (value
& 0x7f);
4996 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4997 Fortunately, we can structure things so that the extra work reduces
4998 to a noop on systems that do things "properly". */
4999 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
5001 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
5002 || ((value
== -1) && ((byte
& 0x40) != 0))));
5013 static inline unsigned int
5014 output_uleb128 (char *p
, valueT value
)
5020 unsigned byte
= (value
& 0x7f);
5024 /* More bytes to follow. */
5035 output_leb128 (char *p
, valueT value
, int sign
)
5038 return output_sleb128 (p
, (offsetT
) value
);
5040 return output_uleb128 (p
, value
);
5043 /* Do the same for bignums. We combine sizeof with output here in that
5044 we don't output for NULL values of P. It isn't really as critical as
5045 for "normal" values that this be streamlined. Returns the number of
5048 static inline unsigned int
5049 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5056 /* Strip leading sign extensions off the bignum. */
5058 && bignum
[size
- 1] == LITTLENUM_MASK
5059 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
5064 /* OR in the next part of the littlenum. */
5065 val
|= (*bignum
<< loaded
);
5066 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
5070 /* Add bytes until there are less than 7 bits left in VAL
5071 or until every non-sign bit has been written. */
5078 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
5085 while ((byte
& 0x80) != 0 && loaded
>= 7);
5089 /* Mop up any left-over bits (of which there will be less than 7). */
5090 if ((byte
& 0x80) != 0)
5092 /* Sign-extend VAL. */
5093 if (val
& (1 << (loaded
- 1)))
5094 val
|= ~0U << loaded
;
5103 static inline unsigned int
5104 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
)
5111 /* Strip leading zeros off the bignum. */
5112 /* XXX: Is this needed? */
5113 while (size
> 0 && bignum
[size
- 1] == 0)
5118 if (loaded
< 7 && size
> 0)
5120 val
|= (*bignum
<< loaded
);
5121 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5130 if (size
> 0 || val
)
5137 while (byte
& 0x80);
5143 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, unsigned int size
, int sign
)
5146 return output_big_sleb128 (p
, bignum
, size
);
5148 return output_big_uleb128 (p
, bignum
, size
);
5151 /* Generate the appropriate fragments for a given expression to emit a
5152 leb128 value. SIGN is 1 for sleb, 0 for uleb. */
5155 emit_leb128_expr (expressionS
*exp
, int sign
)
5157 operatorT op
= exp
->X_op
;
5158 unsigned int nbytes
;
5160 if (op
== O_absent
|| op
== O_illegal
)
5162 as_warn (_("zero assumed for missing expression"));
5163 exp
->X_add_number
= 0;
5166 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5168 as_bad (_("floating point number invalid"));
5169 exp
->X_add_number
= 0;
5172 else if (op
== O_register
)
5174 as_warn (_("register value used as expression"));
5177 else if (op
== O_constant
5179 && (exp
->X_add_number
< 0) == !exp
->X_extrabit
)
5181 /* We're outputting a signed leb128 and the sign of X_add_number
5182 doesn't reflect the sign of the original value. Convert EXP
5183 to a correctly-extended bignum instead. */
5184 convert_to_bignum (exp
, exp
->X_extrabit
);
5188 if (now_seg
== absolute_section
)
5190 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
5191 as_bad (_("attempt to store value in absolute section"));
5192 abs_section_offset
++;
5196 if ((op
!= O_constant
|| exp
->X_add_number
!= 0) && in_bss ())
5197 as_bad (_("attempt to store non-zero value in section `%s'"),
5198 segment_name (now_seg
));
5200 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5201 a signal that this is leb128 data. It shouldn't optimize this away. */
5202 nbytes
= (unsigned int) -1;
5203 if (check_eh_frame (exp
, &nbytes
))
5206 /* Let the backend know that subsequent data may be byte aligned. */
5207 #ifdef md_cons_align
5211 if (op
== O_constant
)
5213 /* If we've got a constant, emit the thing directly right now. */
5215 valueT value
= exp
->X_add_number
;
5219 size
= sizeof_leb128 (value
, sign
);
5220 p
= frag_more (size
);
5221 if (output_leb128 (p
, value
, sign
) > size
)
5224 else if (op
== O_big
)
5226 /* O_big is a different sort of constant. */
5227 int nbr_digits
= exp
->X_add_number
;
5231 /* If the leading littenum is 0xffff, prepend a 0 to avoid confusion with
5232 a signed number. Unary operators like - or ~ always extend the
5233 bignum to its largest size. */
5235 && nbr_digits
< SIZE_OF_LARGE_NUMBER
5236 && generic_bignum
[nbr_digits
- 1] == LITTLENUM_MASK
)
5237 generic_bignum
[nbr_digits
++] = 0;
5239 size
= output_big_leb128 (NULL
, generic_bignum
, nbr_digits
, sign
);
5240 p
= frag_more (size
);
5241 if (output_big_leb128 (p
, generic_bignum
, nbr_digits
, sign
) > size
)
5246 /* Otherwise, we have to create a variable sized fragment and
5247 resolve things later. */
5249 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5250 make_expr_symbol (exp
), 0, (char *) NULL
);
5254 /* Parse the .sleb128 and .uleb128 pseudos. */
5261 #ifdef md_flush_pending_output
5262 md_flush_pending_output ();
5268 emit_leb128_expr (&exp
, sign
);
5270 while (*input_line_pointer
++ == ',');
5272 input_line_pointer
--;
5273 demand_empty_rest_of_line ();
5277 stringer_append_char (int c
, int bitsize
)
5280 as_bad (_("attempt to store non-empty string in section `%s'"),
5281 segment_name (now_seg
));
5283 if (!target_big_endian
)
5284 FRAG_APPEND_1_CHAR (c
);
5289 FRAG_APPEND_1_CHAR (0);
5290 FRAG_APPEND_1_CHAR (0);
5291 FRAG_APPEND_1_CHAR (0);
5292 FRAG_APPEND_1_CHAR (0);
5295 FRAG_APPEND_1_CHAR (0);
5296 FRAG_APPEND_1_CHAR (0);
5299 FRAG_APPEND_1_CHAR (0);
5304 /* Called with invalid bitsize argument. */
5308 if (target_big_endian
)
5309 FRAG_APPEND_1_CHAR (c
);
5312 /* Worker to do .ascii etc statements.
5313 Reads 0 or more ',' separated, double-quoted strings.
5314 Caller should have checked need_pass_2 is FALSE because we don't
5316 Checks for end-of-line.
5317 BITS_APPENDZERO says how many bits are in a target char.
5318 The bottom bit is set if a NUL char should be appended to the strings. */
5321 stringer (int bits_appendzero
)
5323 const int bitsize
= bits_appendzero
& ~7;
5324 const int append_zero
= bits_appendzero
& 1;
5326 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5330 #ifdef md_flush_pending_output
5331 md_flush_pending_output ();
5334 #ifdef md_cons_align
5338 /* If we have been switched into the abs_section then we
5339 will not have an obstack onto which we can hang strings. */
5340 if (now_seg
== absolute_section
)
5342 as_bad (_("strings must be placed into a section"));
5343 ignore_rest_of_line ();
5347 /* The following awkward logic is to parse ZERO or more strings,
5348 comma separated. Recall a string expression includes spaces
5349 before the opening '\"' and spaces after the closing '\"'.
5350 We fake a leading ',' if there is (supposed to be)
5351 a 1st, expression. We keep demanding expressions for each ','. */
5352 if (is_it_end_of_statement ())
5354 c
= 0; /* Skip loop. */
5355 ++input_line_pointer
; /* Compensate for end of loop. */
5359 c
= ','; /* Do loop. */
5362 while (c
== ',' || c
== '<' || c
== '"')
5365 switch (*input_line_pointer
)
5368 ++input_line_pointer
; /*->1st char of string. */
5369 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5370 start
= input_line_pointer
;
5373 while (is_a_char (c
= next_char_of_string ()))
5374 stringer_append_char (c
, bitsize
);
5377 stringer_append_char (0, bitsize
);
5379 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5380 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5381 will emit .string with a filename in the .debug section
5382 after a sequence of constants. See the comment in
5383 emit_expr for the sequence. emit_expr will set
5384 dwarf_file_string to non-zero if this string might be a
5385 source file name. */
5386 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5387 dwarf_file_string
= 0;
5388 else if (dwarf_file_string
)
5390 c
= input_line_pointer
[-1];
5391 input_line_pointer
[-1] = '\0';
5392 listing_source_file (start
);
5393 input_line_pointer
[-1] = c
;
5399 input_line_pointer
++;
5400 c
= get_single_number ();
5401 stringer_append_char (c
, bitsize
);
5402 if (*input_line_pointer
!= '>')
5404 as_bad (_("expected <nn>"));
5405 ignore_rest_of_line ();
5408 input_line_pointer
++;
5411 input_line_pointer
++;
5415 c
= *input_line_pointer
;
5418 demand_empty_rest_of_line ();
5421 /* FIXME-SOMEDAY: I had trouble here on characters with the
5422 high bits set. We'll probably also have trouble with
5423 multibyte chars, wide chars, etc. Also be careful about
5424 returning values bigger than 1 byte. xoxorich. */
5427 next_char_of_string (void)
5431 c
= *input_line_pointer
++ & CHAR_MASK
;
5435 /* PR 20902: Do not advance past the end of the buffer. */
5436 -- input_line_pointer
;
5445 as_warn (_("unterminated string; newline inserted"));
5446 bump_line_counters ();
5450 if (!TC_STRING_ESCAPES
)
5452 switch (c
= *input_line_pointer
++ & CHAR_MASK
)
5480 break; /* As itself. */
5496 for (i
= 0, number
= 0;
5497 ISDIGIT (c
) && i
< 3;
5498 c
= *input_line_pointer
++, i
++)
5500 number
= number
* 8 + c
- '0';
5503 c
= number
& CHAR_MASK
;
5505 --input_line_pointer
;
5514 c
= *input_line_pointer
++;
5515 while (ISXDIGIT (c
))
5518 number
= number
* 16 + c
- '0';
5519 else if (ISUPPER (c
))
5520 number
= number
* 16 + c
- 'A' + 10;
5522 number
= number
* 16 + c
- 'a' + 10;
5523 c
= *input_line_pointer
++;
5525 c
= number
& CHAR_MASK
;
5526 --input_line_pointer
;
5531 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5532 as_warn (_("unterminated string; newline inserted"));
5534 bump_line_counters ();
5538 /* Do not advance past the end of the buffer. */
5539 -- input_line_pointer
;
5545 #ifdef ONLY_STANDARD_ESCAPES
5546 as_bad (_("bad escaped character in string"));
5548 #endif /* ONLY_STANDARD_ESCAPES */
5561 get_segmented_expression (expressionS
*expP
)
5565 retval
= expression (expP
);
5566 if (expP
->X_op
== O_illegal
5567 || expP
->X_op
== O_absent
5568 || expP
->X_op
== O_big
)
5570 as_bad (_("expected address expression"));
5571 expP
->X_op
= O_constant
;
5572 expP
->X_add_number
= 0;
5573 retval
= absolute_section
;
5579 get_known_segmented_expression (expressionS
*expP
)
5581 segT retval
= get_segmented_expression (expP
);
5583 if (retval
== undefined_section
)
5585 /* There is no easy way to extract the undefined symbol from the
5587 if (expP
->X_add_symbol
!= NULL
5588 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5589 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5590 S_GET_NAME (expP
->X_add_symbol
));
5592 as_warn (_("some symbol undefined; zero assumed"));
5593 retval
= absolute_section
;
5594 expP
->X_op
= O_constant
;
5595 expP
->X_add_number
= 0;
5600 char /* Return terminator. */
5601 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5603 /* FIXME: val_pointer should probably be offsetT *. */
5604 *val_pointer
= (long) get_absolute_expression ();
5605 return (*input_line_pointer
++);
5608 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5609 Give a warning if that happens. */
5612 demand_copy_C_string (int *len_pointer
)
5616 if ((s
= demand_copy_string (len_pointer
)) != 0)
5620 for (len
= *len_pointer
; len
> 0; len
--)
5627 as_bad (_("this string may not contain \'\\0\'"));
5635 /* Demand string, but return a safe (=private) copy of the string.
5636 Return NULL if we can't read a string here. */
5639 demand_copy_string (int *lenP
)
5647 if (*input_line_pointer
== '\"')
5649 input_line_pointer
++; /* Skip opening quote. */
5651 while (is_a_char (c
= next_char_of_string ()))
5653 obstack_1grow (¬es
, c
);
5656 /* JF this next line is so demand_copy_C_string will return a
5657 null terminated string. */
5658 obstack_1grow (¬es
, '\0');
5659 retval
= (char *) obstack_finish (¬es
);
5663 as_bad (_("missing string"));
5665 ignore_rest_of_line ();
5671 /* In: Input_line_pointer->next character.
5673 Do: Skip input_line_pointer over all whitespace.
5675 Out: 1 if input_line_pointer->end-of-line. */
5678 is_it_end_of_statement (void)
5681 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5685 equals (char *sym_name
, int reassign
)
5690 input_line_pointer
++;
5691 if (*input_line_pointer
== '=')
5692 input_line_pointer
++;
5693 if (reassign
< 0 && *input_line_pointer
== '=')
5694 input_line_pointer
++;
5696 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5697 input_line_pointer
++;
5700 stop
= mri_comment_field (&stopc
);
5702 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5706 demand_empty_rest_of_line ();
5707 mri_comment_end (stop
, stopc
);
5711 /* .incbin -- include a file verbatim at the current location. */
5714 s_incbin (int x ATTRIBUTE_UNUSED
)
5725 #ifdef md_flush_pending_output
5726 md_flush_pending_output ();
5729 #ifdef md_cons_align
5734 filename
= demand_copy_string (& len
);
5735 if (filename
== NULL
)
5740 /* Look for optional skip and count. */
5741 if (* input_line_pointer
== ',')
5743 ++ input_line_pointer
;
5744 skip
= get_absolute_expression ();
5748 if (* input_line_pointer
== ',')
5750 ++ input_line_pointer
;
5752 count
= get_absolute_expression ();
5754 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5760 demand_empty_rest_of_line ();
5762 /* Try opening absolute path first, then try include dirs. */
5763 binfile
= fopen (filename
, FOPEN_RB
);
5764 if (binfile
== NULL
)
5768 path
= XNEWVEC (char, (unsigned long) len
+ include_dir_maxlen
+ 5);
5770 for (i
= 0; i
< include_dir_count
; i
++)
5772 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5774 binfile
= fopen (path
, FOPEN_RB
);
5775 if (binfile
!= NULL
)
5779 if (binfile
== NULL
)
5780 as_bad (_("file not found: %s"), filename
);
5783 path
= xstrdup (filename
);
5789 register_dependency (path
);
5791 /* Compute the length of the file. */
5792 if (fseek (binfile
, 0, SEEK_END
) != 0)
5794 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5797 file_len
= ftell (binfile
);
5799 /* If a count was not specified use the remainder of the file. */
5801 count
= file_len
- skip
;
5803 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5805 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5806 skip
, count
, file_len
);
5810 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5812 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5816 /* Allocate frag space and store file contents in it. */
5817 binfrag
= frag_more (count
);
5819 bytes
= fread (binfrag
, 1, count
, binfile
);
5821 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5822 path
, bytes
, count
);
5825 if (binfile
!= NULL
)
5830 /* .include -- include a file at this point. */
5833 s_include (int arg ATTRIBUTE_UNUSED
)
5842 filename
= demand_copy_string (&i
);
5843 if (filename
== NULL
)
5845 /* demand_copy_string has already printed an error and
5846 called ignore_rest_of_line. */
5854 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5855 && *input_line_pointer
!= ' '
5856 && *input_line_pointer
!= '\t')
5858 obstack_1grow (¬es
, *input_line_pointer
);
5859 ++input_line_pointer
;
5863 obstack_1grow (¬es
, '\0');
5864 filename
= (char *) obstack_finish (¬es
);
5865 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5866 ++input_line_pointer
;
5869 demand_empty_rest_of_line ();
5870 path
= XNEWVEC (char, (unsigned long) i
5871 + include_dir_maxlen
+ 5 /* slop */ );
5873 for (i
= 0; i
< include_dir_count
; i
++)
5875 strcpy (path
, include_dirs
[i
]);
5877 strcat (path
, filename
);
5878 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5888 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5889 register_dependency (path
);
5890 input_scrub_insert_file (path
);
5894 add_include_dir (char *path
)
5898 if (include_dir_count
== 0)
5900 include_dirs
= XNEWVEC (const char *, 2);
5901 include_dirs
[0] = "."; /* Current dir. */
5902 include_dir_count
= 2;
5906 include_dir_count
++;
5907 include_dirs
= XRESIZEVEC (const char *, include_dirs
,
5911 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5914 if (i
> include_dir_maxlen
)
5915 include_dir_maxlen
= i
;
5918 /* Output debugging information to denote the source file. */
5921 generate_file_debug (void)
5923 if (debug_type
== DEBUG_STABS
)
5924 stabs_generate_asm_file ();
5927 /* Output line number debugging information for the current source line. */
5930 generate_lineno_debug (void)
5934 case DEBUG_UNSPECIFIED
:
5939 stabs_generate_asm_lineno ();
5942 ecoff_generate_asm_lineno ();
5945 /* ??? We could here indicate to dwarf2dbg.c that something
5946 has changed. However, since there is additional backend
5947 support that is required (calling dwarf2_emit_insn), we
5948 let dwarf2dbg.c call as_where on its own. */
5953 /* Output debugging information to mark a function entry point or end point.
5954 END_P is zero for .func, and non-zero for .endfunc. */
5959 do_s_func (end_p
, NULL
);
5962 /* Subroutine of s_func so targets can choose a different default prefix.
5963 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5966 do_s_func (int end_p
, const char *default_prefix
)
5968 /* Record the current function so that we can issue an error message for
5969 misplaced .func,.endfunc, and also so that .endfunc needs no
5971 static char *current_name
;
5972 static char *current_label
;
5976 if (current_name
== NULL
)
5978 as_bad (_("missing .func"));
5979 ignore_rest_of_line ();
5983 if (debug_type
== DEBUG_STABS
)
5984 stabs_generate_asm_endfunc (current_name
, current_label
);
5986 current_name
= current_label
= NULL
;
5991 char delim1
, delim2
;
5993 if (current_name
!= NULL
)
5995 as_bad (_(".endfunc missing for previous .func"));
5996 ignore_rest_of_line ();
6000 delim1
= get_symbol_name (& name
);
6001 name
= xstrdup (name
);
6002 *input_line_pointer
= delim1
;
6003 SKIP_WHITESPACE_AFTER_NAME ();
6004 if (*input_line_pointer
!= ',')
6008 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
6009 as_fatal ("%s", xstrerror (errno
));
6013 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
6014 /* Missing entry point, use function's name with the leading
6018 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
6019 as_fatal ("%s", xstrerror (errno
));
6027 ++input_line_pointer
;
6029 delim2
= get_symbol_name (& label
);
6030 label
= xstrdup (label
);
6031 restore_line_pointer (delim2
);
6034 if (debug_type
== DEBUG_STABS
)
6035 stabs_generate_asm_func (name
, label
);
6037 current_name
= name
;
6038 current_label
= label
;
6041 demand_empty_rest_of_line ();
6044 #ifdef HANDLE_BUNDLE
6047 s_bundle_align_mode (int arg ATTRIBUTE_UNUSED
)
6049 unsigned int align
= get_absolute_expression ();
6051 demand_empty_rest_of_line ();
6053 if (align
> (unsigned int) TC_ALIGN_LIMIT
)
6054 as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
6055 (unsigned int) TC_ALIGN_LIMIT
);
6057 if (bundle_lock_frag
!= NULL
)
6059 as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
6063 bundle_align_p2
= align
;
6067 s_bundle_lock (int arg ATTRIBUTE_UNUSED
)
6069 demand_empty_rest_of_line ();
6071 if (bundle_align_p2
== 0)
6073 as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
6077 if (bundle_lock_depth
== 0)
6079 bundle_lock_frchain
= frchain_now
;
6080 bundle_lock_frag
= start_bundle ();
6082 ++bundle_lock_depth
;
6086 s_bundle_unlock (int arg ATTRIBUTE_UNUSED
)
6090 demand_empty_rest_of_line ();
6092 if (bundle_lock_frag
== NULL
)
6094 as_bad (_(".bundle_unlock without preceding .bundle_lock"));
6098 gas_assert (bundle_align_p2
> 0);
6100 gas_assert (bundle_lock_depth
> 0);
6101 if (--bundle_lock_depth
> 0)
6104 size
= pending_bundle_size (bundle_lock_frag
);
6106 if (size
> 1U << bundle_align_p2
)
6107 as_bad (_(".bundle_lock sequence is %u bytes, "
6108 "but bundle size is only %u bytes"),
6109 size
, 1u << bundle_align_p2
);
6111 finish_bundle (bundle_lock_frag
, size
);
6113 bundle_lock_frag
= NULL
;
6114 bundle_lock_frchain
= NULL
;
6117 #endif /* HANDLE_BUNDLE */
6120 s_ignore (int arg ATTRIBUTE_UNUSED
)
6122 ignore_rest_of_line ();
6126 read_print_statistics (FILE *file
)
6128 hash_print_statistics (file
, "pseudo-op table", po_hash
);
6131 /* Inserts the given line into the input stream.
6133 This call avoids macro/conditionals nesting checking, since the contents of
6134 the line are assumed to replace the contents of a line already scanned.
6136 An appropriate use of this function would be substitution of input lines when
6137 called by md_start_line_hook(). The given line is assumed to already be
6138 properly scrubbed. */
6141 input_scrub_insert_line (const char *line
)
6144 size_t len
= strlen (line
);
6145 sb_build (&newline
, len
);
6146 sb_add_buffer (&newline
, line
, len
);
6147 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
6149 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6152 /* Insert a file into the input stream; the path must resolve to an actual
6153 file; no include path searching or dependency registering is performed. */
6156 input_scrub_insert_file (char *path
)
6158 input_scrub_include_file (path
, input_line_pointer
);
6159 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
6162 /* Find the end of a line, considering quotation and escaping of quotes. */
6164 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
6165 # define TC_SINGLE_QUOTE_STRINGS 1
6169 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
6172 char inquote
= '\0';
6175 while (!is_end_of_line
[(unsigned char) *s
]
6176 || (inquote
&& !ISCNTRL (*s
))
6177 || (inquote
== '\'' && flag_mri
)
6178 #ifdef TC_EOL_IN_INSN
6179 || (insn
&& TC_EOL_IN_INSN (s
))
6181 /* PR 6926: When we are parsing the body of a macro the sequence
6182 \@ is special - it refers to the invocation count. If the @
6183 character happens to be registered as a line-separator character
6184 by the target, then the is_end_of_line[] test above will have
6185 returned true, but we need to ignore the line separating
6186 semantics in this particular case. */
6187 || (in_macro
&& inescape
&& *s
== '@')
6190 if (mri_string
&& *s
== '\'')
6194 else if (*s
== '\\')
6198 #ifdef TC_SINGLE_QUOTE_STRINGS
6199 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
6206 as_warn (_("missing closing `%c'"), inquote
);
6207 if (inescape
&& !ignore_input ())
6208 as_warn (_("stray `\\'"));
6213 find_end_of_line (char *s
, int mri_string
)
6215 return _find_end_of_line (s
, mri_string
, 0, 0);
6218 static char *saved_ilp
= NULL
;
6219 static char *saved_limit
;
6221 /* Use BUF as a temporary input pointer for calling other functions in this
6222 file. BUF must be a C string, so that its end can be found by strlen.
6223 Also sets the buffer_limit variable (local to this file) so that buffer
6224 overruns should not occur. Saves the current input line pointer so that
6225 it can be restored by calling restore_ilp().
6227 Does not support recursion. */
6230 temp_ilp (char *buf
)
6232 gas_assert (saved_ilp
== NULL
);
6233 gas_assert (buf
!= NULL
);
6235 saved_ilp
= input_line_pointer
;
6236 saved_limit
= buffer_limit
;
6237 /* Prevent the assert in restore_ilp from triggering if
6238 the input_line_pointer has not yet been initialised. */
6239 if (saved_ilp
== NULL
)
6240 saved_limit
= saved_ilp
= (char *) "";
6242 input_line_pointer
= buf
;
6243 buffer_limit
= buf
+ strlen (buf
);
6244 input_from_string
= TRUE
;
6247 /* Restore a saved input line pointer. */
6252 gas_assert (saved_ilp
!= NULL
);
6254 input_line_pointer
= saved_ilp
;
6255 buffer_limit
= saved_limit
;
6256 input_from_string
= FALSE
;