1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
23 change this a bit. But then, GNU isn't
24 spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.)
28 #define MASK_CHAR ((int)(unsigned char)-1)
32 /* This is the largest known floating point format (for now). It will
33 grow when we do 4361 style flonums. */
35 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
37 /* Routines that read assembler source text to build spagetti in memory.
38 Another group of these functions is in the expr.c module. */
47 #include "libiberty.h"
51 #ifndef TC_START_LABEL
52 #define TC_START_LABEL(x,y) (x==':')
55 /* The NOP_OPCODE is for the alignment fill value.
56 * fill it a nop instruction so that the disassembler does not choke
60 #define NOP_OPCODE 0x00
63 char *input_line_pointer
; /*->next char of source file to parse. */
65 int generate_asm_lineno
= 0; /* flag to generate line stab for .s file */
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
74 /* The m88k unfortunately uses @ as a label beginner. */
79 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
84 /* The Delta 68k assembler permits % inside label names. */
89 /* The PowerPC Windows NT assemblers permits ? inside label names. */
94 /* The a29k assembler does not permits labels to start with $. */
98 /* used by is_... macros. our ctype[] */
101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
103 0, 0, 0, 0, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
104 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
105 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
106 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
107 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
108 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 0, /* pqrstuvwxyz{|}~. */
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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,
121 * Out: 1 if this character ends a line.
124 char is_end_of_line
[256] =
127 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
129 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
131 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
133 _
,99, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* _!"#$%&'()*+,-./ */
134 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* 0123456789:;<=>? */
136 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
137 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
139 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
140 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
141 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
142 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
143 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
144 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
145 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
146 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
147 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
151 /* Functions private to this file. */
153 static char *buffer
; /* 1st char of each buffer of lines is here. */
154 static char *buffer_limit
; /*->1 + last char in buffer. */
156 #ifdef TARGET_BYTES_BIG_ENDIAN
157 /* Hack to deal with tc-*.h defining TARGET_BYTES_BIG_ENDIAN to empty
158 instead of to 0 or 1. */
159 #if 5 - TARGET_BYTES_BIG_ENDIAN - 5 == 10
160 #undef TARGET_BYTES_BIG_ENDIAN
161 #define TARGET_BYTES_BIG_ENDIAN 1
163 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
165 int target_big_endian
/* = 0 */;
168 static char *old_buffer
; /* JF a hack */
169 static char *old_input
;
170 static char *old_limit
;
172 /* Variables for handling include file directory list. */
174 char **include_dirs
; /* List of pointers to directories to
175 search for .include's */
176 int include_dir_count
; /* How many are in the list */
177 int include_dir_maxlen
= 1;/* Length of longest in list */
179 #ifndef WORKING_DOT_WORD
180 struct broken_word
*broken_words
;
181 int new_broken_words
;
184 /* The current offset into the absolute section. We don't try to
185 build frags in the absolute section, since no data can be stored
186 there. We just keep track of the current offset. */
187 addressT abs_section_offset
;
189 /* If this line had an MRI style label, it is stored in this variable.
190 This is used by some of the MRI pseudo-ops. */
193 /* This global variable is used to support MRI common sections. We
194 translate such sections into a common symbol. This variable is
195 non-NULL when we are in an MRI common section. */
196 symbolS
*mri_common_symbol
;
198 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
199 need to align to an even byte boundary unless the next pseudo-op is
200 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
202 static int mri_pending_align
;
204 static int scrub_from_string
PARAMS ((char **));
205 static void do_align
PARAMS ((int, char *, int));
206 static int hex_float
PARAMS ((int, char *));
207 static void do_org
PARAMS ((segT
, expressionS
*, int));
208 char *demand_copy_string
PARAMS ((int *lenP
));
209 int is_it_end_of_statement
PARAMS ((void));
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 {"list", listing_list
, 1}, /* Turn listing on */
331 {"llen", listing_psize
, 1},
334 {"macro", s_macro
, 0},
335 {"mexit", s_mexit
, 0},
336 {"name", s_ignore
, 0},
337 {"noformat", s_ignore
, 0},
338 {"nolist", listing_list
, 0}, /* Turn listing off */
339 {"nopage", listing_nopage
, 0},
341 {"offset", s_struct
, 0},
343 {"p2align", s_align_ptwo
, 0},
344 {"p2alignw", s_align_ptwo
, 2},
345 {"p2alignl", s_align_ptwo
, 4},
346 {"page", listing_eject
, 0},
347 {"plen", listing_psize
, 0},
348 {"print", s_print
, 0},
349 {"psize", listing_psize
, 0}, /* set paper size */
350 {"purgem", s_purgem
, 0},
355 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
360 {"single", float_cons
, 'f'},
362 {"space", s_space
, 0},
363 {"spc", s_ignore
, 0},
364 {"stabd", s_stab
, 'd'},
365 {"stabn", s_stab
, 'n'},
366 {"stabs", s_stab
, 's'},
367 {"string", stringer
, 1},
368 {"struct", s_struct
, 0},
372 /* This is for gcc to use. It's only just been added (2/94), so gcc
373 won't be able to use it for a while -- probably a year or more.
374 But once this has been released, check with gcc maintainers
375 before deleting it or even changing the spelling. */
376 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
377 /* If we're folding case -- done for some targets, not necessarily
378 all -- the above string in an input file will be converted to
379 this one. Match it either way... */
380 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
382 {"title", listing_title
, 0}, /* Listing title */
383 {"ttl", listing_title
, 0},
388 {"xdef", s_globl
, 0},
389 {"xref", s_ignore
, 0},
390 {"xstabs", s_xstab
, 's'},
392 {"zero", s_space
, 0},
393 {NULL
} /* end sentinel */
396 static int pop_override_ok
= 0;
397 static const char *pop_table_name
;
401 const pseudo_typeS
*table
;
404 const pseudo_typeS
*pop
;
405 for (pop
= table
; pop
->poc_name
; pop
++)
407 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
408 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
409 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
414 #ifndef md_pop_insert
415 #define md_pop_insert() pop_insert(md_pseudo_table)
418 #ifndef obj_pop_insert
419 #define obj_pop_insert() pop_insert(obj_pseudo_table)
425 po_hash
= hash_new ();
427 /* Do the target-specific pseudo ops. */
428 pop_table_name
= "md";
431 /* Now object specific. Skip any that were in the target table. */
432 pop_table_name
= "obj";
436 /* Now portable ones. Skip any that we've seen already. */
437 pop_table_name
= "standard";
438 pop_insert (potable
);
441 #define HANDLE_CONDITIONAL_ASSEMBLY() \
442 if (ignore_input ()) \
444 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
445 if (input_line_pointer == buffer_limit) \
451 /* This function is used when scrubbing the characters between #APP
454 static char *scrub_string
;
455 static char *scrub_string_end
;
458 scrub_from_string (from
)
463 *from
= scrub_string
;
464 size
= scrub_string_end
- scrub_string
;
465 scrub_string
= scrub_string_end
;
469 /* read_a_source_file()
471 * We read the file, putting things into a web that
472 * represents what we have been reading.
475 read_a_source_file (name
)
479 register char *s
; /* string of symbol, '\0' appended */
483 buffer
= input_scrub_new_file (name
);
486 listing_newline ("");
488 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
489 { /* We have another line to parse. */
490 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
491 contin
: /* JF this goto is my fault I admit it.
492 Someone brave please re-write the whole
493 input section here? Pleeze??? */
494 while (input_line_pointer
< buffer_limit
)
496 /* We have more of this buffer to parse. */
499 * We now have input_line_pointer->1st char of next line.
500 * If input_line_pointer [-1] == '\n' then we just
501 * scanned another line: so bump line counters.
503 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
505 #ifdef md_start_line_hook
506 md_start_line_hook ();
509 if (input_line_pointer
[-1] == '\n')
510 bump_line_counters ();
515 #ifdef LABELS_WITHOUT_COLONS
520 /* Text at the start of a line must be a label, we
521 run down and stick a colon in. */
522 if (is_name_beginner (*input_line_pointer
))
524 char *line_start
= input_line_pointer
;
527 HANDLE_CONDITIONAL_ASSEMBLY ();
529 c
= get_symbol_end ();
531 /* In MRI mode, the EQU pseudoop must be
532 handled specially. */
535 char *rest
= input_line_pointer
+ 1;
539 if (*rest
== ' ' || *rest
== '\t')
541 if ((strncasecmp (rest
, "EQU", 3) == 0
542 || strncasecmp (rest
, "SET", 3) == 0)
543 && (rest
[3] == ' ' || rest
[3] == '\t'))
545 input_line_pointer
= rest
+ 3;
551 line_label
= colon (line_start
);
553 *input_line_pointer
= c
;
555 input_line_pointer
++;
561 * We are at the begining of a line, or similar place.
562 * We expect a well-formed assembler statement.
563 * A "symbol-name:" is a statement.
565 * Depending on what compiler is used, the order of these tests
566 * may vary to catch most common case 1st.
567 * Each test is independent of all other tests at the (top) level.
568 * PLEASE make a compiler that doesn't use this assembler.
569 * It is crufty to waste a compiler's time encoding things for this
570 * assembler, which then wastes more time decoding it.
571 * (And communicating via (linear) files is silly!
572 * If you must pass stuff, please pass a tree!)
574 if ((c
= *input_line_pointer
++) == '\t'
579 c
= *input_line_pointer
++;
581 know (c
!= ' '); /* No further leading whitespace. */
584 * C is the 1st significant character.
585 * Input_line_pointer points after that character.
587 if (is_name_beginner (c
))
589 /* want user-defined label or pseudo/opcode */
590 HANDLE_CONDITIONAL_ASSEMBLY ();
592 s
= --input_line_pointer
;
593 c
= get_symbol_end (); /* name's delimiter */
595 * C is character after symbol.
596 * That character's place in the input line is now '\0'.
597 * S points to the beginning of the symbol.
598 * [In case of pseudo-op, s->'.'.]
599 * Input_line_pointer->'\0' where c was.
601 if (TC_START_LABEL(c
, input_line_pointer
))
605 char *rest
= input_line_pointer
+ 1;
607 /* In MRI mode, \tsym: set 0 is permitted. */
611 if (*rest
== ' ' || *rest
== '\t')
613 if ((strncasecmp (rest
, "EQU", 3) == 0
614 || strncasecmp (rest
, "SET", 3) == 0)
615 && (rest
[3] == ' ' || rest
[3] == '\t'))
617 input_line_pointer
= rest
+ 3;
623 line_label
= colon (s
); /* user-defined label */
624 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
625 /* Input_line_pointer->after ':'. */
631 || (input_line_pointer
[1] == '='
632 #ifdef TC_EQUAL_IN_INSN
633 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
638 demand_empty_rest_of_line ();
641 { /* expect pseudo-op or machine instruction */
644 #define IGNORE_OPCODE_CASE
645 #ifdef IGNORE_OPCODE_CASE
663 /* The MRI assembler and the m88k use pseudo-ops
665 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
666 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
671 || (! flag_m68k_mri
&& *s
== '.'))
676 * WARNING: c has next char, which may be end-of-line.
677 * We lookup the pseudo-op table with s+1 because we
678 * already know that the pseudo-op begins with a '.'.
682 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
684 /* In MRI mode, we may need to insert an
685 automatic alignment directive. What a hack
687 if (mri_pending_align
689 || ! ((pop
->poc_handler
== cons
690 && pop
->poc_val
== 1)
691 || (pop
->poc_handler
== s_space
692 && pop
->poc_val
== 1))))
694 do_align (1, (char *) NULL
, 0);
695 mri_pending_align
= 0;
698 /* Print the error msg now, while we still can */
701 as_bad ("Unknown pseudo-op: `%s'", s
);
702 *input_line_pointer
= c
;
707 /* Put it back for error messages etc. */
708 *input_line_pointer
= c
;
709 /* The following skip of whitespace is compulsory.
710 A well shaped space is sometimes all that separates
711 keyword from operands. */
712 if (c
== ' ' || c
== '\t')
713 input_line_pointer
++;
715 * Input_line is restored.
716 * Input_line_pointer->1st non-blank char
717 * after pseudo-operation.
719 (*pop
->poc_handler
) (pop
->poc_val
);
721 /* If that was .end, just get out now. */
722 if (pop
->poc_handler
== s_end
)
726 { /* machine instruction */
729 if (mri_pending_align
)
731 do_align (1, (char *) NULL
, 0);
732 mri_pending_align
= 0;
735 /* WARNING: c has char, which may be end-of-line. */
736 /* Also: input_line_pointer->`\0` where c was. */
737 *input_line_pointer
= c
;
738 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
740 #ifdef TC_EOL_IN_INSN
741 || TC_EOL_IN_INSN (input_line_pointer
)
745 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
747 input_line_pointer
++;
750 c
= *input_line_pointer
;
751 *input_line_pointer
= '\0';
753 #ifdef OBJ_GENERATE_ASM_LINENO
754 if (generate_asm_lineno
== 0)
756 if (ecoff_no_current_file ())
757 generate_asm_lineno
= 1;
759 if (generate_asm_lineno
== 1)
764 as_where (&s
, &lineno
);
765 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
774 if (check_macro (s
, &out
, '\0', &err
))
778 *input_line_pointer
++ = c
;
779 input_scrub_include_sb (&out
,
783 input_scrub_next_buffer (&input_line_pointer
);
788 md_assemble (s
); /* Assemble 1 instruction. */
790 *input_line_pointer
++ = c
;
792 /* We resume loop AFTER the end-of-line from
797 } /* if (is_name_beginner(c) */
800 /* Empty statement? */
801 if (is_end_of_line
[(unsigned char) c
])
804 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
807 /* local label ("4:") */
808 char *backup
= input_line_pointer
;
810 HANDLE_CONDITIONAL_ASSEMBLY ();
814 while (isdigit (*input_line_pointer
))
816 temp
= (temp
* 10) + *input_line_pointer
- '0';
817 ++input_line_pointer
;
818 } /* read the whole number */
820 if (LOCAL_LABELS_DOLLAR
821 && *input_line_pointer
== '$'
822 && *(input_line_pointer
+ 1) == ':')
824 input_line_pointer
+= 2;
826 if (dollar_label_defined (temp
))
828 as_fatal ("label \"%d$\" redefined", temp
);
831 define_dollar_label (temp
);
832 colon (dollar_label_name (temp
, 0));
837 && *input_line_pointer
++ == ':')
839 fb_label_instance_inc (temp
);
840 colon (fb_label_name (temp
, 0));
844 input_line_pointer
= backup
;
845 } /* local label ("4:") */
847 if (c
&& strchr (line_comment_chars
, c
))
848 { /* Its a comment. Better say APP or NO_APP */
852 unsigned int new_length
;
855 bump_line_counters ();
856 s
= input_line_pointer
;
857 if (strncmp (s
, "APP\n", 4))
858 continue; /* We ignore it */
861 ends
= strstr (s
, "#NO_APP\n");
865 unsigned int tmp_len
;
868 /* The end of the #APP wasn't in this buffer. We
869 keep reading in buffers until we find the #NO_APP
870 that goes with this #APP There is one. The specs
872 tmp_len
= buffer_limit
- s
;
873 tmp_buf
= xmalloc (tmp_len
+ 1);
874 memcpy (tmp_buf
, s
, tmp_len
);
877 new_tmp
= input_scrub_next_buffer (&buffer
);
881 buffer_limit
= new_tmp
;
882 input_line_pointer
= buffer
;
883 ends
= strstr (buffer
, "#NO_APP\n");
887 num
= buffer_limit
- buffer
;
889 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
890 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
895 input_line_pointer
= ends
? ends
+ 8 : NULL
;
903 input_line_pointer
= ends
+ 8;
907 scrub_string_end
= ends
;
909 new_length
= ends
- s
;
910 new_buf
= (char *) xmalloc (new_length
);
917 space
= (new_buf
+ new_length
) - new_tmp
;
918 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
926 new_buf
= xrealloc (new_buf
, new_length
+ 100);
927 new_tmp
= new_buf
+ new_length
;
934 old_input
= input_line_pointer
;
935 old_limit
= buffer_limit
;
937 input_line_pointer
= new_buf
;
938 buffer_limit
= new_tmp
;
942 HANDLE_CONDITIONAL_ASSEMBLY ();
944 #ifdef tc_unrecognized_line
945 if (tc_unrecognized_line (c
))
949 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
950 input_line_pointer
--; /* Report unknown char as ignored. */
951 ignore_rest_of_line ();
952 } /* while (input_line_pointer<buffer_limit) */
954 #ifdef md_after_pass_hook
955 md_after_pass_hook ();
961 bump_line_counters ();
965 input_line_pointer
= old_input
;
966 buffer_limit
= old_limit
;
971 } /* while (more buffers to scan) */
974 input_scrub_close (); /* Close the input file */
977 /* For most MRI pseudo-ops, the line actually ends at the first
978 nonquoted space. This function looks for that point, stuffs a null
979 in, and sets *STOPCP to the character that used to be there, and
980 returns the location.
982 Until I hear otherwise, I am going to assume that this is only true
983 for the m68k MRI assembler. */
986 mri_comment_field (stopcp
)
994 know (flag_m68k_mri
);
996 for (s
= input_line_pointer
;
997 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1002 inquote
= ! inquote
;
1012 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1022 /* Skip to the end of an MRI comment field. */
1025 mri_comment_end (stop
, stopc
)
1031 input_line_pointer
= stop
;
1033 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1034 ++input_line_pointer
;
1041 as_fatal (".abort detected. Abandoning ship.");
1044 /* Guts of .align directive. */
1046 do_align (n
, fill
, len
)
1052 md_do_align (n
, fill
, len
, just_record_alignment
);
1056 /* @@ Fix this right for BFD! */
1058 static char nop_opcode
= NOP_OPCODE
;
1060 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1071 /* Only make a frag if we HAVE to. . . */
1072 if (n
&& !need_pass_2
)
1075 frag_align (n
, *fill
);
1077 frag_align_pattern (n
, fill
, len
);
1081 just_record_alignment
:
1084 record_alignment (now_seg
, n
);
1087 /* For machines where ".align 4" means align to a 4 byte boundary. */
1092 register unsigned int temp
;
1095 unsigned long max_alignment
= 1 << 15;
1100 stop
= mri_comment_field (&stopc
);
1102 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1103 temp
= arg
; /* Default value from pseudo-op table */
1105 temp
= get_absolute_expression ();
1107 if (temp
> max_alignment
)
1109 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1112 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1113 have to convert it. */
1116 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1120 as_bad ("Alignment not a power of 2");
1123 if (*input_line_pointer
== ',')
1127 input_line_pointer
++;
1128 fillval
= get_absolute_expression ();
1133 temp_fill
= fillval
;
1134 do_align (temp
, &temp_fill
, arg
);
1140 if (arg
> sizeof ab
)
1142 md_number_to_chars (ab
, fillval
, arg
);
1143 do_align (temp
, ab
, arg
);
1149 as_warn ("expected fill pattern missing");
1150 do_align (temp
, (char *) NULL
, 0);
1154 mri_comment_end (stop
, stopc
);
1156 demand_empty_rest_of_line ();
1159 /* For machines where ".align 4" means align to 2**4 boundary. */
1166 long max_alignment
= 15;
1171 stop
= mri_comment_field (&stopc
);
1173 temp
= get_absolute_expression ();
1174 if (temp
> max_alignment
)
1175 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1178 as_bad ("Alignment negative. 0 assumed.");
1181 if (*input_line_pointer
== ',')
1185 input_line_pointer
++;
1186 fillval
= get_absolute_expression ();
1191 temp_fill
= fillval
;
1192 do_align (temp
, &temp_fill
, arg
);
1198 if (arg
> sizeof ab
)
1200 md_number_to_chars (ab
, fillval
, arg
);
1201 do_align (temp
, ab
, arg
);
1207 as_warn ("expected fill pattern missing");
1208 do_align (temp
, (char *) NULL
, 0);
1212 mri_comment_end (stop
, stopc
);
1214 demand_empty_rest_of_line ();
1221 register char *name
;
1225 register symbolS
*symbolP
;
1230 stop
= mri_comment_field (&stopc
);
1232 name
= input_line_pointer
;
1233 c
= get_symbol_end ();
1234 /* just after name is now '\0' */
1235 p
= input_line_pointer
;
1238 if (*input_line_pointer
!= ',')
1240 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1242 mri_comment_end (stop
, stopc
);
1243 ignore_rest_of_line ();
1246 input_line_pointer
++; /* skip ',' */
1247 if ((temp
= get_absolute_expression ()) < 0)
1249 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1251 mri_comment_end (stop
, stopc
);
1252 ignore_rest_of_line ();
1256 symbolP
= symbol_find_or_make (name
);
1258 if (S_IS_DEFINED (symbolP
))
1260 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1261 S_GET_NAME (symbolP
));
1263 mri_comment_end (stop
, stopc
);
1264 ignore_rest_of_line ();
1267 if (S_GET_VALUE (symbolP
))
1269 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1270 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1271 S_GET_NAME (symbolP
),
1272 (long) S_GET_VALUE (symbolP
),
1277 S_SET_VALUE (symbolP
, (valueT
) temp
);
1278 S_SET_EXTERNAL (symbolP
);
1282 extern int flag_one
;
1283 if ( (!temp
) || !flag_one
)
1284 S_GET_OTHER(symbolP
) = const_flag
;
1286 #endif /* not OBJ_VMS */
1287 know (symbolP
->sy_frag
== &zero_address_frag
);
1290 mri_comment_end (stop
, stopc
);
1292 demand_empty_rest_of_line ();
1295 /* The MRI COMMON pseudo-op. We handle this by creating a common
1296 symbol with the appropriate name. We make s_space do the right
1297 thing by increasing the size. */
1300 s_mri_common (small
)
1317 stop
= mri_comment_field (&stopc
);
1321 name
= input_line_pointer
;
1322 if (! isdigit ((unsigned char) *name
))
1323 c
= get_symbol_end ();
1328 ++input_line_pointer
;
1330 while (isdigit ((unsigned char) *input_line_pointer
));
1331 c
= *input_line_pointer
;
1332 *input_line_pointer
= '\0';
1334 if (line_label
!= NULL
)
1336 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1337 + (input_line_pointer
- name
)
1339 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1344 sym
= symbol_find_or_make (name
);
1345 *input_line_pointer
= c
;
1349 if (*input_line_pointer
!= ',')
1353 ++input_line_pointer
;
1354 align
= get_absolute_expression ();
1357 if (S_IS_DEFINED (sym
))
1359 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1360 if (! S_IS_COMMON (sym
))
1363 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1364 mri_comment_end (stop
, stopc
);
1365 ignore_rest_of_line ();
1370 S_SET_EXTERNAL (sym
);
1371 mri_common_symbol
= sym
;
1375 S_SET_ALIGN (sym
, align
);
1378 if (line_label
!= NULL
)
1380 line_label
->sy_value
.X_op
= O_symbol
;
1381 line_label
->sy_value
.X_add_symbol
= sym
;
1382 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1383 line_label
->sy_frag
= &zero_address_frag
;
1384 S_SET_SEGMENT (line_label
, expr_section
);
1387 /* FIXME: We just ignore the small argument, which distinguishes
1388 COMMON and COMMON.S. I don't know what we can do about it. */
1390 /* Ignore the type and hptype. */
1391 if (*input_line_pointer
== ',')
1392 input_line_pointer
+= 2;
1393 if (*input_line_pointer
== ',')
1394 input_line_pointer
+= 2;
1396 mri_comment_end (stop
, stopc
);
1398 demand_empty_rest_of_line ();
1408 temp
= get_absolute_expression ();
1409 if (flag_readonly_data_in_text
)
1411 section
= text_section
;
1415 section
= data_section
;
1417 subseg_set (section
, (subsegT
) temp
);
1422 demand_empty_rest_of_line ();
1425 /* Handle the .appfile pseudo-op. This is automatically generated by
1426 do_scrub_chars when a preprocessor # line comment is seen with a
1427 file name. This default definition may be overridden by the object
1428 or CPU specific pseudo-ops. This function is also the default
1429 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1433 s_app_file (appfile
)
1439 /* Some assemblers tolerate immediately following '"' */
1440 if ((s
= demand_copy_string (&length
)) != 0)
1442 /* If this is a fake .appfile, a fake newline was inserted into
1443 the buffer. Passing -2 to new_logical_line tells it to
1445 new_logical_line (s
, appfile
? -2 : -1);
1447 /* In MRI mode, the preprocessor may have inserted an extraneous
1450 && *input_line_pointer
== '\''
1451 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1452 ++input_line_pointer
;
1454 demand_empty_rest_of_line ();
1457 listing_source_file (s
);
1465 /* Handle the .appline pseudo-op. This is automatically generated by
1466 do_scrub_chars when a preprocessor # line comment is seen. This
1467 default definition may be overridden by the object or CPU specific
1476 /* The given number is that of the next line. */
1477 l
= get_absolute_expression () - 1;
1479 /* Some of the back ends can't deal with non-positive line numbers.
1480 Besides, it's silly. */
1481 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1484 new_logical_line ((char *) NULL
, l
);
1487 listing_source_line (l
);
1490 demand_empty_rest_of_line ();
1493 /* Handle the .end pseudo-op. Actually, the real work is done in
1494 read_a_source_file. */
1502 /* The MRI assembler permits the start symbol to follow .end,
1503 but we don't support that. */
1505 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1506 && *input_line_pointer
!= '*'
1507 && *input_line_pointer
!= '!')
1508 as_warn ("start address not supported");
1512 /* Handle the .err pseudo-op. */
1518 as_bad (".err encountered");
1519 demand_empty_rest_of_line ();
1522 /* Handle the MRI fail pseudo-op. */
1533 stop
= mri_comment_field (&stopc
);
1535 temp
= get_absolute_expression ();
1537 as_warn (".fail %ld encountered", (long) temp
);
1539 as_bad (".fail %ld encountered", (long) temp
);
1542 mri_comment_end (stop
, stopc
);
1544 demand_empty_rest_of_line ();
1551 long temp_repeat
= 0;
1553 register long temp_fill
= 0;
1556 #ifdef md_flush_pending_output
1557 md_flush_pending_output ();
1560 temp_repeat
= get_absolute_expression ();
1561 if (*input_line_pointer
== ',')
1563 input_line_pointer
++;
1564 temp_size
= get_absolute_expression ();
1565 if (*input_line_pointer
== ',')
1567 input_line_pointer
++;
1568 temp_fill
= get_absolute_expression ();
1571 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1572 #define BSD_FILL_SIZE_CROCK_8 (8)
1573 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1575 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1576 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1580 as_warn ("Size negative: .fill ignored.");
1583 else if (temp_repeat
<= 0)
1585 as_warn ("Repeat < 0, .fill ignored");
1589 if (temp_size
&& !need_pass_2
)
1591 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1592 memset (p
, 0, (unsigned int) temp_size
);
1593 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1594 * flavoured AS. The following bizzare behaviour is to be
1595 * compatible with above. I guess they tried to take up to 8
1596 * bytes from a 4-byte expression and they forgot to sign
1597 * extend. Un*x Sux. */
1598 #define BSD_FILL_SIZE_CROCK_4 (4)
1599 md_number_to_chars (p
, (valueT
) temp_fill
,
1600 (temp_size
> BSD_FILL_SIZE_CROCK_4
1601 ? BSD_FILL_SIZE_CROCK_4
1602 : (int) temp_size
));
1603 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1604 * but emits no error message because it seems a legal thing to do.
1605 * It is a degenerate case of .fill but could be emitted by a compiler.
1608 demand_empty_rest_of_line ();
1622 stop
= mri_comment_field (&stopc
);
1626 name
= input_line_pointer
;
1627 c
= get_symbol_end ();
1628 symbolP
= symbol_find_or_make (name
);
1629 *input_line_pointer
= c
;
1631 S_SET_EXTERNAL (symbolP
);
1634 input_line_pointer
++;
1636 if (*input_line_pointer
== '\n')
1643 mri_comment_end (stop
, stopc
);
1645 demand_empty_rest_of_line ();
1648 /* Handle the MRI IRP and IRPC pseudo-ops. */
1660 as_where (&file
, &line
);
1663 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1664 sb_add_char (&s
, *input_line_pointer
++);
1668 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1670 as_bad_where (file
, line
, "%s", err
);
1674 input_scrub_include_sb (&out
, input_line_pointer
);
1676 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1680 s_lcomm (needs_align
)
1681 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1682 (alignment); 0 if it was an ".lcomm" (2 args only) */
1685 register char *name
;
1689 register symbolS
*symbolP
;
1690 segT current_seg
= now_seg
;
1691 subsegT current_subseg
= now_subseg
;
1692 const int max_alignment
= 15;
1694 segT bss_seg
= bss_section
;
1696 name
= input_line_pointer
;
1697 c
= get_symbol_end ();
1698 p
= input_line_pointer
;
1702 /* Accept an optional comma after the name. The comma used to be
1703 required, but Irix 5 cc does not generate it. */
1704 if (*input_line_pointer
== ',')
1706 ++input_line_pointer
;
1710 if (*input_line_pointer
== '\n')
1712 as_bad ("Missing size expression");
1716 if ((temp
= get_absolute_expression ()) < 0)
1718 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1719 ignore_rest_of_line ();
1723 #if defined (TC_MIPS) || defined (TC_ALPHA)
1724 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1725 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1727 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1728 if (temp
<= bfd_get_gp_size (stdoutput
))
1730 bss_seg
= subseg_new (".sbss", 1);
1731 seg_info (bss_seg
)->bss
= 1;
1737 /* FIXME. This needs to be machine independent. */
1747 record_alignment(bss_seg
, align
);
1754 if (*input_line_pointer
!= ',')
1756 as_bad ("Expected comma after size");
1757 ignore_rest_of_line ();
1760 input_line_pointer
++;
1762 if (*input_line_pointer
== '\n')
1764 as_bad ("Missing alignment");
1767 align
= get_absolute_expression ();
1768 if (align
> max_alignment
)
1770 align
= max_alignment
;
1771 as_warn ("Alignment too large: %d. assumed.", align
);
1776 as_warn ("Alignment negative. 0 assumed.");
1778 record_alignment (bss_seg
, align
);
1779 } /* if needs align */
1782 /* Assume some objects may require alignment on some systems. */
1786 align
= ffs (temp
) - 1;
1787 if (temp
% (1 << align
))
1794 symbolP
= symbol_find_or_make (name
);
1798 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1799 S_GET_OTHER (symbolP
) == 0 &&
1800 S_GET_DESC (symbolP
) == 0 &&
1801 #endif /* OBJ_AOUT or OBJ_BOUT */
1802 (S_GET_SEGMENT (symbolP
) == bss_seg
1803 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1807 subseg_set (bss_seg
, 1);
1810 frag_align (align
, 0);
1811 /* detach from old frag */
1812 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1813 symbolP
->sy_frag
->fr_symbol
= NULL
;
1815 symbolP
->sy_frag
= frag_now
;
1816 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1820 S_SET_SEGMENT (symbolP
, bss_seg
);
1823 /* The symbol may already have been created with a preceding
1824 ".globl" directive -- be careful not to step on storage class
1825 in that case. Otherwise, set it to static. */
1826 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1828 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1830 #endif /* OBJ_COFF */
1833 S_SET_SIZE (symbolP
, temp
);
1837 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1838 S_GET_NAME (symbolP
));
1840 subseg_set (current_seg
, current_subseg
);
1842 demand_empty_rest_of_line ();
1849 register char *name
;
1853 register symbolS
*symbolP
;
1855 /* we permit ANY defined expression: BSD4.2 demands constants */
1856 name
= input_line_pointer
;
1857 c
= get_symbol_end ();
1858 p
= input_line_pointer
;
1861 if (*input_line_pointer
!= ',')
1864 as_bad ("Expected comma after name \"%s\"", name
);
1866 ignore_rest_of_line ();
1869 input_line_pointer
++;
1871 if (exp
.X_op
!= O_constant
1872 && exp
.X_op
!= O_register
)
1874 as_bad ("bad expression");
1875 ignore_rest_of_line ();
1879 symbolP
= symbol_find_or_make (name
);
1881 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1882 symbolP->sy_desc == 0) out of this test because coff doesn't have
1883 those fields, and I can't see when they'd ever be tripped. I
1884 don't think I understand why they were here so I may have
1885 introduced a bug. As recently as 1.37 didn't have this test
1886 anyway. xoxorich. */
1888 if (S_GET_SEGMENT (symbolP
) == undefined_section
1889 && S_GET_VALUE (symbolP
) == 0)
1891 /* The name might be an undefined .global symbol; be sure to
1892 keep the "external" bit. */
1893 S_SET_SEGMENT (symbolP
,
1894 (exp
.X_op
== O_constant
1897 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
1901 as_bad ("Symbol %s already defined", name
);
1904 demand_empty_rest_of_line ();
1907 /* Read a line into an sb. */
1913 if (input_line_pointer
>= buffer_limit
)
1915 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1916 if (buffer_limit
== 0)
1920 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1921 sb_add_char (line
, *input_line_pointer
++);
1922 while (input_line_pointer
< buffer_limit
1923 && is_end_of_line
[(unsigned char) *input_line_pointer
])
1925 if (*input_line_pointer
== '\n')
1927 bump_line_counters ();
1930 ++input_line_pointer
;
1935 /* Define a macro. This is an interface to macro.c, which is shared
1936 between gas and gasp. */
1948 as_where (&file
, &line
);
1951 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1952 sb_add_char (&s
, *input_line_pointer
++);
1955 if (line_label
!= NULL
)
1956 sb_add_string (&label
, S_GET_NAME (line_label
));
1958 demand_empty_rest_of_line ();
1960 err
= define_macro (0, &s
, &label
, get_line_sb
);
1962 as_bad_where (file
, line
, "%s", err
);
1965 if (line_label
!= NULL
)
1967 S_SET_SEGMENT (line_label
, undefined_section
);
1968 S_SET_VALUE (line_label
, 0);
1969 line_label
->sy_frag
= &zero_address_frag
;
1976 /* Handle the .mexit pseudo-op, which immediately exits a macro
1983 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1986 /* Handle changing the location counter. */
1989 do_org (segment
, exp
, fill
)
1994 if (segment
!= now_seg
&& segment
!= absolute_section
)
1995 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
1996 segment_name (segment
), segment_name (now_seg
));
1998 if (now_seg
== absolute_section
)
2001 as_warn ("ignoring fill value in absolute section");
2002 if (exp
->X_op
!= O_constant
)
2004 as_bad ("only constant offsets supported in absolute section");
2005 exp
->X_add_number
= 0;
2007 abs_section_offset
= exp
->X_add_number
;
2013 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2014 exp
->X_add_number
, (char *) NULL
);
2023 register segT segment
;
2025 register long temp_fill
;
2027 /* The m68k MRI assembler has a different meaning for .org. It
2028 means to create an absolute section at a given address. We can't
2029 support that--use a linker script instead. */
2032 as_bad ("MRI style ORG pseudo-op not supported");
2033 ignore_rest_of_line ();
2037 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2038 thing as a sub-segment-relative origin. Any absolute origin is
2039 given a warning, then assumed to be segment-relative. Any
2040 segmented origin expression ("foo+42") had better be in the right
2041 segment or the .org is ignored.
2043 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2044 we never know sub-segment sizes when we are reading code. BSD
2045 will crash trying to emit negative numbers of filler bytes in
2046 certain .orgs. We don't crash, but see as-write for that code.
2048 Don't make frag if need_pass_2==1. */
2049 segment
= get_known_segmented_expression (&exp
);
2050 if (*input_line_pointer
== ',')
2052 input_line_pointer
++;
2053 temp_fill
= get_absolute_expression ();
2059 do_org (segment
, &exp
, temp_fill
);
2061 demand_empty_rest_of_line ();
2064 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2065 called by the obj-format routine which handles section changing
2066 when in MRI mode. It will create a new section, and return it. It
2067 will set *TYPE to the section type: one of '\0' (unspecified), 'C'
2068 (code), 'D' (data), 'M' (mixed), or 'R' (romable). If
2069 BFD_ASSEMBLER is defined, the flags will be set in the section. */
2083 name
= input_line_pointer
;
2084 if (! isdigit ((unsigned char) *name
))
2085 c
= get_symbol_end ();
2090 ++input_line_pointer
;
2092 while (isdigit ((unsigned char) *input_line_pointer
));
2093 c
= *input_line_pointer
;
2094 *input_line_pointer
= '\0';
2097 name
= strdup (name
);
2099 as_fatal ("virtual memory exhausted");
2101 *input_line_pointer
= c
;
2103 seg
= subseg_new (name
, 0);
2105 if (*input_line_pointer
== ',')
2109 ++input_line_pointer
;
2110 align
= get_absolute_expression ();
2111 record_alignment (seg
, align
);
2115 if (*input_line_pointer
== ',')
2117 c
= *++input_line_pointer
;
2118 c
= toupper ((unsigned char) c
);
2119 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2122 as_bad ("unrecognized section type");
2123 ++input_line_pointer
;
2125 #ifdef BFD_ASSEMBLER
2129 flags
= SEC_NO_FLAGS
;
2132 else if (*type
== 'D')
2134 else if (*type
== 'R')
2136 if (flags
!= SEC_NO_FLAGS
)
2138 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2139 as_warn ("error setting flags for \"%s\": %s",
2140 bfd_section_name (stdoutput
, seg
),
2141 bfd_errmsg (bfd_get_error ()));
2147 /* Ignore the HP type. */
2148 if (*input_line_pointer
== ',')
2149 input_line_pointer
+= 2;
2151 demand_empty_rest_of_line ();
2153 #else /* ! TC_M68K */
2162 name
= input_line_pointer
;
2163 c
= get_symbol_end ();
2165 name
= strdup (name
);
2167 as_fatal ("virtual memory exhausted");
2169 *input_line_pointer
= c
;
2171 seg
= subseg_new (name
, 0);
2173 if (*input_line_pointer
!= ',')
2179 ++input_line_pointer
;
2181 sectype
= input_line_pointer
;
2182 c
= get_symbol_end ();
2183 if (*sectype
== '\0')
2185 else if (strcasecmp (sectype
, "text") == 0)
2187 else if (strcasecmp (sectype
, "data") == 0)
2189 else if (strcasecmp (sectype
, "romdata") == 0)
2192 as_warn ("unrecognized section type `%s'", sectype
);
2193 *input_line_pointer
= c
;
2196 if (*input_line_pointer
== ',')
2200 ++input_line_pointer
;
2202 seccmd
= input_line_pointer
;
2203 c
= get_symbol_end ();
2204 if (strcasecmp (seccmd
, "absolute") == 0)
2206 as_bad ("absolute sections are not supported");
2207 *input_line_pointer
= c
;
2208 ignore_rest_of_line ();
2211 else if (strcasecmp (seccmd
, "align") == 0)
2215 *input_line_pointer
= c
;
2216 align
= get_absolute_expression ();
2217 record_alignment (seg
, align
);
2221 as_warn ("unrecognized section command `%s'", seccmd
);
2222 *input_line_pointer
= c
;
2226 demand_empty_rest_of_line ();
2228 #else /* ! TC_I960 */
2229 /* The MRI assembler seems to use different forms of .sect for
2230 different targets. */
2232 #endif /* ! TC_I960 */
2233 #endif /* ! TC_M68K */
2236 /* Handle the .print pseudo-op. */
2245 s
= demand_copy_C_string (&len
);
2247 demand_empty_rest_of_line ();
2250 /* Handle the .purgem pseudo-op. */
2256 if (is_it_end_of_statement ())
2258 demand_empty_rest_of_line ();
2268 name
= input_line_pointer
;
2269 c
= get_symbol_end ();
2270 delete_macro (name
);
2271 *input_line_pointer
= c
;
2274 while (*input_line_pointer
++ == ',');
2276 --input_line_pointer
;
2277 demand_empty_rest_of_line ();
2280 /* Handle the .rept pseudo-op. */
2290 count
= get_absolute_expression ();
2293 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2295 as_bad ("rept without endr");
2301 sb_add_sb (&many
, &one
);
2305 input_scrub_include_sb (&many
, input_line_pointer
);
2307 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2314 register char *name
;
2315 register char delim
;
2316 register char *end_name
;
2317 register symbolS
*symbolP
;
2320 * Especial apologies for the random logic:
2321 * this just grew, and could be parsed much more simply!
2324 name
= input_line_pointer
;
2325 delim
= get_symbol_end ();
2326 end_name
= input_line_pointer
;
2330 if (*input_line_pointer
!= ',')
2333 as_bad ("Expected comma after name \"%s\"", name
);
2335 ignore_rest_of_line ();
2339 input_line_pointer
++;
2342 if (name
[0] == '.' && name
[1] == '\0')
2344 /* Turn '. = mumble' into a .org mumble */
2345 register segT segment
;
2348 segment
= get_known_segmented_expression (&exp
);
2351 do_org (segment
, &exp
, 0);
2357 if ((symbolP
= symbol_find (name
)) == NULL
2358 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2360 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2362 /* "set" symbols are local unless otherwise specified. */
2363 SF_SET_LOCAL (symbolP
);
2364 #endif /* OBJ_COFF */
2366 } /* make a new symbol */
2368 symbol_table_insert (symbolP
);
2371 pseudo_set (symbolP
);
2372 demand_empty_rest_of_line ();
2385 #ifdef md_flush_pending_output
2386 md_flush_pending_output ();
2390 stop
= mri_comment_field (&stopc
);
2392 /* Just like .fill, but temp_size = 1 */
2394 if (exp
.X_op
== O_constant
)
2398 repeat
= exp
.X_add_number
;
2403 if (! flag_mri
|| repeat
< 0)
2404 as_warn (".space repeat count is %s, ignored",
2405 repeat
? "negative" : "zero");
2409 /* If we are in the absolute section, just bump the offset. */
2410 if (now_seg
== absolute_section
)
2412 abs_section_offset
+= repeat
;
2416 /* If we are secretly in an MRI common section, then creating
2417 space just increases the size of the common symbol. */
2418 if (mri_common_symbol
!= NULL
)
2420 S_SET_VALUE (mri_common_symbol
,
2421 S_GET_VALUE (mri_common_symbol
) + repeat
);
2426 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2427 repeat
, (char *) 0);
2431 if (now_seg
== absolute_section
)
2433 as_bad ("space allocation too complex in absolute section");
2434 subseg_set (text_section
, 0);
2436 if (mri_common_symbol
!= NULL
)
2438 as_bad ("space allocation too complex in common section");
2439 mri_common_symbol
= NULL
;
2442 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2443 make_expr_symbol (&exp
), 0L, (char *) 0);
2446 if (*input_line_pointer
== ',')
2448 input_line_pointer
++;
2449 temp_fill
= get_absolute_expression ();
2462 mri_comment_end (stop
, stopc
);
2464 demand_empty_rest_of_line ();
2467 /* This is like s_space, but the value is a floating point number with
2468 the given precision. This is for the MRI dcb.s pseudo-op and
2472 s_float_space (float_type
)
2477 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2482 stop
= mri_comment_field (&stopc
);
2484 count
= get_absolute_expression ();
2487 if (*input_line_pointer
!= ',')
2489 as_bad ("missing value");
2491 mri_comment_end (stop
, stopc
);
2492 ignore_rest_of_line ();
2496 ++input_line_pointer
;
2500 /* Skip any 0{letter} that may be present. Don't even check if the
2501 * letter is legal. */
2502 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2503 input_line_pointer
+= 2;
2505 /* Accept :xxxx, where the x's are hex digits, for a floating point
2506 with the exact digits specified. */
2507 if (input_line_pointer
[0] == ':')
2509 flen
= hex_float (float_type
, temp
);
2513 mri_comment_end (stop
, stopc
);
2514 ignore_rest_of_line ();
2522 err
= md_atof (float_type
, temp
, &flen
);
2523 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2527 as_bad ("Bad floating literal: %s", err
);
2529 mri_comment_end (stop
, stopc
);
2530 ignore_rest_of_line ();
2535 while (--count
>= 0)
2539 p
= frag_more (flen
);
2540 memcpy (p
, temp
, (unsigned int) flen
);
2544 mri_comment_end (stop
, stopc
);
2546 demand_empty_rest_of_line ();
2549 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2559 stop
= mri_comment_field (&stopc
);
2560 abs_section_offset
= get_absolute_expression ();
2561 subseg_set (absolute_section
, 0);
2563 mri_comment_end (stop
, stopc
);
2564 demand_empty_rest_of_line ();
2573 temp
= get_absolute_expression ();
2574 subseg_set (text_section
, (subsegT
) temp
);
2575 demand_empty_rest_of_line ();
2577 const_flag
&= ~IN_DEFAULT_SECTION
;
2583 demand_empty_rest_of_line ()
2586 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2588 input_line_pointer
++;
2592 ignore_rest_of_line ();
2594 /* Return having already swallowed end-of-line. */
2595 } /* Return pointing just after end-of-line. */
2598 ignore_rest_of_line () /* For suspect lines: gives warning. */
2600 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2602 if (isprint (*input_line_pointer
))
2603 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2604 *input_line_pointer
);
2606 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2607 *input_line_pointer
);
2608 while (input_line_pointer
< buffer_limit
2609 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2611 input_line_pointer
++;
2614 input_line_pointer
++; /* Return pointing just after end-of-line. */
2615 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2621 * In: Pointer to a symbol.
2622 * Input_line_pointer->expression.
2624 * Out: Input_line_pointer->just after any whitespace after expression.
2625 * Tried to set symbol to value of expression.
2626 * Will change symbols type, value, and frag;
2629 pseudo_set (symbolP
)
2633 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2635 #endif /* OBJ_AOUT or OBJ_BOUT */
2637 know (symbolP
); /* NULL pointer is logic error. */
2638 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2639 ext
= S_IS_EXTERNAL (symbolP
);
2640 #endif /* OBJ_AOUT or OBJ_BOUT */
2642 (void) expression (&exp
);
2644 if (exp
.X_op
== O_illegal
)
2645 as_bad ("illegal expression; zero assumed");
2646 else if (exp
.X_op
== O_absent
)
2647 as_bad ("missing expression; zero assumed");
2648 else if (exp
.X_op
== O_big
)
2649 as_bad ("%s number invalid; zero assumed",
2650 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2651 else if (exp
.X_op
== O_subtract
2652 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2653 == S_GET_SEGMENT (exp
.X_op_symbol
))
2654 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2655 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2657 exp
.X_op
= O_constant
;
2658 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2659 - S_GET_VALUE (exp
.X_op_symbol
));
2667 exp
.X_add_number
= 0;
2670 S_SET_SEGMENT (symbolP
, absolute_section
);
2671 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2673 S_SET_EXTERNAL (symbolP
);
2675 S_CLEAR_EXTERNAL (symbolP
);
2676 #endif /* OBJ_AOUT or OBJ_BOUT */
2677 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2678 symbolP
->sy_frag
= &zero_address_frag
;
2682 S_SET_SEGMENT (symbolP
, reg_section
);
2683 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2684 symbolP
->sy_frag
= &zero_address_frag
;
2688 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2689 || exp
.X_add_number
!= 0)
2690 symbolP
->sy_value
= exp
;
2693 symbolS
*s
= exp
.X_add_symbol
;
2695 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2696 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2698 S_SET_EXTERNAL (symbolP
);
2700 S_CLEAR_EXTERNAL (symbolP
);
2701 #endif /* OBJ_AOUT or OBJ_BOUT */
2702 S_SET_VALUE (symbolP
,
2703 exp
.X_add_number
+ S_GET_VALUE (s
));
2704 symbolP
->sy_frag
= s
->sy_frag
;
2705 copy_symbol_attributes (symbolP
, s
);
2710 /* The value is some complex expression.
2711 FIXME: Should we set the segment to anything? */
2712 symbolP
->sy_value
= exp
;
2720 * CONStruct more frag of .bytes, or .words etc.
2721 * Should need_pass_2 be 1 then emit no frag(s).
2722 * This understands EXPRESSIONS.
2726 * This has a split personality. We use expression() to read the
2727 * value. We can detect if the value won't fit in a byte or word.
2728 * But we can't detect if expression() discarded significant digits
2729 * in the case of a long. Not worth the crocks required to fix it.
2732 /* Select a parser for cons expressions. */
2734 /* Some targets need to parse the expression in various fancy ways.
2735 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2736 (for example, the HPPA does this). Otherwise, you can define
2737 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2738 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2739 are defined, which is the normal case, then only simple expressions
2743 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2745 #ifndef TC_PARSE_CONS_EXPRESSION
2746 #ifdef BITFIELD_CONS_EXPRESSIONS
2747 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2749 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2751 #ifdef REPEAT_CONS_EXPRESSIONS
2752 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2754 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2757 /* If we haven't gotten one yet, just call expression. */
2758 #ifndef TC_PARSE_CONS_EXPRESSION
2759 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2763 /* worker to do .byte etc statements */
2764 /* clobbers input_line_pointer, checks */
2767 cons_worker (nbytes
, rva
)
2768 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
2776 #ifdef md_flush_pending_output
2777 md_flush_pending_output ();
2781 stop
= mri_comment_field (&stopc
);
2783 if (is_it_end_of_statement ())
2786 mri_comment_end (stop
, stopc
);
2787 demand_empty_rest_of_line ();
2795 parse_mri_cons (&exp
, (unsigned int) nbytes
);
2797 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
2801 if (exp
.X_op
== O_symbol
)
2802 exp
.X_op
= O_symbol_rva
;
2804 as_fatal ("rva without symbol");
2806 emit_expr (&exp
, (unsigned int) nbytes
);
2809 while (*input_line_pointer
++ == ',');
2811 /* In MRI mode, after an odd number of bytes, we must align to an
2812 even word boundary, unless the next instruction is a dc.b, ds.b
2814 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
2815 mri_pending_align
= 1;
2817 input_line_pointer
--; /* Put terminator back into stream. */
2820 mri_comment_end (stop
, stopc
);
2822 demand_empty_rest_of_line ();
2830 cons_worker (size
, 0);
2837 cons_worker (size
, 1);
2841 /* Put the contents of expression EXP into the object file using
2842 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
2845 emit_expr (exp
, nbytes
)
2847 unsigned int nbytes
;
2851 valueT extra_digit
= 0;
2853 /* Don't do anything if we are going to make another pass. */
2859 /* Allow `.word 0' in the absolute section. */
2860 if (now_seg
== absolute_section
)
2862 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
2863 as_bad ("attempt to store value in absolute section");
2864 abs_section_offset
+= nbytes
;
2868 /* Handle a negative bignum. */
2870 && exp
->X_add_number
== 0
2871 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
2872 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
2875 unsigned long carry
;
2877 exp
= &exp
->X_add_symbol
->sy_value
;
2879 /* Negate the bignum: one's complement each digit and add 1. */
2881 for (i
= 0; i
< exp
->X_add_number
; i
++)
2885 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
2888 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
2889 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
2892 /* We can ignore any carry out, because it will be handled by
2893 extra_digit if it is needed. */
2895 extra_digit
= (valueT
) -1;
2899 if (op
== O_absent
|| op
== O_illegal
)
2901 as_warn ("zero assumed for missing expression");
2902 exp
->X_add_number
= 0;
2905 else if (op
== O_big
&& exp
->X_add_number
<= 0)
2907 as_bad ("floating point number invalid; zero assumed");
2908 exp
->X_add_number
= 0;
2911 else if (op
== O_register
)
2913 as_warn ("register value used as expression");
2917 p
= frag_more ((int) nbytes
);
2919 #ifndef WORKING_DOT_WORD
2920 /* If we have the difference of two symbols in a word, save it on
2921 the broken_words list. See the code in write.c. */
2922 if (op
== O_subtract
&& nbytes
== 2)
2924 struct broken_word
*x
;
2926 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
2927 x
->next_broken_word
= broken_words
;
2930 x
->word_goes_here
= p
;
2932 x
->add
= exp
->X_add_symbol
;
2933 x
->sub
= exp
->X_op_symbol
;
2934 x
->addnum
= exp
->X_add_number
;
2941 /* If we have an integer, but the number of bytes is too large to
2942 pass to md_number_to_chars, handle it as a bignum. */
2943 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
2948 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
2949 extra_digit
= (valueT
) -1;
2950 val
= (valueT
) exp
->X_add_number
;
2954 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
2955 val
>>= LITTLENUM_NUMBER_OF_BITS
;
2959 op
= exp
->X_op
= O_big
;
2960 exp
->X_add_number
= gencnt
;
2963 if (op
== O_constant
)
2965 register valueT get
;
2966 register valueT use
;
2967 register valueT mask
;
2968 register valueT unmask
;
2970 /* JF << of >= number of bits in the object is undefined. In
2971 particular SPARC (Sun 4) has problems */
2972 if (nbytes
>= sizeof (valueT
))
2975 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
2977 unmask
= ~mask
; /* Do store these bits. */
2980 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
2981 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
2984 get
= exp
->X_add_number
;
2986 if ((get
& mask
) != 0 && (get
& mask
) != mask
)
2987 { /* Leading bits contain both 0s & 1s. */
2988 as_warn ("Value 0x%lx truncated to 0x%lx.", get
, use
);
2990 /* put bytes in right order. */
2991 md_number_to_chars (p
, use
, (int) nbytes
);
2993 else if (op
== O_big
)
2996 LITTLENUM_TYPE
*nums
;
2998 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3000 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3003 as_warn ("Bignum truncated to %d bytes", nbytes
);
3007 if (target_big_endian
)
3009 while (nbytes
> size
)
3011 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3012 nbytes
-= CHARS_PER_LITTLENUM
;
3013 p
+= CHARS_PER_LITTLENUM
;
3016 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3020 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3021 size
-= CHARS_PER_LITTLENUM
;
3022 p
+= CHARS_PER_LITTLENUM
;
3027 nums
= generic_bignum
;
3030 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3032 size
-= CHARS_PER_LITTLENUM
;
3033 p
+= CHARS_PER_LITTLENUM
;
3034 nbytes
-= CHARS_PER_LITTLENUM
;
3039 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3040 nbytes
-= CHARS_PER_LITTLENUM
;
3041 p
+= CHARS_PER_LITTLENUM
;
3047 memset (p
, 0, nbytes
);
3049 /* Now we need to generate a fixS to record the symbol value.
3050 This is easy for BFD. For other targets it can be more
3051 complex. For very complex cases (currently, the HPPA and
3052 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3053 want. For simpler cases, you can define TC_CONS_RELOC to be
3054 the name of the reloc code that should be stored in the fixS.
3055 If neither is defined, the code uses NO_RELOC if it is
3056 defined, and otherwise uses 0. */
3058 #ifdef BFD_ASSEMBLER
3059 #ifdef TC_CONS_FIX_NEW
3060 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3062 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3063 /* @@ Should look at CPU word size. */
3064 nbytes
== 2 ? BFD_RELOC_16
3065 : nbytes
== 8 ? BFD_RELOC_64
3069 #ifdef TC_CONS_FIX_NEW
3070 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3072 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3073 it is defined, otherwise use NO_RELOC if it is defined,
3075 #ifndef TC_CONS_RELOC
3077 #define TC_CONS_RELOC NO_RELOC
3079 #define TC_CONS_RELOC 0
3082 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3084 #endif /* TC_CONS_FIX_NEW */
3085 #endif /* BFD_ASSEMBLER */
3089 #ifdef BITFIELD_CONS_EXPRESSIONS
3091 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3092 w:x,y:z, where w and y are bitwidths and x and y are values. They
3093 then pack them all together. We do a little better in that we allow
3094 them in words, longs, etc. and we'll pack them in target byte order
3097 The rules are: pack least significat bit first, if a field doesn't
3098 entirely fit, put it in the next unit. Overflowing the bitfield is
3099 explicitly *not* even a warning. The bitwidth should be considered
3102 To use this function the tc-XXX.h file should define
3103 BITFIELD_CONS_EXPRESSIONS. */
3106 parse_bitfield_cons (exp
, nbytes
)
3108 unsigned int nbytes
;
3110 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3111 char *hold
= input_line_pointer
;
3113 (void) expression (exp
);
3115 if (*input_line_pointer
== ':')
3121 unsigned long width
;
3123 if (*input_line_pointer
!= ':')
3125 input_line_pointer
= hold
;
3127 } /* next piece is not a bitfield */
3129 /* In the general case, we can't allow
3130 full expressions with symbol
3131 differences and such. The relocation
3132 entries for symbols not defined in this
3133 assembly would require arbitrary field
3134 widths, positions, and masks which most
3135 of our current object formats don't
3138 In the specific case where a symbol
3139 *is* defined in this assembly, we
3140 *could* build fixups and track it, but
3141 this could lead to confusion for the
3142 backends. I'm lazy. I'll take any
3143 SEG_ABSOLUTE. I think that means that
3144 you can use a previous .set or
3145 .equ type symbol. xoxorich. */
3147 if (exp
->X_op
== O_absent
)
3149 as_warn ("using a bit field width of zero");
3150 exp
->X_add_number
= 0;
3151 exp
->X_op
= O_constant
;
3152 } /* implied zero width bitfield */
3154 if (exp
->X_op
!= O_constant
)
3156 *input_line_pointer
= '\0';
3157 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3158 *input_line_pointer
= ':';
3159 demand_empty_rest_of_line ();
3163 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3165 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3166 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3167 width
= BITS_PER_CHAR
* nbytes
;
3170 if (width
> bits_available
)
3172 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3173 input_line_pointer
= hold
;
3174 exp
->X_add_number
= value
;
3178 hold
= ++input_line_pointer
; /* skip ':' */
3180 (void) expression (exp
);
3181 if (exp
->X_op
!= O_constant
)
3183 char cache
= *input_line_pointer
;
3185 *input_line_pointer
= '\0';
3186 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3187 *input_line_pointer
= cache
;
3188 demand_empty_rest_of_line ();
3192 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3193 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3195 if ((bits_available
-= width
) == 0
3196 || is_it_end_of_statement ()
3197 || *input_line_pointer
!= ',')
3200 } /* all the bitfields we're gonna get */
3202 hold
= ++input_line_pointer
;
3203 (void) expression (exp
);
3204 } /* forever loop */
3206 exp
->X_add_number
= value
;
3207 exp
->X_op
= O_constant
;
3208 exp
->X_unsigned
= 1;
3209 } /* if looks like a bitfield */
3210 } /* parse_bitfield_cons() */
3212 #endif /* BITFIELD_CONS_EXPRESSIONS */
3214 /* Handle an MRI style string expression. */
3217 parse_mri_cons (exp
, nbytes
)
3219 unsigned int nbytes
;
3221 if (*input_line_pointer
!= '\''
3222 && (input_line_pointer
[1] != '\''
3223 || (*input_line_pointer
!= 'A'
3224 && *input_line_pointer
!= 'E')))
3225 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3229 unsigned int result
= 0;
3231 /* An MRI style string. Cut into as many bytes as will fit into
3232 a nbyte chunk, left justify if necessary, and separate with
3233 commas so we can try again later. */
3234 if (*input_line_pointer
== 'A')
3235 ++input_line_pointer
;
3236 else if (*input_line_pointer
== 'E')
3238 as_bad ("EBCDIC constants are not supported");
3239 ++input_line_pointer
;
3242 input_line_pointer
++;
3243 for (scan
= 0; scan
< nbytes
; scan
++)
3245 if (*input_line_pointer
== '\'')
3247 if (input_line_pointer
[1] == '\'')
3249 input_line_pointer
++;
3254 result
= (result
<< 8) | (*input_line_pointer
++);
3258 while (scan
< nbytes
)
3263 /* Create correct expression */
3264 exp
->X_op
= O_constant
;
3265 exp
->X_add_number
= result
;
3266 /* Fake it so that we can read the next char too */
3267 if (input_line_pointer
[0] != '\'' ||
3268 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3270 input_line_pointer
-= 2;
3271 input_line_pointer
[0] = ',';
3272 input_line_pointer
[1] = '\'';
3275 input_line_pointer
++;
3279 #ifdef REPEAT_CONS_EXPRESSIONS
3281 /* Parse a repeat expression for cons. This is used by the MIPS
3282 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3283 object file COUNT times.
3285 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3288 parse_repeat_cons (exp
, nbytes
)
3290 unsigned int nbytes
;
3297 if (*input_line_pointer
!= ':')
3299 /* No repeat count. */
3303 ++input_line_pointer
;
3304 expression (&count
);
3305 if (count
.X_op
!= O_constant
3306 || count
.X_add_number
<= 0)
3308 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3312 /* The cons function is going to output this expression once. So we
3313 output it count - 1 times. */
3314 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3315 emit_expr (exp
, nbytes
);
3318 #endif /* REPEAT_CONS_EXPRESSIONS */
3320 /* Parse a floating point number represented as a hex constant. This
3321 permits users to specify the exact bits they want in the floating
3325 hex_float (float_type
, bytes
)
3359 as_bad ("Unknown floating type type '%c'", float_type
);
3363 /* It would be nice if we could go through expression to parse the
3364 hex constant, but if we get a bignum it's a pain to sort it into
3365 the buffer correctly. */
3367 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3371 /* The MRI assembler accepts arbitrary underscores strewn about
3372 through the hex constant, so we ignore them as well. */
3373 if (*input_line_pointer
== '_')
3375 ++input_line_pointer
;
3381 as_warn ("Floating point constant too large");
3384 d
= hex_value (*input_line_pointer
) << 4;
3385 ++input_line_pointer
;
3386 while (*input_line_pointer
== '_')
3387 ++input_line_pointer
;
3388 if (hex_p (*input_line_pointer
))
3390 d
+= hex_value (*input_line_pointer
);
3391 ++input_line_pointer
;
3393 if (target_big_endian
)
3396 bytes
[length
- i
- 1] = d
;
3402 if (target_big_endian
)
3403 memset (bytes
+ i
, 0, length
- i
);
3405 memset (bytes
, 0, length
- i
);
3414 * CONStruct some more frag chars of .floats .ffloats etc.
3415 * Makes 0 or more new frags.
3416 * If need_pass_2 == 1, no frags are emitted.
3417 * This understands only floating literals, not expressions. Sorry.
3419 * A floating constant is defined by atof_generic(), except it is preceded
3420 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3421 * reading, I decided to be incompatible. This always tries to give you
3422 * rounded bits to the precision of the pseudo-op. Former AS did premature
3423 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3424 * a choice of 2 flavours of noise according to which of 2 floating-point
3425 * scanners you directed AS to use.
3427 * In: input_line_pointer->whitespace before, or '0' of flonum.
3432 float_cons (float_type
)
3433 /* Clobbers input_line-pointer, checks end-of-line. */
3434 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3437 int length
; /* Number of chars in an object. */
3438 register char *err
; /* Error from scanning floating literal. */
3439 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3441 if (is_it_end_of_statement ())
3443 demand_empty_rest_of_line ();
3449 /* input_line_pointer->1st char of a flonum (we hope!). */
3452 /* Skip any 0{letter} that may be present. Don't even check if the
3453 * letter is legal. Someone may invent a "z" format and this routine
3454 * has no use for such information. Lusers beware: you get
3455 * diagnostics if your input is ill-conditioned.
3457 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3458 input_line_pointer
+= 2;
3460 /* Accept :xxxx, where the x's are hex digits, for a floating
3461 point with the exact digits specified. */
3462 if (input_line_pointer
[0] == ':')
3464 ++input_line_pointer
;
3465 length
= hex_float (float_type
, temp
);
3468 ignore_rest_of_line ();
3474 err
= md_atof (float_type
, temp
, &length
);
3475 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3479 as_bad ("Bad floating literal: %s", err
);
3480 ignore_rest_of_line ();
3491 #ifdef REPEAT_CONS_EXPRESSIONS
3492 if (*input_line_pointer
== ':')
3494 expressionS count_exp
;
3496 ++input_line_pointer
;
3497 expression (&count_exp
);
3498 if (count_exp
.X_op
!= O_constant
3499 || count_exp
.X_add_number
<= 0)
3501 as_warn ("unresolvable or nonpositive repeat count; using 1");
3504 count
= count_exp
.X_add_number
;
3508 while (--count
>= 0)
3510 p
= frag_more (length
);
3511 memcpy (p
, temp
, (unsigned int) length
);
3516 while (*input_line_pointer
++ == ',');
3518 --input_line_pointer
; /* Put terminator back into stream. */
3519 demand_empty_rest_of_line ();
3520 } /* float_cons() */
3525 * We read 0 or more ',' seperated, double-quoted strings.
3527 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3532 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3533 /* Checks end-of-line. */
3534 register int append_zero
; /* 0: don't append '\0', else 1 */
3536 register unsigned int c
;
3538 #ifdef md_flush_pending_output
3539 md_flush_pending_output ();
3543 * The following awkward logic is to parse ZERO or more strings,
3544 * comma seperated. Recall a string expression includes spaces
3545 * before the opening '\"' and spaces after the closing '\"'.
3546 * We fake a leading ',' if there is (supposed to be)
3547 * a 1st, expression. We keep demanding expressions for each
3550 if (is_it_end_of_statement ())
3552 c
= 0; /* Skip loop. */
3553 ++input_line_pointer
; /* Compensate for end of loop. */
3557 c
= ','; /* Do loop. */
3559 while (c
== ',' || c
== '<' || c
== '"')
3562 switch (*input_line_pointer
)
3565 ++input_line_pointer
; /*->1st char of string. */
3566 while (is_a_char (c
= next_char_of_string ()))
3568 FRAG_APPEND_1_CHAR (c
);
3572 FRAG_APPEND_1_CHAR (0);
3574 know (input_line_pointer
[-1] == '\"');
3577 input_line_pointer
++;
3578 c
= get_single_number ();
3579 FRAG_APPEND_1_CHAR (c
);
3580 if (*input_line_pointer
!= '>')
3582 as_bad ("Expected <nn>");
3584 input_line_pointer
++;
3587 input_line_pointer
++;
3591 c
= *input_line_pointer
;
3594 demand_empty_rest_of_line ();
3597 /* FIXME-SOMEDAY: I had trouble here on characters with the
3598 high bits set. We'll probably also have trouble with
3599 multibyte chars, wide chars, etc. Also be careful about
3600 returning values bigger than 1 byte. xoxorich. */
3603 next_char_of_string ()
3605 register unsigned int c
;
3607 c
= *input_line_pointer
++ & CHAR_MASK
;
3614 #ifndef NO_STRING_ESCAPES
3616 switch (c
= *input_line_pointer
++)
3644 break; /* As itself. */
3660 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3662 number
= number
* 8 + c
- '0';
3666 --input_line_pointer
;
3675 c
= *input_line_pointer
++;
3676 while (isxdigit (c
))
3679 number
= number
* 16 + c
- '0';
3680 else if (isupper (c
))
3681 number
= number
* 16 + c
- 'A' + 10;
3683 number
= number
* 16 + c
- 'a' + 10;
3684 c
= *input_line_pointer
++;
3687 --input_line_pointer
;
3692 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3693 as_warn ("Unterminated string: Newline inserted.");
3699 #ifdef ONLY_STANDARD_ESCAPES
3700 as_bad ("Bad escaped character in string, '?' assumed");
3702 #endif /* ONLY_STANDARD_ESCAPES */
3705 } /* switch on escaped char */
3707 #endif /* ! defined (NO_STRING_ESCAPES) */
3711 } /* switch on char */
3713 } /* next_char_of_string() */
3716 get_segmented_expression (expP
)
3717 register expressionS
*expP
;
3719 register segT retval
;
3721 retval
= expression (expP
);
3722 if (expP
->X_op
== O_illegal
3723 || expP
->X_op
== O_absent
3724 || expP
->X_op
== O_big
)
3726 as_bad ("expected address expression; zero assumed");
3727 expP
->X_op
= O_constant
;
3728 expP
->X_add_number
= 0;
3729 retval
= absolute_section
;
3735 get_known_segmented_expression (expP
)
3736 register expressionS
*expP
;
3738 register segT retval
;
3740 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
3742 /* There is no easy way to extract the undefined symbol from the
3744 if (expP
->X_add_symbol
!= NULL
3745 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
3746 as_warn ("symbol \"%s\" undefined; zero assumed",
3747 S_GET_NAME (expP
->X_add_symbol
));
3749 as_warn ("some symbol undefined; zero assumed");
3750 retval
= absolute_section
;
3751 expP
->X_op
= O_constant
;
3752 expP
->X_add_number
= 0;
3754 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
3756 } /* get_known_segmented_expression() */
3759 get_absolute_expression ()
3764 if (exp
.X_op
!= O_constant
)
3766 if (exp
.X_op
!= O_absent
)
3767 as_bad ("bad or irreducible absolute expression; zero assumed");
3768 exp
.X_add_number
= 0;
3770 return exp
.X_add_number
;
3773 char /* return terminator */
3774 get_absolute_expression_and_terminator (val_pointer
)
3775 long *val_pointer
; /* return value of expression */
3777 /* FIXME: val_pointer should probably be offsetT *. */
3778 *val_pointer
= (long) get_absolute_expression ();
3779 return (*input_line_pointer
++);
3783 * demand_copy_C_string()
3785 * Like demand_copy_string, but return NULL if the string contains any '\0's.
3786 * Give a warning if that happens.
3789 demand_copy_C_string (len_pointer
)
3794 if ((s
= demand_copy_string (len_pointer
)) != 0)
3798 for (len
= *len_pointer
; len
> 0; len
--)
3805 as_bad ("This string may not contain \'\\0\'");
3813 * demand_copy_string()
3815 * Demand string, but return a safe (=private) copy of the string.
3816 * Return NULL if we can't read a string here.
3819 demand_copy_string (lenP
)
3822 register unsigned int c
;
3828 if (*input_line_pointer
== '\"')
3830 input_line_pointer
++; /* Skip opening quote. */
3832 while (is_a_char (c
= next_char_of_string ()))
3834 obstack_1grow (¬es
, c
);
3837 /* JF this next line is so demand_copy_C_string will return a
3838 null terminated string. */
3839 obstack_1grow (¬es
, '\0');
3840 retval
= obstack_finish (¬es
);
3844 as_warn ("Missing string");
3846 ignore_rest_of_line ();
3850 } /* demand_copy_string() */
3853 * is_it_end_of_statement()
3855 * In: Input_line_pointer->next character.
3857 * Do: Skip input_line_pointer over all whitespace.
3859 * Out: 1 if input_line_pointer->end-of-line.
3862 is_it_end_of_statement ()
3865 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
3866 } /* is_it_end_of_statement() */
3872 register symbolS
*symbolP
; /* symbol we are working with */
3876 input_line_pointer
++;
3877 if (*input_line_pointer
== '=')
3878 input_line_pointer
++;
3880 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
3881 input_line_pointer
++;
3884 stop
= mri_comment_field (&stopc
);
3886 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
3888 /* Turn '. = mumble' into a .org mumble */
3889 register segT segment
;
3892 segment
= get_known_segmented_expression (&exp
);
3894 do_org (segment
, &exp
, 0);
3898 symbolP
= symbol_find_or_make (sym_name
);
3899 pseudo_set (symbolP
);
3903 mri_comment_end (stop
, stopc
);
3906 /* .include -- include a file at this point. */
3919 if (! flag_m68k_mri
)
3920 filename
= demand_copy_string (&i
);
3925 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
3926 && *input_line_pointer
!= ' '
3927 && *input_line_pointer
!= '\t')
3929 obstack_1grow (¬es
, *input_line_pointer
);
3930 ++input_line_pointer
;
3933 obstack_1grow (¬es
, '\0');
3934 filename
= obstack_finish (¬es
);
3935 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3936 ++input_line_pointer
;
3938 demand_empty_rest_of_line ();
3939 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
3940 for (i
= 0; i
< include_dir_count
; i
++)
3942 strcpy (path
, include_dirs
[i
]);
3944 strcat (path
, filename
);
3945 if (0 != (try = fopen (path
, "r")))
3954 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
3955 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
3956 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3960 add_include_dir (path
)
3965 if (include_dir_count
== 0)
3967 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
3968 include_dirs
[0] = "."; /* Current dir */
3969 include_dir_count
= 2;
3973 include_dir_count
++;
3974 include_dirs
= (char **) realloc (include_dirs
,
3975 include_dir_count
* sizeof (*include_dirs
));
3978 include_dirs
[include_dir_count
- 1] = path
; /* New one */
3981 if (i
> include_dir_maxlen
)
3982 include_dir_maxlen
= i
;
3983 } /* add_include_dir() */
3989 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
3991 ++input_line_pointer
;
3993 ++input_line_pointer
;
3998 read_print_statistics (file
)
4001 hash_print_statistics (file
, "pseudo-op table", po_hash
);