1 /* read.c - read a source file -
2 Copyright (C) 1986, 1987, 1990, 1991, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
23 change this a bit. But then, GNU isn't
24 spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.)
28 #define MASK_CHAR ((int)(unsigned char)-1)
32 /* This is the largest known floating point format (for now). It will
33 grow when we do 4361 style flonums. */
35 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
37 /* Routines that read assembler source text to build spagetti in memory.
38 Another group of these functions is in the expr.c module. */
47 #include "libiberty.h"
51 #ifndef TC_START_LABEL
52 #define TC_START_LABEL(x,y) (x==':')
55 /* The NOP_OPCODE is for the alignment fill value.
56 * fill it a nop instruction so that the disassembler does not choke
60 #define NOP_OPCODE 0x00
63 char *input_line_pointer
; /*->next char of source file to parse. */
65 int generate_asm_lineno
= 0; /* flag to generate line stab for .s file */
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!)! */
74 /* The m88k unfortunately uses @ as a label beginner. */
79 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
84 /* The Delta 68k assembler permits % inside label names. */
89 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* used by is_... macros. our ctype[] */
96 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
97 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
98 0, 0, 0, 0, 3, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
99 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
100 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
101 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
102 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
103 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 0, /* pqrstuvwxyz{|}~. */
104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
107 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 * Out: 1 if this character ends a line.
119 char is_end_of_line
[256] =
122 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
124 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
126 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
128 _
,99, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* _!"#$%&'()*+,-./ */
129 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* 0123456789:;<=>? */
131 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
132 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
134 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
135 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
136 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
137 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
138 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
139 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
140 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
141 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
142 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
146 /* Functions private to this file. */
148 static char *buffer
; /* 1st char of each buffer of lines is here. */
149 static char *buffer_limit
; /*->1 + last char in buffer. */
151 #ifdef TARGET_BYTES_BIG_ENDIAN
152 /* Hack to deal with tc-*.h defining TARGET_BYTES_BIG_ENDIAN to empty
153 instead of to 0 or 1. */
154 #if 5 - TARGET_BYTES_BIG_ENDIAN - 5 == 10
155 #undef TARGET_BYTES_BIG_ENDIAN
156 #define TARGET_BYTES_BIG_ENDIAN 1
158 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
160 int target_big_endian
/* = 0 */;
163 static char *old_buffer
; /* JF a hack */
164 static char *old_input
;
165 static char *old_limit
;
167 /* Variables for handling include file directory list. */
169 char **include_dirs
; /* List of pointers to directories to
170 search for .include's */
171 int include_dir_count
; /* How many are in the list */
172 int include_dir_maxlen
= 1;/* Length of longest in list */
174 #ifndef WORKING_DOT_WORD
175 struct broken_word
*broken_words
;
176 int new_broken_words
;
179 /* The current offset into the absolute section. We don't try to
180 build frags in the absolute section, since no data can be stored
181 there. We just keep track of the current offset. */
182 addressT abs_section_offset
;
184 /* If this line had an MRI style label, it is stored in this variable.
185 This is used by some of the MRI pseudo-ops. */
188 /* This global variable is used to support MRI common sections. We
189 translate such sections into a common symbol. This variable is
190 non-NULL when we are in an MRI common section. */
191 symbolS
*mri_common_symbol
;
193 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
194 need to align to an even byte boundary unless the next pseudo-op is
195 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
197 static int mri_pending_align
;
199 static int scrub_from_string
PARAMS ((char **));
200 static void do_align
PARAMS ((int, char *));
201 static int hex_float
PARAMS ((int, char *));
202 static void do_org
PARAMS ((segT
, expressionS
*, int));
203 char *demand_copy_string
PARAMS ((int *lenP
));
204 int is_it_end_of_statement
PARAMS ((void));
205 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
206 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
207 static void pobegin
PARAMS ((void));
208 static int get_line_sb
PARAMS ((sb
*));
217 obj_read_begin_hook ();
219 /* Something close -- but not too close -- to a multiple of 1024.
220 The debugging malloc I'm using has 24 bytes of overhead. */
221 obstack_begin (¬es
, 5090);
222 obstack_begin (&cond_obstack
, 990);
224 /* Use machine dependent syntax */
225 for (p
= line_separator_chars
; *p
; p
++)
226 is_end_of_line
[(unsigned char) *p
] = 1;
227 /* Use more. FIXME-SOMEDAY. */
233 /* set up pseudo-op tables */
235 static struct hash_control
*po_hash
;
237 static const pseudo_typeS potable
[] =
239 {"abort", s_abort
, 0},
240 {"align", s_align_ptwo
, 0},
241 {"ascii", stringer
, 0},
242 {"asciz", stringer
, 1},
243 {"balign", s_align_bytes
, 0},
247 {"common", s_mri_common
, 0},
248 {"common.s", s_mri_common
, 1},
252 {"dc.d", float_cons
, 'd'},
254 {"dc.s", float_cons
, 'f'},
256 {"dc.x", float_cons
, 'x'},
258 {"dcb.b", s_space
, 1},
259 {"dcb.d", s_float_space
, 'd'},
260 {"dcb.l", s_space
, 4},
261 {"dcb.s", s_float_space
, 'f'},
262 {"dcb.w", s_space
, 2},
263 {"dcb.x", s_float_space
, 'x'},
265 {"ds.b", s_space
, 1},
266 {"ds.d", s_space
, 8},
267 {"ds.l", s_space
, 4},
268 {"ds.p", s_space
, 12},
269 {"ds.s", s_space
, 4},
270 {"ds.w", s_space
, 2},
271 {"ds.x", s_space
, 12},
276 {"double", float_cons
, 'd'},
278 {"eject", listing_eject
, 0}, /* Formfeed listing */
280 {"elsec", s_else
, 0},
282 {"endc", s_endif
, 0},
283 {"endif", s_endif
, 0},
287 {"exitm", s_mexit
, 0},
289 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
290 {"appfile", s_app_file
, 1},
291 {"appline", s_app_line
, 0},
293 {"file", s_app_file
, 0},
295 {"float", float_cons
, 'f'},
296 {"format", s_ignore
, 0},
297 {"global", s_globl
, 0},
298 {"globl", s_globl
, 0},
300 {"if", s_if
, (int) O_ne
},
302 {"ifdef", s_ifdef
, 0},
303 {"ifeq", s_if
, (int) O_eq
},
304 {"ifeqs", s_ifeqs
, 0},
305 {"ifge", s_if
, (int) O_ge
},
306 {"ifgt", s_if
, (int) O_gt
},
307 {"ifle", s_if
, (int) O_le
},
308 {"iflt", s_if
, (int) O_lt
},
310 {"ifndef", s_ifdef
, 1},
311 {"ifne", s_if
, (int) O_ne
},
312 {"ifnes", s_ifeqs
, 1},
313 {"ifnotdef", s_ifdef
, 1},
314 {"include", s_include
, 0},
318 {"lcomm", s_lcomm
, 0},
319 {"lflags", listing_flags
, 0}, /* Listing flags */
320 {"list", listing_list
, 1}, /* Turn listing on */
321 {"llen", listing_psize
, 1},
324 {"macro", s_macro
, 0},
325 {"mexit", s_mexit
, 0},
326 {"noformat", s_ignore
, 0},
327 {"nolist", listing_list
, 0}, /* Turn listing off */
328 {"nopage", listing_nopage
, 0},
330 {"offset", s_struct
, 0},
332 {"p2align", s_align_ptwo
, 0},
333 {"page", listing_eject
, 0},
334 {"plen", listing_psize
, 0},
335 {"psize", listing_psize
, 0}, /* set paper size */
340 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
345 {"single", float_cons
, 'f'},
347 {"space", s_space
, 0},
348 {"spc", s_ignore
, 0},
349 {"stabd", s_stab
, 'd'},
350 {"stabn", s_stab
, 'n'},
351 {"stabs", s_stab
, 's'},
352 {"string", stringer
, 1},
353 {"struct", s_struct
, 0},
357 /* This is for gcc to use. It's only just been added (2/94), so gcc
358 won't be able to use it for a while -- probably a year or more.
359 But once this has been released, check with gcc maintainers
360 before deleting it or even changing the spelling. */
361 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
362 /* If we're folding case -- done for some targets, not necessarily
363 all -- the above string in an input file will be converted to
364 this one. Match it either way... */
365 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
367 {"title", listing_title
, 0}, /* Listing title */
368 {"ttl", listing_title
, 0},
373 {"xdef", s_globl
, 0},
374 {"xref", s_ignore
, 0},
375 {"xstabs", s_xstab
, 's'},
377 {"zero", s_space
, 0},
378 {NULL
} /* end sentinel */
381 static int pop_override_ok
= 0;
382 static const char *pop_table_name
;
386 const pseudo_typeS
*table
;
389 const pseudo_typeS
*pop
;
390 for (pop
= table
; pop
->poc_name
; pop
++)
392 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
393 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
394 as_fatal ("error constructing %s pseudo-op table", pop_table_name
);
398 #ifndef md_pop_insert
399 #define md_pop_insert() pop_insert(md_pseudo_table)
402 #ifndef obj_pop_insert
403 #define obj_pop_insert() pop_insert(obj_pseudo_table)
409 po_hash
= hash_new ();
411 /* Do the target-specific pseudo ops. */
412 pop_table_name
= "md";
415 /* Now object specific. Skip any that were in the target table. */
416 pop_table_name
= "obj";
420 /* Now portable ones. Skip any that we've seen already. */
421 pop_table_name
= "standard";
422 pop_insert (potable
);
425 #define HANDLE_CONDITIONAL_ASSEMBLY() \
426 if (ignore_input ()) \
428 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
429 if (input_line_pointer == buffer_limit) \
435 /* This function is used when scrubbing the characters between #APP
438 static char *scrub_string
;
439 static char *scrub_string_end
;
442 scrub_from_string (from
)
447 *from
= scrub_string
;
448 size
= scrub_string_end
- scrub_string
;
449 scrub_string
= scrub_string_end
;
453 /* read_a_source_file()
455 * We read the file, putting things into a web that
456 * represents what we have been reading.
459 read_a_source_file (name
)
463 register char *s
; /* string of symbol, '\0' appended */
467 buffer
= input_scrub_new_file (name
);
470 listing_newline ("");
472 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
473 { /* We have another line to parse. */
474 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
475 contin
: /* JF this goto is my fault I admit it.
476 Someone brave please re-write the whole
477 input section here? Pleeze??? */
478 while (input_line_pointer
< buffer_limit
)
480 /* We have more of this buffer to parse. */
483 * We now have input_line_pointer->1st char of next line.
484 * If input_line_pointer [-1] == '\n' then we just
485 * scanned another line: so bump line counters.
487 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
489 #ifdef md_start_line_hook
490 md_start_line_hook ();
493 if (input_line_pointer
[-1] == '\n')
494 bump_line_counters ();
499 #ifdef LABELS_WITHOUT_COLONS
504 /* Text at the start of a line must be a label, we
505 run down and stick a colon in. */
506 if (is_name_beginner (*input_line_pointer
))
508 char *line_start
= input_line_pointer
;
511 HANDLE_CONDITIONAL_ASSEMBLY ();
513 c
= get_symbol_end ();
515 /* In MRI mode, the EQU pseudoop must be
516 handled specially. */
519 char *rest
= input_line_pointer
+ 1;
523 if (*rest
== ' ' || *rest
== '\t')
525 if ((strncasecmp (rest
, "EQU", 3) == 0
526 || strncasecmp (rest
, "SET", 3) == 0)
527 && (rest
[3] == ' ' || rest
[3] == '\t'))
529 input_line_pointer
= rest
+ 3;
535 line_label
= colon (line_start
);
537 *input_line_pointer
= c
;
539 input_line_pointer
++;
545 * We are at the begining of a line, or similar place.
546 * We expect a well-formed assembler statement.
547 * A "symbol-name:" is a statement.
549 * Depending on what compiler is used, the order of these tests
550 * may vary to catch most common case 1st.
551 * Each test is independent of all other tests at the (top) level.
552 * PLEASE make a compiler that doesn't use this assembler.
553 * It is crufty to waste a compiler's time encoding things for this
554 * assembler, which then wastes more time decoding it.
555 * (And communicating via (linear) files is silly!
556 * If you must pass stuff, please pass a tree!)
558 if ((c
= *input_line_pointer
++) == '\t'
563 c
= *input_line_pointer
++;
565 know (c
!= ' '); /* No further leading whitespace. */
568 * C is the 1st significant character.
569 * Input_line_pointer points after that character.
571 if (is_name_beginner (c
))
573 /* want user-defined label or pseudo/opcode */
574 HANDLE_CONDITIONAL_ASSEMBLY ();
576 s
= --input_line_pointer
;
577 c
= get_symbol_end (); /* name's delimiter */
579 * C is character after symbol.
580 * That character's place in the input line is now '\0'.
581 * S points to the beginning of the symbol.
582 * [In case of pseudo-op, s->'.'.]
583 * Input_line_pointer->'\0' where c was.
585 if (TC_START_LABEL(c
, input_line_pointer
))
589 char *rest
= input_line_pointer
+ 1;
591 /* In MRI mode, \tsym: set 0 is permitted. */
595 if (*rest
== ' ' || *rest
== '\t')
597 if ((strncasecmp (rest
, "EQU", 3) == 0
598 || strncasecmp (rest
, "SET", 3) == 0)
599 && (rest
[3] == ' ' || rest
[3] == '\t'))
601 input_line_pointer
= rest
+ 3;
607 line_label
= colon (s
); /* user-defined label */
608 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
609 /* Input_line_pointer->after ':'. */
615 || (input_line_pointer
[1] == '='
616 #ifdef TC_EQUAL_IN_INSN
617 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
622 demand_empty_rest_of_line ();
625 { /* expect pseudo-op or machine instruction */
628 #define IGNORE_OPCODE_CASE
629 #ifdef IGNORE_OPCODE_CASE
647 /* The MRI assembler and the m88k use pseudo-ops
649 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
650 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
655 || (! flag_mri
&& *s
== '.'))
660 * WARNING: c has next char, which may be end-of-line.
661 * We lookup the pseudo-op table with s+1 because we
662 * already know that the pseudo-op begins with a '.'.
666 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
668 /* In MRI mode, we may need to insert an
669 automatic alignment directive. What a hack
671 if (mri_pending_align
673 || ! ((pop
->poc_handler
== cons
674 && pop
->poc_val
== 1)
675 || (pop
->poc_handler
== s_space
676 && pop
->poc_val
== 1))))
678 do_align (1, (char *) NULL
);
679 mri_pending_align
= 0;
682 /* Print the error msg now, while we still can */
685 as_bad ("Unknown pseudo-op: `%s'", s
);
686 *input_line_pointer
= c
;
691 /* Put it back for error messages etc. */
692 *input_line_pointer
= c
;
693 /* The following skip of whitespace is compulsory.
694 A well shaped space is sometimes all that separates
695 keyword from operands. */
696 if (c
== ' ' || c
== '\t')
697 input_line_pointer
++;
699 * Input_line is restored.
700 * Input_line_pointer->1st non-blank char
701 * after pseudo-operation.
703 (*pop
->poc_handler
) (pop
->poc_val
);
705 /* If that was .end, just get out now. */
706 if (pop
->poc_handler
== s_end
)
710 { /* machine instruction */
713 if (mri_pending_align
)
715 do_align (1, (char *) NULL
);
716 mri_pending_align
= 0;
719 /* WARNING: c has char, which may be end-of-line. */
720 /* Also: input_line_pointer->`\0` where c was. */
721 *input_line_pointer
= c
;
722 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
724 #ifdef TC_EOL_IN_INSN
725 || TC_EOL_IN_INSN (input_line_pointer
)
729 if (flag_mri
&& *input_line_pointer
== '\'')
731 input_line_pointer
++;
734 c
= *input_line_pointer
;
735 *input_line_pointer
= '\0';
737 #ifdef OBJ_GENERATE_ASM_LINENO
738 if (generate_asm_lineno
== 0)
740 if (ecoff_no_current_file ())
741 generate_asm_lineno
= 1;
743 if (generate_asm_lineno
== 1)
748 as_where (&s
, &lineno
);
749 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
758 if (check_macro (s
, &out
, '\0', &err
))
762 *input_line_pointer
++ = c
;
763 input_scrub_include_sb (&out
,
767 input_scrub_next_buffer (&input_line_pointer
);
772 md_assemble (s
); /* Assemble 1 instruction. */
774 *input_line_pointer
++ = c
;
776 /* We resume loop AFTER the end-of-line from
781 } /* if (is_name_beginner(c) */
784 /* Empty statement? */
785 if (is_end_of_line
[(unsigned char) c
])
788 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
791 /* local label ("4:") */
792 char *backup
= input_line_pointer
;
794 HANDLE_CONDITIONAL_ASSEMBLY ();
798 while (isdigit (*input_line_pointer
))
800 temp
= (temp
* 10) + *input_line_pointer
- '0';
801 ++input_line_pointer
;
802 } /* read the whole number */
804 if (LOCAL_LABELS_DOLLAR
805 && *input_line_pointer
== '$'
806 && *(input_line_pointer
+ 1) == ':')
808 input_line_pointer
+= 2;
810 if (dollar_label_defined (temp
))
812 as_fatal ("label \"%d$\" redefined", temp
);
815 define_dollar_label (temp
);
816 colon (dollar_label_name (temp
, 0));
821 && *input_line_pointer
++ == ':')
823 fb_label_instance_inc (temp
);
824 colon (fb_label_name (temp
, 0));
828 input_line_pointer
= backup
;
829 } /* local label ("4:") */
831 if (c
&& strchr (line_comment_chars
, c
))
832 { /* Its a comment. Better say APP or NO_APP */
836 unsigned int new_length
;
839 bump_line_counters ();
840 s
= input_line_pointer
;
841 if (strncmp (s
, "APP\n", 4))
842 continue; /* We ignore it */
845 ends
= strstr (s
, "#NO_APP\n");
849 unsigned int tmp_len
;
852 /* The end of the #APP wasn't in this buffer. We
853 keep reading in buffers until we find the #NO_APP
854 that goes with this #APP There is one. The specs
856 tmp_len
= buffer_limit
- s
;
857 tmp_buf
= xmalloc (tmp_len
+ 1);
858 memcpy (tmp_buf
, s
, tmp_len
);
861 new_tmp
= input_scrub_next_buffer (&buffer
);
865 buffer_limit
= new_tmp
;
866 input_line_pointer
= buffer
;
867 ends
= strstr (buffer
, "#NO_APP\n");
871 num
= buffer_limit
- buffer
;
873 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
874 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
879 input_line_pointer
= ends
? ends
+ 8 : NULL
;
887 input_line_pointer
= ends
+ 8;
891 scrub_string_end
= ends
;
893 new_length
= ends
- s
;
894 new_buf
= (char *) xmalloc (new_length
);
901 space
= (new_buf
+ new_length
) - new_tmp
;
902 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
910 new_buf
= xrealloc (new_buf
, new_length
+ 100);
911 new_tmp
= new_buf
+ new_length
;
918 old_input
= input_line_pointer
;
919 old_limit
= buffer_limit
;
921 input_line_pointer
= new_buf
;
922 buffer_limit
= new_tmp
;
926 HANDLE_CONDITIONAL_ASSEMBLY ();
928 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
929 input_line_pointer
--; /* Report unknown char as ignored. */
930 ignore_rest_of_line ();
931 } /* while (input_line_pointer<buffer_limit) */
933 #ifdef md_after_pass_hook
934 md_after_pass_hook ();
940 bump_line_counters ();
944 input_line_pointer
= old_input
;
945 buffer_limit
= old_limit
;
950 } /* while (more buffers to scan) */
953 input_scrub_close (); /* Close the input file */
956 /* For most MRI pseudo-ops, the line actually ends at the first
957 nonquoted space. This function looks for that point, stuffs a null
958 in, and sets *STOPCP to the character that used to be there, and
959 returns the location. */
962 mri_comment_field (stopcp
)
970 for (s
= input_line_pointer
;
971 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
983 /* Skip to the end of an MRI comment field. */
986 mri_comment_end (stop
, stopc
)
992 input_line_pointer
= stop
;
994 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
995 ++input_line_pointer
;
1002 as_fatal (".abort detected. Abandoning ship.");
1005 /* Guts of .align directive. */
1012 md_do_align (n
, fill
, just_record_alignment
);
1016 /* @@ Fix this right for BFD! */
1018 static char nop_opcode
= NOP_OPCODE
;
1020 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1029 /* Only make a frag if we HAVE to. . . */
1030 if (n
&& !need_pass_2
)
1031 frag_align (n
, *fill
);
1034 just_record_alignment
:
1037 record_alignment (now_seg
, n
);
1040 /* For machines where ".align 4" means align to a 4 byte boundary. */
1045 register unsigned int temp
;
1048 unsigned long max_alignment
= 1 << 15;
1053 stop
= mri_comment_field (&stopc
);
1055 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1056 temp
= arg
; /* Default value from pseudo-op table */
1058 temp
= get_absolute_expression ();
1060 if (temp
> max_alignment
)
1062 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1065 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1066 have to convert it. */
1069 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1073 as_bad ("Alignment not a power of 2");
1076 if (*input_line_pointer
== ',')
1078 input_line_pointer
++;
1079 temp_fill
= get_absolute_expression ();
1080 do_align (temp
, &temp_fill
);
1083 do_align (temp
, (char *) 0);
1086 mri_comment_end (stop
, stopc
);
1088 demand_empty_rest_of_line ();
1091 /* For machines where ".align 4" means align to 2**4 boundary. */
1093 s_align_ptwo (ignore
)
1098 long max_alignment
= 15;
1103 stop
= mri_comment_field (&stopc
);
1105 temp
= get_absolute_expression ();
1106 if (temp
> max_alignment
)
1107 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1110 as_bad ("Alignment negative. 0 assumed.");
1113 if (*input_line_pointer
== ',')
1115 input_line_pointer
++;
1116 temp_fill
= get_absolute_expression ();
1117 do_align (temp
, &temp_fill
);
1120 do_align (temp
, (char *) 0);
1123 mri_comment_end (stop
, stopc
);
1125 demand_empty_rest_of_line ();
1132 register char *name
;
1136 register symbolS
*symbolP
;
1141 stop
= mri_comment_field (&stopc
);
1143 name
= input_line_pointer
;
1144 c
= get_symbol_end ();
1145 /* just after name is now '\0' */
1146 p
= input_line_pointer
;
1149 if (*input_line_pointer
!= ',')
1151 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1153 mri_comment_end (stop
, stopc
);
1154 ignore_rest_of_line ();
1157 input_line_pointer
++; /* skip ',' */
1158 if ((temp
= get_absolute_expression ()) < 0)
1160 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1162 mri_comment_end (stop
, stopc
);
1163 ignore_rest_of_line ();
1167 symbolP
= symbol_find_or_make (name
);
1169 if (S_IS_DEFINED (symbolP
))
1171 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1172 S_GET_NAME (symbolP
));
1174 mri_comment_end (stop
, stopc
);
1175 ignore_rest_of_line ();
1178 if (S_GET_VALUE (symbolP
))
1180 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1181 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1182 S_GET_NAME (symbolP
),
1183 (long) S_GET_VALUE (symbolP
),
1188 S_SET_VALUE (symbolP
, (valueT
) temp
);
1189 S_SET_EXTERNAL (symbolP
);
1193 extern int flag_one
;
1194 if ( (!temp
) || !flag_one
)
1195 S_GET_OTHER(symbolP
) = const_flag
;
1197 #endif /* not OBJ_VMS */
1198 know (symbolP
->sy_frag
== &zero_address_frag
);
1201 mri_comment_end (stop
, stopc
);
1203 demand_empty_rest_of_line ();
1206 /* The MRI COMMON pseudo-op. We handle this by creating a common
1207 symbol with the appropriate name. We make s_space do the right
1208 thing by increasing the size. */
1211 s_mri_common (small
)
1228 stop
= mri_comment_field (&stopc
);
1232 name
= input_line_pointer
;
1233 if (! isdigit ((unsigned char) *name
))
1234 c
= get_symbol_end ();
1239 ++input_line_pointer
;
1241 while (isdigit ((unsigned char) *input_line_pointer
));
1242 c
= *input_line_pointer
;
1243 *input_line_pointer
= '\0';
1245 if (line_label
!= NULL
)
1247 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1248 + (input_line_pointer
- name
)
1250 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1255 sym
= symbol_find_or_make (name
);
1256 *input_line_pointer
= c
;
1260 if (*input_line_pointer
!= ',')
1264 ++input_line_pointer
;
1265 align
= get_absolute_expression ();
1268 if (S_IS_DEFINED (sym
))
1270 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1271 if (! S_IS_COMMON (sym
))
1274 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1275 mri_comment_end (stop
, stopc
);
1276 ignore_rest_of_line ();
1281 S_SET_EXTERNAL (sym
);
1282 mri_common_symbol
= sym
;
1286 S_SET_ALIGN (sym
, align
);
1289 if (line_label
!= NULL
)
1291 line_label
->sy_value
.X_op
= O_symbol
;
1292 line_label
->sy_value
.X_add_symbol
= sym
;
1293 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1294 line_label
->sy_frag
= &zero_address_frag
;
1295 S_SET_SEGMENT (line_label
, expr_section
);
1298 /* FIXME: We just ignore the small argument, which distinguishes
1299 COMMON and COMMON.S. I don't know what we can do about it. */
1301 /* Ignore the type and hptype. */
1302 if (*input_line_pointer
== ',')
1303 input_line_pointer
+= 2;
1304 if (*input_line_pointer
== ',')
1305 input_line_pointer
+= 2;
1307 mri_comment_end (stop
, stopc
);
1309 demand_empty_rest_of_line ();
1319 temp
= get_absolute_expression ();
1320 if (flag_readonly_data_in_text
)
1322 section
= text_section
;
1326 section
= data_section
;
1328 subseg_set (section
, (subsegT
) temp
);
1333 demand_empty_rest_of_line ();
1336 /* Handle the .appfile pseudo-op. This is automatically generated by
1337 do_scrub_chars when a preprocessor # line comment is seen with a
1338 file name. This default definition may be overridden by the object
1339 or CPU specific pseudo-ops. This function is also the default
1340 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1344 s_app_file (appfile
)
1350 /* Some assemblers tolerate immediately following '"' */
1351 if ((s
= demand_copy_string (&length
)) != 0)
1353 /* If this is a fake .appfile, a fake newline was inserted into
1354 the buffer. Passing -2 to new_logical_line tells it to
1356 new_logical_line (s
, appfile
? -2 : -1);
1357 demand_empty_rest_of_line ();
1360 listing_source_file (s
);
1368 /* Handle the .appline pseudo-op. This is automatically generated by
1369 do_scrub_chars when a preprocessor # line comment is seen. This
1370 default definition may be overridden by the object or CPU specific
1379 /* The given number is that of the next line. */
1380 l
= get_absolute_expression () - 1;
1382 /* Some of the back ends can't deal with non-positive line numbers.
1383 Besides, it's silly. */
1384 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1387 new_logical_line ((char *) NULL
, l
);
1390 listing_source_line (l
);
1393 demand_empty_rest_of_line ();
1396 /* Handle the .end pseudo-op. Actually, the real work is done in
1397 read_a_source_file. */
1405 /* The MRI assembler permits the start symbol to follow .end,
1406 but we don't support that. */
1408 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1409 && *input_line_pointer
!= '*'
1410 && *input_line_pointer
!= '!')
1411 as_warn ("start address not supported");
1415 /* Handle the MRI fail pseudo-op. */
1426 stop
= mri_comment_field (&stopc
);
1428 temp
= get_absolute_expression ();
1430 as_warn (".fail %ld encountered", (long) temp
);
1432 as_bad (".fail %ld encountered", (long) temp
);
1435 mri_comment_end (stop
, stopc
);
1437 demand_empty_rest_of_line ();
1444 long temp_repeat
= 0;
1446 register long temp_fill
= 0;
1450 temp_repeat
= get_absolute_expression ();
1451 if (*input_line_pointer
== ',')
1453 input_line_pointer
++;
1454 temp_size
= get_absolute_expression ();
1455 if (*input_line_pointer
== ',')
1457 input_line_pointer
++;
1458 temp_fill
= get_absolute_expression ();
1461 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1462 #define BSD_FILL_SIZE_CROCK_8 (8)
1463 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1465 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1466 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1470 as_warn ("Size negative: .fill ignored.");
1473 else if (temp_repeat
<= 0)
1475 as_warn ("Repeat < 0, .fill ignored");
1479 if (temp_size
&& !need_pass_2
)
1481 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1482 memset (p
, 0, (unsigned int) temp_size
);
1483 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1484 * flavoured AS. The following bizzare behaviour is to be
1485 * compatible with above. I guess they tried to take up to 8
1486 * bytes from a 4-byte expression and they forgot to sign
1487 * extend. Un*x Sux. */
1488 #define BSD_FILL_SIZE_CROCK_4 (4)
1489 md_number_to_chars (p
, (valueT
) temp_fill
,
1490 (temp_size
> BSD_FILL_SIZE_CROCK_4
1491 ? BSD_FILL_SIZE_CROCK_4
1492 : (int) temp_size
));
1493 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1494 * but emits no error message because it seems a legal thing to do.
1495 * It is a degenerate case of .fill but could be emitted by a compiler.
1498 demand_empty_rest_of_line ();
1512 stop
= mri_comment_field (&stopc
);
1516 name
= input_line_pointer
;
1517 c
= get_symbol_end ();
1518 symbolP
= symbol_find_or_make (name
);
1519 *input_line_pointer
= c
;
1521 S_SET_EXTERNAL (symbolP
);
1524 input_line_pointer
++;
1526 if (*input_line_pointer
== '\n')
1533 mri_comment_end (stop
, stopc
);
1535 demand_empty_rest_of_line ();
1538 /* Handle the MRI IRP and IRPC pseudo-ops. */
1550 as_where (&file
, &line
);
1553 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1554 sb_add_char (&s
, *input_line_pointer
++);
1558 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1560 as_bad_where (file
, line
, "%s", err
);
1564 input_scrub_include_sb (&out
, input_line_pointer
);
1566 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1570 s_lcomm (needs_align
)
1571 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1572 (alignment); 0 if it was an ".lcomm" (2 args only) */
1575 register char *name
;
1579 register symbolS
*symbolP
;
1580 segT current_seg
= now_seg
;
1581 subsegT current_subseg
= now_subseg
;
1582 const int max_alignment
= 15;
1584 segT bss_seg
= bss_section
;
1586 name
= input_line_pointer
;
1587 c
= get_symbol_end ();
1588 p
= input_line_pointer
;
1592 /* Accept an optional comma after the name. The comma used to be
1593 required, but Irix 5 cc does not generate it. */
1594 if (*input_line_pointer
== ',')
1596 ++input_line_pointer
;
1600 if (*input_line_pointer
== '\n')
1602 as_bad ("Missing size expression");
1606 if ((temp
= get_absolute_expression ()) < 0)
1608 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1609 ignore_rest_of_line ();
1613 #if defined (TC_MIPS) || defined (TC_ALPHA)
1614 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1615 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1617 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1618 if (temp
<= bfd_get_gp_size (stdoutput
))
1620 bss_seg
= subseg_new (".sbss", 1);
1621 seg_info (bss_seg
)->bss
= 1;
1627 /* FIXME. This needs to be machine independent. */
1637 record_alignment(bss_seg
, align
);
1644 if (*input_line_pointer
!= ',')
1646 as_bad ("Expected comma after size");
1647 ignore_rest_of_line ();
1650 input_line_pointer
++;
1652 if (*input_line_pointer
== '\n')
1654 as_bad ("Missing alignment");
1657 align
= get_absolute_expression ();
1658 if (align
> max_alignment
)
1660 align
= max_alignment
;
1661 as_warn ("Alignment too large: %d. assumed.", align
);
1666 as_warn ("Alignment negative. 0 assumed.");
1668 record_alignment (bss_seg
, align
);
1669 } /* if needs align */
1672 /* Assume some objects may require alignment on some systems. */
1676 align
= ffs (temp
) - 1;
1677 if (temp
% (1 << align
))
1684 symbolP
= symbol_find_or_make (name
);
1688 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1689 S_GET_OTHER (symbolP
) == 0 &&
1690 S_GET_DESC (symbolP
) == 0 &&
1691 #endif /* OBJ_AOUT or OBJ_BOUT */
1692 (S_GET_SEGMENT (symbolP
) == bss_seg
1693 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1697 subseg_set (bss_seg
, 1);
1700 frag_align (align
, 0);
1701 /* detach from old frag */
1702 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1703 symbolP
->sy_frag
->fr_symbol
= NULL
;
1705 symbolP
->sy_frag
= frag_now
;
1706 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1710 S_SET_SEGMENT (symbolP
, bss_seg
);
1713 /* The symbol may already have been created with a preceding
1714 ".globl" directive -- be careful not to step on storage class
1715 in that case. Otherwise, set it to static. */
1716 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1718 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1720 #endif /* OBJ_COFF */
1723 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1724 S_GET_NAME (symbolP
));
1726 subseg_set (current_seg
, current_subseg
);
1728 demand_empty_rest_of_line ();
1735 register char *name
;
1739 register symbolS
*symbolP
;
1741 /* we permit ANY defined expression: BSD4.2 demands constants */
1742 name
= input_line_pointer
;
1743 c
= get_symbol_end ();
1744 p
= input_line_pointer
;
1747 if (*input_line_pointer
!= ',')
1750 as_bad ("Expected comma after name \"%s\"", name
);
1752 ignore_rest_of_line ();
1755 input_line_pointer
++;
1757 if (exp
.X_op
!= O_constant
1758 && exp
.X_op
!= O_register
)
1760 as_bad ("bad expression");
1761 ignore_rest_of_line ();
1765 symbolP
= symbol_find_or_make (name
);
1767 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1768 symbolP->sy_desc == 0) out of this test because coff doesn't have
1769 those fields, and I can't see when they'd ever be tripped. I
1770 don't think I understand why they were here so I may have
1771 introduced a bug. As recently as 1.37 didn't have this test
1772 anyway. xoxorich. */
1774 if (S_GET_SEGMENT (symbolP
) == undefined_section
1775 && S_GET_VALUE (symbolP
) == 0)
1777 /* The name might be an undefined .global symbol; be sure to
1778 keep the "external" bit. */
1779 S_SET_SEGMENT (symbolP
,
1780 (exp
.X_op
== O_constant
1783 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
1787 as_bad ("Symbol %s already defined", name
);
1790 demand_empty_rest_of_line ();
1793 /* Read a line into an sb. */
1799 if (input_line_pointer
>= buffer_limit
)
1801 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1802 if (buffer_limit
== 0)
1806 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1807 sb_add_char (line
, *input_line_pointer
++);
1808 while (is_end_of_line
[(unsigned char) *input_line_pointer
])
1810 if (*input_line_pointer
== '\n')
1812 bump_line_counters ();
1815 ++input_line_pointer
;
1820 /* Define a macro. This is an interface to macro.c, which is shared
1821 between gas and gasp. */
1833 as_where (&file
, &line
);
1836 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1837 sb_add_char (&s
, *input_line_pointer
++);
1840 if (line_label
!= NULL
)
1841 sb_add_string (&label
, S_GET_NAME (line_label
));
1843 demand_empty_rest_of_line ();
1845 err
= define_macro (0, &s
, &label
, get_line_sb
);
1847 as_bad_where (file
, line
, "%s", err
);
1850 if (line_label
!= NULL
)
1852 S_SET_SEGMENT (line_label
, undefined_section
);
1853 S_SET_VALUE (line_label
, 0);
1854 line_label
->sy_frag
= &zero_address_frag
;
1861 /* Handle the .mexit pseudo-op, which immediately exits a macro
1868 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1871 /* Handle changing the location counter. */
1874 do_org (segment
, exp
, fill
)
1879 if (segment
!= now_seg
&& segment
!= absolute_section
)
1880 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
1881 segment_name (segment
), segment_name (now_seg
));
1883 if (now_seg
== absolute_section
)
1886 as_warn ("ignoring fill value in absolute section");
1887 if (exp
->X_op
!= O_constant
)
1889 as_bad ("only constant offsets supported in absolute section");
1890 exp
->X_add_number
= 0;
1892 abs_section_offset
= exp
->X_add_number
;
1898 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
1899 exp
->X_add_number
, (char *) NULL
);
1908 register segT segment
;
1910 register long temp_fill
;
1912 /* The MRI assembler has a different meaning for .org. It means to
1913 create an absolute section at a given address. We can't support
1914 that--use a linker script instead. */
1917 as_bad ("MRI style ORG pseudo-op not supported");
1918 ignore_rest_of_line ();
1922 /* Don't believe the documentation of BSD 4.2 AS. There is no such
1923 thing as a sub-segment-relative origin. Any absolute origin is
1924 given a warning, then assumed to be segment-relative. Any
1925 segmented origin expression ("foo+42") had better be in the right
1926 segment or the .org is ignored.
1928 BSD 4.2 AS warns if you try to .org backwards. We cannot because
1929 we never know sub-segment sizes when we are reading code. BSD
1930 will crash trying to emit negative numbers of filler bytes in
1931 certain .orgs. We don't crash, but see as-write for that code.
1933 Don't make frag if need_pass_2==1. */
1934 segment
= get_known_segmented_expression (&exp
);
1935 if (*input_line_pointer
== ',')
1937 input_line_pointer
++;
1938 temp_fill
= get_absolute_expression ();
1944 do_org (segment
, &exp
, temp_fill
);
1946 demand_empty_rest_of_line ();
1949 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
1950 called by the obj-format routine which handles section changing
1951 when in MRI mode. It will create a new section, and return it. It
1952 will set *TYPE to the section type: one of '\0' (unspecified), 'C'
1953 (code), 'D' (data), 'M' (mixed), or 'R' (romable). If
1954 BFD_ASSEMBLER is defined, the flags will be set in the section. */
1966 name
= input_line_pointer
;
1967 if (! isdigit ((unsigned char) *name
))
1968 c
= get_symbol_end ();
1973 ++input_line_pointer
;
1975 while (isdigit ((unsigned char) *input_line_pointer
));
1976 c
= *input_line_pointer
;
1977 *input_line_pointer
= '\0';
1980 name
= strdup (name
);
1982 as_fatal ("virtual memory exhausted");
1984 *input_line_pointer
= c
;
1986 seg
= subseg_new (name
, 0);
1988 if (*input_line_pointer
== ',')
1992 ++input_line_pointer
;
1993 align
= get_absolute_expression ();
1994 record_alignment (seg
, align
);
1998 if (*input_line_pointer
== ',')
2000 c
= *++input_line_pointer
;
2001 c
= toupper ((unsigned char) c
);
2002 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2005 as_bad ("unrecognized section type");
2006 ++input_line_pointer
;
2008 #ifdef BFD_ASSEMBLER
2012 flags
= SEC_NO_FLAGS
;
2015 else if (*type
== 'D')
2017 else if (*type
== 'R')
2019 if (flags
!= SEC_NO_FLAGS
)
2021 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2022 as_warn ("error setting flags for \"%s\": %s",
2023 bfd_section_name (stdoutput
, seg
),
2024 bfd_errmsg (bfd_get_error ()));
2030 /* Ignore the HP type. */
2031 if (*input_line_pointer
== ',')
2032 input_line_pointer
+= 2;
2034 demand_empty_rest_of_line ();
2037 /* Handle the .rept pseudo-op. */
2047 count
= get_absolute_expression ();
2050 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2052 as_bad ("rept without endr");
2058 sb_add_sb (&many
, &one
);
2062 input_scrub_include_sb (&many
, input_line_pointer
);
2064 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2071 register char *name
;
2072 register char delim
;
2073 register char *end_name
;
2074 register symbolS
*symbolP
;
2077 * Especial apologies for the random logic:
2078 * this just grew, and could be parsed much more simply!
2081 name
= input_line_pointer
;
2082 delim
= get_symbol_end ();
2083 end_name
= input_line_pointer
;
2087 if (*input_line_pointer
!= ',')
2090 as_bad ("Expected comma after name \"%s\"", name
);
2092 ignore_rest_of_line ();
2096 input_line_pointer
++;
2099 if (name
[0] == '.' && name
[1] == '\0')
2101 /* Turn '. = mumble' into a .org mumble */
2102 register segT segment
;
2105 segment
= get_known_segmented_expression (&exp
);
2108 do_org (segment
, &exp
, 0);
2114 if ((symbolP
= symbol_find (name
)) == NULL
2115 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2117 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2119 /* "set" symbols are local unless otherwise specified. */
2120 SF_SET_LOCAL (symbolP
);
2121 #endif /* OBJ_COFF */
2123 } /* make a new symbol */
2125 symbol_table_insert (symbolP
);
2128 pseudo_set (symbolP
);
2129 demand_empty_rest_of_line ();
2142 #ifdef md_flush_pending_output
2143 md_flush_pending_output ();
2147 stop
= mri_comment_field (&stopc
);
2149 /* Just like .fill, but temp_size = 1 */
2151 if (exp
.X_op
== O_constant
)
2155 repeat
= exp
.X_add_number
;
2160 if (! flag_mri
|| repeat
< 0)
2161 as_warn (".space repeat count is %s, ignored",
2162 repeat
? "negative" : "zero");
2166 /* If we are in the absolute section, just bump the offset. */
2167 if (now_seg
== absolute_section
)
2169 abs_section_offset
+= repeat
;
2173 /* If we are secretly in an MRI common section, then creating
2174 space just increases the size of the common symbol. */
2175 if (mri_common_symbol
!= NULL
)
2177 S_SET_VALUE (mri_common_symbol
,
2178 S_GET_VALUE (mri_common_symbol
) + repeat
);
2183 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2184 repeat
, (char *) 0);
2188 if (now_seg
== absolute_section
)
2190 as_bad ("space allocation too complex in absolute section");
2191 subseg_set (text_section
, 0);
2193 if (mri_common_symbol
!= NULL
)
2195 as_bad ("space allocation too complex in common section");
2196 mri_common_symbol
= NULL
;
2199 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2200 make_expr_symbol (&exp
), 0L, (char *) 0);
2203 if (*input_line_pointer
== ',')
2205 input_line_pointer
++;
2206 temp_fill
= get_absolute_expression ();
2219 mri_comment_end (stop
, stopc
);
2221 demand_empty_rest_of_line ();
2224 /* This is like s_space, but the value is a floating point number with
2225 the given precision. This is for the MRI dcb.s pseudo-op and
2229 s_float_space (float_type
)
2234 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2239 stop
= mri_comment_field (&stopc
);
2241 count
= get_absolute_expression ();
2244 if (*input_line_pointer
!= ',')
2246 as_bad ("missing value");
2248 mri_comment_end (stop
, stopc
);
2249 ignore_rest_of_line ();
2253 ++input_line_pointer
;
2257 /* Skip any 0{letter} that may be present. Don't even check if the
2258 * letter is legal. */
2259 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2260 input_line_pointer
+= 2;
2262 /* Accept :xxxx, where the x's are hex digits, for a floating point
2263 with the exact digits specified. */
2264 if (input_line_pointer
[0] == ':')
2266 flen
= hex_float (float_type
, temp
);
2270 mri_comment_end (stop
, stopc
);
2271 ignore_rest_of_line ();
2279 err
= md_atof (float_type
, temp
, &flen
);
2280 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2284 as_bad ("Bad floating literal: %s", err
);
2286 mri_comment_end (stop
, stopc
);
2287 ignore_rest_of_line ();
2292 while (--count
>= 0)
2296 p
= frag_more (flen
);
2297 memcpy (p
, temp
, (unsigned int) flen
);
2301 mri_comment_end (stop
, stopc
);
2303 demand_empty_rest_of_line ();
2306 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2316 stop
= mri_comment_field (&stopc
);
2317 abs_section_offset
= get_absolute_expression ();
2318 subseg_set (absolute_section
, 0);
2320 mri_comment_end (stop
, stopc
);
2321 demand_empty_rest_of_line ();
2330 temp
= get_absolute_expression ();
2331 subseg_set (text_section
, (subsegT
) temp
);
2332 demand_empty_rest_of_line ();
2334 const_flag
&= ~IN_DEFAULT_SECTION
;
2340 demand_empty_rest_of_line ()
2343 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2345 input_line_pointer
++;
2349 ignore_rest_of_line ();
2351 /* Return having already swallowed end-of-line. */
2352 } /* Return pointing just after end-of-line. */
2355 ignore_rest_of_line () /* For suspect lines: gives warning. */
2357 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2359 if (isprint (*input_line_pointer
))
2360 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2361 *input_line_pointer
);
2363 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2364 *input_line_pointer
);
2365 while (input_line_pointer
< buffer_limit
2366 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2368 input_line_pointer
++;
2371 input_line_pointer
++; /* Return pointing just after end-of-line. */
2372 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2378 * In: Pointer to a symbol.
2379 * Input_line_pointer->expression.
2381 * Out: Input_line_pointer->just after any whitespace after expression.
2382 * Tried to set symbol to value of expression.
2383 * Will change symbols type, value, and frag;
2386 pseudo_set (symbolP
)
2390 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2392 #endif /* OBJ_AOUT or OBJ_BOUT */
2394 know (symbolP
); /* NULL pointer is logic error. */
2395 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2396 ext
= S_IS_EXTERNAL (symbolP
);
2397 #endif /* OBJ_AOUT or OBJ_BOUT */
2399 (void) expression (&exp
);
2401 if (exp
.X_op
== O_illegal
)
2402 as_bad ("illegal expression; zero assumed");
2403 else if (exp
.X_op
== O_absent
)
2404 as_bad ("missing expression; zero assumed");
2405 else if (exp
.X_op
== O_big
)
2406 as_bad ("%s number invalid; zero assumed",
2407 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2408 else if (exp
.X_op
== O_subtract
2409 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2410 == S_GET_SEGMENT (exp
.X_op_symbol
))
2411 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2412 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2414 exp
.X_op
= O_constant
;
2415 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2416 - S_GET_VALUE (exp
.X_op_symbol
));
2424 exp
.X_add_number
= 0;
2427 S_SET_SEGMENT (symbolP
, absolute_section
);
2428 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2430 S_SET_EXTERNAL (symbolP
);
2432 S_CLEAR_EXTERNAL (symbolP
);
2433 #endif /* OBJ_AOUT or OBJ_BOUT */
2434 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2435 symbolP
->sy_frag
= &zero_address_frag
;
2439 S_SET_SEGMENT (symbolP
, reg_section
);
2440 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2441 symbolP
->sy_frag
= &zero_address_frag
;
2445 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2446 || exp
.X_add_number
!= 0)
2447 symbolP
->sy_value
= exp
;
2450 symbolS
*s
= exp
.X_add_symbol
;
2452 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2453 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2455 S_SET_EXTERNAL (symbolP
);
2457 S_CLEAR_EXTERNAL (symbolP
);
2458 #endif /* OBJ_AOUT or OBJ_BOUT */
2459 S_SET_VALUE (symbolP
,
2460 exp
.X_add_number
+ S_GET_VALUE (s
));
2461 symbolP
->sy_frag
= s
->sy_frag
;
2462 copy_symbol_attributes (symbolP
, s
);
2467 /* The value is some complex expression.
2468 FIXME: Should we set the segment to anything? */
2469 symbolP
->sy_value
= exp
;
2477 * CONStruct more frag of .bytes, or .words etc.
2478 * Should need_pass_2 be 1 then emit no frag(s).
2479 * This understands EXPRESSIONS.
2483 * This has a split personality. We use expression() to read the
2484 * value. We can detect if the value won't fit in a byte or word.
2485 * But we can't detect if expression() discarded significant digits
2486 * in the case of a long. Not worth the crocks required to fix it.
2489 /* Select a parser for cons expressions. */
2491 /* Some targets need to parse the expression in various fancy ways.
2492 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2493 (for example, the HPPA does this). Otherwise, you can define
2494 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2495 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2496 are defined, which is the normal case, then only simple expressions
2500 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2502 #ifndef TC_PARSE_CONS_EXPRESSION
2503 #ifdef BITFIELD_CONS_EXPRESSIONS
2504 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2506 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2508 #ifdef REPEAT_CONS_EXPRESSIONS
2509 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2511 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2514 /* If we haven't gotten one yet, just call expression. */
2515 #ifndef TC_PARSE_CONS_EXPRESSION
2516 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2520 /* worker to do .byte etc statements */
2521 /* clobbers input_line_pointer, checks */
2524 cons_worker (nbytes
, rva
)
2525 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
2533 #ifdef md_flush_pending_output
2534 md_flush_pending_output ();
2538 stop
= mri_comment_field (&stopc
);
2540 if (is_it_end_of_statement ())
2542 mri_comment_end (stop
, stopc
);
2543 demand_empty_rest_of_line ();
2552 /* If this is an .rva pseudoop then stick
2553 an extra reloc in for this word. */
2555 char *p
= frag_more (0);
2556 exp
.X_op
= O_absent
;
2558 #ifdef BFD_ASSEMBLER
2559 reloc
= BFD_RELOC_RVA
;
2562 reloc
= TC_RVA_RELOC
;
2567 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
,
2568 nbytes
, &exp
, 0, reloc
);
2572 parse_mri_cons (&exp
, (unsigned int) nbytes
);
2574 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
2575 emit_expr (&exp
, (unsigned int) nbytes
);
2578 while (*input_line_pointer
++ == ',');
2580 /* In MRI mode, after an odd number of bytes, we must align to an
2581 even word boundary, unless the next instruction is a dc.b, ds.b
2583 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
2584 mri_pending_align
= 1;
2586 input_line_pointer
--; /* Put terminator back into stream. */
2589 mri_comment_end (stop
, stopc
);
2591 demand_empty_rest_of_line ();
2599 cons_worker (size
, 0);
2606 cons_worker (size
, 1);
2610 /* Put the contents of expression EXP into the object file using
2611 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
2614 emit_expr (exp
, nbytes
)
2616 unsigned int nbytes
;
2620 valueT extra_digit
= 0;
2622 /* Don't do anything if we are going to make another pass. */
2628 /* Allow `.word 0' in the absolute section. */
2629 if (now_seg
== absolute_section
)
2631 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
2632 as_bad ("attempt to store value in absolute section");
2633 abs_section_offset
+= nbytes
;
2637 /* Handle a negative bignum. */
2639 && exp
->X_add_number
== 0
2640 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
2641 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
2644 unsigned long carry
;
2646 exp
= &exp
->X_add_symbol
->sy_value
;
2648 /* Negate the bignum: one's complement each digit and add 1. */
2650 for (i
= 0; i
< exp
->X_add_number
; i
++)
2654 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
2657 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
2658 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
2661 /* We can ignore any carry out, because it will be handled by
2662 extra_digit if it is needed. */
2664 extra_digit
= (valueT
) -1;
2668 if (op
== O_absent
|| op
== O_illegal
)
2670 as_warn ("zero assumed for missing expression");
2671 exp
->X_add_number
= 0;
2674 else if (op
== O_big
&& exp
->X_add_number
<= 0)
2676 as_bad ("floating point number invalid; zero assumed");
2677 exp
->X_add_number
= 0;
2680 else if (op
== O_register
)
2682 as_warn ("register value used as expression");
2686 p
= frag_more ((int) nbytes
);
2688 #ifndef WORKING_DOT_WORD
2689 /* If we have the difference of two symbols in a word, save it on
2690 the broken_words list. See the code in write.c. */
2691 if (op
== O_subtract
&& nbytes
== 2)
2693 struct broken_word
*x
;
2695 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
2696 x
->next_broken_word
= broken_words
;
2699 x
->word_goes_here
= p
;
2701 x
->add
= exp
->X_add_symbol
;
2702 x
->sub
= exp
->X_op_symbol
;
2703 x
->addnum
= exp
->X_add_number
;
2710 /* If we have an integer, but the number of bytes is too large to
2711 pass to md_number_to_chars, handle it as a bignum. */
2712 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
2717 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
2718 extra_digit
= (valueT
) -1;
2719 val
= (valueT
) exp
->X_add_number
;
2723 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
2724 val
>>= LITTLENUM_NUMBER_OF_BITS
;
2728 op
= exp
->X_op
= O_big
;
2729 exp
->X_add_number
= gencnt
;
2732 if (op
== O_constant
)
2734 register valueT get
;
2735 register valueT use
;
2736 register valueT mask
;
2737 register valueT unmask
;
2739 /* JF << of >= number of bits in the object is undefined. In
2740 particular SPARC (Sun 4) has problems */
2741 if (nbytes
>= sizeof (valueT
))
2744 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
2746 unmask
= ~mask
; /* Do store these bits. */
2749 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
2750 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
2753 get
= exp
->X_add_number
;
2755 if ((get
& mask
) != 0 && (get
& mask
) != mask
)
2756 { /* Leading bits contain both 0s & 1s. */
2757 as_warn ("Value 0x%lx truncated to 0x%lx.", get
, use
);
2759 /* put bytes in right order. */
2760 md_number_to_chars (p
, use
, (int) nbytes
);
2762 else if (op
== O_big
)
2765 LITTLENUM_TYPE
*nums
;
2767 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
2769 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
2772 as_warn ("Bignum truncated to %d bytes", nbytes
);
2776 if (target_big_endian
)
2778 while (nbytes
> size
)
2780 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
2781 nbytes
-= CHARS_PER_LITTLENUM
;
2782 p
+= CHARS_PER_LITTLENUM
;
2785 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
2789 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
2790 size
-= CHARS_PER_LITTLENUM
;
2791 p
+= CHARS_PER_LITTLENUM
;
2796 nums
= generic_bignum
;
2799 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
2801 size
-= CHARS_PER_LITTLENUM
;
2802 p
+= CHARS_PER_LITTLENUM
;
2803 nbytes
-= CHARS_PER_LITTLENUM
;
2808 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
2809 nbytes
-= CHARS_PER_LITTLENUM
;
2810 p
+= CHARS_PER_LITTLENUM
;
2816 memset (p
, 0, nbytes
);
2818 /* Now we need to generate a fixS to record the symbol value.
2819 This is easy for BFD. For other targets it can be more
2820 complex. For very complex cases (currently, the HPPA and
2821 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
2822 want. For simpler cases, you can define TC_CONS_RELOC to be
2823 the name of the reloc code that should be stored in the fixS.
2824 If neither is defined, the code uses NO_RELOC if it is
2825 defined, and otherwise uses 0. */
2827 #ifdef BFD_ASSEMBLER
2828 #ifdef TC_CONS_FIX_NEW
2829 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
2831 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
2832 /* @@ Should look at CPU word size. */
2833 nbytes
== 2 ? BFD_RELOC_16
2834 : nbytes
== 8 ? BFD_RELOC_64
2838 #ifdef TC_CONS_FIX_NEW
2839 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
2841 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
2842 it is defined, otherwise use NO_RELOC if it is defined,
2844 #ifndef TC_CONS_RELOC
2846 #define TC_CONS_RELOC NO_RELOC
2848 #define TC_CONS_RELOC 0
2851 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
2853 #endif /* TC_CONS_FIX_NEW */
2854 #endif /* BFD_ASSEMBLER */
2858 #ifdef BITFIELD_CONS_EXPRESSIONS
2860 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
2861 w:x,y:z, where w and y are bitwidths and x and y are values. They
2862 then pack them all together. We do a little better in that we allow
2863 them in words, longs, etc. and we'll pack them in target byte order
2866 The rules are: pack least significat bit first, if a field doesn't
2867 entirely fit, put it in the next unit. Overflowing the bitfield is
2868 explicitly *not* even a warning. The bitwidth should be considered
2871 To use this function the tc-XXX.h file should define
2872 BITFIELD_CONS_EXPRESSIONS. */
2875 parse_bitfield_cons (exp
, nbytes
)
2877 unsigned int nbytes
;
2879 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
2880 char *hold
= input_line_pointer
;
2882 (void) expression (exp
);
2884 if (*input_line_pointer
== ':')
2890 unsigned long width
;
2892 if (*input_line_pointer
!= ':')
2894 input_line_pointer
= hold
;
2896 } /* next piece is not a bitfield */
2898 /* In the general case, we can't allow
2899 full expressions with symbol
2900 differences and such. The relocation
2901 entries for symbols not defined in this
2902 assembly would require arbitrary field
2903 widths, positions, and masks which most
2904 of our current object formats don't
2907 In the specific case where a symbol
2908 *is* defined in this assembly, we
2909 *could* build fixups and track it, but
2910 this could lead to confusion for the
2911 backends. I'm lazy. I'll take any
2912 SEG_ABSOLUTE. I think that means that
2913 you can use a previous .set or
2914 .equ type symbol. xoxorich. */
2916 if (exp
->X_op
== O_absent
)
2918 as_warn ("using a bit field width of zero");
2919 exp
->X_add_number
= 0;
2920 exp
->X_op
= O_constant
;
2921 } /* implied zero width bitfield */
2923 if (exp
->X_op
!= O_constant
)
2925 *input_line_pointer
= '\0';
2926 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
2927 *input_line_pointer
= ':';
2928 demand_empty_rest_of_line ();
2932 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
2934 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
2935 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
2936 width
= BITS_PER_CHAR
* nbytes
;
2939 if (width
> bits_available
)
2941 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
2942 input_line_pointer
= hold
;
2943 exp
->X_add_number
= value
;
2947 hold
= ++input_line_pointer
; /* skip ':' */
2949 (void) expression (exp
);
2950 if (exp
->X_op
!= O_constant
)
2952 char cache
= *input_line_pointer
;
2954 *input_line_pointer
= '\0';
2955 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
2956 *input_line_pointer
= cache
;
2957 demand_empty_rest_of_line ();
2961 value
|= ((~(-1 << width
) & exp
->X_add_number
)
2962 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
2964 if ((bits_available
-= width
) == 0
2965 || is_it_end_of_statement ()
2966 || *input_line_pointer
!= ',')
2969 } /* all the bitfields we're gonna get */
2971 hold
= ++input_line_pointer
;
2972 (void) expression (exp
);
2973 } /* forever loop */
2975 exp
->X_add_number
= value
;
2976 exp
->X_op
= O_constant
;
2977 exp
->X_unsigned
= 1;
2978 } /* if looks like a bitfield */
2979 } /* parse_bitfield_cons() */
2981 #endif /* BITFIELD_CONS_EXPRESSIONS */
2983 /* Handle an MRI style string expression. */
2986 parse_mri_cons (exp
, nbytes
)
2988 unsigned int nbytes
;
2990 if (*input_line_pointer
!= '\''
2991 && (input_line_pointer
[1] != '\''
2992 || (*input_line_pointer
!= 'A'
2993 && *input_line_pointer
!= 'E')))
2994 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
2998 unsigned int result
= 0;
3000 /* An MRI style string. Cut into as many bytes as will fit into
3001 a nbyte chunk, left justify if necessary, and separate with
3002 commas so we can try again later. */
3003 if (*input_line_pointer
== 'A')
3004 ++input_line_pointer
;
3005 else if (*input_line_pointer
== 'E')
3007 as_bad ("EBCDIC constants are not supported");
3008 ++input_line_pointer
;
3011 input_line_pointer
++;
3012 for (scan
= 0; scan
< nbytes
; scan
++)
3014 if (*input_line_pointer
== '\'')
3016 if (input_line_pointer
[1] == '\'')
3018 input_line_pointer
++;
3023 result
= (result
<< 8) | (*input_line_pointer
++);
3027 while (scan
< nbytes
)
3032 /* Create correct expression */
3033 exp
->X_op
= O_constant
;
3034 exp
->X_add_number
= result
;
3035 /* Fake it so that we can read the next char too */
3036 if (input_line_pointer
[0] != '\'' ||
3037 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3039 input_line_pointer
-= 2;
3040 input_line_pointer
[0] = ',';
3041 input_line_pointer
[1] = '\'';
3044 input_line_pointer
++;
3048 #ifdef REPEAT_CONS_EXPRESSIONS
3050 /* Parse a repeat expression for cons. This is used by the MIPS
3051 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3052 object file COUNT times.
3054 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3057 parse_repeat_cons (exp
, nbytes
)
3059 unsigned int nbytes
;
3066 if (*input_line_pointer
!= ':')
3068 /* No repeat count. */
3072 ++input_line_pointer
;
3073 expression (&count
);
3074 if (count
.X_op
!= O_constant
3075 || count
.X_add_number
<= 0)
3077 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3081 /* The cons function is going to output this expression once. So we
3082 output it count - 1 times. */
3083 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3084 emit_expr (exp
, nbytes
);
3087 #endif /* REPEAT_CONS_EXPRESSIONS */
3089 /* Parse a floating point number represented as a hex constant. This
3090 permits users to specify the exact bits they want in the floating
3094 hex_float (float_type
, bytes
)
3128 as_bad ("Unknown floating type type '%c'", float_type
);
3132 /* It would be nice if we could go through expression to parse the
3133 hex constant, but if we get a bignum it's a pain to sort it into
3134 the buffer correctly. */
3136 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3140 /* The MRI assembler accepts arbitrary underscores strewn about
3141 through the hex constant, so we ignore them as well. */
3142 if (*input_line_pointer
== '_')
3144 ++input_line_pointer
;
3150 as_warn ("Floating point constant too large");
3153 d
= hex_value (*input_line_pointer
) << 4;
3154 ++input_line_pointer
;
3155 while (*input_line_pointer
== '_')
3156 ++input_line_pointer
;
3157 if (hex_p (*input_line_pointer
))
3159 d
+= hex_value (*input_line_pointer
);
3160 ++input_line_pointer
;
3162 if (target_big_endian
)
3165 bytes
[length
- i
- 1] = d
;
3171 if (target_big_endian
)
3172 memset (bytes
+ i
, 0, length
- i
);
3174 memset (bytes
, 0, length
- i
);
3183 * CONStruct some more frag chars of .floats .ffloats etc.
3184 * Makes 0 or more new frags.
3185 * If need_pass_2 == 1, no frags are emitted.
3186 * This understands only floating literals, not expressions. Sorry.
3188 * A floating constant is defined by atof_generic(), except it is preceded
3189 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3190 * reading, I decided to be incompatible. This always tries to give you
3191 * rounded bits to the precision of the pseudo-op. Former AS did premature
3192 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3193 * a choice of 2 flavours of noise according to which of 2 floating-point
3194 * scanners you directed AS to use.
3196 * In: input_line_pointer->whitespace before, or '0' of flonum.
3201 float_cons (float_type
)
3202 /* Clobbers input_line-pointer, checks end-of-line. */
3203 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3206 int length
; /* Number of chars in an object. */
3207 register char *err
; /* Error from scanning floating literal. */
3208 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3210 if (is_it_end_of_statement ())
3212 demand_empty_rest_of_line ();
3218 /* input_line_pointer->1st char of a flonum (we hope!). */
3221 /* Skip any 0{letter} that may be present. Don't even check if the
3222 * letter is legal. Someone may invent a "z" format and this routine
3223 * has no use for such information. Lusers beware: you get
3224 * diagnostics if your input is ill-conditioned.
3226 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3227 input_line_pointer
+= 2;
3229 /* Accept :xxxx, where the x's are hex digits, for a floating
3230 point with the exact digits specified. */
3231 if (input_line_pointer
[0] == ':')
3233 ++input_line_pointer
;
3234 length
= hex_float (float_type
, temp
);
3237 ignore_rest_of_line ();
3243 err
= md_atof (float_type
, temp
, &length
);
3244 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3248 as_bad ("Bad floating literal: %s", err
);
3249 ignore_rest_of_line ();
3260 #ifdef REPEAT_CONS_EXPRESSIONS
3261 if (*input_line_pointer
== ':')
3263 expressionS count_exp
;
3265 ++input_line_pointer
;
3266 expression (&count_exp
);
3267 if (count_exp
.X_op
!= O_constant
3268 || count_exp
.X_add_number
<= 0)
3270 as_warn ("unresolvable or nonpositive repeat count; using 1");
3273 count
= count_exp
.X_add_number
;
3277 while (--count
>= 0)
3279 p
= frag_more (length
);
3280 memcpy (p
, temp
, (unsigned int) length
);
3285 while (*input_line_pointer
++ == ',');
3287 --input_line_pointer
; /* Put terminator back into stream. */
3288 demand_empty_rest_of_line ();
3289 } /* float_cons() */
3294 * We read 0 or more ',' seperated, double-quoted strings.
3296 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3301 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3302 /* Checks end-of-line. */
3303 register int append_zero
; /* 0: don't append '\0', else 1 */
3305 register unsigned int c
;
3307 #ifdef md_flush_pending_output
3308 md_flush_pending_output ();
3312 * The following awkward logic is to parse ZERO or more strings,
3313 * comma seperated. Recall a string expression includes spaces
3314 * before the opening '\"' and spaces after the closing '\"'.
3315 * We fake a leading ',' if there is (supposed to be)
3316 * a 1st, expression. We keep demanding expressions for each
3319 if (is_it_end_of_statement ())
3321 c
= 0; /* Skip loop. */
3322 ++input_line_pointer
; /* Compensate for end of loop. */
3326 c
= ','; /* Do loop. */
3328 while (c
== ',' || c
== '<' || c
== '"')
3331 switch (*input_line_pointer
)
3334 ++input_line_pointer
; /*->1st char of string. */
3335 while (is_a_char (c
= next_char_of_string ()))
3337 FRAG_APPEND_1_CHAR (c
);
3341 FRAG_APPEND_1_CHAR (0);
3343 know (input_line_pointer
[-1] == '\"');
3346 input_line_pointer
++;
3347 c
= get_single_number ();
3348 FRAG_APPEND_1_CHAR (c
);
3349 if (*input_line_pointer
!= '>')
3351 as_bad ("Expected <nn>");
3353 input_line_pointer
++;
3356 input_line_pointer
++;
3360 c
= *input_line_pointer
;
3363 demand_empty_rest_of_line ();
3366 /* FIXME-SOMEDAY: I had trouble here on characters with the
3367 high bits set. We'll probably also have trouble with
3368 multibyte chars, wide chars, etc. Also be careful about
3369 returning values bigger than 1 byte. xoxorich. */
3372 next_char_of_string ()
3374 register unsigned int c
;
3376 c
= *input_line_pointer
++ & CHAR_MASK
;
3383 #ifndef NO_STRING_ESCAPES
3385 switch (c
= *input_line_pointer
++)
3413 break; /* As itself. */
3429 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3431 number
= number
* 8 + c
- '0';
3435 --input_line_pointer
;
3444 c
= *input_line_pointer
++;
3445 while (isxdigit (c
))
3448 number
= number
* 16 + c
- '0';
3449 else if (isupper (c
))
3450 number
= number
* 16 + c
- 'A' + 10;
3452 number
= number
* 16 + c
- 'a' + 10;
3453 c
= *input_line_pointer
++;
3456 --input_line_pointer
;
3461 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3462 as_warn ("Unterminated string: Newline inserted.");
3468 #ifdef ONLY_STANDARD_ESCAPES
3469 as_bad ("Bad escaped character in string, '?' assumed");
3471 #endif /* ONLY_STANDARD_ESCAPES */
3474 } /* switch on escaped char */
3476 #endif /* ! defined (NO_STRING_ESCAPES) */
3480 } /* switch on char */
3482 } /* next_char_of_string() */
3485 get_segmented_expression (expP
)
3486 register expressionS
*expP
;
3488 register segT retval
;
3490 retval
= expression (expP
);
3491 if (expP
->X_op
== O_illegal
3492 || expP
->X_op
== O_absent
3493 || expP
->X_op
== O_big
)
3495 as_bad ("expected address expression; zero assumed");
3496 expP
->X_op
= O_constant
;
3497 expP
->X_add_number
= 0;
3498 retval
= absolute_section
;
3504 get_known_segmented_expression (expP
)
3505 register expressionS
*expP
;
3507 register segT retval
;
3509 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
3511 /* There is no easy way to extract the undefined symbol from the
3513 if (expP
->X_add_symbol
!= NULL
3514 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
3515 as_warn ("symbol \"%s\" undefined; zero assumed",
3516 S_GET_NAME (expP
->X_add_symbol
));
3518 as_warn ("some symbol undefined; zero assumed");
3519 retval
= absolute_section
;
3520 expP
->X_op
= O_constant
;
3521 expP
->X_add_number
= 0;
3523 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
3525 } /* get_known_segmented_expression() */
3528 get_absolute_expression ()
3533 if (exp
.X_op
!= O_constant
)
3535 if (exp
.X_op
!= O_absent
)
3536 as_bad ("bad or irreducible absolute expression; zero assumed");
3537 exp
.X_add_number
= 0;
3539 return exp
.X_add_number
;
3542 char /* return terminator */
3543 get_absolute_expression_and_terminator (val_pointer
)
3544 long *val_pointer
; /* return value of expression */
3546 /* FIXME: val_pointer should probably be offsetT *. */
3547 *val_pointer
= (long) get_absolute_expression ();
3548 return (*input_line_pointer
++);
3552 * demand_copy_C_string()
3554 * Like demand_copy_string, but return NULL if the string contains any '\0's.
3555 * Give a warning if that happens.
3558 demand_copy_C_string (len_pointer
)
3563 if ((s
= demand_copy_string (len_pointer
)) != 0)
3567 for (len
= *len_pointer
;
3576 as_bad ("This string may not contain \'\\0\'");
3584 * demand_copy_string()
3586 * Demand string, but return a safe (=private) copy of the string.
3587 * Return NULL if we can't read a string here.
3590 demand_copy_string (lenP
)
3593 register unsigned int c
;
3599 if (*input_line_pointer
== '\"')
3601 input_line_pointer
++; /* Skip opening quote. */
3603 while (is_a_char (c
= next_char_of_string ()))
3605 obstack_1grow (¬es
, c
);
3608 /* JF this next line is so demand_copy_C_string will return a null
3609 termanated string. */
3610 obstack_1grow (¬es
, '\0');
3611 retval
= obstack_finish (¬es
);
3615 as_warn ("Missing string");
3617 ignore_rest_of_line ();
3621 } /* demand_copy_string() */
3624 * is_it_end_of_statement()
3626 * In: Input_line_pointer->next character.
3628 * Do: Skip input_line_pointer over all whitespace.
3630 * Out: 1 if input_line_pointer->end-of-line.
3633 is_it_end_of_statement ()
3636 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
3637 } /* is_it_end_of_statement() */
3643 register symbolS
*symbolP
; /* symbol we are working with */
3647 input_line_pointer
++;
3648 if (*input_line_pointer
== '=')
3649 input_line_pointer
++;
3651 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
3652 input_line_pointer
++;
3655 stop
= mri_comment_field (&stopc
);
3657 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
3659 /* Turn '. = mumble' into a .org mumble */
3660 register segT segment
;
3663 segment
= get_known_segmented_expression (&exp
);
3665 do_org (segment
, &exp
, 0);
3669 symbolP
= symbol_find_or_make (sym_name
);
3670 pseudo_set (symbolP
);
3674 mri_comment_end (stop
, stopc
);
3677 /* .include -- include a file at this point. */
3691 filename
= demand_copy_string (&i
);
3696 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
3697 && *input_line_pointer
!= ' '
3698 && *input_line_pointer
!= '\t')
3700 obstack_1grow (¬es
, *input_line_pointer
);
3701 ++input_line_pointer
;
3704 obstack_1grow (¬es
, '\0');
3705 filename
= obstack_finish (¬es
);
3707 demand_empty_rest_of_line ();
3708 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
3709 for (i
= 0; i
< include_dir_count
; i
++)
3711 strcpy (path
, include_dirs
[i
]);
3713 strcat (path
, filename
);
3714 if (0 != (try = fopen (path
, "r")))
3723 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
3724 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
3725 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3729 add_include_dir (path
)
3734 if (include_dir_count
== 0)
3736 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
3737 include_dirs
[0] = "."; /* Current dir */
3738 include_dir_count
= 2;
3742 include_dir_count
++;
3743 include_dirs
= (char **) realloc (include_dirs
,
3744 include_dir_count
* sizeof (*include_dirs
));
3747 include_dirs
[include_dir_count
- 1] = path
; /* New one */
3750 if (i
> include_dir_maxlen
)
3751 include_dir_maxlen
= i
;
3752 } /* add_include_dir() */
3758 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
3760 ++input_line_pointer
;
3762 ++input_line_pointer
;