1 /* read.c - read a source file -
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
24 But then, GNU isn't spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.) */
26 #define MASK_CHAR ((int)(unsigned char) -1)
28 /* This is the largest known floating point format (for now). It will
29 grow when we do 4361 style flonums. */
30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
32 /* Routines that read assembler source text to build spaghetti in memory.
33 Another group of these functions is in the expr.c module. */
36 #include "safe-ctype.h"
42 #include "dw2gencfi.h"
44 #ifndef TC_START_LABEL
45 #define TC_START_LABEL(x,y,z) (x == ':')
48 /* Set by the object-format or the target. */
49 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
50 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
55 else if ((SIZE) >= 4) \
57 else if ((SIZE) >= 2) \
65 char *input_line_pointer
; /*->next char of source file to parse. */
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
94 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
103 /* The Delta 68k assembler permits ~ at start of label names. */
107 /* Used by is_... macros. our ctype[]. */
108 char lex_type
[256] = {
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
111 0, 0, 0, LEX_HASH
, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
113 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
114 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
115 0, 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
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
128 Out: 1 if this character ends a line.
129 2 if this character is a line separator. */
130 char is_end_of_line
[256] = {
132 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string
[128];
157 /* Functions private to this file. */
159 static char *buffer
; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit
; /*->1 + last char in buffer. */
162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
163 in the tc-<CPU>.h file. See the "Porting GAS" section of the
165 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
167 /* Variables for handling include file directory table. */
169 /* Table of pointers to directories to search for .include's. */
172 /* How many are in the table. */
173 int include_dir_count
;
175 /* Length of longest in table. */
176 int include_dir_maxlen
= 1;
178 #ifndef WORKING_DOT_WORD
179 struct broken_word
*broken_words
;
180 int new_broken_words
;
183 /* The current offset into the absolute section. We don't try to
184 build frags in the absolute section, since no data can be stored
185 there. We just keep track of the current offset. */
186 addressT abs_section_offset
;
188 /* If this line had an MRI style label, it is stored in this variable.
189 This is used by some of the MRI pseudo-ops. */
192 /* This global variable is used to support MRI common sections. We
193 translate such sections into a common symbol. This variable is
194 non-NULL when we are in an MRI common section. */
195 symbolS
*mri_common_symbol
;
197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
198 need to align to an even byte boundary unless the next pseudo-op is
199 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
201 static int mri_pending_align
;
205 /* This variable is set to be non-zero if the next string we see might
206 be the name of the source file in DWARF debugging information. See
207 the comment in emit_expr for the format we look for. */
208 static int dwarf_file_string
;
212 static void do_s_func (int end_p
, const char *default_prefix
);
213 static void do_align (int, char *, int, int);
214 static void s_align (int, int);
215 static void s_altmacro (int);
216 static void s_bad_end (int);
218 static void s_gnu_attribute (int);
220 static void s_reloc (int);
221 static int hex_float (int, char *);
222 static segT
get_known_segmented_expression (expressionS
* expP
);
223 static void pobegin (void);
224 static int get_non_macro_line_sb (sb
*);
225 static void generate_file_debug (void);
226 static char *_find_end_of_line (char *, int, int, int);
234 obj_read_begin_hook ();
236 /* Something close -- but not too close -- to a multiple of 1024.
237 The debugging malloc I'm using has 24 bytes of overhead. */
238 obstack_begin (¬es
, chunksize
);
239 obstack_begin (&cond_obstack
, chunksize
);
241 /* Use machine dependent syntax. */
242 for (p
= line_separator_chars
; *p
; p
++)
243 is_end_of_line
[(unsigned char) *p
] = 2;
244 /* Use more. FIXME-SOMEDAY. */
250 #ifndef TC_ADDRESS_BYTES
251 #define TC_ADDRESS_BYTES address_bytes
256 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
257 contain an address. */
258 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
266 /* Set up pseudo-op tables. */
268 static struct hash_control
*po_hash
;
270 static const pseudo_typeS potable
[] = {
271 {"abort", s_abort
, 0},
272 {"align", s_align_ptwo
, 0},
273 {"altmacro", s_altmacro
, 1},
274 {"ascii", stringer
, 8+0},
275 {"asciz", stringer
, 8+1},
276 {"balign", s_align_bytes
, 0},
277 {"balignw", s_align_bytes
, -2},
278 {"balignl", s_align_bytes
, -4},
282 {"common", s_mri_common
, 0},
283 {"common.s", s_mri_common
, 1},
286 #ifdef TC_ADDRESS_BYTES
290 {"dc.d", float_cons
, 'd'},
292 {"dc.s", float_cons
, 'f'},
294 {"dc.x", float_cons
, 'x'},
296 {"dcb.b", s_space
, 1},
297 {"dcb.d", s_float_space
, 'd'},
298 {"dcb.l", s_space
, 4},
299 {"dcb.s", s_float_space
, 'f'},
300 {"dcb.w", s_space
, 2},
301 {"dcb.x", s_float_space
, 'x'},
303 {"ds.b", s_space
, 1},
304 {"ds.d", s_space
, 8},
305 {"ds.l", s_space
, 4},
306 {"ds.p", s_space
, 12},
307 {"ds.s", s_space
, 4},
308 {"ds.w", s_space
, 2},
309 {"ds.x", s_space
, 12},
310 {"debug", s_ignore
, 0},
315 {"double", float_cons
, 'd'},
317 {"eject", listing_eject
, 0}, /* Formfeed listing. */
319 {"elsec", s_else
, 0},
320 {"elseif", s_elseif
, (int) O_ne
},
322 {"endc", s_endif
, 0},
323 {"endfunc", s_func
, 1},
324 {"endif", s_endif
, 0},
325 {"endm", s_bad_end
, 0},
326 {"endr", s_bad_end
, 1},
332 {"error", s_errwarn
, 1},
333 {"exitm", s_mexit
, 0},
335 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
336 {"appfile", s_app_file
, 1},
337 {"appline", s_app_line
, 1},
339 {"file", s_app_file
, 0},
341 {"float", float_cons
, 'f'},
342 {"format", s_ignore
, 0},
344 {"global", s_globl
, 0},
345 {"globl", s_globl
, 0},
347 {"gnu_attribute", s_gnu_attribute
, 0},
350 {"if", s_if
, (int) O_ne
},
353 {"ifdef", s_ifdef
, 0},
354 {"ifeq", s_if
, (int) O_eq
},
355 {"ifeqs", s_ifeqs
, 0},
356 {"ifge", s_if
, (int) O_ge
},
357 {"ifgt", s_if
, (int) O_gt
},
358 {"ifle", s_if
, (int) O_le
},
359 {"iflt", s_if
, (int) O_lt
},
362 {"ifndef", s_ifdef
, 1},
363 {"ifne", s_if
, (int) O_ne
},
364 {"ifnes", s_ifeqs
, 1},
365 {"ifnotdef", s_ifdef
, 1},
366 {"incbin", s_incbin
, 0},
367 {"include", s_include
, 0},
373 {"lcomm", s_lcomm
, 0},
374 {"lflags", s_ignore
, 0}, /* Listing flags. */
375 {"linefile", s_app_line
, 0},
376 {"linkonce", s_linkonce
, 0},
377 {"list", listing_list
, 1}, /* Turn listing on. */
378 {"llen", listing_psize
, 1},
381 {"macro", s_macro
, 0},
382 {"mexit", s_mexit
, 0},
384 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
385 {"name", s_ignore
, 0},
386 {"noaltmacro", s_altmacro
, 0},
387 {"noformat", s_ignore
, 0},
388 {"nolist", listing_list
, 0}, /* Turn listing off. */
389 {"nopage", listing_nopage
, 0},
391 {"offset", s_struct
, 0},
393 {"p2align", s_align_ptwo
, 0},
394 {"p2alignw", s_align_ptwo
, -2},
395 {"p2alignl", s_align_ptwo
, -4},
396 {"page", listing_eject
, 0},
397 {"plen", listing_psize
, 0},
398 {"print", s_print
, 0},
399 {"psize", listing_psize
, 0}, /* Set paper size. */
400 {"purgem", s_purgem
, 0},
402 {"reloc", s_reloc
, 0},
406 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
411 {"single", float_cons
, 'f'},
413 {"space", s_space
, 0},
414 {"skip", s_space
, 0},
415 {"sleb128", s_leb128
, 1},
416 {"spc", s_ignore
, 0},
417 {"stabd", s_stab
, 'd'},
418 {"stabn", s_stab
, 'n'},
419 {"stabs", s_stab
, 's'},
420 {"string", stringer
, 8+1},
421 {"string8", stringer
, 8+1},
422 {"string16", stringer
, 16+1},
423 {"string32", stringer
, 32+1},
424 {"string64", stringer
, 64+1},
425 {"struct", s_struct
, 0},
429 /* This is for gcc to use. It's only just been added (2/94), so gcc
430 won't be able to use it for a while -- probably a year or more.
431 But once this has been released, check with gcc maintainers
432 before deleting it or even changing the spelling. */
433 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
434 /* If we're folding case -- done for some targets, not necessarily
435 all -- the above string in an input file will be converted to
436 this one. Match it either way... */
437 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
439 {"title", listing_title
, 0}, /* Listing title. */
440 {"ttl", listing_title
, 0},
442 {"uleb128", s_leb128
, 0},
446 {"xdef", s_globl
, 0},
447 {"xref", s_ignore
, 0},
448 {"xstabs", s_xstab
, 's'},
449 {"warning", s_errwarn
, 0},
450 {"weakref", s_weakref
, 0},
452 {"zero", s_space
, 0},
453 {NULL
, NULL
, 0} /* End sentinel. */
457 get_absolute_expr (expressionS
*exp
)
459 expression_and_evaluate (exp
);
460 if (exp
->X_op
!= O_constant
)
462 if (exp
->X_op
!= O_absent
)
463 as_bad (_("bad or irreducible absolute expression"));
464 exp
->X_add_number
= 0;
466 return exp
->X_add_number
;
470 get_absolute_expression (void)
474 return get_absolute_expr (&exp
);
477 static int pop_override_ok
= 0;
478 static const char *pop_table_name
;
481 pop_insert (const pseudo_typeS
*table
)
484 const pseudo_typeS
*pop
;
485 for (pop
= table
; pop
->poc_name
; pop
++)
487 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
488 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
489 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
494 #ifndef md_pop_insert
495 #define md_pop_insert() pop_insert(md_pseudo_table)
498 #ifndef obj_pop_insert
499 #define obj_pop_insert() pop_insert(obj_pseudo_table)
502 #ifndef cfi_pop_insert
503 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
509 po_hash
= hash_new ();
511 /* Do the target-specific pseudo ops. */
512 pop_table_name
= "md";
515 /* Now object specific. Skip any that were in the target table. */
516 pop_table_name
= "obj";
520 /* Now portable ones. Skip any that we've seen already. */
521 pop_table_name
= "standard";
522 pop_insert (potable
);
525 pop_table_name
= "cfi";
530 #define HANDLE_CONDITIONAL_ASSEMBLY() \
531 if (ignore_input ()) \
533 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
534 input_line_pointer = (input_line_pointer <= buffer_limit \
535 && eol >= buffer_limit) \
541 /* This function is used when scrubbing the characters between #APP
544 static char *scrub_string
;
545 static char *scrub_string_end
;
548 scrub_from_string (char *buf
, int buflen
)
552 copy
= scrub_string_end
- scrub_string
;
555 memcpy (buf
, scrub_string
, copy
);
556 scrub_string
+= copy
;
560 /* Helper function of read_a_source_file, which tries to expand a macro. */
562 try_macro (char term
, const char *line
)
568 if (check_macro (line
, &out
, &err
, ¯o
))
572 *input_line_pointer
++ = term
;
573 input_scrub_include_sb (&out
,
574 input_line_pointer
, 1);
577 input_scrub_next_buffer (&input_line_pointer
);
579 md_macro_info (macro
);
586 /* We read the file, putting things into a web that represents what we
587 have been reading. */
589 read_a_source_file (char *name
)
592 char *s
; /* String of symbol, '\0' appended. */
600 buffer
= input_scrub_new_file (name
);
603 listing_newline (NULL
);
604 register_dependency (name
);
606 /* Generate debugging information before we've read anything in to denote
607 this file as the "main" source file and not a subordinate one
608 (e.g. N_SO vs N_SOL in stabs). */
609 generate_file_debug ();
611 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
612 { /* We have another line to parse. */
614 /* In order to avoid listing macro expansion lines with labels
615 multiple times, keep track of which line was last issued. */
616 static char *last_eol
;
620 while (input_line_pointer
< buffer_limit
)
622 bfd_boolean was_new_line
;
623 /* We have more of this buffer to parse. */
625 /* We now have input_line_pointer->1st char of next line.
626 If input_line_pointer [-1] == '\n' then we just
627 scanned another line: so bump line counters. */
628 was_new_line
= is_end_of_line
[(unsigned char) input_line_pointer
[-1]];
631 symbol_set_value_now (&dot_symbol
);
632 #ifdef md_start_line_hook
633 md_start_line_hook ();
635 if (input_line_pointer
[-1] == '\n')
636 bump_line_counters ();
640 /* If listing is on, and we are expanding a macro, then give
641 the listing code the contents of the expanded line. */
644 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
646 /* Find the end of the current expanded macro line. */
647 s
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
655 /* Copy it for safe keeping. Also give an indication of
656 how much macro nesting is involved at this point. */
657 len
= s
- input_line_pointer
;
658 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
659 memset (copy
, '>', macro_nest
);
660 copy
[macro_nest
] = ' ';
661 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
, len
);
662 copy
[macro_nest
+ 1 + len
] = '\0';
664 /* Install the line with the listing facility. */
665 listing_newline (copy
);
669 listing_newline (NULL
);
676 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
678 /* Text at the start of a line must be a label, we
679 run down and stick a colon in. */
680 if (is_name_beginner (*input_line_pointer
))
682 char *line_start
= input_line_pointer
;
685 HANDLE_CONDITIONAL_ASSEMBLY ();
687 c
= get_symbol_end ();
689 /* In MRI mode, the EQU and MACRO pseudoops must
690 be handled specially. */
694 char *rest
= input_line_pointer
+ 1;
698 if (*rest
== ' ' || *rest
== '\t')
700 if ((strncasecmp (rest
, "EQU", 3) == 0
701 || strncasecmp (rest
, "SET", 3) == 0)
702 && (rest
[3] == ' ' || rest
[3] == '\t'))
704 input_line_pointer
= rest
+ 3;
706 strncasecmp (rest
, "SET", 3) == 0);
709 if (strncasecmp (rest
, "MACRO", 5) == 0
712 || is_end_of_line
[(unsigned char) rest
[5]]))
716 /* In MRI mode, we need to handle the MACRO
717 pseudo-op specially: we don't want to put the
718 symbol in the symbol table. */
720 #ifdef TC_START_LABEL_WITHOUT_COLON
721 && TC_START_LABEL_WITHOUT_COLON(c
,
725 line_label
= colon (line_start
);
727 line_label
= symbol_create (line_start
,
732 *input_line_pointer
= c
;
734 input_line_pointer
++;
739 /* We are at the beginning of a line, or similar place.
740 We expect a well-formed assembler statement.
741 A "symbol-name:" is a statement.
743 Depending on what compiler is used, the order of these tests
744 may vary to catch most common case 1st.
745 Each test is independent of all other tests at the (top)
748 c
= *input_line_pointer
++;
749 while (c
== '\t' || c
== ' ' || c
== '\f');
751 /* C is the 1st significant character.
752 Input_line_pointer points after that character. */
753 if (is_name_beginner (c
))
755 /* Want user-defined label or pseudo/opcode. */
756 HANDLE_CONDITIONAL_ASSEMBLY ();
758 s
= --input_line_pointer
;
759 c
= get_symbol_end (); /* name's delimiter. */
761 /* C is character after symbol.
762 That character's place in the input line is now '\0'.
763 S points to the beginning of the symbol.
764 [In case of pseudo-op, s->'.'.]
765 Input_line_pointer->'\0' where c was. */
766 if (TC_START_LABEL (c
, s
, input_line_pointer
))
770 char *rest
= input_line_pointer
+ 1;
772 /* In MRI mode, \tsym: set 0 is permitted. */
776 if (*rest
== ' ' || *rest
== '\t')
779 if ((strncasecmp (rest
, "EQU", 3) == 0
780 || strncasecmp (rest
, "SET", 3) == 0)
781 && (rest
[3] == ' ' || rest
[3] == '\t'))
783 input_line_pointer
= rest
+ 3;
789 line_label
= colon (s
); /* User-defined label. */
790 /* Put ':' back for error messages' sake. */
791 *input_line_pointer
++ = ':';
792 #ifdef tc_check_label
793 tc_check_label (line_label
);
795 /* Input_line_pointer->after ':'. */
798 else if ((c
== '=' && input_line_pointer
[1] == '=')
799 || ((c
== ' ' || c
== '\t')
800 && input_line_pointer
[1] == '='
801 && input_line_pointer
[2] == '='))
804 demand_empty_rest_of_line ();
807 || ((c
== ' ' || c
== '\t')
808 && input_line_pointer
[1] == '='))
809 #ifdef TC_EQUAL_IN_INSN
810 && !TC_EQUAL_IN_INSN (c
, s
)
815 demand_empty_rest_of_line ();
819 /* Expect pseudo-op or machine instruction. */
822 #ifndef TC_CASE_SENSITIVE
826 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
827 original_case_string
[sizeof (original_case_string
) - 1] = 0;
836 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
838 /* The MRI assembler uses pseudo-ops without
840 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
841 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
846 || (!flag_m68k_mri
&& *s
== '.'))
850 WARNING: c has next char, which may be end-of-line.
851 We lookup the pseudo-op table with s+1 because we
852 already know that the pseudo-op begins with a '.'. */
855 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
856 if (pop
&& !pop
->poc_handler
)
859 /* In MRI mode, we may need to insert an
860 automatic alignment directive. What a hack
862 if (mri_pending_align
864 || !((pop
->poc_handler
== cons
865 && pop
->poc_val
== 1)
866 || (pop
->poc_handler
== s_space
867 && pop
->poc_val
== 1)
868 #ifdef tc_conditional_pseudoop
869 || tc_conditional_pseudoop (pop
)
871 || pop
->poc_handler
== s_if
872 || pop
->poc_handler
== s_ifdef
873 || pop
->poc_handler
== s_ifc
874 || pop
->poc_handler
== s_ifeqs
875 || pop
->poc_handler
== s_else
876 || pop
->poc_handler
== s_endif
877 || pop
->poc_handler
== s_globl
878 || pop
->poc_handler
== s_ignore
)))
880 do_align (1, (char *) NULL
, 0, 0);
881 mri_pending_align
= 0;
883 if (line_label
!= NULL
)
885 symbol_set_frag (line_label
, frag_now
);
886 S_SET_VALUE (line_label
, frag_now_fix ());
890 /* Print the error msg now, while we still can. */
893 char *end
= input_line_pointer
;
895 *input_line_pointer
= c
;
897 c
= *--input_line_pointer
;
898 *input_line_pointer
= '\0';
899 if (! macro_defined
|| ! try_macro (c
, s
))
902 as_bad (_("unknown pseudo-op: `%s'"), s
);
903 *input_line_pointer
++ = c
;
908 /* Put it back for error messages etc. */
909 *input_line_pointer
= c
;
910 /* The following skip of whitespace is compulsory.
911 A well shaped space is sometimes all that separates
912 keyword from operands. */
913 if (c
== ' ' || c
== '\t')
914 input_line_pointer
++;
916 /* Input_line is restored.
917 Input_line_pointer->1st non-blank char
918 after pseudo-operation. */
919 (*pop
->poc_handler
) (pop
->poc_val
);
921 /* If that was .end, just get out now. */
922 if (pop
->poc_handler
== s_end
)
927 /* WARNING: c has char, which may be end-of-line. */
928 /* Also: input_line_pointer->`\0` where c was. */
929 *input_line_pointer
= c
;
930 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
931 c
= *input_line_pointer
;
932 *input_line_pointer
= '\0';
934 generate_lineno_debug ();
936 if (macro_defined
&& try_macro (c
, s
))
939 if (mri_pending_align
)
941 do_align (1, (char *) NULL
, 0, 0);
942 mri_pending_align
= 0;
943 if (line_label
!= NULL
)
945 symbol_set_frag (line_label
, frag_now
);
946 S_SET_VALUE (line_label
, frag_now_fix ());
950 md_assemble (s
); /* Assemble 1 instruction. */
952 *input_line_pointer
++ = c
;
954 /* We resume loop AFTER the end-of-line from
961 /* Empty statement? */
962 if (is_end_of_line
[(unsigned char) c
])
965 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (c
))
967 /* local label ("4:") */
968 char *backup
= input_line_pointer
;
970 HANDLE_CONDITIONAL_ASSEMBLY ();
974 /* Read the whole number. */
975 while (ISDIGIT (*input_line_pointer
))
977 temp
= (temp
* 10) + *input_line_pointer
- '0';
978 ++input_line_pointer
;
981 if (LOCAL_LABELS_DOLLAR
982 && *input_line_pointer
== '$'
983 && *(input_line_pointer
+ 1) == ':')
985 input_line_pointer
+= 2;
987 if (dollar_label_defined (temp
))
989 as_fatal (_("label \"%d$\" redefined"), temp
);
992 define_dollar_label (temp
);
993 colon (dollar_label_name (temp
, 0));
998 && *input_line_pointer
++ == ':')
1000 fb_label_instance_inc (temp
);
1001 colon (fb_label_name (temp
, 0));
1005 input_line_pointer
= backup
;
1006 } /* local label ("4:") */
1008 if (c
&& strchr (line_comment_chars
, c
))
1009 { /* Its a comment. Better say APP or NO_APP. */
1014 unsigned int new_length
;
1017 s
= input_line_pointer
;
1018 if (strncmp (s
, "APP\n", 4))
1021 ignore_rest_of_line ();
1024 bump_line_counters ();
1028 ends
= strstr (s
, "#NO_APP\n");
1032 unsigned int tmp_len
;
1035 /* The end of the #APP wasn't in this buffer. We
1036 keep reading in buffers until we find the #NO_APP
1037 that goes with this #APP There is one. The specs
1039 tmp_len
= buffer_limit
- s
;
1040 tmp_buf
= (char *) xmalloc (tmp_len
+ 1);
1041 memcpy (tmp_buf
, s
, tmp_len
);
1044 new_tmp
= input_scrub_next_buffer (&buffer
);
1048 buffer_limit
= new_tmp
;
1049 input_line_pointer
= buffer
;
1050 ends
= strstr (buffer
, "#NO_APP\n");
1052 num
= ends
- buffer
;
1054 num
= buffer_limit
- buffer
;
1056 tmp_buf
= (char *) xrealloc (tmp_buf
, tmp_len
+ num
);
1057 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1062 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1070 input_line_pointer
= ends
+ 8;
1074 scrub_string_end
= ends
;
1076 new_length
= ends
- s
;
1077 new_buf
= (char *) xmalloc (new_length
);
1084 space
= (new_buf
+ new_length
) - new_tmp
;
1085 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1093 new_buf
= (char *) xrealloc (new_buf
, new_length
+ 100);
1094 new_tmp
= new_buf
+ new_length
;
1101 /* We've "scrubbed" input to the preferred format. In the
1102 process we may have consumed the whole of the remaining
1103 file (and included files). We handle this formatted
1104 input similar to that of macro expansion, letting
1105 actual macro expansion (possibly nested) and other
1106 input expansion work. Beware that in messages, line
1107 numbers and possibly file names will be incorrect. */
1108 sb_add_string (&sbuf
, new_buf
);
1109 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1111 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1116 HANDLE_CONDITIONAL_ASSEMBLY ();
1118 #ifdef tc_unrecognized_line
1119 if (tc_unrecognized_line (c
))
1122 input_line_pointer
--;
1123 /* Report unknown char as error. */
1124 demand_empty_rest_of_line ();
1129 symbol_set_value_now (&dot_symbol
);
1134 /* Close the input file. */
1135 input_scrub_close ();
1136 #ifdef WARN_COMMENTS
1138 if (warn_comment
&& found_comment
)
1139 as_warn_where (found_comment_file
, found_comment
,
1140 "first comment found here");
1145 /* Convert O_constant expression EXP into the equivalent O_big representation.
1146 Take the sign of the number from X_unsigned rather than X_add_number. */
1149 convert_to_bignum (expressionS
*exp
)
1154 value
= exp
->X_add_number
;
1155 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1157 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1158 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1160 /* Add a sequence of sign bits if the top bit of X_add_number is not
1161 the sign of the original value. */
1162 if ((exp
->X_add_number
< 0) != !exp
->X_unsigned
)
1163 generic_bignum
[i
++] = exp
->X_unsigned
? 0 : LITTLENUM_MASK
;
1165 exp
->X_add_number
= i
;
1168 /* For most MRI pseudo-ops, the line actually ends at the first
1169 nonquoted space. This function looks for that point, stuffs a null
1170 in, and sets *STOPCP to the character that used to be there, and
1171 returns the location.
1173 Until I hear otherwise, I am going to assume that this is only true
1174 for the m68k MRI assembler. */
1177 mri_comment_field (char *stopcp
)
1183 know (flag_m68k_mri
);
1185 for (s
= input_line_pointer
;
1186 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1194 for (s
= input_line_pointer
;
1195 !is_end_of_line
[(unsigned char) *s
];
1205 /* Skip to the end of an MRI comment field. */
1208 mri_comment_end (char *stop
, int stopc
)
1212 input_line_pointer
= stop
;
1214 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1215 ++input_line_pointer
;
1219 s_abort (int ignore ATTRIBUTE_UNUSED
)
1221 as_fatal (_(".abort detected. Abandoning ship."));
1224 /* Guts of .align directive. N is the power of two to which to align.
1225 FILL may be NULL, or it may point to the bytes of the fill pattern.
1226 LEN is the length of whatever FILL points to, if anything. MAX is
1227 the maximum number of characters to skip when doing the alignment,
1228 or 0 if there is no maximum. */
1231 do_align (int n
, char *fill
, int len
, int max
)
1233 if (now_seg
== absolute_section
)
1237 if (*fill
++ != '\0')
1239 as_warn (_("ignoring fill value in absolute section"));
1246 #ifdef md_flush_pending_output
1247 md_flush_pending_output ();
1250 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1253 /* Only make a frag if we HAVE to... */
1254 if (n
!= 0 && !need_pass_2
)
1258 if (subseg_text_p (now_seg
))
1259 frag_align_code (n
, max
);
1261 frag_align (n
, 0, max
);
1264 frag_align (n
, *fill
, max
);
1266 frag_align_pattern (n
, fill
, len
, max
);
1270 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
1273 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
1276 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1277 (in bytes). A negative ARG is the negative of the length of the
1278 fill pattern. BYTES_P is non-zero if the alignment value should be
1279 interpreted as the byte boundary, rather than the power of 2. */
1280 #ifndef TC_ALIGN_LIMIT
1281 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1285 s_align (int arg
, int bytes_p
)
1287 unsigned int align_limit
= TC_ALIGN_LIMIT
;
1296 stop
= mri_comment_field (&stopc
);
1298 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1303 align
= arg
; /* Default value from pseudo-op table. */
1307 align
= get_absolute_expression ();
1313 /* Convert to a power of 2. */
1318 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1321 as_bad (_("alignment not a power of 2"));
1327 if (align
> align_limit
)
1329 align
= align_limit
;
1330 as_warn (_("alignment too large: %u assumed"), align
);
1333 if (*input_line_pointer
!= ',')
1340 ++input_line_pointer
;
1341 if (*input_line_pointer
== ',')
1345 fill
= get_absolute_expression ();
1350 if (*input_line_pointer
!= ',')
1354 ++input_line_pointer
;
1355 max
= get_absolute_expression ();
1362 as_warn (_("expected fill pattern missing"));
1363 do_align (align
, (char *) NULL
, 0, max
);
1378 do_align (align
, &fill_char
, fill_len
, max
);
1384 if ((size_t) fill_len
> sizeof ab
)
1386 md_number_to_chars (ab
, fill
, fill_len
);
1387 do_align (align
, ab
, fill_len
, max
);
1391 demand_empty_rest_of_line ();
1394 mri_comment_end (stop
, stopc
);
1397 /* Handle the .align pseudo-op on machines where ".align 4" means
1398 align to a 4 byte boundary. */
1401 s_align_bytes (int arg
)
1406 /* Handle the .align pseudo-op on machines where ".align 4" means align
1407 to a 2**4 boundary. */
1410 s_align_ptwo (int arg
)
1415 /* Switch in and out of alternate macro mode. */
1420 demand_empty_rest_of_line ();
1421 macro_set_alternate (on
);
1425 s_comm_internal (int param
,
1426 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1432 symbolS
*symbolP
= NULL
;
1438 stop
= mri_comment_field (&stopc
);
1440 name
= input_line_pointer
;
1441 c
= get_symbol_end ();
1442 /* Just after name is now '\0'. */
1443 p
= input_line_pointer
;
1448 as_bad (_("expected symbol name"));
1449 ignore_rest_of_line ();
1455 /* Accept an optional comma after the name. The comma used to be
1456 required, but Irix 5 cc does not generate it for .lcomm. */
1457 if (*input_line_pointer
== ',')
1458 input_line_pointer
++;
1460 temp
= get_absolute_expr (&exp
);
1462 size
&= ((offsetT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1463 if (exp
.X_op
== O_absent
)
1465 as_bad (_("missing size expression"));
1466 ignore_rest_of_line ();
1469 else if (temp
!= size
|| !exp
.X_unsigned
)
1471 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1472 ignore_rest_of_line ();
1477 symbolP
= symbol_find_or_make (name
);
1478 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1479 && !S_IS_COMMON (symbolP
))
1481 if (!S_IS_VOLATILE (symbolP
))
1484 as_bad (_("symbol `%s' is already defined"), name
);
1486 ignore_rest_of_line ();
1489 symbolP
= symbol_clone (symbolP
, 1);
1490 S_SET_SEGMENT (symbolP
, undefined_section
);
1491 S_SET_VALUE (symbolP
, 0);
1492 symbol_set_frag (symbolP
, &zero_address_frag
);
1493 S_CLEAR_VOLATILE (symbolP
);
1496 size
= S_GET_VALUE (symbolP
);
1499 else if (size
!= temp
)
1500 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1501 name
, (long) size
, (long) temp
);
1504 if (comm_parse_extra
!= NULL
)
1505 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1508 S_SET_VALUE (symbolP
, (valueT
) size
);
1509 S_SET_EXTERNAL (symbolP
);
1510 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1513 extern int flag_one
;
1514 if (size
== 0 || !flag_one
)
1515 S_GET_OTHER (symbolP
) = const_flag
;
1520 demand_empty_rest_of_line ();
1523 mri_comment_end (stop
, stopc
);
1530 s_comm_internal (ignore
, NULL
);
1533 /* The MRI COMMON pseudo-op. We handle this by creating a common
1534 symbol with the appropriate name. We make s_space do the right
1535 thing by increasing the size. */
1538 s_mri_common (int small ATTRIBUTE_UNUSED
)
1554 stop
= mri_comment_field (&stopc
);
1558 name
= input_line_pointer
;
1559 if (!ISDIGIT (*name
))
1560 c
= get_symbol_end ();
1565 ++input_line_pointer
;
1567 while (ISDIGIT (*input_line_pointer
));
1569 c
= *input_line_pointer
;
1570 *input_line_pointer
= '\0';
1572 if (line_label
!= NULL
)
1574 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1575 + (input_line_pointer
- name
)
1577 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1582 sym
= symbol_find_or_make (name
);
1583 *input_line_pointer
= c
;
1587 if (*input_line_pointer
!= ',')
1591 ++input_line_pointer
;
1592 align
= get_absolute_expression ();
1595 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1597 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1598 ignore_rest_of_line ();
1599 mri_comment_end (stop
, stopc
);
1603 S_SET_EXTERNAL (sym
);
1604 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1605 mri_common_symbol
= sym
;
1609 S_SET_ALIGN (sym
, align
);
1614 if (line_label
!= NULL
)
1617 exp
.X_op
= O_symbol
;
1618 exp
.X_add_symbol
= sym
;
1619 exp
.X_add_number
= 0;
1620 symbol_set_value_expression (line_label
, &exp
);
1621 symbol_set_frag (line_label
, &zero_address_frag
);
1622 S_SET_SEGMENT (line_label
, expr_section
);
1625 /* FIXME: We just ignore the small argument, which distinguishes
1626 COMMON and COMMON.S. I don't know what we can do about it. */
1628 /* Ignore the type and hptype. */
1629 if (*input_line_pointer
== ',')
1630 input_line_pointer
+= 2;
1631 if (*input_line_pointer
== ',')
1632 input_line_pointer
+= 2;
1634 demand_empty_rest_of_line ();
1636 mri_comment_end (stop
, stopc
);
1640 s_data (int ignore ATTRIBUTE_UNUSED
)
1645 temp
= get_absolute_expression ();
1646 if (flag_readonly_data_in_text
)
1648 section
= text_section
;
1652 section
= data_section
;
1654 subseg_set (section
, (subsegT
) temp
);
1659 demand_empty_rest_of_line ();
1662 /* Handle the .appfile pseudo-op. This is automatically generated by
1663 do_scrub_chars when a preprocessor # line comment is seen with a
1664 file name. This default definition may be overridden by the object
1665 or CPU specific pseudo-ops. This function is also the default
1666 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1670 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1674 listing_source_file (file
);
1676 register_dependency (file
);
1678 obj_app_file (file
, appfile
);
1683 s_app_file (int appfile
)
1688 /* Some assemblers tolerate immediately following '"'. */
1689 if ((s
= demand_copy_string (&length
)) != 0)
1692 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1694 /* In MRI mode, the preprocessor may have inserted an extraneous
1697 && *input_line_pointer
== '\''
1698 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1699 ++input_line_pointer
;
1701 demand_empty_rest_of_line ();
1703 s_app_file_string (s
, appfile
);
1708 get_linefile_number (int *flag
)
1712 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1715 *flag
= get_absolute_expression ();
1720 /* Handle the .appline pseudo-op. This is automatically generated by
1721 do_scrub_chars when a preprocessor # line comment is seen. This
1722 default definition may be overridden by the object or CPU specific
1726 s_app_line (int appline
)
1731 /* The given number is that of the next line. */
1733 l
= get_absolute_expression ();
1734 else if (!get_linefile_number (&l
))
1736 ignore_rest_of_line ();
1743 /* Some of the back ends can't deal with non-positive line numbers.
1744 Besides, it's silly. GCC however will generate a line number of
1745 zero when it is pre-processing builtins for assembler-with-cpp files:
1749 We do not want to barf on this, especially since such files are used
1750 in the GCC and GDB testsuites. So we check for negative line numbers
1751 rather than non-positive line numbers. */
1752 as_warn (_("line numbers must be positive; line number %d rejected"),
1763 if (*input_line_pointer
== '"')
1764 file
= demand_copy_string (&length
);
1770 while (get_linefile_number (&this_flag
))
1773 /* From GCC's cpp documentation:
1774 1: start of a new file.
1775 2: returning to a file after having included
1777 3: following text comes from a system header file.
1778 4: following text should be treated as extern "C".
1780 4 is nonsensical for the assembler; 3, we don't
1781 care about, so we ignore it just in case a
1782 system header file is included while
1783 preprocessing assembly. So 1 and 2 are all we
1784 care about, and they are mutually incompatible.
1785 new_logical_line_flags() demands this. */
1788 if (flags
&& flags
!= (1 << this_flag
))
1789 as_warn (_("incompatible flag %i in line directive"),
1792 flags
|= 1 << this_flag
;
1797 /* We ignore these. */
1801 as_warn (_("unsupported flag %i in line directive"),
1806 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
1811 if (appline
|| file
)
1813 new_logical_line_flags (file
, l
, flags
);
1816 listing_source_line (l
);
1820 if (appline
|| file
)
1821 demand_empty_rest_of_line ();
1823 ignore_rest_of_line ();
1826 /* Handle the .end pseudo-op. Actually, the real work is done in
1827 read_a_source_file. */
1830 s_end (int ignore ATTRIBUTE_UNUSED
)
1834 /* The MRI assembler permits the start symbol to follow .end,
1835 but we don't support that. */
1837 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
1838 && *input_line_pointer
!= '*'
1839 && *input_line_pointer
!= '!')
1840 as_warn (_("start address not supported"));
1844 /* Handle the .err pseudo-op. */
1847 s_err (int ignore ATTRIBUTE_UNUSED
)
1849 as_bad (_(".err encountered"));
1850 demand_empty_rest_of_line ();
1853 /* Handle the .error and .warning pseudo-ops. */
1859 /* The purpose for the conditional assignment is not to
1860 internationalize the directive itself, but that we need a
1861 self-contained message, one that can be passed like the
1862 demand_copy_C_string return value, and with no assumption on the
1863 location of the name of the directive within the message. */
1865 = (err
? _(".error directive invoked in source file")
1866 : _(".warning directive invoked in source file"));
1868 if (!is_it_end_of_statement ())
1870 if (*input_line_pointer
!= '\"')
1872 as_bad (_("%s argument must be a string"),
1873 err
? ".error" : ".warning");
1874 ignore_rest_of_line ();
1878 msg
= demand_copy_C_string (&len
);
1886 as_warn ("%s", msg
);
1887 demand_empty_rest_of_line ();
1890 /* Handle the MRI fail pseudo-op. */
1893 s_fail (int ignore ATTRIBUTE_UNUSED
)
1900 stop
= mri_comment_field (&stopc
);
1902 temp
= get_absolute_expression ();
1904 as_warn (_(".fail %ld encountered"), (long) temp
);
1906 as_bad (_(".fail %ld encountered"), (long) temp
);
1908 demand_empty_rest_of_line ();
1911 mri_comment_end (stop
, stopc
);
1915 s_fill (int ignore ATTRIBUTE_UNUSED
)
1917 expressionS rep_exp
;
1922 #ifdef md_flush_pending_output
1923 md_flush_pending_output ();
1926 #ifdef md_cons_align
1930 get_known_segmented_expression (&rep_exp
);
1931 if (*input_line_pointer
== ',')
1933 input_line_pointer
++;
1934 size
= get_absolute_expression ();
1935 if (*input_line_pointer
== ',')
1937 input_line_pointer
++;
1938 fill
= get_absolute_expression ();
1942 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1943 #define BSD_FILL_SIZE_CROCK_8 (8)
1944 if (size
> BSD_FILL_SIZE_CROCK_8
)
1946 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
1947 size
= BSD_FILL_SIZE_CROCK_8
;
1951 as_warn (_("size negative; .fill ignored"));
1954 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
1956 if (rep_exp
.X_add_number
< 0)
1957 as_warn (_("repeat < 0; .fill ignored"));
1961 if (size
&& !need_pass_2
)
1963 if (rep_exp
.X_op
== O_constant
)
1965 p
= frag_var (rs_fill
, (int) size
, (int) size
,
1966 (relax_substateT
) 0, (symbolS
*) 0,
1967 (offsetT
) rep_exp
.X_add_number
,
1972 /* We don't have a constant repeat count, so we can't use
1973 rs_fill. We can get the same results out of rs_space,
1974 but its argument is in bytes, so we must multiply the
1975 repeat count by size. */
1978 rep_sym
= make_expr_symbol (&rep_exp
);
1981 expressionS size_exp
;
1982 size_exp
.X_op
= O_constant
;
1983 size_exp
.X_add_number
= size
;
1985 rep_exp
.X_op
= O_multiply
;
1986 rep_exp
.X_add_symbol
= rep_sym
;
1987 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
1988 rep_exp
.X_add_number
= 0;
1989 rep_sym
= make_expr_symbol (&rep_exp
);
1992 p
= frag_var (rs_space
, (int) size
, (int) size
,
1993 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
1996 memset (p
, 0, (unsigned int) size
);
1998 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1999 flavoured AS. The following bizarre behaviour is to be
2000 compatible with above. I guess they tried to take up to 8
2001 bytes from a 4-byte expression and they forgot to sign
2003 #define BSD_FILL_SIZE_CROCK_4 (4)
2004 md_number_to_chars (p
, (valueT
) fill
,
2005 (size
> BSD_FILL_SIZE_CROCK_4
2006 ? BSD_FILL_SIZE_CROCK_4
2008 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2009 but emits no error message because it seems a legal thing to do.
2010 It is a degenerate case of .fill but could be emitted by a
2013 demand_empty_rest_of_line ();
2017 s_globl (int ignore ATTRIBUTE_UNUSED
)
2026 stop
= mri_comment_field (&stopc
);
2030 name
= input_line_pointer
;
2031 c
= get_symbol_end ();
2032 symbolP
= symbol_find_or_make (name
);
2033 S_SET_EXTERNAL (symbolP
);
2035 *input_line_pointer
= c
;
2037 c
= *input_line_pointer
;
2040 input_line_pointer
++;
2042 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2048 demand_empty_rest_of_line ();
2051 mri_comment_end (stop
, stopc
);
2055 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
2058 skip_past_char (char ** str
, char c
)
2068 #define skip_past_comma(str) skip_past_char (str, ',')
2070 /* Parse an attribute directive for VENDOR.
2071 Returns the attribute number read, or zero on error. */
2073 s_vendor_attribute (int vendor
)
2081 /* Read the first number or name. */
2082 skip_whitespace (input_line_pointer
);
2083 s
= input_line_pointer
;
2084 if (ISDIGIT (*input_line_pointer
))
2087 if (exp
.X_op
!= O_constant
)
2089 tag
= exp
.X_add_number
;
2095 /* A name may contain '_', but no other punctuation. */
2096 for (; ISALNUM (*input_line_pointer
) || *input_line_pointer
== '_';
2097 ++input_line_pointer
)
2102 name
= (char *) alloca (i
+ 1);
2103 memcpy (name
, s
, i
);
2106 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2107 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2110 tag
= CONVERT_SYMBOLIC_ATTRIBUTE (name
);
2113 as_bad (_("Attribute name not recognised: %s"), name
);
2114 ignore_rest_of_line ();
2119 type
= _bfd_elf_obj_attrs_arg_type (stdoutput
, vendor
, tag
);
2121 if (skip_past_comma (&input_line_pointer
) == -1)
2126 if (exp
.X_op
!= O_constant
)
2128 as_bad (_("expected numeric constant"));
2129 ignore_rest_of_line ();
2132 i
= exp
.X_add_number
;
2135 && skip_past_comma (&input_line_pointer
) == -1)
2137 as_bad (_("expected comma"));
2138 ignore_rest_of_line ();
2145 skip_whitespace (input_line_pointer
);
2146 if (*input_line_pointer
!= '"')
2148 s
= demand_copy_C_string (&len
);
2154 bfd_elf_add_obj_attr_int_string (stdoutput
, vendor
, tag
, i
, s
);
2157 bfd_elf_add_obj_attr_string (stdoutput
, vendor
, tag
, s
);
2160 bfd_elf_add_obj_attr_int (stdoutput
, vendor
, tag
, i
);
2166 demand_empty_rest_of_line ();
2169 as_bad (_("bad string constant"));
2170 ignore_rest_of_line ();
2173 as_bad (_("expected <tag> , <value>"));
2174 ignore_rest_of_line ();
2178 /* Parse a .gnu_attribute directive. */
2181 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED
)
2183 s_vendor_attribute (OBJ_ATTR_GNU
);
2185 #endif /* OBJ_ELF */
2187 /* Handle the MRI IRP and IRPC pseudo-ops. */
2198 as_where (&file
, &line
);
2201 eol
= find_end_of_line (input_line_pointer
, 0);
2202 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2203 input_line_pointer
= eol
;
2207 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2209 as_bad_where (file
, line
, "%s", err
);
2213 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2215 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2218 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2219 the section to only be linked once. However, this is not supported
2220 by most object file formats. This takes an optional argument,
2221 which is what to do about duplicates. */
2224 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2226 enum linkonce_type type
;
2230 type
= LINKONCE_DISCARD
;
2232 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2237 s
= input_line_pointer
;
2238 c
= get_symbol_end ();
2239 if (strcasecmp (s
, "discard") == 0)
2240 type
= LINKONCE_DISCARD
;
2241 else if (strcasecmp (s
, "one_only") == 0)
2242 type
= LINKONCE_ONE_ONLY
;
2243 else if (strcasecmp (s
, "same_size") == 0)
2244 type
= LINKONCE_SAME_SIZE
;
2245 else if (strcasecmp (s
, "same_contents") == 0)
2246 type
= LINKONCE_SAME_CONTENTS
;
2248 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2250 *input_line_pointer
= c
;
2253 #ifdef obj_handle_link_once
2254 obj_handle_link_once (type
);
2255 #else /* ! defined (obj_handle_link_once) */
2259 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2260 as_warn (_(".linkonce is not supported for this object file format"));
2262 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2263 flags
|= SEC_LINK_ONCE
;
2268 case LINKONCE_DISCARD
:
2269 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2271 case LINKONCE_ONE_ONLY
:
2272 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2274 case LINKONCE_SAME_SIZE
:
2275 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2277 case LINKONCE_SAME_CONTENTS
:
2278 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2281 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2282 as_bad (_("bfd_set_section_flags: %s"),
2283 bfd_errmsg (bfd_get_error ()));
2285 #endif /* ! defined (obj_handle_link_once) */
2287 demand_empty_rest_of_line ();
2291 bss_alloc (symbolS
*symbolP
, addressT size
, int align
)
2294 segT current_seg
= now_seg
;
2295 subsegT current_subseg
= now_subseg
;
2296 segT bss_seg
= bss_section
;
2298 #if defined (TC_MIPS) || defined (TC_ALPHA)
2299 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2300 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2302 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2303 if (size
<= bfd_get_gp_size (stdoutput
))
2305 bss_seg
= subseg_new (".sbss", 1);
2306 seg_info (bss_seg
)->bss
= 1;
2307 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2308 as_warn (_("error setting flags for \".sbss\": %s"),
2309 bfd_errmsg (bfd_get_error ()));
2313 subseg_set (bss_seg
, 1);
2317 record_alignment (bss_seg
, align
);
2318 frag_align (align
, 0, 0);
2321 /* Detach from old frag. */
2322 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2323 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2325 symbol_set_frag (symbolP
, frag_now
);
2326 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2330 S_SET_SIZE (symbolP
, size
);
2332 S_SET_SEGMENT (symbolP
, bss_seg
);
2335 /* The symbol may already have been created with a preceding
2336 ".globl" directive -- be careful not to step on storage class
2337 in that case. Otherwise, set it to static. */
2338 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2339 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2340 #endif /* OBJ_COFF */
2342 subseg_set (current_seg
, current_subseg
);
2346 parse_align (int align_bytes
)
2352 if (*input_line_pointer
!= ',')
2355 as_bad (_("expected alignment after size"));
2356 ignore_rest_of_line ();
2360 input_line_pointer
++;
2363 align
= get_absolute_expr (&exp
);
2364 if (exp
.X_op
== O_absent
)
2367 if (!exp
.X_unsigned
)
2369 as_warn (_("alignment negative; 0 assumed"));
2373 if (align_bytes
&& align
!= 0)
2375 /* convert to a power of 2 alignment */
2376 unsigned int alignp2
= 0;
2377 while ((align
& 1) == 0)
2378 align
>>= 1, ++alignp2
;
2381 as_bad (_("alignment not a power of 2"));
2382 ignore_rest_of_line ();
2390 /* Called from s_comm_internal after symbol name and size have been
2391 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2392 1 if this was a ".bss" directive which has a 3rd argument
2393 (alignment as a power of 2), or 2 if this was a ".bss" directive
2394 with alignment in bytes. */
2397 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2403 align
= parse_align (needs_align
- 1);
2404 if (align
== (addressT
) -1)
2408 /* Assume some objects may require alignment on some systems. */
2409 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2411 bss_alloc (symbolP
, size
, align
);
2416 s_lcomm (int needs_align
)
2418 s_comm_internal (needs_align
, s_lcomm_internal
);
2422 s_lcomm_bytes (int needs_align
)
2424 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2428 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2436 /* We permit ANY defined expression: BSD4.2 demands constants. */
2437 name
= input_line_pointer
;
2438 c
= get_symbol_end ();
2439 p
= input_line_pointer
;
2444 as_bad (_("expected symbol name"));
2445 ignore_rest_of_line ();
2451 if (*input_line_pointer
!= ',')
2454 as_bad (_("expected comma after \"%s\""), name
);
2456 ignore_rest_of_line ();
2460 input_line_pointer
++;
2461 expression_and_evaluate (&exp
);
2463 if (exp
.X_op
!= O_constant
2464 && exp
.X_op
!= O_register
)
2466 as_bad (_("bad expression"));
2467 ignore_rest_of_line ();
2472 symbolP
= symbol_find_or_make (name
);
2474 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2476 /* The name might be an undefined .global symbol; be sure to
2477 keep the "external" bit. */
2478 S_SET_SEGMENT (symbolP
,
2479 (exp
.X_op
== O_constant
2482 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2486 as_bad (_("symbol `%s' is already defined"), name
);
2490 demand_empty_rest_of_line ();
2493 /* Read a line into an sb. Returns the character that ended the line
2494 or zero if there are no more lines. */
2497 get_line_sb (sb
*line
, int in_macro
)
2501 if (input_line_pointer
[-1] == '\n')
2502 bump_line_counters ();
2504 if (input_line_pointer
>= buffer_limit
)
2506 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2507 if (buffer_limit
== 0)
2511 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2512 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2513 input_line_pointer
= eol
;
2515 /* Don't skip multiple end-of-line characters, because that breaks support
2516 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2517 characters but isn't. Instead just skip one end of line character and
2518 return the character skipped so that the caller can re-insert it if
2520 return *input_line_pointer
++;
2524 get_non_macro_line_sb (sb
*line
)
2526 return get_line_sb (line
, 0);
2530 get_macro_line_sb (sb
*line
)
2532 return get_line_sb (line
, 1);
2535 /* Define a macro. This is an interface to macro.c. */
2538 s_macro (int ignore ATTRIBUTE_UNUSED
)
2546 as_where (&file
, &line
);
2549 eol
= find_end_of_line (input_line_pointer
, 0);
2550 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2551 input_line_pointer
= eol
;
2553 if (line_label
!= NULL
)
2558 sb_add_string (&label
, S_GET_NAME (line_label
));
2559 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2563 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2565 as_bad_where (file
, line
, err
, name
);
2568 if (line_label
!= NULL
)
2570 S_SET_SEGMENT (line_label
, absolute_section
);
2571 S_SET_VALUE (line_label
, 0);
2572 symbol_set_frag (line_label
, &zero_address_frag
);
2575 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2576 && hash_find (po_hash
, name
) != NULL
)
2579 && hash_find (po_hash
, name
+ 1) != NULL
))
2580 as_warn_where (file
,
2582 _("attempt to redefine pseudo-op `%s' ignored"),
2589 /* Handle the .mexit pseudo-op, which immediately exits a macro
2593 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2597 cond_exit_macro (macro_nest
);
2598 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2601 as_warn (_("ignoring macro exit outside a macro definition."));
2604 /* Switch in and out of MRI mode. */
2607 s_mri (int ignore ATTRIBUTE_UNUSED
)
2610 #ifdef MRI_MODE_CHANGE
2614 on
= get_absolute_expression ();
2615 #ifdef MRI_MODE_CHANGE
2616 old_flag
= flag_mri
;
2635 /* Operator precedence changes in m68k MRI mode, so we need to
2636 update the operator rankings. */
2637 expr_set_precedence ();
2639 #ifdef MRI_MODE_CHANGE
2641 MRI_MODE_CHANGE (on
);
2644 demand_empty_rest_of_line ();
2647 /* Handle changing the location counter. */
2650 do_org (segT segment
, expressionS
*exp
, int fill
)
2652 if (segment
!= now_seg
2653 && segment
!= absolute_section
2654 && segment
!= expr_section
)
2655 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2657 if (now_seg
== absolute_section
)
2660 as_warn (_("ignoring fill value in absolute section"));
2661 if (exp
->X_op
!= O_constant
)
2663 as_bad (_("only constant offsets supported in absolute section"));
2664 exp
->X_add_number
= 0;
2666 abs_section_offset
= exp
->X_add_number
;
2671 symbolS
*sym
= exp
->X_add_symbol
;
2672 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2674 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2676 /* Handle complex expressions. */
2677 sym
= make_expr_symbol (exp
);
2681 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2687 s_org (int ignore ATTRIBUTE_UNUSED
)
2693 #ifdef md_flush_pending_output
2694 md_flush_pending_output ();
2697 /* The m68k MRI assembler has a different meaning for .org. It
2698 means to create an absolute section at a given address. We can't
2699 support that--use a linker script instead. */
2702 as_bad (_("MRI style ORG pseudo-op not supported"));
2703 ignore_rest_of_line ();
2707 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2708 thing as a sub-segment-relative origin. Any absolute origin is
2709 given a warning, then assumed to be segment-relative. Any
2710 segmented origin expression ("foo+42") had better be in the right
2711 segment or the .org is ignored.
2713 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2714 we never know sub-segment sizes when we are reading code. BSD
2715 will crash trying to emit negative numbers of filler bytes in
2716 certain .orgs. We don't crash, but see as-write for that code.
2718 Don't make frag if need_pass_2==1. */
2719 segment
= get_known_segmented_expression (&exp
);
2720 if (*input_line_pointer
== ',')
2722 input_line_pointer
++;
2723 temp_fill
= get_absolute_expression ();
2729 do_org (segment
, &exp
, temp_fill
);
2731 demand_empty_rest_of_line ();
2734 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2735 called by the obj-format routine which handles section changing
2736 when in MRI mode. It will create a new section, and return it. It
2737 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2738 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2741 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2751 name
= input_line_pointer
;
2752 if (!ISDIGIT (*name
))
2753 c
= get_symbol_end ();
2758 ++input_line_pointer
;
2760 while (ISDIGIT (*input_line_pointer
));
2762 c
= *input_line_pointer
;
2763 *input_line_pointer
= '\0';
2766 name
= xstrdup (name
);
2768 *input_line_pointer
= c
;
2770 seg
= subseg_new (name
, 0);
2772 if (*input_line_pointer
== ',')
2776 ++input_line_pointer
;
2777 align
= get_absolute_expression ();
2778 record_alignment (seg
, align
);
2782 if (*input_line_pointer
== ',')
2784 c
= *++input_line_pointer
;
2786 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2789 as_bad (_("unrecognized section type"));
2790 ++input_line_pointer
;
2795 flags
= SEC_NO_FLAGS
;
2797 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2798 else if (*type
== 'D' || *type
== 'M')
2799 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2800 else if (*type
== 'R')
2801 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2802 if (flags
!= SEC_NO_FLAGS
)
2804 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2805 as_warn (_("error setting flags for \"%s\": %s"),
2806 bfd_section_name (stdoutput
, seg
),
2807 bfd_errmsg (bfd_get_error ()));
2812 /* Ignore the HP type. */
2813 if (*input_line_pointer
== ',')
2814 input_line_pointer
+= 2;
2816 demand_empty_rest_of_line ();
2818 #else /* ! TC_M68K */
2827 name
= input_line_pointer
;
2828 c
= get_symbol_end ();
2830 name
= xstrdup (name
);
2832 *input_line_pointer
= c
;
2834 seg
= subseg_new (name
, 0);
2836 if (*input_line_pointer
!= ',')
2842 ++input_line_pointer
;
2844 sectype
= input_line_pointer
;
2845 c
= get_symbol_end ();
2846 if (*sectype
== '\0')
2848 else if (strcasecmp (sectype
, "text") == 0)
2850 else if (strcasecmp (sectype
, "data") == 0)
2852 else if (strcasecmp (sectype
, "romdata") == 0)
2855 as_warn (_("unrecognized section type `%s'"), sectype
);
2856 *input_line_pointer
= c
;
2859 if (*input_line_pointer
== ',')
2863 ++input_line_pointer
;
2865 seccmd
= input_line_pointer
;
2866 c
= get_symbol_end ();
2867 if (strcasecmp (seccmd
, "absolute") == 0)
2869 as_bad (_("absolute sections are not supported"));
2870 *input_line_pointer
= c
;
2871 ignore_rest_of_line ();
2874 else if (strcasecmp (seccmd
, "align") == 0)
2878 *input_line_pointer
= c
;
2879 align
= get_absolute_expression ();
2880 record_alignment (seg
, align
);
2884 as_warn (_("unrecognized section command `%s'"), seccmd
);
2885 *input_line_pointer
= c
;
2889 demand_empty_rest_of_line ();
2891 #else /* ! TC_I960 */
2892 /* The MRI assembler seems to use different forms of .sect for
2893 different targets. */
2894 as_bad ("MRI mode not supported for this target");
2895 ignore_rest_of_line ();
2896 #endif /* ! TC_I960 */
2897 #endif /* ! TC_M68K */
2900 /* Handle the .print pseudo-op. */
2903 s_print (int ignore ATTRIBUTE_UNUSED
)
2908 s
= demand_copy_C_string (&len
);
2911 demand_empty_rest_of_line ();
2914 /* Handle the .purgem pseudo-op. */
2917 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2919 if (is_it_end_of_statement ())
2921 demand_empty_rest_of_line ();
2931 name
= input_line_pointer
;
2932 c
= get_symbol_end ();
2933 delete_macro (name
);
2934 *input_line_pointer
= c
;
2937 while (*input_line_pointer
++ == ',');
2939 --input_line_pointer
;
2940 demand_empty_rest_of_line ();
2943 /* Handle the .endm/.endr pseudo-ops. */
2946 s_bad_end (int endr
)
2948 as_warn (_(".end%c encountered without preceeding %s"),
2950 endr
? ".rept, .irp, or .irpc" : ".macro");
2951 demand_empty_rest_of_line ();
2954 /* Handle the .rept pseudo-op. */
2957 s_rept (int ignore ATTRIBUTE_UNUSED
)
2961 count
= get_absolute_expression ();
2963 do_repeat (count
, "REPT", "ENDR");
2966 /* This function provides a generic repeat block implementation. It allows
2967 different directives to be used as the start/end keys. */
2970 do_repeat (int count
, const char *start
, const char *end
)
2976 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
2978 as_bad (_("%s without %s"), start
, end
);
2984 sb_add_sb (&many
, &one
);
2988 input_scrub_include_sb (&many
, input_line_pointer
, 1);
2990 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2993 /* Like do_repeat except that any text matching EXPANDER in the
2994 block is replaced by the itteration count. */
2997 do_repeat_with_expander (int count
,
3000 const char * expander
)
3006 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
3008 as_bad (_("%s without %s"), start
, end
);
3014 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3016 while (count
-- > 0)
3022 sb_new (& processed
);
3023 sb_add_sb (& processed
, & one
);
3024 sub
= strstr (processed
.ptr
, expander
);
3025 len
= sprintf (sub
, "%d", count
);
3026 gas_assert (len
< 8);
3027 strcpy (sub
+ len
, sub
+ 8);
3028 processed
.len
-= (8 - len
);
3029 sb_add_sb (& many
, & processed
);
3030 sb_kill (& processed
);
3035 sb_add_sb (&many
, &one
);
3039 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3041 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3044 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3045 input buffers to skip. Assumes that conditionals preceding the loop end
3046 are properly nested.
3048 This function makes it easier to implement a premature "break" out of the
3049 loop. The EXTRA arg accounts for other buffers we might have inserted,
3050 such as line substitutions. */
3053 end_repeat (int extra
)
3055 cond_exit_macro (macro_nest
);
3056 while (extra
-- >= 0)
3057 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3061 assign_symbol (char *name
, int mode
)
3065 if (name
[0] == '.' && name
[1] == '\0')
3067 /* Turn '. = mumble' into a .org mumble. */
3071 segment
= get_known_segmented_expression (&exp
);
3074 do_org (segment
, &exp
, 0);
3079 if ((symbolP
= symbol_find (name
)) == NULL
3080 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3082 symbolP
= symbol_find_or_make (name
);
3084 /* When doing symbol listings, play games with dummy fragments living
3085 outside the normal fragment chain to record the file and line info
3087 if (listing
& LISTING_SYMBOLS
)
3089 extern struct list_info_struct
*listing_tail
;
3090 fragS
*dummy_frag
= (fragS
*) xcalloc (1, sizeof (fragS
));
3091 dummy_frag
->line
= listing_tail
;
3092 dummy_frag
->fr_symbol
= symbolP
;
3093 symbol_set_frag (symbolP
, dummy_frag
);
3097 /* "set" symbols are local unless otherwise specified. */
3098 SF_SET_LOCAL (symbolP
);
3102 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3104 /* Permit register names to be redefined. */
3105 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3106 && S_GET_SEGMENT (symbolP
) != reg_section
)
3108 as_bad (_("symbol `%s' is already defined"), name
);
3109 symbolP
= symbol_clone (symbolP
, 0);
3111 /* If the symbol is volatile, copy the symbol and replace the
3112 original with the copy, so that previous uses of the symbol will
3113 retain the value of the symbol at the point of use. */
3114 else if (S_IS_VOLATILE (symbolP
))
3115 symbolP
= symbol_clone (symbolP
, 1);
3119 S_SET_VOLATILE (symbolP
);
3121 S_SET_FORWARD_REF (symbolP
);
3123 pseudo_set (symbolP
);
3126 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3127 then this is .equiv, and it is an error if the symbol is already
3128 defined. If EQUIV is -1, the symbol additionally is a forward
3138 /* Especial apologies for the random logic:
3139 this just grew, and could be parsed much more simply!
3141 name
= input_line_pointer
;
3142 delim
= get_symbol_end ();
3143 end_name
= input_line_pointer
;
3146 if (name
== end_name
)
3148 as_bad (_("expected symbol name"));
3149 ignore_rest_of_line ();
3155 if (*input_line_pointer
!= ',')
3158 as_bad (_("expected comma after \"%s\""), name
);
3160 ignore_rest_of_line ();
3164 input_line_pointer
++;
3167 assign_symbol (name
, equiv
);
3170 demand_empty_rest_of_line ();
3183 #ifdef md_flush_pending_output
3184 md_flush_pending_output ();
3187 #ifdef md_cons_align
3192 stop
= mri_comment_field (&stopc
);
3194 /* In m68k MRI mode, we need to align to a word boundary, unless
3196 if (flag_m68k_mri
&& mult
> 1)
3198 if (now_seg
== absolute_section
)
3200 abs_section_offset
+= abs_section_offset
& 1;
3201 if (line_label
!= NULL
)
3202 S_SET_VALUE (line_label
, abs_section_offset
);
3204 else if (mri_common_symbol
!= NULL
)
3208 mri_val
= S_GET_VALUE (mri_common_symbol
);
3209 if ((mri_val
& 1) != 0)
3211 S_SET_VALUE (mri_common_symbol
, mri_val
+ 1);
3212 if (line_label
!= NULL
)
3214 expressionS
*symexp
;
3216 symexp
= symbol_get_value_expression (line_label
);
3217 know (symexp
->X_op
== O_symbol
);
3218 know (symexp
->X_add_symbol
== mri_common_symbol
);
3219 symexp
->X_add_number
+= 1;
3225 do_align (1, (char *) NULL
, 0, 0);
3226 if (line_label
!= NULL
)
3228 symbol_set_frag (line_label
, frag_now
);
3229 S_SET_VALUE (line_label
, frag_now_fix ());
3239 if (*input_line_pointer
== ',')
3241 ++input_line_pointer
;
3246 val
.X_op
= O_constant
;
3247 val
.X_add_number
= 0;
3250 if (val
.X_op
!= O_constant
3251 || val
.X_add_number
< - 0x80
3252 || val
.X_add_number
> 0xff
3253 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3255 resolve_expression (&exp
);
3256 if (exp
.X_op
!= O_constant
)
3257 as_bad (_("unsupported variable size or fill value"));
3264 bytes
= mult
* exp
.X_add_number
;
3265 for (i
= 0; i
< exp
.X_add_number
; i
++)
3266 emit_expr (&val
, mult
);
3271 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3272 resolve_expression (&exp
);
3274 if (exp
.X_op
== O_constant
)
3278 repeat
= exp
.X_add_number
;
3285 as_warn (_(".space repeat count is zero, ignored"));
3286 else if (repeat
< 0)
3287 as_warn (_(".space repeat count is negative, ignored"));
3291 /* If we are in the absolute section, just bump the offset. */
3292 if (now_seg
== absolute_section
)
3294 abs_section_offset
+= repeat
;
3298 /* If we are secretly in an MRI common section, then
3299 creating space just increases the size of the common
3301 if (mri_common_symbol
!= NULL
)
3303 S_SET_VALUE (mri_common_symbol
,
3304 S_GET_VALUE (mri_common_symbol
) + repeat
);
3309 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3310 (offsetT
) repeat
, (char *) 0);
3314 if (now_seg
== absolute_section
)
3316 as_bad (_("space allocation too complex in absolute section"));
3317 subseg_set (text_section
, 0);
3320 if (mri_common_symbol
!= NULL
)
3322 as_bad (_("space allocation too complex in common section"));
3323 mri_common_symbol
= NULL
;
3327 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3328 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3332 *p
= val
.X_add_number
;
3337 /* In MRI mode, after an odd number of bytes, we must align to an
3338 even word boundary, unless the next instruction is a dc.b, ds.b
3340 if (flag_mri
&& (bytes
& 1) != 0)
3341 mri_pending_align
= 1;
3343 demand_empty_rest_of_line ();
3346 mri_comment_end (stop
, stopc
);
3349 /* This is like s_space, but the value is a floating point number with
3350 the given precision. This is for the MRI dcb.s pseudo-op and
3354 s_float_space (int float_type
)
3358 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3362 #ifdef md_cons_align
3367 stop
= mri_comment_field (&stopc
);
3369 count
= get_absolute_expression ();
3372 if (*input_line_pointer
!= ',')
3374 as_bad (_("missing value"));
3375 ignore_rest_of_line ();
3377 mri_comment_end (stop
, stopc
);
3381 ++input_line_pointer
;
3385 /* Skip any 0{letter} that may be present. Don't even check if the
3386 * letter is legal. */
3387 if (input_line_pointer
[0] == '0'
3388 && ISALPHA (input_line_pointer
[1]))
3389 input_line_pointer
+= 2;
3391 /* Accept :xxxx, where the x's are hex digits, for a floating point
3392 with the exact digits specified. */
3393 if (input_line_pointer
[0] == ':')
3395 flen
= hex_float (float_type
, temp
);
3398 ignore_rest_of_line ();
3400 mri_comment_end (stop
, stopc
);
3408 err
= md_atof (float_type
, temp
, &flen
);
3409 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3410 know (err
!= NULL
|| flen
> 0);
3413 as_bad (_("bad floating literal: %s"), err
);
3414 ignore_rest_of_line ();
3416 mri_comment_end (stop
, stopc
);
3421 while (--count
>= 0)
3425 p
= frag_more (flen
);
3426 memcpy (p
, temp
, (unsigned int) flen
);
3429 demand_empty_rest_of_line ();
3432 mri_comment_end (stop
, stopc
);
3435 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3438 s_struct (int ignore ATTRIBUTE_UNUSED
)
3444 stop
= mri_comment_field (&stopc
);
3445 abs_section_offset
= get_absolute_expression ();
3446 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3447 /* The ELF backend needs to know that we are changing sections, so
3448 that .previous works correctly. */
3450 obj_elf_section_change_hook ();
3452 subseg_set (absolute_section
, 0);
3453 demand_empty_rest_of_line ();
3455 mri_comment_end (stop
, stopc
);
3459 s_text (int ignore ATTRIBUTE_UNUSED
)
3463 temp
= get_absolute_expression ();
3464 subseg_set (text_section
, (subsegT
) temp
);
3465 demand_empty_rest_of_line ();
3467 const_flag
&= ~IN_DEFAULT_SECTION
;
3471 /* .weakref x, y sets x as an alias to y that, as long as y is not
3472 referenced directly, will cause y to become a weak symbol. */
3474 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3483 name
= input_line_pointer
;
3484 delim
= get_symbol_end ();
3485 end_name
= input_line_pointer
;
3487 if (name
== end_name
)
3489 as_bad (_("expected symbol name"));
3491 ignore_rest_of_line ();
3495 symbolP
= symbol_find_or_make (name
);
3497 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3499 if (!S_IS_VOLATILE (symbolP
))
3501 as_bad (_("symbol `%s' is already defined"), name
);
3503 ignore_rest_of_line ();
3506 symbolP
= symbol_clone (symbolP
, 1);
3507 S_CLEAR_VOLATILE (symbolP
);
3514 if (*input_line_pointer
!= ',')
3517 as_bad (_("expected comma after \"%s\""), name
);
3519 ignore_rest_of_line ();
3523 input_line_pointer
++;
3527 name
= input_line_pointer
;
3528 delim
= get_symbol_end ();
3529 end_name
= input_line_pointer
;
3531 if (name
== end_name
)
3533 as_bad (_("expected symbol name"));
3534 ignore_rest_of_line ();
3538 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3539 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3541 symbolP2
= symbol_find_or_make (name
);
3542 S_SET_WEAKREFD (symbolP2
);
3546 symbolS
*symp
= symbolP2
;
3548 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3550 expressionS
*expP
= symbol_get_value_expression (symp
);
3552 gas_assert (expP
->X_op
== O_symbol
3553 && expP
->X_add_number
== 0);
3554 symp
= expP
->X_add_symbol
;
3556 if (symp
== symbolP
)
3560 loop
= concat (S_GET_NAME (symbolP
),
3561 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3564 while (symp
!= symbolP
)
3566 char *old_loop
= loop
;
3567 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3568 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3569 (const char *) NULL
);
3573 as_bad (_("%s: would close weakref loop: %s"),
3574 S_GET_NAME (symbolP
), loop
);
3579 ignore_rest_of_line ();
3583 /* Short-circuiting instead of just checking here might speed
3584 things up a tiny little bit, but loop error messages would
3585 miss intermediate links. */
3586 /* symbolP2 = symp; */
3591 memset (&exp
, 0, sizeof (exp
));
3592 exp
.X_op
= O_symbol
;
3593 exp
.X_add_symbol
= symbolP2
;
3595 S_SET_SEGMENT (symbolP
, undefined_section
);
3596 symbol_set_value_expression (symbolP
, &exp
);
3597 symbol_set_frag (symbolP
, &zero_address_frag
);
3598 S_SET_WEAKREFR (symbolP
);
3600 demand_empty_rest_of_line ();
3604 /* Verify that we are at the end of a line. If not, issue an error and
3608 demand_empty_rest_of_line (void)
3611 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3612 input_line_pointer
++;
3615 if (ISPRINT (*input_line_pointer
))
3616 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3617 *input_line_pointer
);
3619 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3620 *input_line_pointer
);
3621 ignore_rest_of_line ();
3624 /* Return pointing just after end-of-line. */
3625 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3628 /* Silently advance to the end of line. Use this after already having
3629 issued an error about something bad. */
3632 ignore_rest_of_line (void)
3634 while (input_line_pointer
< buffer_limit
3635 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3636 input_line_pointer
++;
3638 input_line_pointer
++;
3640 /* Return pointing just after end-of-line. */
3641 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3644 /* Sets frag for given symbol to zero_address_frag, except when the
3645 symbol frag is already set to a dummy listing frag. */
3648 set_zero_frag (symbolS
*symbolP
)
3650 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3651 symbol_set_frag (symbolP
, &zero_address_frag
);
3654 /* In: Pointer to a symbol.
3655 Input_line_pointer->expression.
3657 Out: Input_line_pointer->just after any whitespace after expression.
3658 Tried to set symbol to value of expression.
3659 Will change symbols type, value, and frag; */
3662 pseudo_set (symbolS
*symbolP
)
3667 know (symbolP
); /* NULL pointer is logic error. */
3669 if (!S_IS_FORWARD_REF (symbolP
))
3670 (void) expression (&exp
);
3672 (void) deferred_expression (&exp
);
3674 if (exp
.X_op
== O_illegal
)
3675 as_bad (_("illegal expression"));
3676 else if (exp
.X_op
== O_absent
)
3677 as_bad (_("missing expression"));
3678 else if (exp
.X_op
== O_big
)
3680 if (exp
.X_add_number
> 0)
3681 as_bad (_("bignum invalid"));
3683 as_bad (_("floating point number invalid"));
3685 else if (exp
.X_op
== O_subtract
3686 && !S_IS_FORWARD_REF (symbolP
)
3687 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3688 && (symbol_get_frag (exp
.X_add_symbol
)
3689 == symbol_get_frag (exp
.X_op_symbol
)))
3691 exp
.X_op
= O_constant
;
3692 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3693 - S_GET_VALUE (exp
.X_op_symbol
));
3696 if (symbol_section_p (symbolP
))
3698 as_bad ("attempt to set value of section symbol");
3707 exp
.X_add_number
= 0;
3710 S_SET_SEGMENT (symbolP
, absolute_section
);
3711 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3712 set_zero_frag (symbolP
);
3716 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3717 if (S_IS_EXTERNAL (symbolP
))
3719 as_bad ("can't equate global symbol `%s' with register name",
3720 S_GET_NAME (symbolP
));
3724 S_SET_SEGMENT (symbolP
, reg_section
);
3725 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3726 set_zero_frag (symbolP
);
3727 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3731 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3732 /* For x=undef+const, create an expression symbol.
3733 For x=x+const, just update x except when x is an undefined symbol
3734 For x=defined+const, evaluate x. */
3735 if (symbolP
== exp
.X_add_symbol
3736 && (seg
!= undefined_section
3737 || !symbol_constant_p (symbolP
)))
3739 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3742 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3744 symbolS
*s
= exp
.X_add_symbol
;
3746 if (S_IS_COMMON (s
))
3747 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3748 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3750 S_SET_SEGMENT (symbolP
, seg
);
3751 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3752 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3753 copy_symbol_attributes (symbolP
, s
);
3756 S_SET_SEGMENT (symbolP
, undefined_section
);
3757 symbol_set_value_expression (symbolP
, &exp
);
3758 copy_symbol_attributes (symbolP
, exp
.X_add_symbol
);
3759 set_zero_frag (symbolP
);
3763 /* The value is some complex expression. */
3764 S_SET_SEGMENT (symbolP
, expr_section
);
3765 symbol_set_value_expression (symbolP
, &exp
);
3766 set_zero_frag (symbolP
);
3773 CONStruct more frag of .bytes, or .words etc.
3774 Should need_pass_2 be 1 then emit no frag(s).
3775 This understands EXPRESSIONS.
3779 This has a split personality. We use expression() to read the
3780 value. We can detect if the value won't fit in a byte or word.
3781 But we can't detect if expression() discarded significant digits
3782 in the case of a long. Not worth the crocks required to fix it. */
3784 /* Select a parser for cons expressions. */
3786 /* Some targets need to parse the expression in various fancy ways.
3787 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3788 (for example, the HPPA does this). Otherwise, you can define
3789 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3790 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3791 are defined, which is the normal case, then only simple expressions
3796 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3799 #ifndef TC_PARSE_CONS_EXPRESSION
3800 #ifdef BITFIELD_CONS_EXPRESSIONS
3801 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3803 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3805 #ifdef REPEAT_CONS_EXPRESSIONS
3806 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3808 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3811 /* If we haven't gotten one yet, just call expression. */
3812 #ifndef TC_PARSE_CONS_EXPRESSION
3813 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3818 do_parse_cons_expression (expressionS
*exp
,
3819 int nbytes ATTRIBUTE_UNUSED
)
3821 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3825 /* Worker to do .byte etc statements.
3826 Clobbers input_line_pointer and checks end-of-line. */
3829 cons_worker (int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3837 #ifdef md_flush_pending_output
3838 md_flush_pending_output ();
3842 stop
= mri_comment_field (&stopc
);
3844 if (is_it_end_of_statement ())
3846 demand_empty_rest_of_line ();
3848 mri_comment_end (stop
, stopc
);
3852 #ifdef TC_ADDRESS_BYTES
3854 nbytes
= TC_ADDRESS_BYTES ();
3857 #ifdef md_cons_align
3858 md_cons_align (nbytes
);
3866 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3870 if (*input_line_pointer
== '"')
3872 as_bad (_("unexpected `\"' in expression"));
3873 ignore_rest_of_line ();
3876 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3881 if (exp
.X_op
== O_symbol
)
3882 exp
.X_op
= O_symbol_rva
;
3884 as_fatal (_("rva without symbol"));
3886 emit_expr (&exp
, (unsigned int) nbytes
);
3889 while (*input_line_pointer
++ == ',');
3891 /* In MRI mode, after an odd number of bytes, we must align to an
3892 even word boundary, unless the next instruction is a dc.b, ds.b
3894 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3895 mri_pending_align
= 1;
3897 input_line_pointer
--; /* Put terminator back into stream. */
3899 demand_empty_rest_of_line ();
3902 mri_comment_end (stop
, stopc
);
3908 cons_worker (size
, 0);
3914 cons_worker (size
, 1);
3917 /* .reloc offset, reloc_name, symbol+addend. */
3920 s_reloc (int ignore ATTRIBUTE_UNUSED
)
3927 struct reloc_list
*reloc
;
3929 reloc
= (struct reloc_list
*) xmalloc (sizeof (*reloc
));
3932 stop
= mri_comment_field (&stopc
);
3941 as_bad (_("missing or bad offset expression"));
3944 exp
.X_add_symbol
= section_symbol (now_seg
);
3945 exp
.X_op
= O_symbol
;
3948 if (exp
.X_add_number
== 0)
3950 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
3955 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
3960 if (*input_line_pointer
!= ',')
3962 as_bad (_("missing reloc type"));
3966 ++input_line_pointer
;
3968 r_name
= input_line_pointer
;
3969 c
= get_symbol_end ();
3970 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
3971 *input_line_pointer
= c
;
3972 if (reloc
->u
.a
.howto
== NULL
)
3974 as_bad (_("unrecognized reloc type"));
3978 exp
.X_op
= O_absent
;
3980 if (*input_line_pointer
== ',')
3982 ++input_line_pointer
;
3990 as_bad (_("bad reloc expression"));
3992 ignore_rest_of_line ();
3995 mri_comment_end (stop
, stopc
);
3998 reloc
->u
.a
.sym
= NULL
;
3999 reloc
->u
.a
.addend
= 0;
4002 reloc
->u
.a
.sym
= NULL
;
4003 reloc
->u
.a
.addend
= exp
.X_add_number
;
4006 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
4007 reloc
->u
.a
.addend
= exp
.X_add_number
;
4010 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
4011 reloc
->u
.a
.addend
= 0;
4015 as_where (&reloc
->file
, &reloc
->line
);
4016 reloc
->next
= reloc_list
;
4019 demand_empty_rest_of_line ();
4021 mri_comment_end (stop
, stopc
);
4024 /* Put the contents of expression EXP into the object file using
4025 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4028 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4032 valueT extra_digit
= 0;
4034 /* Don't do anything if we are going to make another pass. */
4038 /* Grow the current frag now so that dot_value does not get invalidated
4039 if the frag were to fill up in the frag_more() call below. */
4041 dot_value
= frag_now_fix ();
4045 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4046 appear as a four byte positive constant in the .line section,
4047 followed by a 2 byte 0xffff. Look for that case here. */
4049 static int dwarf_line
= -1;
4051 if (strcmp (segment_name (now_seg
), ".line") != 0)
4053 else if (dwarf_line
>= 0
4055 && exp
->X_op
== O_constant
4056 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4057 listing_source_line ((unsigned int) dwarf_line
);
4058 else if (nbytes
== 4
4059 && exp
->X_op
== O_constant
4060 && exp
->X_add_number
>= 0)
4061 dwarf_line
= exp
->X_add_number
;
4066 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4067 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4068 AT_sibling (0x12) followed by a four byte address of the sibling
4069 followed by a 2 byte AT_name (0x38) followed by the name of the
4070 file. We look for that case here. */
4072 static int dwarf_file
= 0;
4074 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4076 else if (dwarf_file
== 0
4078 && exp
->X_op
== O_constant
4079 && exp
->X_add_number
== 0x11)
4081 else if (dwarf_file
== 1
4083 && exp
->X_op
== O_constant
4084 && exp
->X_add_number
== 0x12)
4086 else if (dwarf_file
== 2
4089 else if (dwarf_file
== 3
4091 && exp
->X_op
== O_constant
4092 && exp
->X_add_number
== 0x38)
4097 /* The variable dwarf_file_string tells stringer that the string
4098 may be the name of the source file. */
4099 if (dwarf_file
== 4)
4100 dwarf_file_string
= 1;
4102 dwarf_file_string
= 0;
4107 if (check_eh_frame (exp
, &nbytes
))
4112 /* Allow `.word 0' in the absolute section. */
4113 if (now_seg
== absolute_section
)
4115 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4116 as_bad (_("attempt to store value in absolute section"));
4117 abs_section_offset
+= nbytes
;
4121 /* Handle a negative bignum. */
4123 && exp
->X_add_number
== 0
4124 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4125 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4128 unsigned long carry
;
4130 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4132 /* Negate the bignum: one's complement each digit and add 1. */
4134 for (i
= 0; i
< exp
->X_add_number
; i
++)
4138 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4141 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4142 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4145 /* We can ignore any carry out, because it will be handled by
4146 extra_digit if it is needed. */
4148 extra_digit
= (valueT
) -1;
4152 if (op
== O_absent
|| op
== O_illegal
)
4154 as_warn (_("zero assumed for missing expression"));
4155 exp
->X_add_number
= 0;
4158 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4160 as_bad (_("floating point number invalid"));
4161 exp
->X_add_number
= 0;
4164 else if (op
== O_register
)
4166 as_warn (_("register value used as expression"));
4170 p
= frag_more ((int) nbytes
);
4172 #ifndef WORKING_DOT_WORD
4173 /* If we have the difference of two symbols in a word, save it on
4174 the broken_words list. See the code in write.c. */
4175 if (op
== O_subtract
&& nbytes
== 2)
4177 struct broken_word
*x
;
4179 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
4180 x
->next_broken_word
= broken_words
;
4183 x
->subseg
= now_subseg
;
4185 x
->word_goes_here
= p
;
4187 x
->add
= exp
->X_add_symbol
;
4188 x
->sub
= exp
->X_op_symbol
;
4189 x
->addnum
= exp
->X_add_number
;
4197 /* If we have an integer, but the number of bytes is too large to
4198 pass to md_number_to_chars, handle it as a bignum. */
4199 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4201 extra_digit
= exp
->X_unsigned
? 0 : -1;
4202 convert_to_bignum (exp
);
4206 if (op
== O_constant
)
4214 /* JF << of >= number of bits in the object is undefined. In
4215 particular SPARC (Sun 4) has problems. */
4216 if (nbytes
>= sizeof (valueT
))
4219 if (nbytes
> sizeof (valueT
))
4222 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4226 /* Don't store these bits. */
4227 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4228 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4231 unmask
= ~mask
; /* Do store these bits. */
4234 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4235 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4238 get
= exp
->X_add_number
;
4240 if ((get
& mask
) != 0
4241 && ((get
& mask
) != mask
4242 || (get
& hibit
) == 0))
4243 { /* Leading bits contain both 0s & 1s. */
4244 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4246 as_warn (_("value 0x%llx truncated to 0x%llx"),
4247 (unsigned long long) get
, (unsigned long long) use
);
4249 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4250 (unsigned long long) get
, (unsigned long long) use
);
4253 as_warn (_("value 0x%lx truncated to 0x%lx"),
4254 (unsigned long) get
, (unsigned long) use
);
4257 /* Put bytes in right order. */
4258 md_number_to_chars (p
, use
, (int) nbytes
);
4260 else if (op
== O_big
)
4263 LITTLENUM_TYPE
*nums
;
4265 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4268 int i
= nbytes
/ CHARS_PER_LITTLENUM
;
4271 LITTLENUM_TYPE sign
= 0;
4272 if ((generic_bignum
[--i
]
4273 & (1 << (LITTLENUM_NUMBER_OF_BITS
- 1))) != 0)
4274 sign
= ~(LITTLENUM_TYPE
) 0;
4275 while (++i
< exp
->X_add_number
)
4276 if (generic_bignum
[i
] != sign
)
4279 if (i
< exp
->X_add_number
)
4280 as_warn (_("bignum truncated to %d bytes"), nbytes
);
4286 md_number_to_chars (p
, (valueT
) generic_bignum
[0], 1);
4289 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4291 if (target_big_endian
)
4293 while (nbytes
> size
)
4295 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4296 nbytes
-= CHARS_PER_LITTLENUM
;
4297 p
+= CHARS_PER_LITTLENUM
;
4300 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4301 while (size
>= CHARS_PER_LITTLENUM
)
4304 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4305 size
-= CHARS_PER_LITTLENUM
;
4306 p
+= CHARS_PER_LITTLENUM
;
4311 nums
= generic_bignum
;
4312 while (size
>= CHARS_PER_LITTLENUM
)
4314 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4316 size
-= CHARS_PER_LITTLENUM
;
4317 p
+= CHARS_PER_LITTLENUM
;
4318 nbytes
-= CHARS_PER_LITTLENUM
;
4321 while (nbytes
>= CHARS_PER_LITTLENUM
)
4323 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4324 nbytes
-= CHARS_PER_LITTLENUM
;
4325 p
+= CHARS_PER_LITTLENUM
;
4330 emit_expr_fix (exp
, nbytes
, frag_now
, p
);
4334 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
)
4336 memset (p
, 0, nbytes
);
4338 /* Generate a fixS to record the symbol value. */
4340 #ifdef TC_CONS_FIX_NEW
4341 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
, nbytes
, exp
);
4344 bfd_reloc_code_real_type r
;
4364 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
4368 fix_new_exp (frag
, p
- frag
->fr_literal
, (int) nbytes
, exp
,
4374 #ifdef BITFIELD_CONS_EXPRESSIONS
4376 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4377 w:x,y:z, where w and y are bitwidths and x and y are values. They
4378 then pack them all together. We do a little better in that we allow
4379 them in words, longs, etc. and we'll pack them in target byte order
4382 The rules are: pack least significant bit first, if a field doesn't
4383 entirely fit, put it in the next unit. Overflowing the bitfield is
4384 explicitly *not* even a warning. The bitwidth should be considered
4387 To use this function the tc-XXX.h file should define
4388 BITFIELD_CONS_EXPRESSIONS. */
4391 parse_bitfield_cons (exp
, nbytes
)
4393 unsigned int nbytes
;
4395 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4396 char *hold
= input_line_pointer
;
4398 (void) expression (exp
);
4400 if (*input_line_pointer
== ':')
4407 unsigned long width
;
4409 if (*input_line_pointer
!= ':')
4411 input_line_pointer
= hold
;
4413 } /* Next piece is not a bitfield. */
4415 /* In the general case, we can't allow
4416 full expressions with symbol
4417 differences and such. The relocation
4418 entries for symbols not defined in this
4419 assembly would require arbitrary field
4420 widths, positions, and masks which most
4421 of our current object formats don't
4424 In the specific case where a symbol
4425 *is* defined in this assembly, we
4426 *could* build fixups and track it, but
4427 this could lead to confusion for the
4428 backends. I'm lazy. I'll take any
4429 SEG_ABSOLUTE. I think that means that
4430 you can use a previous .set or
4431 .equ type symbol. xoxorich. */
4433 if (exp
->X_op
== O_absent
)
4435 as_warn (_("using a bit field width of zero"));
4436 exp
->X_add_number
= 0;
4437 exp
->X_op
= O_constant
;
4438 } /* Implied zero width bitfield. */
4440 if (exp
->X_op
!= O_constant
)
4442 *input_line_pointer
= '\0';
4443 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4444 *input_line_pointer
= ':';
4445 demand_empty_rest_of_line ();
4447 } /* Too complex. */
4449 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4451 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4452 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4453 width
= BITS_PER_CHAR
* nbytes
;
4456 if (width
> bits_available
)
4458 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4459 input_line_pointer
= hold
;
4460 exp
->X_add_number
= value
;
4465 hold
= ++input_line_pointer
;
4467 (void) expression (exp
);
4468 if (exp
->X_op
!= O_constant
)
4470 char cache
= *input_line_pointer
;
4472 *input_line_pointer
= '\0';
4473 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4474 *input_line_pointer
= cache
;
4475 demand_empty_rest_of_line ();
4477 } /* Too complex. */
4479 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4480 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4482 if ((bits_available
-= width
) == 0
4483 || is_it_end_of_statement ()
4484 || *input_line_pointer
!= ',')
4487 } /* All the bitfields we're gonna get. */
4489 hold
= ++input_line_pointer
;
4490 (void) expression (exp
);
4493 exp
->X_add_number
= value
;
4494 exp
->X_op
= O_constant
;
4495 exp
->X_unsigned
= 1;
4499 #endif /* BITFIELD_CONS_EXPRESSIONS */
4501 /* Handle an MRI style string expression. */
4505 parse_mri_cons (exp
, nbytes
)
4507 unsigned int nbytes
;
4509 if (*input_line_pointer
!= '\''
4510 && (input_line_pointer
[1] != '\''
4511 || (*input_line_pointer
!= 'A'
4512 && *input_line_pointer
!= 'E')))
4513 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4517 unsigned int result
= 0;
4519 /* An MRI style string. Cut into as many bytes as will fit into
4520 a nbyte chunk, left justify if necessary, and separate with
4521 commas so we can try again later. */
4522 if (*input_line_pointer
== 'A')
4523 ++input_line_pointer
;
4524 else if (*input_line_pointer
== 'E')
4526 as_bad (_("EBCDIC constants are not supported"));
4527 ++input_line_pointer
;
4530 input_line_pointer
++;
4531 for (scan
= 0; scan
< nbytes
; scan
++)
4533 if (*input_line_pointer
== '\'')
4535 if (input_line_pointer
[1] == '\'')
4537 input_line_pointer
++;
4542 result
= (result
<< 8) | (*input_line_pointer
++);
4546 while (scan
< nbytes
)
4552 /* Create correct expression. */
4553 exp
->X_op
= O_constant
;
4554 exp
->X_add_number
= result
;
4556 /* Fake it so that we can read the next char too. */
4557 if (input_line_pointer
[0] != '\'' ||
4558 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4560 input_line_pointer
-= 2;
4561 input_line_pointer
[0] = ',';
4562 input_line_pointer
[1] = '\'';
4565 input_line_pointer
++;
4568 #endif /* TC_M68K */
4570 #ifdef REPEAT_CONS_EXPRESSIONS
4572 /* Parse a repeat expression for cons. This is used by the MIPS
4573 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4574 object file COUNT times.
4576 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4579 parse_repeat_cons (exp
, nbytes
)
4581 unsigned int nbytes
;
4588 if (*input_line_pointer
!= ':')
4590 /* No repeat count. */
4594 ++input_line_pointer
;
4595 expression (&count
);
4596 if (count
.X_op
!= O_constant
4597 || count
.X_add_number
<= 0)
4599 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4603 /* The cons function is going to output this expression once. So we
4604 output it count - 1 times. */
4605 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4606 emit_expr (exp
, nbytes
);
4609 #endif /* REPEAT_CONS_EXPRESSIONS */
4611 /* Parse a floating point number represented as a hex constant. This
4612 permits users to specify the exact bits they want in the floating
4616 hex_float (int float_type
, char *bytes
)
4648 as_bad (_("unknown floating type type '%c'"), float_type
);
4652 /* It would be nice if we could go through expression to parse the
4653 hex constant, but if we get a bignum it's a pain to sort it into
4654 the buffer correctly. */
4656 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4660 /* The MRI assembler accepts arbitrary underscores strewn about
4661 through the hex constant, so we ignore them as well. */
4662 if (*input_line_pointer
== '_')
4664 ++input_line_pointer
;
4670 as_warn (_("floating point constant too large"));
4673 d
= hex_value (*input_line_pointer
) << 4;
4674 ++input_line_pointer
;
4675 while (*input_line_pointer
== '_')
4676 ++input_line_pointer
;
4677 if (hex_p (*input_line_pointer
))
4679 d
+= hex_value (*input_line_pointer
);
4680 ++input_line_pointer
;
4682 if (target_big_endian
)
4685 bytes
[length
- i
- 1] = d
;
4691 if (target_big_endian
)
4692 memset (bytes
+ i
, 0, length
- i
);
4694 memset (bytes
, 0, length
- i
);
4702 CONStruct some more frag chars of .floats .ffloats etc.
4703 Makes 0 or more new frags.
4704 If need_pass_2 == 1, no frags are emitted.
4705 This understands only floating literals, not expressions. Sorry.
4707 A floating constant is defined by atof_generic(), except it is preceded
4708 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4709 reading, I decided to be incompatible. This always tries to give you
4710 rounded bits to the precision of the pseudo-op. Former AS did premature
4711 truncation, restored noisy bits instead of trailing 0s AND gave you
4712 a choice of 2 flavours of noise according to which of 2 floating-point
4713 scanners you directed AS to use.
4715 In: input_line_pointer->whitespace before, or '0' of flonum. */
4718 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4719 int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4722 int length
; /* Number of chars in an object. */
4723 char *err
; /* Error from scanning floating literal. */
4724 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4726 if (is_it_end_of_statement ())
4728 demand_empty_rest_of_line ();
4732 #ifdef md_flush_pending_output
4733 md_flush_pending_output ();
4736 #ifdef md_cons_align
4742 /* input_line_pointer->1st char of a flonum (we hope!). */
4745 /* Skip any 0{letter} that may be present. Don't even check if the
4746 letter is legal. Someone may invent a "z" format and this routine
4747 has no use for such information. Lusers beware: you get
4748 diagnostics if your input is ill-conditioned. */
4749 if (input_line_pointer
[0] == '0'
4750 && ISALPHA (input_line_pointer
[1]))
4751 input_line_pointer
+= 2;
4753 /* Accept :xxxx, where the x's are hex digits, for a floating
4754 point with the exact digits specified. */
4755 if (input_line_pointer
[0] == ':')
4757 ++input_line_pointer
;
4758 length
= hex_float (float_type
, temp
);
4761 ignore_rest_of_line ();
4767 err
= md_atof (float_type
, temp
, &length
);
4768 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4769 know (err
!= NULL
|| length
> 0);
4772 as_bad (_("bad floating literal: %s"), err
);
4773 ignore_rest_of_line ();
4784 #ifdef REPEAT_CONS_EXPRESSIONS
4785 if (*input_line_pointer
== ':')
4787 expressionS count_exp
;
4789 ++input_line_pointer
;
4790 expression (&count_exp
);
4792 if (count_exp
.X_op
!= O_constant
4793 || count_exp
.X_add_number
<= 0)
4794 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4796 count
= count_exp
.X_add_number
;
4800 while (--count
>= 0)
4802 p
= frag_more (length
);
4803 memcpy (p
, temp
, (unsigned int) length
);
4808 while (*input_line_pointer
++ == ',');
4810 /* Put terminator back into stream. */
4811 --input_line_pointer
;
4812 demand_empty_rest_of_line ();
4815 /* Return the size of a LEB128 value. */
4818 sizeof_sleb128 (offsetT value
)
4825 byte
= (value
& 0x7f);
4826 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4827 Fortunately, we can structure things so that the extra work reduces
4828 to a noop on systems that do things "properly". */
4829 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4832 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4833 || ((value
== -1) && ((byte
& 0x40) != 0))));
4839 sizeof_uleb128 (valueT value
)
4854 sizeof_leb128 (valueT value
, int sign
)
4857 return sizeof_sleb128 ((offsetT
) value
);
4859 return sizeof_uleb128 (value
);
4862 /* Output a LEB128 value. */
4865 output_sleb128 (char *p
, offsetT value
)
4872 unsigned byte
= (value
& 0x7f);
4874 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4875 Fortunately, we can structure things so that the extra work reduces
4876 to a noop on systems that do things "properly". */
4877 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4879 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4880 || ((value
== -1) && ((byte
& 0x40) != 0))));
4892 output_uleb128 (char *p
, valueT value
)
4898 unsigned byte
= (value
& 0x7f);
4901 /* More bytes to follow. */
4912 output_leb128 (char *p
, valueT value
, int sign
)
4915 return output_sleb128 (p
, (offsetT
) value
);
4917 return output_uleb128 (p
, value
);
4920 /* Do the same for bignums. We combine sizeof with output here in that
4921 we don't output for NULL values of P. It isn't really as critical as
4922 for "normal" values that this be streamlined. */
4925 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4932 /* Strip leading sign extensions off the bignum. */
4934 && bignum
[size
- 1] == LITTLENUM_MASK
4935 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
4940 /* OR in the next part of the littlenum. */
4941 val
|= (*bignum
<< loaded
);
4942 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
4946 /* Add bytes until there are less than 7 bits left in VAL
4947 or until every non-sign bit has been written. */
4954 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
4961 while ((byte
& 0x80) != 0 && loaded
>= 7);
4965 /* Mop up any left-over bits (of which there will be less than 7). */
4966 if ((byte
& 0x80) != 0)
4968 /* Sign-extend VAL. */
4969 if (val
& (1 << (loaded
- 1)))
4970 val
|= ~0 << loaded
;
4980 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4987 /* Strip leading zeros off the bignum. */
4988 /* XXX: Is this needed? */
4989 while (size
> 0 && bignum
[size
- 1] == 0)
4994 if (loaded
< 7 && size
> 0)
4996 val
|= (*bignum
<< loaded
);
4997 loaded
+= 8 * CHARS_PER_LITTLENUM
;
5006 if (size
> 0 || val
)
5013 while (byte
& 0x80);
5019 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
5022 return output_big_sleb128 (p
, bignum
, size
);
5024 return output_big_uleb128 (p
, bignum
, size
);
5027 /* Generate the appropriate fragments for a given expression to emit a
5031 emit_leb128_expr (expressionS
*exp
, int sign
)
5033 operatorT op
= exp
->X_op
;
5034 unsigned int nbytes
;
5036 if (op
== O_absent
|| op
== O_illegal
)
5038 as_warn (_("zero assumed for missing expression"));
5039 exp
->X_add_number
= 0;
5042 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5044 as_bad (_("floating point number invalid"));
5045 exp
->X_add_number
= 0;
5048 else if (op
== O_register
)
5050 as_warn (_("register value used as expression"));
5053 else if (op
== O_constant
5055 && (exp
->X_add_number
< 0) != !exp
->X_unsigned
)
5057 /* We're outputting a signed leb128 and the sign of X_add_number
5058 doesn't reflect the sign of the original value. Convert EXP
5059 to a correctly-extended bignum instead. */
5060 convert_to_bignum (exp
);
5064 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5065 a signal that this is leb128 data. It shouldn't optimize this away. */
5066 nbytes
= (unsigned int) -1;
5067 if (check_eh_frame (exp
, &nbytes
))
5070 /* Let the backend know that subsequent data may be byte aligned. */
5071 #ifdef md_cons_align
5075 if (op
== O_constant
)
5077 /* If we've got a constant, emit the thing directly right now. */
5079 valueT value
= exp
->X_add_number
;
5083 size
= sizeof_leb128 (value
, sign
);
5084 p
= frag_more (size
);
5085 output_leb128 (p
, value
, sign
);
5087 else if (op
== O_big
)
5089 /* O_big is a different sort of constant. */
5094 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
5095 p
= frag_more (size
);
5096 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
5100 /* Otherwise, we have to create a variable sized fragment and
5101 resolve things later. */
5103 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5104 make_expr_symbol (exp
), 0, (char *) NULL
);
5108 /* Parse the .sleb128 and .uleb128 pseudos. */
5115 #ifdef md_flush_pending_output
5116 md_flush_pending_output ();
5122 emit_leb128_expr (&exp
, sign
);
5124 while (*input_line_pointer
++ == ',');
5126 input_line_pointer
--;
5127 demand_empty_rest_of_line ();
5131 stringer_append_char (int c
, int bitsize
)
5133 if (!target_big_endian
)
5134 FRAG_APPEND_1_CHAR (c
);
5139 FRAG_APPEND_1_CHAR (0);
5140 FRAG_APPEND_1_CHAR (0);
5141 FRAG_APPEND_1_CHAR (0);
5142 FRAG_APPEND_1_CHAR (0);
5145 FRAG_APPEND_1_CHAR (0);
5146 FRAG_APPEND_1_CHAR (0);
5149 FRAG_APPEND_1_CHAR (0);
5154 /* Called with invalid bitsize argument. */
5158 if (target_big_endian
)
5159 FRAG_APPEND_1_CHAR (c
);
5162 /* Worker to do .ascii etc statements.
5163 Reads 0 or more ',' separated, double-quoted strings.
5164 Caller should have checked need_pass_2 is FALSE because we don't
5166 Checks for end-of-line.
5167 BITS_APPENDZERO says how many bits are in a target char.
5168 The bottom bit is set if a NUL char should be appended to the strings. */
5171 stringer (int bits_appendzero
)
5173 const int bitsize
= bits_appendzero
& ~7;
5174 const int append_zero
= bits_appendzero
& 1;
5176 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5180 #ifdef md_flush_pending_output
5181 md_flush_pending_output ();
5184 #ifdef md_cons_align
5188 /* The following awkward logic is to parse ZERO or more strings,
5189 comma separated. Recall a string expression includes spaces
5190 before the opening '\"' and spaces after the closing '\"'.
5191 We fake a leading ',' if there is (supposed to be)
5192 a 1st, expression. We keep demanding expressions for each ','. */
5193 if (is_it_end_of_statement ())
5195 c
= 0; /* Skip loop. */
5196 ++input_line_pointer
; /* Compensate for end of loop. */
5200 c
= ','; /* Do loop. */
5202 /* If we have been switched into the abs_section then we
5203 will not have an obstack onto which we can hang strings. */
5204 if (now_seg
== absolute_section
)
5206 as_bad (_("strings must be placed into a section"));
5208 ignore_rest_of_line ();
5211 while (c
== ',' || c
== '<' || c
== '"')
5214 switch (*input_line_pointer
)
5217 ++input_line_pointer
; /*->1st char of string. */
5218 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5219 start
= input_line_pointer
;
5222 while (is_a_char (c
= next_char_of_string ()))
5223 stringer_append_char (c
, bitsize
);
5226 stringer_append_char (0, bitsize
);
5228 know (input_line_pointer
[-1] == '\"');
5230 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5231 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5232 will emit .string with a filename in the .debug section
5233 after a sequence of constants. See the comment in
5234 emit_expr for the sequence. emit_expr will set
5235 dwarf_file_string to non-zero if this string might be a
5236 source file name. */
5237 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5238 dwarf_file_string
= 0;
5239 else if (dwarf_file_string
)
5241 c
= input_line_pointer
[-1];
5242 input_line_pointer
[-1] = '\0';
5243 listing_source_file (start
);
5244 input_line_pointer
[-1] = c
;
5250 input_line_pointer
++;
5251 c
= get_single_number ();
5252 stringer_append_char (c
, bitsize
);
5253 if (*input_line_pointer
!= '>')
5254 as_bad (_("expected <nn>"));
5256 input_line_pointer
++;
5259 input_line_pointer
++;
5263 c
= *input_line_pointer
;
5266 demand_empty_rest_of_line ();
5269 /* FIXME-SOMEDAY: I had trouble here on characters with the
5270 high bits set. We'll probably also have trouble with
5271 multibyte chars, wide chars, etc. Also be careful about
5272 returning values bigger than 1 byte. xoxorich. */
5275 next_char_of_string (void)
5279 c
= *input_line_pointer
++ & CHAR_MASK
;
5287 as_warn (_("unterminated string; newline inserted"));
5288 bump_line_counters ();
5291 #ifndef NO_STRING_ESCAPES
5293 switch (c
= *input_line_pointer
++)
5321 break; /* As itself. */
5337 for (i
= 0, number
= 0;
5338 ISDIGIT (c
) && i
< 3;
5339 c
= *input_line_pointer
++, i
++)
5341 number
= number
* 8 + c
- '0';
5346 --input_line_pointer
;
5355 c
= *input_line_pointer
++;
5356 while (ISXDIGIT (c
))
5359 number
= number
* 16 + c
- '0';
5360 else if (ISUPPER (c
))
5361 number
= number
* 16 + c
- 'A' + 10;
5363 number
= number
* 16 + c
- 'a' + 10;
5364 c
= *input_line_pointer
++;
5367 --input_line_pointer
;
5372 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5373 as_warn (_("unterminated string; newline inserted"));
5375 bump_line_counters ();
5380 #ifdef ONLY_STANDARD_ESCAPES
5381 as_bad (_("bad escaped character in string"));
5383 #endif /* ONLY_STANDARD_ESCAPES */
5388 #endif /* ! defined (NO_STRING_ESCAPES) */
5397 get_segmented_expression (expressionS
*expP
)
5401 retval
= expression (expP
);
5402 if (expP
->X_op
== O_illegal
5403 || expP
->X_op
== O_absent
5404 || expP
->X_op
== O_big
)
5406 as_bad (_("expected address expression"));
5407 expP
->X_op
= O_constant
;
5408 expP
->X_add_number
= 0;
5409 retval
= absolute_section
;
5415 get_known_segmented_expression (expressionS
*expP
)
5417 segT retval
= get_segmented_expression (expP
);
5419 if (retval
== undefined_section
)
5421 /* There is no easy way to extract the undefined symbol from the
5423 if (expP
->X_add_symbol
!= NULL
5424 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5425 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5426 S_GET_NAME (expP
->X_add_symbol
));
5428 as_warn (_("some symbol undefined; zero assumed"));
5429 retval
= absolute_section
;
5430 expP
->X_op
= O_constant
;
5431 expP
->X_add_number
= 0;
5436 char /* Return terminator. */
5437 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5439 /* FIXME: val_pointer should probably be offsetT *. */
5440 *val_pointer
= (long) get_absolute_expression ();
5441 return (*input_line_pointer
++);
5444 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5445 Give a warning if that happens. */
5448 demand_copy_C_string (int *len_pointer
)
5452 if ((s
= demand_copy_string (len_pointer
)) != 0)
5456 for (len
= *len_pointer
; len
> 0; len
--)
5463 as_bad (_("this string may not contain \'\\0\'"));
5471 /* Demand string, but return a safe (=private) copy of the string.
5472 Return NULL if we can't read a string here. */
5475 demand_copy_string (int *lenP
)
5483 if (*input_line_pointer
== '\"')
5485 input_line_pointer
++; /* Skip opening quote. */
5487 while (is_a_char (c
= next_char_of_string ()))
5489 obstack_1grow (¬es
, c
);
5492 /* JF this next line is so demand_copy_C_string will return a
5493 null terminated string. */
5494 obstack_1grow (¬es
, '\0');
5495 retval
= (char *) obstack_finish (¬es
);
5499 as_bad (_("missing string"));
5501 ignore_rest_of_line ();
5507 /* In: Input_line_pointer->next character.
5509 Do: Skip input_line_pointer over all whitespace.
5511 Out: 1 if input_line_pointer->end-of-line. */
5514 is_it_end_of_statement (void)
5517 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5521 equals (char *sym_name
, int reassign
)
5526 input_line_pointer
++;
5527 if (*input_line_pointer
== '=')
5528 input_line_pointer
++;
5529 if (reassign
< 0 && *input_line_pointer
== '=')
5530 input_line_pointer
++;
5532 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5533 input_line_pointer
++;
5536 stop
= mri_comment_field (&stopc
);
5538 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5542 demand_empty_rest_of_line ();
5543 mri_comment_end (stop
, stopc
);
5547 /* .incbin -- include a file verbatim at the current location. */
5550 s_incbin (int x ATTRIBUTE_UNUSED
)
5561 #ifdef md_flush_pending_output
5562 md_flush_pending_output ();
5565 #ifdef md_cons_align
5570 filename
= demand_copy_string (& len
);
5571 if (filename
== NULL
)
5576 /* Look for optional skip and count. */
5577 if (* input_line_pointer
== ',')
5579 ++ input_line_pointer
;
5580 skip
= get_absolute_expression ();
5584 if (* input_line_pointer
== ',')
5586 ++ input_line_pointer
;
5588 count
= get_absolute_expression ();
5590 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5596 demand_empty_rest_of_line ();
5598 /* Try opening absolute path first, then try include dirs. */
5599 binfile
= fopen (filename
, FOPEN_RB
);
5600 if (binfile
== NULL
)
5604 path
= (char *) xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5606 for (i
= 0; i
< include_dir_count
; i
++)
5608 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5610 binfile
= fopen (path
, FOPEN_RB
);
5611 if (binfile
!= NULL
)
5615 if (binfile
== NULL
)
5616 as_bad (_("file not found: %s"), filename
);
5619 path
= xstrdup (filename
);
5625 register_dependency (path
);
5627 /* Compute the length of the file. */
5628 if (fseek (binfile
, 0, SEEK_END
) != 0)
5630 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5633 file_len
= ftell (binfile
);
5635 /* If a count was not specified use the remainder of the file. */
5637 count
= file_len
- skip
;
5639 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5641 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5642 skip
, count
, file_len
);
5646 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5648 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5652 /* Allocate frag space and store file contents in it. */
5653 binfrag
= frag_more (count
);
5655 bytes
= fread (binfrag
, 1, count
, binfile
);
5657 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5658 path
, bytes
, count
);
5661 if (binfile
!= NULL
)
5667 /* .include -- include a file at this point. */
5670 s_include (int arg ATTRIBUTE_UNUSED
)
5679 filename
= demand_copy_string (&i
);
5680 if (filename
== NULL
)
5682 /* demand_copy_string has already printed an error and
5683 called ignore_rest_of_line. */
5691 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5692 && *input_line_pointer
!= ' '
5693 && *input_line_pointer
!= '\t')
5695 obstack_1grow (¬es
, *input_line_pointer
);
5696 ++input_line_pointer
;
5700 obstack_1grow (¬es
, '\0');
5701 filename
= (char *) obstack_finish (¬es
);
5702 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5703 ++input_line_pointer
;
5706 demand_empty_rest_of_line ();
5707 path
= (char *) xmalloc ((unsigned long) i
5708 + include_dir_maxlen
+ 5 /* slop */ );
5710 for (i
= 0; i
< include_dir_count
; i
++)
5712 strcpy (path
, include_dirs
[i
]);
5714 strcat (path
, filename
);
5715 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5725 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5726 register_dependency (path
);
5727 input_scrub_insert_file (path
);
5731 add_include_dir (char *path
)
5735 if (include_dir_count
== 0)
5737 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5738 include_dirs
[0] = "."; /* Current dir. */
5739 include_dir_count
= 2;
5743 include_dir_count
++;
5745 (char **) realloc (include_dirs
,
5746 include_dir_count
* sizeof (*include_dirs
));
5749 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5752 if (i
> include_dir_maxlen
)
5753 include_dir_maxlen
= i
;
5756 /* Output debugging information to denote the source file. */
5759 generate_file_debug (void)
5761 if (debug_type
== DEBUG_STABS
)
5762 stabs_generate_asm_file ();
5765 /* Output line number debugging information for the current source line. */
5768 generate_lineno_debug (void)
5772 case DEBUG_UNSPECIFIED
:
5777 stabs_generate_asm_lineno ();
5780 ecoff_generate_asm_lineno ();
5783 /* ??? We could here indicate to dwarf2dbg.c that something
5784 has changed. However, since there is additional backend
5785 support that is required (calling dwarf2_emit_insn), we
5786 let dwarf2dbg.c call as_where on its own. */
5791 /* Output debugging information to mark a function entry point or end point.
5792 END_P is zero for .func, and non-zero for .endfunc. */
5797 do_s_func (end_p
, NULL
);
5800 /* Subroutine of s_func so targets can choose a different default prefix.
5801 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5804 do_s_func (int end_p
, const char *default_prefix
)
5806 /* Record the current function so that we can issue an error message for
5807 misplaced .func,.endfunc, and also so that .endfunc needs no
5809 static char *current_name
;
5810 static char *current_label
;
5814 if (current_name
== NULL
)
5816 as_bad (_("missing .func"));
5817 ignore_rest_of_line ();
5821 if (debug_type
== DEBUG_STABS
)
5822 stabs_generate_asm_endfunc (current_name
, current_label
);
5824 current_name
= current_label
= NULL
;
5829 char delim1
, delim2
;
5831 if (current_name
!= NULL
)
5833 as_bad (_(".endfunc missing for previous .func"));
5834 ignore_rest_of_line ();
5838 name
= input_line_pointer
;
5839 delim1
= get_symbol_end ();
5840 name
= xstrdup (name
);
5841 *input_line_pointer
= delim1
;
5843 if (*input_line_pointer
!= ',')
5847 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5848 as_fatal ("%s", xstrerror (errno
));
5852 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5853 /* Missing entry point, use function's name with the leading
5857 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
5858 as_fatal ("%s", xstrerror (errno
));
5866 ++input_line_pointer
;
5868 label
= input_line_pointer
;
5869 delim2
= get_symbol_end ();
5870 label
= xstrdup (label
);
5871 *input_line_pointer
= delim2
;
5874 if (debug_type
== DEBUG_STABS
)
5875 stabs_generate_asm_func (name
, label
);
5877 current_name
= name
;
5878 current_label
= label
;
5881 demand_empty_rest_of_line ();
5885 s_ignore (int arg ATTRIBUTE_UNUSED
)
5887 ignore_rest_of_line ();
5891 read_print_statistics (FILE *file
)
5893 hash_print_statistics (file
, "pseudo-op table", po_hash
);
5896 /* Inserts the given line into the input stream.
5898 This call avoids macro/conditionals nesting checking, since the contents of
5899 the line are assumed to replace the contents of a line already scanned.
5901 An appropriate use of this function would be substitution of input lines when
5902 called by md_start_line_hook(). The given line is assumed to already be
5903 properly scrubbed. */
5906 input_scrub_insert_line (const char *line
)
5910 sb_add_string (&newline
, line
);
5911 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
5913 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5916 /* Insert a file into the input stream; the path must resolve to an actual
5917 file; no include path searching or dependency registering is performed. */
5920 input_scrub_insert_file (char *path
)
5922 input_scrub_include_file (path
, input_line_pointer
);
5923 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5926 /* Find the end of a line, considering quotation and escaping of quotes. */
5928 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5929 # define TC_SINGLE_QUOTE_STRINGS 1
5933 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
5936 char inquote
= '\0';
5939 while (!is_end_of_line
[(unsigned char) *s
]
5940 || (inquote
&& !ISCNTRL (*s
))
5941 || (inquote
== '\'' && flag_mri
)
5942 #ifdef TC_EOL_IN_INSN
5943 || (insn
&& TC_EOL_IN_INSN (s
))
5945 /* PR 6926: When we are parsing the body of a macro the sequence
5946 \@ is special - it refers to the invocation count. If the @
5947 character happens to be registered as a line-separator character
5948 by the target, then the is_end_of_line[] test above will have
5949 returned true, but we need to ignore the line separating
5950 semantics in this particular case. */
5951 || (in_macro
&& inescape
&& *s
== '@')
5954 if (mri_string
&& *s
== '\'')
5958 else if (*s
== '\\')
5962 #ifdef TC_SINGLE_QUOTE_STRINGS
5963 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
5970 as_warn (_("missing closing `%c'"), inquote
);
5972 as_warn (_("stray `\\'"));
5977 find_end_of_line (char *s
, int mri_string
)
5979 return _find_end_of_line (s
, mri_string
, 0, 0);