1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 1997
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 the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
24 change this a bit. But then, GNU isn't
25 spozed to run on your machine anyway.
26 (RMS is so shortsighted sometimes.)
29 #define MASK_CHAR ((int)(unsigned char)-1)
33 /* This is the largest known floating point format (for now). It will
34 grow when we do 4361 style flonums. */
36 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
38 /* Routines that read assembler source text to build spagetti in memory.
39 Another group of these functions is in the expr.c module. */
52 #ifndef TC_START_LABEL
53 #define TC_START_LABEL(x,y) (x==':')
56 /* The NOP_OPCODE is for the alignment fill value.
57 * fill it a nop instruction so that the disassembler does not choke
61 #define NOP_OPCODE 0x00
64 char *input_line_pointer
; /*->next char of source file to parse. */
66 int generate_asm_lineno
= 0; /* flag to generate line stab for .s file */
68 #if BITS_PER_CHAR != 8
69 /* The following table is indexed by[(char)] and will break if
70 a char does not have exactly 256 states (hopefully 0:255!)! */
75 /* The m88k unfortunately uses @ as a label beginner. */
80 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
85 /* The Delta 68k assembler permits % inside label names. */
90 /* The PowerPC Windows NT assemblers permits ? inside label names. */
95 /* The a29k assembler does not permits labels to start with $. */
99 /* used by is_... macros. our ctype[] */
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
104 0, 0, 0, 0, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
105 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
106 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
107 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
108 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
109 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 0, /* pqrstuvwxyz{|}~. */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
122 * Out: 1 if this character ends a line.
125 char is_end_of_line
[256] =
128 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
130 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
132 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
134 _
,99, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* _!"#$%&'()*+,-./ */
135 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* 0123456789:;<=>? */
137 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
138 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
140 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
141 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
142 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
143 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
144 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
145 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
146 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
147 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
148 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
152 /* Functions private to this file. */
154 static char *buffer
; /* 1st char of each buffer of lines is here. */
155 static char *buffer_limit
; /*->1 + last char in buffer. */
157 #ifdef TARGET_BYTES_BIG_ENDIAN
158 /* Hack to deal with tc-*.h defining TARGET_BYTES_BIG_ENDIAN to empty
159 instead of to 0 or 1. */
160 #if 5 - TARGET_BYTES_BIG_ENDIAN - 5 == 10
161 #undef TARGET_BYTES_BIG_ENDIAN
162 #define TARGET_BYTES_BIG_ENDIAN 1
164 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
166 int target_big_endian
/* = 0 */;
169 static char *old_buffer
; /* JF a hack */
170 static char *old_input
;
171 static char *old_limit
;
173 /* Variables for handling include file directory list. */
175 char **include_dirs
; /* List of pointers to directories to
176 search for .include's */
177 int include_dir_count
; /* How many are in the list */
178 int include_dir_maxlen
= 1;/* Length of longest in list */
180 #ifndef WORKING_DOT_WORD
181 struct broken_word
*broken_words
;
182 int new_broken_words
;
185 /* The current offset into the absolute section. We don't try to
186 build frags in the absolute section, since no data can be stored
187 there. We just keep track of the current offset. */
188 addressT abs_section_offset
;
190 /* If this line had an MRI style label, it is stored in this variable.
191 This is used by some of the MRI pseudo-ops. */
194 /* This global variable is used to support MRI common sections. We
195 translate such sections into a common symbol. This variable is
196 non-NULL when we are in an MRI common section. */
197 symbolS
*mri_common_symbol
;
199 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
200 need to align to an even byte boundary unless the next pseudo-op is
201 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
203 static int mri_pending_align
;
205 static int scrub_from_string
PARAMS ((char **));
206 static void do_align
PARAMS ((int, char *, int));
207 static int hex_float
PARAMS ((int, char *));
208 static void do_org
PARAMS ((segT
, expressionS
*, int));
209 char *demand_copy_string
PARAMS ((int *lenP
));
210 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
211 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
212 static void pobegin
PARAMS ((void));
213 static int get_line_sb
PARAMS ((sb
*));
222 obj_read_begin_hook ();
224 /* Something close -- but not too close -- to a multiple of 1024.
225 The debugging malloc I'm using has 24 bytes of overhead. */
226 obstack_begin (¬es
, chunksize
);
227 obstack_begin (&cond_obstack
, chunksize
);
229 /* Use machine dependent syntax */
230 for (p
= line_separator_chars
; *p
; p
++)
231 is_end_of_line
[(unsigned char) *p
] = 1;
232 /* Use more. FIXME-SOMEDAY. */
238 /* set up pseudo-op tables */
240 static struct hash_control
*po_hash
;
242 static const pseudo_typeS potable
[] =
244 {"abort", s_abort
, 0},
245 {"align", s_align_ptwo
, 0},
246 {"ascii", stringer
, 0},
247 {"asciz", stringer
, 1},
248 {"balign", s_align_bytes
, 0},
249 {"balignw", s_align_bytes
, -2},
250 {"balignl", s_align_bytes
, -4},
254 {"common", s_mri_common
, 0},
255 {"common.s", s_mri_common
, 1},
259 {"dc.d", float_cons
, 'd'},
261 {"dc.s", float_cons
, 'f'},
263 {"dc.x", float_cons
, 'x'},
265 {"dcb.b", s_space
, 1},
266 {"dcb.d", s_float_space
, 'd'},
267 {"dcb.l", s_space
, 4},
268 {"dcb.s", s_float_space
, 'f'},
269 {"dcb.w", s_space
, 2},
270 {"dcb.x", s_float_space
, 'x'},
272 {"ds.b", s_space
, 1},
273 {"ds.d", s_space
, 8},
274 {"ds.l", s_space
, 4},
275 {"ds.p", s_space
, 12},
276 {"ds.s", s_space
, 4},
277 {"ds.w", s_space
, 2},
278 {"ds.x", s_space
, 12},
279 {"debug", s_ignore
, 0},
284 {"double", float_cons
, 'd'},
286 {"eject", listing_eject
, 0}, /* Formfeed listing */
288 {"elsec", s_else
, 0},
290 {"endc", s_endif
, 0},
291 {"endif", s_endif
, 0},
295 {"exitm", s_mexit
, 0},
297 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
298 {"appfile", s_app_file
, 1},
299 {"appline", s_app_line
, 0},
301 {"file", s_app_file
, 0},
303 {"float", float_cons
, 'f'},
304 {"format", s_ignore
, 0},
305 {"global", s_globl
, 0},
306 {"globl", s_globl
, 0},
308 {"if", s_if
, (int) O_ne
},
310 {"ifdef", s_ifdef
, 0},
311 {"ifeq", s_if
, (int) O_eq
},
312 {"ifeqs", s_ifeqs
, 0},
313 {"ifge", s_if
, (int) O_ge
},
314 {"ifgt", s_if
, (int) O_gt
},
315 {"ifle", s_if
, (int) O_le
},
316 {"iflt", s_if
, (int) O_lt
},
318 {"ifndef", s_ifdef
, 1},
319 {"ifne", s_if
, (int) O_ne
},
320 {"ifnes", s_ifeqs
, 1},
321 {"ifnotdef", s_ifdef
, 1},
322 {"include", s_include
, 0},
328 {"lcomm", s_lcomm
, 0},
329 {"lflags", listing_flags
, 0}, /* Listing flags */
330 {"linkonce", s_linkonce
, 0},
331 {"list", listing_list
, 1}, /* Turn listing on */
332 {"llen", listing_psize
, 1},
335 {"macro", s_macro
, 0},
336 {"mexit", s_mexit
, 0},
338 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
339 {"name", s_ignore
, 0},
340 {"noformat", s_ignore
, 0},
341 {"nolist", listing_list
, 0}, /* Turn listing off */
342 {"nopage", listing_nopage
, 0},
344 {"offset", s_struct
, 0},
346 {"p2align", s_align_ptwo
, 0},
347 {"p2alignw", s_align_ptwo
, -2},
348 {"p2alignl", s_align_ptwo
, -4},
349 {"page", listing_eject
, 0},
350 {"plen", listing_psize
, 0},
351 {"print", s_print
, 0},
352 {"psize", listing_psize
, 0}, /* set paper size */
353 {"purgem", s_purgem
, 0},
358 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
363 {"single", float_cons
, 'f'},
365 {"space", s_space
, 0},
366 {"skip", s_space
, 0},
367 {"spc", s_ignore
, 0},
368 {"stabd", s_stab
, 'd'},
369 {"stabn", s_stab
, 'n'},
370 {"stabs", s_stab
, 's'},
371 {"string", stringer
, 1},
372 {"struct", s_struct
, 0},
376 /* This is for gcc to use. It's only just been added (2/94), so gcc
377 won't be able to use it for a while -- probably a year or more.
378 But once this has been released, check with gcc maintainers
379 before deleting it or even changing the spelling. */
380 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
381 /* If we're folding case -- done for some targets, not necessarily
382 all -- the above string in an input file will be converted to
383 this one. Match it either way... */
384 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
386 {"title", listing_title
, 0}, /* Listing title */
387 {"ttl", listing_title
, 0},
392 {"xdef", s_globl
, 0},
393 {"xref", s_ignore
, 0},
394 {"xstabs", s_xstab
, 's'},
396 {"zero", s_space
, 0},
397 {NULL
} /* end sentinel */
400 static int pop_override_ok
= 0;
401 static const char *pop_table_name
;
405 const pseudo_typeS
*table
;
408 const pseudo_typeS
*pop
;
409 for (pop
= table
; pop
->poc_name
; pop
++)
411 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
412 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
413 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
418 #ifndef md_pop_insert
419 #define md_pop_insert() pop_insert(md_pseudo_table)
422 #ifndef obj_pop_insert
423 #define obj_pop_insert() pop_insert(obj_pseudo_table)
429 po_hash
= hash_new ();
431 /* Do the target-specific pseudo ops. */
432 pop_table_name
= "md";
435 /* Now object specific. Skip any that were in the target table. */
436 pop_table_name
= "obj";
440 /* Now portable ones. Skip any that we've seen already. */
441 pop_table_name
= "standard";
442 pop_insert (potable
);
445 #define HANDLE_CONDITIONAL_ASSEMBLY() \
446 if (ignore_input ()) \
448 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
449 if (input_line_pointer == buffer_limit) \
455 /* This function is used when scrubbing the characters between #APP
458 static char *scrub_string
;
459 static char *scrub_string_end
;
462 scrub_from_string (from
)
467 *from
= scrub_string
;
468 size
= scrub_string_end
- scrub_string
;
469 scrub_string
= scrub_string_end
;
473 /* read_a_source_file()
475 * We read the file, putting things into a web that
476 * represents what we have been reading.
479 read_a_source_file (name
)
483 register char *s
; /* string of symbol, '\0' appended */
487 buffer
= input_scrub_new_file (name
);
490 listing_newline ("");
492 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
493 { /* We have another line to parse. */
494 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
495 contin
: /* JF this goto is my fault I admit it.
496 Someone brave please re-write the whole
497 input section here? Pleeze??? */
498 while (input_line_pointer
< buffer_limit
)
500 /* We have more of this buffer to parse. */
503 * We now have input_line_pointer->1st char of next line.
504 * If input_line_pointer [-1] == '\n' then we just
505 * scanned another line: so bump line counters.
507 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
509 #ifdef md_start_line_hook
510 md_start_line_hook ();
513 if (input_line_pointer
[-1] == '\n')
514 bump_line_counters ();
519 #ifdef LABELS_WITHOUT_COLONS
524 /* Text at the start of a line must be a label, we
525 run down and stick a colon in. */
526 if (is_name_beginner (*input_line_pointer
))
528 char *line_start
= input_line_pointer
;
532 HANDLE_CONDITIONAL_ASSEMBLY ();
534 c
= get_symbol_end ();
536 /* In MRI mode, the EQU and MACRO pseudoops must
537 be handled specially. */
541 char *rest
= input_line_pointer
+ 1;
545 if (*rest
== ' ' || *rest
== '\t')
547 if ((strncasecmp (rest
, "EQU", 3) == 0
548 || strncasecmp (rest
, "SET", 3) == 0)
549 && (rest
[3] == ' ' || rest
[3] == '\t'))
551 input_line_pointer
= rest
+ 3;
555 if (strncasecmp (rest
, "MACRO", 5) == 0
558 || is_end_of_line
[(unsigned char) rest
[5]]))
562 /* In MRI mode, we need to handle the MACRO
563 pseudo-op specially: we don't want to put the
564 symbol in the symbol table. */
565 if (! mri_line_macro
)
566 line_label
= colon (line_start
);
568 line_label
= symbol_create (line_start
,
573 *input_line_pointer
= c
;
575 input_line_pointer
++;
581 * We are at the begining of a line, or similar place.
582 * We expect a well-formed assembler statement.
583 * A "symbol-name:" is a statement.
585 * Depending on what compiler is used, the order of these tests
586 * may vary to catch most common case 1st.
587 * Each test is independent of all other tests at the (top) level.
588 * PLEASE make a compiler that doesn't use this assembler.
589 * It is crufty to waste a compiler's time encoding things for this
590 * assembler, which then wastes more time decoding it.
591 * (And communicating via (linear) files is silly!
592 * If you must pass stuff, please pass a tree!)
594 if ((c
= *input_line_pointer
++) == '\t'
599 c
= *input_line_pointer
++;
601 know (c
!= ' '); /* No further leading whitespace. */
604 * C is the 1st significant character.
605 * Input_line_pointer points after that character.
607 if (is_name_beginner (c
))
609 /* want user-defined label or pseudo/opcode */
610 HANDLE_CONDITIONAL_ASSEMBLY ();
612 s
= --input_line_pointer
;
613 c
= get_symbol_end (); /* name's delimiter */
615 * C is character after symbol.
616 * That character's place in the input line is now '\0'.
617 * S points to the beginning of the symbol.
618 * [In case of pseudo-op, s->'.'.]
619 * Input_line_pointer->'\0' where c was.
621 if (TC_START_LABEL(c
, input_line_pointer
))
625 char *rest
= input_line_pointer
+ 1;
627 /* In MRI mode, \tsym: set 0 is permitted. */
631 if (*rest
== ' ' || *rest
== '\t')
633 if ((strncasecmp (rest
, "EQU", 3) == 0
634 || strncasecmp (rest
, "SET", 3) == 0)
635 && (rest
[3] == ' ' || rest
[3] == '\t'))
637 input_line_pointer
= rest
+ 3;
643 line_label
= colon (s
); /* user-defined label */
644 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
645 /* Input_line_pointer->after ':'. */
651 || ((c
== ' ' || c
== '\t')
652 && input_line_pointer
[1] == '='
653 #ifdef TC_EQUAL_IN_INSN
654 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
659 demand_empty_rest_of_line ();
662 { /* expect pseudo-op or machine instruction */
665 #define IGNORE_OPCODE_CASE
666 #ifdef IGNORE_OPCODE_CASE
684 /* The MRI assembler and the m88k use pseudo-ops
686 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
687 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
692 || (! flag_m68k_mri
&& *s
== '.'))
697 * WARNING: c has next char, which may be end-of-line.
698 * We lookup the pseudo-op table with s+1 because we
699 * already know that the pseudo-op begins with a '.'.
703 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
705 /* In MRI mode, we may need to insert an
706 automatic alignment directive. What a hack
708 if (mri_pending_align
710 || ! ((pop
->poc_handler
== cons
711 && pop
->poc_val
== 1)
712 || (pop
->poc_handler
== s_space
713 && pop
->poc_val
== 1)
714 #ifdef tc_conditional_pseudoop
715 || tc_conditional_pseudoop (pop
)
717 || pop
->poc_handler
== s_if
718 || pop
->poc_handler
== s_ifdef
719 || pop
->poc_handler
== s_ifc
720 || pop
->poc_handler
== s_ifeqs
721 || pop
->poc_handler
== s_else
722 || pop
->poc_handler
== s_endif
)))
724 do_align (1, (char *) NULL
, 0);
725 mri_pending_align
= 0;
726 if (line_label
!= NULL
)
728 line_label
->sy_frag
= frag_now
;
729 S_SET_VALUE (line_label
, frag_now_fix ());
733 /* Print the error msg now, while we still can */
736 as_bad ("Unknown pseudo-op: `%s'", s
);
737 *input_line_pointer
= c
;
742 /* Put it back for error messages etc. */
743 *input_line_pointer
= c
;
744 /* The following skip of whitespace is compulsory.
745 A well shaped space is sometimes all that separates
746 keyword from operands. */
747 if (c
== ' ' || c
== '\t')
748 input_line_pointer
++;
750 * Input_line is restored.
751 * Input_line_pointer->1st non-blank char
752 * after pseudo-operation.
754 (*pop
->poc_handler
) (pop
->poc_val
);
756 /* If that was .end, just get out now. */
757 if (pop
->poc_handler
== s_end
)
764 /* WARNING: c has char, which may be end-of-line. */
765 /* Also: input_line_pointer->`\0` where c was. */
766 *input_line_pointer
= c
;
767 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
769 #ifdef TC_EOL_IN_INSN
770 || TC_EOL_IN_INSN (input_line_pointer
)
774 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
776 input_line_pointer
++;
779 c
= *input_line_pointer
;
780 *input_line_pointer
= '\0';
782 #ifdef OBJ_GENERATE_ASM_LINENO
783 if (generate_asm_lineno
== 0)
785 if (ecoff_no_current_file ())
786 generate_asm_lineno
= 1;
788 if (generate_asm_lineno
== 1)
793 as_where (&s
, &lineno
);
794 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
803 if (check_macro (s
, &out
, '\0', &err
))
807 *input_line_pointer
++ = c
;
808 input_scrub_include_sb (&out
,
812 input_scrub_next_buffer (&input_line_pointer
);
817 if (mri_pending_align
)
819 do_align (1, (char *) NULL
, 0);
820 mri_pending_align
= 0;
821 if (line_label
!= NULL
)
823 line_label
->sy_frag
= frag_now
;
824 S_SET_VALUE (line_label
, frag_now_fix ());
828 md_assemble (s
); /* Assemble 1 instruction. */
830 *input_line_pointer
++ = c
;
832 /* We resume loop AFTER the end-of-line from
837 } /* if (is_name_beginner(c) */
840 /* Empty statement? */
841 if (is_end_of_line
[(unsigned char) c
])
844 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
847 /* local label ("4:") */
848 char *backup
= input_line_pointer
;
850 HANDLE_CONDITIONAL_ASSEMBLY ();
854 while (isdigit (*input_line_pointer
))
856 temp
= (temp
* 10) + *input_line_pointer
- '0';
857 ++input_line_pointer
;
858 } /* read the whole number */
860 if (LOCAL_LABELS_DOLLAR
861 && *input_line_pointer
== '$'
862 && *(input_line_pointer
+ 1) == ':')
864 input_line_pointer
+= 2;
866 if (dollar_label_defined (temp
))
868 as_fatal ("label \"%d$\" redefined", temp
);
871 define_dollar_label (temp
);
872 colon (dollar_label_name (temp
, 0));
877 && *input_line_pointer
++ == ':')
879 fb_label_instance_inc (temp
);
880 colon (fb_label_name (temp
, 0));
884 input_line_pointer
= backup
;
885 } /* local label ("4:") */
887 if (c
&& strchr (line_comment_chars
, c
))
888 { /* Its a comment. Better say APP or NO_APP */
892 unsigned int new_length
;
895 bump_line_counters ();
896 s
= input_line_pointer
;
897 if (strncmp (s
, "APP\n", 4))
898 continue; /* We ignore it */
901 ends
= strstr (s
, "#NO_APP\n");
905 unsigned int tmp_len
;
908 /* The end of the #APP wasn't in this buffer. We
909 keep reading in buffers until we find the #NO_APP
910 that goes with this #APP There is one. The specs
912 tmp_len
= buffer_limit
- s
;
913 tmp_buf
= xmalloc (tmp_len
+ 1);
914 memcpy (tmp_buf
, s
, tmp_len
);
917 new_tmp
= input_scrub_next_buffer (&buffer
);
921 buffer_limit
= new_tmp
;
922 input_line_pointer
= buffer
;
923 ends
= strstr (buffer
, "#NO_APP\n");
927 num
= buffer_limit
- buffer
;
929 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
930 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
935 input_line_pointer
= ends
? ends
+ 8 : NULL
;
943 input_line_pointer
= ends
+ 8;
947 scrub_string_end
= ends
;
949 new_length
= ends
- s
;
950 new_buf
= (char *) xmalloc (new_length
);
957 space
= (new_buf
+ new_length
) - new_tmp
;
958 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
966 new_buf
= xrealloc (new_buf
, new_length
+ 100);
967 new_tmp
= new_buf
+ new_length
;
974 old_input
= input_line_pointer
;
975 old_limit
= buffer_limit
;
977 input_line_pointer
= new_buf
;
978 buffer_limit
= new_tmp
;
982 HANDLE_CONDITIONAL_ASSEMBLY ();
984 #ifdef tc_unrecognized_line
985 if (tc_unrecognized_line (c
))
989 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
990 input_line_pointer
--; /* Report unknown char as ignored. */
991 ignore_rest_of_line ();
992 } /* while (input_line_pointer<buffer_limit) */
994 #ifdef md_after_pass_hook
995 md_after_pass_hook ();
1001 bump_line_counters ();
1004 buffer
= old_buffer
;
1005 input_line_pointer
= old_input
;
1006 buffer_limit
= old_limit
;
1011 } /* while (more buffers to scan) */
1018 input_scrub_close (); /* Close the input file */
1021 /* For most MRI pseudo-ops, the line actually ends at the first
1022 nonquoted space. This function looks for that point, stuffs a null
1023 in, and sets *STOPCP to the character that used to be there, and
1024 returns the location.
1026 Until I hear otherwise, I am going to assume that this is only true
1027 for the m68k MRI assembler. */
1030 mri_comment_field (stopcp
)
1038 know (flag_m68k_mri
);
1040 for (s
= input_line_pointer
;
1041 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1046 inquote
= ! inquote
;
1056 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1066 /* Skip to the end of an MRI comment field. */
1069 mri_comment_end (stop
, stopc
)
1075 input_line_pointer
= stop
;
1077 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1078 ++input_line_pointer
;
1085 as_fatal (".abort detected. Abandoning ship.");
1088 /* Guts of .align directive. */
1090 do_align (n
, fill
, len
)
1096 md_do_align (n
, fill
, len
, just_record_alignment
);
1100 /* @@ Fix this right for BFD! */
1102 static char nop_opcode
= NOP_OPCODE
;
1104 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1115 /* Only make a frag if we HAVE to. . . */
1116 if (n
&& !need_pass_2
)
1119 frag_align (n
, *fill
);
1121 frag_align_pattern (n
, fill
, len
);
1125 just_record_alignment
:
1128 record_alignment (now_seg
, n
);
1131 /* For machines where ".align 4" means align to a 4 byte boundary. */
1136 register unsigned int temp
;
1139 unsigned long max_alignment
= 1 << 15;
1144 stop
= mri_comment_field (&stopc
);
1146 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1151 temp
= arg
; /* Default value from pseudo-op table */
1154 temp
= get_absolute_expression ();
1156 if (temp
> max_alignment
)
1158 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1161 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1162 have to convert it. */
1165 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1169 as_bad ("Alignment not a power of 2");
1172 if (*input_line_pointer
== ',')
1177 input_line_pointer
++;
1178 fillval
= get_absolute_expression ();
1185 temp_fill
= fillval
;
1186 do_align (temp
, &temp_fill
, len
);
1192 if (len
> sizeof ab
)
1194 md_number_to_chars (ab
, fillval
, len
);
1195 do_align (temp
, ab
, len
);
1201 as_warn ("expected fill pattern missing");
1202 do_align (temp
, (char *) NULL
, 0);
1206 mri_comment_end (stop
, stopc
);
1208 demand_empty_rest_of_line ();
1211 /* For machines where ".align 4" means align to 2**4 boundary. */
1218 long max_alignment
= 15;
1223 stop
= mri_comment_field (&stopc
);
1225 temp
= get_absolute_expression ();
1226 if (temp
> max_alignment
)
1227 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1230 as_bad ("Alignment negative. 0 assumed.");
1233 if (*input_line_pointer
== ',')
1238 input_line_pointer
++;
1239 fillval
= get_absolute_expression ();
1246 temp_fill
= fillval
;
1247 do_align (temp
, &temp_fill
, len
);
1253 if (len
> sizeof ab
)
1255 md_number_to_chars (ab
, fillval
, len
);
1256 do_align (temp
, ab
, len
);
1262 as_warn ("expected fill pattern missing");
1263 do_align (temp
, (char *) NULL
, 0);
1267 mri_comment_end (stop
, stopc
);
1269 demand_empty_rest_of_line ();
1276 register char *name
;
1280 register symbolS
*symbolP
;
1285 stop
= mri_comment_field (&stopc
);
1287 name
= input_line_pointer
;
1288 c
= get_symbol_end ();
1289 /* just after name is now '\0' */
1290 p
= input_line_pointer
;
1293 if (*input_line_pointer
!= ',')
1295 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1297 mri_comment_end (stop
, stopc
);
1298 ignore_rest_of_line ();
1301 input_line_pointer
++; /* skip ',' */
1302 if ((temp
= get_absolute_expression ()) < 0)
1304 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1306 mri_comment_end (stop
, stopc
);
1307 ignore_rest_of_line ();
1311 symbolP
= symbol_find_or_make (name
);
1313 if (S_IS_DEFINED (symbolP
))
1315 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1316 S_GET_NAME (symbolP
));
1318 mri_comment_end (stop
, stopc
);
1319 ignore_rest_of_line ();
1322 if (S_GET_VALUE (symbolP
))
1324 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1325 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1326 S_GET_NAME (symbolP
),
1327 (long) S_GET_VALUE (symbolP
),
1332 S_SET_VALUE (symbolP
, (valueT
) temp
);
1333 S_SET_EXTERNAL (symbolP
);
1337 extern int flag_one
;
1338 if ( (!temp
) || !flag_one
)
1339 S_GET_OTHER(symbolP
) = const_flag
;
1341 #endif /* not OBJ_VMS */
1342 know (symbolP
->sy_frag
== &zero_address_frag
);
1345 mri_comment_end (stop
, stopc
);
1347 demand_empty_rest_of_line ();
1350 /* The MRI COMMON pseudo-op. We handle this by creating a common
1351 symbol with the appropriate name. We make s_space do the right
1352 thing by increasing the size. */
1355 s_mri_common (small
)
1372 stop
= mri_comment_field (&stopc
);
1376 name
= input_line_pointer
;
1377 if (! isdigit ((unsigned char) *name
))
1378 c
= get_symbol_end ();
1383 ++input_line_pointer
;
1385 while (isdigit ((unsigned char) *input_line_pointer
));
1386 c
= *input_line_pointer
;
1387 *input_line_pointer
= '\0';
1389 if (line_label
!= NULL
)
1391 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1392 + (input_line_pointer
- name
)
1394 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1399 sym
= symbol_find_or_make (name
);
1400 *input_line_pointer
= c
;
1404 if (*input_line_pointer
!= ',')
1408 ++input_line_pointer
;
1409 align
= get_absolute_expression ();
1412 if (S_IS_DEFINED (sym
))
1414 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1415 if (! S_IS_COMMON (sym
))
1418 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1419 mri_comment_end (stop
, stopc
);
1420 ignore_rest_of_line ();
1425 S_SET_EXTERNAL (sym
);
1426 mri_common_symbol
= sym
;
1430 S_SET_ALIGN (sym
, align
);
1433 if (line_label
!= NULL
)
1435 line_label
->sy_value
.X_op
= O_symbol
;
1436 line_label
->sy_value
.X_add_symbol
= sym
;
1437 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1438 line_label
->sy_frag
= &zero_address_frag
;
1439 S_SET_SEGMENT (line_label
, expr_section
);
1442 /* FIXME: We just ignore the small argument, which distinguishes
1443 COMMON and COMMON.S. I don't know what we can do about it. */
1445 /* Ignore the type and hptype. */
1446 if (*input_line_pointer
== ',')
1447 input_line_pointer
+= 2;
1448 if (*input_line_pointer
== ',')
1449 input_line_pointer
+= 2;
1451 mri_comment_end (stop
, stopc
);
1453 demand_empty_rest_of_line ();
1463 temp
= get_absolute_expression ();
1464 if (flag_readonly_data_in_text
)
1466 section
= text_section
;
1470 section
= data_section
;
1472 subseg_set (section
, (subsegT
) temp
);
1477 demand_empty_rest_of_line ();
1480 /* Handle the .appfile pseudo-op. This is automatically generated by
1481 do_scrub_chars when a preprocessor # line comment is seen with a
1482 file name. This default definition may be overridden by the object
1483 or CPU specific pseudo-ops. This function is also the default
1484 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1488 s_app_file (appfile
)
1494 /* Some assemblers tolerate immediately following '"' */
1495 if ((s
= demand_copy_string (&length
)) != 0)
1497 /* If this is a fake .appfile, a fake newline was inserted into
1498 the buffer. Passing -2 to new_logical_line tells it to
1500 new_logical_line (s
, appfile
? -2 : -1);
1502 /* In MRI mode, the preprocessor may have inserted an extraneous
1505 && *input_line_pointer
== '\''
1506 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1507 ++input_line_pointer
;
1509 demand_empty_rest_of_line ();
1512 listing_source_file (s
);
1520 /* Handle the .appline pseudo-op. This is automatically generated by
1521 do_scrub_chars when a preprocessor # line comment is seen. This
1522 default definition may be overridden by the object or CPU specific
1531 /* The given number is that of the next line. */
1532 l
= get_absolute_expression () - 1;
1534 /* Some of the back ends can't deal with non-positive line numbers.
1535 Besides, it's silly. */
1536 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1539 new_logical_line ((char *) NULL
, l
);
1542 listing_source_line (l
);
1545 demand_empty_rest_of_line ();
1548 /* Handle the .end pseudo-op. Actually, the real work is done in
1549 read_a_source_file. */
1557 /* The MRI assembler permits the start symbol to follow .end,
1558 but we don't support that. */
1560 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1561 && *input_line_pointer
!= '*'
1562 && *input_line_pointer
!= '!')
1563 as_warn ("start address not supported");
1567 /* Handle the .err pseudo-op. */
1573 as_bad (".err encountered");
1574 demand_empty_rest_of_line ();
1577 /* Handle the MRI fail pseudo-op. */
1588 stop
= mri_comment_field (&stopc
);
1590 temp
= get_absolute_expression ();
1592 as_warn (".fail %ld encountered", (long) temp
);
1594 as_bad (".fail %ld encountered", (long) temp
);
1597 mri_comment_end (stop
, stopc
);
1599 demand_empty_rest_of_line ();
1606 long temp_repeat
= 0;
1608 register long temp_fill
= 0;
1611 #ifdef md_flush_pending_output
1612 md_flush_pending_output ();
1615 temp_repeat
= get_absolute_expression ();
1616 if (*input_line_pointer
== ',')
1618 input_line_pointer
++;
1619 temp_size
= get_absolute_expression ();
1620 if (*input_line_pointer
== ',')
1622 input_line_pointer
++;
1623 temp_fill
= get_absolute_expression ();
1626 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1627 #define BSD_FILL_SIZE_CROCK_8 (8)
1628 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1630 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1631 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1635 as_warn ("Size negative: .fill ignored.");
1638 else if (temp_repeat
<= 0)
1640 if (temp_repeat
< 0)
1641 as_warn ("Repeat < 0, .fill ignored");
1645 if (temp_size
&& !need_pass_2
)
1647 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1648 memset (p
, 0, (unsigned int) temp_size
);
1649 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1650 * flavoured AS. The following bizzare behaviour is to be
1651 * compatible with above. I guess they tried to take up to 8
1652 * bytes from a 4-byte expression and they forgot to sign
1653 * extend. Un*x Sux. */
1654 #define BSD_FILL_SIZE_CROCK_4 (4)
1655 md_number_to_chars (p
, (valueT
) temp_fill
,
1656 (temp_size
> BSD_FILL_SIZE_CROCK_4
1657 ? BSD_FILL_SIZE_CROCK_4
1658 : (int) temp_size
));
1659 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1660 * but emits no error message because it seems a legal thing to do.
1661 * It is a degenerate case of .fill but could be emitted by a compiler.
1664 demand_empty_rest_of_line ();
1678 stop
= mri_comment_field (&stopc
);
1682 name
= input_line_pointer
;
1683 c
= get_symbol_end ();
1684 symbolP
= symbol_find_or_make (name
);
1685 *input_line_pointer
= c
;
1687 S_SET_EXTERNAL (symbolP
);
1690 input_line_pointer
++;
1692 if (*input_line_pointer
== '\n')
1699 mri_comment_end (stop
, stopc
);
1701 demand_empty_rest_of_line ();
1704 /* Handle the MRI IRP and IRPC pseudo-ops. */
1716 as_where (&file
, &line
);
1719 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1720 sb_add_char (&s
, *input_line_pointer
++);
1724 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1726 as_bad_where (file
, line
, "%s", err
);
1730 input_scrub_include_sb (&out
, input_line_pointer
);
1732 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1735 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1736 the section to only be linked once. However, this is not supported
1737 by most object file formats. This takes an optional argument,
1738 which is what to do about duplicates. */
1744 enum linkonce_type type
;
1748 type
= LINKONCE_DISCARD
;
1750 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1755 s
= input_line_pointer
;
1756 c
= get_symbol_end ();
1757 if (strcasecmp (s
, "discard") == 0)
1758 type
= LINKONCE_DISCARD
;
1759 else if (strcasecmp (s
, "one_only") == 0)
1760 type
= LINKONCE_ONE_ONLY
;
1761 else if (strcasecmp (s
, "same_size") == 0)
1762 type
= LINKONCE_SAME_SIZE
;
1763 else if (strcasecmp (s
, "same_contents") == 0)
1764 type
= LINKONCE_SAME_CONTENTS
;
1766 as_warn ("unrecognized .linkonce type `%s'", s
);
1768 *input_line_pointer
= c
;
1771 #ifdef obj_handle_link_once
1772 obj_handle_link_once (type
);
1773 #else /* ! defined (obj_handle_link_once) */
1774 #ifdef BFD_ASSEMBLER
1778 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1779 as_warn (".linkonce is not supported for this object file format");
1781 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1782 flags
|= SEC_LINK_ONCE
;
1787 case LINKONCE_DISCARD
:
1788 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1790 case LINKONCE_ONE_ONLY
:
1791 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1793 case LINKONCE_SAME_SIZE
:
1794 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1796 case LINKONCE_SAME_CONTENTS
:
1797 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1800 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1801 as_bad ("bfd_set_section_flags: %s",
1802 bfd_errmsg (bfd_get_error ()));
1804 #else /* ! defined (BFD_ASSEMBLER) */
1805 as_warn (".linkonce is not supported for this object file format");
1806 #endif /* ! defined (BFD_ASSEMBLER) */
1807 #endif /* ! defined (obj_handle_link_once) */
1809 demand_empty_rest_of_line ();
1813 s_lcomm (needs_align
)
1814 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1815 (alignment); 0 if it was an ".lcomm" (2 args only) */
1818 register char *name
;
1822 register symbolS
*symbolP
;
1823 segT current_seg
= now_seg
;
1824 subsegT current_subseg
= now_subseg
;
1825 const int max_alignment
= 15;
1827 segT bss_seg
= bss_section
;
1829 name
= input_line_pointer
;
1830 c
= get_symbol_end ();
1831 p
= input_line_pointer
;
1835 /* Accept an optional comma after the name. The comma used to be
1836 required, but Irix 5 cc does not generate it. */
1837 if (*input_line_pointer
== ',')
1839 ++input_line_pointer
;
1843 if (*input_line_pointer
== '\n')
1845 as_bad ("Missing size expression");
1849 if ((temp
= get_absolute_expression ()) < 0)
1851 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1852 ignore_rest_of_line ();
1856 #if defined (TC_MIPS) || defined (TC_ALPHA)
1857 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1858 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1860 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1861 if (temp
<= bfd_get_gp_size (stdoutput
))
1863 bss_seg
= subseg_new (".sbss", 1);
1864 seg_info (bss_seg
)->bss
= 1;
1865 #ifdef BFD_ASSEMBLER
1866 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1867 as_warn ("error setting flags for \".sbss\": %s",
1868 bfd_errmsg (bfd_get_error ()));
1875 /* FIXME. This needs to be machine independent. */
1886 /* FIXME: This needs to be done in a more general fashion. */
1890 record_alignment(bss_seg
, align
);
1897 if (*input_line_pointer
!= ',')
1899 as_bad ("Expected comma after size");
1900 ignore_rest_of_line ();
1903 input_line_pointer
++;
1905 if (*input_line_pointer
== '\n')
1907 as_bad ("Missing alignment");
1910 align
= get_absolute_expression ();
1911 if (align
> max_alignment
)
1913 align
= max_alignment
;
1914 as_warn ("Alignment too large: %d. assumed.", align
);
1919 as_warn ("Alignment negative. 0 assumed.");
1921 record_alignment (bss_seg
, align
);
1922 } /* if needs align */
1925 /* Assume some objects may require alignment on some systems. */
1926 #if defined (TC_ALPHA) && ! defined (VMS)
1929 align
= ffs (temp
) - 1;
1930 if (temp
% (1 << align
))
1937 symbolP
= symbol_find_or_make (name
);
1941 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1942 S_GET_OTHER (symbolP
) == 0 &&
1943 S_GET_DESC (symbolP
) == 0 &&
1944 #endif /* OBJ_AOUT or OBJ_BOUT */
1945 (S_GET_SEGMENT (symbolP
) == bss_seg
1946 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1950 subseg_set (bss_seg
, 1);
1953 frag_align (align
, 0);
1954 /* detach from old frag */
1955 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1956 symbolP
->sy_frag
->fr_symbol
= NULL
;
1958 symbolP
->sy_frag
= frag_now
;
1959 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1963 S_SET_SEGMENT (symbolP
, bss_seg
);
1966 /* The symbol may already have been created with a preceding
1967 ".globl" directive -- be careful not to step on storage class
1968 in that case. Otherwise, set it to static. */
1969 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1971 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1973 #endif /* OBJ_COFF */
1976 S_SET_SIZE (symbolP
, temp
);
1980 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1981 S_GET_NAME (symbolP
));
1983 subseg_set (current_seg
, current_subseg
);
1985 demand_empty_rest_of_line ();
1992 register char *name
;
1996 register symbolS
*symbolP
;
1998 /* we permit ANY defined expression: BSD4.2 demands constants */
1999 name
= input_line_pointer
;
2000 c
= get_symbol_end ();
2001 p
= input_line_pointer
;
2004 if (*input_line_pointer
!= ',')
2007 as_bad ("Expected comma after name \"%s\"", name
);
2009 ignore_rest_of_line ();
2012 input_line_pointer
++;
2014 if (exp
.X_op
!= O_constant
2015 && exp
.X_op
!= O_register
)
2017 as_bad ("bad expression");
2018 ignore_rest_of_line ();
2022 symbolP
= symbol_find_or_make (name
);
2024 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2025 symbolP->sy_desc == 0) out of this test because coff doesn't have
2026 those fields, and I can't see when they'd ever be tripped. I
2027 don't think I understand why they were here so I may have
2028 introduced a bug. As recently as 1.37 didn't have this test
2029 anyway. xoxorich. */
2031 if (S_GET_SEGMENT (symbolP
) == undefined_section
2032 && S_GET_VALUE (symbolP
) == 0)
2034 /* The name might be an undefined .global symbol; be sure to
2035 keep the "external" bit. */
2036 S_SET_SEGMENT (symbolP
,
2037 (exp
.X_op
== O_constant
2040 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2044 as_bad ("Symbol %s already defined", name
);
2047 demand_empty_rest_of_line ();
2050 /* Read a line into an sb. */
2056 if (input_line_pointer
[-1] == '\n')
2057 bump_line_counters ();
2059 if (input_line_pointer
>= buffer_limit
)
2061 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2062 if (buffer_limit
== 0)
2066 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2067 sb_add_char (line
, *input_line_pointer
++);
2068 while (input_line_pointer
< buffer_limit
2069 && is_end_of_line
[(unsigned char) *input_line_pointer
])
2071 if (input_line_pointer
[-1] == '\n')
2072 bump_line_counters ();
2073 ++input_line_pointer
;
2078 /* Define a macro. This is an interface to macro.c, which is shared
2079 between gas and gasp. */
2092 as_where (&file
, &line
);
2095 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2096 sb_add_char (&s
, *input_line_pointer
++);
2099 if (line_label
!= NULL
)
2100 sb_add_string (&label
, S_GET_NAME (line_label
));
2102 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2104 as_bad_where (file
, line
, "%s", err
);
2107 if (line_label
!= NULL
)
2109 S_SET_SEGMENT (line_label
, undefined_section
);
2110 S_SET_VALUE (line_label
, 0);
2111 line_label
->sy_frag
= &zero_address_frag
;
2115 #ifdef NO_PSEUDO_DOT
2119 && hash_find (po_hash
, name
) != NULL
)
2122 && hash_find (po_hash
, name
+ 1) != NULL
))
2123 as_warn ("attempt to redefine pseudo-op `%s' ignored",
2130 /* Handle the .mexit pseudo-op, which immediately exits a macro
2137 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2140 /* Switch in and out of MRI mode. */
2148 on
= get_absolute_expression ();
2149 old_flag
= flag_mri
;
2163 #ifdef MRI_MODE_CHANGE
2165 MRI_MODE_CHANGE (on
);
2168 demand_empty_rest_of_line ();
2171 /* Handle changing the location counter. */
2174 do_org (segment
, exp
, fill
)
2179 if (segment
!= now_seg
&& segment
!= absolute_section
)
2180 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2181 segment_name (segment
), segment_name (now_seg
));
2183 if (now_seg
== absolute_section
)
2186 as_warn ("ignoring fill value in absolute section");
2187 if (exp
->X_op
!= O_constant
)
2189 as_bad ("only constant offsets supported in absolute section");
2190 exp
->X_add_number
= 0;
2192 abs_section_offset
= exp
->X_add_number
;
2198 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2199 exp
->X_add_number
, (char *) NULL
);
2208 register segT segment
;
2210 register long temp_fill
;
2212 /* The m68k MRI assembler has a different meaning for .org. It
2213 means to create an absolute section at a given address. We can't
2214 support that--use a linker script instead. */
2217 as_bad ("MRI style ORG pseudo-op not supported");
2218 ignore_rest_of_line ();
2222 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2223 thing as a sub-segment-relative origin. Any absolute origin is
2224 given a warning, then assumed to be segment-relative. Any
2225 segmented origin expression ("foo+42") had better be in the right
2226 segment or the .org is ignored.
2228 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2229 we never know sub-segment sizes when we are reading code. BSD
2230 will crash trying to emit negative numbers of filler bytes in
2231 certain .orgs. We don't crash, but see as-write for that code.
2233 Don't make frag if need_pass_2==1. */
2234 segment
= get_known_segmented_expression (&exp
);
2235 if (*input_line_pointer
== ',')
2237 input_line_pointer
++;
2238 temp_fill
= get_absolute_expression ();
2244 do_org (segment
, &exp
, temp_fill
);
2246 demand_empty_rest_of_line ();
2249 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2250 called by the obj-format routine which handles section changing
2251 when in MRI mode. It will create a new section, and return it. It
2252 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2253 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2254 flags will be set in the section. */
2268 name
= input_line_pointer
;
2269 if (! isdigit ((unsigned char) *name
))
2270 c
= get_symbol_end ();
2275 ++input_line_pointer
;
2277 while (isdigit ((unsigned char) *input_line_pointer
));
2278 c
= *input_line_pointer
;
2279 *input_line_pointer
= '\0';
2282 name
= xstrdup (name
);
2284 *input_line_pointer
= c
;
2286 seg
= subseg_new (name
, 0);
2288 if (*input_line_pointer
== ',')
2292 ++input_line_pointer
;
2293 align
= get_absolute_expression ();
2294 record_alignment (seg
, align
);
2298 if (*input_line_pointer
== ',')
2300 c
= *++input_line_pointer
;
2301 c
= toupper ((unsigned char) c
);
2302 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2305 as_bad ("unrecognized section type");
2306 ++input_line_pointer
;
2308 #ifdef BFD_ASSEMBLER
2312 flags
= SEC_NO_FLAGS
;
2314 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2315 else if (*type
== 'D' || *type
== 'M')
2316 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2317 else if (*type
== 'R')
2318 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2319 if (flags
!= SEC_NO_FLAGS
)
2321 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2322 as_warn ("error setting flags for \"%s\": %s",
2323 bfd_section_name (stdoutput
, seg
),
2324 bfd_errmsg (bfd_get_error ()));
2330 /* Ignore the HP type. */
2331 if (*input_line_pointer
== ',')
2332 input_line_pointer
+= 2;
2334 demand_empty_rest_of_line ();
2336 #else /* ! TC_M68K */
2345 name
= input_line_pointer
;
2346 c
= get_symbol_end ();
2348 name
= xstrdup (name
);
2350 *input_line_pointer
= c
;
2352 seg
= subseg_new (name
, 0);
2354 if (*input_line_pointer
!= ',')
2360 ++input_line_pointer
;
2362 sectype
= input_line_pointer
;
2363 c
= get_symbol_end ();
2364 if (*sectype
== '\0')
2366 else if (strcasecmp (sectype
, "text") == 0)
2368 else if (strcasecmp (sectype
, "data") == 0)
2370 else if (strcasecmp (sectype
, "romdata") == 0)
2373 as_warn ("unrecognized section type `%s'", sectype
);
2374 *input_line_pointer
= c
;
2377 if (*input_line_pointer
== ',')
2381 ++input_line_pointer
;
2383 seccmd
= input_line_pointer
;
2384 c
= get_symbol_end ();
2385 if (strcasecmp (seccmd
, "absolute") == 0)
2387 as_bad ("absolute sections are not supported");
2388 *input_line_pointer
= c
;
2389 ignore_rest_of_line ();
2392 else if (strcasecmp (seccmd
, "align") == 0)
2396 *input_line_pointer
= c
;
2397 align
= get_absolute_expression ();
2398 record_alignment (seg
, align
);
2402 as_warn ("unrecognized section command `%s'", seccmd
);
2403 *input_line_pointer
= c
;
2407 demand_empty_rest_of_line ();
2409 #else /* ! TC_I960 */
2410 /* The MRI assembler seems to use different forms of .sect for
2411 different targets. */
2413 #endif /* ! TC_I960 */
2414 #endif /* ! TC_M68K */
2417 /* Handle the .print pseudo-op. */
2426 s
= demand_copy_C_string (&len
);
2428 demand_empty_rest_of_line ();
2431 /* Handle the .purgem pseudo-op. */
2437 if (is_it_end_of_statement ())
2439 demand_empty_rest_of_line ();
2449 name
= input_line_pointer
;
2450 c
= get_symbol_end ();
2451 delete_macro (name
);
2452 *input_line_pointer
= c
;
2455 while (*input_line_pointer
++ == ',');
2457 --input_line_pointer
;
2458 demand_empty_rest_of_line ();
2461 /* Handle the .rept pseudo-op. */
2471 count
= get_absolute_expression ();
2474 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2476 as_bad ("rept without endr");
2482 sb_add_sb (&many
, &one
);
2486 input_scrub_include_sb (&many
, input_line_pointer
);
2488 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2495 register char *name
;
2496 register char delim
;
2497 register char *end_name
;
2498 register symbolS
*symbolP
;
2501 * Especial apologies for the random logic:
2502 * this just grew, and could be parsed much more simply!
2505 name
= input_line_pointer
;
2506 delim
= get_symbol_end ();
2507 end_name
= input_line_pointer
;
2511 if (*input_line_pointer
!= ',')
2514 as_bad ("Expected comma after name \"%s\"", name
);
2516 ignore_rest_of_line ();
2520 input_line_pointer
++;
2523 if (name
[0] == '.' && name
[1] == '\0')
2525 /* Turn '. = mumble' into a .org mumble */
2526 register segT segment
;
2529 segment
= get_known_segmented_expression (&exp
);
2532 do_org (segment
, &exp
, 0);
2538 if ((symbolP
= symbol_find (name
)) == NULL
2539 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2541 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2543 /* "set" symbols are local unless otherwise specified. */
2544 SF_SET_LOCAL (symbolP
);
2545 #endif /* OBJ_COFF */
2547 } /* make a new symbol */
2549 symbol_table_insert (symbolP
);
2552 pseudo_set (symbolP
);
2553 demand_empty_rest_of_line ();
2567 #ifdef md_flush_pending_output
2568 md_flush_pending_output ();
2572 stop
= mri_comment_field (&stopc
);
2574 /* In m68k MRI mode, we need to align to a word boundary, unless
2576 if (flag_m68k_mri
&& mult
> 1)
2578 if (now_seg
== absolute_section
)
2580 abs_section_offset
+= abs_section_offset
& 1;
2581 if (line_label
!= NULL
)
2582 S_SET_VALUE (line_label
, abs_section_offset
);
2584 else if (mri_common_symbol
!= NULL
)
2588 val
= S_GET_VALUE (mri_common_symbol
);
2591 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2592 if (line_label
!= NULL
)
2594 know (line_label
->sy_value
.X_op
== O_symbol
);
2595 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2596 line_label
->sy_value
.X_add_number
+= 1;
2602 do_align (1, (char *) NULL
, 0);
2603 if (line_label
!= NULL
)
2605 line_label
->sy_frag
= frag_now
;
2606 S_SET_VALUE (line_label
, frag_now_fix ());
2616 if (*input_line_pointer
== ',')
2618 ++input_line_pointer
;
2623 val
.X_op
= O_constant
;
2624 val
.X_add_number
= 0;
2627 if (val
.X_op
!= O_constant
2628 || val
.X_add_number
< - 0x80
2629 || val
.X_add_number
> 0xff
2630 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2632 if (exp
.X_op
!= O_constant
)
2633 as_bad ("Unsupported variable size or fill value");
2640 bytes
= mult
* exp
.X_add_number
;
2641 for (i
= 0; i
< exp
.X_add_number
; i
++)
2642 emit_expr (&val
, mult
);
2647 if (exp
.X_op
== O_constant
)
2651 repeat
= exp
.X_add_number
;
2657 if (! flag_mri
|| repeat
< 0)
2658 as_warn (".space repeat count is %s, ignored",
2659 repeat
? "negative" : "zero");
2663 /* If we are in the absolute section, just bump the offset. */
2664 if (now_seg
== absolute_section
)
2666 abs_section_offset
+= repeat
;
2670 /* If we are secretly in an MRI common section, then
2671 creating space just increases the size of the common
2673 if (mri_common_symbol
!= NULL
)
2675 S_SET_VALUE (mri_common_symbol
,
2676 S_GET_VALUE (mri_common_symbol
) + repeat
);
2681 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2682 repeat
, (char *) 0);
2686 if (now_seg
== absolute_section
)
2688 as_bad ("space allocation too complex in absolute section");
2689 subseg_set (text_section
, 0);
2691 if (mri_common_symbol
!= NULL
)
2693 as_bad ("space allocation too complex in common section");
2694 mri_common_symbol
= NULL
;
2697 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2698 make_expr_symbol (&exp
), 0L, (char *) 0);
2702 *p
= val
.X_add_number
;
2707 /* In MRI mode, after an odd number of bytes, we must align to an
2708 even word boundary, unless the next instruction is a dc.b, ds.b
2710 if (flag_mri
&& (bytes
& 1) != 0)
2711 mri_pending_align
= 1;
2714 mri_comment_end (stop
, stopc
);
2716 demand_empty_rest_of_line ();
2719 /* This is like s_space, but the value is a floating point number with
2720 the given precision. This is for the MRI dcb.s pseudo-op and
2724 s_float_space (float_type
)
2729 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2734 stop
= mri_comment_field (&stopc
);
2736 count
= get_absolute_expression ();
2739 if (*input_line_pointer
!= ',')
2741 as_bad ("missing value");
2743 mri_comment_end (stop
, stopc
);
2744 ignore_rest_of_line ();
2748 ++input_line_pointer
;
2752 /* Skip any 0{letter} that may be present. Don't even check if the
2753 * letter is legal. */
2754 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2755 input_line_pointer
+= 2;
2757 /* Accept :xxxx, where the x's are hex digits, for a floating point
2758 with the exact digits specified. */
2759 if (input_line_pointer
[0] == ':')
2761 flen
= hex_float (float_type
, temp
);
2765 mri_comment_end (stop
, stopc
);
2766 ignore_rest_of_line ();
2774 err
= md_atof (float_type
, temp
, &flen
);
2775 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2779 as_bad ("Bad floating literal: %s", err
);
2781 mri_comment_end (stop
, stopc
);
2782 ignore_rest_of_line ();
2787 while (--count
>= 0)
2791 p
= frag_more (flen
);
2792 memcpy (p
, temp
, (unsigned int) flen
);
2796 mri_comment_end (stop
, stopc
);
2798 demand_empty_rest_of_line ();
2801 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2811 stop
= mri_comment_field (&stopc
);
2812 abs_section_offset
= get_absolute_expression ();
2813 subseg_set (absolute_section
, 0);
2815 mri_comment_end (stop
, stopc
);
2816 demand_empty_rest_of_line ();
2825 temp
= get_absolute_expression ();
2826 subseg_set (text_section
, (subsegT
) temp
);
2827 demand_empty_rest_of_line ();
2829 const_flag
&= ~IN_DEFAULT_SECTION
;
2835 demand_empty_rest_of_line ()
2838 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2840 input_line_pointer
++;
2844 ignore_rest_of_line ();
2846 /* Return having already swallowed end-of-line. */
2847 } /* Return pointing just after end-of-line. */
2850 ignore_rest_of_line () /* For suspect lines: gives warning. */
2852 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2854 if (isprint (*input_line_pointer
))
2855 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2856 *input_line_pointer
);
2858 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2859 *input_line_pointer
);
2860 while (input_line_pointer
< buffer_limit
2861 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2863 input_line_pointer
++;
2866 input_line_pointer
++; /* Return pointing just after end-of-line. */
2867 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2873 * In: Pointer to a symbol.
2874 * Input_line_pointer->expression.
2876 * Out: Input_line_pointer->just after any whitespace after expression.
2877 * Tried to set symbol to value of expression.
2878 * Will change symbols type, value, and frag;
2881 pseudo_set (symbolP
)
2885 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2887 #endif /* OBJ_AOUT or OBJ_BOUT */
2889 know (symbolP
); /* NULL pointer is logic error. */
2890 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2891 ext
= S_IS_EXTERNAL (symbolP
);
2892 #endif /* OBJ_AOUT or OBJ_BOUT */
2894 (void) expression (&exp
);
2896 if (exp
.X_op
== O_illegal
)
2897 as_bad ("illegal expression; zero assumed");
2898 else if (exp
.X_op
== O_absent
)
2899 as_bad ("missing expression; zero assumed");
2900 else if (exp
.X_op
== O_big
)
2901 as_bad ("%s number invalid; zero assumed",
2902 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2903 else if (exp
.X_op
== O_subtract
2904 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2905 == S_GET_SEGMENT (exp
.X_op_symbol
))
2906 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2907 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2909 exp
.X_op
= O_constant
;
2910 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2911 - S_GET_VALUE (exp
.X_op_symbol
));
2919 exp
.X_add_number
= 0;
2922 S_SET_SEGMENT (symbolP
, absolute_section
);
2923 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2925 S_SET_EXTERNAL (symbolP
);
2927 S_CLEAR_EXTERNAL (symbolP
);
2928 #endif /* OBJ_AOUT or OBJ_BOUT */
2929 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2930 symbolP
->sy_frag
= &zero_address_frag
;
2934 S_SET_SEGMENT (symbolP
, reg_section
);
2935 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2936 symbolP
->sy_frag
= &zero_address_frag
;
2940 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2941 || exp
.X_add_number
!= 0)
2942 symbolP
->sy_value
= exp
;
2945 symbolS
*s
= exp
.X_add_symbol
;
2947 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2948 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2950 S_SET_EXTERNAL (symbolP
);
2952 S_CLEAR_EXTERNAL (symbolP
);
2953 #endif /* OBJ_AOUT or OBJ_BOUT */
2954 S_SET_VALUE (symbolP
,
2955 exp
.X_add_number
+ S_GET_VALUE (s
));
2956 symbolP
->sy_frag
= s
->sy_frag
;
2957 copy_symbol_attributes (symbolP
, s
);
2962 /* The value is some complex expression.
2963 FIXME: Should we set the segment to anything? */
2964 symbolP
->sy_value
= exp
;
2972 * CONStruct more frag of .bytes, or .words etc.
2973 * Should need_pass_2 be 1 then emit no frag(s).
2974 * This understands EXPRESSIONS.
2978 * This has a split personality. We use expression() to read the
2979 * value. We can detect if the value won't fit in a byte or word.
2980 * But we can't detect if expression() discarded significant digits
2981 * in the case of a long. Not worth the crocks required to fix it.
2984 /* Select a parser for cons expressions. */
2986 /* Some targets need to parse the expression in various fancy ways.
2987 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2988 (for example, the HPPA does this). Otherwise, you can define
2989 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2990 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2991 are defined, which is the normal case, then only simple expressions
2995 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2997 #ifndef TC_PARSE_CONS_EXPRESSION
2998 #ifdef BITFIELD_CONS_EXPRESSIONS
2999 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3001 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3003 #ifdef REPEAT_CONS_EXPRESSIONS
3004 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3006 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3009 /* If we haven't gotten one yet, just call expression. */
3010 #ifndef TC_PARSE_CONS_EXPRESSION
3011 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3015 /* worker to do .byte etc statements */
3016 /* clobbers input_line_pointer, checks */
3019 cons_worker (nbytes
, rva
)
3020 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3028 #ifdef md_flush_pending_output
3029 md_flush_pending_output ();
3033 stop
= mri_comment_field (&stopc
);
3035 if (is_it_end_of_statement ())
3038 mri_comment_end (stop
, stopc
);
3039 demand_empty_rest_of_line ();
3043 #ifdef md_cons_align
3044 md_cons_align (nbytes
);
3051 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3053 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3057 if (exp
.X_op
== O_symbol
)
3058 exp
.X_op
= O_symbol_rva
;
3060 as_fatal ("rva without symbol");
3062 emit_expr (&exp
, (unsigned int) nbytes
);
3065 while (*input_line_pointer
++ == ',');
3067 /* In MRI mode, after an odd number of bytes, we must align to an
3068 even word boundary, unless the next instruction is a dc.b, ds.b
3070 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3071 mri_pending_align
= 1;
3073 input_line_pointer
--; /* Put terminator back into stream. */
3076 mri_comment_end (stop
, stopc
);
3078 demand_empty_rest_of_line ();
3086 cons_worker (size
, 0);
3093 cons_worker (size
, 1);
3097 /* Put the contents of expression EXP into the object file using
3098 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3101 emit_expr (exp
, nbytes
)
3103 unsigned int nbytes
;
3107 valueT extra_digit
= 0;
3109 /* Don't do anything if we are going to make another pass. */
3115 /* Allow `.word 0' in the absolute section. */
3116 if (now_seg
== absolute_section
)
3118 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3119 as_bad ("attempt to store value in absolute section");
3120 abs_section_offset
+= nbytes
;
3124 /* Handle a negative bignum. */
3126 && exp
->X_add_number
== 0
3127 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3128 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3131 unsigned long carry
;
3133 exp
= &exp
->X_add_symbol
->sy_value
;
3135 /* Negate the bignum: one's complement each digit and add 1. */
3137 for (i
= 0; i
< exp
->X_add_number
; i
++)
3141 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3144 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3145 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3148 /* We can ignore any carry out, because it will be handled by
3149 extra_digit if it is needed. */
3151 extra_digit
= (valueT
) -1;
3155 if (op
== O_absent
|| op
== O_illegal
)
3157 as_warn ("zero assumed for missing expression");
3158 exp
->X_add_number
= 0;
3161 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3163 as_bad ("floating point number invalid; zero assumed");
3164 exp
->X_add_number
= 0;
3167 else if (op
== O_register
)
3169 as_warn ("register value used as expression");
3173 p
= frag_more ((int) nbytes
);
3175 #ifndef WORKING_DOT_WORD
3176 /* If we have the difference of two symbols in a word, save it on
3177 the broken_words list. See the code in write.c. */
3178 if (op
== O_subtract
&& nbytes
== 2)
3180 struct broken_word
*x
;
3182 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3183 x
->next_broken_word
= broken_words
;
3186 x
->word_goes_here
= p
;
3188 x
->add
= exp
->X_add_symbol
;
3189 x
->sub
= exp
->X_op_symbol
;
3190 x
->addnum
= exp
->X_add_number
;
3197 /* If we have an integer, but the number of bytes is too large to
3198 pass to md_number_to_chars, handle it as a bignum. */
3199 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3204 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3205 extra_digit
= (valueT
) -1;
3206 val
= (valueT
) exp
->X_add_number
;
3210 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3211 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3215 op
= exp
->X_op
= O_big
;
3216 exp
->X_add_number
= gencnt
;
3219 if (op
== O_constant
)
3221 register valueT get
;
3222 register valueT use
;
3223 register valueT mask
;
3225 register valueT unmask
;
3227 /* JF << of >= number of bits in the object is undefined. In
3228 particular SPARC (Sun 4) has problems */
3229 if (nbytes
>= sizeof (valueT
))
3232 if (nbytes
> sizeof (valueT
))
3235 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3239 /* Don't store these bits. */
3240 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3241 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3244 unmask
= ~mask
; /* Do store these bits. */
3247 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3248 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3251 get
= exp
->X_add_number
;
3253 if ((get
& mask
) != 0
3254 && ((get
& mask
) != mask
3255 || (get
& hibit
) == 0))
3256 { /* Leading bits contain both 0s & 1s. */
3257 as_warn ("Value 0x%lx truncated to 0x%lx.",
3258 (unsigned long) get
, (unsigned long) use
);
3260 /* put bytes in right order. */
3261 md_number_to_chars (p
, use
, (int) nbytes
);
3263 else if (op
== O_big
)
3266 LITTLENUM_TYPE
*nums
;
3268 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3270 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3273 as_warn ("Bignum truncated to %d bytes", nbytes
);
3277 if (target_big_endian
)
3279 while (nbytes
> size
)
3281 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3282 nbytes
-= CHARS_PER_LITTLENUM
;
3283 p
+= CHARS_PER_LITTLENUM
;
3286 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3290 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3291 size
-= CHARS_PER_LITTLENUM
;
3292 p
+= CHARS_PER_LITTLENUM
;
3297 nums
= generic_bignum
;
3300 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3302 size
-= CHARS_PER_LITTLENUM
;
3303 p
+= CHARS_PER_LITTLENUM
;
3304 nbytes
-= CHARS_PER_LITTLENUM
;
3309 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3310 nbytes
-= CHARS_PER_LITTLENUM
;
3311 p
+= CHARS_PER_LITTLENUM
;
3317 memset (p
, 0, nbytes
);
3319 /* Now we need to generate a fixS to record the symbol value.
3320 This is easy for BFD. For other targets it can be more
3321 complex. For very complex cases (currently, the HPPA and
3322 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3323 want. For simpler cases, you can define TC_CONS_RELOC to be
3324 the name of the reloc code that should be stored in the fixS.
3325 If neither is defined, the code uses NO_RELOC if it is
3326 defined, and otherwise uses 0. */
3328 #ifdef BFD_ASSEMBLER
3329 #ifdef TC_CONS_FIX_NEW
3330 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3333 bfd_reloc_code_real_type r
;
3350 as_bad ("unsupported BFD relocation size %u", nbytes
);
3354 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3359 #ifdef TC_CONS_FIX_NEW
3360 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3362 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3363 it is defined, otherwise use NO_RELOC if it is defined,
3365 #ifndef TC_CONS_RELOC
3367 #define TC_CONS_RELOC NO_RELOC
3369 #define TC_CONS_RELOC 0
3372 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3374 #endif /* TC_CONS_FIX_NEW */
3375 #endif /* BFD_ASSEMBLER */
3379 #ifdef BITFIELD_CONS_EXPRESSIONS
3381 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3382 w:x,y:z, where w and y are bitwidths and x and y are values. They
3383 then pack them all together. We do a little better in that we allow
3384 them in words, longs, etc. and we'll pack them in target byte order
3387 The rules are: pack least significat bit first, if a field doesn't
3388 entirely fit, put it in the next unit. Overflowing the bitfield is
3389 explicitly *not* even a warning. The bitwidth should be considered
3392 To use this function the tc-XXX.h file should define
3393 BITFIELD_CONS_EXPRESSIONS. */
3396 parse_bitfield_cons (exp
, nbytes
)
3398 unsigned int nbytes
;
3400 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3401 char *hold
= input_line_pointer
;
3403 (void) expression (exp
);
3405 if (*input_line_pointer
== ':')
3411 unsigned long width
;
3413 if (*input_line_pointer
!= ':')
3415 input_line_pointer
= hold
;
3417 } /* next piece is not a bitfield */
3419 /* In the general case, we can't allow
3420 full expressions with symbol
3421 differences and such. The relocation
3422 entries for symbols not defined in this
3423 assembly would require arbitrary field
3424 widths, positions, and masks which most
3425 of our current object formats don't
3428 In the specific case where a symbol
3429 *is* defined in this assembly, we
3430 *could* build fixups and track it, but
3431 this could lead to confusion for the
3432 backends. I'm lazy. I'll take any
3433 SEG_ABSOLUTE. I think that means that
3434 you can use a previous .set or
3435 .equ type symbol. xoxorich. */
3437 if (exp
->X_op
== O_absent
)
3439 as_warn ("using a bit field width of zero");
3440 exp
->X_add_number
= 0;
3441 exp
->X_op
= O_constant
;
3442 } /* implied zero width bitfield */
3444 if (exp
->X_op
!= O_constant
)
3446 *input_line_pointer
= '\0';
3447 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3448 *input_line_pointer
= ':';
3449 demand_empty_rest_of_line ();
3453 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3455 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3456 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3457 width
= BITS_PER_CHAR
* nbytes
;
3460 if (width
> bits_available
)
3462 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3463 input_line_pointer
= hold
;
3464 exp
->X_add_number
= value
;
3468 hold
= ++input_line_pointer
; /* skip ':' */
3470 (void) expression (exp
);
3471 if (exp
->X_op
!= O_constant
)
3473 char cache
= *input_line_pointer
;
3475 *input_line_pointer
= '\0';
3476 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3477 *input_line_pointer
= cache
;
3478 demand_empty_rest_of_line ();
3482 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3483 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3485 if ((bits_available
-= width
) == 0
3486 || is_it_end_of_statement ()
3487 || *input_line_pointer
!= ',')
3490 } /* all the bitfields we're gonna get */
3492 hold
= ++input_line_pointer
;
3493 (void) expression (exp
);
3494 } /* forever loop */
3496 exp
->X_add_number
= value
;
3497 exp
->X_op
= O_constant
;
3498 exp
->X_unsigned
= 1;
3499 } /* if looks like a bitfield */
3500 } /* parse_bitfield_cons() */
3502 #endif /* BITFIELD_CONS_EXPRESSIONS */
3504 /* Handle an MRI style string expression. */
3507 parse_mri_cons (exp
, nbytes
)
3509 unsigned int nbytes
;
3511 if (*input_line_pointer
!= '\''
3512 && (input_line_pointer
[1] != '\''
3513 || (*input_line_pointer
!= 'A'
3514 && *input_line_pointer
!= 'E')))
3515 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3519 unsigned int result
= 0;
3521 /* An MRI style string. Cut into as many bytes as will fit into
3522 a nbyte chunk, left justify if necessary, and separate with
3523 commas so we can try again later. */
3524 if (*input_line_pointer
== 'A')
3525 ++input_line_pointer
;
3526 else if (*input_line_pointer
== 'E')
3528 as_bad ("EBCDIC constants are not supported");
3529 ++input_line_pointer
;
3532 input_line_pointer
++;
3533 for (scan
= 0; scan
< nbytes
; scan
++)
3535 if (*input_line_pointer
== '\'')
3537 if (input_line_pointer
[1] == '\'')
3539 input_line_pointer
++;
3544 result
= (result
<< 8) | (*input_line_pointer
++);
3548 while (scan
< nbytes
)
3553 /* Create correct expression */
3554 exp
->X_op
= O_constant
;
3555 exp
->X_add_number
= result
;
3556 /* Fake it so that we can read the next char too */
3557 if (input_line_pointer
[0] != '\'' ||
3558 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3560 input_line_pointer
-= 2;
3561 input_line_pointer
[0] = ',';
3562 input_line_pointer
[1] = '\'';
3565 input_line_pointer
++;
3569 #ifdef REPEAT_CONS_EXPRESSIONS
3571 /* Parse a repeat expression for cons. This is used by the MIPS
3572 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3573 object file COUNT times.
3575 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3578 parse_repeat_cons (exp
, nbytes
)
3580 unsigned int nbytes
;
3587 if (*input_line_pointer
!= ':')
3589 /* No repeat count. */
3593 ++input_line_pointer
;
3594 expression (&count
);
3595 if (count
.X_op
!= O_constant
3596 || count
.X_add_number
<= 0)
3598 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3602 /* The cons function is going to output this expression once. So we
3603 output it count - 1 times. */
3604 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3605 emit_expr (exp
, nbytes
);
3608 #endif /* REPEAT_CONS_EXPRESSIONS */
3610 /* Parse a floating point number represented as a hex constant. This
3611 permits users to specify the exact bits they want in the floating
3615 hex_float (float_type
, bytes
)
3649 as_bad ("Unknown floating type type '%c'", float_type
);
3653 /* It would be nice if we could go through expression to parse the
3654 hex constant, but if we get a bignum it's a pain to sort it into
3655 the buffer correctly. */
3657 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3661 /* The MRI assembler accepts arbitrary underscores strewn about
3662 through the hex constant, so we ignore them as well. */
3663 if (*input_line_pointer
== '_')
3665 ++input_line_pointer
;
3671 as_warn ("Floating point constant too large");
3674 d
= hex_value (*input_line_pointer
) << 4;
3675 ++input_line_pointer
;
3676 while (*input_line_pointer
== '_')
3677 ++input_line_pointer
;
3678 if (hex_p (*input_line_pointer
))
3680 d
+= hex_value (*input_line_pointer
);
3681 ++input_line_pointer
;
3683 if (target_big_endian
)
3686 bytes
[length
- i
- 1] = d
;
3692 if (target_big_endian
)
3693 memset (bytes
+ i
, 0, length
- i
);
3695 memset (bytes
, 0, length
- i
);
3704 * CONStruct some more frag chars of .floats .ffloats etc.
3705 * Makes 0 or more new frags.
3706 * If need_pass_2 == 1, no frags are emitted.
3707 * This understands only floating literals, not expressions. Sorry.
3709 * A floating constant is defined by atof_generic(), except it is preceded
3710 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3711 * reading, I decided to be incompatible. This always tries to give you
3712 * rounded bits to the precision of the pseudo-op. Former AS did premature
3713 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3714 * a choice of 2 flavours of noise according to which of 2 floating-point
3715 * scanners you directed AS to use.
3717 * In: input_line_pointer->whitespace before, or '0' of flonum.
3722 float_cons (float_type
)
3723 /* Clobbers input_line-pointer, checks end-of-line. */
3724 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3727 int length
; /* Number of chars in an object. */
3728 register char *err
; /* Error from scanning floating literal. */
3729 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3731 if (is_it_end_of_statement ())
3733 demand_empty_rest_of_line ();
3737 #ifdef md_flush_pending_output
3738 md_flush_pending_output ();
3743 /* input_line_pointer->1st char of a flonum (we hope!). */
3746 /* Skip any 0{letter} that may be present. Don't even check if the
3747 * letter is legal. Someone may invent a "z" format and this routine
3748 * has no use for such information. Lusers beware: you get
3749 * diagnostics if your input is ill-conditioned.
3751 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3752 input_line_pointer
+= 2;
3754 /* Accept :xxxx, where the x's are hex digits, for a floating
3755 point with the exact digits specified. */
3756 if (input_line_pointer
[0] == ':')
3758 ++input_line_pointer
;
3759 length
= hex_float (float_type
, temp
);
3762 ignore_rest_of_line ();
3768 err
= md_atof (float_type
, temp
, &length
);
3769 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3773 as_bad ("Bad floating literal: %s", err
);
3774 ignore_rest_of_line ();
3785 #ifdef REPEAT_CONS_EXPRESSIONS
3786 if (*input_line_pointer
== ':')
3788 expressionS count_exp
;
3790 ++input_line_pointer
;
3791 expression (&count_exp
);
3792 if (count_exp
.X_op
!= O_constant
3793 || count_exp
.X_add_number
<= 0)
3795 as_warn ("unresolvable or nonpositive repeat count; using 1");
3798 count
= count_exp
.X_add_number
;
3802 while (--count
>= 0)
3804 p
= frag_more (length
);
3805 memcpy (p
, temp
, (unsigned int) length
);
3810 while (*input_line_pointer
++ == ',');
3812 --input_line_pointer
; /* Put terminator back into stream. */
3813 demand_empty_rest_of_line ();
3814 } /* float_cons() */
3819 * We read 0 or more ',' seperated, double-quoted strings.
3821 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3826 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3827 /* Checks end-of-line. */
3828 register int append_zero
; /* 0: don't append '\0', else 1 */
3830 register unsigned int c
;
3832 #ifdef md_flush_pending_output
3833 md_flush_pending_output ();
3837 * The following awkward logic is to parse ZERO or more strings,
3838 * comma seperated. Recall a string expression includes spaces
3839 * before the opening '\"' and spaces after the closing '\"'.
3840 * We fake a leading ',' if there is (supposed to be)
3841 * a 1st, expression. We keep demanding expressions for each
3844 if (is_it_end_of_statement ())
3846 c
= 0; /* Skip loop. */
3847 ++input_line_pointer
; /* Compensate for end of loop. */
3851 c
= ','; /* Do loop. */
3853 while (c
== ',' || c
== '<' || c
== '"')
3856 switch (*input_line_pointer
)
3859 ++input_line_pointer
; /*->1st char of string. */
3860 while (is_a_char (c
= next_char_of_string ()))
3862 FRAG_APPEND_1_CHAR (c
);
3866 FRAG_APPEND_1_CHAR (0);
3868 know (input_line_pointer
[-1] == '\"');
3871 input_line_pointer
++;
3872 c
= get_single_number ();
3873 FRAG_APPEND_1_CHAR (c
);
3874 if (*input_line_pointer
!= '>')
3876 as_bad ("Expected <nn>");
3878 input_line_pointer
++;
3881 input_line_pointer
++;
3885 c
= *input_line_pointer
;
3888 demand_empty_rest_of_line ();
3891 /* FIXME-SOMEDAY: I had trouble here on characters with the
3892 high bits set. We'll probably also have trouble with
3893 multibyte chars, wide chars, etc. Also be careful about
3894 returning values bigger than 1 byte. xoxorich. */
3897 next_char_of_string ()
3899 register unsigned int c
;
3901 c
= *input_line_pointer
++ & CHAR_MASK
;
3909 as_warn ("Unterminated string: Newline inserted.");
3910 bump_line_counters ();
3913 #ifndef NO_STRING_ESCAPES
3915 switch (c
= *input_line_pointer
++)
3943 break; /* As itself. */
3959 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3961 number
= number
* 8 + c
- '0';
3965 --input_line_pointer
;
3974 c
= *input_line_pointer
++;
3975 while (isxdigit (c
))
3978 number
= number
* 16 + c
- '0';
3979 else if (isupper (c
))
3980 number
= number
* 16 + c
- 'A' + 10;
3982 number
= number
* 16 + c
- 'a' + 10;
3983 c
= *input_line_pointer
++;
3986 --input_line_pointer
;
3991 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3992 as_warn ("Unterminated string: Newline inserted.");
3994 bump_line_counters ();
3999 #ifdef ONLY_STANDARD_ESCAPES
4000 as_bad ("Bad escaped character in string, '?' assumed");
4002 #endif /* ONLY_STANDARD_ESCAPES */
4005 } /* switch on escaped char */
4007 #endif /* ! defined (NO_STRING_ESCAPES) */
4011 } /* switch on char */
4013 } /* next_char_of_string() */
4016 get_segmented_expression (expP
)
4017 register expressionS
*expP
;
4019 register segT retval
;
4021 retval
= expression (expP
);
4022 if (expP
->X_op
== O_illegal
4023 || expP
->X_op
== O_absent
4024 || expP
->X_op
== O_big
)
4026 as_bad ("expected address expression; zero assumed");
4027 expP
->X_op
= O_constant
;
4028 expP
->X_add_number
= 0;
4029 retval
= absolute_section
;
4035 get_known_segmented_expression (expP
)
4036 register expressionS
*expP
;
4038 register segT retval
;
4040 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4042 /* There is no easy way to extract the undefined symbol from the
4044 if (expP
->X_add_symbol
!= NULL
4045 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4046 as_warn ("symbol \"%s\" undefined; zero assumed",
4047 S_GET_NAME (expP
->X_add_symbol
));
4049 as_warn ("some symbol undefined; zero assumed");
4050 retval
= absolute_section
;
4051 expP
->X_op
= O_constant
;
4052 expP
->X_add_number
= 0;
4054 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4056 } /* get_known_segmented_expression() */
4059 get_absolute_expression ()
4064 if (exp
.X_op
!= O_constant
)
4066 if (exp
.X_op
!= O_absent
)
4067 as_bad ("bad or irreducible absolute expression; zero assumed");
4068 exp
.X_add_number
= 0;
4070 return exp
.X_add_number
;
4073 char /* return terminator */
4074 get_absolute_expression_and_terminator (val_pointer
)
4075 long *val_pointer
; /* return value of expression */
4077 /* FIXME: val_pointer should probably be offsetT *. */
4078 *val_pointer
= (long) get_absolute_expression ();
4079 return (*input_line_pointer
++);
4083 * demand_copy_C_string()
4085 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4086 * Give a warning if that happens.
4089 demand_copy_C_string (len_pointer
)
4094 if ((s
= demand_copy_string (len_pointer
)) != 0)
4098 for (len
= *len_pointer
; len
> 0; len
--)
4105 as_bad ("This string may not contain \'\\0\'");
4113 * demand_copy_string()
4115 * Demand string, but return a safe (=private) copy of the string.
4116 * Return NULL if we can't read a string here.
4119 demand_copy_string (lenP
)
4122 register unsigned int c
;
4128 if (*input_line_pointer
== '\"')
4130 input_line_pointer
++; /* Skip opening quote. */
4132 while (is_a_char (c
= next_char_of_string ()))
4134 obstack_1grow (¬es
, c
);
4137 /* JF this next line is so demand_copy_C_string will return a
4138 null terminated string. */
4139 obstack_1grow (¬es
, '\0');
4140 retval
= obstack_finish (¬es
);
4144 as_warn ("Missing string");
4146 ignore_rest_of_line ();
4150 } /* demand_copy_string() */
4153 * is_it_end_of_statement()
4155 * In: Input_line_pointer->next character.
4157 * Do: Skip input_line_pointer over all whitespace.
4159 * Out: 1 if input_line_pointer->end-of-line.
4162 is_it_end_of_statement ()
4165 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4166 } /* is_it_end_of_statement() */
4172 register symbolS
*symbolP
; /* symbol we are working with */
4176 input_line_pointer
++;
4177 if (*input_line_pointer
== '=')
4178 input_line_pointer
++;
4180 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4181 input_line_pointer
++;
4184 stop
= mri_comment_field (&stopc
);
4186 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4188 /* Turn '. = mumble' into a .org mumble */
4189 register segT segment
;
4192 segment
= get_known_segmented_expression (&exp
);
4194 do_org (segment
, &exp
, 0);
4198 symbolP
= symbol_find_or_make (sym_name
);
4199 pseudo_set (symbolP
);
4203 mri_comment_end (stop
, stopc
);
4206 /* .include -- include a file at this point. */
4219 if (! flag_m68k_mri
)
4220 filename
= demand_copy_string (&i
);
4225 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4226 && *input_line_pointer
!= ' '
4227 && *input_line_pointer
!= '\t')
4229 obstack_1grow (¬es
, *input_line_pointer
);
4230 ++input_line_pointer
;
4233 obstack_1grow (¬es
, '\0');
4234 filename
= obstack_finish (¬es
);
4235 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4236 ++input_line_pointer
;
4238 demand_empty_rest_of_line ();
4239 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4240 for (i
= 0; i
< include_dir_count
; i
++)
4242 strcpy (path
, include_dirs
[i
]);
4244 strcat (path
, filename
);
4245 if (0 != (try = fopen (path
, "r")))
4254 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4255 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4256 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4260 add_include_dir (path
)
4265 if (include_dir_count
== 0)
4267 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4268 include_dirs
[0] = "."; /* Current dir */
4269 include_dir_count
= 2;
4273 include_dir_count
++;
4274 include_dirs
= (char **) realloc (include_dirs
,
4275 include_dir_count
* sizeof (*include_dirs
));
4278 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4281 if (i
> include_dir_maxlen
)
4282 include_dir_maxlen
= i
;
4283 } /* add_include_dir() */
4289 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4291 ++input_line_pointer
;
4293 ++input_line_pointer
;
4298 read_print_statistics (file
)
4301 hash_print_statistics (file
, "pseudo-op table", po_hash
);