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 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", listing_flags
, 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
);
524 #ifdef TARGET_USE_CFIPOP
525 pop_table_name
= "cfi";
531 #define HANDLE_CONDITIONAL_ASSEMBLY() \
532 if (ignore_input ()) \
534 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
535 input_line_pointer = (input_line_pointer <= buffer_limit \
536 && eol >= buffer_limit) \
542 /* This function is used when scrubbing the characters between #APP
545 static char *scrub_string
;
546 static char *scrub_string_end
;
549 scrub_from_string (char *buf
, int buflen
)
553 copy
= scrub_string_end
- scrub_string
;
556 memcpy (buf
, scrub_string
, copy
);
557 scrub_string
+= copy
;
561 /* Helper function of read_a_source_file, which tries to expand a macro. */
563 try_macro (char term
, const char *line
)
569 if (check_macro (line
, &out
, &err
, ¯o
))
573 *input_line_pointer
++ = term
;
574 input_scrub_include_sb (&out
,
575 input_line_pointer
, 1);
578 input_scrub_next_buffer (&input_line_pointer
);
580 md_macro_info (macro
);
587 /* We read the file, putting things into a web that represents what we
588 have been reading. */
590 read_a_source_file (char *name
)
593 register char *s
; /* String of symbol, '\0' appended. */
601 buffer
= input_scrub_new_file (name
);
604 listing_newline (NULL
);
605 register_dependency (name
);
607 /* Generate debugging information before we've read anything in to denote
608 this file as the "main" source file and not a subordinate one
609 (e.g. N_SO vs N_SOL in stabs). */
610 generate_file_debug ();
612 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
613 { /* We have another line to parse. */
615 /* In order to avoid listing macro expansion lines with labels
616 multiple times, keep track of which line was last issued. */
617 static char *last_eol
;
621 while (input_line_pointer
< buffer_limit
)
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 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
630 #ifdef md_start_line_hook
631 md_start_line_hook ();
633 if (input_line_pointer
[-1] == '\n')
634 bump_line_counters ();
638 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
640 /* Text at the start of a line must be a label, we
641 run down and stick a colon in. */
642 if (is_name_beginner (*input_line_pointer
))
644 char *line_start
= input_line_pointer
;
649 HANDLE_CONDITIONAL_ASSEMBLY ();
651 c
= get_symbol_end ();
653 /* In MRI mode, the EQU and MACRO pseudoops must
654 be handled specially. */
658 char *rest
= input_line_pointer
+ 1;
662 if (*rest
== ' ' || *rest
== '\t')
664 if ((strncasecmp (rest
, "EQU", 3) == 0
665 || strncasecmp (rest
, "SET", 3) == 0)
666 && (rest
[3] == ' ' || rest
[3] == '\t'))
668 input_line_pointer
= rest
+ 3;
670 strncasecmp (rest
, "SET", 3) == 0);
673 if (strncasecmp (rest
, "MACRO", 5) == 0
676 || is_end_of_line
[(unsigned char) rest
[5]]))
680 /* In MRI mode, we need to handle the MACRO
681 pseudo-op specially: we don't want to put the
682 symbol in the symbol table. */
684 #ifdef TC_START_LABEL_WITHOUT_COLON
685 && TC_START_LABEL_WITHOUT_COLON(c
,
689 line_label
= colon (line_start
);
691 line_label
= symbol_create (line_start
,
696 *input_line_pointer
= c
;
698 input_line_pointer
++;
703 /* We are at the beginning of a line, or similar place.
704 We expect a well-formed assembler statement.
705 A "symbol-name:" is a statement.
707 Depending on what compiler is used, the order of these tests
708 may vary to catch most common case 1st.
709 Each test is independent of all other tests at the (top)
712 c
= *input_line_pointer
++;
713 while (c
== '\t' || c
== ' ' || c
== '\f');
716 /* If listing is on, and we are expanding a macro, then give
717 the listing code the contents of the expanded line. */
720 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
725 /* Find the end of the current expanded macro line. */
726 s
= find_end_of_line (input_line_pointer
- 1, flag_m68k_mri
);
731 /* Copy it for safe keeping. Also give an indication of
732 how much macro nesting is involved at this point. */
733 len
= s
- (input_line_pointer
- 1);
734 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
735 memset (copy
, '>', macro_nest
);
736 copy
[macro_nest
] = ' ';
737 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
- 1, len
);
738 copy
[macro_nest
+ 1 + len
] = '\0';
740 /* Install the line with the listing facility. */
741 listing_newline (copy
);
745 listing_newline (NULL
);
748 /* C is the 1st significant character.
749 Input_line_pointer points after that character. */
750 if (is_name_beginner (c
))
752 /* Want user-defined label or pseudo/opcode. */
753 HANDLE_CONDITIONAL_ASSEMBLY ();
755 s
= --input_line_pointer
;
756 c
= get_symbol_end (); /* name's delimiter. */
758 /* C is character after symbol.
759 That character's place in the input line is now '\0'.
760 S points to the beginning of the symbol.
761 [In case of pseudo-op, s->'.'.]
762 Input_line_pointer->'\0' where c was. */
763 if (TC_START_LABEL (c
, s
, input_line_pointer
))
767 char *rest
= input_line_pointer
+ 1;
769 /* In MRI mode, \tsym: set 0 is permitted. */
773 if (*rest
== ' ' || *rest
== '\t')
776 if ((strncasecmp (rest
, "EQU", 3) == 0
777 || strncasecmp (rest
, "SET", 3) == 0)
778 && (rest
[3] == ' ' || rest
[3] == '\t'))
780 input_line_pointer
= rest
+ 3;
786 line_label
= colon (s
); /* User-defined label. */
787 /* Put ':' back for error messages' sake. */
788 *input_line_pointer
++ = ':';
789 #ifdef tc_check_label
790 tc_check_label (line_label
);
792 /* Input_line_pointer->after ':'. */
795 else if ((c
== '=' && input_line_pointer
[1] == '=')
796 || ((c
== ' ' || c
== '\t')
797 && input_line_pointer
[1] == '='
798 && input_line_pointer
[2] == '='))
801 demand_empty_rest_of_line ();
804 || ((c
== ' ' || c
== '\t')
805 && input_line_pointer
[1] == '='))
806 #ifdef TC_EQUAL_IN_INSN
807 && !TC_EQUAL_IN_INSN (c
, s
)
812 demand_empty_rest_of_line ();
816 /* Expect pseudo-op or machine instruction. */
819 #ifndef TC_CASE_SENSITIVE
823 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
824 original_case_string
[sizeof (original_case_string
) - 1] = 0;
833 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
835 /* The MRI assembler uses pseudo-ops without
837 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
838 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
843 || (!flag_m68k_mri
&& *s
== '.'))
847 WARNING: c has next char, which may be end-of-line.
848 We lookup the pseudo-op table with s+1 because we
849 already know that the pseudo-op begins with a '.'. */
852 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
853 if (pop
&& !pop
->poc_handler
)
856 /* In MRI mode, we may need to insert an
857 automatic alignment directive. What a hack
859 if (mri_pending_align
861 || !((pop
->poc_handler
== cons
862 && pop
->poc_val
== 1)
863 || (pop
->poc_handler
== s_space
864 && pop
->poc_val
== 1)
865 #ifdef tc_conditional_pseudoop
866 || tc_conditional_pseudoop (pop
)
868 || pop
->poc_handler
== s_if
869 || pop
->poc_handler
== s_ifdef
870 || pop
->poc_handler
== s_ifc
871 || pop
->poc_handler
== s_ifeqs
872 || pop
->poc_handler
== s_else
873 || pop
->poc_handler
== s_endif
874 || pop
->poc_handler
== s_globl
875 || pop
->poc_handler
== s_ignore
)))
877 do_align (1, (char *) NULL
, 0, 0);
878 mri_pending_align
= 0;
880 if (line_label
!= NULL
)
882 symbol_set_frag (line_label
, frag_now
);
883 S_SET_VALUE (line_label
, frag_now_fix ());
887 /* Print the error msg now, while we still can. */
890 char *end
= input_line_pointer
;
892 *input_line_pointer
= c
;
894 c
= *--input_line_pointer
;
895 *input_line_pointer
= '\0';
896 if (! macro_defined
|| ! try_macro (c
, s
))
899 as_bad (_("unknown pseudo-op: `%s'"), s
);
900 *input_line_pointer
++ = c
;
905 /* Put it back for error messages etc. */
906 *input_line_pointer
= c
;
907 /* The following skip of whitespace is compulsory.
908 A well shaped space is sometimes all that separates
909 keyword from operands. */
910 if (c
== ' ' || c
== '\t')
911 input_line_pointer
++;
913 /* Input_line is restored.
914 Input_line_pointer->1st non-blank char
915 after pseudo-operation. */
916 (*pop
->poc_handler
) (pop
->poc_val
);
918 /* If that was .end, just get out now. */
919 if (pop
->poc_handler
== s_end
)
924 /* WARNING: c has char, which may be end-of-line. */
925 /* Also: input_line_pointer->`\0` where c was. */
926 *input_line_pointer
= c
;
927 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1, 0);
928 c
= *input_line_pointer
;
929 *input_line_pointer
= '\0';
931 generate_lineno_debug ();
933 if (macro_defined
&& try_macro (c
, s
))
936 if (mri_pending_align
)
938 do_align (1, (char *) NULL
, 0, 0);
939 mri_pending_align
= 0;
940 if (line_label
!= NULL
)
942 symbol_set_frag (line_label
, frag_now
);
943 S_SET_VALUE (line_label
, frag_now_fix ());
947 md_assemble (s
); /* Assemble 1 instruction. */
949 *input_line_pointer
++ = c
;
951 /* We resume loop AFTER the end-of-line from
958 /* Empty statement? */
959 if (is_end_of_line
[(unsigned char) c
])
962 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (c
))
964 /* local label ("4:") */
965 char *backup
= input_line_pointer
;
967 HANDLE_CONDITIONAL_ASSEMBLY ();
971 /* Read the whole number. */
972 while (ISDIGIT (*input_line_pointer
))
974 temp
= (temp
* 10) + *input_line_pointer
- '0';
975 ++input_line_pointer
;
978 if (LOCAL_LABELS_DOLLAR
979 && *input_line_pointer
== '$'
980 && *(input_line_pointer
+ 1) == ':')
982 input_line_pointer
+= 2;
984 if (dollar_label_defined (temp
))
986 as_fatal (_("label \"%d$\" redefined"), temp
);
989 define_dollar_label (temp
);
990 colon (dollar_label_name (temp
, 0));
995 && *input_line_pointer
++ == ':')
997 fb_label_instance_inc (temp
);
998 colon (fb_label_name (temp
, 0));
1002 input_line_pointer
= backup
;
1003 } /* local label ("4:") */
1005 if (c
&& strchr (line_comment_chars
, c
))
1006 { /* Its a comment. Better say APP or NO_APP. */
1011 unsigned int new_length
;
1014 s
= input_line_pointer
;
1015 if (strncmp (s
, "APP\n", 4))
1018 ignore_rest_of_line ();
1021 bump_line_counters ();
1025 ends
= strstr (s
, "#NO_APP\n");
1029 unsigned int tmp_len
;
1032 /* The end of the #APP wasn't in this buffer. We
1033 keep reading in buffers until we find the #NO_APP
1034 that goes with this #APP There is one. The specs
1036 tmp_len
= buffer_limit
- s
;
1037 tmp_buf
= (char *) xmalloc (tmp_len
+ 1);
1038 memcpy (tmp_buf
, s
, tmp_len
);
1041 new_tmp
= input_scrub_next_buffer (&buffer
);
1045 buffer_limit
= new_tmp
;
1046 input_line_pointer
= buffer
;
1047 ends
= strstr (buffer
, "#NO_APP\n");
1049 num
= ends
- buffer
;
1051 num
= buffer_limit
- buffer
;
1053 tmp_buf
= (char *) xrealloc (tmp_buf
, tmp_len
+ num
);
1054 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1059 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1067 input_line_pointer
= ends
+ 8;
1071 scrub_string_end
= ends
;
1073 new_length
= ends
- s
;
1074 new_buf
= (char *) xmalloc (new_length
);
1081 space
= (new_buf
+ new_length
) - new_tmp
;
1082 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1090 new_buf
= (char *) xrealloc (new_buf
, new_length
+ 100);
1091 new_tmp
= new_buf
+ new_length
;
1098 /* We've "scrubbed" input to the preferred format. In the
1099 process we may have consumed the whole of the remaining
1100 file (and included files). We handle this formatted
1101 input similar to that of macro expansion, letting
1102 actual macro expansion (possibly nested) and other
1103 input expansion work. Beware that in messages, line
1104 numbers and possibly file names will be incorrect. */
1105 sb_add_string (&sbuf
, new_buf
);
1106 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1108 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1113 HANDLE_CONDITIONAL_ASSEMBLY ();
1115 #ifdef tc_unrecognized_line
1116 if (tc_unrecognized_line (c
))
1119 input_line_pointer
--;
1120 /* Report unknown char as error. */
1121 demand_empty_rest_of_line ();
1124 #ifdef md_after_pass_hook
1125 md_after_pass_hook ();
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
);
1612 if (line_label
!= NULL
)
1615 exp
.X_op
= O_symbol
;
1616 exp
.X_add_symbol
= sym
;
1617 exp
.X_add_number
= 0;
1618 symbol_set_value_expression (line_label
, &exp
);
1619 symbol_set_frag (line_label
, &zero_address_frag
);
1620 S_SET_SEGMENT (line_label
, expr_section
);
1623 /* FIXME: We just ignore the small argument, which distinguishes
1624 COMMON and COMMON.S. I don't know what we can do about it. */
1626 /* Ignore the type and hptype. */
1627 if (*input_line_pointer
== ',')
1628 input_line_pointer
+= 2;
1629 if (*input_line_pointer
== ',')
1630 input_line_pointer
+= 2;
1632 demand_empty_rest_of_line ();
1634 mri_comment_end (stop
, stopc
);
1638 s_data (int ignore ATTRIBUTE_UNUSED
)
1643 temp
= get_absolute_expression ();
1644 if (flag_readonly_data_in_text
)
1646 section
= text_section
;
1650 section
= data_section
;
1652 subseg_set (section
, (subsegT
) temp
);
1657 demand_empty_rest_of_line ();
1660 /* Handle the .appfile pseudo-op. This is automatically generated by
1661 do_scrub_chars when a preprocessor # line comment is seen with a
1662 file name. This default definition may be overridden by the object
1663 or CPU specific pseudo-ops. This function is also the default
1664 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1668 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1672 listing_source_file (file
);
1674 register_dependency (file
);
1676 obj_app_file (file
, appfile
);
1681 s_app_file (int appfile
)
1686 /* Some assemblers tolerate immediately following '"'. */
1687 if ((s
= demand_copy_string (&length
)) != 0)
1690 = (!new_logical_line_flags (s
, -1, 1) && appfile
);
1692 /* In MRI mode, the preprocessor may have inserted an extraneous
1695 && *input_line_pointer
== '\''
1696 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1697 ++input_line_pointer
;
1699 demand_empty_rest_of_line ();
1701 s_app_file_string (s
, appfile
);
1706 get_linefile_number (int *flag
)
1710 if (*input_line_pointer
< '0' || *input_line_pointer
> '9')
1713 *flag
= get_absolute_expression ();
1718 /* Handle the .appline pseudo-op. This is automatically generated by
1719 do_scrub_chars when a preprocessor # line comment is seen. This
1720 default definition may be overridden by the object or CPU specific
1724 s_app_line (int appline
)
1729 /* The given number is that of the next line. */
1731 l
= get_absolute_expression ();
1732 else if (!get_linefile_number (&l
))
1734 ignore_rest_of_line ();
1741 /* Some of the back ends can't deal with non-positive line numbers.
1742 Besides, it's silly. GCC however will generate a line number of
1743 zero when it is pre-processing builtins for assembler-with-cpp files:
1747 We do not want to barf on this, especially since such files are used
1748 in the GCC and GDB testsuites. So we check for negative line numbers
1749 rather than non-positive line numbers. */
1750 as_warn (_("line numbers must be positive; line number %d rejected"),
1761 if (*input_line_pointer
== '"')
1762 file
= demand_copy_string (&length
);
1768 while (get_linefile_number (&this_flag
))
1771 /* From GCC's cpp documentation:
1772 1: start of a new file.
1773 2: returning to a file after having included
1775 3: following text comes from a system header file.
1776 4: following text should be treated as extern "C".
1778 4 is nonsensical for the assembler; 3, we don't
1779 care about, so we ignore it just in case a
1780 system header file is included while
1781 preprocessing assembly. So 1 and 2 are all we
1782 care about, and they are mutually incompatible.
1783 new_logical_line_flags() demands this. */
1786 if (flags
&& flags
!= (1 << this_flag
))
1787 as_warn (_("incompatible flag %i in line directive"),
1790 flags
|= 1 << this_flag
;
1795 /* We ignore these. */
1799 as_warn (_("unsupported flag %i in line directive"),
1804 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
1809 if (appline
|| file
)
1811 new_logical_line_flags (file
, l
, flags
);
1814 listing_source_line (l
);
1818 if (appline
|| file
)
1819 demand_empty_rest_of_line ();
1821 ignore_rest_of_line ();
1824 /* Handle the .end pseudo-op. Actually, the real work is done in
1825 read_a_source_file. */
1828 s_end (int ignore ATTRIBUTE_UNUSED
)
1832 /* The MRI assembler permits the start symbol to follow .end,
1833 but we don't support that. */
1835 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
1836 && *input_line_pointer
!= '*'
1837 && *input_line_pointer
!= '!')
1838 as_warn (_("start address not supported"));
1842 /* Handle the .err pseudo-op. */
1845 s_err (int ignore ATTRIBUTE_UNUSED
)
1847 as_bad (_(".err encountered"));
1848 demand_empty_rest_of_line ();
1851 /* Handle the .error and .warning pseudo-ops. */
1857 /* The purpose for the conditional assignment is not to
1858 internationalize the directive itself, but that we need a
1859 self-contained message, one that can be passed like the
1860 demand_copy_C_string return value, and with no assumption on the
1861 location of the name of the directive within the message. */
1863 = (err
? _(".error directive invoked in source file")
1864 : _(".warning directive invoked in source file"));
1866 if (!is_it_end_of_statement ())
1868 if (*input_line_pointer
!= '\"')
1870 as_bad (_("%s argument must be a string"),
1871 err
? ".error" : ".warning");
1872 ignore_rest_of_line ();
1876 msg
= demand_copy_C_string (&len
);
1884 as_warn ("%s", msg
);
1885 demand_empty_rest_of_line ();
1888 /* Handle the MRI fail pseudo-op. */
1891 s_fail (int ignore ATTRIBUTE_UNUSED
)
1898 stop
= mri_comment_field (&stopc
);
1900 temp
= get_absolute_expression ();
1902 as_warn (_(".fail %ld encountered"), (long) temp
);
1904 as_bad (_(".fail %ld encountered"), (long) temp
);
1906 demand_empty_rest_of_line ();
1909 mri_comment_end (stop
, stopc
);
1913 s_fill (int ignore ATTRIBUTE_UNUSED
)
1915 expressionS rep_exp
;
1917 register long fill
= 0;
1920 #ifdef md_flush_pending_output
1921 md_flush_pending_output ();
1924 #ifdef md_cons_align
1928 get_known_segmented_expression (&rep_exp
);
1929 if (*input_line_pointer
== ',')
1931 input_line_pointer
++;
1932 size
= get_absolute_expression ();
1933 if (*input_line_pointer
== ',')
1935 input_line_pointer
++;
1936 fill
= get_absolute_expression ();
1940 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1941 #define BSD_FILL_SIZE_CROCK_8 (8)
1942 if (size
> BSD_FILL_SIZE_CROCK_8
)
1944 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
1945 size
= BSD_FILL_SIZE_CROCK_8
;
1949 as_warn (_("size negative; .fill ignored"));
1952 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
1954 if (rep_exp
.X_add_number
< 0)
1955 as_warn (_("repeat < 0; .fill ignored"));
1959 if (size
&& !need_pass_2
)
1961 if (rep_exp
.X_op
== O_constant
)
1963 p
= frag_var (rs_fill
, (int) size
, (int) size
,
1964 (relax_substateT
) 0, (symbolS
*) 0,
1965 (offsetT
) rep_exp
.X_add_number
,
1970 /* We don't have a constant repeat count, so we can't use
1971 rs_fill. We can get the same results out of rs_space,
1972 but its argument is in bytes, so we must multiply the
1973 repeat count by size. */
1976 rep_sym
= make_expr_symbol (&rep_exp
);
1979 expressionS size_exp
;
1980 size_exp
.X_op
= O_constant
;
1981 size_exp
.X_add_number
= size
;
1983 rep_exp
.X_op
= O_multiply
;
1984 rep_exp
.X_add_symbol
= rep_sym
;
1985 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
1986 rep_exp
.X_add_number
= 0;
1987 rep_sym
= make_expr_symbol (&rep_exp
);
1990 p
= frag_var (rs_space
, (int) size
, (int) size
,
1991 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
1994 memset (p
, 0, (unsigned int) size
);
1996 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1997 flavoured AS. The following bizarre behaviour is to be
1998 compatible with above. I guess they tried to take up to 8
1999 bytes from a 4-byte expression and they forgot to sign
2001 #define BSD_FILL_SIZE_CROCK_4 (4)
2002 md_number_to_chars (p
, (valueT
) fill
,
2003 (size
> BSD_FILL_SIZE_CROCK_4
2004 ? BSD_FILL_SIZE_CROCK_4
2006 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2007 but emits no error message because it seems a legal thing to do.
2008 It is a degenerate case of .fill but could be emitted by a
2011 demand_empty_rest_of_line ();
2015 s_globl (int ignore ATTRIBUTE_UNUSED
)
2024 stop
= mri_comment_field (&stopc
);
2028 name
= input_line_pointer
;
2029 c
= get_symbol_end ();
2030 symbolP
= symbol_find_or_make (name
);
2031 S_SET_EXTERNAL (symbolP
);
2033 *input_line_pointer
= c
;
2035 c
= *input_line_pointer
;
2038 input_line_pointer
++;
2040 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2046 demand_empty_rest_of_line ();
2049 mri_comment_end (stop
, stopc
);
2053 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
2056 skip_past_char (char ** str
, char c
)
2066 #define skip_past_comma(str) skip_past_char (str, ',')
2068 /* Parse an attribute directive for VENDOR.
2069 Returns the attribute number read, or zero on error. */
2071 s_vendor_attribute (int vendor
)
2079 /* Read the first number or name. */
2080 skip_whitespace (input_line_pointer
);
2081 s
= input_line_pointer
;
2082 if (ISDIGIT (*input_line_pointer
))
2085 if (exp
.X_op
!= O_constant
)
2087 tag
= exp
.X_add_number
;
2093 /* A name may contain '_', but no other punctuation. */
2094 for (; ISALNUM (*input_line_pointer
) || *input_line_pointer
== '_';
2095 ++input_line_pointer
)
2100 name
= (char *) alloca (i
+ 1);
2101 memcpy (name
, s
, i
);
2104 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2105 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2108 tag
= CONVERT_SYMBOLIC_ATTRIBUTE (name
);
2111 as_bad (_("Attribute name not recognised: %s"), name
);
2112 ignore_rest_of_line ();
2117 type
= _bfd_elf_obj_attrs_arg_type (stdoutput
, vendor
, tag
);
2119 if (skip_past_comma (&input_line_pointer
) == -1)
2124 if (exp
.X_op
!= O_constant
)
2126 as_bad (_("expected numeric constant"));
2127 ignore_rest_of_line ();
2130 i
= exp
.X_add_number
;
2133 && skip_past_comma (&input_line_pointer
) == -1)
2135 as_bad (_("expected comma"));
2136 ignore_rest_of_line ();
2143 skip_whitespace (input_line_pointer
);
2144 if (*input_line_pointer
!= '"')
2146 s
= demand_copy_C_string (&len
);
2152 bfd_elf_add_obj_attr_int_string (stdoutput
, vendor
, tag
, i
, s
);
2155 bfd_elf_add_obj_attr_string (stdoutput
, vendor
, tag
, s
);
2158 bfd_elf_add_obj_attr_int (stdoutput
, vendor
, tag
, i
);
2164 demand_empty_rest_of_line ();
2167 as_bad (_("bad string constant"));
2168 ignore_rest_of_line ();
2171 as_bad (_("expected <tag> , <value>"));
2172 ignore_rest_of_line ();
2176 /* Parse a .gnu_attribute directive. */
2179 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED
)
2181 s_vendor_attribute (OBJ_ATTR_GNU
);
2183 #endif /* OBJ_ELF */
2185 /* Handle the MRI IRP and IRPC pseudo-ops. */
2196 as_where (&file
, &line
);
2199 eol
= find_end_of_line (input_line_pointer
, 0);
2200 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2201 input_line_pointer
= eol
;
2205 err
= expand_irp (irpc
, 0, &s
, &out
, get_non_macro_line_sb
);
2207 as_bad_where (file
, line
, "%s", err
);
2211 input_scrub_include_sb (&out
, input_line_pointer
, 1);
2213 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2216 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2217 the section to only be linked once. However, this is not supported
2218 by most object file formats. This takes an optional argument,
2219 which is what to do about duplicates. */
2222 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
2224 enum linkonce_type type
;
2228 type
= LINKONCE_DISCARD
;
2230 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2235 s
= input_line_pointer
;
2236 c
= get_symbol_end ();
2237 if (strcasecmp (s
, "discard") == 0)
2238 type
= LINKONCE_DISCARD
;
2239 else if (strcasecmp (s
, "one_only") == 0)
2240 type
= LINKONCE_ONE_ONLY
;
2241 else if (strcasecmp (s
, "same_size") == 0)
2242 type
= LINKONCE_SAME_SIZE
;
2243 else if (strcasecmp (s
, "same_contents") == 0)
2244 type
= LINKONCE_SAME_CONTENTS
;
2246 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2248 *input_line_pointer
= c
;
2251 #ifdef obj_handle_link_once
2252 obj_handle_link_once (type
);
2253 #else /* ! defined (obj_handle_link_once) */
2257 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2258 as_warn (_(".linkonce is not supported for this object file format"));
2260 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2261 flags
|= SEC_LINK_ONCE
;
2266 case LINKONCE_DISCARD
:
2267 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2269 case LINKONCE_ONE_ONLY
:
2270 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2272 case LINKONCE_SAME_SIZE
:
2273 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2275 case LINKONCE_SAME_CONTENTS
:
2276 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2279 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2280 as_bad (_("bfd_set_section_flags: %s"),
2281 bfd_errmsg (bfd_get_error ()));
2283 #endif /* ! defined (obj_handle_link_once) */
2285 demand_empty_rest_of_line ();
2289 bss_alloc (symbolS
*symbolP
, addressT size
, int align
)
2292 segT current_seg
= now_seg
;
2293 subsegT current_subseg
= now_subseg
;
2294 segT bss_seg
= bss_section
;
2296 #if defined (TC_MIPS) || defined (TC_ALPHA)
2297 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2298 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2300 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2301 if (size
<= bfd_get_gp_size (stdoutput
))
2303 bss_seg
= subseg_new (".sbss", 1);
2304 seg_info (bss_seg
)->bss
= 1;
2305 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2306 as_warn (_("error setting flags for \".sbss\": %s"),
2307 bfd_errmsg (bfd_get_error ()));
2311 subseg_set (bss_seg
, 1);
2315 record_alignment (bss_seg
, align
);
2316 frag_align (align
, 0, 0);
2319 /* Detach from old frag. */
2320 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2321 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2323 symbol_set_frag (symbolP
, frag_now
);
2324 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2328 S_SET_SIZE (symbolP
, size
);
2330 S_SET_SEGMENT (symbolP
, bss_seg
);
2333 /* The symbol may already have been created with a preceding
2334 ".globl" directive -- be careful not to step on storage class
2335 in that case. Otherwise, set it to static. */
2336 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2337 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2338 #endif /* OBJ_COFF */
2340 subseg_set (current_seg
, current_subseg
);
2344 parse_align (int align_bytes
)
2350 if (*input_line_pointer
!= ',')
2353 as_bad (_("expected alignment after size"));
2354 ignore_rest_of_line ();
2358 input_line_pointer
++;
2361 align
= get_absolute_expr (&exp
);
2362 if (exp
.X_op
== O_absent
)
2365 if (!exp
.X_unsigned
)
2367 as_warn (_("alignment negative; 0 assumed"));
2371 if (align_bytes
&& align
!= 0)
2373 /* convert to a power of 2 alignment */
2374 unsigned int alignp2
= 0;
2375 while ((align
& 1) == 0)
2376 align
>>= 1, ++alignp2
;
2379 as_bad (_("alignment not a power of 2"));
2380 ignore_rest_of_line ();
2388 /* Called from s_comm_internal after symbol name and size have been
2389 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2390 1 if this was a ".bss" directive which has a 3rd argument
2391 (alignment as a power of 2), or 2 if this was a ".bss" directive
2392 with alignment in bytes. */
2395 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2401 align
= parse_align (needs_align
- 1);
2402 if (align
== (addressT
) -1)
2406 /* Assume some objects may require alignment on some systems. */
2407 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2409 bss_alloc (symbolP
, size
, align
);
2414 s_lcomm (int needs_align
)
2416 s_comm_internal (needs_align
, s_lcomm_internal
);
2420 s_lcomm_bytes (int needs_align
)
2422 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2426 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2428 register char *name
;
2432 register symbolS
*symbolP
;
2434 /* We permit ANY defined expression: BSD4.2 demands constants. */
2435 name
= input_line_pointer
;
2436 c
= get_symbol_end ();
2437 p
= input_line_pointer
;
2442 as_bad (_("expected symbol name"));
2443 ignore_rest_of_line ();
2449 if (*input_line_pointer
!= ',')
2452 as_bad (_("expected comma after \"%s\""), name
);
2454 ignore_rest_of_line ();
2458 input_line_pointer
++;
2459 expression_and_evaluate (&exp
);
2461 if (exp
.X_op
!= O_constant
2462 && exp
.X_op
!= O_register
)
2464 as_bad (_("bad expression"));
2465 ignore_rest_of_line ();
2470 symbolP
= symbol_find_or_make (name
);
2472 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2474 /* The name might be an undefined .global symbol; be sure to
2475 keep the "external" bit. */
2476 S_SET_SEGMENT (symbolP
,
2477 (exp
.X_op
== O_constant
2480 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2484 as_bad (_("symbol `%s' is already defined"), name
);
2488 demand_empty_rest_of_line ();
2491 /* Read a line into an sb. Returns the character that ended the line
2492 or zero if there are no more lines. */
2495 get_line_sb (sb
*line
, int in_macro
)
2499 if (input_line_pointer
[-1] == '\n')
2500 bump_line_counters ();
2502 if (input_line_pointer
>= buffer_limit
)
2504 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2505 if (buffer_limit
== 0)
2509 eol
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 0, in_macro
);
2510 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2511 input_line_pointer
= eol
;
2513 /* Don't skip multiple end-of-line characters, because that breaks support
2514 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2515 characters but isn't. Instead just skip one end of line character and
2516 return the character skipped so that the caller can re-insert it if
2518 return *input_line_pointer
++;
2522 get_non_macro_line_sb (sb
*line
)
2524 return get_line_sb (line
, 0);
2528 get_macro_line_sb (sb
*line
)
2530 return get_line_sb (line
, 1);
2533 /* Define a macro. This is an interface to macro.c. */
2536 s_macro (int ignore ATTRIBUTE_UNUSED
)
2544 as_where (&file
, &line
);
2547 eol
= find_end_of_line (input_line_pointer
, 0);
2548 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2549 input_line_pointer
= eol
;
2551 if (line_label
!= NULL
)
2556 sb_add_string (&label
, S_GET_NAME (line_label
));
2557 err
= define_macro (0, &s
, &label
, get_macro_line_sb
, file
, line
, &name
);
2561 err
= define_macro (0, &s
, NULL
, get_macro_line_sb
, file
, line
, &name
);
2563 as_bad_where (file
, line
, err
, name
);
2566 if (line_label
!= NULL
)
2568 S_SET_SEGMENT (line_label
, absolute_section
);
2569 S_SET_VALUE (line_label
, 0);
2570 symbol_set_frag (line_label
, &zero_address_frag
);
2573 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2574 && hash_find (po_hash
, name
) != NULL
)
2577 && hash_find (po_hash
, name
+ 1) != NULL
))
2578 as_warn_where (file
,
2580 _("attempt to redefine pseudo-op `%s' ignored"),
2587 /* Handle the .mexit pseudo-op, which immediately exits a macro
2591 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2595 cond_exit_macro (macro_nest
);
2596 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2599 as_warn (_("ignoring macro exit outside a macro definition."));
2602 /* Switch in and out of MRI mode. */
2605 s_mri (int ignore ATTRIBUTE_UNUSED
)
2609 on
= get_absolute_expression ();
2610 old_flag
= flag_mri
;
2628 /* Operator precedence changes in m68k MRI mode, so we need to
2629 update the operator rankings. */
2630 expr_set_precedence ();
2632 #ifdef MRI_MODE_CHANGE
2634 MRI_MODE_CHANGE (on
);
2637 demand_empty_rest_of_line ();
2640 /* Handle changing the location counter. */
2643 do_org (segT segment
, expressionS
*exp
, int fill
)
2645 if (segment
!= now_seg
&& segment
!= absolute_section
)
2646 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2648 if (now_seg
== absolute_section
)
2651 as_warn (_("ignoring fill value in absolute section"));
2652 if (exp
->X_op
!= O_constant
)
2654 as_bad (_("only constant offsets supported in absolute section"));
2655 exp
->X_add_number
= 0;
2657 abs_section_offset
= exp
->X_add_number
;
2662 symbolS
*sym
= exp
->X_add_symbol
;
2663 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2665 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2667 /* Handle complex expressions. */
2668 sym
= make_expr_symbol (exp
);
2672 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2678 s_org (int ignore ATTRIBUTE_UNUSED
)
2680 register segT segment
;
2682 register long temp_fill
;
2684 #ifdef md_flush_pending_output
2685 md_flush_pending_output ();
2688 /* The m68k MRI assembler has a different meaning for .org. It
2689 means to create an absolute section at a given address. We can't
2690 support that--use a linker script instead. */
2693 as_bad (_("MRI style ORG pseudo-op not supported"));
2694 ignore_rest_of_line ();
2698 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2699 thing as a sub-segment-relative origin. Any absolute origin is
2700 given a warning, then assumed to be segment-relative. Any
2701 segmented origin expression ("foo+42") had better be in the right
2702 segment or the .org is ignored.
2704 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2705 we never know sub-segment sizes when we are reading code. BSD
2706 will crash trying to emit negative numbers of filler bytes in
2707 certain .orgs. We don't crash, but see as-write for that code.
2709 Don't make frag if need_pass_2==1. */
2710 segment
= get_known_segmented_expression (&exp
);
2711 if (*input_line_pointer
== ',')
2713 input_line_pointer
++;
2714 temp_fill
= get_absolute_expression ();
2720 do_org (segment
, &exp
, temp_fill
);
2722 demand_empty_rest_of_line ();
2725 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2726 called by the obj-format routine which handles section changing
2727 when in MRI mode. It will create a new section, and return it. It
2728 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2729 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2732 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2742 name
= input_line_pointer
;
2743 if (!ISDIGIT (*name
))
2744 c
= get_symbol_end ();
2749 ++input_line_pointer
;
2751 while (ISDIGIT (*input_line_pointer
));
2753 c
= *input_line_pointer
;
2754 *input_line_pointer
= '\0';
2757 name
= xstrdup (name
);
2759 *input_line_pointer
= c
;
2761 seg
= subseg_new (name
, 0);
2763 if (*input_line_pointer
== ',')
2767 ++input_line_pointer
;
2768 align
= get_absolute_expression ();
2769 record_alignment (seg
, align
);
2773 if (*input_line_pointer
== ',')
2775 c
= *++input_line_pointer
;
2777 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2780 as_bad (_("unrecognized section type"));
2781 ++input_line_pointer
;
2786 flags
= SEC_NO_FLAGS
;
2788 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2789 else if (*type
== 'D' || *type
== 'M')
2790 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2791 else if (*type
== 'R')
2792 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2793 if (flags
!= SEC_NO_FLAGS
)
2795 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2796 as_warn (_("error setting flags for \"%s\": %s"),
2797 bfd_section_name (stdoutput
, seg
),
2798 bfd_errmsg (bfd_get_error ()));
2803 /* Ignore the HP type. */
2804 if (*input_line_pointer
== ',')
2805 input_line_pointer
+= 2;
2807 demand_empty_rest_of_line ();
2809 #else /* ! TC_M68K */
2818 name
= input_line_pointer
;
2819 c
= get_symbol_end ();
2821 name
= xstrdup (name
);
2823 *input_line_pointer
= c
;
2825 seg
= subseg_new (name
, 0);
2827 if (*input_line_pointer
!= ',')
2833 ++input_line_pointer
;
2835 sectype
= input_line_pointer
;
2836 c
= get_symbol_end ();
2837 if (*sectype
== '\0')
2839 else if (strcasecmp (sectype
, "text") == 0)
2841 else if (strcasecmp (sectype
, "data") == 0)
2843 else if (strcasecmp (sectype
, "romdata") == 0)
2846 as_warn (_("unrecognized section type `%s'"), sectype
);
2847 *input_line_pointer
= c
;
2850 if (*input_line_pointer
== ',')
2854 ++input_line_pointer
;
2856 seccmd
= input_line_pointer
;
2857 c
= get_symbol_end ();
2858 if (strcasecmp (seccmd
, "absolute") == 0)
2860 as_bad (_("absolute sections are not supported"));
2861 *input_line_pointer
= c
;
2862 ignore_rest_of_line ();
2865 else if (strcasecmp (seccmd
, "align") == 0)
2869 *input_line_pointer
= c
;
2870 align
= get_absolute_expression ();
2871 record_alignment (seg
, align
);
2875 as_warn (_("unrecognized section command `%s'"), seccmd
);
2876 *input_line_pointer
= c
;
2880 demand_empty_rest_of_line ();
2882 #else /* ! TC_I960 */
2883 /* The MRI assembler seems to use different forms of .sect for
2884 different targets. */
2885 as_bad ("MRI mode not supported for this target");
2886 ignore_rest_of_line ();
2887 #endif /* ! TC_I960 */
2888 #endif /* ! TC_M68K */
2891 /* Handle the .print pseudo-op. */
2894 s_print (int ignore ATTRIBUTE_UNUSED
)
2899 s
= demand_copy_C_string (&len
);
2902 demand_empty_rest_of_line ();
2905 /* Handle the .purgem pseudo-op. */
2908 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2910 if (is_it_end_of_statement ())
2912 demand_empty_rest_of_line ();
2922 name
= input_line_pointer
;
2923 c
= get_symbol_end ();
2924 delete_macro (name
);
2925 *input_line_pointer
= c
;
2928 while (*input_line_pointer
++ == ',');
2930 --input_line_pointer
;
2931 demand_empty_rest_of_line ();
2934 /* Handle the .endm/.endr pseudo-ops. */
2937 s_bad_end (int endr
)
2939 as_warn (_(".end%c encountered without preceeding %s"),
2941 endr
? ".rept, .irp, or .irpc" : ".macro");
2942 demand_empty_rest_of_line ();
2945 /* Handle the .rept pseudo-op. */
2948 s_rept (int ignore ATTRIBUTE_UNUSED
)
2952 count
= get_absolute_expression ();
2954 do_repeat (count
, "REPT", "ENDR");
2957 /* This function provides a generic repeat block implementation. It allows
2958 different directives to be used as the start/end keys. */
2961 do_repeat (int count
, const char *start
, const char *end
)
2967 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
2969 as_bad (_("%s without %s"), start
, end
);
2975 sb_add_sb (&many
, &one
);
2979 input_scrub_include_sb (&many
, input_line_pointer
, 1);
2981 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2984 /* Like do_repeat except that any text matching EXPANDER in the
2985 block is replaced by the itteration count. */
2988 do_repeat_with_expander (int count
,
2991 const char * expander
)
2997 if (!buffer_and_nest (start
, end
, &one
, get_non_macro_line_sb
))
2999 as_bad (_("%s without %s"), start
, end
);
3005 if (expander
!= NULL
&& strstr (one
.ptr
, expander
) != NULL
)
3007 while (count
-- > 0)
3013 sb_new (& processed
);
3014 sb_add_sb (& processed
, & one
);
3015 sub
= strstr (processed
.ptr
, expander
);
3016 len
= sprintf (sub
, "%d", count
);
3017 gas_assert (len
< 8);
3018 strcpy (sub
+ len
, sub
+ 8);
3019 processed
.len
-= (8 - len
);
3020 sb_add_sb (& many
, & processed
);
3021 sb_kill (& processed
);
3026 sb_add_sb (&many
, &one
);
3030 input_scrub_include_sb (&many
, input_line_pointer
, 1);
3032 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3035 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3036 input buffers to skip. Assumes that conditionals preceding the loop end
3037 are properly nested.
3039 This function makes it easier to implement a premature "break" out of the
3040 loop. The EXTRA arg accounts for other buffers we might have inserted,
3041 such as line substitutions. */
3044 end_repeat (int extra
)
3046 cond_exit_macro (macro_nest
);
3047 while (extra
-- >= 0)
3048 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3052 assign_symbol (char *name
, int mode
)
3056 if (name
[0] == '.' && name
[1] == '\0')
3058 /* Turn '. = mumble' into a .org mumble. */
3062 segment
= get_known_segmented_expression (&exp
);
3065 do_org (segment
, &exp
, 0);
3070 if ((symbolP
= symbol_find (name
)) == NULL
3071 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
3073 symbolP
= symbol_find_or_make (name
);
3075 /* When doing symbol listings, play games with dummy fragments living
3076 outside the normal fragment chain to record the file and line info
3078 if (listing
& LISTING_SYMBOLS
)
3080 extern struct list_info_struct
*listing_tail
;
3081 fragS
*dummy_frag
= (fragS
*) xcalloc (1, sizeof (fragS
));
3082 dummy_frag
->line
= listing_tail
;
3083 dummy_frag
->fr_symbol
= symbolP
;
3084 symbol_set_frag (symbolP
, dummy_frag
);
3088 /* "set" symbols are local unless otherwise specified. */
3089 SF_SET_LOCAL (symbolP
);
3093 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3095 /* Permit register names to be redefined. */
3096 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
3097 && S_GET_SEGMENT (symbolP
) != reg_section
)
3099 as_bad (_("symbol `%s' is already defined"), name
);
3100 symbolP
= symbol_clone (symbolP
, 0);
3102 /* If the symbol is volatile, copy the symbol and replace the
3103 original with the copy, so that previous uses of the symbol will
3104 retain the value of the symbol at the point of use. */
3105 else if (S_IS_VOLATILE (symbolP
))
3106 symbolP
= symbol_clone (symbolP
, 1);
3110 S_SET_VOLATILE (symbolP
);
3112 S_SET_FORWARD_REF (symbolP
);
3114 pseudo_set (symbolP
);
3117 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3118 then this is .equiv, and it is an error if the symbol is already
3119 defined. If EQUIV is -1, the symbol additionally is a forward
3129 /* Especial apologies for the random logic:
3130 this just grew, and could be parsed much more simply!
3132 name
= input_line_pointer
;
3133 delim
= get_symbol_end ();
3134 end_name
= input_line_pointer
;
3137 if (name
== end_name
)
3139 as_bad (_("expected symbol name"));
3140 ignore_rest_of_line ();
3146 if (*input_line_pointer
!= ',')
3149 as_bad (_("expected comma after \"%s\""), name
);
3151 ignore_rest_of_line ();
3155 input_line_pointer
++;
3158 assign_symbol (name
, equiv
);
3161 demand_empty_rest_of_line ();
3174 #ifdef md_flush_pending_output
3175 md_flush_pending_output ();
3178 #ifdef md_cons_align
3183 stop
= mri_comment_field (&stopc
);
3185 /* In m68k MRI mode, we need to align to a word boundary, unless
3187 if (flag_m68k_mri
&& mult
> 1)
3189 if (now_seg
== absolute_section
)
3191 abs_section_offset
+= abs_section_offset
& 1;
3192 if (line_label
!= NULL
)
3193 S_SET_VALUE (line_label
, abs_section_offset
);
3195 else if (mri_common_symbol
!= NULL
)
3199 val
= S_GET_VALUE (mri_common_symbol
);
3202 S_SET_VALUE (mri_common_symbol
, val
+ 1);
3203 if (line_label
!= NULL
)
3205 expressionS
*symexp
;
3207 symexp
= symbol_get_value_expression (line_label
);
3208 know (symexp
->X_op
== O_symbol
);
3209 know (symexp
->X_add_symbol
== mri_common_symbol
);
3210 symexp
->X_add_number
+= 1;
3216 do_align (1, (char *) NULL
, 0, 0);
3217 if (line_label
!= NULL
)
3219 symbol_set_frag (line_label
, frag_now
);
3220 S_SET_VALUE (line_label
, frag_now_fix ());
3230 if (*input_line_pointer
== ',')
3232 ++input_line_pointer
;
3237 val
.X_op
= O_constant
;
3238 val
.X_add_number
= 0;
3241 if (val
.X_op
!= O_constant
3242 || val
.X_add_number
< - 0x80
3243 || val
.X_add_number
> 0xff
3244 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
3246 resolve_expression (&exp
);
3247 if (exp
.X_op
!= O_constant
)
3248 as_bad (_("unsupported variable size or fill value"));
3255 bytes
= mult
* exp
.X_add_number
;
3256 for (i
= 0; i
< exp
.X_add_number
; i
++)
3257 emit_expr (&val
, mult
);
3262 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
3263 resolve_expression (&exp
);
3265 if (exp
.X_op
== O_constant
)
3269 repeat
= exp
.X_add_number
;
3276 as_warn (_(".space repeat count is zero, ignored"));
3277 else if (repeat
< 0)
3278 as_warn (_(".space repeat count is negative, ignored"));
3282 /* If we are in the absolute section, just bump the offset. */
3283 if (now_seg
== absolute_section
)
3285 abs_section_offset
+= repeat
;
3289 /* If we are secretly in an MRI common section, then
3290 creating space just increases the size of the common
3292 if (mri_common_symbol
!= NULL
)
3294 S_SET_VALUE (mri_common_symbol
,
3295 S_GET_VALUE (mri_common_symbol
) + repeat
);
3300 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3301 (offsetT
) repeat
, (char *) 0);
3305 if (now_seg
== absolute_section
)
3307 as_bad (_("space allocation too complex in absolute section"));
3308 subseg_set (text_section
, 0);
3311 if (mri_common_symbol
!= NULL
)
3313 as_bad (_("space allocation too complex in common section"));
3314 mri_common_symbol
= NULL
;
3318 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3319 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3323 *p
= val
.X_add_number
;
3328 /* In MRI mode, after an odd number of bytes, we must align to an
3329 even word boundary, unless the next instruction is a dc.b, ds.b
3331 if (flag_mri
&& (bytes
& 1) != 0)
3332 mri_pending_align
= 1;
3334 demand_empty_rest_of_line ();
3337 mri_comment_end (stop
, stopc
);
3340 /* This is like s_space, but the value is a floating point number with
3341 the given precision. This is for the MRI dcb.s pseudo-op and
3345 s_float_space (int float_type
)
3349 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3353 #ifdef md_cons_align
3358 stop
= mri_comment_field (&stopc
);
3360 count
= get_absolute_expression ();
3363 if (*input_line_pointer
!= ',')
3365 as_bad (_("missing value"));
3366 ignore_rest_of_line ();
3368 mri_comment_end (stop
, stopc
);
3372 ++input_line_pointer
;
3376 /* Skip any 0{letter} that may be present. Don't even check if the
3377 * letter is legal. */
3378 if (input_line_pointer
[0] == '0'
3379 && ISALPHA (input_line_pointer
[1]))
3380 input_line_pointer
+= 2;
3382 /* Accept :xxxx, where the x's are hex digits, for a floating point
3383 with the exact digits specified. */
3384 if (input_line_pointer
[0] == ':')
3386 flen
= hex_float (float_type
, temp
);
3389 ignore_rest_of_line ();
3391 mri_comment_end (stop
, stopc
);
3399 err
= md_atof (float_type
, temp
, &flen
);
3400 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3401 know (err
!= NULL
|| flen
> 0);
3404 as_bad (_("bad floating literal: %s"), err
);
3405 ignore_rest_of_line ();
3407 mri_comment_end (stop
, stopc
);
3412 while (--count
>= 0)
3416 p
= frag_more (flen
);
3417 memcpy (p
, temp
, (unsigned int) flen
);
3420 demand_empty_rest_of_line ();
3423 mri_comment_end (stop
, stopc
);
3426 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3429 s_struct (int ignore ATTRIBUTE_UNUSED
)
3435 stop
= mri_comment_field (&stopc
);
3436 abs_section_offset
= get_absolute_expression ();
3437 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3438 /* The ELF backend needs to know that we are changing sections, so
3439 that .previous works correctly. */
3441 obj_elf_section_change_hook ();
3443 subseg_set (absolute_section
, 0);
3444 demand_empty_rest_of_line ();
3446 mri_comment_end (stop
, stopc
);
3450 s_text (int ignore ATTRIBUTE_UNUSED
)
3454 temp
= get_absolute_expression ();
3455 subseg_set (text_section
, (subsegT
) temp
);
3456 demand_empty_rest_of_line ();
3458 const_flag
&= ~IN_DEFAULT_SECTION
;
3462 /* .weakref x, y sets x as an alias to y that, as long as y is not
3463 referenced directly, will cause y to become a weak symbol. */
3465 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3474 name
= input_line_pointer
;
3475 delim
= get_symbol_end ();
3476 end_name
= input_line_pointer
;
3478 if (name
== end_name
)
3480 as_bad (_("expected symbol name"));
3482 ignore_rest_of_line ();
3486 symbolP
= symbol_find_or_make (name
);
3488 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3490 if (!S_IS_VOLATILE (symbolP
))
3492 as_bad (_("symbol `%s' is already defined"), name
);
3494 ignore_rest_of_line ();
3497 symbolP
= symbol_clone (symbolP
, 1);
3498 S_CLEAR_VOLATILE (symbolP
);
3505 if (*input_line_pointer
!= ',')
3508 as_bad (_("expected comma after \"%s\""), name
);
3510 ignore_rest_of_line ();
3514 input_line_pointer
++;
3518 name
= input_line_pointer
;
3519 delim
= get_symbol_end ();
3520 end_name
= input_line_pointer
;
3522 if (name
== end_name
)
3524 as_bad (_("expected symbol name"));
3525 ignore_rest_of_line ();
3529 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3530 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3532 symbolP2
= symbol_find_or_make (name
);
3533 S_SET_WEAKREFD (symbolP2
);
3537 symbolS
*symp
= symbolP2
;
3539 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3541 expressionS
*expP
= symbol_get_value_expression (symp
);
3543 gas_assert (expP
->X_op
== O_symbol
3544 && expP
->X_add_number
== 0);
3545 symp
= expP
->X_add_symbol
;
3547 if (symp
== symbolP
)
3551 loop
= concat (S_GET_NAME (symbolP
),
3552 " => ", S_GET_NAME (symbolP2
), (const char *) NULL
);
3555 while (symp
!= symbolP
)
3557 char *old_loop
= loop
;
3558 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3559 loop
= concat (loop
, " => ", S_GET_NAME (symp
),
3560 (const char *) NULL
);
3564 as_bad (_("%s: would close weakref loop: %s"),
3565 S_GET_NAME (symbolP
), loop
);
3570 ignore_rest_of_line ();
3574 /* Short-circuiting instead of just checking here might speed
3575 things up a tiny little bit, but loop error messages would
3576 miss intermediate links. */
3577 /* symbolP2 = symp; */
3582 memset (&exp
, 0, sizeof (exp
));
3583 exp
.X_op
= O_symbol
;
3584 exp
.X_add_symbol
= symbolP2
;
3586 S_SET_SEGMENT (symbolP
, undefined_section
);
3587 symbol_set_value_expression (symbolP
, &exp
);
3588 symbol_set_frag (symbolP
, &zero_address_frag
);
3589 S_SET_WEAKREFR (symbolP
);
3591 demand_empty_rest_of_line ();
3595 /* Verify that we are at the end of a line. If not, issue an error and
3599 demand_empty_rest_of_line (void)
3602 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3603 input_line_pointer
++;
3606 if (ISPRINT (*input_line_pointer
))
3607 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3608 *input_line_pointer
);
3610 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3611 *input_line_pointer
);
3612 ignore_rest_of_line ();
3615 /* Return pointing just after end-of-line. */
3616 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3619 /* Silently advance to the end of line. Use this after already having
3620 issued an error about something bad. */
3623 ignore_rest_of_line (void)
3625 while (input_line_pointer
< buffer_limit
3626 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3627 input_line_pointer
++;
3629 input_line_pointer
++;
3631 /* Return pointing just after end-of-line. */
3632 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3635 /* Sets frag for given symbol to zero_address_frag, except when the
3636 symbol frag is already set to a dummy listing frag. */
3639 set_zero_frag (symbolS
*symbolP
)
3641 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3642 symbol_set_frag (symbolP
, &zero_address_frag
);
3645 /* In: Pointer to a symbol.
3646 Input_line_pointer->expression.
3648 Out: Input_line_pointer->just after any whitespace after expression.
3649 Tried to set symbol to value of expression.
3650 Will change symbols type, value, and frag; */
3653 pseudo_set (symbolS
*symbolP
)
3658 know (symbolP
); /* NULL pointer is logic error. */
3660 if (!S_IS_FORWARD_REF (symbolP
))
3661 (void) expression (&exp
);
3663 (void) deferred_expression (&exp
);
3665 if (exp
.X_op
== O_illegal
)
3666 as_bad (_("illegal expression"));
3667 else if (exp
.X_op
== O_absent
)
3668 as_bad (_("missing expression"));
3669 else if (exp
.X_op
== O_big
)
3671 if (exp
.X_add_number
> 0)
3672 as_bad (_("bignum invalid"));
3674 as_bad (_("floating point number invalid"));
3676 else if (exp
.X_op
== O_subtract
3677 && !S_IS_FORWARD_REF (symbolP
)
3678 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3679 && (symbol_get_frag (exp
.X_add_symbol
)
3680 == symbol_get_frag (exp
.X_op_symbol
)))
3682 exp
.X_op
= O_constant
;
3683 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3684 - S_GET_VALUE (exp
.X_op_symbol
));
3687 if (symbol_section_p (symbolP
))
3689 as_bad ("attempt to set value of section symbol");
3698 exp
.X_add_number
= 0;
3701 S_SET_SEGMENT (symbolP
, absolute_section
);
3702 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3703 set_zero_frag (symbolP
);
3707 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3708 if (S_IS_EXTERNAL (symbolP
))
3710 as_bad ("can't equate global symbol `%s' with register name",
3711 S_GET_NAME (symbolP
));
3715 S_SET_SEGMENT (symbolP
, reg_section
);
3716 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3717 set_zero_frag (symbolP
);
3718 symbol_get_value_expression (symbolP
)->X_op
= O_register
;
3722 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3723 /* For x=undef+const, create an expression symbol.
3724 For x=x+const, just update x except when x is an undefined symbol
3725 For x=defined+const, evaluate x. */
3726 if (symbolP
== exp
.X_add_symbol
3727 && (seg
!= undefined_section
3728 || !symbol_constant_p (symbolP
)))
3730 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3733 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3735 symbolS
*s
= exp
.X_add_symbol
;
3737 if (S_IS_COMMON (s
))
3738 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3739 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3741 S_SET_SEGMENT (symbolP
, seg
);
3742 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3743 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3744 copy_symbol_attributes (symbolP
, s
);
3747 S_SET_SEGMENT (symbolP
, undefined_section
);
3748 symbol_set_value_expression (symbolP
, &exp
);
3749 set_zero_frag (symbolP
);
3753 /* The value is some complex expression. */
3754 S_SET_SEGMENT (symbolP
, expr_section
);
3755 symbol_set_value_expression (symbolP
, &exp
);
3756 set_zero_frag (symbolP
);
3763 CONStruct more frag of .bytes, or .words etc.
3764 Should need_pass_2 be 1 then emit no frag(s).
3765 This understands EXPRESSIONS.
3769 This has a split personality. We use expression() to read the
3770 value. We can detect if the value won't fit in a byte or word.
3771 But we can't detect if expression() discarded significant digits
3772 in the case of a long. Not worth the crocks required to fix it. */
3774 /* Select a parser for cons expressions. */
3776 /* Some targets need to parse the expression in various fancy ways.
3777 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3778 (for example, the HPPA does this). Otherwise, you can define
3779 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3780 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3781 are defined, which is the normal case, then only simple expressions
3786 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3789 #ifndef TC_PARSE_CONS_EXPRESSION
3790 #ifdef BITFIELD_CONS_EXPRESSIONS
3791 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3793 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3795 #ifdef REPEAT_CONS_EXPRESSIONS
3796 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3798 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3801 /* If we haven't gotten one yet, just call expression. */
3802 #ifndef TC_PARSE_CONS_EXPRESSION
3803 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3808 do_parse_cons_expression (expressionS
*exp
,
3809 int nbytes ATTRIBUTE_UNUSED
)
3811 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3815 /* Worker to do .byte etc statements.
3816 Clobbers input_line_pointer and checks end-of-line. */
3819 cons_worker (register int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3827 #ifdef md_flush_pending_output
3828 md_flush_pending_output ();
3832 stop
= mri_comment_field (&stopc
);
3834 if (is_it_end_of_statement ())
3836 demand_empty_rest_of_line ();
3838 mri_comment_end (stop
, stopc
);
3842 #ifdef TC_ADDRESS_BYTES
3844 nbytes
= TC_ADDRESS_BYTES ();
3847 #ifdef md_cons_align
3848 md_cons_align (nbytes
);
3856 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3859 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3863 if (exp
.X_op
== O_symbol
)
3864 exp
.X_op
= O_symbol_rva
;
3866 as_fatal (_("rva without symbol"));
3868 emit_expr (&exp
, (unsigned int) nbytes
);
3871 while (*input_line_pointer
++ == ',');
3873 /* In MRI mode, after an odd number of bytes, we must align to an
3874 even word boundary, unless the next instruction is a dc.b, ds.b
3876 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3877 mri_pending_align
= 1;
3879 input_line_pointer
--; /* Put terminator back into stream. */
3881 demand_empty_rest_of_line ();
3884 mri_comment_end (stop
, stopc
);
3890 cons_worker (size
, 0);
3896 cons_worker (size
, 1);
3899 /* .reloc offset, reloc_name, symbol+addend. */
3902 s_reloc (int ignore ATTRIBUTE_UNUSED
)
3909 struct reloc_list
*reloc
;
3911 reloc
= (struct reloc_list
*) xmalloc (sizeof (*reloc
));
3914 stop
= mri_comment_field (&stopc
);
3923 as_bad (_("missing or bad offset expression"));
3926 exp
.X_add_symbol
= section_symbol (now_seg
);
3927 exp
.X_op
= O_symbol
;
3930 if (exp
.X_add_number
== 0)
3932 reloc
->u
.a
.offset_sym
= exp
.X_add_symbol
;
3937 reloc
->u
.a
.offset_sym
= make_expr_symbol (&exp
);
3942 if (*input_line_pointer
!= ',')
3944 as_bad (_("missing reloc type"));
3948 ++input_line_pointer
;
3950 r_name
= input_line_pointer
;
3951 c
= get_symbol_end ();
3952 reloc
->u
.a
.howto
= bfd_reloc_name_lookup (stdoutput
, r_name
);
3953 *input_line_pointer
= c
;
3954 if (reloc
->u
.a
.howto
== NULL
)
3956 as_bad (_("unrecognized reloc type"));
3960 exp
.X_op
= O_absent
;
3962 if (*input_line_pointer
== ',')
3964 ++input_line_pointer
;
3972 as_bad (_("bad reloc expression"));
3974 ignore_rest_of_line ();
3977 mri_comment_end (stop
, stopc
);
3980 reloc
->u
.a
.sym
= NULL
;
3981 reloc
->u
.a
.addend
= 0;
3984 reloc
->u
.a
.sym
= NULL
;
3985 reloc
->u
.a
.addend
= exp
.X_add_number
;
3988 reloc
->u
.a
.sym
= exp
.X_add_symbol
;
3989 reloc
->u
.a
.addend
= exp
.X_add_number
;
3992 reloc
->u
.a
.sym
= make_expr_symbol (&exp
);
3993 reloc
->u
.a
.addend
= 0;
3997 as_where (&reloc
->file
, &reloc
->line
);
3998 reloc
->next
= reloc_list
;
4001 demand_empty_rest_of_line ();
4003 mri_comment_end (stop
, stopc
);
4006 /* Put the contents of expression EXP into the object file using
4007 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4010 emit_expr (expressionS
*exp
, unsigned int nbytes
)
4014 valueT extra_digit
= 0;
4016 /* Don't do anything if we are going to make another pass. */
4020 /* Grow the current frag now so that dot_value does not get invalidated
4021 if the frag were to fill up in the frag_more() call below. */
4023 dot_value
= frag_now_fix ();
4027 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4028 appear as a four byte positive constant in the .line section,
4029 followed by a 2 byte 0xffff. Look for that case here. */
4031 static int dwarf_line
= -1;
4033 if (strcmp (segment_name (now_seg
), ".line") != 0)
4035 else if (dwarf_line
>= 0
4037 && exp
->X_op
== O_constant
4038 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
4039 listing_source_line ((unsigned int) dwarf_line
);
4040 else if (nbytes
== 4
4041 && exp
->X_op
== O_constant
4042 && exp
->X_add_number
>= 0)
4043 dwarf_line
= exp
->X_add_number
;
4048 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4049 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4050 AT_sibling (0x12) followed by a four byte address of the sibling
4051 followed by a 2 byte AT_name (0x38) followed by the name of the
4052 file. We look for that case here. */
4054 static int dwarf_file
= 0;
4056 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4058 else if (dwarf_file
== 0
4060 && exp
->X_op
== O_constant
4061 && exp
->X_add_number
== 0x11)
4063 else if (dwarf_file
== 1
4065 && exp
->X_op
== O_constant
4066 && exp
->X_add_number
== 0x12)
4068 else if (dwarf_file
== 2
4071 else if (dwarf_file
== 3
4073 && exp
->X_op
== O_constant
4074 && exp
->X_add_number
== 0x38)
4079 /* The variable dwarf_file_string tells stringer that the string
4080 may be the name of the source file. */
4081 if (dwarf_file
== 4)
4082 dwarf_file_string
= 1;
4084 dwarf_file_string
= 0;
4089 if (check_eh_frame (exp
, &nbytes
))
4094 /* Allow `.word 0' in the absolute section. */
4095 if (now_seg
== absolute_section
)
4097 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
4098 as_bad (_("attempt to store value in absolute section"));
4099 abs_section_offset
+= nbytes
;
4103 /* Handle a negative bignum. */
4105 && exp
->X_add_number
== 0
4106 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
4107 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
4110 unsigned long carry
;
4112 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
4114 /* Negate the bignum: one's complement each digit and add 1. */
4116 for (i
= 0; i
< exp
->X_add_number
; i
++)
4120 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
4123 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
4124 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
4127 /* We can ignore any carry out, because it will be handled by
4128 extra_digit if it is needed. */
4130 extra_digit
= (valueT
) -1;
4134 if (op
== O_absent
|| op
== O_illegal
)
4136 as_warn (_("zero assumed for missing expression"));
4137 exp
->X_add_number
= 0;
4140 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4142 as_bad (_("floating point number invalid"));
4143 exp
->X_add_number
= 0;
4146 else if (op
== O_register
)
4148 as_warn (_("register value used as expression"));
4152 p
= frag_more ((int) nbytes
);
4154 #ifndef WORKING_DOT_WORD
4155 /* If we have the difference of two symbols in a word, save it on
4156 the broken_words list. See the code in write.c. */
4157 if (op
== O_subtract
&& nbytes
== 2)
4159 struct broken_word
*x
;
4161 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
4162 x
->next_broken_word
= broken_words
;
4165 x
->subseg
= now_subseg
;
4167 x
->word_goes_here
= p
;
4169 x
->add
= exp
->X_add_symbol
;
4170 x
->sub
= exp
->X_op_symbol
;
4171 x
->addnum
= exp
->X_add_number
;
4179 /* If we have an integer, but the number of bytes is too large to
4180 pass to md_number_to_chars, handle it as a bignum. */
4181 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
4183 extra_digit
= exp
->X_unsigned
? 0 : -1;
4184 convert_to_bignum (exp
);
4188 if (op
== O_constant
)
4190 register valueT get
;
4191 register valueT use
;
4192 register valueT mask
;
4194 register valueT unmask
;
4196 /* JF << of >= number of bits in the object is undefined. In
4197 particular SPARC (Sun 4) has problems. */
4198 if (nbytes
>= sizeof (valueT
))
4201 if (nbytes
> sizeof (valueT
))
4204 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4208 /* Don't store these bits. */
4209 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
4210 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
4213 unmask
= ~mask
; /* Do store these bits. */
4216 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4217 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
4220 get
= exp
->X_add_number
;
4222 if ((get
& mask
) != 0
4223 && ((get
& mask
) != mask
4224 || (get
& hibit
) == 0))
4225 { /* Leading bits contain both 0s & 1s. */
4226 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4228 as_warn (_("value 0x%llx truncated to 0x%llx"),
4229 (unsigned long long) get
, (unsigned long long) use
);
4231 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4232 (unsigned long long) get
, (unsigned long long) use
);
4235 as_warn (_("value 0x%lx truncated to 0x%lx"),
4236 (unsigned long) get
, (unsigned long) use
);
4239 /* Put bytes in right order. */
4240 md_number_to_chars (p
, use
, (int) nbytes
);
4242 else if (op
== O_big
)
4245 LITTLENUM_TYPE
*nums
;
4247 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
4249 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
4252 as_warn (_("bignum truncated to %d bytes"), nbytes
);
4256 if (target_big_endian
)
4258 while (nbytes
> size
)
4260 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4261 nbytes
-= CHARS_PER_LITTLENUM
;
4262 p
+= CHARS_PER_LITTLENUM
;
4265 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
4266 while (size
>= CHARS_PER_LITTLENUM
)
4269 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4270 size
-= CHARS_PER_LITTLENUM
;
4271 p
+= CHARS_PER_LITTLENUM
;
4276 nums
= generic_bignum
;
4277 while (size
>= CHARS_PER_LITTLENUM
)
4279 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
4281 size
-= CHARS_PER_LITTLENUM
;
4282 p
+= CHARS_PER_LITTLENUM
;
4283 nbytes
-= CHARS_PER_LITTLENUM
;
4286 while (nbytes
>= CHARS_PER_LITTLENUM
)
4288 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
4289 nbytes
-= CHARS_PER_LITTLENUM
;
4290 p
+= CHARS_PER_LITTLENUM
;
4295 emit_expr_fix (exp
, nbytes
, frag_now
, p
);
4299 emit_expr_fix (expressionS
*exp
, unsigned int nbytes
, fragS
*frag
, char *p
)
4301 memset (p
, 0, nbytes
);
4303 /* Generate a fixS to record the symbol value. */
4305 #ifdef TC_CONS_FIX_NEW
4306 TC_CONS_FIX_NEW (frag
, p
- frag
->fr_literal
, nbytes
, exp
);
4309 bfd_reloc_code_real_type r
;
4329 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
4333 fix_new_exp (frag
, p
- frag
->fr_literal
, (int) nbytes
, exp
,
4339 #ifdef BITFIELD_CONS_EXPRESSIONS
4341 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4342 w:x,y:z, where w and y are bitwidths and x and y are values. They
4343 then pack them all together. We do a little better in that we allow
4344 them in words, longs, etc. and we'll pack them in target byte order
4347 The rules are: pack least significant bit first, if a field doesn't
4348 entirely fit, put it in the next unit. Overflowing the bitfield is
4349 explicitly *not* even a warning. The bitwidth should be considered
4352 To use this function the tc-XXX.h file should define
4353 BITFIELD_CONS_EXPRESSIONS. */
4356 parse_bitfield_cons (exp
, nbytes
)
4358 unsigned int nbytes
;
4360 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
4361 char *hold
= input_line_pointer
;
4363 (void) expression (exp
);
4365 if (*input_line_pointer
== ':')
4372 unsigned long width
;
4374 if (*input_line_pointer
!= ':')
4376 input_line_pointer
= hold
;
4378 } /* Next piece is not a bitfield. */
4380 /* In the general case, we can't allow
4381 full expressions with symbol
4382 differences and such. The relocation
4383 entries for symbols not defined in this
4384 assembly would require arbitrary field
4385 widths, positions, and masks which most
4386 of our current object formats don't
4389 In the specific case where a symbol
4390 *is* defined in this assembly, we
4391 *could* build fixups and track it, but
4392 this could lead to confusion for the
4393 backends. I'm lazy. I'll take any
4394 SEG_ABSOLUTE. I think that means that
4395 you can use a previous .set or
4396 .equ type symbol. xoxorich. */
4398 if (exp
->X_op
== O_absent
)
4400 as_warn (_("using a bit field width of zero"));
4401 exp
->X_add_number
= 0;
4402 exp
->X_op
= O_constant
;
4403 } /* Implied zero width bitfield. */
4405 if (exp
->X_op
!= O_constant
)
4407 *input_line_pointer
= '\0';
4408 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
4409 *input_line_pointer
= ':';
4410 demand_empty_rest_of_line ();
4412 } /* Too complex. */
4414 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
4416 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4417 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
4418 width
= BITS_PER_CHAR
* nbytes
;
4421 if (width
> bits_available
)
4423 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4424 input_line_pointer
= hold
;
4425 exp
->X_add_number
= value
;
4430 hold
= ++input_line_pointer
;
4432 (void) expression (exp
);
4433 if (exp
->X_op
!= O_constant
)
4435 char cache
= *input_line_pointer
;
4437 *input_line_pointer
= '\0';
4438 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4439 *input_line_pointer
= cache
;
4440 demand_empty_rest_of_line ();
4442 } /* Too complex. */
4444 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4445 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4447 if ((bits_available
-= width
) == 0
4448 || is_it_end_of_statement ()
4449 || *input_line_pointer
!= ',')
4452 } /* All the bitfields we're gonna get. */
4454 hold
= ++input_line_pointer
;
4455 (void) expression (exp
);
4458 exp
->X_add_number
= value
;
4459 exp
->X_op
= O_constant
;
4460 exp
->X_unsigned
= 1;
4464 #endif /* BITFIELD_CONS_EXPRESSIONS */
4466 /* Handle an MRI style string expression. */
4470 parse_mri_cons (exp
, nbytes
)
4472 unsigned int nbytes
;
4474 if (*input_line_pointer
!= '\''
4475 && (input_line_pointer
[1] != '\''
4476 || (*input_line_pointer
!= 'A'
4477 && *input_line_pointer
!= 'E')))
4478 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4482 unsigned int result
= 0;
4484 /* An MRI style string. Cut into as many bytes as will fit into
4485 a nbyte chunk, left justify if necessary, and separate with
4486 commas so we can try again later. */
4487 if (*input_line_pointer
== 'A')
4488 ++input_line_pointer
;
4489 else if (*input_line_pointer
== 'E')
4491 as_bad (_("EBCDIC constants are not supported"));
4492 ++input_line_pointer
;
4495 input_line_pointer
++;
4496 for (scan
= 0; scan
< nbytes
; scan
++)
4498 if (*input_line_pointer
== '\'')
4500 if (input_line_pointer
[1] == '\'')
4502 input_line_pointer
++;
4507 result
= (result
<< 8) | (*input_line_pointer
++);
4511 while (scan
< nbytes
)
4517 /* Create correct expression. */
4518 exp
->X_op
= O_constant
;
4519 exp
->X_add_number
= result
;
4521 /* Fake it so that we can read the next char too. */
4522 if (input_line_pointer
[0] != '\'' ||
4523 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4525 input_line_pointer
-= 2;
4526 input_line_pointer
[0] = ',';
4527 input_line_pointer
[1] = '\'';
4530 input_line_pointer
++;
4533 #endif /* TC_M68K */
4535 #ifdef REPEAT_CONS_EXPRESSIONS
4537 /* Parse a repeat expression for cons. This is used by the MIPS
4538 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4539 object file COUNT times.
4541 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4544 parse_repeat_cons (exp
, nbytes
)
4546 unsigned int nbytes
;
4553 if (*input_line_pointer
!= ':')
4555 /* No repeat count. */
4559 ++input_line_pointer
;
4560 expression (&count
);
4561 if (count
.X_op
!= O_constant
4562 || count
.X_add_number
<= 0)
4564 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4568 /* The cons function is going to output this expression once. So we
4569 output it count - 1 times. */
4570 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4571 emit_expr (exp
, nbytes
);
4574 #endif /* REPEAT_CONS_EXPRESSIONS */
4576 /* Parse a floating point number represented as a hex constant. This
4577 permits users to specify the exact bits they want in the floating
4581 hex_float (int float_type
, char *bytes
)
4613 as_bad (_("unknown floating type type '%c'"), float_type
);
4617 /* It would be nice if we could go through expression to parse the
4618 hex constant, but if we get a bignum it's a pain to sort it into
4619 the buffer correctly. */
4621 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4625 /* The MRI assembler accepts arbitrary underscores strewn about
4626 through the hex constant, so we ignore them as well. */
4627 if (*input_line_pointer
== '_')
4629 ++input_line_pointer
;
4635 as_warn (_("floating point constant too large"));
4638 d
= hex_value (*input_line_pointer
) << 4;
4639 ++input_line_pointer
;
4640 while (*input_line_pointer
== '_')
4641 ++input_line_pointer
;
4642 if (hex_p (*input_line_pointer
))
4644 d
+= hex_value (*input_line_pointer
);
4645 ++input_line_pointer
;
4647 if (target_big_endian
)
4650 bytes
[length
- i
- 1] = d
;
4656 if (target_big_endian
)
4657 memset (bytes
+ i
, 0, length
- i
);
4659 memset (bytes
, 0, length
- i
);
4667 CONStruct some more frag chars of .floats .ffloats etc.
4668 Makes 0 or more new frags.
4669 If need_pass_2 == 1, no frags are emitted.
4670 This understands only floating literals, not expressions. Sorry.
4672 A floating constant is defined by atof_generic(), except it is preceded
4673 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4674 reading, I decided to be incompatible. This always tries to give you
4675 rounded bits to the precision of the pseudo-op. Former AS did premature
4676 truncation, restored noisy bits instead of trailing 0s AND gave you
4677 a choice of 2 flavours of noise according to which of 2 floating-point
4678 scanners you directed AS to use.
4680 In: input_line_pointer->whitespace before, or '0' of flonum. */
4683 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4684 register int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4687 int length
; /* Number of chars in an object. */
4688 register char *err
; /* Error from scanning floating literal. */
4689 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4691 if (is_it_end_of_statement ())
4693 demand_empty_rest_of_line ();
4697 #ifdef md_flush_pending_output
4698 md_flush_pending_output ();
4701 #ifdef md_cons_align
4707 /* input_line_pointer->1st char of a flonum (we hope!). */
4710 /* Skip any 0{letter} that may be present. Don't even check if the
4711 letter is legal. Someone may invent a "z" format and this routine
4712 has no use for such information. Lusers beware: you get
4713 diagnostics if your input is ill-conditioned. */
4714 if (input_line_pointer
[0] == '0'
4715 && ISALPHA (input_line_pointer
[1]))
4716 input_line_pointer
+= 2;
4718 /* Accept :xxxx, where the x's are hex digits, for a floating
4719 point with the exact digits specified. */
4720 if (input_line_pointer
[0] == ':')
4722 ++input_line_pointer
;
4723 length
= hex_float (float_type
, temp
);
4726 ignore_rest_of_line ();
4732 err
= md_atof (float_type
, temp
, &length
);
4733 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4734 know (err
!= NULL
|| length
> 0);
4737 as_bad (_("bad floating literal: %s"), err
);
4738 ignore_rest_of_line ();
4749 #ifdef REPEAT_CONS_EXPRESSIONS
4750 if (*input_line_pointer
== ':')
4752 expressionS count_exp
;
4754 ++input_line_pointer
;
4755 expression (&count_exp
);
4757 if (count_exp
.X_op
!= O_constant
4758 || count_exp
.X_add_number
<= 0)
4759 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4761 count
= count_exp
.X_add_number
;
4765 while (--count
>= 0)
4767 p
= frag_more (length
);
4768 memcpy (p
, temp
, (unsigned int) length
);
4773 while (*input_line_pointer
++ == ',');
4775 /* Put terminator back into stream. */
4776 --input_line_pointer
;
4777 demand_empty_rest_of_line ();
4780 /* Return the size of a LEB128 value. */
4783 sizeof_sleb128 (offsetT value
)
4785 register int size
= 0;
4786 register unsigned byte
;
4790 byte
= (value
& 0x7f);
4791 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4792 Fortunately, we can structure things so that the extra work reduces
4793 to a noop on systems that do things "properly". */
4794 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4797 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4798 || ((value
== -1) && ((byte
& 0x40) != 0))));
4804 sizeof_uleb128 (valueT value
)
4806 register int size
= 0;
4807 register unsigned byte
;
4811 byte
= (value
& 0x7f);
4821 sizeof_leb128 (valueT value
, int sign
)
4824 return sizeof_sleb128 ((offsetT
) value
);
4826 return sizeof_uleb128 (value
);
4829 /* Output a LEB128 value. */
4832 output_sleb128 (char *p
, offsetT value
)
4834 register char *orig
= p
;
4839 unsigned byte
= (value
& 0x7f);
4841 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4842 Fortunately, we can structure things so that the extra work reduces
4843 to a noop on systems that do things "properly". */
4844 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4846 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4847 || ((value
== -1) && ((byte
& 0x40) != 0))));
4859 output_uleb128 (char *p
, valueT value
)
4865 unsigned byte
= (value
& 0x7f);
4868 /* More bytes to follow. */
4879 output_leb128 (char *p
, valueT value
, int sign
)
4882 return output_sleb128 (p
, (offsetT
) value
);
4884 return output_uleb128 (p
, value
);
4887 /* Do the same for bignums. We combine sizeof with output here in that
4888 we don't output for NULL values of P. It isn't really as critical as
4889 for "normal" values that this be streamlined. */
4892 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4899 /* Strip leading sign extensions off the bignum. */
4901 && bignum
[size
- 1] == LITTLENUM_MASK
4902 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
4907 /* OR in the next part of the littlenum. */
4908 val
|= (*bignum
<< loaded
);
4909 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
4913 /* Add bytes until there are less than 7 bits left in VAL
4914 or until every non-sign bit has been written. */
4921 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
4928 while ((byte
& 0x80) != 0 && loaded
>= 7);
4932 /* Mop up any left-over bits (of which there will be less than 7). */
4933 if ((byte
& 0x80) != 0)
4935 /* Sign-extend VAL. */
4936 if (val
& (1 << (loaded
- 1)))
4937 val
|= ~0 << loaded
;
4947 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4954 /* Strip leading zeros off the bignum. */
4955 /* XXX: Is this needed? */
4956 while (size
> 0 && bignum
[size
- 1] == 0)
4961 if (loaded
< 7 && size
> 0)
4963 val
|= (*bignum
<< loaded
);
4964 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4973 if (size
> 0 || val
)
4980 while (byte
& 0x80);
4986 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
4989 return output_big_sleb128 (p
, bignum
, size
);
4991 return output_big_uleb128 (p
, bignum
, size
);
4994 /* Generate the appropriate fragments for a given expression to emit a
4998 emit_leb128_expr (expressionS
*exp
, int sign
)
5000 operatorT op
= exp
->X_op
;
5001 unsigned int nbytes
;
5003 if (op
== O_absent
|| op
== O_illegal
)
5005 as_warn (_("zero assumed for missing expression"));
5006 exp
->X_add_number
= 0;
5009 else if (op
== O_big
&& exp
->X_add_number
<= 0)
5011 as_bad (_("floating point number invalid"));
5012 exp
->X_add_number
= 0;
5015 else if (op
== O_register
)
5017 as_warn (_("register value used as expression"));
5020 else if (op
== O_constant
5022 && (exp
->X_add_number
< 0) != !exp
->X_unsigned
)
5024 /* We're outputting a signed leb128 and the sign of X_add_number
5025 doesn't reflect the sign of the original value. Convert EXP
5026 to a correctly-extended bignum instead. */
5027 convert_to_bignum (exp
);
5031 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5032 a signal that this is leb128 data. It shouldn't optimize this away. */
5033 nbytes
= (unsigned int) -1;
5034 if (check_eh_frame (exp
, &nbytes
))
5037 /* Let the backend know that subsequent data may be byte aligned. */
5038 #ifdef md_cons_align
5042 if (op
== O_constant
)
5044 /* If we've got a constant, emit the thing directly right now. */
5046 valueT value
= exp
->X_add_number
;
5050 size
= sizeof_leb128 (value
, sign
);
5051 p
= frag_more (size
);
5052 output_leb128 (p
, value
, sign
);
5054 else if (op
== O_big
)
5056 /* O_big is a different sort of constant. */
5061 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
5062 p
= frag_more (size
);
5063 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
5067 /* Otherwise, we have to create a variable sized fragment and
5068 resolve things later. */
5070 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
5071 make_expr_symbol (exp
), 0, (char *) NULL
);
5075 /* Parse the .sleb128 and .uleb128 pseudos. */
5082 #ifdef md_flush_pending_output
5083 md_flush_pending_output ();
5089 emit_leb128_expr (&exp
, sign
);
5091 while (*input_line_pointer
++ == ',');
5093 input_line_pointer
--;
5094 demand_empty_rest_of_line ();
5098 stringer_append_char (int c
, int bitsize
)
5100 if (!target_big_endian
)
5101 FRAG_APPEND_1_CHAR (c
);
5106 FRAG_APPEND_1_CHAR (0);
5107 FRAG_APPEND_1_CHAR (0);
5108 FRAG_APPEND_1_CHAR (0);
5109 FRAG_APPEND_1_CHAR (0);
5112 FRAG_APPEND_1_CHAR (0);
5113 FRAG_APPEND_1_CHAR (0);
5116 FRAG_APPEND_1_CHAR (0);
5121 /* Called with invalid bitsize argument. */
5125 if (target_big_endian
)
5126 FRAG_APPEND_1_CHAR (c
);
5129 /* Worker to do .ascii etc statements.
5130 Reads 0 or more ',' separated, double-quoted strings.
5131 Caller should have checked need_pass_2 is FALSE because we don't
5133 Checks for end-of-line.
5134 BITS_APPENDZERO says how many bits are in a target char.
5135 The bottom bit is set if a NUL char should be appended to the strings. */
5138 stringer (int bits_appendzero
)
5140 const int bitsize
= bits_appendzero
& ~7;
5141 const int append_zero
= bits_appendzero
& 1;
5145 #ifdef md_flush_pending_output
5146 md_flush_pending_output ();
5149 #ifdef md_cons_align
5153 /* The following awkward logic is to parse ZERO or more strings,
5154 comma separated. Recall a string expression includes spaces
5155 before the opening '\"' and spaces after the closing '\"'.
5156 We fake a leading ',' if there is (supposed to be)
5157 a 1st, expression. We keep demanding expressions for each ','. */
5158 if (is_it_end_of_statement ())
5160 c
= 0; /* Skip loop. */
5161 ++input_line_pointer
; /* Compensate for end of loop. */
5165 c
= ','; /* Do loop. */
5167 /* If we have been switched into the abs_section then we
5168 will not have an obstack onto which we can hang strings. */
5169 if (now_seg
== absolute_section
)
5171 as_bad (_("strings must be placed into a section"));
5173 ignore_rest_of_line ();
5176 while (c
== ',' || c
== '<' || c
== '"')
5179 switch (*input_line_pointer
)
5182 ++input_line_pointer
; /*->1st char of string. */
5183 start
= input_line_pointer
;
5185 while (is_a_char (c
= next_char_of_string ()))
5186 stringer_append_char (c
, bitsize
);
5189 stringer_append_char (0, bitsize
);
5191 know (input_line_pointer
[-1] == '\"');
5195 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5196 will emit .string with a filename in the .debug section
5197 after a sequence of constants. See the comment in
5198 emit_expr for the sequence. emit_expr will set
5199 dwarf_file_string to non-zero if this string might be a
5200 source file name. */
5201 if (strcmp (segment_name (now_seg
), ".debug") != 0)
5202 dwarf_file_string
= 0;
5203 else if (dwarf_file_string
)
5205 c
= input_line_pointer
[-1];
5206 input_line_pointer
[-1] = '\0';
5207 listing_source_file (start
);
5208 input_line_pointer
[-1] = c
;
5215 input_line_pointer
++;
5216 c
= get_single_number ();
5217 stringer_append_char (c
, bitsize
);
5218 if (*input_line_pointer
!= '>')
5219 as_bad (_("expected <nn>"));
5221 input_line_pointer
++;
5224 input_line_pointer
++;
5228 c
= *input_line_pointer
;
5231 demand_empty_rest_of_line ();
5234 /* FIXME-SOMEDAY: I had trouble here on characters with the
5235 high bits set. We'll probably also have trouble with
5236 multibyte chars, wide chars, etc. Also be careful about
5237 returning values bigger than 1 byte. xoxorich. */
5240 next_char_of_string (void)
5242 register unsigned int c
;
5244 c
= *input_line_pointer
++ & CHAR_MASK
;
5252 as_warn (_("unterminated string; newline inserted"));
5253 bump_line_counters ();
5256 #ifndef NO_STRING_ESCAPES
5258 switch (c
= *input_line_pointer
++)
5286 break; /* As itself. */
5302 for (i
= 0, number
= 0;
5303 ISDIGIT (c
) && i
< 3;
5304 c
= *input_line_pointer
++, i
++)
5306 number
= number
* 8 + c
- '0';
5311 --input_line_pointer
;
5320 c
= *input_line_pointer
++;
5321 while (ISXDIGIT (c
))
5324 number
= number
* 16 + c
- '0';
5325 else if (ISUPPER (c
))
5326 number
= number
* 16 + c
- 'A' + 10;
5328 number
= number
* 16 + c
- 'a' + 10;
5329 c
= *input_line_pointer
++;
5332 --input_line_pointer
;
5337 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5338 as_warn (_("unterminated string; newline inserted"));
5340 bump_line_counters ();
5345 #ifdef ONLY_STANDARD_ESCAPES
5346 as_bad (_("bad escaped character in string"));
5348 #endif /* ONLY_STANDARD_ESCAPES */
5353 #endif /* ! defined (NO_STRING_ESCAPES) */
5362 get_segmented_expression (register expressionS
*expP
)
5364 register segT retval
;
5366 retval
= expression (expP
);
5367 if (expP
->X_op
== O_illegal
5368 || expP
->X_op
== O_absent
5369 || expP
->X_op
== O_big
)
5371 as_bad (_("expected address expression"));
5372 expP
->X_op
= O_constant
;
5373 expP
->X_add_number
= 0;
5374 retval
= absolute_section
;
5380 get_known_segmented_expression (register expressionS
*expP
)
5382 register segT retval
;
5384 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
5386 /* There is no easy way to extract the undefined symbol from the
5388 if (expP
->X_add_symbol
!= NULL
5389 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
5390 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5391 S_GET_NAME (expP
->X_add_symbol
));
5393 as_warn (_("some symbol undefined; zero assumed"));
5394 retval
= absolute_section
;
5395 expP
->X_op
= O_constant
;
5396 expP
->X_add_number
= 0;
5398 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
5402 char /* Return terminator. */
5403 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
5405 /* FIXME: val_pointer should probably be offsetT *. */
5406 *val_pointer
= (long) get_absolute_expression ();
5407 return (*input_line_pointer
++);
5410 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5411 Give a warning if that happens. */
5414 demand_copy_C_string (int *len_pointer
)
5418 if ((s
= demand_copy_string (len_pointer
)) != 0)
5422 for (len
= *len_pointer
; len
> 0; len
--)
5429 as_bad (_("this string may not contain \'\\0\'"));
5437 /* Demand string, but return a safe (=private) copy of the string.
5438 Return NULL if we can't read a string here. */
5441 demand_copy_string (int *lenP
)
5443 register unsigned int c
;
5449 if (*input_line_pointer
== '\"')
5451 input_line_pointer
++; /* Skip opening quote. */
5453 while (is_a_char (c
= next_char_of_string ()))
5455 obstack_1grow (¬es
, c
);
5458 /* JF this next line is so demand_copy_C_string will return a
5459 null terminated string. */
5460 obstack_1grow (¬es
, '\0');
5461 retval
= (char *) obstack_finish (¬es
);
5465 as_bad (_("missing string"));
5467 ignore_rest_of_line ();
5473 /* In: Input_line_pointer->next character.
5475 Do: Skip input_line_pointer over all whitespace.
5477 Out: 1 if input_line_pointer->end-of-line. */
5480 is_it_end_of_statement (void)
5483 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5487 equals (char *sym_name
, int reassign
)
5492 input_line_pointer
++;
5493 if (*input_line_pointer
== '=')
5494 input_line_pointer
++;
5495 if (reassign
< 0 && *input_line_pointer
== '=')
5496 input_line_pointer
++;
5498 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5499 input_line_pointer
++;
5502 stop
= mri_comment_field (&stopc
);
5504 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5508 demand_empty_rest_of_line ();
5509 mri_comment_end (stop
, stopc
);
5513 /* .incbin -- include a file verbatim at the current location. */
5516 s_incbin (int x ATTRIBUTE_UNUSED
)
5527 #ifdef md_flush_pending_output
5528 md_flush_pending_output ();
5531 #ifdef md_cons_align
5536 filename
= demand_copy_string (& len
);
5537 if (filename
== NULL
)
5542 /* Look for optional skip and count. */
5543 if (* input_line_pointer
== ',')
5545 ++ input_line_pointer
;
5546 skip
= get_absolute_expression ();
5550 if (* input_line_pointer
== ',')
5552 ++ input_line_pointer
;
5554 count
= get_absolute_expression ();
5556 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5562 demand_empty_rest_of_line ();
5564 /* Try opening absolute path first, then try include dirs. */
5565 binfile
= fopen (filename
, FOPEN_RB
);
5566 if (binfile
== NULL
)
5570 path
= (char *) xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5572 for (i
= 0; i
< include_dir_count
; i
++)
5574 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5576 binfile
= fopen (path
, FOPEN_RB
);
5577 if (binfile
!= NULL
)
5581 if (binfile
== NULL
)
5582 as_bad (_("file not found: %s"), filename
);
5585 path
= xstrdup (filename
);
5591 register_dependency (path
);
5593 /* Compute the length of the file. */
5594 if (fseek (binfile
, 0, SEEK_END
) != 0)
5596 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5599 file_len
= ftell (binfile
);
5601 /* If a count was not specified use the remainder of the file. */
5603 count
= file_len
- skip
;
5605 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5607 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5608 skip
, count
, file_len
);
5612 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5614 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5618 /* Allocate frag space and store file contents in it. */
5619 binfrag
= frag_more (count
);
5621 bytes
= fread (binfrag
, 1, count
, binfile
);
5623 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5624 path
, bytes
, count
);
5627 if (binfile
!= NULL
)
5633 /* .include -- include a file at this point. */
5636 s_include (int arg ATTRIBUTE_UNUSED
)
5645 filename
= demand_copy_string (&i
);
5646 if (filename
== NULL
)
5648 /* demand_copy_string has already printed an error and
5649 called ignore_rest_of_line. */
5657 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5658 && *input_line_pointer
!= ' '
5659 && *input_line_pointer
!= '\t')
5661 obstack_1grow (¬es
, *input_line_pointer
);
5662 ++input_line_pointer
;
5666 obstack_1grow (¬es
, '\0');
5667 filename
= (char *) obstack_finish (¬es
);
5668 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5669 ++input_line_pointer
;
5672 demand_empty_rest_of_line ();
5673 path
= (char *) xmalloc ((unsigned long) i
5674 + include_dir_maxlen
+ 5 /* slop */ );
5676 for (i
= 0; i
< include_dir_count
; i
++)
5678 strcpy (path
, include_dirs
[i
]);
5680 strcat (path
, filename
);
5681 if (0 != (try_file
= fopen (path
, FOPEN_RT
)))
5691 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5692 register_dependency (path
);
5693 input_scrub_insert_file (path
);
5697 add_include_dir (char *path
)
5701 if (include_dir_count
== 0)
5703 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5704 include_dirs
[0] = "."; /* Current dir. */
5705 include_dir_count
= 2;
5709 include_dir_count
++;
5711 (char **) realloc (include_dirs
,
5712 include_dir_count
* sizeof (*include_dirs
));
5715 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5718 if (i
> include_dir_maxlen
)
5719 include_dir_maxlen
= i
;
5722 /* Output debugging information to denote the source file. */
5725 generate_file_debug (void)
5727 if (debug_type
== DEBUG_STABS
)
5728 stabs_generate_asm_file ();
5731 /* Output line number debugging information for the current source line. */
5734 generate_lineno_debug (void)
5738 case DEBUG_UNSPECIFIED
:
5743 stabs_generate_asm_lineno ();
5746 ecoff_generate_asm_lineno ();
5749 /* ??? We could here indicate to dwarf2dbg.c that something
5750 has changed. However, since there is additional backend
5751 support that is required (calling dwarf2_emit_insn), we
5752 let dwarf2dbg.c call as_where on its own. */
5757 /* Output debugging information to mark a function entry point or end point.
5758 END_P is zero for .func, and non-zero for .endfunc. */
5763 do_s_func (end_p
, NULL
);
5766 /* Subroutine of s_func so targets can choose a different default prefix.
5767 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5770 do_s_func (int end_p
, const char *default_prefix
)
5772 /* Record the current function so that we can issue an error message for
5773 misplaced .func,.endfunc, and also so that .endfunc needs no
5775 static char *current_name
;
5776 static char *current_label
;
5780 if (current_name
== NULL
)
5782 as_bad (_("missing .func"));
5783 ignore_rest_of_line ();
5787 if (debug_type
== DEBUG_STABS
)
5788 stabs_generate_asm_endfunc (current_name
, current_label
);
5790 current_name
= current_label
= NULL
;
5795 char delim1
, delim2
;
5797 if (current_name
!= NULL
)
5799 as_bad (_(".endfunc missing for previous .func"));
5800 ignore_rest_of_line ();
5804 name
= input_line_pointer
;
5805 delim1
= get_symbol_end ();
5806 name
= xstrdup (name
);
5807 *input_line_pointer
= delim1
;
5809 if (*input_line_pointer
!= ',')
5813 if (asprintf (&label
, "%s%s", default_prefix
, name
) == -1)
5814 as_fatal ("%s", xstrerror (errno
));
5818 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5819 /* Missing entry point, use function's name with the leading
5823 if (asprintf (&label
, "%c%s", leading_char
, name
) == -1)
5824 as_fatal ("%s", xstrerror (errno
));
5832 ++input_line_pointer
;
5834 label
= input_line_pointer
;
5835 delim2
= get_symbol_end ();
5836 label
= xstrdup (label
);
5837 *input_line_pointer
= delim2
;
5840 if (debug_type
== DEBUG_STABS
)
5841 stabs_generate_asm_func (name
, label
);
5843 current_name
= name
;
5844 current_label
= label
;
5847 demand_empty_rest_of_line ();
5851 s_ignore (int arg ATTRIBUTE_UNUSED
)
5853 ignore_rest_of_line ();
5857 read_print_statistics (FILE *file
)
5859 hash_print_statistics (file
, "pseudo-op table", po_hash
);
5862 /* Inserts the given line into the input stream.
5864 This call avoids macro/conditionals nesting checking, since the contents of
5865 the line are assumed to replace the contents of a line already scanned.
5867 An appropriate use of this function would be substitution of input lines when
5868 called by md_start_line_hook(). The given line is assumed to already be
5869 properly scrubbed. */
5872 input_scrub_insert_line (const char *line
)
5876 sb_add_string (&newline
, line
);
5877 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
5879 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5882 /* Insert a file into the input stream; the path must resolve to an actual
5883 file; no include path searching or dependency registering is performed. */
5886 input_scrub_insert_file (char *path
)
5888 input_scrub_include_file (path
, input_line_pointer
);
5889 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5892 /* Find the end of a line, considering quotation and escaping of quotes. */
5894 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5895 # define TC_SINGLE_QUOTE_STRINGS 1
5899 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
,
5902 char inquote
= '\0';
5905 while (!is_end_of_line
[(unsigned char) *s
]
5906 || (inquote
&& !ISCNTRL (*s
))
5907 || (inquote
== '\'' && flag_mri
)
5908 #ifdef TC_EOL_IN_INSN
5909 || (insn
&& TC_EOL_IN_INSN (s
))
5911 /* PR 6926: When we are parsing the body of a macro the sequence
5912 \@ is special - it refers to the invocation count. If the @
5913 character happens to be registered as a line-separator character
5914 by the target, then the is_end_of_line[] test above will have
5915 returned true, but we need to ignore the line separating
5916 semantics in this particular case. */
5917 || (in_macro
&& inescape
&& *s
== '@')
5920 if (mri_string
&& *s
== '\'')
5924 else if (*s
== '\\')
5928 #ifdef TC_SINGLE_QUOTE_STRINGS
5929 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
5936 as_warn (_("missing closing `%c'"), inquote
);
5938 as_warn (_("stray `\\'"));
5943 find_end_of_line (char *s
, int mri_string
)
5945 return _find_end_of_line (s
, mri_string
, 0, 0);