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
723 || pop
->poc_handler
== s_globl
724 || pop
->poc_handler
== s_ignore
)))
726 do_align (1, (char *) NULL
, 0);
727 mri_pending_align
= 0;
728 if (line_label
!= NULL
)
730 line_label
->sy_frag
= frag_now
;
731 S_SET_VALUE (line_label
, frag_now_fix ());
735 /* Print the error msg now, while we still can */
738 as_bad ("Unknown pseudo-op: `%s'", s
);
739 *input_line_pointer
= c
;
744 /* Put it back for error messages etc. */
745 *input_line_pointer
= c
;
746 /* The following skip of whitespace is compulsory.
747 A well shaped space is sometimes all that separates
748 keyword from operands. */
749 if (c
== ' ' || c
== '\t')
750 input_line_pointer
++;
752 * Input_line is restored.
753 * Input_line_pointer->1st non-blank char
754 * after pseudo-operation.
756 (*pop
->poc_handler
) (pop
->poc_val
);
758 /* If that was .end, just get out now. */
759 if (pop
->poc_handler
== s_end
)
766 /* WARNING: c has char, which may be end-of-line. */
767 /* Also: input_line_pointer->`\0` where c was. */
768 *input_line_pointer
= c
;
769 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
771 #ifdef TC_EOL_IN_INSN
772 || TC_EOL_IN_INSN (input_line_pointer
)
776 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
778 input_line_pointer
++;
781 c
= *input_line_pointer
;
782 *input_line_pointer
= '\0';
784 #ifdef OBJ_GENERATE_ASM_LINENO
785 if (generate_asm_lineno
== 0)
787 if (ecoff_no_current_file ())
788 generate_asm_lineno
= 1;
790 if (generate_asm_lineno
== 1)
795 as_where (&s
, &lineno
);
796 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
805 if (check_macro (s
, &out
, '\0', &err
))
809 *input_line_pointer
++ = c
;
810 input_scrub_include_sb (&out
,
814 input_scrub_next_buffer (&input_line_pointer
);
819 if (mri_pending_align
)
821 do_align (1, (char *) NULL
, 0);
822 mri_pending_align
= 0;
823 if (line_label
!= NULL
)
825 line_label
->sy_frag
= frag_now
;
826 S_SET_VALUE (line_label
, frag_now_fix ());
830 md_assemble (s
); /* Assemble 1 instruction. */
832 *input_line_pointer
++ = c
;
834 /* We resume loop AFTER the end-of-line from
839 } /* if (is_name_beginner(c) */
842 /* Empty statement? */
843 if (is_end_of_line
[(unsigned char) c
])
846 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
849 /* local label ("4:") */
850 char *backup
= input_line_pointer
;
852 HANDLE_CONDITIONAL_ASSEMBLY ();
856 while (isdigit (*input_line_pointer
))
858 temp
= (temp
* 10) + *input_line_pointer
- '0';
859 ++input_line_pointer
;
860 } /* read the whole number */
862 if (LOCAL_LABELS_DOLLAR
863 && *input_line_pointer
== '$'
864 && *(input_line_pointer
+ 1) == ':')
866 input_line_pointer
+= 2;
868 if (dollar_label_defined (temp
))
870 as_fatal ("label \"%d$\" redefined", temp
);
873 define_dollar_label (temp
);
874 colon (dollar_label_name (temp
, 0));
879 && *input_line_pointer
++ == ':')
881 fb_label_instance_inc (temp
);
882 colon (fb_label_name (temp
, 0));
886 input_line_pointer
= backup
;
887 } /* local label ("4:") */
889 if (c
&& strchr (line_comment_chars
, c
))
890 { /* Its a comment. Better say APP or NO_APP */
894 unsigned int new_length
;
897 bump_line_counters ();
898 s
= input_line_pointer
;
899 if (strncmp (s
, "APP\n", 4))
900 continue; /* We ignore it */
903 ends
= strstr (s
, "#NO_APP\n");
907 unsigned int tmp_len
;
910 /* The end of the #APP wasn't in this buffer. We
911 keep reading in buffers until we find the #NO_APP
912 that goes with this #APP There is one. The specs
914 tmp_len
= buffer_limit
- s
;
915 tmp_buf
= xmalloc (tmp_len
+ 1);
916 memcpy (tmp_buf
, s
, tmp_len
);
919 new_tmp
= input_scrub_next_buffer (&buffer
);
923 buffer_limit
= new_tmp
;
924 input_line_pointer
= buffer
;
925 ends
= strstr (buffer
, "#NO_APP\n");
929 num
= buffer_limit
- buffer
;
931 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
932 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
937 input_line_pointer
= ends
? ends
+ 8 : NULL
;
945 input_line_pointer
= ends
+ 8;
949 scrub_string_end
= ends
;
951 new_length
= ends
- s
;
952 new_buf
= (char *) xmalloc (new_length
);
959 space
= (new_buf
+ new_length
) - new_tmp
;
960 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
968 new_buf
= xrealloc (new_buf
, new_length
+ 100);
969 new_tmp
= new_buf
+ new_length
;
976 old_input
= input_line_pointer
;
977 old_limit
= buffer_limit
;
979 input_line_pointer
= new_buf
;
980 buffer_limit
= new_tmp
;
984 HANDLE_CONDITIONAL_ASSEMBLY ();
986 #ifdef tc_unrecognized_line
987 if (tc_unrecognized_line (c
))
991 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
992 input_line_pointer
--; /* Report unknown char as ignored. */
993 ignore_rest_of_line ();
994 } /* while (input_line_pointer<buffer_limit) */
996 #ifdef md_after_pass_hook
997 md_after_pass_hook ();
1003 bump_line_counters ();
1006 buffer
= old_buffer
;
1007 input_line_pointer
= old_input
;
1008 buffer_limit
= old_limit
;
1013 } /* while (more buffers to scan) */
1020 input_scrub_close (); /* Close the input file */
1023 /* For most MRI pseudo-ops, the line actually ends at the first
1024 nonquoted space. This function looks for that point, stuffs a null
1025 in, and sets *STOPCP to the character that used to be there, and
1026 returns the location.
1028 Until I hear otherwise, I am going to assume that this is only true
1029 for the m68k MRI assembler. */
1032 mri_comment_field (stopcp
)
1040 know (flag_m68k_mri
);
1042 for (s
= input_line_pointer
;
1043 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1048 inquote
= ! inquote
;
1058 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1068 /* Skip to the end of an MRI comment field. */
1071 mri_comment_end (stop
, stopc
)
1077 input_line_pointer
= stop
;
1079 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1080 ++input_line_pointer
;
1087 as_fatal (".abort detected. Abandoning ship.");
1090 /* Guts of .align directive. */
1092 do_align (n
, fill
, len
)
1098 md_do_align (n
, fill
, len
, just_record_alignment
);
1102 /* @@ Fix this right for BFD! */
1104 static char nop_opcode
= NOP_OPCODE
;
1106 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1117 /* Only make a frag if we HAVE to. . . */
1118 if (n
&& !need_pass_2
)
1121 frag_align (n
, *fill
);
1123 frag_align_pattern (n
, fill
, len
);
1127 just_record_alignment
:
1130 record_alignment (now_seg
, n
);
1133 /* For machines where ".align 4" means align to a 4 byte boundary. */
1138 register unsigned int temp
;
1141 unsigned long max_alignment
= 1 << 15;
1146 stop
= mri_comment_field (&stopc
);
1148 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1153 temp
= arg
; /* Default value from pseudo-op table */
1156 temp
= get_absolute_expression ();
1158 if (temp
> max_alignment
)
1160 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1163 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1164 have to convert it. */
1167 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1171 as_bad ("Alignment not a power of 2");
1174 if (*input_line_pointer
== ',')
1179 input_line_pointer
++;
1180 fillval
= get_absolute_expression ();
1187 temp_fill
= fillval
;
1188 do_align (temp
, &temp_fill
, len
);
1194 if (len
> sizeof ab
)
1196 md_number_to_chars (ab
, fillval
, len
);
1197 do_align (temp
, ab
, len
);
1203 as_warn ("expected fill pattern missing");
1204 do_align (temp
, (char *) NULL
, 0);
1208 mri_comment_end (stop
, stopc
);
1210 demand_empty_rest_of_line ();
1213 /* For machines where ".align 4" means align to 2**4 boundary. */
1220 long max_alignment
= 15;
1225 stop
= mri_comment_field (&stopc
);
1227 temp
= get_absolute_expression ();
1228 if (temp
> max_alignment
)
1229 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1232 as_bad ("Alignment negative. 0 assumed.");
1235 if (*input_line_pointer
== ',')
1240 input_line_pointer
++;
1241 fillval
= get_absolute_expression ();
1248 temp_fill
= fillval
;
1249 do_align (temp
, &temp_fill
, len
);
1255 if (len
> sizeof ab
)
1257 md_number_to_chars (ab
, fillval
, len
);
1258 do_align (temp
, ab
, len
);
1264 as_warn ("expected fill pattern missing");
1265 do_align (temp
, (char *) NULL
, 0);
1269 mri_comment_end (stop
, stopc
);
1271 demand_empty_rest_of_line ();
1278 register char *name
;
1282 register symbolS
*symbolP
;
1287 stop
= mri_comment_field (&stopc
);
1289 name
= input_line_pointer
;
1290 c
= get_symbol_end ();
1291 /* just after name is now '\0' */
1292 p
= input_line_pointer
;
1295 if (*input_line_pointer
!= ',')
1297 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1299 mri_comment_end (stop
, stopc
);
1300 ignore_rest_of_line ();
1303 input_line_pointer
++; /* skip ',' */
1304 if ((temp
= get_absolute_expression ()) < 0)
1306 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1308 mri_comment_end (stop
, stopc
);
1309 ignore_rest_of_line ();
1313 symbolP
= symbol_find_or_make (name
);
1315 if (S_IS_DEFINED (symbolP
))
1317 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1318 S_GET_NAME (symbolP
));
1320 mri_comment_end (stop
, stopc
);
1321 ignore_rest_of_line ();
1324 if (S_GET_VALUE (symbolP
))
1326 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1327 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1328 S_GET_NAME (symbolP
),
1329 (long) S_GET_VALUE (symbolP
),
1334 S_SET_VALUE (symbolP
, (valueT
) temp
);
1335 S_SET_EXTERNAL (symbolP
);
1339 extern int flag_one
;
1340 if ( (!temp
) || !flag_one
)
1341 S_GET_OTHER(symbolP
) = const_flag
;
1343 #endif /* not OBJ_VMS */
1344 know (symbolP
->sy_frag
== &zero_address_frag
);
1347 mri_comment_end (stop
, stopc
);
1349 demand_empty_rest_of_line ();
1352 /* The MRI COMMON pseudo-op. We handle this by creating a common
1353 symbol with the appropriate name. We make s_space do the right
1354 thing by increasing the size. */
1357 s_mri_common (small
)
1374 stop
= mri_comment_field (&stopc
);
1378 name
= input_line_pointer
;
1379 if (! isdigit ((unsigned char) *name
))
1380 c
= get_symbol_end ();
1385 ++input_line_pointer
;
1387 while (isdigit ((unsigned char) *input_line_pointer
));
1388 c
= *input_line_pointer
;
1389 *input_line_pointer
= '\0';
1391 if (line_label
!= NULL
)
1393 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1394 + (input_line_pointer
- name
)
1396 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1401 sym
= symbol_find_or_make (name
);
1402 *input_line_pointer
= c
;
1406 if (*input_line_pointer
!= ',')
1410 ++input_line_pointer
;
1411 align
= get_absolute_expression ();
1414 if (S_IS_DEFINED (sym
))
1416 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1417 if (! S_IS_COMMON (sym
))
1420 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1421 mri_comment_end (stop
, stopc
);
1422 ignore_rest_of_line ();
1427 S_SET_EXTERNAL (sym
);
1428 mri_common_symbol
= sym
;
1432 S_SET_ALIGN (sym
, align
);
1435 if (line_label
!= NULL
)
1437 line_label
->sy_value
.X_op
= O_symbol
;
1438 line_label
->sy_value
.X_add_symbol
= sym
;
1439 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1440 line_label
->sy_frag
= &zero_address_frag
;
1441 S_SET_SEGMENT (line_label
, expr_section
);
1444 /* FIXME: We just ignore the small argument, which distinguishes
1445 COMMON and COMMON.S. I don't know what we can do about it. */
1447 /* Ignore the type and hptype. */
1448 if (*input_line_pointer
== ',')
1449 input_line_pointer
+= 2;
1450 if (*input_line_pointer
== ',')
1451 input_line_pointer
+= 2;
1453 mri_comment_end (stop
, stopc
);
1455 demand_empty_rest_of_line ();
1465 temp
= get_absolute_expression ();
1466 if (flag_readonly_data_in_text
)
1468 section
= text_section
;
1472 section
= data_section
;
1474 subseg_set (section
, (subsegT
) temp
);
1479 demand_empty_rest_of_line ();
1482 /* Handle the .appfile pseudo-op. This is automatically generated by
1483 do_scrub_chars when a preprocessor # line comment is seen with a
1484 file name. This default definition may be overridden by the object
1485 or CPU specific pseudo-ops. This function is also the default
1486 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1490 s_app_file (appfile
)
1496 /* Some assemblers tolerate immediately following '"' */
1497 if ((s
= demand_copy_string (&length
)) != 0)
1499 /* If this is a fake .appfile, a fake newline was inserted into
1500 the buffer. Passing -2 to new_logical_line tells it to
1502 new_logical_line (s
, appfile
? -2 : -1);
1504 /* In MRI mode, the preprocessor may have inserted an extraneous
1507 && *input_line_pointer
== '\''
1508 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1509 ++input_line_pointer
;
1511 demand_empty_rest_of_line ();
1514 listing_source_file (s
);
1522 /* Handle the .appline pseudo-op. This is automatically generated by
1523 do_scrub_chars when a preprocessor # line comment is seen. This
1524 default definition may be overridden by the object or CPU specific
1533 /* The given number is that of the next line. */
1534 l
= get_absolute_expression () - 1;
1536 /* Some of the back ends can't deal with non-positive line numbers.
1537 Besides, it's silly. */
1538 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1541 new_logical_line ((char *) NULL
, l
);
1544 listing_source_line (l
);
1547 demand_empty_rest_of_line ();
1550 /* Handle the .end pseudo-op. Actually, the real work is done in
1551 read_a_source_file. */
1559 /* The MRI assembler permits the start symbol to follow .end,
1560 but we don't support that. */
1562 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1563 && *input_line_pointer
!= '*'
1564 && *input_line_pointer
!= '!')
1565 as_warn ("start address not supported");
1569 /* Handle the .err pseudo-op. */
1575 as_bad (".err encountered");
1576 demand_empty_rest_of_line ();
1579 /* Handle the MRI fail pseudo-op. */
1590 stop
= mri_comment_field (&stopc
);
1592 temp
= get_absolute_expression ();
1594 as_warn (".fail %ld encountered", (long) temp
);
1596 as_bad (".fail %ld encountered", (long) temp
);
1599 mri_comment_end (stop
, stopc
);
1601 demand_empty_rest_of_line ();
1608 long temp_repeat
= 0;
1610 register long temp_fill
= 0;
1613 #ifdef md_flush_pending_output
1614 md_flush_pending_output ();
1617 temp_repeat
= get_absolute_expression ();
1618 if (*input_line_pointer
== ',')
1620 input_line_pointer
++;
1621 temp_size
= get_absolute_expression ();
1622 if (*input_line_pointer
== ',')
1624 input_line_pointer
++;
1625 temp_fill
= get_absolute_expression ();
1628 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1629 #define BSD_FILL_SIZE_CROCK_8 (8)
1630 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1632 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1633 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1637 as_warn ("Size negative: .fill ignored.");
1640 else if (temp_repeat
<= 0)
1642 if (temp_repeat
< 0)
1643 as_warn ("Repeat < 0, .fill ignored");
1647 if (temp_size
&& !need_pass_2
)
1649 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1650 memset (p
, 0, (unsigned int) temp_size
);
1651 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1652 * flavoured AS. The following bizzare behaviour is to be
1653 * compatible with above. I guess they tried to take up to 8
1654 * bytes from a 4-byte expression and they forgot to sign
1655 * extend. Un*x Sux. */
1656 #define BSD_FILL_SIZE_CROCK_4 (4)
1657 md_number_to_chars (p
, (valueT
) temp_fill
,
1658 (temp_size
> BSD_FILL_SIZE_CROCK_4
1659 ? BSD_FILL_SIZE_CROCK_4
1660 : (int) temp_size
));
1661 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1662 * but emits no error message because it seems a legal thing to do.
1663 * It is a degenerate case of .fill but could be emitted by a compiler.
1666 demand_empty_rest_of_line ();
1680 stop
= mri_comment_field (&stopc
);
1684 name
= input_line_pointer
;
1685 c
= get_symbol_end ();
1686 symbolP
= symbol_find_or_make (name
);
1687 *input_line_pointer
= c
;
1689 S_SET_EXTERNAL (symbolP
);
1692 input_line_pointer
++;
1694 if (*input_line_pointer
== '\n')
1701 mri_comment_end (stop
, stopc
);
1703 demand_empty_rest_of_line ();
1706 /* Handle the MRI IRP and IRPC pseudo-ops. */
1718 as_where (&file
, &line
);
1721 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1722 sb_add_char (&s
, *input_line_pointer
++);
1726 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1728 as_bad_where (file
, line
, "%s", err
);
1732 input_scrub_include_sb (&out
, input_line_pointer
);
1734 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1737 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1738 the section to only be linked once. However, this is not supported
1739 by most object file formats. This takes an optional argument,
1740 which is what to do about duplicates. */
1746 enum linkonce_type type
;
1750 type
= LINKONCE_DISCARD
;
1752 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1757 s
= input_line_pointer
;
1758 c
= get_symbol_end ();
1759 if (strcasecmp (s
, "discard") == 0)
1760 type
= LINKONCE_DISCARD
;
1761 else if (strcasecmp (s
, "one_only") == 0)
1762 type
= LINKONCE_ONE_ONLY
;
1763 else if (strcasecmp (s
, "same_size") == 0)
1764 type
= LINKONCE_SAME_SIZE
;
1765 else if (strcasecmp (s
, "same_contents") == 0)
1766 type
= LINKONCE_SAME_CONTENTS
;
1768 as_warn ("unrecognized .linkonce type `%s'", s
);
1770 *input_line_pointer
= c
;
1773 #ifdef obj_handle_link_once
1774 obj_handle_link_once (type
);
1775 #else /* ! defined (obj_handle_link_once) */
1776 #ifdef BFD_ASSEMBLER
1780 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1781 as_warn (".linkonce is not supported for this object file format");
1783 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1784 flags
|= SEC_LINK_ONCE
;
1789 case LINKONCE_DISCARD
:
1790 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1792 case LINKONCE_ONE_ONLY
:
1793 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1795 case LINKONCE_SAME_SIZE
:
1796 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1798 case LINKONCE_SAME_CONTENTS
:
1799 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1802 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1803 as_bad ("bfd_set_section_flags: %s",
1804 bfd_errmsg (bfd_get_error ()));
1806 #else /* ! defined (BFD_ASSEMBLER) */
1807 as_warn (".linkonce is not supported for this object file format");
1808 #endif /* ! defined (BFD_ASSEMBLER) */
1809 #endif /* ! defined (obj_handle_link_once) */
1811 demand_empty_rest_of_line ();
1815 s_lcomm (needs_align
)
1816 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1817 (alignment); 0 if it was an ".lcomm" (2 args only) */
1820 register char *name
;
1824 register symbolS
*symbolP
;
1825 segT current_seg
= now_seg
;
1826 subsegT current_subseg
= now_subseg
;
1827 const int max_alignment
= 15;
1829 segT bss_seg
= bss_section
;
1831 name
= input_line_pointer
;
1832 c
= get_symbol_end ();
1833 p
= input_line_pointer
;
1837 /* Accept an optional comma after the name. The comma used to be
1838 required, but Irix 5 cc does not generate it. */
1839 if (*input_line_pointer
== ',')
1841 ++input_line_pointer
;
1845 if (*input_line_pointer
== '\n')
1847 as_bad ("Missing size expression");
1851 if ((temp
= get_absolute_expression ()) < 0)
1853 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1854 ignore_rest_of_line ();
1858 #if defined (TC_MIPS) || defined (TC_ALPHA)
1859 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1860 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1862 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1863 if (temp
<= bfd_get_gp_size (stdoutput
))
1865 bss_seg
= subseg_new (".sbss", 1);
1866 seg_info (bss_seg
)->bss
= 1;
1867 #ifdef BFD_ASSEMBLER
1868 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1869 as_warn ("error setting flags for \".sbss\": %s",
1870 bfd_errmsg (bfd_get_error ()));
1877 /* FIXME. This needs to be machine independent. */
1888 /* FIXME: This needs to be done in a more general fashion. */
1892 record_alignment(bss_seg
, align
);
1899 if (*input_line_pointer
!= ',')
1901 as_bad ("Expected comma after size");
1902 ignore_rest_of_line ();
1905 input_line_pointer
++;
1907 if (*input_line_pointer
== '\n')
1909 as_bad ("Missing alignment");
1912 align
= get_absolute_expression ();
1913 if (align
> max_alignment
)
1915 align
= max_alignment
;
1916 as_warn ("Alignment too large: %d. assumed.", align
);
1921 as_warn ("Alignment negative. 0 assumed.");
1923 record_alignment (bss_seg
, align
);
1924 } /* if needs align */
1927 /* Assume some objects may require alignment on some systems. */
1928 #if defined (TC_ALPHA) && ! defined (VMS)
1931 align
= ffs (temp
) - 1;
1932 if (temp
% (1 << align
))
1939 symbolP
= symbol_find_or_make (name
);
1943 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1944 S_GET_OTHER (symbolP
) == 0 &&
1945 S_GET_DESC (symbolP
) == 0 &&
1946 #endif /* OBJ_AOUT or OBJ_BOUT */
1947 (S_GET_SEGMENT (symbolP
) == bss_seg
1948 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1952 subseg_set (bss_seg
, 1);
1955 frag_align (align
, 0);
1956 /* detach from old frag */
1957 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1958 symbolP
->sy_frag
->fr_symbol
= NULL
;
1960 symbolP
->sy_frag
= frag_now
;
1961 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1965 S_SET_SEGMENT (symbolP
, bss_seg
);
1968 /* The symbol may already have been created with a preceding
1969 ".globl" directive -- be careful not to step on storage class
1970 in that case. Otherwise, set it to static. */
1971 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1973 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1975 #endif /* OBJ_COFF */
1978 S_SET_SIZE (symbolP
, temp
);
1982 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1983 S_GET_NAME (symbolP
));
1985 subseg_set (current_seg
, current_subseg
);
1987 demand_empty_rest_of_line ();
1994 register char *name
;
1998 register symbolS
*symbolP
;
2000 /* we permit ANY defined expression: BSD4.2 demands constants */
2001 name
= input_line_pointer
;
2002 c
= get_symbol_end ();
2003 p
= input_line_pointer
;
2006 if (*input_line_pointer
!= ',')
2009 as_bad ("Expected comma after name \"%s\"", name
);
2011 ignore_rest_of_line ();
2014 input_line_pointer
++;
2016 if (exp
.X_op
!= O_constant
2017 && exp
.X_op
!= O_register
)
2019 as_bad ("bad expression");
2020 ignore_rest_of_line ();
2024 symbolP
= symbol_find_or_make (name
);
2026 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2027 symbolP->sy_desc == 0) out of this test because coff doesn't have
2028 those fields, and I can't see when they'd ever be tripped. I
2029 don't think I understand why they were here so I may have
2030 introduced a bug. As recently as 1.37 didn't have this test
2031 anyway. xoxorich. */
2033 if (S_GET_SEGMENT (symbolP
) == undefined_section
2034 && S_GET_VALUE (symbolP
) == 0)
2036 /* The name might be an undefined .global symbol; be sure to
2037 keep the "external" bit. */
2038 S_SET_SEGMENT (symbolP
,
2039 (exp
.X_op
== O_constant
2042 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2046 as_bad ("Symbol %s already defined", name
);
2049 demand_empty_rest_of_line ();
2052 /* Read a line into an sb. */
2058 if (input_line_pointer
[-1] == '\n')
2059 bump_line_counters ();
2061 if (input_line_pointer
>= buffer_limit
)
2063 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2064 if (buffer_limit
== 0)
2068 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2069 sb_add_char (line
, *input_line_pointer
++);
2070 while (input_line_pointer
< buffer_limit
2071 && is_end_of_line
[(unsigned char) *input_line_pointer
])
2073 if (input_line_pointer
[-1] == '\n')
2074 bump_line_counters ();
2075 ++input_line_pointer
;
2080 /* Define a macro. This is an interface to macro.c, which is shared
2081 between gas and gasp. */
2094 as_where (&file
, &line
);
2097 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2098 sb_add_char (&s
, *input_line_pointer
++);
2101 if (line_label
!= NULL
)
2102 sb_add_string (&label
, S_GET_NAME (line_label
));
2104 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2106 as_bad_where (file
, line
, "%s", err
);
2109 if (line_label
!= NULL
)
2111 S_SET_SEGMENT (line_label
, undefined_section
);
2112 S_SET_VALUE (line_label
, 0);
2113 line_label
->sy_frag
= &zero_address_frag
;
2117 #ifdef NO_PSEUDO_DOT
2121 && hash_find (po_hash
, name
) != NULL
)
2124 && hash_find (po_hash
, name
+ 1) != NULL
))
2125 as_warn ("attempt to redefine pseudo-op `%s' ignored",
2132 /* Handle the .mexit pseudo-op, which immediately exits a macro
2139 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2142 /* Switch in and out of MRI mode. */
2150 on
= get_absolute_expression ();
2151 old_flag
= flag_mri
;
2165 #ifdef MRI_MODE_CHANGE
2167 MRI_MODE_CHANGE (on
);
2170 demand_empty_rest_of_line ();
2173 /* Handle changing the location counter. */
2176 do_org (segment
, exp
, fill
)
2181 if (segment
!= now_seg
&& segment
!= absolute_section
)
2182 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2183 segment_name (segment
), segment_name (now_seg
));
2185 if (now_seg
== absolute_section
)
2188 as_warn ("ignoring fill value in absolute section");
2189 if (exp
->X_op
!= O_constant
)
2191 as_bad ("only constant offsets supported in absolute section");
2192 exp
->X_add_number
= 0;
2194 abs_section_offset
= exp
->X_add_number
;
2200 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2201 exp
->X_add_number
, (char *) NULL
);
2210 register segT segment
;
2212 register long temp_fill
;
2214 /* The m68k MRI assembler has a different meaning for .org. It
2215 means to create an absolute section at a given address. We can't
2216 support that--use a linker script instead. */
2219 as_bad ("MRI style ORG pseudo-op not supported");
2220 ignore_rest_of_line ();
2224 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2225 thing as a sub-segment-relative origin. Any absolute origin is
2226 given a warning, then assumed to be segment-relative. Any
2227 segmented origin expression ("foo+42") had better be in the right
2228 segment or the .org is ignored.
2230 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2231 we never know sub-segment sizes when we are reading code. BSD
2232 will crash trying to emit negative numbers of filler bytes in
2233 certain .orgs. We don't crash, but see as-write for that code.
2235 Don't make frag if need_pass_2==1. */
2236 segment
= get_known_segmented_expression (&exp
);
2237 if (*input_line_pointer
== ',')
2239 input_line_pointer
++;
2240 temp_fill
= get_absolute_expression ();
2246 do_org (segment
, &exp
, temp_fill
);
2248 demand_empty_rest_of_line ();
2251 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2252 called by the obj-format routine which handles section changing
2253 when in MRI mode. It will create a new section, and return it. It
2254 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2255 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2256 flags will be set in the section. */
2270 name
= input_line_pointer
;
2271 if (! isdigit ((unsigned char) *name
))
2272 c
= get_symbol_end ();
2277 ++input_line_pointer
;
2279 while (isdigit ((unsigned char) *input_line_pointer
));
2280 c
= *input_line_pointer
;
2281 *input_line_pointer
= '\0';
2284 name
= xstrdup (name
);
2286 *input_line_pointer
= c
;
2288 seg
= subseg_new (name
, 0);
2290 if (*input_line_pointer
== ',')
2294 ++input_line_pointer
;
2295 align
= get_absolute_expression ();
2296 record_alignment (seg
, align
);
2300 if (*input_line_pointer
== ',')
2302 c
= *++input_line_pointer
;
2303 c
= toupper ((unsigned char) c
);
2304 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2307 as_bad ("unrecognized section type");
2308 ++input_line_pointer
;
2310 #ifdef BFD_ASSEMBLER
2314 flags
= SEC_NO_FLAGS
;
2316 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2317 else if (*type
== 'D' || *type
== 'M')
2318 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2319 else if (*type
== 'R')
2320 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2321 if (flags
!= SEC_NO_FLAGS
)
2323 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2324 as_warn ("error setting flags for \"%s\": %s",
2325 bfd_section_name (stdoutput
, seg
),
2326 bfd_errmsg (bfd_get_error ()));
2332 /* Ignore the HP type. */
2333 if (*input_line_pointer
== ',')
2334 input_line_pointer
+= 2;
2336 demand_empty_rest_of_line ();
2338 #else /* ! TC_M68K */
2347 name
= input_line_pointer
;
2348 c
= get_symbol_end ();
2350 name
= xstrdup (name
);
2352 *input_line_pointer
= c
;
2354 seg
= subseg_new (name
, 0);
2356 if (*input_line_pointer
!= ',')
2362 ++input_line_pointer
;
2364 sectype
= input_line_pointer
;
2365 c
= get_symbol_end ();
2366 if (*sectype
== '\0')
2368 else if (strcasecmp (sectype
, "text") == 0)
2370 else if (strcasecmp (sectype
, "data") == 0)
2372 else if (strcasecmp (sectype
, "romdata") == 0)
2375 as_warn ("unrecognized section type `%s'", sectype
);
2376 *input_line_pointer
= c
;
2379 if (*input_line_pointer
== ',')
2383 ++input_line_pointer
;
2385 seccmd
= input_line_pointer
;
2386 c
= get_symbol_end ();
2387 if (strcasecmp (seccmd
, "absolute") == 0)
2389 as_bad ("absolute sections are not supported");
2390 *input_line_pointer
= c
;
2391 ignore_rest_of_line ();
2394 else if (strcasecmp (seccmd
, "align") == 0)
2398 *input_line_pointer
= c
;
2399 align
= get_absolute_expression ();
2400 record_alignment (seg
, align
);
2404 as_warn ("unrecognized section command `%s'", seccmd
);
2405 *input_line_pointer
= c
;
2409 demand_empty_rest_of_line ();
2411 #else /* ! TC_I960 */
2412 /* The MRI assembler seems to use different forms of .sect for
2413 different targets. */
2415 #endif /* ! TC_I960 */
2416 #endif /* ! TC_M68K */
2419 /* Handle the .print pseudo-op. */
2428 s
= demand_copy_C_string (&len
);
2430 demand_empty_rest_of_line ();
2433 /* Handle the .purgem pseudo-op. */
2439 if (is_it_end_of_statement ())
2441 demand_empty_rest_of_line ();
2451 name
= input_line_pointer
;
2452 c
= get_symbol_end ();
2453 delete_macro (name
);
2454 *input_line_pointer
= c
;
2457 while (*input_line_pointer
++ == ',');
2459 --input_line_pointer
;
2460 demand_empty_rest_of_line ();
2463 /* Handle the .rept pseudo-op. */
2473 count
= get_absolute_expression ();
2476 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2478 as_bad ("rept without endr");
2484 sb_add_sb (&many
, &one
);
2488 input_scrub_include_sb (&many
, input_line_pointer
);
2490 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2497 register char *name
;
2498 register char delim
;
2499 register char *end_name
;
2500 register symbolS
*symbolP
;
2503 * Especial apologies for the random logic:
2504 * this just grew, and could be parsed much more simply!
2507 name
= input_line_pointer
;
2508 delim
= get_symbol_end ();
2509 end_name
= input_line_pointer
;
2513 if (*input_line_pointer
!= ',')
2516 as_bad ("Expected comma after name \"%s\"", name
);
2518 ignore_rest_of_line ();
2522 input_line_pointer
++;
2525 if (name
[0] == '.' && name
[1] == '\0')
2527 /* Turn '. = mumble' into a .org mumble */
2528 register segT segment
;
2531 segment
= get_known_segmented_expression (&exp
);
2534 do_org (segment
, &exp
, 0);
2540 if ((symbolP
= symbol_find (name
)) == NULL
2541 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2543 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2545 /* "set" symbols are local unless otherwise specified. */
2546 SF_SET_LOCAL (symbolP
);
2547 #endif /* OBJ_COFF */
2549 } /* make a new symbol */
2551 symbol_table_insert (symbolP
);
2554 pseudo_set (symbolP
);
2555 demand_empty_rest_of_line ();
2569 #ifdef md_flush_pending_output
2570 md_flush_pending_output ();
2574 stop
= mri_comment_field (&stopc
);
2576 /* In m68k MRI mode, we need to align to a word boundary, unless
2578 if (flag_m68k_mri
&& mult
> 1)
2580 if (now_seg
== absolute_section
)
2582 abs_section_offset
+= abs_section_offset
& 1;
2583 if (line_label
!= NULL
)
2584 S_SET_VALUE (line_label
, abs_section_offset
);
2586 else if (mri_common_symbol
!= NULL
)
2590 val
= S_GET_VALUE (mri_common_symbol
);
2593 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2594 if (line_label
!= NULL
)
2596 know (line_label
->sy_value
.X_op
== O_symbol
);
2597 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2598 line_label
->sy_value
.X_add_number
+= 1;
2604 do_align (1, (char *) NULL
, 0);
2605 if (line_label
!= NULL
)
2607 line_label
->sy_frag
= frag_now
;
2608 S_SET_VALUE (line_label
, frag_now_fix ());
2618 if (*input_line_pointer
== ',')
2620 ++input_line_pointer
;
2625 val
.X_op
= O_constant
;
2626 val
.X_add_number
= 0;
2629 if (val
.X_op
!= O_constant
2630 || val
.X_add_number
< - 0x80
2631 || val
.X_add_number
> 0xff
2632 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2634 if (exp
.X_op
!= O_constant
)
2635 as_bad ("Unsupported variable size or fill value");
2642 bytes
= mult
* exp
.X_add_number
;
2643 for (i
= 0; i
< exp
.X_add_number
; i
++)
2644 emit_expr (&val
, mult
);
2649 if (exp
.X_op
== O_constant
)
2653 repeat
= exp
.X_add_number
;
2659 if (! flag_mri
|| repeat
< 0)
2660 as_warn (".space repeat count is %s, ignored",
2661 repeat
? "negative" : "zero");
2665 /* If we are in the absolute section, just bump the offset. */
2666 if (now_seg
== absolute_section
)
2668 abs_section_offset
+= repeat
;
2672 /* If we are secretly in an MRI common section, then
2673 creating space just increases the size of the common
2675 if (mri_common_symbol
!= NULL
)
2677 S_SET_VALUE (mri_common_symbol
,
2678 S_GET_VALUE (mri_common_symbol
) + repeat
);
2683 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2684 repeat
, (char *) 0);
2688 if (now_seg
== absolute_section
)
2690 as_bad ("space allocation too complex in absolute section");
2691 subseg_set (text_section
, 0);
2693 if (mri_common_symbol
!= NULL
)
2695 as_bad ("space allocation too complex in common section");
2696 mri_common_symbol
= NULL
;
2699 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2700 make_expr_symbol (&exp
), 0L, (char *) 0);
2704 *p
= val
.X_add_number
;
2709 /* In MRI mode, after an odd number of bytes, we must align to an
2710 even word boundary, unless the next instruction is a dc.b, ds.b
2712 if (flag_mri
&& (bytes
& 1) != 0)
2713 mri_pending_align
= 1;
2716 mri_comment_end (stop
, stopc
);
2718 demand_empty_rest_of_line ();
2721 /* This is like s_space, but the value is a floating point number with
2722 the given precision. This is for the MRI dcb.s pseudo-op and
2726 s_float_space (float_type
)
2731 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2736 stop
= mri_comment_field (&stopc
);
2738 count
= get_absolute_expression ();
2741 if (*input_line_pointer
!= ',')
2743 as_bad ("missing value");
2745 mri_comment_end (stop
, stopc
);
2746 ignore_rest_of_line ();
2750 ++input_line_pointer
;
2754 /* Skip any 0{letter} that may be present. Don't even check if the
2755 * letter is legal. */
2756 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2757 input_line_pointer
+= 2;
2759 /* Accept :xxxx, where the x's are hex digits, for a floating point
2760 with the exact digits specified. */
2761 if (input_line_pointer
[0] == ':')
2763 flen
= hex_float (float_type
, temp
);
2767 mri_comment_end (stop
, stopc
);
2768 ignore_rest_of_line ();
2776 err
= md_atof (float_type
, temp
, &flen
);
2777 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2781 as_bad ("Bad floating literal: %s", err
);
2783 mri_comment_end (stop
, stopc
);
2784 ignore_rest_of_line ();
2789 while (--count
>= 0)
2793 p
= frag_more (flen
);
2794 memcpy (p
, temp
, (unsigned int) flen
);
2798 mri_comment_end (stop
, stopc
);
2800 demand_empty_rest_of_line ();
2803 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2813 stop
= mri_comment_field (&stopc
);
2814 abs_section_offset
= get_absolute_expression ();
2815 subseg_set (absolute_section
, 0);
2817 mri_comment_end (stop
, stopc
);
2818 demand_empty_rest_of_line ();
2827 temp
= get_absolute_expression ();
2828 subseg_set (text_section
, (subsegT
) temp
);
2829 demand_empty_rest_of_line ();
2831 const_flag
&= ~IN_DEFAULT_SECTION
;
2837 demand_empty_rest_of_line ()
2840 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2842 input_line_pointer
++;
2846 ignore_rest_of_line ();
2848 /* Return having already swallowed end-of-line. */
2849 } /* Return pointing just after end-of-line. */
2852 ignore_rest_of_line () /* For suspect lines: gives warning. */
2854 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2856 if (isprint (*input_line_pointer
))
2857 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2858 *input_line_pointer
);
2860 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2861 *input_line_pointer
);
2862 while (input_line_pointer
< buffer_limit
2863 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2865 input_line_pointer
++;
2868 input_line_pointer
++; /* Return pointing just after end-of-line. */
2869 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2875 * In: Pointer to a symbol.
2876 * Input_line_pointer->expression.
2878 * Out: Input_line_pointer->just after any whitespace after expression.
2879 * Tried to set symbol to value of expression.
2880 * Will change symbols type, value, and frag;
2883 pseudo_set (symbolP
)
2887 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2889 #endif /* OBJ_AOUT or OBJ_BOUT */
2891 know (symbolP
); /* NULL pointer is logic error. */
2892 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2893 ext
= S_IS_EXTERNAL (symbolP
);
2894 #endif /* OBJ_AOUT or OBJ_BOUT */
2896 (void) expression (&exp
);
2898 if (exp
.X_op
== O_illegal
)
2899 as_bad ("illegal expression; zero assumed");
2900 else if (exp
.X_op
== O_absent
)
2901 as_bad ("missing expression; zero assumed");
2902 else if (exp
.X_op
== O_big
)
2903 as_bad ("%s number invalid; zero assumed",
2904 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2905 else if (exp
.X_op
== O_subtract
2906 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2907 == S_GET_SEGMENT (exp
.X_op_symbol
))
2908 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2909 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2911 exp
.X_op
= O_constant
;
2912 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2913 - S_GET_VALUE (exp
.X_op_symbol
));
2921 exp
.X_add_number
= 0;
2924 S_SET_SEGMENT (symbolP
, absolute_section
);
2925 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2927 S_SET_EXTERNAL (symbolP
);
2929 S_CLEAR_EXTERNAL (symbolP
);
2930 #endif /* OBJ_AOUT or OBJ_BOUT */
2931 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2932 symbolP
->sy_frag
= &zero_address_frag
;
2936 S_SET_SEGMENT (symbolP
, reg_section
);
2937 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2938 symbolP
->sy_frag
= &zero_address_frag
;
2942 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2943 || exp
.X_add_number
!= 0)
2944 symbolP
->sy_value
= exp
;
2947 symbolS
*s
= exp
.X_add_symbol
;
2949 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2950 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2952 S_SET_EXTERNAL (symbolP
);
2954 S_CLEAR_EXTERNAL (symbolP
);
2955 #endif /* OBJ_AOUT or OBJ_BOUT */
2956 S_SET_VALUE (symbolP
,
2957 exp
.X_add_number
+ S_GET_VALUE (s
));
2958 symbolP
->sy_frag
= s
->sy_frag
;
2959 copy_symbol_attributes (symbolP
, s
);
2964 /* The value is some complex expression.
2965 FIXME: Should we set the segment to anything? */
2966 symbolP
->sy_value
= exp
;
2974 * CONStruct more frag of .bytes, or .words etc.
2975 * Should need_pass_2 be 1 then emit no frag(s).
2976 * This understands EXPRESSIONS.
2980 * This has a split personality. We use expression() to read the
2981 * value. We can detect if the value won't fit in a byte or word.
2982 * But we can't detect if expression() discarded significant digits
2983 * in the case of a long. Not worth the crocks required to fix it.
2986 /* Select a parser for cons expressions. */
2988 /* Some targets need to parse the expression in various fancy ways.
2989 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2990 (for example, the HPPA does this). Otherwise, you can define
2991 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2992 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2993 are defined, which is the normal case, then only simple expressions
2997 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2999 #ifndef TC_PARSE_CONS_EXPRESSION
3000 #ifdef BITFIELD_CONS_EXPRESSIONS
3001 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3003 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3005 #ifdef REPEAT_CONS_EXPRESSIONS
3006 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3008 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3011 /* If we haven't gotten one yet, just call expression. */
3012 #ifndef TC_PARSE_CONS_EXPRESSION
3013 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3017 /* worker to do .byte etc statements */
3018 /* clobbers input_line_pointer, checks */
3021 cons_worker (nbytes
, rva
)
3022 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3030 #ifdef md_flush_pending_output
3031 md_flush_pending_output ();
3035 stop
= mri_comment_field (&stopc
);
3037 if (is_it_end_of_statement ())
3040 mri_comment_end (stop
, stopc
);
3041 demand_empty_rest_of_line ();
3045 #ifdef md_cons_align
3046 md_cons_align (nbytes
);
3053 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3055 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3059 if (exp
.X_op
== O_symbol
)
3060 exp
.X_op
= O_symbol_rva
;
3062 as_fatal ("rva without symbol");
3064 emit_expr (&exp
, (unsigned int) nbytes
);
3067 while (*input_line_pointer
++ == ',');
3069 /* In MRI mode, after an odd number of bytes, we must align to an
3070 even word boundary, unless the next instruction is a dc.b, ds.b
3072 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3073 mri_pending_align
= 1;
3075 input_line_pointer
--; /* Put terminator back into stream. */
3078 mri_comment_end (stop
, stopc
);
3080 demand_empty_rest_of_line ();
3088 cons_worker (size
, 0);
3095 cons_worker (size
, 1);
3099 /* Put the contents of expression EXP into the object file using
3100 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3103 emit_expr (exp
, nbytes
)
3105 unsigned int nbytes
;
3109 valueT extra_digit
= 0;
3111 /* Don't do anything if we are going to make another pass. */
3117 /* Allow `.word 0' in the absolute section. */
3118 if (now_seg
== absolute_section
)
3120 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3121 as_bad ("attempt to store value in absolute section");
3122 abs_section_offset
+= nbytes
;
3126 /* Handle a negative bignum. */
3128 && exp
->X_add_number
== 0
3129 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3130 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3133 unsigned long carry
;
3135 exp
= &exp
->X_add_symbol
->sy_value
;
3137 /* Negate the bignum: one's complement each digit and add 1. */
3139 for (i
= 0; i
< exp
->X_add_number
; i
++)
3143 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3146 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3147 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3150 /* We can ignore any carry out, because it will be handled by
3151 extra_digit if it is needed. */
3153 extra_digit
= (valueT
) -1;
3157 if (op
== O_absent
|| op
== O_illegal
)
3159 as_warn ("zero assumed for missing expression");
3160 exp
->X_add_number
= 0;
3163 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3165 as_bad ("floating point number invalid; zero assumed");
3166 exp
->X_add_number
= 0;
3169 else if (op
== O_register
)
3171 as_warn ("register value used as expression");
3175 p
= frag_more ((int) nbytes
);
3177 #ifndef WORKING_DOT_WORD
3178 /* If we have the difference of two symbols in a word, save it on
3179 the broken_words list. See the code in write.c. */
3180 if (op
== O_subtract
&& nbytes
== 2)
3182 struct broken_word
*x
;
3184 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3185 x
->next_broken_word
= broken_words
;
3188 x
->word_goes_here
= p
;
3190 x
->add
= exp
->X_add_symbol
;
3191 x
->sub
= exp
->X_op_symbol
;
3192 x
->addnum
= exp
->X_add_number
;
3199 /* If we have an integer, but the number of bytes is too large to
3200 pass to md_number_to_chars, handle it as a bignum. */
3201 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3206 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3207 extra_digit
= (valueT
) -1;
3208 val
= (valueT
) exp
->X_add_number
;
3212 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3213 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3217 op
= exp
->X_op
= O_big
;
3218 exp
->X_add_number
= gencnt
;
3221 if (op
== O_constant
)
3223 register valueT get
;
3224 register valueT use
;
3225 register valueT mask
;
3227 register valueT unmask
;
3229 /* JF << of >= number of bits in the object is undefined. In
3230 particular SPARC (Sun 4) has problems */
3231 if (nbytes
>= sizeof (valueT
))
3234 if (nbytes
> sizeof (valueT
))
3237 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3241 /* Don't store these bits. */
3242 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3243 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3246 unmask
= ~mask
; /* Do store these bits. */
3249 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3250 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3253 get
= exp
->X_add_number
;
3255 if ((get
& mask
) != 0
3256 && ((get
& mask
) != mask
3257 || (get
& hibit
) == 0))
3258 { /* Leading bits contain both 0s & 1s. */
3259 as_warn ("Value 0x%lx truncated to 0x%lx.",
3260 (unsigned long) get
, (unsigned long) use
);
3262 /* put bytes in right order. */
3263 md_number_to_chars (p
, use
, (int) nbytes
);
3265 else if (op
== O_big
)
3268 LITTLENUM_TYPE
*nums
;
3270 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3272 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3275 as_warn ("Bignum truncated to %d bytes", nbytes
);
3279 if (target_big_endian
)
3281 while (nbytes
> size
)
3283 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3284 nbytes
-= CHARS_PER_LITTLENUM
;
3285 p
+= CHARS_PER_LITTLENUM
;
3288 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3292 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3293 size
-= CHARS_PER_LITTLENUM
;
3294 p
+= CHARS_PER_LITTLENUM
;
3299 nums
= generic_bignum
;
3302 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3304 size
-= CHARS_PER_LITTLENUM
;
3305 p
+= CHARS_PER_LITTLENUM
;
3306 nbytes
-= CHARS_PER_LITTLENUM
;
3311 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3312 nbytes
-= CHARS_PER_LITTLENUM
;
3313 p
+= CHARS_PER_LITTLENUM
;
3319 memset (p
, 0, nbytes
);
3321 /* Now we need to generate a fixS to record the symbol value.
3322 This is easy for BFD. For other targets it can be more
3323 complex. For very complex cases (currently, the HPPA and
3324 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3325 want. For simpler cases, you can define TC_CONS_RELOC to be
3326 the name of the reloc code that should be stored in the fixS.
3327 If neither is defined, the code uses NO_RELOC if it is
3328 defined, and otherwise uses 0. */
3330 #ifdef BFD_ASSEMBLER
3331 #ifdef TC_CONS_FIX_NEW
3332 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3335 bfd_reloc_code_real_type r
;
3352 as_bad ("unsupported BFD relocation size %u", nbytes
);
3356 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3361 #ifdef TC_CONS_FIX_NEW
3362 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3364 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3365 it is defined, otherwise use NO_RELOC if it is defined,
3367 #ifndef TC_CONS_RELOC
3369 #define TC_CONS_RELOC NO_RELOC
3371 #define TC_CONS_RELOC 0
3374 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3376 #endif /* TC_CONS_FIX_NEW */
3377 #endif /* BFD_ASSEMBLER */
3381 #ifdef BITFIELD_CONS_EXPRESSIONS
3383 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3384 w:x,y:z, where w and y are bitwidths and x and y are values. They
3385 then pack them all together. We do a little better in that we allow
3386 them in words, longs, etc. and we'll pack them in target byte order
3389 The rules are: pack least significat bit first, if a field doesn't
3390 entirely fit, put it in the next unit. Overflowing the bitfield is
3391 explicitly *not* even a warning. The bitwidth should be considered
3394 To use this function the tc-XXX.h file should define
3395 BITFIELD_CONS_EXPRESSIONS. */
3398 parse_bitfield_cons (exp
, nbytes
)
3400 unsigned int nbytes
;
3402 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3403 char *hold
= input_line_pointer
;
3405 (void) expression (exp
);
3407 if (*input_line_pointer
== ':')
3413 unsigned long width
;
3415 if (*input_line_pointer
!= ':')
3417 input_line_pointer
= hold
;
3419 } /* next piece is not a bitfield */
3421 /* In the general case, we can't allow
3422 full expressions with symbol
3423 differences and such. The relocation
3424 entries for symbols not defined in this
3425 assembly would require arbitrary field
3426 widths, positions, and masks which most
3427 of our current object formats don't
3430 In the specific case where a symbol
3431 *is* defined in this assembly, we
3432 *could* build fixups and track it, but
3433 this could lead to confusion for the
3434 backends. I'm lazy. I'll take any
3435 SEG_ABSOLUTE. I think that means that
3436 you can use a previous .set or
3437 .equ type symbol. xoxorich. */
3439 if (exp
->X_op
== O_absent
)
3441 as_warn ("using a bit field width of zero");
3442 exp
->X_add_number
= 0;
3443 exp
->X_op
= O_constant
;
3444 } /* implied zero width bitfield */
3446 if (exp
->X_op
!= O_constant
)
3448 *input_line_pointer
= '\0';
3449 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3450 *input_line_pointer
= ':';
3451 demand_empty_rest_of_line ();
3455 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3457 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3458 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3459 width
= BITS_PER_CHAR
* nbytes
;
3462 if (width
> bits_available
)
3464 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3465 input_line_pointer
= hold
;
3466 exp
->X_add_number
= value
;
3470 hold
= ++input_line_pointer
; /* skip ':' */
3472 (void) expression (exp
);
3473 if (exp
->X_op
!= O_constant
)
3475 char cache
= *input_line_pointer
;
3477 *input_line_pointer
= '\0';
3478 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3479 *input_line_pointer
= cache
;
3480 demand_empty_rest_of_line ();
3484 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3485 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3487 if ((bits_available
-= width
) == 0
3488 || is_it_end_of_statement ()
3489 || *input_line_pointer
!= ',')
3492 } /* all the bitfields we're gonna get */
3494 hold
= ++input_line_pointer
;
3495 (void) expression (exp
);
3496 } /* forever loop */
3498 exp
->X_add_number
= value
;
3499 exp
->X_op
= O_constant
;
3500 exp
->X_unsigned
= 1;
3501 } /* if looks like a bitfield */
3502 } /* parse_bitfield_cons() */
3504 #endif /* BITFIELD_CONS_EXPRESSIONS */
3506 /* Handle an MRI style string expression. */
3509 parse_mri_cons (exp
, nbytes
)
3511 unsigned int nbytes
;
3513 if (*input_line_pointer
!= '\''
3514 && (input_line_pointer
[1] != '\''
3515 || (*input_line_pointer
!= 'A'
3516 && *input_line_pointer
!= 'E')))
3517 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3521 unsigned int result
= 0;
3523 /* An MRI style string. Cut into as many bytes as will fit into
3524 a nbyte chunk, left justify if necessary, and separate with
3525 commas so we can try again later. */
3526 if (*input_line_pointer
== 'A')
3527 ++input_line_pointer
;
3528 else if (*input_line_pointer
== 'E')
3530 as_bad ("EBCDIC constants are not supported");
3531 ++input_line_pointer
;
3534 input_line_pointer
++;
3535 for (scan
= 0; scan
< nbytes
; scan
++)
3537 if (*input_line_pointer
== '\'')
3539 if (input_line_pointer
[1] == '\'')
3541 input_line_pointer
++;
3546 result
= (result
<< 8) | (*input_line_pointer
++);
3550 while (scan
< nbytes
)
3555 /* Create correct expression */
3556 exp
->X_op
= O_constant
;
3557 exp
->X_add_number
= result
;
3558 /* Fake it so that we can read the next char too */
3559 if (input_line_pointer
[0] != '\'' ||
3560 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3562 input_line_pointer
-= 2;
3563 input_line_pointer
[0] = ',';
3564 input_line_pointer
[1] = '\'';
3567 input_line_pointer
++;
3571 #ifdef REPEAT_CONS_EXPRESSIONS
3573 /* Parse a repeat expression for cons. This is used by the MIPS
3574 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3575 object file COUNT times.
3577 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3580 parse_repeat_cons (exp
, nbytes
)
3582 unsigned int nbytes
;
3589 if (*input_line_pointer
!= ':')
3591 /* No repeat count. */
3595 ++input_line_pointer
;
3596 expression (&count
);
3597 if (count
.X_op
!= O_constant
3598 || count
.X_add_number
<= 0)
3600 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3604 /* The cons function is going to output this expression once. So we
3605 output it count - 1 times. */
3606 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3607 emit_expr (exp
, nbytes
);
3610 #endif /* REPEAT_CONS_EXPRESSIONS */
3612 /* Parse a floating point number represented as a hex constant. This
3613 permits users to specify the exact bits they want in the floating
3617 hex_float (float_type
, bytes
)
3651 as_bad ("Unknown floating type type '%c'", float_type
);
3655 /* It would be nice if we could go through expression to parse the
3656 hex constant, but if we get a bignum it's a pain to sort it into
3657 the buffer correctly. */
3659 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3663 /* The MRI assembler accepts arbitrary underscores strewn about
3664 through the hex constant, so we ignore them as well. */
3665 if (*input_line_pointer
== '_')
3667 ++input_line_pointer
;
3673 as_warn ("Floating point constant too large");
3676 d
= hex_value (*input_line_pointer
) << 4;
3677 ++input_line_pointer
;
3678 while (*input_line_pointer
== '_')
3679 ++input_line_pointer
;
3680 if (hex_p (*input_line_pointer
))
3682 d
+= hex_value (*input_line_pointer
);
3683 ++input_line_pointer
;
3685 if (target_big_endian
)
3688 bytes
[length
- i
- 1] = d
;
3694 if (target_big_endian
)
3695 memset (bytes
+ i
, 0, length
- i
);
3697 memset (bytes
, 0, length
- i
);
3706 * CONStruct some more frag chars of .floats .ffloats etc.
3707 * Makes 0 or more new frags.
3708 * If need_pass_2 == 1, no frags are emitted.
3709 * This understands only floating literals, not expressions. Sorry.
3711 * A floating constant is defined by atof_generic(), except it is preceded
3712 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3713 * reading, I decided to be incompatible. This always tries to give you
3714 * rounded bits to the precision of the pseudo-op. Former AS did premature
3715 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3716 * a choice of 2 flavours of noise according to which of 2 floating-point
3717 * scanners you directed AS to use.
3719 * In: input_line_pointer->whitespace before, or '0' of flonum.
3724 float_cons (float_type
)
3725 /* Clobbers input_line-pointer, checks end-of-line. */
3726 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3729 int length
; /* Number of chars in an object. */
3730 register char *err
; /* Error from scanning floating literal. */
3731 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3733 if (is_it_end_of_statement ())
3735 demand_empty_rest_of_line ();
3739 #ifdef md_flush_pending_output
3740 md_flush_pending_output ();
3745 /* input_line_pointer->1st char of a flonum (we hope!). */
3748 /* Skip any 0{letter} that may be present. Don't even check if the
3749 * letter is legal. Someone may invent a "z" format and this routine
3750 * has no use for such information. Lusers beware: you get
3751 * diagnostics if your input is ill-conditioned.
3753 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3754 input_line_pointer
+= 2;
3756 /* Accept :xxxx, where the x's are hex digits, for a floating
3757 point with the exact digits specified. */
3758 if (input_line_pointer
[0] == ':')
3760 ++input_line_pointer
;
3761 length
= hex_float (float_type
, temp
);
3764 ignore_rest_of_line ();
3770 err
= md_atof (float_type
, temp
, &length
);
3771 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3775 as_bad ("Bad floating literal: %s", err
);
3776 ignore_rest_of_line ();
3787 #ifdef REPEAT_CONS_EXPRESSIONS
3788 if (*input_line_pointer
== ':')
3790 expressionS count_exp
;
3792 ++input_line_pointer
;
3793 expression (&count_exp
);
3794 if (count_exp
.X_op
!= O_constant
3795 || count_exp
.X_add_number
<= 0)
3797 as_warn ("unresolvable or nonpositive repeat count; using 1");
3800 count
= count_exp
.X_add_number
;
3804 while (--count
>= 0)
3806 p
= frag_more (length
);
3807 memcpy (p
, temp
, (unsigned int) length
);
3812 while (*input_line_pointer
++ == ',');
3814 --input_line_pointer
; /* Put terminator back into stream. */
3815 demand_empty_rest_of_line ();
3816 } /* float_cons() */
3821 * We read 0 or more ',' seperated, double-quoted strings.
3823 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3828 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3829 /* Checks end-of-line. */
3830 register int append_zero
; /* 0: don't append '\0', else 1 */
3832 register unsigned int c
;
3834 #ifdef md_flush_pending_output
3835 md_flush_pending_output ();
3839 * The following awkward logic is to parse ZERO or more strings,
3840 * comma seperated. Recall a string expression includes spaces
3841 * before the opening '\"' and spaces after the closing '\"'.
3842 * We fake a leading ',' if there is (supposed to be)
3843 * a 1st, expression. We keep demanding expressions for each
3846 if (is_it_end_of_statement ())
3848 c
= 0; /* Skip loop. */
3849 ++input_line_pointer
; /* Compensate for end of loop. */
3853 c
= ','; /* Do loop. */
3855 while (c
== ',' || c
== '<' || c
== '"')
3858 switch (*input_line_pointer
)
3861 ++input_line_pointer
; /*->1st char of string. */
3862 while (is_a_char (c
= next_char_of_string ()))
3864 FRAG_APPEND_1_CHAR (c
);
3868 FRAG_APPEND_1_CHAR (0);
3870 know (input_line_pointer
[-1] == '\"');
3873 input_line_pointer
++;
3874 c
= get_single_number ();
3875 FRAG_APPEND_1_CHAR (c
);
3876 if (*input_line_pointer
!= '>')
3878 as_bad ("Expected <nn>");
3880 input_line_pointer
++;
3883 input_line_pointer
++;
3887 c
= *input_line_pointer
;
3890 demand_empty_rest_of_line ();
3893 /* FIXME-SOMEDAY: I had trouble here on characters with the
3894 high bits set. We'll probably also have trouble with
3895 multibyte chars, wide chars, etc. Also be careful about
3896 returning values bigger than 1 byte. xoxorich. */
3899 next_char_of_string ()
3901 register unsigned int c
;
3903 c
= *input_line_pointer
++ & CHAR_MASK
;
3911 as_warn ("Unterminated string: Newline inserted.");
3912 bump_line_counters ();
3915 #ifndef NO_STRING_ESCAPES
3917 switch (c
= *input_line_pointer
++)
3945 break; /* As itself. */
3961 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3963 number
= number
* 8 + c
- '0';
3967 --input_line_pointer
;
3976 c
= *input_line_pointer
++;
3977 while (isxdigit (c
))
3980 number
= number
* 16 + c
- '0';
3981 else if (isupper (c
))
3982 number
= number
* 16 + c
- 'A' + 10;
3984 number
= number
* 16 + c
- 'a' + 10;
3985 c
= *input_line_pointer
++;
3988 --input_line_pointer
;
3993 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3994 as_warn ("Unterminated string: Newline inserted.");
3996 bump_line_counters ();
4001 #ifdef ONLY_STANDARD_ESCAPES
4002 as_bad ("Bad escaped character in string, '?' assumed");
4004 #endif /* ONLY_STANDARD_ESCAPES */
4007 } /* switch on escaped char */
4009 #endif /* ! defined (NO_STRING_ESCAPES) */
4013 } /* switch on char */
4015 } /* next_char_of_string() */
4018 get_segmented_expression (expP
)
4019 register expressionS
*expP
;
4021 register segT retval
;
4023 retval
= expression (expP
);
4024 if (expP
->X_op
== O_illegal
4025 || expP
->X_op
== O_absent
4026 || expP
->X_op
== O_big
)
4028 as_bad ("expected address expression; zero assumed");
4029 expP
->X_op
= O_constant
;
4030 expP
->X_add_number
= 0;
4031 retval
= absolute_section
;
4037 get_known_segmented_expression (expP
)
4038 register expressionS
*expP
;
4040 register segT retval
;
4042 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4044 /* There is no easy way to extract the undefined symbol from the
4046 if (expP
->X_add_symbol
!= NULL
4047 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4048 as_warn ("symbol \"%s\" undefined; zero assumed",
4049 S_GET_NAME (expP
->X_add_symbol
));
4051 as_warn ("some symbol undefined; zero assumed");
4052 retval
= absolute_section
;
4053 expP
->X_op
= O_constant
;
4054 expP
->X_add_number
= 0;
4056 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4058 } /* get_known_segmented_expression() */
4061 get_absolute_expression ()
4066 if (exp
.X_op
!= O_constant
)
4068 if (exp
.X_op
!= O_absent
)
4069 as_bad ("bad or irreducible absolute expression; zero assumed");
4070 exp
.X_add_number
= 0;
4072 return exp
.X_add_number
;
4075 char /* return terminator */
4076 get_absolute_expression_and_terminator (val_pointer
)
4077 long *val_pointer
; /* return value of expression */
4079 /* FIXME: val_pointer should probably be offsetT *. */
4080 *val_pointer
= (long) get_absolute_expression ();
4081 return (*input_line_pointer
++);
4085 * demand_copy_C_string()
4087 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4088 * Give a warning if that happens.
4091 demand_copy_C_string (len_pointer
)
4096 if ((s
= demand_copy_string (len_pointer
)) != 0)
4100 for (len
= *len_pointer
; len
> 0; len
--)
4107 as_bad ("This string may not contain \'\\0\'");
4115 * demand_copy_string()
4117 * Demand string, but return a safe (=private) copy of the string.
4118 * Return NULL if we can't read a string here.
4121 demand_copy_string (lenP
)
4124 register unsigned int c
;
4130 if (*input_line_pointer
== '\"')
4132 input_line_pointer
++; /* Skip opening quote. */
4134 while (is_a_char (c
= next_char_of_string ()))
4136 obstack_1grow (¬es
, c
);
4139 /* JF this next line is so demand_copy_C_string will return a
4140 null terminated string. */
4141 obstack_1grow (¬es
, '\0');
4142 retval
= obstack_finish (¬es
);
4146 as_warn ("Missing string");
4148 ignore_rest_of_line ();
4152 } /* demand_copy_string() */
4155 * is_it_end_of_statement()
4157 * In: Input_line_pointer->next character.
4159 * Do: Skip input_line_pointer over all whitespace.
4161 * Out: 1 if input_line_pointer->end-of-line.
4164 is_it_end_of_statement ()
4167 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4168 } /* is_it_end_of_statement() */
4174 register symbolS
*symbolP
; /* symbol we are working with */
4178 input_line_pointer
++;
4179 if (*input_line_pointer
== '=')
4180 input_line_pointer
++;
4182 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4183 input_line_pointer
++;
4186 stop
= mri_comment_field (&stopc
);
4188 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4190 /* Turn '. = mumble' into a .org mumble */
4191 register segT segment
;
4194 segment
= get_known_segmented_expression (&exp
);
4196 do_org (segment
, &exp
, 0);
4200 symbolP
= symbol_find_or_make (sym_name
);
4201 pseudo_set (symbolP
);
4205 mri_comment_end (stop
, stopc
);
4208 /* .include -- include a file at this point. */
4221 if (! flag_m68k_mri
)
4222 filename
= demand_copy_string (&i
);
4227 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4228 && *input_line_pointer
!= ' '
4229 && *input_line_pointer
!= '\t')
4231 obstack_1grow (¬es
, *input_line_pointer
);
4232 ++input_line_pointer
;
4235 obstack_1grow (¬es
, '\0');
4236 filename
= obstack_finish (¬es
);
4237 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4238 ++input_line_pointer
;
4240 demand_empty_rest_of_line ();
4241 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4242 for (i
= 0; i
< include_dir_count
; i
++)
4244 strcpy (path
, include_dirs
[i
]);
4246 strcat (path
, filename
);
4247 if (0 != (try = fopen (path
, "r")))
4256 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4257 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4258 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4262 add_include_dir (path
)
4267 if (include_dir_count
== 0)
4269 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4270 include_dirs
[0] = "."; /* Current dir */
4271 include_dir_count
= 2;
4275 include_dir_count
++;
4276 include_dirs
= (char **) realloc (include_dirs
,
4277 include_dir_count
* sizeof (*include_dirs
));
4280 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4283 if (i
> include_dir_maxlen
)
4284 include_dir_maxlen
= i
;
4285 } /* add_include_dir() */
4291 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4293 ++input_line_pointer
;
4295 ++input_line_pointer
;
4300 read_print_statistics (file
)
4303 hash_print_statistics (file
, "pseudo-op table", po_hash
);