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
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 2, 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) (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 char is_end_of_line
[256] = {
131 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
133 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
135 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
152 #ifndef TC_CASE_SENSITIVE
153 char original_case_string
[128];
156 /* Functions private to this file. */
158 static char *buffer
; /* 1st char of each buffer of lines is here. */
159 static char *buffer_limit
; /*->1 + last char in buffer. */
161 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
162 in the tc-<CPU>.h file. See the "Porting GAS" section of the
164 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
166 /* Variables for handling include file directory table. */
168 /* Table of pointers to directories to search for .include's. */
171 /* How many are in the table. */
172 int include_dir_count
;
174 /* Length of longest in table. */
175 int include_dir_maxlen
= 1;
177 #ifndef WORKING_DOT_WORD
178 struct broken_word
*broken_words
;
179 int new_broken_words
;
182 /* The current offset into the absolute section. We don't try to
183 build frags in the absolute section, since no data can be stored
184 there. We just keep track of the current offset. */
185 addressT abs_section_offset
;
187 /* If this line had an MRI style label, it is stored in this variable.
188 This is used by some of the MRI pseudo-ops. */
191 /* This global variable is used to support MRI common sections. We
192 translate such sections into a common symbol. This variable is
193 non-NULL when we are in an MRI common section. */
194 symbolS
*mri_common_symbol
;
196 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
197 need to align to an even byte boundary unless the next pseudo-op is
198 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
200 static int mri_pending_align
;
204 /* This variable is set to be non-zero if the next string we see might
205 be the name of the source file in DWARF debugging information. See
206 the comment in emit_expr for the format we look for. */
207 static int dwarf_file_string
;
211 static void do_s_func (int end_p
, const char *default_prefix
);
212 static void do_align (int, char *, int, int);
213 static void s_align (int, int);
214 static void s_altmacro (int);
215 static void s_bad_end (int);
216 static int hex_float (int, char *);
217 static segT
get_known_segmented_expression (expressionS
* expP
);
218 static void pobegin (void);
219 static int get_line_sb (sb
*);
220 static void generate_file_debug (void);
221 static char *_find_end_of_line (char *, int, int);
229 obj_read_begin_hook ();
231 /* Something close -- but not too close -- to a multiple of 1024.
232 The debugging malloc I'm using has 24 bytes of overhead. */
233 obstack_begin (¬es
, chunksize
);
234 obstack_begin (&cond_obstack
, chunksize
);
236 /* Use machine dependent syntax. */
237 for (p
= line_separator_chars
; *p
; p
++)
238 is_end_of_line
[(unsigned char) *p
] = 1;
239 /* Use more. FIXME-SOMEDAY. */
245 #ifndef TC_ADDRESS_BYTES
246 #define TC_ADDRESS_BYTES address_bytes
251 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
252 contain an address. */
253 int n
= (stdoutput
->arch_info
->bits_per_address
- 1) / 8;
261 /* Set up pseudo-op tables. */
263 static struct hash_control
*po_hash
;
265 static const pseudo_typeS potable
[] = {
266 {"abort", s_abort
, 0},
267 {"align", s_align_ptwo
, 0},
268 {"altmacro", s_altmacro
, 1},
269 {"ascii", stringer
, 0},
270 {"asciz", stringer
, 1},
271 {"balign", s_align_bytes
, 0},
272 {"balignw", s_align_bytes
, -2},
273 {"balignl", s_align_bytes
, -4},
277 {"common", s_mri_common
, 0},
278 {"common.s", s_mri_common
, 1},
281 #ifdef TC_ADDRESS_BYTES
285 {"dc.d", float_cons
, 'd'},
287 {"dc.s", float_cons
, 'f'},
289 {"dc.x", float_cons
, 'x'},
291 {"dcb.b", s_space
, 1},
292 {"dcb.d", s_float_space
, 'd'},
293 {"dcb.l", s_space
, 4},
294 {"dcb.s", s_float_space
, 'f'},
295 {"dcb.w", s_space
, 2},
296 {"dcb.x", s_float_space
, 'x'},
298 {"ds.b", s_space
, 1},
299 {"ds.d", s_space
, 8},
300 {"ds.l", s_space
, 4},
301 {"ds.p", s_space
, 12},
302 {"ds.s", s_space
, 4},
303 {"ds.w", s_space
, 2},
304 {"ds.x", s_space
, 12},
305 {"debug", s_ignore
, 0},
310 {"double", float_cons
, 'd'},
312 {"eject", listing_eject
, 0}, /* Formfeed listing. */
314 {"elsec", s_else
, 0},
315 {"elseif", s_elseif
, (int) O_ne
},
317 {"endc", s_endif
, 0},
318 {"endfunc", s_func
, 1},
319 {"endif", s_endif
, 0},
320 {"endm", s_bad_end
, 0},
321 {"endr", s_bad_end
, 1},
327 {"error", s_errwarn
, 1},
328 {"exitm", s_mexit
, 0},
330 {"extern", s_ignore
, 0}, /* We treat all undef as ext. */
331 {"appfile", s_app_file
, 1},
332 {"appline", s_app_line
, 0},
334 {"file", s_app_file
, 0},
336 {"float", float_cons
, 'f'},
337 {"format", s_ignore
, 0},
339 {"global", s_globl
, 0},
340 {"globl", s_globl
, 0},
342 {"if", s_if
, (int) O_ne
},
345 {"ifdef", s_ifdef
, 0},
346 {"ifeq", s_if
, (int) O_eq
},
347 {"ifeqs", s_ifeqs
, 0},
348 {"ifge", s_if
, (int) O_ge
},
349 {"ifgt", s_if
, (int) O_gt
},
350 {"ifle", s_if
, (int) O_le
},
351 {"iflt", s_if
, (int) O_lt
},
354 {"ifndef", s_ifdef
, 1},
355 {"ifne", s_if
, (int) O_ne
},
356 {"ifnes", s_ifeqs
, 1},
357 {"ifnotdef", s_ifdef
, 1},
358 {"incbin", s_incbin
, 0},
359 {"include", s_include
, 0},
365 {"lcomm", s_lcomm
, 0},
366 {"lflags", listing_flags
, 0}, /* Listing flags. */
367 {"linkonce", s_linkonce
, 0},
368 {"list", listing_list
, 1}, /* Turn listing on. */
369 {"llen", listing_psize
, 1},
372 {"macro", s_macro
, 0},
373 {"mexit", s_mexit
, 0},
375 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
376 {"name", s_ignore
, 0},
377 {"noaltmacro", s_altmacro
, 0},
378 {"noformat", s_ignore
, 0},
379 {"nolist", listing_list
, 0}, /* Turn listing off. */
380 {"nopage", listing_nopage
, 0},
382 {"offset", s_struct
, 0},
384 {"p2align", s_align_ptwo
, 0},
385 {"p2alignw", s_align_ptwo
, -2},
386 {"p2alignl", s_align_ptwo
, -4},
387 {"page", listing_eject
, 0},
388 {"plen", listing_psize
, 0},
389 {"print", s_print
, 0},
390 {"psize", listing_psize
, 0}, /* Set paper size. */
391 {"purgem", s_purgem
, 0},
396 {"sbttl", listing_title
, 1}, /* Subtitle of listing. */
401 {"single", float_cons
, 'f'},
403 {"space", s_space
, 0},
404 {"skip", s_space
, 0},
405 {"sleb128", s_leb128
, 1},
406 {"spc", s_ignore
, 0},
407 {"stabd", s_stab
, 'd'},
408 {"stabn", s_stab
, 'n'},
409 {"stabs", s_stab
, 's'},
410 {"string", stringer
, 1},
411 {"struct", s_struct
, 0},
415 /* This is for gcc to use. It's only just been added (2/94), so gcc
416 won't be able to use it for a while -- probably a year or more.
417 But once this has been released, check with gcc maintainers
418 before deleting it or even changing the spelling. */
419 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
420 /* If we're folding case -- done for some targets, not necessarily
421 all -- the above string in an input file will be converted to
422 this one. Match it either way... */
423 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
425 {"title", listing_title
, 0}, /* Listing title. */
426 {"ttl", listing_title
, 0},
428 {"uleb128", s_leb128
, 0},
432 {"xdef", s_globl
, 0},
433 {"xref", s_ignore
, 0},
434 {"xstabs", s_xstab
, 's'},
435 {"warning", s_errwarn
, 0},
436 {"weakref", s_weakref
, 0},
438 {"zero", s_space
, 0},
439 {NULL
, NULL
, 0} /* End sentinel. */
443 get_absolute_expr (expressionS
*exp
)
445 expression_and_evaluate (exp
);
446 if (exp
->X_op
!= O_constant
)
448 if (exp
->X_op
!= O_absent
)
449 as_bad (_("bad or irreducible absolute expression"));
450 exp
->X_add_number
= 0;
452 return exp
->X_add_number
;
456 get_absolute_expression (void)
460 return get_absolute_expr (&exp
);
463 static int pop_override_ok
= 0;
464 static const char *pop_table_name
;
467 pop_insert (const pseudo_typeS
*table
)
470 const pseudo_typeS
*pop
;
471 for (pop
= table
; pop
->poc_name
; pop
++)
473 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
474 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
475 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
480 #ifndef md_pop_insert
481 #define md_pop_insert() pop_insert(md_pseudo_table)
484 #ifndef obj_pop_insert
485 #define obj_pop_insert() pop_insert(obj_pseudo_table)
488 #ifndef cfi_pop_insert
489 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
495 po_hash
= hash_new ();
497 /* Do the target-specific pseudo ops. */
498 pop_table_name
= "md";
501 /* Now object specific. Skip any that were in the target table. */
502 pop_table_name
= "obj";
506 /* Now portable ones. Skip any that we've seen already. */
507 pop_table_name
= "standard";
508 pop_insert (potable
);
510 #ifdef TARGET_USE_CFIPOP
511 pop_table_name
= "cfi";
517 #define HANDLE_CONDITIONAL_ASSEMBLY() \
518 if (ignore_input ()) \
520 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
521 input_line_pointer = (input_line_pointer <= buffer_limit \
522 && eol >= buffer_limit) \
528 /* This function is used when scrubbing the characters between #APP
531 static char *scrub_string
;
532 static char *scrub_string_end
;
535 scrub_from_string (char *buf
, int buflen
)
539 copy
= scrub_string_end
- scrub_string
;
542 memcpy (buf
, scrub_string
, copy
);
543 scrub_string
+= copy
;
547 /* Helper function of read_a_source_file, which tries to expand a macro. */
549 try_macro (char term
, const char *line
)
555 if (check_macro (line
, &out
, &err
, ¯o
))
559 *input_line_pointer
++ = term
;
560 input_scrub_include_sb (&out
,
561 input_line_pointer
, 1);
564 input_scrub_next_buffer (&input_line_pointer
);
566 md_macro_info (macro
);
573 /* We read the file, putting things into a web that represents what we
574 have been reading. */
576 read_a_source_file (char *name
)
579 register char *s
; /* String of symbol, '\0' appended. */
587 buffer
= input_scrub_new_file (name
);
590 listing_newline (NULL
);
591 register_dependency (name
);
593 /* Generate debugging information before we've read anything in to denote
594 this file as the "main" source file and not a subordinate one
595 (e.g. N_SO vs N_SOL in stabs). */
596 generate_file_debug ();
598 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
599 { /* We have another line to parse. */
601 /* In order to avoid listing macro expansion lines with labels
602 multiple times, keep track of which line was last issued. */
603 static char *last_eol
;
607 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
609 while (input_line_pointer
< buffer_limit
)
611 /* We have more of this buffer to parse. */
613 /* We now have input_line_pointer->1st char of next line.
614 If input_line_pointer [-1] == '\n' then we just
615 scanned another line: so bump line counters. */
616 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
618 #ifdef md_start_line_hook
619 md_start_line_hook ();
621 if (input_line_pointer
[-1] == '\n')
622 bump_line_counters ();
626 if (LABELS_WITHOUT_COLONS
|| flag_m68k_mri
)
628 /* Text at the start of a line must be a label, we
629 run down and stick a colon in. */
630 if (is_name_beginner (*input_line_pointer
))
632 char *line_start
= input_line_pointer
;
637 HANDLE_CONDITIONAL_ASSEMBLY ();
639 c
= get_symbol_end ();
641 /* In MRI mode, the EQU and MACRO pseudoops must
642 be handled specially. */
646 char *rest
= input_line_pointer
+ 1;
650 if (*rest
== ' ' || *rest
== '\t')
652 if ((strncasecmp (rest
, "EQU", 3) == 0
653 || strncasecmp (rest
, "SET", 3) == 0)
654 && (rest
[3] == ' ' || rest
[3] == '\t'))
656 input_line_pointer
= rest
+ 3;
658 strncasecmp (rest
, "SET", 3) == 0);
661 if (strncasecmp (rest
, "MACRO", 5) == 0
664 || is_end_of_line
[(unsigned char) rest
[5]]))
668 /* In MRI mode, we need to handle the MACRO
669 pseudo-op specially: we don't want to put the
670 symbol in the symbol table. */
672 #ifdef TC_START_LABEL_WITHOUT_COLON
673 && TC_START_LABEL_WITHOUT_COLON(c
,
677 line_label
= colon (line_start
);
679 line_label
= symbol_create (line_start
,
684 *input_line_pointer
= c
;
686 input_line_pointer
++;
691 /* We are at the beginning of a line, or similar place.
692 We expect a well-formed assembler statement.
693 A "symbol-name:" is a statement.
695 Depending on what compiler is used, the order of these tests
696 may vary to catch most common case 1st.
697 Each test is independent of all other tests at the (top) level.
698 PLEASE make a compiler that doesn't use this assembler.
699 It is crufty to waste a compiler's time encoding things for this
700 assembler, which then wastes more time decoding it.
701 (And communicating via (linear) files is silly!
702 If you must pass stuff, please pass a tree!) */
703 if ((c
= *input_line_pointer
++) == '\t'
707 c
= *input_line_pointer
++;
709 know (c
!= ' '); /* No further leading whitespace. */
712 /* If listing is on, and we are expanding a macro, then give
713 the listing code the contents of the expanded line. */
716 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
721 /* Find the end of the current expanded macro line. */
722 s
= find_end_of_line (input_line_pointer
- 1, flag_m68k_mri
);
727 /* Copy it for safe keeping. Also give an indication of
728 how much macro nesting is involved at this point. */
729 len
= s
- (input_line_pointer
- 1);
730 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
731 memset (copy
, '>', macro_nest
);
732 copy
[macro_nest
] = ' ';
733 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
- 1, len
);
734 copy
[macro_nest
+ 1 + len
] = '\0';
736 /* Install the line with the listing facility. */
737 listing_newline (copy
);
741 listing_newline (NULL
);
744 /* C is the 1st significant character.
745 Input_line_pointer points after that character. */
746 if (is_name_beginner (c
))
748 /* Want user-defined label or pseudo/opcode. */
749 HANDLE_CONDITIONAL_ASSEMBLY ();
751 s
= --input_line_pointer
;
752 c
= get_symbol_end (); /* name's delimiter. */
754 /* C is character after symbol.
755 That character's place in the input line is now '\0'.
756 S points to the beginning of the symbol.
757 [In case of pseudo-op, s->'.'.]
758 Input_line_pointer->'\0' where c was. */
759 if (TC_START_LABEL (c
, input_line_pointer
))
763 char *rest
= input_line_pointer
+ 1;
765 /* In MRI mode, \tsym: set 0 is permitted. */
769 if (*rest
== ' ' || *rest
== '\t')
772 if ((strncasecmp (rest
, "EQU", 3) == 0
773 || strncasecmp (rest
, "SET", 3) == 0)
774 && (rest
[3] == ' ' || rest
[3] == '\t'))
776 input_line_pointer
= rest
+ 3;
782 line_label
= colon (s
); /* User-defined label. */
783 /* Put ':' back for error messages' sake. */
784 *input_line_pointer
++ = ':';
785 #ifdef tc_check_label
786 tc_check_label (line_label
);
788 /* Input_line_pointer->after ':'. */
791 else if (input_line_pointer
[1] == '='
793 || ((c
== ' ' || c
== '\t')
794 && input_line_pointer
[2] == '=')))
797 demand_empty_rest_of_line ();
800 || ((c
== ' ' || c
== '\t')
801 && input_line_pointer
[1] == '='))
802 #ifdef TC_EQUAL_IN_INSN
803 && !TC_EQUAL_IN_INSN (c
, s
)
808 demand_empty_rest_of_line ();
812 /* Expect pseudo-op or machine instruction. */
815 #ifndef TC_CASE_SENSITIVE
819 strncpy (original_case_string
, s2
, sizeof (original_case_string
));
820 original_case_string
[sizeof (original_case_string
) - 1] = 0;
829 if (NO_PSEUDO_DOT
|| flag_m68k_mri
)
831 /* The MRI assembler uses pseudo-ops without
833 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
834 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
839 || (!flag_m68k_mri
&& *s
== '.'))
843 WARNING: c has next char, which may be end-of-line.
844 We lookup the pseudo-op table with s+1 because we
845 already know that the pseudo-op begins with a '.'. */
848 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
849 if (pop
&& !pop
->poc_handler
)
852 /* In MRI mode, we may need to insert an
853 automatic alignment directive. What a hack
855 if (mri_pending_align
857 || !((pop
->poc_handler
== cons
858 && pop
->poc_val
== 1)
859 || (pop
->poc_handler
== s_space
860 && pop
->poc_val
== 1)
861 #ifdef tc_conditional_pseudoop
862 || tc_conditional_pseudoop (pop
)
864 || pop
->poc_handler
== s_if
865 || pop
->poc_handler
== s_ifdef
866 || pop
->poc_handler
== s_ifc
867 || pop
->poc_handler
== s_ifeqs
868 || pop
->poc_handler
== s_else
869 || pop
->poc_handler
== s_endif
870 || pop
->poc_handler
== s_globl
871 || pop
->poc_handler
== s_ignore
)))
873 do_align (1, (char *) NULL
, 0, 0);
874 mri_pending_align
= 0;
876 if (line_label
!= NULL
)
878 symbol_set_frag (line_label
, frag_now
);
879 S_SET_VALUE (line_label
, frag_now_fix ());
883 /* Print the error msg now, while we still can. */
886 char *end
= input_line_pointer
;
888 *input_line_pointer
= c
;
890 c
= *--input_line_pointer
;
891 *input_line_pointer
= '\0';
892 if (! macro_defined
|| ! try_macro (c
, s
))
895 as_bad (_("unknown pseudo-op: `%s'"), s
);
896 *input_line_pointer
++ = c
;
901 /* Put it back for error messages etc. */
902 *input_line_pointer
= c
;
903 /* The following skip of whitespace is compulsory.
904 A well shaped space is sometimes all that separates
905 keyword from operands. */
906 if (c
== ' ' || c
== '\t')
907 input_line_pointer
++;
909 /* Input_line is restored.
910 Input_line_pointer->1st non-blank char
911 after pseudo-operation. */
912 (*pop
->poc_handler
) (pop
->poc_val
);
914 /* If that was .end, just get out now. */
915 if (pop
->poc_handler
== s_end
)
920 /* WARNING: c has char, which may be end-of-line. */
921 /* Also: input_line_pointer->`\0` where c was. */
922 *input_line_pointer
= c
;
923 input_line_pointer
= _find_end_of_line (input_line_pointer
, flag_m68k_mri
, 1);
924 c
= *input_line_pointer
;
925 *input_line_pointer
= '\0';
927 generate_lineno_debug ();
929 if (macro_defined
&& try_macro (c
, s
))
932 if (mri_pending_align
)
934 do_align (1, (char *) NULL
, 0, 0);
935 mri_pending_align
= 0;
936 if (line_label
!= NULL
)
938 symbol_set_frag (line_label
, frag_now
);
939 S_SET_VALUE (line_label
, frag_now_fix ());
943 md_assemble (s
); /* Assemble 1 instruction. */
945 *input_line_pointer
++ = c
;
947 /* We resume loop AFTER the end-of-line from
954 /* Empty statement? */
955 if (is_end_of_line
[(unsigned char) c
])
958 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
) && ISDIGIT (c
))
960 /* local label ("4:") */
961 char *backup
= input_line_pointer
;
963 HANDLE_CONDITIONAL_ASSEMBLY ();
967 /* Read the whole number. */
968 while (ISDIGIT (*input_line_pointer
))
970 temp
= (temp
* 10) + *input_line_pointer
- '0';
971 ++input_line_pointer
;
974 if (LOCAL_LABELS_DOLLAR
975 && *input_line_pointer
== '$'
976 && *(input_line_pointer
+ 1) == ':')
978 input_line_pointer
+= 2;
980 if (dollar_label_defined (temp
))
982 as_fatal (_("label \"%d$\" redefined"), temp
);
985 define_dollar_label (temp
);
986 colon (dollar_label_name (temp
, 0));
991 && *input_line_pointer
++ == ':')
993 fb_label_instance_inc (temp
);
994 colon (fb_label_name (temp
, 0));
998 input_line_pointer
= backup
;
999 } /* local label ("4:") */
1001 if (c
&& strchr (line_comment_chars
, c
))
1002 { /* Its a comment. Better say APP or NO_APP. */
1007 unsigned int new_length
;
1010 bump_line_counters ();
1011 s
= input_line_pointer
;
1012 if (strncmp (s
, "APP\n", 4))
1013 continue; /* We ignore it */
1017 ends
= strstr (s
, "#NO_APP\n");
1021 unsigned int tmp_len
;
1024 /* The end of the #APP wasn't in this buffer. We
1025 keep reading in buffers until we find the #NO_APP
1026 that goes with this #APP There is one. The specs
1028 tmp_len
= buffer_limit
- s
;
1029 tmp_buf
= xmalloc (tmp_len
+ 1);
1030 memcpy (tmp_buf
, s
, tmp_len
);
1033 new_tmp
= input_scrub_next_buffer (&buffer
);
1037 buffer_limit
= new_tmp
;
1038 input_line_pointer
= buffer
;
1039 ends
= strstr (buffer
, "#NO_APP\n");
1041 num
= ends
- buffer
;
1043 num
= buffer_limit
- buffer
;
1045 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
1046 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
1051 input_line_pointer
= ends
? ends
+ 8 : NULL
;
1059 input_line_pointer
= ends
+ 8;
1063 scrub_string_end
= ends
;
1065 new_length
= ends
- s
;
1066 new_buf
= (char *) xmalloc (new_length
);
1073 space
= (new_buf
+ new_length
) - new_tmp
;
1074 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1082 new_buf
= xrealloc (new_buf
, new_length
+ 100);
1083 new_tmp
= new_buf
+ new_length
;
1090 /* We've "scrubbed" input to the preferred format. In the
1091 process we may have consumed the whole of the remaining
1092 file (and included files). We handle this formatted
1093 input similar to that of macro expansion, letting
1094 actual macro expansion (possibly nested) and other
1095 input expansion work. Beware that in messages, line
1096 numbers and possibly file names will be incorrect. */
1097 sb_add_string (&sbuf
, new_buf
);
1098 input_scrub_include_sb (&sbuf
, input_line_pointer
, 0);
1100 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1105 HANDLE_CONDITIONAL_ASSEMBLY ();
1107 #ifdef tc_unrecognized_line
1108 if (tc_unrecognized_line (c
))
1111 input_line_pointer
--;
1112 /* Report unknown char as ignored. */
1113 demand_empty_rest_of_line ();
1116 #ifdef md_after_pass_hook
1117 md_after_pass_hook ();
1126 /* Close the input file. */
1127 input_scrub_close ();
1128 #ifdef WARN_COMMENTS
1130 if (warn_comment
&& found_comment
)
1131 as_warn_where (found_comment_file
, found_comment
,
1132 "first comment found here");
1137 /* Convert O_constant expression EXP into the equivalent O_big representation.
1138 Take the sign of the number from X_unsigned rather than X_add_number. */
1141 convert_to_bignum (expressionS
*exp
)
1146 value
= exp
->X_add_number
;
1147 for (i
= 0; i
< sizeof (exp
->X_add_number
) / CHARS_PER_LITTLENUM
; i
++)
1149 generic_bignum
[i
] = value
& LITTLENUM_MASK
;
1150 value
>>= LITTLENUM_NUMBER_OF_BITS
;
1152 /* Add a sequence of sign bits if the top bit of X_add_number is not
1153 the sign of the original value. */
1154 if ((exp
->X_add_number
< 0) != !exp
->X_unsigned
)
1155 generic_bignum
[i
++] = exp
->X_unsigned
? 0 : LITTLENUM_MASK
;
1157 exp
->X_add_number
= i
;
1160 /* For most MRI pseudo-ops, the line actually ends at the first
1161 nonquoted space. This function looks for that point, stuffs a null
1162 in, and sets *STOPCP to the character that used to be there, and
1163 returns the location.
1165 Until I hear otherwise, I am going to assume that this is only true
1166 for the m68k MRI assembler. */
1169 mri_comment_field (char *stopcp
)
1175 know (flag_m68k_mri
);
1177 for (s
= input_line_pointer
;
1178 ((!is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1186 for (s
= input_line_pointer
;
1187 !is_end_of_line
[(unsigned char) *s
];
1197 /* Skip to the end of an MRI comment field. */
1200 mri_comment_end (char *stop
, int stopc
)
1204 input_line_pointer
= stop
;
1206 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1207 ++input_line_pointer
;
1211 s_abort (int ignore ATTRIBUTE_UNUSED
)
1213 as_fatal (_(".abort detected. Abandoning ship."));
1216 /* Guts of .align directive. N is the power of two to which to align.
1217 FILL may be NULL, or it may point to the bytes of the fill pattern.
1218 LEN is the length of whatever FILL points to, if anything. MAX is
1219 the maximum number of characters to skip when doing the alignment,
1220 or 0 if there is no maximum. */
1223 do_align (int n
, char *fill
, int len
, int max
)
1225 if (now_seg
== absolute_section
)
1229 if (*fill
++ != '\0')
1231 as_warn (_("ignoring fill value in absolute section"));
1238 #ifdef md_flush_pending_output
1239 md_flush_pending_output ();
1242 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1245 /* Only make a frag if we HAVE to... */
1246 if (n
!= 0 && !need_pass_2
)
1250 if (subseg_text_p (now_seg
))
1251 frag_align_code (n
, max
);
1253 frag_align (n
, 0, max
);
1256 frag_align (n
, *fill
, max
);
1258 frag_align_pattern (n
, fill
, len
, max
);
1262 just_record_alignment
: ATTRIBUTE_UNUSED_LABEL
1265 record_alignment (now_seg
, n
- OCTETS_PER_BYTE_POWER
);
1268 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1269 (in bytes). A negative ARG is the negative of the length of the
1270 fill pattern. BYTES_P is non-zero if the alignment value should be
1271 interpreted as the byte boundary, rather than the power of 2. */
1273 #define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1276 s_align (int arg
, int bytes_p
)
1278 unsigned int align_limit
= ALIGN_LIMIT
;
1287 stop
= mri_comment_field (&stopc
);
1289 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1294 align
= arg
; /* Default value from pseudo-op table. */
1298 align
= get_absolute_expression ();
1304 /* Convert to a power of 2. */
1309 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1312 as_bad (_("alignment not a power of 2"));
1318 if (align
> align_limit
)
1320 align
= align_limit
;
1321 as_warn (_("alignment too large: %u assumed"), align
);
1324 if (*input_line_pointer
!= ',')
1331 ++input_line_pointer
;
1332 if (*input_line_pointer
== ',')
1336 fill
= get_absolute_expression ();
1341 if (*input_line_pointer
!= ',')
1345 ++input_line_pointer
;
1346 max
= get_absolute_expression ();
1353 as_warn (_("expected fill pattern missing"));
1354 do_align (align
, (char *) NULL
, 0, max
);
1369 do_align (align
, &fill_char
, fill_len
, max
);
1375 if ((size_t) fill_len
> sizeof ab
)
1377 md_number_to_chars (ab
, fill
, fill_len
);
1378 do_align (align
, ab
, fill_len
, max
);
1382 demand_empty_rest_of_line ();
1385 mri_comment_end (stop
, stopc
);
1388 /* Handle the .align pseudo-op on machines where ".align 4" means
1389 align to a 4 byte boundary. */
1392 s_align_bytes (int arg
)
1397 /* Handle the .align pseudo-op on machines where ".align 4" means align
1398 to a 2**4 boundary. */
1401 s_align_ptwo (int arg
)
1406 /* Switch in and out of alternate macro mode. */
1411 demand_empty_rest_of_line ();
1412 macro_set_alternate (on
);
1416 s_comm_internal (int param
,
1417 symbolS
*(*comm_parse_extra
) (int, symbolS
*, addressT
))
1423 symbolS
*symbolP
= NULL
;
1429 stop
= mri_comment_field (&stopc
);
1431 name
= input_line_pointer
;
1432 c
= get_symbol_end ();
1433 /* Just after name is now '\0'. */
1434 p
= input_line_pointer
;
1439 as_bad (_("expected symbol name"));
1440 ignore_rest_of_line ();
1446 /* Accept an optional comma after the name. The comma used to be
1447 required, but Irix 5 cc does not generate it for .lcomm. */
1448 if (*input_line_pointer
== ',')
1449 input_line_pointer
++;
1451 temp
= get_absolute_expr (&exp
);
1453 size
&= ((offsetT
) 2 << (stdoutput
->arch_info
->bits_per_address
- 1)) - 1;
1454 if (exp
.X_op
== O_absent
)
1456 as_bad (_("missing size expression"));
1457 ignore_rest_of_line ();
1460 else if (temp
!= size
|| !exp
.X_unsigned
)
1462 as_warn (_("size (%ld) out of range, ignored"), (long) temp
);
1463 ignore_rest_of_line ();
1468 symbolP
= symbol_find_or_make (name
);
1469 if ((S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
1470 && !S_IS_COMMON (symbolP
))
1472 if (!S_IS_VOLATILE (symbolP
))
1475 as_bad (_("symbol `%s' is already defined"), name
);
1477 ignore_rest_of_line ();
1480 symbolP
= symbol_clone (symbolP
, 1);
1481 S_SET_SEGMENT (symbolP
, undefined_section
);
1482 S_SET_VALUE (symbolP
, 0);
1483 symbol_set_frag (symbolP
, &zero_address_frag
);
1484 S_CLEAR_VOLATILE (symbolP
);
1487 size
= S_GET_VALUE (symbolP
);
1490 else if (size
!= temp
)
1491 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1492 name
, (long) size
, (long) temp
);
1495 if (comm_parse_extra
!= NULL
)
1496 symbolP
= (*comm_parse_extra
) (param
, symbolP
, size
);
1499 S_SET_VALUE (symbolP
, (valueT
) size
);
1500 S_SET_EXTERNAL (symbolP
);
1501 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1504 extern int flag_one
;
1505 if (size
== 0 || !flag_one
)
1506 S_GET_OTHER (symbolP
) = const_flag
;
1511 demand_empty_rest_of_line ();
1514 mri_comment_end (stop
, stopc
);
1521 s_comm_internal (ignore
, NULL
);
1524 /* The MRI COMMON pseudo-op. We handle this by creating a common
1525 symbol with the appropriate name. We make s_space do the right
1526 thing by increasing the size. */
1529 s_mri_common (int small ATTRIBUTE_UNUSED
)
1545 stop
= mri_comment_field (&stopc
);
1549 name
= input_line_pointer
;
1550 if (!ISDIGIT (*name
))
1551 c
= get_symbol_end ();
1556 ++input_line_pointer
;
1558 while (ISDIGIT (*input_line_pointer
));
1560 c
= *input_line_pointer
;
1561 *input_line_pointer
= '\0';
1563 if (line_label
!= NULL
)
1565 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1566 + (input_line_pointer
- name
)
1568 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1573 sym
= symbol_find_or_make (name
);
1574 *input_line_pointer
= c
;
1578 if (*input_line_pointer
!= ',')
1582 ++input_line_pointer
;
1583 align
= get_absolute_expression ();
1586 if (S_IS_DEFINED (sym
) && !S_IS_COMMON (sym
))
1588 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym
));
1589 ignore_rest_of_line ();
1590 mri_comment_end (stop
, stopc
);
1594 S_SET_EXTERNAL (sym
);
1595 S_SET_SEGMENT (sym
, bfd_com_section_ptr
);
1596 mri_common_symbol
= sym
;
1600 S_SET_ALIGN (sym
, align
);
1603 if (line_label
!= NULL
)
1606 exp
.X_op
= O_symbol
;
1607 exp
.X_add_symbol
= sym
;
1608 exp
.X_add_number
= 0;
1609 symbol_set_value_expression (line_label
, &exp
);
1610 symbol_set_frag (line_label
, &zero_address_frag
);
1611 S_SET_SEGMENT (line_label
, expr_section
);
1614 /* FIXME: We just ignore the small argument, which distinguishes
1615 COMMON and COMMON.S. I don't know what we can do about it. */
1617 /* Ignore the type and hptype. */
1618 if (*input_line_pointer
== ',')
1619 input_line_pointer
+= 2;
1620 if (*input_line_pointer
== ',')
1621 input_line_pointer
+= 2;
1623 demand_empty_rest_of_line ();
1625 mri_comment_end (stop
, stopc
);
1629 s_data (int ignore ATTRIBUTE_UNUSED
)
1634 temp
= get_absolute_expression ();
1635 if (flag_readonly_data_in_text
)
1637 section
= text_section
;
1641 section
= data_section
;
1643 subseg_set (section
, (subsegT
) temp
);
1648 demand_empty_rest_of_line ();
1651 /* Handle the .appfile pseudo-op. This is automatically generated by
1652 do_scrub_chars when a preprocessor # line comment is seen with a
1653 file name. This default definition may be overridden by the object
1654 or CPU specific pseudo-ops. This function is also the default
1655 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1659 s_app_file_string (char *file
, int appfile ATTRIBUTE_UNUSED
)
1663 listing_source_file (file
);
1665 register_dependency (file
);
1667 obj_app_file (file
, appfile
);
1672 s_app_file (int appfile
)
1677 /* Some assemblers tolerate immediately following '"'. */
1678 if ((s
= demand_copy_string (&length
)) != 0)
1680 /* If this is a fake .appfile, a fake newline was inserted into
1681 the buffer. Passing -2 to new_logical_line tells it to
1684 = (!new_logical_line (s
, appfile
? -2 : -1) && appfile
);
1686 /* In MRI mode, the preprocessor may have inserted an extraneous
1689 && *input_line_pointer
== '\''
1690 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1691 ++input_line_pointer
;
1693 demand_empty_rest_of_line ();
1695 s_app_file_string (s
, appfile
);
1699 /* Handle the .appline pseudo-op. This is automatically generated by
1700 do_scrub_chars when a preprocessor # line comment is seen. This
1701 default definition may be overridden by the object or CPU specific
1705 s_app_line (int ignore ATTRIBUTE_UNUSED
)
1709 /* The given number is that of the next line. */
1710 l
= get_absolute_expression () - 1;
1713 /* Some of the back ends can't deal with non-positive line numbers.
1714 Besides, it's silly. GCC however will generate a line number of
1715 zero when it is pre-processing builtins for assembler-with-cpp files:
1719 We do not want to barf on this, especially since such files are used
1720 in the GCC and GDB testsuites. So we check for negative line numbers
1721 rather than non-positive line numbers. */
1722 as_warn (_("line numbers must be positive; line number %d rejected"),
1726 new_logical_line ((char *) NULL
, l
);
1729 listing_source_line (l
);
1732 demand_empty_rest_of_line ();
1735 /* Handle the .end pseudo-op. Actually, the real work is done in
1736 read_a_source_file. */
1739 s_end (int ignore ATTRIBUTE_UNUSED
)
1743 /* The MRI assembler permits the start symbol to follow .end,
1744 but we don't support that. */
1746 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
1747 && *input_line_pointer
!= '*'
1748 && *input_line_pointer
!= '!')
1749 as_warn (_("start address not supported"));
1753 /* Handle the .err pseudo-op. */
1756 s_err (int ignore ATTRIBUTE_UNUSED
)
1758 as_bad (_(".err encountered"));
1759 demand_empty_rest_of_line ();
1762 /* Handle the .error and .warning pseudo-ops. */
1768 /* The purpose for the conditional assignment is not to
1769 internationalize the directive itself, but that we need a
1770 self-contained message, one that can be passed like the
1771 demand_copy_C_string return value, and with no assumption on the
1772 location of the name of the directive within the message. */
1774 = (err
? _(".error directive invoked in source file")
1775 : _(".warning directive invoked in source file"));
1777 if (!is_it_end_of_statement ())
1779 if (*input_line_pointer
!= '\"')
1781 as_bad (_("%s argument must be a string"),
1782 err
? ".error" : ".warning");
1783 ignore_rest_of_line ();
1787 msg
= demand_copy_C_string (&len
);
1795 as_warn ("%s", msg
);
1796 demand_empty_rest_of_line ();
1799 /* Handle the MRI fail pseudo-op. */
1802 s_fail (int ignore ATTRIBUTE_UNUSED
)
1809 stop
= mri_comment_field (&stopc
);
1811 temp
= get_absolute_expression ();
1813 as_warn (_(".fail %ld encountered"), (long) temp
);
1815 as_bad (_(".fail %ld encountered"), (long) temp
);
1817 demand_empty_rest_of_line ();
1820 mri_comment_end (stop
, stopc
);
1824 s_fill (int ignore ATTRIBUTE_UNUSED
)
1826 expressionS rep_exp
;
1828 register long fill
= 0;
1831 #ifdef md_flush_pending_output
1832 md_flush_pending_output ();
1835 get_known_segmented_expression (&rep_exp
);
1836 if (*input_line_pointer
== ',')
1838 input_line_pointer
++;
1839 size
= get_absolute_expression ();
1840 if (*input_line_pointer
== ',')
1842 input_line_pointer
++;
1843 fill
= get_absolute_expression ();
1847 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1848 #define BSD_FILL_SIZE_CROCK_8 (8)
1849 if (size
> BSD_FILL_SIZE_CROCK_8
)
1851 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8
);
1852 size
= BSD_FILL_SIZE_CROCK_8
;
1856 as_warn (_("size negative; .fill ignored"));
1859 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
1861 if (rep_exp
.X_add_number
< 0)
1862 as_warn (_("repeat < 0; .fill ignored"));
1866 if (size
&& !need_pass_2
)
1868 if (rep_exp
.X_op
== O_constant
)
1870 p
= frag_var (rs_fill
, (int) size
, (int) size
,
1871 (relax_substateT
) 0, (symbolS
*) 0,
1872 (offsetT
) rep_exp
.X_add_number
,
1877 /* We don't have a constant repeat count, so we can't use
1878 rs_fill. We can get the same results out of rs_space,
1879 but its argument is in bytes, so we must multiply the
1880 repeat count by size. */
1883 rep_sym
= make_expr_symbol (&rep_exp
);
1886 expressionS size_exp
;
1887 size_exp
.X_op
= O_constant
;
1888 size_exp
.X_add_number
= size
;
1890 rep_exp
.X_op
= O_multiply
;
1891 rep_exp
.X_add_symbol
= rep_sym
;
1892 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
1893 rep_exp
.X_add_number
= 0;
1894 rep_sym
= make_expr_symbol (&rep_exp
);
1897 p
= frag_var (rs_space
, (int) size
, (int) size
,
1898 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
1901 memset (p
, 0, (unsigned int) size
);
1903 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1904 flavoured AS. The following bizarre behaviour is to be
1905 compatible with above. I guess they tried to take up to 8
1906 bytes from a 4-byte expression and they forgot to sign
1908 #define BSD_FILL_SIZE_CROCK_4 (4)
1909 md_number_to_chars (p
, (valueT
) fill
,
1910 (size
> BSD_FILL_SIZE_CROCK_4
1911 ? BSD_FILL_SIZE_CROCK_4
1913 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1914 but emits no error message because it seems a legal thing to do.
1915 It is a degenerate case of .fill but could be emitted by a
1918 demand_empty_rest_of_line ();
1922 s_globl (int ignore ATTRIBUTE_UNUSED
)
1931 stop
= mri_comment_field (&stopc
);
1935 name
= input_line_pointer
;
1936 c
= get_symbol_end ();
1937 symbolP
= symbol_find_or_make (name
);
1938 S_SET_EXTERNAL (symbolP
);
1940 *input_line_pointer
= c
;
1942 c
= *input_line_pointer
;
1945 input_line_pointer
++;
1947 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1953 demand_empty_rest_of_line ();
1956 mri_comment_end (stop
, stopc
);
1959 /* Handle the MRI IRP and IRPC pseudo-ops. */
1970 as_where (&file
, &line
);
1973 eol
= find_end_of_line (input_line_pointer
, 0);
1974 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
1975 input_line_pointer
= eol
;
1979 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
);
1981 as_bad_where (file
, line
, "%s", err
);
1985 input_scrub_include_sb (&out
, input_line_pointer
, 1);
1987 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1990 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1991 the section to only be linked once. However, this is not supported
1992 by most object file formats. This takes an optional argument,
1993 which is what to do about duplicates. */
1996 s_linkonce (int ignore ATTRIBUTE_UNUSED
)
1998 enum linkonce_type type
;
2002 type
= LINKONCE_DISCARD
;
2004 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2009 s
= input_line_pointer
;
2010 c
= get_symbol_end ();
2011 if (strcasecmp (s
, "discard") == 0)
2012 type
= LINKONCE_DISCARD
;
2013 else if (strcasecmp (s
, "one_only") == 0)
2014 type
= LINKONCE_ONE_ONLY
;
2015 else if (strcasecmp (s
, "same_size") == 0)
2016 type
= LINKONCE_SAME_SIZE
;
2017 else if (strcasecmp (s
, "same_contents") == 0)
2018 type
= LINKONCE_SAME_CONTENTS
;
2020 as_warn (_("unrecognized .linkonce type `%s'"), s
);
2022 *input_line_pointer
= c
;
2025 #ifdef obj_handle_link_once
2026 obj_handle_link_once (type
);
2027 #else /* ! defined (obj_handle_link_once) */
2031 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
2032 as_warn (_(".linkonce is not supported for this object file format"));
2034 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
2035 flags
|= SEC_LINK_ONCE
;
2040 case LINKONCE_DISCARD
:
2041 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
2043 case LINKONCE_ONE_ONLY
:
2044 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
2046 case LINKONCE_SAME_SIZE
:
2047 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
2049 case LINKONCE_SAME_CONTENTS
:
2050 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
2053 if (!bfd_set_section_flags (stdoutput
, now_seg
, flags
))
2054 as_bad (_("bfd_set_section_flags: %s"),
2055 bfd_errmsg (bfd_get_error ()));
2057 #endif /* ! defined (obj_handle_link_once) */
2059 demand_empty_rest_of_line ();
2063 bss_alloc (symbolS
*symbolP
, addressT size
, int align
)
2066 segT current_seg
= now_seg
;
2067 subsegT current_subseg
= now_subseg
;
2068 segT bss_seg
= bss_section
;
2070 #if defined (TC_MIPS) || defined (TC_ALPHA)
2071 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
2072 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
2074 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2075 if (size
<= bfd_get_gp_size (stdoutput
))
2077 bss_seg
= subseg_new (".sbss", 1);
2078 seg_info (bss_seg
)->bss
= 1;
2079 if (!bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
2080 as_warn (_("error setting flags for \".sbss\": %s"),
2081 bfd_errmsg (bfd_get_error ()));
2085 subseg_set (bss_seg
, 1);
2089 record_alignment (bss_seg
, align
);
2090 frag_align (align
, 0, 0);
2093 /* Detach from old frag. */
2094 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2095 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
2097 symbol_set_frag (symbolP
, frag_now
);
2098 pfrag
= frag_var (rs_org
, 1, 1, 0, symbolP
, size
, NULL
);
2102 S_SET_SIZE (symbolP
, size
);
2104 S_SET_SEGMENT (symbolP
, bss_seg
);
2107 /* The symbol may already have been created with a preceding
2108 ".globl" directive -- be careful not to step on storage class
2109 in that case. Otherwise, set it to static. */
2110 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2111 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2112 #endif /* OBJ_COFF */
2114 subseg_set (current_seg
, current_subseg
);
2118 parse_align (int align_bytes
)
2124 if (*input_line_pointer
!= ',')
2127 as_bad (_("expected alignment after size"));
2128 ignore_rest_of_line ();
2132 input_line_pointer
++;
2135 align
= get_absolute_expr (&exp
);
2136 if (exp
.X_op
== O_absent
)
2139 if (!exp
.X_unsigned
)
2141 as_warn (_("alignment negative; 0 assumed"));
2145 if (align_bytes
&& align
!= 0)
2147 /* convert to a power of 2 alignment */
2148 unsigned int alignp2
= 0;
2149 while ((align
& 1) == 0)
2150 align
>>= 1, ++alignp2
;
2153 as_bad (_("alignment not a power of 2"));
2154 ignore_rest_of_line ();
2162 /* Called from s_comm_internal after symbol name and size have been
2163 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2164 1 if this was a ".bss" directive which has a 3rd argument
2165 (alignment as a power of 2), or 2 if this was a ".bss" directive
2166 with alignment in bytes. */
2169 s_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
2175 align
= parse_align (needs_align
- 1);
2176 if (align
== (addressT
) -1)
2180 /* Assume some objects may require alignment on some systems. */
2181 TC_IMPLICIT_LCOMM_ALIGNMENT (size
, align
);
2183 bss_alloc (symbolP
, size
, align
);
2188 s_lcomm (int needs_align
)
2190 s_comm_internal (needs_align
, s_lcomm_internal
);
2194 s_lcomm_bytes (int needs_align
)
2196 s_comm_internal (needs_align
* 2, s_lcomm_internal
);
2200 s_lsym (int ignore ATTRIBUTE_UNUSED
)
2202 register char *name
;
2206 register symbolS
*symbolP
;
2208 /* We permit ANY defined expression: BSD4.2 demands constants. */
2209 name
= input_line_pointer
;
2210 c
= get_symbol_end ();
2211 p
= input_line_pointer
;
2216 as_bad (_("expected symbol name"));
2217 ignore_rest_of_line ();
2223 if (*input_line_pointer
!= ',')
2226 as_bad (_("expected comma after \"%s\""), name
);
2228 ignore_rest_of_line ();
2232 input_line_pointer
++;
2233 expression_and_evaluate (&exp
);
2235 if (exp
.X_op
!= O_constant
2236 && exp
.X_op
!= O_register
)
2238 as_bad (_("bad expression"));
2239 ignore_rest_of_line ();
2244 symbolP
= symbol_find_or_make (name
);
2246 if (S_GET_SEGMENT (symbolP
) == undefined_section
)
2248 /* The name might be an undefined .global symbol; be sure to
2249 keep the "external" bit. */
2250 S_SET_SEGMENT (symbolP
,
2251 (exp
.X_op
== O_constant
2254 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2258 as_bad (_("symbol `%s' is already defined"), name
);
2262 demand_empty_rest_of_line ();
2265 /* Read a line into an sb. Returns the character that ended the line
2266 or zero if there are no more lines. */
2269 get_line_sb (sb
*line
)
2273 if (input_line_pointer
[-1] == '\n')
2274 bump_line_counters ();
2276 if (input_line_pointer
>= buffer_limit
)
2278 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2279 if (buffer_limit
== 0)
2283 eol
= find_end_of_line (input_line_pointer
, flag_m68k_mri
);
2284 sb_add_buffer (line
, input_line_pointer
, eol
- input_line_pointer
);
2285 input_line_pointer
= eol
;
2287 /* Don't skip multiple end-of-line characters, because that breaks support
2288 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2289 characters but isn't. Instead just skip one end of line character and
2290 return the character skipped so that the caller can re-insert it if
2292 return *input_line_pointer
++;
2295 /* Define a macro. This is an interface to macro.c. */
2298 s_macro (int ignore ATTRIBUTE_UNUSED
)
2306 as_where (&file
, &line
);
2309 eol
= find_end_of_line (input_line_pointer
, 0);
2310 sb_add_buffer (&s
, input_line_pointer
, eol
- input_line_pointer
);
2311 input_line_pointer
= eol
;
2313 if (line_label
!= NULL
)
2318 sb_add_string (&label
, S_GET_NAME (line_label
));
2319 err
= define_macro (0, &s
, &label
, get_line_sb
, file
, line
, &name
);
2323 err
= define_macro (0, &s
, NULL
, get_line_sb
, file
, line
, &name
);
2325 as_bad_where (file
, line
, err
, name
);
2328 if (line_label
!= NULL
)
2330 S_SET_SEGMENT (line_label
, absolute_section
);
2331 S_SET_VALUE (line_label
, 0);
2332 symbol_set_frag (line_label
, &zero_address_frag
);
2335 if (((NO_PSEUDO_DOT
|| flag_m68k_mri
)
2336 && hash_find (po_hash
, name
) != NULL
)
2339 && hash_find (po_hash
, name
+ 1) != NULL
))
2340 as_warn_where (file
,
2342 _("attempt to redefine pseudo-op `%s' ignored"),
2349 /* Handle the .mexit pseudo-op, which immediately exits a macro
2353 s_mexit (int ignore ATTRIBUTE_UNUSED
)
2355 cond_exit_macro (macro_nest
);
2356 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2359 /* Switch in and out of MRI mode. */
2362 s_mri (int ignore ATTRIBUTE_UNUSED
)
2366 on
= get_absolute_expression ();
2367 old_flag
= flag_mri
;
2385 /* Operator precedence changes in m68k MRI mode, so we need to
2386 update the operator rankings. */
2387 expr_set_precedence ();
2389 #ifdef MRI_MODE_CHANGE
2391 MRI_MODE_CHANGE (on
);
2394 demand_empty_rest_of_line ();
2397 /* Handle changing the location counter. */
2400 do_org (segT segment
, expressionS
*exp
, int fill
)
2402 if (segment
!= now_seg
&& segment
!= absolute_section
)
2403 as_bad (_("invalid segment \"%s\""), segment_name (segment
));
2405 if (now_seg
== absolute_section
)
2408 as_warn (_("ignoring fill value in absolute section"));
2409 if (exp
->X_op
!= O_constant
)
2411 as_bad (_("only constant offsets supported in absolute section"));
2412 exp
->X_add_number
= 0;
2414 abs_section_offset
= exp
->X_add_number
;
2419 symbolS
*sym
= exp
->X_add_symbol
;
2420 offsetT off
= exp
->X_add_number
* OCTETS_PER_BYTE
;
2422 if (exp
->X_op
!= O_constant
&& exp
->X_op
!= O_symbol
)
2424 /* Handle complex expressions. */
2425 sym
= make_expr_symbol (exp
);
2429 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, sym
, off
, (char *) 0);
2435 s_org (int ignore ATTRIBUTE_UNUSED
)
2437 register segT segment
;
2439 register long temp_fill
;
2441 #ifdef md_flush_pending_output
2442 md_flush_pending_output ();
2445 /* The m68k MRI assembler has a different meaning for .org. It
2446 means to create an absolute section at a given address. We can't
2447 support that--use a linker script instead. */
2450 as_bad (_("MRI style ORG pseudo-op not supported"));
2451 ignore_rest_of_line ();
2455 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2456 thing as a sub-segment-relative origin. Any absolute origin is
2457 given a warning, then assumed to be segment-relative. Any
2458 segmented origin expression ("foo+42") had better be in the right
2459 segment or the .org is ignored.
2461 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2462 we never know sub-segment sizes when we are reading code. BSD
2463 will crash trying to emit negative numbers of filler bytes in
2464 certain .orgs. We don't crash, but see as-write for that code.
2466 Don't make frag if need_pass_2==1. */
2467 segment
= get_known_segmented_expression (&exp
);
2468 if (*input_line_pointer
== ',')
2470 input_line_pointer
++;
2471 temp_fill
= get_absolute_expression ();
2477 do_org (segment
, &exp
, temp_fill
);
2479 demand_empty_rest_of_line ();
2482 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2483 called by the obj-format routine which handles section changing
2484 when in MRI mode. It will create a new section, and return it. It
2485 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2486 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2489 s_mri_sect (char *type ATTRIBUTE_UNUSED
)
2499 name
= input_line_pointer
;
2500 if (!ISDIGIT (*name
))
2501 c
= get_symbol_end ();
2506 ++input_line_pointer
;
2508 while (ISDIGIT (*input_line_pointer
));
2510 c
= *input_line_pointer
;
2511 *input_line_pointer
= '\0';
2514 name
= xstrdup (name
);
2516 *input_line_pointer
= c
;
2518 seg
= subseg_new (name
, 0);
2520 if (*input_line_pointer
== ',')
2524 ++input_line_pointer
;
2525 align
= get_absolute_expression ();
2526 record_alignment (seg
, align
);
2530 if (*input_line_pointer
== ',')
2532 c
= *++input_line_pointer
;
2534 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2537 as_bad (_("unrecognized section type"));
2538 ++input_line_pointer
;
2543 flags
= SEC_NO_FLAGS
;
2545 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2546 else if (*type
== 'D' || *type
== 'M')
2547 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2548 else if (*type
== 'R')
2549 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2550 if (flags
!= SEC_NO_FLAGS
)
2552 if (!bfd_set_section_flags (stdoutput
, seg
, flags
))
2553 as_warn (_("error setting flags for \"%s\": %s"),
2554 bfd_section_name (stdoutput
, seg
),
2555 bfd_errmsg (bfd_get_error ()));
2560 /* Ignore the HP type. */
2561 if (*input_line_pointer
== ',')
2562 input_line_pointer
+= 2;
2564 demand_empty_rest_of_line ();
2566 #else /* ! TC_M68K */
2575 name
= input_line_pointer
;
2576 c
= get_symbol_end ();
2578 name
= xstrdup (name
);
2580 *input_line_pointer
= c
;
2582 seg
= subseg_new (name
, 0);
2584 if (*input_line_pointer
!= ',')
2590 ++input_line_pointer
;
2592 sectype
= input_line_pointer
;
2593 c
= get_symbol_end ();
2594 if (*sectype
== '\0')
2596 else if (strcasecmp (sectype
, "text") == 0)
2598 else if (strcasecmp (sectype
, "data") == 0)
2600 else if (strcasecmp (sectype
, "romdata") == 0)
2603 as_warn (_("unrecognized section type `%s'"), sectype
);
2604 *input_line_pointer
= c
;
2607 if (*input_line_pointer
== ',')
2611 ++input_line_pointer
;
2613 seccmd
= input_line_pointer
;
2614 c
= get_symbol_end ();
2615 if (strcasecmp (seccmd
, "absolute") == 0)
2617 as_bad (_("absolute sections are not supported"));
2618 *input_line_pointer
= c
;
2619 ignore_rest_of_line ();
2622 else if (strcasecmp (seccmd
, "align") == 0)
2626 *input_line_pointer
= c
;
2627 align
= get_absolute_expression ();
2628 record_alignment (seg
, align
);
2632 as_warn (_("unrecognized section command `%s'"), seccmd
);
2633 *input_line_pointer
= c
;
2637 demand_empty_rest_of_line ();
2639 #else /* ! TC_I960 */
2640 /* The MRI assembler seems to use different forms of .sect for
2641 different targets. */
2642 as_bad ("MRI mode not supported for this target");
2643 ignore_rest_of_line ();
2644 #endif /* ! TC_I960 */
2645 #endif /* ! TC_M68K */
2648 /* Handle the .print pseudo-op. */
2651 s_print (int ignore ATTRIBUTE_UNUSED
)
2656 s
= demand_copy_C_string (&len
);
2659 demand_empty_rest_of_line ();
2662 /* Handle the .purgem pseudo-op. */
2665 s_purgem (int ignore ATTRIBUTE_UNUSED
)
2667 if (is_it_end_of_statement ())
2669 demand_empty_rest_of_line ();
2679 name
= input_line_pointer
;
2680 c
= get_symbol_end ();
2681 delete_macro (name
);
2682 *input_line_pointer
= c
;
2685 while (*input_line_pointer
++ == ',');
2687 --input_line_pointer
;
2688 demand_empty_rest_of_line ();
2691 /* Handle the .endm/.endr pseudo-ops. */
2694 s_bad_end (int endr
)
2696 as_warn (_(".end%c encountered without preceeding %s"),
2698 endr
? ".rept, .irp, or .irpc" : ".macro");
2699 demand_empty_rest_of_line ();
2702 /* Handle the .rept pseudo-op. */
2705 s_rept (int ignore ATTRIBUTE_UNUSED
)
2709 count
= get_absolute_expression ();
2711 do_repeat (count
, "REPT", "ENDR");
2714 /* This function provides a generic repeat block implementation. It allows
2715 different directives to be used as the start/end keys. */
2718 do_repeat (int count
, const char *start
, const char *end
)
2724 if (!buffer_and_nest (start
, end
, &one
, get_line_sb
))
2726 as_bad (_("%s without %s"), start
, end
);
2732 sb_add_sb (&many
, &one
);
2736 input_scrub_include_sb (&many
, input_line_pointer
, 1);
2738 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2741 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2742 input buffers to skip. Assumes that conditionals preceding the loop end
2743 are properly nested.
2745 This function makes it easier to implement a premature "break" out of the
2746 loop. The EXTRA arg accounts for other buffers we might have inserted,
2747 such as line substitutions. */
2750 end_repeat (int extra
)
2752 cond_exit_macro (macro_nest
);
2753 while (extra
-- >= 0)
2754 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2758 assign_symbol (char *name
, int mode
)
2762 if (name
[0] == '.' && name
[1] == '\0')
2764 /* Turn '. = mumble' into a .org mumble. */
2768 segment
= get_known_segmented_expression (&exp
);
2771 do_org (segment
, &exp
, 0);
2776 if ((symbolP
= symbol_find (name
)) == NULL
2777 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2779 symbolP
= symbol_find_or_make (name
);
2781 /* When doing symbol listings, play games with dummy fragments living
2782 outside the normal fragment chain to record the file and line info
2784 if (listing
& LISTING_SYMBOLS
)
2786 extern struct list_info_struct
*listing_tail
;
2787 fragS
*dummy_frag
= (fragS
*) xcalloc (1, sizeof (fragS
));
2788 dummy_frag
->line
= listing_tail
;
2789 dummy_frag
->fr_symbol
= symbolP
;
2790 symbol_set_frag (symbolP
, dummy_frag
);
2794 /* "set" symbols are local unless otherwise specified. */
2795 SF_SET_LOCAL (symbolP
);
2799 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
2801 /* Permit register names to be redefined. */
2802 if ((mode
!= 0 || !S_IS_VOLATILE (symbolP
))
2803 && S_GET_SEGMENT (symbolP
) != reg_section
)
2805 as_bad (_("symbol `%s' is already defined"), name
);
2806 symbolP
= symbol_clone (symbolP
, 0);
2808 /* If the symbol is volatile, copy the symbol and replace the
2809 original with the copy, so that previous uses of the symbol will
2810 retain the value of the symbol at the point of use. */
2811 else if (S_IS_VOLATILE (symbolP
))
2812 symbolP
= symbol_clone (symbolP
, 1);
2816 S_SET_VOLATILE (symbolP
);
2818 S_SET_FORWARD_REF (symbolP
);
2820 pseudo_set (symbolP
);
2823 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
2824 then this is .equiv, and it is an error if the symbol is already
2825 defined. If EQUIV is -1, the symbol additionally is a forward
2835 /* Especial apologies for the random logic:
2836 this just grew, and could be parsed much more simply!
2838 name
= input_line_pointer
;
2839 delim
= get_symbol_end ();
2840 end_name
= input_line_pointer
;
2843 if (name
== end_name
)
2845 as_bad (_("expected symbol name"));
2846 ignore_rest_of_line ();
2852 if (*input_line_pointer
!= ',')
2855 as_bad (_("expected comma after \"%s\""), name
);
2857 ignore_rest_of_line ();
2861 input_line_pointer
++;
2864 assign_symbol (name
, equiv
);
2867 demand_empty_rest_of_line ();
2880 #ifdef md_flush_pending_output
2881 md_flush_pending_output ();
2885 stop
= mri_comment_field (&stopc
);
2887 /* In m68k MRI mode, we need to align to a word boundary, unless
2889 if (flag_m68k_mri
&& mult
> 1)
2891 if (now_seg
== absolute_section
)
2893 abs_section_offset
+= abs_section_offset
& 1;
2894 if (line_label
!= NULL
)
2895 S_SET_VALUE (line_label
, abs_section_offset
);
2897 else if (mri_common_symbol
!= NULL
)
2901 val
= S_GET_VALUE (mri_common_symbol
);
2904 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2905 if (line_label
!= NULL
)
2907 expressionS
*symexp
;
2909 symexp
= symbol_get_value_expression (line_label
);
2910 know (symexp
->X_op
== O_symbol
);
2911 know (symexp
->X_add_symbol
== mri_common_symbol
);
2912 symexp
->X_add_number
+= 1;
2918 do_align (1, (char *) NULL
, 0, 0);
2919 if (line_label
!= NULL
)
2921 symbol_set_frag (line_label
, frag_now
);
2922 S_SET_VALUE (line_label
, frag_now_fix ());
2932 if (*input_line_pointer
== ',')
2934 ++input_line_pointer
;
2939 val
.X_op
= O_constant
;
2940 val
.X_add_number
= 0;
2943 if (val
.X_op
!= O_constant
2944 || val
.X_add_number
< - 0x80
2945 || val
.X_add_number
> 0xff
2946 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2948 resolve_expression (&exp
);
2949 if (exp
.X_op
!= O_constant
)
2950 as_bad (_("unsupported variable size or fill value"));
2957 bytes
= mult
* exp
.X_add_number
;
2958 for (i
= 0; i
< exp
.X_add_number
; i
++)
2959 emit_expr (&val
, mult
);
2964 if (now_seg
== absolute_section
|| mri_common_symbol
!= NULL
)
2965 resolve_expression (&exp
);
2967 if (exp
.X_op
== O_constant
)
2971 repeat
= exp
.X_add_number
;
2978 as_warn (_(".space repeat count is zero, ignored"));
2979 else if (repeat
< 0)
2980 as_warn (_(".space repeat count is negative, ignored"));
2984 /* If we are in the absolute section, just bump the offset. */
2985 if (now_seg
== absolute_section
)
2987 abs_section_offset
+= repeat
;
2991 /* If we are secretly in an MRI common section, then
2992 creating space just increases the size of the common
2994 if (mri_common_symbol
!= NULL
)
2996 S_SET_VALUE (mri_common_symbol
,
2997 S_GET_VALUE (mri_common_symbol
) + repeat
);
3002 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
3003 (offsetT
) repeat
, (char *) 0);
3007 if (now_seg
== absolute_section
)
3009 as_bad (_("space allocation too complex in absolute section"));
3010 subseg_set (text_section
, 0);
3013 if (mri_common_symbol
!= NULL
)
3015 as_bad (_("space allocation too complex in common section"));
3016 mri_common_symbol
= NULL
;
3020 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
3021 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
3025 *p
= val
.X_add_number
;
3030 /* In MRI mode, after an odd number of bytes, we must align to an
3031 even word boundary, unless the next instruction is a dc.b, ds.b
3033 if (flag_mri
&& (bytes
& 1) != 0)
3034 mri_pending_align
= 1;
3036 demand_empty_rest_of_line ();
3039 mri_comment_end (stop
, stopc
);
3042 /* This is like s_space, but the value is a floating point number with
3043 the given precision. This is for the MRI dcb.s pseudo-op and
3047 s_float_space (int float_type
)
3051 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3056 stop
= mri_comment_field (&stopc
);
3058 count
= get_absolute_expression ();
3061 if (*input_line_pointer
!= ',')
3063 as_bad (_("missing value"));
3064 ignore_rest_of_line ();
3066 mri_comment_end (stop
, stopc
);
3070 ++input_line_pointer
;
3074 /* Skip any 0{letter} that may be present. Don't even check if the
3075 * letter is legal. */
3076 if (input_line_pointer
[0] == '0'
3077 && ISALPHA (input_line_pointer
[1]))
3078 input_line_pointer
+= 2;
3080 /* Accept :xxxx, where the x's are hex digits, for a floating point
3081 with the exact digits specified. */
3082 if (input_line_pointer
[0] == ':')
3084 flen
= hex_float (float_type
, temp
);
3087 ignore_rest_of_line ();
3089 mri_comment_end (stop
, stopc
);
3097 err
= md_atof (float_type
, temp
, &flen
);
3098 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3102 as_bad (_("bad floating literal: %s"), err
);
3103 ignore_rest_of_line ();
3105 mri_comment_end (stop
, stopc
);
3110 while (--count
>= 0)
3114 p
= frag_more (flen
);
3115 memcpy (p
, temp
, (unsigned int) flen
);
3118 demand_empty_rest_of_line ();
3121 mri_comment_end (stop
, stopc
);
3124 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3127 s_struct (int ignore ATTRIBUTE_UNUSED
)
3133 stop
= mri_comment_field (&stopc
);
3134 abs_section_offset
= get_absolute_expression ();
3135 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3136 /* The ELF backend needs to know that we are changing sections, so
3137 that .previous works correctly. */
3139 obj_elf_section_change_hook ();
3141 subseg_set (absolute_section
, 0);
3142 demand_empty_rest_of_line ();
3144 mri_comment_end (stop
, stopc
);
3148 s_text (int ignore ATTRIBUTE_UNUSED
)
3152 temp
= get_absolute_expression ();
3153 subseg_set (text_section
, (subsegT
) temp
);
3154 demand_empty_rest_of_line ();
3156 const_flag
&= ~IN_DEFAULT_SECTION
;
3160 /* .weakref x, y sets x as an alias to y that, as long as y is not
3161 referenced directly, will cause y to become a weak symbol. */
3163 s_weakref (int ignore ATTRIBUTE_UNUSED
)
3172 name
= input_line_pointer
;
3173 delim
= get_symbol_end ();
3174 end_name
= input_line_pointer
;
3176 if (name
== end_name
)
3178 as_bad (_("expected symbol name"));
3180 ignore_rest_of_line ();
3184 symbolP
= symbol_find_or_make (name
);
3186 if (S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
3188 if (!S_IS_VOLATILE (symbolP
))
3190 as_bad (_("symbol `%s' is already defined"), name
);
3192 ignore_rest_of_line ();
3195 symbolP
= symbol_clone (symbolP
, 1);
3196 S_CLEAR_VOLATILE (symbolP
);
3203 if (*input_line_pointer
!= ',')
3206 as_bad (_("expected comma after \"%s\""), name
);
3208 ignore_rest_of_line ();
3212 input_line_pointer
++;
3216 name
= input_line_pointer
;
3217 delim
= get_symbol_end ();
3218 end_name
= input_line_pointer
;
3220 if (name
== end_name
)
3222 as_bad (_("expected symbol name"));
3223 ignore_rest_of_line ();
3227 if ((symbolP2
= symbol_find_noref (name
, 1)) == NULL
3228 && (symbolP2
= md_undefined_symbol (name
)) == NULL
)
3230 symbolP2
= symbol_find_or_make (name
);
3231 S_SET_WEAKREFD (symbolP2
);
3235 symbolS
*symp
= symbolP2
;
3237 while (S_IS_WEAKREFR (symp
) && symp
!= symbolP
)
3239 expressionS
*expP
= symbol_get_value_expression (symp
);
3241 assert (expP
->X_op
== O_symbol
3242 && expP
->X_add_number
== 0);
3243 symp
= expP
->X_add_symbol
;
3245 if (symp
== symbolP
)
3249 loop
= concat (S_GET_NAME (symbolP
),
3250 " => ", S_GET_NAME (symbolP2
), NULL
);
3253 while (symp
!= symbolP
)
3255 char *old_loop
= loop
;
3256 symp
= symbol_get_value_expression (symp
)->X_add_symbol
;
3257 loop
= concat (loop
, " => ", S_GET_NAME (symp
), NULL
);
3261 as_bad (_("%s: would close weakref loop: %s"),
3262 S_GET_NAME (symbolP
), loop
);
3267 ignore_rest_of_line ();
3271 /* Short-circuiting instead of just checking here might speed
3272 things up a tiny little bit, but loop error messages would
3273 miss intermediate links. */
3274 /* symbolP2 = symp; */
3279 memset (&exp
, 0, sizeof (exp
));
3280 exp
.X_op
= O_symbol
;
3281 exp
.X_add_symbol
= symbolP2
;
3283 S_SET_SEGMENT (symbolP
, undefined_section
);
3284 symbol_set_value_expression (symbolP
, &exp
);
3285 symbol_set_frag (symbolP
, &zero_address_frag
);
3286 S_SET_WEAKREFR (symbolP
);
3288 demand_empty_rest_of_line ();
3292 /* Verify that we are at the end of a line. If not, issue an error and
3296 demand_empty_rest_of_line (void)
3299 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3300 input_line_pointer
++;
3303 if (ISPRINT (*input_line_pointer
))
3304 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3305 *input_line_pointer
);
3307 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3308 *input_line_pointer
);
3309 ignore_rest_of_line ();
3312 /* Return pointing just after end-of-line. */
3313 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3316 /* Silently advance to the end of line. Use this after already having
3317 issued an error about something bad. */
3320 ignore_rest_of_line (void)
3322 while (input_line_pointer
< buffer_limit
3323 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3324 input_line_pointer
++;
3326 input_line_pointer
++;
3328 /* Return pointing just after end-of-line. */
3329 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3332 /* Sets frag for given symbol to zero_address_frag, except when the
3333 symbol frag is already set to a dummy listing frag. */
3336 set_zero_frag (symbolS
*symbolP
)
3338 if (symbol_get_frag (symbolP
)->fr_type
!= rs_dummy
)
3339 symbol_set_frag (symbolP
, &zero_address_frag
);
3342 /* In: Pointer to a symbol.
3343 Input_line_pointer->expression.
3345 Out: Input_line_pointer->just after any whitespace after expression.
3346 Tried to set symbol to value of expression.
3347 Will change symbols type, value, and frag; */
3350 pseudo_set (symbolS
*symbolP
)
3355 know (symbolP
); /* NULL pointer is logic error. */
3357 if (!S_IS_FORWARD_REF (symbolP
))
3358 (void) expression (&exp
);
3360 (void) deferred_expression (&exp
);
3362 if (exp
.X_op
== O_illegal
)
3363 as_bad (_("illegal expression"));
3364 else if (exp
.X_op
== O_absent
)
3365 as_bad (_("missing expression"));
3366 else if (exp
.X_op
== O_big
)
3368 if (exp
.X_add_number
> 0)
3369 as_bad (_("bignum invalid"));
3371 as_bad (_("floating point number invalid"));
3373 else if (exp
.X_op
== O_subtract
3374 && !S_IS_FORWARD_REF (symbolP
)
3375 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3376 && (symbol_get_frag (exp
.X_add_symbol
)
3377 == symbol_get_frag (exp
.X_op_symbol
)))
3379 exp
.X_op
= O_constant
;
3380 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3381 - S_GET_VALUE (exp
.X_op_symbol
));
3384 if (symbol_section_p (symbolP
))
3386 as_bad ("attempt to set value of section symbol");
3395 exp
.X_add_number
= 0;
3398 S_SET_SEGMENT (symbolP
, absolute_section
);
3399 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3400 set_zero_frag (symbolP
);
3404 S_SET_SEGMENT (symbolP
, reg_section
);
3405 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3406 set_zero_frag (symbolP
);
3410 seg
= S_GET_SEGMENT (exp
.X_add_symbol
);
3411 /* For x=undef+const, create an expression symbol.
3412 For x=x+const, just update x except when x is an undefined symbol
3413 For x=defined+const, evaluate x. */
3414 if (symbolP
== exp
.X_add_symbol
3415 && (seg
!= undefined_section
3416 || !symbol_constant_p (symbolP
)))
3418 *symbol_X_add_number (symbolP
) += exp
.X_add_number
;
3421 else if (!S_IS_FORWARD_REF (symbolP
) && seg
!= undefined_section
)
3423 symbolS
*s
= exp
.X_add_symbol
;
3425 if (S_IS_COMMON (s
))
3426 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3427 S_GET_NAME (symbolP
), S_GET_NAME (s
));
3429 S_SET_SEGMENT (symbolP
, seg
);
3430 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (s
));
3431 symbol_set_frag (symbolP
, symbol_get_frag (s
));
3432 copy_symbol_attributes (symbolP
, s
);
3435 S_SET_SEGMENT (symbolP
, undefined_section
);
3436 symbol_set_value_expression (symbolP
, &exp
);
3437 set_zero_frag (symbolP
);
3441 /* The value is some complex expression. */
3442 S_SET_SEGMENT (symbolP
, expr_section
);
3443 symbol_set_value_expression (symbolP
, &exp
);
3444 set_zero_frag (symbolP
);
3451 CONStruct more frag of .bytes, or .words etc.
3452 Should need_pass_2 be 1 then emit no frag(s).
3453 This understands EXPRESSIONS.
3457 This has a split personality. We use expression() to read the
3458 value. We can detect if the value won't fit in a byte or word.
3459 But we can't detect if expression() discarded significant digits
3460 in the case of a long. Not worth the crocks required to fix it. */
3462 /* Select a parser for cons expressions. */
3464 /* Some targets need to parse the expression in various fancy ways.
3465 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3466 (for example, the HPPA does this). Otherwise, you can define
3467 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3468 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3469 are defined, which is the normal case, then only simple expressions
3474 parse_mri_cons (expressionS
*exp
, unsigned int nbytes
);
3477 #ifndef TC_PARSE_CONS_EXPRESSION
3478 #ifdef BITFIELD_CONS_EXPRESSIONS
3479 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3481 parse_bitfield_cons (expressionS
*exp
, unsigned int nbytes
);
3483 #ifdef REPEAT_CONS_EXPRESSIONS
3484 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3486 parse_repeat_cons (expressionS
*exp
, unsigned int nbytes
);
3489 /* If we haven't gotten one yet, just call expression. */
3490 #ifndef TC_PARSE_CONS_EXPRESSION
3491 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3496 do_parse_cons_expression (expressionS
*exp
,
3497 int nbytes ATTRIBUTE_UNUSED
)
3499 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3503 /* Worker to do .byte etc statements.
3504 Clobbers input_line_pointer and checks end-of-line. */
3507 cons_worker (register int nbytes
, /* 1=.byte, 2=.word, 4=.long. */
3515 #ifdef md_flush_pending_output
3516 md_flush_pending_output ();
3520 stop
= mri_comment_field (&stopc
);
3522 if (is_it_end_of_statement ())
3524 demand_empty_rest_of_line ();
3526 mri_comment_end (stop
, stopc
);
3530 #ifdef TC_ADDRESS_BYTES
3532 nbytes
= TC_ADDRESS_BYTES ();
3535 #ifdef md_cons_align
3536 md_cons_align (nbytes
);
3544 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3547 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3551 if (exp
.X_op
== O_symbol
)
3552 exp
.X_op
= O_symbol_rva
;
3554 as_fatal (_("rva without symbol"));
3556 emit_expr (&exp
, (unsigned int) nbytes
);
3559 while (*input_line_pointer
++ == ',');
3561 /* In MRI mode, after an odd number of bytes, we must align to an
3562 even word boundary, unless the next instruction is a dc.b, ds.b
3564 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3565 mri_pending_align
= 1;
3567 input_line_pointer
--; /* Put terminator back into stream. */
3569 demand_empty_rest_of_line ();
3572 mri_comment_end (stop
, stopc
);
3578 cons_worker (size
, 0);
3584 cons_worker (size
, 1);
3587 /* Put the contents of expression EXP into the object file using
3588 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3591 emit_expr (expressionS
*exp
, unsigned int nbytes
)
3595 valueT extra_digit
= 0;
3597 /* Don't do anything if we are going to make another pass. */
3601 dot_value
= frag_now_fix ();
3605 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3606 appear as a four byte positive constant in the .line section,
3607 followed by a 2 byte 0xffff. Look for that case here. */
3609 static int dwarf_line
= -1;
3611 if (strcmp (segment_name (now_seg
), ".line") != 0)
3613 else if (dwarf_line
>= 0
3615 && exp
->X_op
== O_constant
3616 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
3617 listing_source_line ((unsigned int) dwarf_line
);
3618 else if (nbytes
== 4
3619 && exp
->X_op
== O_constant
3620 && exp
->X_add_number
>= 0)
3621 dwarf_line
= exp
->X_add_number
;
3626 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3627 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3628 AT_sibling (0x12) followed by a four byte address of the sibling
3629 followed by a 2 byte AT_name (0x38) followed by the name of the
3630 file. We look for that case here. */
3632 static int dwarf_file
= 0;
3634 if (strcmp (segment_name (now_seg
), ".debug") != 0)
3636 else if (dwarf_file
== 0
3638 && exp
->X_op
== O_constant
3639 && exp
->X_add_number
== 0x11)
3641 else if (dwarf_file
== 1
3643 && exp
->X_op
== O_constant
3644 && exp
->X_add_number
== 0x12)
3646 else if (dwarf_file
== 2
3649 else if (dwarf_file
== 3
3651 && exp
->X_op
== O_constant
3652 && exp
->X_add_number
== 0x38)
3657 /* The variable dwarf_file_string tells stringer that the string
3658 may be the name of the source file. */
3659 if (dwarf_file
== 4)
3660 dwarf_file_string
= 1;
3662 dwarf_file_string
= 0;
3667 if (check_eh_frame (exp
, &nbytes
))
3672 /* Allow `.word 0' in the absolute section. */
3673 if (now_seg
== absolute_section
)
3675 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3676 as_bad (_("attempt to store value in absolute section"));
3677 abs_section_offset
+= nbytes
;
3681 /* Handle a negative bignum. */
3683 && exp
->X_add_number
== 0
3684 && symbol_get_value_expression (exp
->X_add_symbol
)->X_op
== O_big
3685 && symbol_get_value_expression (exp
->X_add_symbol
)->X_add_number
> 0)
3688 unsigned long carry
;
3690 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
3692 /* Negate the bignum: one's complement each digit and add 1. */
3694 for (i
= 0; i
< exp
->X_add_number
; i
++)
3698 next
= (((~(generic_bignum
[i
] & LITTLENUM_MASK
))
3701 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3702 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3705 /* We can ignore any carry out, because it will be handled by
3706 extra_digit if it is needed. */
3708 extra_digit
= (valueT
) -1;
3712 if (op
== O_absent
|| op
== O_illegal
)
3714 as_warn (_("zero assumed for missing expression"));
3715 exp
->X_add_number
= 0;
3718 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3720 as_bad (_("floating point number invalid"));
3721 exp
->X_add_number
= 0;
3724 else if (op
== O_register
)
3726 as_warn (_("register value used as expression"));
3730 p
= frag_more ((int) nbytes
);
3732 #ifndef WORKING_DOT_WORD
3733 /* If we have the difference of two symbols in a word, save it on
3734 the broken_words list. See the code in write.c. */
3735 if (op
== O_subtract
&& nbytes
== 2)
3737 struct broken_word
*x
;
3739 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3740 x
->next_broken_word
= broken_words
;
3743 x
->subseg
= now_subseg
;
3745 x
->word_goes_here
= p
;
3747 x
->add
= exp
->X_add_symbol
;
3748 x
->sub
= exp
->X_op_symbol
;
3749 x
->addnum
= exp
->X_add_number
;
3757 /* If we have an integer, but the number of bytes is too large to
3758 pass to md_number_to_chars, handle it as a bignum. */
3759 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3761 extra_digit
= exp
->X_unsigned
? 0 : -1;
3762 convert_to_bignum (exp
);
3766 if (op
== O_constant
)
3768 register valueT get
;
3769 register valueT use
;
3770 register valueT mask
;
3772 register valueT unmask
;
3774 /* JF << of >= number of bits in the object is undefined. In
3775 particular SPARC (Sun 4) has problems. */
3776 if (nbytes
>= sizeof (valueT
))
3779 if (nbytes
> sizeof (valueT
))
3782 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3786 /* Don't store these bits. */
3787 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3788 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3791 unmask
= ~mask
; /* Do store these bits. */
3794 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3795 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3798 get
= exp
->X_add_number
;
3800 if ((get
& mask
) != 0
3801 && ((get
& mask
) != mask
3802 || (get
& hibit
) == 0))
3803 { /* Leading bits contain both 0s & 1s. */
3804 as_warn (_("value 0x%lx truncated to 0x%lx"),
3805 (unsigned long) get
, (unsigned long) use
);
3807 /* Put bytes in right order. */
3808 md_number_to_chars (p
, use
, (int) nbytes
);
3810 else if (op
== O_big
)
3813 LITTLENUM_TYPE
*nums
;
3815 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3817 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3820 as_warn (_("bignum truncated to %d bytes"), nbytes
);
3824 if (target_big_endian
)
3826 while (nbytes
> size
)
3828 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3829 nbytes
-= CHARS_PER_LITTLENUM
;
3830 p
+= CHARS_PER_LITTLENUM
;
3833 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3834 while (size
>= CHARS_PER_LITTLENUM
)
3837 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3838 size
-= CHARS_PER_LITTLENUM
;
3839 p
+= CHARS_PER_LITTLENUM
;
3844 nums
= generic_bignum
;
3845 while (size
>= CHARS_PER_LITTLENUM
)
3847 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3849 size
-= CHARS_PER_LITTLENUM
;
3850 p
+= CHARS_PER_LITTLENUM
;
3851 nbytes
-= CHARS_PER_LITTLENUM
;
3854 while (nbytes
>= CHARS_PER_LITTLENUM
)
3856 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3857 nbytes
-= CHARS_PER_LITTLENUM
;
3858 p
+= CHARS_PER_LITTLENUM
;
3864 memset (p
, 0, nbytes
);
3866 /* Now we need to generate a fixS to record the symbol value. */
3868 #ifdef TC_CONS_FIX_NEW
3869 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3872 bfd_reloc_code_real_type r
;
3889 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
3893 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3900 #ifdef BITFIELD_CONS_EXPRESSIONS
3902 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3903 w:x,y:z, where w and y are bitwidths and x and y are values. They
3904 then pack them all together. We do a little better in that we allow
3905 them in words, longs, etc. and we'll pack them in target byte order
3908 The rules are: pack least significant bit first, if a field doesn't
3909 entirely fit, put it in the next unit. Overflowing the bitfield is
3910 explicitly *not* even a warning. The bitwidth should be considered
3913 To use this function the tc-XXX.h file should define
3914 BITFIELD_CONS_EXPRESSIONS. */
3917 parse_bitfield_cons (exp
, nbytes
)
3919 unsigned int nbytes
;
3921 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3922 char *hold
= input_line_pointer
;
3924 (void) expression (exp
);
3926 if (*input_line_pointer
== ':')
3933 unsigned long width
;
3935 if (*input_line_pointer
!= ':')
3937 input_line_pointer
= hold
;
3939 } /* Next piece is not a bitfield. */
3941 /* In the general case, we can't allow
3942 full expressions with symbol
3943 differences and such. The relocation
3944 entries for symbols not defined in this
3945 assembly would require arbitrary field
3946 widths, positions, and masks which most
3947 of our current object formats don't
3950 In the specific case where a symbol
3951 *is* defined in this assembly, we
3952 *could* build fixups and track it, but
3953 this could lead to confusion for the
3954 backends. I'm lazy. I'll take any
3955 SEG_ABSOLUTE. I think that means that
3956 you can use a previous .set or
3957 .equ type symbol. xoxorich. */
3959 if (exp
->X_op
== O_absent
)
3961 as_warn (_("using a bit field width of zero"));
3962 exp
->X_add_number
= 0;
3963 exp
->X_op
= O_constant
;
3964 } /* Implied zero width bitfield. */
3966 if (exp
->X_op
!= O_constant
)
3968 *input_line_pointer
= '\0';
3969 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
3970 *input_line_pointer
= ':';
3971 demand_empty_rest_of_line ();
3973 } /* Too complex. */
3975 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3977 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3978 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3979 width
= BITS_PER_CHAR
* nbytes
;
3982 if (width
> bits_available
)
3984 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3985 input_line_pointer
= hold
;
3986 exp
->X_add_number
= value
;
3991 hold
= ++input_line_pointer
;
3993 (void) expression (exp
);
3994 if (exp
->X_op
!= O_constant
)
3996 char cache
= *input_line_pointer
;
3998 *input_line_pointer
= '\0';
3999 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
4000 *input_line_pointer
= cache
;
4001 demand_empty_rest_of_line ();
4003 } /* Too complex. */
4005 value
|= ((~(-1 << width
) & exp
->X_add_number
)
4006 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
4008 if ((bits_available
-= width
) == 0
4009 || is_it_end_of_statement ()
4010 || *input_line_pointer
!= ',')
4013 } /* All the bitfields we're gonna get. */
4015 hold
= ++input_line_pointer
;
4016 (void) expression (exp
);
4019 exp
->X_add_number
= value
;
4020 exp
->X_op
= O_constant
;
4021 exp
->X_unsigned
= 1;
4025 #endif /* BITFIELD_CONS_EXPRESSIONS */
4027 /* Handle an MRI style string expression. */
4031 parse_mri_cons (exp
, nbytes
)
4033 unsigned int nbytes
;
4035 if (*input_line_pointer
!= '\''
4036 && (input_line_pointer
[1] != '\''
4037 || (*input_line_pointer
!= 'A'
4038 && *input_line_pointer
!= 'E')))
4039 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
4043 unsigned int result
= 0;
4045 /* An MRI style string. Cut into as many bytes as will fit into
4046 a nbyte chunk, left justify if necessary, and separate with
4047 commas so we can try again later. */
4048 if (*input_line_pointer
== 'A')
4049 ++input_line_pointer
;
4050 else if (*input_line_pointer
== 'E')
4052 as_bad (_("EBCDIC constants are not supported"));
4053 ++input_line_pointer
;
4056 input_line_pointer
++;
4057 for (scan
= 0; scan
< nbytes
; scan
++)
4059 if (*input_line_pointer
== '\'')
4061 if (input_line_pointer
[1] == '\'')
4063 input_line_pointer
++;
4068 result
= (result
<< 8) | (*input_line_pointer
++);
4072 while (scan
< nbytes
)
4078 /* Create correct expression. */
4079 exp
->X_op
= O_constant
;
4080 exp
->X_add_number
= result
;
4082 /* Fake it so that we can read the next char too. */
4083 if (input_line_pointer
[0] != '\'' ||
4084 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
4086 input_line_pointer
-= 2;
4087 input_line_pointer
[0] = ',';
4088 input_line_pointer
[1] = '\'';
4091 input_line_pointer
++;
4094 #endif /* TC_M68K */
4096 #ifdef REPEAT_CONS_EXPRESSIONS
4098 /* Parse a repeat expression for cons. This is used by the MIPS
4099 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4100 object file COUNT times.
4102 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4105 parse_repeat_cons (exp
, nbytes
)
4107 unsigned int nbytes
;
4114 if (*input_line_pointer
!= ':')
4116 /* No repeat count. */
4120 ++input_line_pointer
;
4121 expression (&count
);
4122 if (count
.X_op
!= O_constant
4123 || count
.X_add_number
<= 0)
4125 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4129 /* The cons function is going to output this expression once. So we
4130 output it count - 1 times. */
4131 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
4132 emit_expr (exp
, nbytes
);
4135 #endif /* REPEAT_CONS_EXPRESSIONS */
4137 /* Parse a floating point number represented as a hex constant. This
4138 permits users to specify the exact bits they want in the floating
4142 hex_float (int float_type
, char *bytes
)
4174 as_bad (_("unknown floating type type '%c'"), float_type
);
4178 /* It would be nice if we could go through expression to parse the
4179 hex constant, but if we get a bignum it's a pain to sort it into
4180 the buffer correctly. */
4182 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
4186 /* The MRI assembler accepts arbitrary underscores strewn about
4187 through the hex constant, so we ignore them as well. */
4188 if (*input_line_pointer
== '_')
4190 ++input_line_pointer
;
4196 as_warn (_("floating point constant too large"));
4199 d
= hex_value (*input_line_pointer
) << 4;
4200 ++input_line_pointer
;
4201 while (*input_line_pointer
== '_')
4202 ++input_line_pointer
;
4203 if (hex_p (*input_line_pointer
))
4205 d
+= hex_value (*input_line_pointer
);
4206 ++input_line_pointer
;
4208 if (target_big_endian
)
4211 bytes
[length
- i
- 1] = d
;
4217 if (target_big_endian
)
4218 memset (bytes
+ i
, 0, length
- i
);
4220 memset (bytes
, 0, length
- i
);
4228 CONStruct some more frag chars of .floats .ffloats etc.
4229 Makes 0 or more new frags.
4230 If need_pass_2 == 1, no frags are emitted.
4231 This understands only floating literals, not expressions. Sorry.
4233 A floating constant is defined by atof_generic(), except it is preceded
4234 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4235 reading, I decided to be incompatible. This always tries to give you
4236 rounded bits to the precision of the pseudo-op. Former AS did premature
4237 truncation, restored noisy bits instead of trailing 0s AND gave you
4238 a choice of 2 flavours of noise according to which of 2 floating-point
4239 scanners you directed AS to use.
4241 In: input_line_pointer->whitespace before, or '0' of flonum. */
4244 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4245 register int float_type
/* 'f':.ffloat ... 'F':.float ... */)
4248 int length
; /* Number of chars in an object. */
4249 register char *err
; /* Error from scanning floating literal. */
4250 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
4252 if (is_it_end_of_statement ())
4254 demand_empty_rest_of_line ();
4258 #ifdef md_flush_pending_output
4259 md_flush_pending_output ();
4264 /* input_line_pointer->1st char of a flonum (we hope!). */
4267 /* Skip any 0{letter} that may be present. Don't even check if the
4268 letter is legal. Someone may invent a "z" format and this routine
4269 has no use for such information. Lusers beware: you get
4270 diagnostics if your input is ill-conditioned. */
4271 if (input_line_pointer
[0] == '0'
4272 && ISALPHA (input_line_pointer
[1]))
4273 input_line_pointer
+= 2;
4275 /* Accept :xxxx, where the x's are hex digits, for a floating
4276 point with the exact digits specified. */
4277 if (input_line_pointer
[0] == ':')
4279 ++input_line_pointer
;
4280 length
= hex_float (float_type
, temp
);
4283 ignore_rest_of_line ();
4289 err
= md_atof (float_type
, temp
, &length
);
4290 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4294 as_bad (_("bad floating literal: %s"), err
);
4295 ignore_rest_of_line ();
4306 #ifdef REPEAT_CONS_EXPRESSIONS
4307 if (*input_line_pointer
== ':')
4309 expressionS count_exp
;
4311 ++input_line_pointer
;
4312 expression (&count_exp
);
4314 if (count_exp
.X_op
!= O_constant
4315 || count_exp
.X_add_number
<= 0)
4316 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4318 count
= count_exp
.X_add_number
;
4322 while (--count
>= 0)
4324 p
= frag_more (length
);
4325 memcpy (p
, temp
, (unsigned int) length
);
4330 while (*input_line_pointer
++ == ',');
4332 /* Put terminator back into stream. */
4333 --input_line_pointer
;
4334 demand_empty_rest_of_line ();
4337 /* Return the size of a LEB128 value. */
4340 sizeof_sleb128 (offsetT value
)
4342 register int size
= 0;
4343 register unsigned byte
;
4347 byte
= (value
& 0x7f);
4348 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4349 Fortunately, we can structure things so that the extra work reduces
4350 to a noop on systems that do things "properly". */
4351 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4354 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4355 || ((value
== -1) && ((byte
& 0x40) != 0))));
4361 sizeof_uleb128 (valueT value
)
4363 register int size
= 0;
4364 register unsigned byte
;
4368 byte
= (value
& 0x7f);
4378 sizeof_leb128 (valueT value
, int sign
)
4381 return sizeof_sleb128 ((offsetT
) value
);
4383 return sizeof_uleb128 (value
);
4386 /* Output a LEB128 value. */
4389 output_sleb128 (char *p
, offsetT value
)
4391 register char *orig
= p
;
4396 unsigned byte
= (value
& 0x7f);
4398 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4399 Fortunately, we can structure things so that the extra work reduces
4400 to a noop on systems that do things "properly". */
4401 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4403 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4404 || ((value
== -1) && ((byte
& 0x40) != 0))));
4416 output_uleb128 (char *p
, valueT value
)
4422 unsigned byte
= (value
& 0x7f);
4425 /* More bytes to follow. */
4436 output_leb128 (char *p
, valueT value
, int sign
)
4439 return output_sleb128 (p
, (offsetT
) value
);
4441 return output_uleb128 (p
, value
);
4444 /* Do the same for bignums. We combine sizeof with output here in that
4445 we don't output for NULL values of P. It isn't really as critical as
4446 for "normal" values that this be streamlined. */
4449 output_big_sleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4456 /* Strip leading sign extensions off the bignum. */
4458 && bignum
[size
- 1] == LITTLENUM_MASK
4459 && bignum
[size
- 2] > LITTLENUM_MASK
/ 2)
4464 /* OR in the next part of the littlenum. */
4465 val
|= (*bignum
<< loaded
);
4466 loaded
+= LITTLENUM_NUMBER_OF_BITS
;
4470 /* Add bytes until there are less than 7 bits left in VAL
4471 or until every non-sign bit has been written. */
4478 || val
!= ((byte
& 0x40) == 0 ? 0 : ((valueT
) 1 << loaded
) - 1))
4485 while ((byte
& 0x80) != 0 && loaded
>= 7);
4489 /* Mop up any left-over bits (of which there will be less than 7). */
4490 if ((byte
& 0x80) != 0)
4492 /* Sign-extend VAL. */
4493 if (val
& (1 << (loaded
- 1)))
4494 val
|= ~0 << loaded
;
4504 output_big_uleb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
)
4511 /* Strip leading zeros off the bignum. */
4512 /* XXX: Is this needed? */
4513 while (size
> 0 && bignum
[size
- 1] == 0)
4518 if (loaded
< 7 && size
> 0)
4520 val
|= (*bignum
<< loaded
);
4521 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4530 if (size
> 0 || val
)
4537 while (byte
& 0x80);
4543 output_big_leb128 (char *p
, LITTLENUM_TYPE
*bignum
, int size
, int sign
)
4546 return output_big_sleb128 (p
, bignum
, size
);
4548 return output_big_uleb128 (p
, bignum
, size
);
4551 /* Generate the appropriate fragments for a given expression to emit a
4555 emit_leb128_expr (expressionS
*exp
, int sign
)
4557 operatorT op
= exp
->X_op
;
4558 unsigned int nbytes
;
4560 if (op
== O_absent
|| op
== O_illegal
)
4562 as_warn (_("zero assumed for missing expression"));
4563 exp
->X_add_number
= 0;
4566 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4568 as_bad (_("floating point number invalid"));
4569 exp
->X_add_number
= 0;
4572 else if (op
== O_register
)
4574 as_warn (_("register value used as expression"));
4577 else if (op
== O_constant
4579 && (exp
->X_add_number
< 0) != !exp
->X_unsigned
)
4581 /* We're outputting a signed leb128 and the sign of X_add_number
4582 doesn't reflect the sign of the original value. Convert EXP
4583 to a correctly-extended bignum instead. */
4584 convert_to_bignum (exp
);
4588 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4589 a signal that this is leb128 data. It shouldn't optimize this away. */
4590 nbytes
= (unsigned int) -1;
4591 if (check_eh_frame (exp
, &nbytes
))
4594 /* Let the backend know that subsequent data may be byte aligned. */
4595 #ifdef md_cons_align
4599 if (op
== O_constant
)
4601 /* If we've got a constant, emit the thing directly right now. */
4603 valueT value
= exp
->X_add_number
;
4607 size
= sizeof_leb128 (value
, sign
);
4608 p
= frag_more (size
);
4609 output_leb128 (p
, value
, sign
);
4611 else if (op
== O_big
)
4613 /* O_big is a different sort of constant. */
4618 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
4619 p
= frag_more (size
);
4620 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
4624 /* Otherwise, we have to create a variable sized fragment and
4625 resolve things later. */
4627 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
) 0), 0, sign
,
4628 make_expr_symbol (exp
), 0, (char *) NULL
);
4632 /* Parse the .sleb128 and .uleb128 pseudos. */
4639 #ifdef md_flush_pending_output
4640 md_flush_pending_output ();
4646 emit_leb128_expr (&exp
, sign
);
4648 while (*input_line_pointer
++ == ',');
4650 input_line_pointer
--;
4651 demand_empty_rest_of_line ();
4654 /* We read 0 or more ',' separated, double-quoted strings.
4655 Caller should have checked need_pass_2 is FALSE because we don't
4659 stringer (/* Worker to do .ascii etc statements. */
4660 /* Checks end-of-line. */
4661 register int append_zero
/* 0: don't append '\0', else 1. */)
4663 register unsigned int c
;
4666 #ifdef md_flush_pending_output
4667 md_flush_pending_output ();
4670 /* The following awkward logic is to parse ZERO or more strings,
4671 comma separated. Recall a string expression includes spaces
4672 before the opening '\"' and spaces after the closing '\"'.
4673 We fake a leading ',' if there is (supposed to be)
4674 a 1st, expression. We keep demanding expressions for each ','. */
4675 if (is_it_end_of_statement ())
4677 c
= 0; /* Skip loop. */
4678 ++input_line_pointer
; /* Compensate for end of loop. */
4682 c
= ','; /* Do loop. */
4684 /* If we have been switched into the abs_section then we
4685 will not have an obstack onto which we can hang strings. */
4686 if (now_seg
== absolute_section
)
4688 as_bad (_("strings must be placed into a section"));
4690 ignore_rest_of_line ();
4693 while (c
== ',' || c
== '<' || c
== '"')
4696 switch (*input_line_pointer
)
4699 ++input_line_pointer
; /*->1st char of string. */
4700 start
= input_line_pointer
;
4701 while (is_a_char (c
= next_char_of_string ()))
4703 FRAG_APPEND_1_CHAR (c
);
4707 FRAG_APPEND_1_CHAR (0);
4709 know (input_line_pointer
[-1] == '\"');
4713 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4714 will emit .string with a filename in the .debug section
4715 after a sequence of constants. See the comment in
4716 emit_expr for the sequence. emit_expr will set
4717 dwarf_file_string to non-zero if this string might be a
4718 source file name. */
4719 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4720 dwarf_file_string
= 0;
4721 else if (dwarf_file_string
)
4723 c
= input_line_pointer
[-1];
4724 input_line_pointer
[-1] = '\0';
4725 listing_source_file (start
);
4726 input_line_pointer
[-1] = c
;
4733 input_line_pointer
++;
4734 c
= get_single_number ();
4735 FRAG_APPEND_1_CHAR (c
);
4736 if (*input_line_pointer
!= '>')
4738 as_bad (_("expected <nn>"));
4740 input_line_pointer
++;
4743 input_line_pointer
++;
4747 c
= *input_line_pointer
;
4750 demand_empty_rest_of_line ();
4753 /* FIXME-SOMEDAY: I had trouble here on characters with the
4754 high bits set. We'll probably also have trouble with
4755 multibyte chars, wide chars, etc. Also be careful about
4756 returning values bigger than 1 byte. xoxorich. */
4759 next_char_of_string (void)
4761 register unsigned int c
;
4763 c
= *input_line_pointer
++ & CHAR_MASK
;
4771 as_warn (_("unterminated string; newline inserted"));
4772 bump_line_counters ();
4775 #ifndef NO_STRING_ESCAPES
4777 switch (c
= *input_line_pointer
++)
4805 break; /* As itself. */
4821 for (i
= 0, number
= 0;
4822 ISDIGIT (c
) && i
< 3;
4823 c
= *input_line_pointer
++, i
++)
4825 number
= number
* 8 + c
- '0';
4830 --input_line_pointer
;
4839 c
= *input_line_pointer
++;
4840 while (ISXDIGIT (c
))
4843 number
= number
* 16 + c
- '0';
4844 else if (ISUPPER (c
))
4845 number
= number
* 16 + c
- 'A' + 10;
4847 number
= number
* 16 + c
- 'a' + 10;
4848 c
= *input_line_pointer
++;
4851 --input_line_pointer
;
4856 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4857 as_warn (_("unterminated string; newline inserted"));
4859 bump_line_counters ();
4864 #ifdef ONLY_STANDARD_ESCAPES
4865 as_bad (_("bad escaped character in string"));
4867 #endif /* ONLY_STANDARD_ESCAPES */
4872 #endif /* ! defined (NO_STRING_ESCAPES) */
4881 get_segmented_expression (register expressionS
*expP
)
4883 register segT retval
;
4885 retval
= expression (expP
);
4886 if (expP
->X_op
== O_illegal
4887 || expP
->X_op
== O_absent
4888 || expP
->X_op
== O_big
)
4890 as_bad (_("expected address expression"));
4891 expP
->X_op
= O_constant
;
4892 expP
->X_add_number
= 0;
4893 retval
= absolute_section
;
4899 get_known_segmented_expression (register expressionS
*expP
)
4901 register segT retval
;
4903 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4905 /* There is no easy way to extract the undefined symbol from the
4907 if (expP
->X_add_symbol
!= NULL
4908 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4909 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4910 S_GET_NAME (expP
->X_add_symbol
));
4912 as_warn (_("some symbol undefined; zero assumed"));
4913 retval
= absolute_section
;
4914 expP
->X_op
= O_constant
;
4915 expP
->X_add_number
= 0;
4917 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4921 char /* Return terminator. */
4922 get_absolute_expression_and_terminator (long *val_pointer
/* Return value of expression. */)
4924 /* FIXME: val_pointer should probably be offsetT *. */
4925 *val_pointer
= (long) get_absolute_expression ();
4926 return (*input_line_pointer
++);
4929 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4930 Give a warning if that happens. */
4933 demand_copy_C_string (int *len_pointer
)
4937 if ((s
= demand_copy_string (len_pointer
)) != 0)
4941 for (len
= *len_pointer
; len
> 0; len
--)
4948 as_bad (_("this string may not contain \'\\0\'"));
4956 /* Demand string, but return a safe (=private) copy of the string.
4957 Return NULL if we can't read a string here. */
4960 demand_copy_string (int *lenP
)
4962 register unsigned int c
;
4968 if (*input_line_pointer
== '\"')
4970 input_line_pointer
++; /* Skip opening quote. */
4972 while (is_a_char (c
= next_char_of_string ()))
4974 obstack_1grow (¬es
, c
);
4977 /* JF this next line is so demand_copy_C_string will return a
4978 null terminated string. */
4979 obstack_1grow (¬es
, '\0');
4980 retval
= obstack_finish (¬es
);
4984 as_bad (_("missing string"));
4986 ignore_rest_of_line ();
4992 /* In: Input_line_pointer->next character.
4994 Do: Skip input_line_pointer over all whitespace.
4996 Out: 1 if input_line_pointer->end-of-line. */
4999 is_it_end_of_statement (void)
5002 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
5006 equals (char *sym_name
, int reassign
)
5011 input_line_pointer
++;
5012 if (*input_line_pointer
== '=')
5013 input_line_pointer
++;
5014 if (reassign
< 0 && *input_line_pointer
== '=')
5015 input_line_pointer
++;
5017 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
5018 input_line_pointer
++;
5021 stop
= mri_comment_field (&stopc
);
5023 assign_symbol (sym_name
, reassign
>= 0 ? !reassign
: reassign
);
5027 demand_empty_rest_of_line ();
5028 mri_comment_end (stop
, stopc
);
5032 /* .incbin -- include a file verbatim at the current location. */
5035 s_incbin (int x ATTRIBUTE_UNUSED
)
5046 #ifdef md_flush_pending_output
5047 md_flush_pending_output ();
5051 filename
= demand_copy_string (& len
);
5052 if (filename
== NULL
)
5057 /* Look for optional skip and count. */
5058 if (* input_line_pointer
== ',')
5060 ++ input_line_pointer
;
5061 skip
= get_absolute_expression ();
5065 if (* input_line_pointer
== ',')
5067 ++ input_line_pointer
;
5069 count
= get_absolute_expression ();
5071 as_warn (_(".incbin count zero, ignoring `%s'"), filename
);
5077 demand_empty_rest_of_line ();
5079 /* Try opening absolute path first, then try include dirs. */
5080 binfile
= fopen (filename
, FOPEN_RB
);
5081 if (binfile
== NULL
)
5085 path
= xmalloc ((unsigned long) len
+ include_dir_maxlen
+ 5);
5087 for (i
= 0; i
< include_dir_count
; i
++)
5089 sprintf (path
, "%s/%s", include_dirs
[i
], filename
);
5091 binfile
= fopen (path
, FOPEN_RB
);
5092 if (binfile
!= NULL
)
5096 if (binfile
== NULL
)
5097 as_bad (_("file not found: %s"), filename
);
5100 path
= xstrdup (filename
);
5106 register_dependency (path
);
5108 /* Compute the length of the file. */
5109 if (fseek (binfile
, 0, SEEK_END
) != 0)
5111 as_bad (_("seek to end of .incbin file failed `%s'"), path
);
5114 file_len
= ftell (binfile
);
5116 /* If a count was not specified use the remainder of the file. */
5118 count
= file_len
- skip
;
5120 if (skip
< 0 || count
< 0 || file_len
< 0 || skip
+ count
> file_len
)
5122 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5123 skip
, count
, file_len
);
5127 if (fseek (binfile
, skip
, SEEK_SET
) != 0)
5129 as_bad (_("could not skip to %ld in file `%s'"), skip
, path
);
5133 /* Allocate frag space and store file contents in it. */
5134 binfrag
= frag_more (count
);
5136 bytes
= fread (binfrag
, 1, count
, binfile
);
5138 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5139 path
, bytes
, count
);
5142 if (binfile
!= NULL
)
5148 /* .include -- include a file at this point. */
5151 s_include (int arg ATTRIBUTE_UNUSED
)
5160 filename
= demand_copy_string (&i
);
5161 if (filename
== NULL
)
5163 /* demand_copy_string has already printed an error and
5164 called ignore_rest_of_line. */
5172 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
5173 && *input_line_pointer
!= ' '
5174 && *input_line_pointer
!= '\t')
5176 obstack_1grow (¬es
, *input_line_pointer
);
5177 ++input_line_pointer
;
5181 obstack_1grow (¬es
, '\0');
5182 filename
= obstack_finish (¬es
);
5183 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5184 ++input_line_pointer
;
5187 demand_empty_rest_of_line ();
5188 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
5190 for (i
= 0; i
< include_dir_count
; i
++)
5192 strcpy (path
, include_dirs
[i
]);
5194 strcat (path
, filename
);
5195 if (0 != (try = fopen (path
, FOPEN_RT
)))
5205 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5206 register_dependency (path
);
5207 input_scrub_insert_file (path
);
5211 add_include_dir (char *path
)
5215 if (include_dir_count
== 0)
5217 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
5218 include_dirs
[0] = "."; /* Current dir. */
5219 include_dir_count
= 2;
5223 include_dir_count
++;
5225 (char **) realloc (include_dirs
,
5226 include_dir_count
* sizeof (*include_dirs
));
5229 include_dirs
[include_dir_count
- 1] = path
; /* New one. */
5232 if (i
> include_dir_maxlen
)
5233 include_dir_maxlen
= i
;
5236 /* Output debugging information to denote the source file. */
5239 generate_file_debug (void)
5241 if (debug_type
== DEBUG_STABS
)
5242 stabs_generate_asm_file ();
5245 /* Output line number debugging information for the current source line. */
5248 generate_lineno_debug (void)
5252 case DEBUG_UNSPECIFIED
:
5257 stabs_generate_asm_lineno ();
5260 ecoff_generate_asm_lineno ();
5263 /* ??? We could here indicate to dwarf2dbg.c that something
5264 has changed. However, since there is additional backend
5265 support that is required (calling dwarf2_emit_insn), we
5266 let dwarf2dbg.c call as_where on its own. */
5271 /* Output debugging information to mark a function entry point or end point.
5272 END_P is zero for .func, and non-zero for .endfunc. */
5277 do_s_func (end_p
, NULL
);
5280 /* Subroutine of s_func so targets can choose a different default prefix.
5281 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5284 do_s_func (int end_p
, const char *default_prefix
)
5286 /* Record the current function so that we can issue an error message for
5287 misplaced .func,.endfunc, and also so that .endfunc needs no
5289 static char *current_name
;
5290 static char *current_label
;
5294 if (current_name
== NULL
)
5296 as_bad (_("missing .func"));
5297 ignore_rest_of_line ();
5301 if (debug_type
== DEBUG_STABS
)
5302 stabs_generate_asm_endfunc (current_name
, current_label
);
5304 current_name
= current_label
= NULL
;
5309 char delim1
, delim2
;
5311 if (current_name
!= NULL
)
5313 as_bad (_(".endfunc missing for previous .func"));
5314 ignore_rest_of_line ();
5318 name
= input_line_pointer
;
5319 delim1
= get_symbol_end ();
5320 name
= xstrdup (name
);
5321 *input_line_pointer
= delim1
;
5323 if (*input_line_pointer
!= ',')
5326 asprintf (&label
, "%s%s", default_prefix
, name
);
5329 char leading_char
= bfd_get_symbol_leading_char (stdoutput
);
5330 /* Missing entry point, use function's name with the leading
5333 asprintf (&label
, "%c%s", leading_char
, name
);
5340 ++input_line_pointer
;
5342 label
= input_line_pointer
;
5343 delim2
= get_symbol_end ();
5344 label
= xstrdup (label
);
5345 *input_line_pointer
= delim2
;
5348 if (debug_type
== DEBUG_STABS
)
5349 stabs_generate_asm_func (name
, label
);
5351 current_name
= name
;
5352 current_label
= label
;
5355 demand_empty_rest_of_line ();
5359 s_ignore (int arg ATTRIBUTE_UNUSED
)
5361 ignore_rest_of_line ();
5365 read_print_statistics (FILE *file
)
5367 hash_print_statistics (file
, "pseudo-op table", po_hash
);
5370 /* Inserts the given line into the input stream.
5372 This call avoids macro/conditionals nesting checking, since the contents of
5373 the line are assumed to replace the contents of a line already scanned.
5375 An appropriate use of this function would be substitution of input lines when
5376 called by md_start_line_hook(). The given line is assumed to already be
5377 properly scrubbed. */
5380 input_scrub_insert_line (const char *line
)
5384 sb_add_string (&newline
, line
);
5385 input_scrub_include_sb (&newline
, input_line_pointer
, 0);
5387 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5390 /* Insert a file into the input stream; the path must resolve to an actual
5391 file; no include path searching or dependency registering is performed. */
5394 input_scrub_insert_file (char *path
)
5396 input_scrub_include_file (path
, input_line_pointer
);
5397 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
5400 /* Find the end of a line, considering quotation and escaping of quotes. */
5402 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5403 # define TC_SINGLE_QUOTE_STRINGS 1
5407 _find_end_of_line (char *s
, int mri_string
, int insn ATTRIBUTE_UNUSED
)
5409 char inquote
= '\0';
5412 while (!is_end_of_line
[(unsigned char) *s
]
5413 || (inquote
&& !ISCNTRL (*s
))
5414 || (inquote
== '\'' && flag_mri
)
5415 #ifdef TC_EOL_IN_INSN
5416 || (insn
&& TC_EOL_IN_INSN (s
))
5420 if (mri_string
&& *s
== '\'')
5424 else if (*s
== '\\')
5428 #ifdef TC_SINGLE_QUOTE_STRINGS
5429 || (TC_SINGLE_QUOTE_STRINGS
&& *s
== '\'')
5436 as_warn (_("missing closing `%c'"), inquote
);
5438 as_warn (_("stray `\\'"));
5443 find_end_of_line (char *s
, int mri_string
)
5445 return _find_end_of_line (s
, mri_string
, 0);