1 /* read.c - read a source file -
2 Copyright (C) 1986, 1987, 1990, 1991, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
23 change this a bit. But then, GNU isn't
24 spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.)
28 #define MASK_CHAR ((int)(unsigned char)-1)
32 /* This is the largest known floating point format (for now). It will
33 grow when we do 4361 style flonums. */
35 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
37 /* Routines that read assembler source text to build spagetti in memory.
38 Another group of these functions is in the expr.c module. */
47 #include "libiberty.h"
51 #ifndef TC_START_LABEL
52 #define TC_START_LABEL(x,y) (x==':')
55 /* The NOP_OPCODE is for the alignment fill value.
56 * fill it a nop instruction so that the disassembler does not choke
60 #define NOP_OPCODE 0x00
63 char *input_line_pointer
; /*->next char of source file to parse. */
65 int generate_asm_lineno
= 0; /* flag to generate line stab for .s file */
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
74 /* The m88k unfortunately uses @ as a label beginner. */
79 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
84 /* The Delta 68k assembler permits % inside label names. */
89 /* The PowerPC Windows NT assemblers permits ? inside label names. */
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 *));
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},
252 {"common", s_mri_common
, 0},
253 {"common.s", s_mri_common
, 1},
257 {"dc.d", float_cons
, 'd'},
259 {"dc.s", float_cons
, 'f'},
261 {"dc.x", float_cons
, 'x'},
263 {"dcb.b", s_space
, 1},
264 {"dcb.d", s_float_space
, 'd'},
265 {"dcb.l", s_space
, 4},
266 {"dcb.s", s_float_space
, 'f'},
267 {"dcb.w", s_space
, 2},
268 {"dcb.x", s_float_space
, 'x'},
270 {"ds.b", s_space
, 1},
271 {"ds.d", s_space
, 8},
272 {"ds.l", s_space
, 4},
273 {"ds.p", s_space
, 12},
274 {"ds.s", s_space
, 4},
275 {"ds.w", s_space
, 2},
276 {"ds.x", s_space
, 12},
277 {"debug", s_ignore
, 0},
282 {"double", float_cons
, 'd'},
284 {"eject", listing_eject
, 0}, /* Formfeed listing */
286 {"elsec", s_else
, 0},
288 {"endc", s_endif
, 0},
289 {"endif", s_endif
, 0},
293 {"exitm", s_mexit
, 0},
295 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
296 {"appfile", s_app_file
, 1},
297 {"appline", s_app_line
, 0},
299 {"file", s_app_file
, 0},
301 {"float", float_cons
, 'f'},
302 {"format", s_ignore
, 0},
303 {"global", s_globl
, 0},
304 {"globl", s_globl
, 0},
306 {"if", s_if
, (int) O_ne
},
308 {"ifdef", s_ifdef
, 0},
309 {"ifeq", s_if
, (int) O_eq
},
310 {"ifeqs", s_ifeqs
, 0},
311 {"ifge", s_if
, (int) O_ge
},
312 {"ifgt", s_if
, (int) O_gt
},
313 {"ifle", s_if
, (int) O_le
},
314 {"iflt", s_if
, (int) O_lt
},
316 {"ifndef", s_ifdef
, 1},
317 {"ifne", s_if
, (int) O_ne
},
318 {"ifnes", s_ifeqs
, 1},
319 {"ifnotdef", s_ifdef
, 1},
320 {"include", s_include
, 0},
326 {"lcomm", s_lcomm
, 0},
327 {"lflags", listing_flags
, 0}, /* Listing flags */
328 {"list", listing_list
, 1}, /* Turn listing on */
329 {"llen", listing_psize
, 1},
332 {"macro", s_macro
, 0},
333 {"mexit", s_mexit
, 0},
334 {"noformat", s_ignore
, 0},
335 {"nolist", listing_list
, 0}, /* Turn listing off */
336 {"nopage", listing_nopage
, 0},
338 {"offset", s_struct
, 0},
340 {"p2align", s_align_ptwo
, 0},
341 {"page", listing_eject
, 0},
342 {"plen", listing_psize
, 0},
343 {"print", s_print
, 0},
344 {"psize", listing_psize
, 0}, /* set paper size */
345 {"purgem", s_purgem
, 0},
350 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
355 {"single", float_cons
, 'f'},
357 {"space", s_space
, 0},
358 {"spc", s_ignore
, 0},
359 {"stabd", s_stab
, 'd'},
360 {"stabn", s_stab
, 'n'},
361 {"stabs", s_stab
, 's'},
362 {"string", stringer
, 1},
363 {"struct", s_struct
, 0},
367 /* This is for gcc to use. It's only just been added (2/94), so gcc
368 won't be able to use it for a while -- probably a year or more.
369 But once this has been released, check with gcc maintainers
370 before deleting it or even changing the spelling. */
371 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
372 /* If we're folding case -- done for some targets, not necessarily
373 all -- the above string in an input file will be converted to
374 this one. Match it either way... */
375 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
377 {"title", listing_title
, 0}, /* Listing title */
378 {"ttl", listing_title
, 0},
383 {"xdef", s_globl
, 0},
384 {"xref", s_ignore
, 0},
385 {"xstabs", s_xstab
, 's'},
387 {"zero", s_space
, 0},
388 {NULL
} /* end sentinel */
391 static int pop_override_ok
= 0;
392 static const char *pop_table_name
;
396 const pseudo_typeS
*table
;
399 const pseudo_typeS
*pop
;
400 for (pop
= table
; pop
->poc_name
; pop
++)
402 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
403 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
404 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
409 #ifndef md_pop_insert
410 #define md_pop_insert() pop_insert(md_pseudo_table)
413 #ifndef obj_pop_insert
414 #define obj_pop_insert() pop_insert(obj_pseudo_table)
420 po_hash
= hash_new ();
422 /* Do the target-specific pseudo ops. */
423 pop_table_name
= "md";
426 /* Now object specific. Skip any that were in the target table. */
427 pop_table_name
= "obj";
431 /* Now portable ones. Skip any that we've seen already. */
432 pop_table_name
= "standard";
433 pop_insert (potable
);
436 #define HANDLE_CONDITIONAL_ASSEMBLY() \
437 if (ignore_input ()) \
439 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
440 if (input_line_pointer == buffer_limit) \
446 /* This function is used when scrubbing the characters between #APP
449 static char *scrub_string
;
450 static char *scrub_string_end
;
453 scrub_from_string (from
)
458 *from
= scrub_string
;
459 size
= scrub_string_end
- scrub_string
;
460 scrub_string
= scrub_string_end
;
464 /* read_a_source_file()
466 * We read the file, putting things into a web that
467 * represents what we have been reading.
470 read_a_source_file (name
)
474 register char *s
; /* string of symbol, '\0' appended */
478 buffer
= input_scrub_new_file (name
);
481 listing_newline ("");
483 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
484 { /* We have another line to parse. */
485 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
486 contin
: /* JF this goto is my fault I admit it.
487 Someone brave please re-write the whole
488 input section here? Pleeze??? */
489 while (input_line_pointer
< buffer_limit
)
491 /* We have more of this buffer to parse. */
494 * We now have input_line_pointer->1st char of next line.
495 * If input_line_pointer [-1] == '\n' then we just
496 * scanned another line: so bump line counters.
498 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
500 #ifdef md_start_line_hook
501 md_start_line_hook ();
504 if (input_line_pointer
[-1] == '\n')
505 bump_line_counters ();
510 #ifdef LABELS_WITHOUT_COLONS
515 /* Text at the start of a line must be a label, we
516 run down and stick a colon in. */
517 if (is_name_beginner (*input_line_pointer
))
519 char *line_start
= input_line_pointer
;
522 HANDLE_CONDITIONAL_ASSEMBLY ();
524 c
= get_symbol_end ();
526 /* In MRI mode, the EQU pseudoop must be
527 handled specially. */
530 char *rest
= input_line_pointer
+ 1;
534 if (*rest
== ' ' || *rest
== '\t')
536 if ((strncasecmp (rest
, "EQU", 3) == 0
537 || strncasecmp (rest
, "SET", 3) == 0)
538 && (rest
[3] == ' ' || rest
[3] == '\t'))
540 input_line_pointer
= rest
+ 3;
546 line_label
= colon (line_start
);
548 *input_line_pointer
= c
;
550 input_line_pointer
++;
556 * We are at the begining of a line, or similar place.
557 * We expect a well-formed assembler statement.
558 * A "symbol-name:" is a statement.
560 * Depending on what compiler is used, the order of these tests
561 * may vary to catch most common case 1st.
562 * Each test is independent of all other tests at the (top) level.
563 * PLEASE make a compiler that doesn't use this assembler.
564 * It is crufty to waste a compiler's time encoding things for this
565 * assembler, which then wastes more time decoding it.
566 * (And communicating via (linear) files is silly!
567 * If you must pass stuff, please pass a tree!)
569 if ((c
= *input_line_pointer
++) == '\t'
574 c
= *input_line_pointer
++;
576 know (c
!= ' '); /* No further leading whitespace. */
579 * C is the 1st significant character.
580 * Input_line_pointer points after that character.
582 if (is_name_beginner (c
))
584 /* want user-defined label or pseudo/opcode */
585 HANDLE_CONDITIONAL_ASSEMBLY ();
587 s
= --input_line_pointer
;
588 c
= get_symbol_end (); /* name's delimiter */
590 * C is character after symbol.
591 * That character's place in the input line is now '\0'.
592 * S points to the beginning of the symbol.
593 * [In case of pseudo-op, s->'.'.]
594 * Input_line_pointer->'\0' where c was.
596 if (TC_START_LABEL(c
, input_line_pointer
))
600 char *rest
= input_line_pointer
+ 1;
602 /* In MRI mode, \tsym: set 0 is permitted. */
606 if (*rest
== ' ' || *rest
== '\t')
608 if ((strncasecmp (rest
, "EQU", 3) == 0
609 || strncasecmp (rest
, "SET", 3) == 0)
610 && (rest
[3] == ' ' || rest
[3] == '\t'))
612 input_line_pointer
= rest
+ 3;
618 line_label
= colon (s
); /* user-defined label */
619 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
620 /* Input_line_pointer->after ':'. */
626 || (input_line_pointer
[1] == '='
627 #ifdef TC_EQUAL_IN_INSN
628 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
633 demand_empty_rest_of_line ();
636 { /* expect pseudo-op or machine instruction */
639 #define IGNORE_OPCODE_CASE
640 #ifdef IGNORE_OPCODE_CASE
652 #ifndef MRI_MODE_NEEDS_PSEUDO_DOT
653 #define MRI_MODE_NEEDS_PSEUDO_DOT 0
656 if ((flag_mri
&& ! MRI_MODE_NEEDS_PSEUDO_DOT
)
662 /* The MRI assembler and the m88k use pseudo-ops
664 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
665 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
670 || ((! flag_mri
|| MRI_MODE_NEEDS_PSEUDO_DOT
)
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
);
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
);
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_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 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
945 input_line_pointer
--; /* Report unknown char as ignored. */
946 ignore_rest_of_line ();
947 } /* while (input_line_pointer<buffer_limit) */
949 #ifdef md_after_pass_hook
950 md_after_pass_hook ();
956 bump_line_counters ();
960 input_line_pointer
= old_input
;
961 buffer_limit
= old_limit
;
966 } /* while (more buffers to scan) */
969 input_scrub_close (); /* Close the input file */
972 /* For most MRI pseudo-ops, the line actually ends at the first
973 nonquoted space. This function looks for that point, stuffs a null
974 in, and sets *STOPCP to the character that used to be there, and
975 returns the location.
977 Until I hear otherwise, I am going to assume that this is only true
978 for the m68k MRI assembler. */
981 mri_comment_field (stopcp
)
991 for (s
= input_line_pointer
;
992 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1007 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1017 /* Skip to the end of an MRI comment field. */
1020 mri_comment_end (stop
, stopc
)
1026 input_line_pointer
= stop
;
1028 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1029 ++input_line_pointer
;
1036 as_fatal (".abort detected. Abandoning ship.");
1039 /* Guts of .align directive. */
1046 md_do_align (n
, fill
, just_record_alignment
);
1050 /* @@ Fix this right for BFD! */
1052 static char nop_opcode
= NOP_OPCODE
;
1054 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1063 /* Only make a frag if we HAVE to. . . */
1064 if (n
&& !need_pass_2
)
1065 frag_align (n
, *fill
);
1068 just_record_alignment
:
1071 record_alignment (now_seg
, n
);
1074 /* For machines where ".align 4" means align to a 4 byte boundary. */
1079 register unsigned int temp
;
1082 unsigned long max_alignment
= 1 << 15;
1087 stop
= mri_comment_field (&stopc
);
1089 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1090 temp
= arg
; /* Default value from pseudo-op table */
1092 temp
= get_absolute_expression ();
1094 if (temp
> max_alignment
)
1096 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1099 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1100 have to convert it. */
1103 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1107 as_bad ("Alignment not a power of 2");
1110 if (*input_line_pointer
== ',')
1112 input_line_pointer
++;
1113 temp_fill
= get_absolute_expression ();
1114 do_align (temp
, &temp_fill
);
1117 do_align (temp
, (char *) 0);
1120 mri_comment_end (stop
, stopc
);
1122 demand_empty_rest_of_line ();
1125 /* For machines where ".align 4" means align to 2**4 boundary. */
1127 s_align_ptwo (ignore
)
1132 long max_alignment
= 15;
1137 stop
= mri_comment_field (&stopc
);
1139 temp
= get_absolute_expression ();
1140 if (temp
> max_alignment
)
1141 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1144 as_bad ("Alignment negative. 0 assumed.");
1147 if (*input_line_pointer
== ',')
1149 input_line_pointer
++;
1150 temp_fill
= get_absolute_expression ();
1151 do_align (temp
, &temp_fill
);
1154 do_align (temp
, (char *) 0);
1157 mri_comment_end (stop
, stopc
);
1159 demand_empty_rest_of_line ();
1166 register char *name
;
1170 register symbolS
*symbolP
;
1175 stop
= mri_comment_field (&stopc
);
1177 name
= input_line_pointer
;
1178 c
= get_symbol_end ();
1179 /* just after name is now '\0' */
1180 p
= input_line_pointer
;
1183 if (*input_line_pointer
!= ',')
1185 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1187 mri_comment_end (stop
, stopc
);
1188 ignore_rest_of_line ();
1191 input_line_pointer
++; /* skip ',' */
1192 if ((temp
= get_absolute_expression ()) < 0)
1194 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1196 mri_comment_end (stop
, stopc
);
1197 ignore_rest_of_line ();
1201 symbolP
= symbol_find_or_make (name
);
1203 if (S_IS_DEFINED (symbolP
))
1205 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1206 S_GET_NAME (symbolP
));
1208 mri_comment_end (stop
, stopc
);
1209 ignore_rest_of_line ();
1212 if (S_GET_VALUE (symbolP
))
1214 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1215 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1216 S_GET_NAME (symbolP
),
1217 (long) S_GET_VALUE (symbolP
),
1222 S_SET_VALUE (symbolP
, (valueT
) temp
);
1223 S_SET_EXTERNAL (symbolP
);
1227 extern int flag_one
;
1228 if ( (!temp
) || !flag_one
)
1229 S_GET_OTHER(symbolP
) = const_flag
;
1231 #endif /* not OBJ_VMS */
1232 know (symbolP
->sy_frag
== &zero_address_frag
);
1235 mri_comment_end (stop
, stopc
);
1237 demand_empty_rest_of_line ();
1240 /* The MRI COMMON pseudo-op. We handle this by creating a common
1241 symbol with the appropriate name. We make s_space do the right
1242 thing by increasing the size. */
1245 s_mri_common (small
)
1262 stop
= mri_comment_field (&stopc
);
1266 name
= input_line_pointer
;
1267 if (! isdigit ((unsigned char) *name
))
1268 c
= get_symbol_end ();
1273 ++input_line_pointer
;
1275 while (isdigit ((unsigned char) *input_line_pointer
));
1276 c
= *input_line_pointer
;
1277 *input_line_pointer
= '\0';
1279 if (line_label
!= NULL
)
1281 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1282 + (input_line_pointer
- name
)
1284 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1289 sym
= symbol_find_or_make (name
);
1290 *input_line_pointer
= c
;
1294 if (*input_line_pointer
!= ',')
1298 ++input_line_pointer
;
1299 align
= get_absolute_expression ();
1302 if (S_IS_DEFINED (sym
))
1304 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1305 if (! S_IS_COMMON (sym
))
1308 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1309 mri_comment_end (stop
, stopc
);
1310 ignore_rest_of_line ();
1315 S_SET_EXTERNAL (sym
);
1316 mri_common_symbol
= sym
;
1320 S_SET_ALIGN (sym
, align
);
1323 if (line_label
!= NULL
)
1325 line_label
->sy_value
.X_op
= O_symbol
;
1326 line_label
->sy_value
.X_add_symbol
= sym
;
1327 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1328 line_label
->sy_frag
= &zero_address_frag
;
1329 S_SET_SEGMENT (line_label
, expr_section
);
1332 /* FIXME: We just ignore the small argument, which distinguishes
1333 COMMON and COMMON.S. I don't know what we can do about it. */
1335 /* Ignore the type and hptype. */
1336 if (*input_line_pointer
== ',')
1337 input_line_pointer
+= 2;
1338 if (*input_line_pointer
== ',')
1339 input_line_pointer
+= 2;
1341 mri_comment_end (stop
, stopc
);
1343 demand_empty_rest_of_line ();
1353 temp
= get_absolute_expression ();
1354 if (flag_readonly_data_in_text
)
1356 section
= text_section
;
1360 section
= data_section
;
1362 subseg_set (section
, (subsegT
) temp
);
1367 demand_empty_rest_of_line ();
1370 /* Handle the .appfile pseudo-op. This is automatically generated by
1371 do_scrub_chars when a preprocessor # line comment is seen with a
1372 file name. This default definition may be overridden by the object
1373 or CPU specific pseudo-ops. This function is also the default
1374 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1378 s_app_file (appfile
)
1384 /* Some assemblers tolerate immediately following '"' */
1385 if ((s
= demand_copy_string (&length
)) != 0)
1387 /* If this is a fake .appfile, a fake newline was inserted into
1388 the buffer. Passing -2 to new_logical_line tells it to
1390 new_logical_line (s
, appfile
? -2 : -1);
1391 demand_empty_rest_of_line ();
1394 listing_source_file (s
);
1402 /* Handle the .appline pseudo-op. This is automatically generated by
1403 do_scrub_chars when a preprocessor # line comment is seen. This
1404 default definition may be overridden by the object or CPU specific
1413 /* The given number is that of the next line. */
1414 l
= get_absolute_expression () - 1;
1416 /* Some of the back ends can't deal with non-positive line numbers.
1417 Besides, it's silly. */
1418 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1421 new_logical_line ((char *) NULL
, l
);
1424 listing_source_line (l
);
1427 demand_empty_rest_of_line ();
1430 /* Handle the .end pseudo-op. Actually, the real work is done in
1431 read_a_source_file. */
1439 /* The MRI assembler permits the start symbol to follow .end,
1440 but we don't support that. */
1442 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1443 && *input_line_pointer
!= '*'
1444 && *input_line_pointer
!= '!')
1445 as_warn ("start address not supported");
1449 /* Handle the .err pseudo-op. */
1455 as_bad (".err encountered");
1456 demand_empty_rest_of_line ();
1459 /* Handle the MRI fail pseudo-op. */
1470 stop
= mri_comment_field (&stopc
);
1472 temp
= get_absolute_expression ();
1474 as_warn (".fail %ld encountered", (long) temp
);
1476 as_bad (".fail %ld encountered", (long) temp
);
1479 mri_comment_end (stop
, stopc
);
1481 demand_empty_rest_of_line ();
1488 long temp_repeat
= 0;
1490 register long temp_fill
= 0;
1493 #ifdef md_flush_pending_output
1494 md_flush_pending_output ();
1497 temp_repeat
= get_absolute_expression ();
1498 if (*input_line_pointer
== ',')
1500 input_line_pointer
++;
1501 temp_size
= get_absolute_expression ();
1502 if (*input_line_pointer
== ',')
1504 input_line_pointer
++;
1505 temp_fill
= get_absolute_expression ();
1508 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1509 #define BSD_FILL_SIZE_CROCK_8 (8)
1510 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1512 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1513 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1517 as_warn ("Size negative: .fill ignored.");
1520 else if (temp_repeat
<= 0)
1522 as_warn ("Repeat < 0, .fill ignored");
1526 if (temp_size
&& !need_pass_2
)
1528 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1529 memset (p
, 0, (unsigned int) temp_size
);
1530 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1531 * flavoured AS. The following bizzare behaviour is to be
1532 * compatible with above. I guess they tried to take up to 8
1533 * bytes from a 4-byte expression and they forgot to sign
1534 * extend. Un*x Sux. */
1535 #define BSD_FILL_SIZE_CROCK_4 (4)
1536 md_number_to_chars (p
, (valueT
) temp_fill
,
1537 (temp_size
> BSD_FILL_SIZE_CROCK_4
1538 ? BSD_FILL_SIZE_CROCK_4
1539 : (int) temp_size
));
1540 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1541 * but emits no error message because it seems a legal thing to do.
1542 * It is a degenerate case of .fill but could be emitted by a compiler.
1545 demand_empty_rest_of_line ();
1559 stop
= mri_comment_field (&stopc
);
1563 name
= input_line_pointer
;
1564 c
= get_symbol_end ();
1565 symbolP
= symbol_find_or_make (name
);
1566 *input_line_pointer
= c
;
1568 S_SET_EXTERNAL (symbolP
);
1571 input_line_pointer
++;
1573 if (*input_line_pointer
== '\n')
1580 mri_comment_end (stop
, stopc
);
1582 demand_empty_rest_of_line ();
1585 /* Handle the MRI IRP and IRPC pseudo-ops. */
1597 as_where (&file
, &line
);
1600 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1601 sb_add_char (&s
, *input_line_pointer
++);
1605 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1607 as_bad_where (file
, line
, "%s", err
);
1611 input_scrub_include_sb (&out
, input_line_pointer
);
1613 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1617 s_lcomm (needs_align
)
1618 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1619 (alignment); 0 if it was an ".lcomm" (2 args only) */
1622 register char *name
;
1626 register symbolS
*symbolP
;
1627 segT current_seg
= now_seg
;
1628 subsegT current_subseg
= now_subseg
;
1629 const int max_alignment
= 15;
1631 segT bss_seg
= bss_section
;
1633 name
= input_line_pointer
;
1634 c
= get_symbol_end ();
1635 p
= input_line_pointer
;
1639 /* Accept an optional comma after the name. The comma used to be
1640 required, but Irix 5 cc does not generate it. */
1641 if (*input_line_pointer
== ',')
1643 ++input_line_pointer
;
1647 if (*input_line_pointer
== '\n')
1649 as_bad ("Missing size expression");
1653 if ((temp
= get_absolute_expression ()) < 0)
1655 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1656 ignore_rest_of_line ();
1660 #if defined (TC_MIPS) || defined (TC_ALPHA)
1661 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1662 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1664 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1665 if (temp
<= bfd_get_gp_size (stdoutput
))
1667 bss_seg
= subseg_new (".sbss", 1);
1668 seg_info (bss_seg
)->bss
= 1;
1674 /* FIXME. This needs to be machine independent. */
1684 record_alignment(bss_seg
, align
);
1691 if (*input_line_pointer
!= ',')
1693 as_bad ("Expected comma after size");
1694 ignore_rest_of_line ();
1697 input_line_pointer
++;
1699 if (*input_line_pointer
== '\n')
1701 as_bad ("Missing alignment");
1704 align
= get_absolute_expression ();
1705 if (align
> max_alignment
)
1707 align
= max_alignment
;
1708 as_warn ("Alignment too large: %d. assumed.", align
);
1713 as_warn ("Alignment negative. 0 assumed.");
1715 record_alignment (bss_seg
, align
);
1716 } /* if needs align */
1719 /* Assume some objects may require alignment on some systems. */
1723 align
= ffs (temp
) - 1;
1724 if (temp
% (1 << align
))
1731 symbolP
= symbol_find_or_make (name
);
1735 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1736 S_GET_OTHER (symbolP
) == 0 &&
1737 S_GET_DESC (symbolP
) == 0 &&
1738 #endif /* OBJ_AOUT or OBJ_BOUT */
1739 (S_GET_SEGMENT (symbolP
) == bss_seg
1740 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1744 subseg_set (bss_seg
, 1);
1747 frag_align (align
, 0);
1748 /* detach from old frag */
1749 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1750 symbolP
->sy_frag
->fr_symbol
= NULL
;
1752 symbolP
->sy_frag
= frag_now
;
1753 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1757 S_SET_SEGMENT (symbolP
, bss_seg
);
1760 /* The symbol may already have been created with a preceding
1761 ".globl" directive -- be careful not to step on storage class
1762 in that case. Otherwise, set it to static. */
1763 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1765 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1767 #endif /* OBJ_COFF */
1770 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1771 S_GET_NAME (symbolP
));
1773 subseg_set (current_seg
, current_subseg
);
1775 demand_empty_rest_of_line ();
1782 register char *name
;
1786 register symbolS
*symbolP
;
1788 /* we permit ANY defined expression: BSD4.2 demands constants */
1789 name
= input_line_pointer
;
1790 c
= get_symbol_end ();
1791 p
= input_line_pointer
;
1794 if (*input_line_pointer
!= ',')
1797 as_bad ("Expected comma after name \"%s\"", name
);
1799 ignore_rest_of_line ();
1802 input_line_pointer
++;
1804 if (exp
.X_op
!= O_constant
1805 && exp
.X_op
!= O_register
)
1807 as_bad ("bad expression");
1808 ignore_rest_of_line ();
1812 symbolP
= symbol_find_or_make (name
);
1814 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1815 symbolP->sy_desc == 0) out of this test because coff doesn't have
1816 those fields, and I can't see when they'd ever be tripped. I
1817 don't think I understand why they were here so I may have
1818 introduced a bug. As recently as 1.37 didn't have this test
1819 anyway. xoxorich. */
1821 if (S_GET_SEGMENT (symbolP
) == undefined_section
1822 && S_GET_VALUE (symbolP
) == 0)
1824 /* The name might be an undefined .global symbol; be sure to
1825 keep the "external" bit. */
1826 S_SET_SEGMENT (symbolP
,
1827 (exp
.X_op
== O_constant
1830 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
1834 as_bad ("Symbol %s already defined", name
);
1837 demand_empty_rest_of_line ();
1840 /* Read a line into an sb. */
1846 if (input_line_pointer
>= buffer_limit
)
1848 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1849 if (buffer_limit
== 0)
1853 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1854 sb_add_char (line
, *input_line_pointer
++);
1855 while (input_line_pointer
< buffer_limit
1856 && is_end_of_line
[(unsigned char) *input_line_pointer
])
1858 if (*input_line_pointer
== '\n')
1860 bump_line_counters ();
1863 ++input_line_pointer
;
1868 /* Define a macro. This is an interface to macro.c, which is shared
1869 between gas and gasp. */
1881 as_where (&file
, &line
);
1884 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1885 sb_add_char (&s
, *input_line_pointer
++);
1888 if (line_label
!= NULL
)
1889 sb_add_string (&label
, S_GET_NAME (line_label
));
1891 demand_empty_rest_of_line ();
1893 err
= define_macro (0, &s
, &label
, get_line_sb
);
1895 as_bad_where (file
, line
, "%s", err
);
1898 if (line_label
!= NULL
)
1900 S_SET_SEGMENT (line_label
, undefined_section
);
1901 S_SET_VALUE (line_label
, 0);
1902 line_label
->sy_frag
= &zero_address_frag
;
1909 /* Handle the .mexit pseudo-op, which immediately exits a macro
1916 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1919 /* Handle changing the location counter. */
1922 do_org (segment
, exp
, fill
)
1927 if (segment
!= now_seg
&& segment
!= absolute_section
)
1928 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
1929 segment_name (segment
), segment_name (now_seg
));
1931 if (now_seg
== absolute_section
)
1934 as_warn ("ignoring fill value in absolute section");
1935 if (exp
->X_op
!= O_constant
)
1937 as_bad ("only constant offsets supported in absolute section");
1938 exp
->X_add_number
= 0;
1940 abs_section_offset
= exp
->X_add_number
;
1946 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
1947 exp
->X_add_number
, (char *) NULL
);
1956 register segT segment
;
1958 register long temp_fill
;
1961 /* The m68k MRI assembler has a different meaning for .org. It
1962 means to create an absolute section at a given address. We can't
1963 support that--use a linker script instead. */
1966 as_bad ("MRI style ORG pseudo-op not supported");
1967 ignore_rest_of_line ();
1972 /* Don't believe the documentation of BSD 4.2 AS. There is no such
1973 thing as a sub-segment-relative origin. Any absolute origin is
1974 given a warning, then assumed to be segment-relative. Any
1975 segmented origin expression ("foo+42") had better be in the right
1976 segment or the .org is ignored.
1978 BSD 4.2 AS warns if you try to .org backwards. We cannot because
1979 we never know sub-segment sizes when we are reading code. BSD
1980 will crash trying to emit negative numbers of filler bytes in
1981 certain .orgs. We don't crash, but see as-write for that code.
1983 Don't make frag if need_pass_2==1. */
1984 segment
= get_known_segmented_expression (&exp
);
1985 if (*input_line_pointer
== ',')
1987 input_line_pointer
++;
1988 temp_fill
= get_absolute_expression ();
1994 do_org (segment
, &exp
, temp_fill
);
1996 demand_empty_rest_of_line ();
1999 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2000 called by the obj-format routine which handles section changing
2001 when in MRI mode. It will create a new section, and return it. It
2002 will set *TYPE to the section type: one of '\0' (unspecified), 'C'
2003 (code), 'D' (data), 'M' (mixed), or 'R' (romable). If
2004 BFD_ASSEMBLER is defined, the flags will be set in the section. */
2018 name
= input_line_pointer
;
2019 if (! isdigit ((unsigned char) *name
))
2020 c
= get_symbol_end ();
2025 ++input_line_pointer
;
2027 while (isdigit ((unsigned char) *input_line_pointer
));
2028 c
= *input_line_pointer
;
2029 *input_line_pointer
= '\0';
2032 name
= strdup (name
);
2034 as_fatal ("virtual memory exhausted");
2036 *input_line_pointer
= c
;
2038 seg
= subseg_new (name
, 0);
2040 if (*input_line_pointer
== ',')
2044 ++input_line_pointer
;
2045 align
= get_absolute_expression ();
2046 record_alignment (seg
, align
);
2050 if (*input_line_pointer
== ',')
2052 c
= *++input_line_pointer
;
2053 c
= toupper ((unsigned char) c
);
2054 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2057 as_bad ("unrecognized section type");
2058 ++input_line_pointer
;
2060 #ifdef BFD_ASSEMBLER
2064 flags
= SEC_NO_FLAGS
;
2067 else if (*type
== 'D')
2069 else if (*type
== 'R')
2071 if (flags
!= SEC_NO_FLAGS
)
2073 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2074 as_warn ("error setting flags for \"%s\": %s",
2075 bfd_section_name (stdoutput
, seg
),
2076 bfd_errmsg (bfd_get_error ()));
2082 /* Ignore the HP type. */
2083 if (*input_line_pointer
== ',')
2084 input_line_pointer
+= 2;
2086 demand_empty_rest_of_line ();
2088 #else /* ! TC_M68K */
2097 name
= input_line_pointer
;
2098 c
= get_symbol_end ();
2100 name
= strdup (name
);
2102 as_fatal ("virtual memory exhausted");
2104 *input_line_pointer
= c
;
2106 seg
= subseg_new (name
, 0);
2108 if (*input_line_pointer
!= ',')
2114 ++input_line_pointer
;
2116 sectype
= input_line_pointer
;
2117 c
= get_symbol_end ();
2118 if (*sectype
== '\0')
2120 else if (strcasecmp (sectype
, "text") == 0)
2122 else if (strcasecmp (sectype
, "data") == 0)
2124 else if (strcasecmp (sectype
, "romdata") == 0)
2127 as_warn ("unrecognized section type `%s'", sectype
);
2128 *input_line_pointer
= c
;
2131 if (*input_line_pointer
== ',')
2135 ++input_line_pointer
;
2137 seccmd
= input_line_pointer
;
2138 c
= get_symbol_end ();
2139 if (strcasecmp (seccmd
, "absolute") == 0)
2141 as_bad ("absolute sections are not supported");
2142 *input_line_pointer
= c
;
2143 ignore_rest_of_line ();
2146 else if (strcasecmp (seccmd
, "align") == 0)
2150 *input_line_pointer
= c
;
2151 align
= get_absolute_expression ();
2152 record_alignment (seg
, align
);
2156 as_warn ("unrecognized section command `%s'", seccmd
);
2157 *input_line_pointer
= c
;
2161 demand_empty_rest_of_line ();
2163 #else /* ! TC_I960 */
2164 /* The MRI assembler seems to use different forms of .sect for
2165 different targets. */
2167 #endif /* ! TC_I960 */
2168 #endif /* ! TC_M68K */
2171 /* Handle the .print pseudo-op. */
2180 s
= demand_copy_C_string (&len
);
2182 demand_empty_rest_of_line ();
2185 /* Handle the .purgem pseudo-op. */
2191 if (is_it_end_of_statement ())
2193 demand_empty_rest_of_line ();
2203 name
= input_line_pointer
;
2204 c
= get_symbol_end ();
2205 delete_macro (name
);
2206 *input_line_pointer
= c
;
2209 while (*input_line_pointer
++ == ',');
2211 --input_line_pointer
;
2212 demand_empty_rest_of_line ();
2215 /* Handle the .rept pseudo-op. */
2225 count
= get_absolute_expression ();
2228 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2230 as_bad ("rept without endr");
2236 sb_add_sb (&many
, &one
);
2240 input_scrub_include_sb (&many
, input_line_pointer
);
2242 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2249 register char *name
;
2250 register char delim
;
2251 register char *end_name
;
2252 register symbolS
*symbolP
;
2255 * Especial apologies for the random logic:
2256 * this just grew, and could be parsed much more simply!
2259 name
= input_line_pointer
;
2260 delim
= get_symbol_end ();
2261 end_name
= input_line_pointer
;
2265 if (*input_line_pointer
!= ',')
2268 as_bad ("Expected comma after name \"%s\"", name
);
2270 ignore_rest_of_line ();
2274 input_line_pointer
++;
2277 if (name
[0] == '.' && name
[1] == '\0')
2279 /* Turn '. = mumble' into a .org mumble */
2280 register segT segment
;
2283 segment
= get_known_segmented_expression (&exp
);
2286 do_org (segment
, &exp
, 0);
2292 if ((symbolP
= symbol_find (name
)) == NULL
2293 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2295 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2297 /* "set" symbols are local unless otherwise specified. */
2298 SF_SET_LOCAL (symbolP
);
2299 #endif /* OBJ_COFF */
2301 } /* make a new symbol */
2303 symbol_table_insert (symbolP
);
2306 pseudo_set (symbolP
);
2307 demand_empty_rest_of_line ();
2320 #ifdef md_flush_pending_output
2321 md_flush_pending_output ();
2325 stop
= mri_comment_field (&stopc
);
2327 /* Just like .fill, but temp_size = 1 */
2329 if (exp
.X_op
== O_constant
)
2333 repeat
= exp
.X_add_number
;
2338 if (! flag_mri
|| repeat
< 0)
2339 as_warn (".space repeat count is %s, ignored",
2340 repeat
? "negative" : "zero");
2344 /* If we are in the absolute section, just bump the offset. */
2345 if (now_seg
== absolute_section
)
2347 abs_section_offset
+= repeat
;
2351 /* If we are secretly in an MRI common section, then creating
2352 space just increases the size of the common symbol. */
2353 if (mri_common_symbol
!= NULL
)
2355 S_SET_VALUE (mri_common_symbol
,
2356 S_GET_VALUE (mri_common_symbol
) + repeat
);
2361 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2362 repeat
, (char *) 0);
2366 if (now_seg
== absolute_section
)
2368 as_bad ("space allocation too complex in absolute section");
2369 subseg_set (text_section
, 0);
2371 if (mri_common_symbol
!= NULL
)
2373 as_bad ("space allocation too complex in common section");
2374 mri_common_symbol
= NULL
;
2377 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2378 make_expr_symbol (&exp
), 0L, (char *) 0);
2381 if (*input_line_pointer
== ',')
2383 input_line_pointer
++;
2384 temp_fill
= get_absolute_expression ();
2397 mri_comment_end (stop
, stopc
);
2399 demand_empty_rest_of_line ();
2402 /* This is like s_space, but the value is a floating point number with
2403 the given precision. This is for the MRI dcb.s pseudo-op and
2407 s_float_space (float_type
)
2412 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2417 stop
= mri_comment_field (&stopc
);
2419 count
= get_absolute_expression ();
2422 if (*input_line_pointer
!= ',')
2424 as_bad ("missing value");
2426 mri_comment_end (stop
, stopc
);
2427 ignore_rest_of_line ();
2431 ++input_line_pointer
;
2435 /* Skip any 0{letter} that may be present. Don't even check if the
2436 * letter is legal. */
2437 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2438 input_line_pointer
+= 2;
2440 /* Accept :xxxx, where the x's are hex digits, for a floating point
2441 with the exact digits specified. */
2442 if (input_line_pointer
[0] == ':')
2444 flen
= hex_float (float_type
, temp
);
2448 mri_comment_end (stop
, stopc
);
2449 ignore_rest_of_line ();
2457 err
= md_atof (float_type
, temp
, &flen
);
2458 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2462 as_bad ("Bad floating literal: %s", err
);
2464 mri_comment_end (stop
, stopc
);
2465 ignore_rest_of_line ();
2470 while (--count
>= 0)
2474 p
= frag_more (flen
);
2475 memcpy (p
, temp
, (unsigned int) flen
);
2479 mri_comment_end (stop
, stopc
);
2481 demand_empty_rest_of_line ();
2484 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2494 stop
= mri_comment_field (&stopc
);
2495 abs_section_offset
= get_absolute_expression ();
2496 subseg_set (absolute_section
, 0);
2498 mri_comment_end (stop
, stopc
);
2499 demand_empty_rest_of_line ();
2508 temp
= get_absolute_expression ();
2509 subseg_set (text_section
, (subsegT
) temp
);
2510 demand_empty_rest_of_line ();
2512 const_flag
&= ~IN_DEFAULT_SECTION
;
2518 demand_empty_rest_of_line ()
2521 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2523 input_line_pointer
++;
2527 ignore_rest_of_line ();
2529 /* Return having already swallowed end-of-line. */
2530 } /* Return pointing just after end-of-line. */
2533 ignore_rest_of_line () /* For suspect lines: gives warning. */
2535 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2537 if (isprint (*input_line_pointer
))
2538 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2539 *input_line_pointer
);
2541 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2542 *input_line_pointer
);
2543 while (input_line_pointer
< buffer_limit
2544 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2546 input_line_pointer
++;
2549 input_line_pointer
++; /* Return pointing just after end-of-line. */
2550 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2556 * In: Pointer to a symbol.
2557 * Input_line_pointer->expression.
2559 * Out: Input_line_pointer->just after any whitespace after expression.
2560 * Tried to set symbol to value of expression.
2561 * Will change symbols type, value, and frag;
2564 pseudo_set (symbolP
)
2568 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2570 #endif /* OBJ_AOUT or OBJ_BOUT */
2572 know (symbolP
); /* NULL pointer is logic error. */
2573 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2574 ext
= S_IS_EXTERNAL (symbolP
);
2575 #endif /* OBJ_AOUT or OBJ_BOUT */
2577 (void) expression (&exp
);
2579 if (exp
.X_op
== O_illegal
)
2580 as_bad ("illegal expression; zero assumed");
2581 else if (exp
.X_op
== O_absent
)
2582 as_bad ("missing expression; zero assumed");
2583 else if (exp
.X_op
== O_big
)
2584 as_bad ("%s number invalid; zero assumed",
2585 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2586 else if (exp
.X_op
== O_subtract
2587 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2588 == S_GET_SEGMENT (exp
.X_op_symbol
))
2589 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2590 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2592 exp
.X_op
= O_constant
;
2593 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2594 - S_GET_VALUE (exp
.X_op_symbol
));
2602 exp
.X_add_number
= 0;
2605 S_SET_SEGMENT (symbolP
, absolute_section
);
2606 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2608 S_SET_EXTERNAL (symbolP
);
2610 S_CLEAR_EXTERNAL (symbolP
);
2611 #endif /* OBJ_AOUT or OBJ_BOUT */
2612 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2613 symbolP
->sy_frag
= &zero_address_frag
;
2617 S_SET_SEGMENT (symbolP
, reg_section
);
2618 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2619 symbolP
->sy_frag
= &zero_address_frag
;
2623 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2624 || exp
.X_add_number
!= 0)
2625 symbolP
->sy_value
= exp
;
2628 symbolS
*s
= exp
.X_add_symbol
;
2630 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2631 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2633 S_SET_EXTERNAL (symbolP
);
2635 S_CLEAR_EXTERNAL (symbolP
);
2636 #endif /* OBJ_AOUT or OBJ_BOUT */
2637 S_SET_VALUE (symbolP
,
2638 exp
.X_add_number
+ S_GET_VALUE (s
));
2639 symbolP
->sy_frag
= s
->sy_frag
;
2640 copy_symbol_attributes (symbolP
, s
);
2645 /* The value is some complex expression.
2646 FIXME: Should we set the segment to anything? */
2647 symbolP
->sy_value
= exp
;
2655 * CONStruct more frag of .bytes, or .words etc.
2656 * Should need_pass_2 be 1 then emit no frag(s).
2657 * This understands EXPRESSIONS.
2661 * This has a split personality. We use expression() to read the
2662 * value. We can detect if the value won't fit in a byte or word.
2663 * But we can't detect if expression() discarded significant digits
2664 * in the case of a long. Not worth the crocks required to fix it.
2667 /* Select a parser for cons expressions. */
2669 /* Some targets need to parse the expression in various fancy ways.
2670 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2671 (for example, the HPPA does this). Otherwise, you can define
2672 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2673 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2674 are defined, which is the normal case, then only simple expressions
2678 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2680 #ifndef TC_PARSE_CONS_EXPRESSION
2681 #ifdef BITFIELD_CONS_EXPRESSIONS
2682 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2684 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2686 #ifdef REPEAT_CONS_EXPRESSIONS
2687 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2689 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2692 /* If we haven't gotten one yet, just call expression. */
2693 #ifndef TC_PARSE_CONS_EXPRESSION
2694 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2698 /* worker to do .byte etc statements */
2699 /* clobbers input_line_pointer, checks */
2702 cons_worker (nbytes
, rva
)
2703 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
2711 #ifdef md_flush_pending_output
2712 md_flush_pending_output ();
2716 stop
= mri_comment_field (&stopc
);
2718 if (is_it_end_of_statement ())
2720 mri_comment_end (stop
, stopc
);
2721 demand_empty_rest_of_line ();
2729 parse_mri_cons (&exp
, (unsigned int) nbytes
);
2731 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
2735 if (exp
.X_op
== O_symbol
)
2736 exp
.X_op
= O_symbol_rva
;
2738 as_fatal ("rva without symbol");
2740 emit_expr (&exp
, (unsigned int) nbytes
);
2743 while (*input_line_pointer
++ == ',');
2745 /* In MRI mode, after an odd number of bytes, we must align to an
2746 even word boundary, unless the next instruction is a dc.b, ds.b
2748 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
2749 mri_pending_align
= 1;
2751 input_line_pointer
--; /* Put terminator back into stream. */
2754 mri_comment_end (stop
, stopc
);
2756 demand_empty_rest_of_line ();
2764 cons_worker (size
, 0);
2771 cons_worker (size
, 1);
2775 /* Put the contents of expression EXP into the object file using
2776 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
2779 emit_expr (exp
, nbytes
)
2781 unsigned int nbytes
;
2785 valueT extra_digit
= 0;
2787 /* Don't do anything if we are going to make another pass. */
2793 /* Allow `.word 0' in the absolute section. */
2794 if (now_seg
== absolute_section
)
2796 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
2797 as_bad ("attempt to store value in absolute section");
2798 abs_section_offset
+= nbytes
;
2802 /* Handle a negative bignum. */
2804 && exp
->X_add_number
== 0
2805 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
2806 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
2809 unsigned long carry
;
2811 exp
= &exp
->X_add_symbol
->sy_value
;
2813 /* Negate the bignum: one's complement each digit and add 1. */
2815 for (i
= 0; i
< exp
->X_add_number
; i
++)
2819 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
2822 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
2823 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
2826 /* We can ignore any carry out, because it will be handled by
2827 extra_digit if it is needed. */
2829 extra_digit
= (valueT
) -1;
2833 if (op
== O_absent
|| op
== O_illegal
)
2835 as_warn ("zero assumed for missing expression");
2836 exp
->X_add_number
= 0;
2839 else if (op
== O_big
&& exp
->X_add_number
<= 0)
2841 as_bad ("floating point number invalid; zero assumed");
2842 exp
->X_add_number
= 0;
2845 else if (op
== O_register
)
2847 as_warn ("register value used as expression");
2851 p
= frag_more ((int) nbytes
);
2853 #ifndef WORKING_DOT_WORD
2854 /* If we have the difference of two symbols in a word, save it on
2855 the broken_words list. See the code in write.c. */
2856 if (op
== O_subtract
&& nbytes
== 2)
2858 struct broken_word
*x
;
2860 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
2861 x
->next_broken_word
= broken_words
;
2864 x
->word_goes_here
= p
;
2866 x
->add
= exp
->X_add_symbol
;
2867 x
->sub
= exp
->X_op_symbol
;
2868 x
->addnum
= exp
->X_add_number
;
2875 /* If we have an integer, but the number of bytes is too large to
2876 pass to md_number_to_chars, handle it as a bignum. */
2877 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
2882 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
2883 extra_digit
= (valueT
) -1;
2884 val
= (valueT
) exp
->X_add_number
;
2888 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
2889 val
>>= LITTLENUM_NUMBER_OF_BITS
;
2893 op
= exp
->X_op
= O_big
;
2894 exp
->X_add_number
= gencnt
;
2897 if (op
== O_constant
)
2899 register valueT get
;
2900 register valueT use
;
2901 register valueT mask
;
2902 register valueT unmask
;
2904 /* JF << of >= number of bits in the object is undefined. In
2905 particular SPARC (Sun 4) has problems */
2906 if (nbytes
>= sizeof (valueT
))
2909 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
2911 unmask
= ~mask
; /* Do store these bits. */
2914 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
2915 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
2918 get
= exp
->X_add_number
;
2920 if ((get
& mask
) != 0 && (get
& mask
) != mask
)
2921 { /* Leading bits contain both 0s & 1s. */
2922 as_warn ("Value 0x%lx truncated to 0x%lx.", get
, use
);
2924 /* put bytes in right order. */
2925 md_number_to_chars (p
, use
, (int) nbytes
);
2927 else if (op
== O_big
)
2930 LITTLENUM_TYPE
*nums
;
2932 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
2934 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
2937 as_warn ("Bignum truncated to %d bytes", nbytes
);
2941 if (target_big_endian
)
2943 while (nbytes
> size
)
2945 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
2946 nbytes
-= CHARS_PER_LITTLENUM
;
2947 p
+= CHARS_PER_LITTLENUM
;
2950 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
2954 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
2955 size
-= CHARS_PER_LITTLENUM
;
2956 p
+= CHARS_PER_LITTLENUM
;
2961 nums
= generic_bignum
;
2964 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
2966 size
-= CHARS_PER_LITTLENUM
;
2967 p
+= CHARS_PER_LITTLENUM
;
2968 nbytes
-= CHARS_PER_LITTLENUM
;
2973 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
2974 nbytes
-= CHARS_PER_LITTLENUM
;
2975 p
+= CHARS_PER_LITTLENUM
;
2981 memset (p
, 0, nbytes
);
2983 /* Now we need to generate a fixS to record the symbol value.
2984 This is easy for BFD. For other targets it can be more
2985 complex. For very complex cases (currently, the HPPA and
2986 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
2987 want. For simpler cases, you can define TC_CONS_RELOC to be
2988 the name of the reloc code that should be stored in the fixS.
2989 If neither is defined, the code uses NO_RELOC if it is
2990 defined, and otherwise uses 0. */
2992 #ifdef BFD_ASSEMBLER
2993 #ifdef TC_CONS_FIX_NEW
2994 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
2996 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
2997 /* @@ Should look at CPU word size. */
2998 nbytes
== 2 ? BFD_RELOC_16
2999 : nbytes
== 8 ? BFD_RELOC_64
3003 #ifdef TC_CONS_FIX_NEW
3004 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3006 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3007 it is defined, otherwise use NO_RELOC if it is defined,
3009 #ifndef TC_CONS_RELOC
3011 #define TC_CONS_RELOC NO_RELOC
3013 #define TC_CONS_RELOC 0
3016 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3018 #endif /* TC_CONS_FIX_NEW */
3019 #endif /* BFD_ASSEMBLER */
3023 #ifdef BITFIELD_CONS_EXPRESSIONS
3025 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3026 w:x,y:z, where w and y are bitwidths and x and y are values. They
3027 then pack them all together. We do a little better in that we allow
3028 them in words, longs, etc. and we'll pack them in target byte order
3031 The rules are: pack least significat bit first, if a field doesn't
3032 entirely fit, put it in the next unit. Overflowing the bitfield is
3033 explicitly *not* even a warning. The bitwidth should be considered
3036 To use this function the tc-XXX.h file should define
3037 BITFIELD_CONS_EXPRESSIONS. */
3040 parse_bitfield_cons (exp
, nbytes
)
3042 unsigned int nbytes
;
3044 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3045 char *hold
= input_line_pointer
;
3047 (void) expression (exp
);
3049 if (*input_line_pointer
== ':')
3055 unsigned long width
;
3057 if (*input_line_pointer
!= ':')
3059 input_line_pointer
= hold
;
3061 } /* next piece is not a bitfield */
3063 /* In the general case, we can't allow
3064 full expressions with symbol
3065 differences and such. The relocation
3066 entries for symbols not defined in this
3067 assembly would require arbitrary field
3068 widths, positions, and masks which most
3069 of our current object formats don't
3072 In the specific case where a symbol
3073 *is* defined in this assembly, we
3074 *could* build fixups and track it, but
3075 this could lead to confusion for the
3076 backends. I'm lazy. I'll take any
3077 SEG_ABSOLUTE. I think that means that
3078 you can use a previous .set or
3079 .equ type symbol. xoxorich. */
3081 if (exp
->X_op
== O_absent
)
3083 as_warn ("using a bit field width of zero");
3084 exp
->X_add_number
= 0;
3085 exp
->X_op
= O_constant
;
3086 } /* implied zero width bitfield */
3088 if (exp
->X_op
!= O_constant
)
3090 *input_line_pointer
= '\0';
3091 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3092 *input_line_pointer
= ':';
3093 demand_empty_rest_of_line ();
3097 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3099 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3100 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3101 width
= BITS_PER_CHAR
* nbytes
;
3104 if (width
> bits_available
)
3106 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3107 input_line_pointer
= hold
;
3108 exp
->X_add_number
= value
;
3112 hold
= ++input_line_pointer
; /* skip ':' */
3114 (void) expression (exp
);
3115 if (exp
->X_op
!= O_constant
)
3117 char cache
= *input_line_pointer
;
3119 *input_line_pointer
= '\0';
3120 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3121 *input_line_pointer
= cache
;
3122 demand_empty_rest_of_line ();
3126 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3127 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3129 if ((bits_available
-= width
) == 0
3130 || is_it_end_of_statement ()
3131 || *input_line_pointer
!= ',')
3134 } /* all the bitfields we're gonna get */
3136 hold
= ++input_line_pointer
;
3137 (void) expression (exp
);
3138 } /* forever loop */
3140 exp
->X_add_number
= value
;
3141 exp
->X_op
= O_constant
;
3142 exp
->X_unsigned
= 1;
3143 } /* if looks like a bitfield */
3144 } /* parse_bitfield_cons() */
3146 #endif /* BITFIELD_CONS_EXPRESSIONS */
3148 /* Handle an MRI style string expression. */
3151 parse_mri_cons (exp
, nbytes
)
3153 unsigned int nbytes
;
3155 if (*input_line_pointer
!= '\''
3156 && (input_line_pointer
[1] != '\''
3157 || (*input_line_pointer
!= 'A'
3158 && *input_line_pointer
!= 'E')))
3159 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3163 unsigned int result
= 0;
3165 /* An MRI style string. Cut into as many bytes as will fit into
3166 a nbyte chunk, left justify if necessary, and separate with
3167 commas so we can try again later. */
3168 if (*input_line_pointer
== 'A')
3169 ++input_line_pointer
;
3170 else if (*input_line_pointer
== 'E')
3172 as_bad ("EBCDIC constants are not supported");
3173 ++input_line_pointer
;
3176 input_line_pointer
++;
3177 for (scan
= 0; scan
< nbytes
; scan
++)
3179 if (*input_line_pointer
== '\'')
3181 if (input_line_pointer
[1] == '\'')
3183 input_line_pointer
++;
3188 result
= (result
<< 8) | (*input_line_pointer
++);
3192 while (scan
< nbytes
)
3197 /* Create correct expression */
3198 exp
->X_op
= O_constant
;
3199 exp
->X_add_number
= result
;
3200 /* Fake it so that we can read the next char too */
3201 if (input_line_pointer
[0] != '\'' ||
3202 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3204 input_line_pointer
-= 2;
3205 input_line_pointer
[0] = ',';
3206 input_line_pointer
[1] = '\'';
3209 input_line_pointer
++;
3213 #ifdef REPEAT_CONS_EXPRESSIONS
3215 /* Parse a repeat expression for cons. This is used by the MIPS
3216 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3217 object file COUNT times.
3219 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3222 parse_repeat_cons (exp
, nbytes
)
3224 unsigned int nbytes
;
3231 if (*input_line_pointer
!= ':')
3233 /* No repeat count. */
3237 ++input_line_pointer
;
3238 expression (&count
);
3239 if (count
.X_op
!= O_constant
3240 || count
.X_add_number
<= 0)
3242 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3246 /* The cons function is going to output this expression once. So we
3247 output it count - 1 times. */
3248 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3249 emit_expr (exp
, nbytes
);
3252 #endif /* REPEAT_CONS_EXPRESSIONS */
3254 /* Parse a floating point number represented as a hex constant. This
3255 permits users to specify the exact bits they want in the floating
3259 hex_float (float_type
, bytes
)
3293 as_bad ("Unknown floating type type '%c'", float_type
);
3297 /* It would be nice if we could go through expression to parse the
3298 hex constant, but if we get a bignum it's a pain to sort it into
3299 the buffer correctly. */
3301 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3305 /* The MRI assembler accepts arbitrary underscores strewn about
3306 through the hex constant, so we ignore them as well. */
3307 if (*input_line_pointer
== '_')
3309 ++input_line_pointer
;
3315 as_warn ("Floating point constant too large");
3318 d
= hex_value (*input_line_pointer
) << 4;
3319 ++input_line_pointer
;
3320 while (*input_line_pointer
== '_')
3321 ++input_line_pointer
;
3322 if (hex_p (*input_line_pointer
))
3324 d
+= hex_value (*input_line_pointer
);
3325 ++input_line_pointer
;
3327 if (target_big_endian
)
3330 bytes
[length
- i
- 1] = d
;
3336 if (target_big_endian
)
3337 memset (bytes
+ i
, 0, length
- i
);
3339 memset (bytes
, 0, length
- i
);
3348 * CONStruct some more frag chars of .floats .ffloats etc.
3349 * Makes 0 or more new frags.
3350 * If need_pass_2 == 1, no frags are emitted.
3351 * This understands only floating literals, not expressions. Sorry.
3353 * A floating constant is defined by atof_generic(), except it is preceded
3354 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3355 * reading, I decided to be incompatible. This always tries to give you
3356 * rounded bits to the precision of the pseudo-op. Former AS did premature
3357 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3358 * a choice of 2 flavours of noise according to which of 2 floating-point
3359 * scanners you directed AS to use.
3361 * In: input_line_pointer->whitespace before, or '0' of flonum.
3366 float_cons (float_type
)
3367 /* Clobbers input_line-pointer, checks end-of-line. */
3368 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3371 int length
; /* Number of chars in an object. */
3372 register char *err
; /* Error from scanning floating literal. */
3373 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3375 if (is_it_end_of_statement ())
3377 demand_empty_rest_of_line ();
3383 /* input_line_pointer->1st char of a flonum (we hope!). */
3386 /* Skip any 0{letter} that may be present. Don't even check if the
3387 * letter is legal. Someone may invent a "z" format and this routine
3388 * has no use for such information. Lusers beware: you get
3389 * diagnostics if your input is ill-conditioned.
3391 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3392 input_line_pointer
+= 2;
3394 /* Accept :xxxx, where the x's are hex digits, for a floating
3395 point with the exact digits specified. */
3396 if (input_line_pointer
[0] == ':')
3398 ++input_line_pointer
;
3399 length
= hex_float (float_type
, temp
);
3402 ignore_rest_of_line ();
3408 err
= md_atof (float_type
, temp
, &length
);
3409 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3413 as_bad ("Bad floating literal: %s", err
);
3414 ignore_rest_of_line ();
3425 #ifdef REPEAT_CONS_EXPRESSIONS
3426 if (*input_line_pointer
== ':')
3428 expressionS count_exp
;
3430 ++input_line_pointer
;
3431 expression (&count_exp
);
3432 if (count_exp
.X_op
!= O_constant
3433 || count_exp
.X_add_number
<= 0)
3435 as_warn ("unresolvable or nonpositive repeat count; using 1");
3438 count
= count_exp
.X_add_number
;
3442 while (--count
>= 0)
3444 p
= frag_more (length
);
3445 memcpy (p
, temp
, (unsigned int) length
);
3450 while (*input_line_pointer
++ == ',');
3452 --input_line_pointer
; /* Put terminator back into stream. */
3453 demand_empty_rest_of_line ();
3454 } /* float_cons() */
3459 * We read 0 or more ',' seperated, double-quoted strings.
3461 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3466 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3467 /* Checks end-of-line. */
3468 register int append_zero
; /* 0: don't append '\0', else 1 */
3470 register unsigned int c
;
3472 #ifdef md_flush_pending_output
3473 md_flush_pending_output ();
3477 * The following awkward logic is to parse ZERO or more strings,
3478 * comma seperated. Recall a string expression includes spaces
3479 * before the opening '\"' and spaces after the closing '\"'.
3480 * We fake a leading ',' if there is (supposed to be)
3481 * a 1st, expression. We keep demanding expressions for each
3484 if (is_it_end_of_statement ())
3486 c
= 0; /* Skip loop. */
3487 ++input_line_pointer
; /* Compensate for end of loop. */
3491 c
= ','; /* Do loop. */
3493 while (c
== ',' || c
== '<' || c
== '"')
3496 switch (*input_line_pointer
)
3499 ++input_line_pointer
; /*->1st char of string. */
3500 while (is_a_char (c
= next_char_of_string ()))
3502 FRAG_APPEND_1_CHAR (c
);
3506 FRAG_APPEND_1_CHAR (0);
3508 know (input_line_pointer
[-1] == '\"');
3511 input_line_pointer
++;
3512 c
= get_single_number ();
3513 FRAG_APPEND_1_CHAR (c
);
3514 if (*input_line_pointer
!= '>')
3516 as_bad ("Expected <nn>");
3518 input_line_pointer
++;
3521 input_line_pointer
++;
3525 c
= *input_line_pointer
;
3528 demand_empty_rest_of_line ();
3531 /* FIXME-SOMEDAY: I had trouble here on characters with the
3532 high bits set. We'll probably also have trouble with
3533 multibyte chars, wide chars, etc. Also be careful about
3534 returning values bigger than 1 byte. xoxorich. */
3537 next_char_of_string ()
3539 register unsigned int c
;
3541 c
= *input_line_pointer
++ & CHAR_MASK
;
3548 #ifndef NO_STRING_ESCAPES
3550 switch (c
= *input_line_pointer
++)
3578 break; /* As itself. */
3594 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3596 number
= number
* 8 + c
- '0';
3600 --input_line_pointer
;
3609 c
= *input_line_pointer
++;
3610 while (isxdigit (c
))
3613 number
= number
* 16 + c
- '0';
3614 else if (isupper (c
))
3615 number
= number
* 16 + c
- 'A' + 10;
3617 number
= number
* 16 + c
- 'a' + 10;
3618 c
= *input_line_pointer
++;
3621 --input_line_pointer
;
3626 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3627 as_warn ("Unterminated string: Newline inserted.");
3633 #ifdef ONLY_STANDARD_ESCAPES
3634 as_bad ("Bad escaped character in string, '?' assumed");
3636 #endif /* ONLY_STANDARD_ESCAPES */
3639 } /* switch on escaped char */
3641 #endif /* ! defined (NO_STRING_ESCAPES) */
3645 } /* switch on char */
3647 } /* next_char_of_string() */
3650 get_segmented_expression (expP
)
3651 register expressionS
*expP
;
3653 register segT retval
;
3655 retval
= expression (expP
);
3656 if (expP
->X_op
== O_illegal
3657 || expP
->X_op
== O_absent
3658 || expP
->X_op
== O_big
)
3660 as_bad ("expected address expression; zero assumed");
3661 expP
->X_op
= O_constant
;
3662 expP
->X_add_number
= 0;
3663 retval
= absolute_section
;
3669 get_known_segmented_expression (expP
)
3670 register expressionS
*expP
;
3672 register segT retval
;
3674 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
3676 /* There is no easy way to extract the undefined symbol from the
3678 if (expP
->X_add_symbol
!= NULL
3679 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
3680 as_warn ("symbol \"%s\" undefined; zero assumed",
3681 S_GET_NAME (expP
->X_add_symbol
));
3683 as_warn ("some symbol undefined; zero assumed");
3684 retval
= absolute_section
;
3685 expP
->X_op
= O_constant
;
3686 expP
->X_add_number
= 0;
3688 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
3690 } /* get_known_segmented_expression() */
3693 get_absolute_expression ()
3698 if (exp
.X_op
!= O_constant
)
3700 if (exp
.X_op
!= O_absent
)
3701 as_bad ("bad or irreducible absolute expression; zero assumed");
3702 exp
.X_add_number
= 0;
3704 return exp
.X_add_number
;
3707 char /* return terminator */
3708 get_absolute_expression_and_terminator (val_pointer
)
3709 long *val_pointer
; /* return value of expression */
3711 /* FIXME: val_pointer should probably be offsetT *. */
3712 *val_pointer
= (long) get_absolute_expression ();
3713 return (*input_line_pointer
++);
3717 * demand_copy_C_string()
3719 * Like demand_copy_string, but return NULL if the string contains any '\0's.
3720 * Give a warning if that happens.
3723 demand_copy_C_string (len_pointer
)
3728 if ((s
= demand_copy_string (len_pointer
)) != 0)
3732 for (len
= *len_pointer
; len
> 0; len
--)
3739 as_bad ("This string may not contain \'\\0\'");
3747 * demand_copy_string()
3749 * Demand string, but return a safe (=private) copy of the string.
3750 * Return NULL if we can't read a string here.
3753 demand_copy_string (lenP
)
3756 register unsigned int c
;
3762 if (*input_line_pointer
== '\"')
3764 input_line_pointer
++; /* Skip opening quote. */
3766 while (is_a_char (c
= next_char_of_string ()))
3768 obstack_1grow (¬es
, c
);
3771 /* JF this next line is so demand_copy_C_string will return a
3772 null terminated string. */
3773 obstack_1grow (¬es
, '\0');
3774 retval
= obstack_finish (¬es
);
3778 as_warn ("Missing string");
3780 ignore_rest_of_line ();
3784 } /* demand_copy_string() */
3787 * is_it_end_of_statement()
3789 * In: Input_line_pointer->next character.
3791 * Do: Skip input_line_pointer over all whitespace.
3793 * Out: 1 if input_line_pointer->end-of-line.
3796 is_it_end_of_statement ()
3799 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
3800 } /* is_it_end_of_statement() */
3806 register symbolS
*symbolP
; /* symbol we are working with */
3810 input_line_pointer
++;
3811 if (*input_line_pointer
== '=')
3812 input_line_pointer
++;
3814 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
3815 input_line_pointer
++;
3818 stop
= mri_comment_field (&stopc
);
3820 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
3822 /* Turn '. = mumble' into a .org mumble */
3823 register segT segment
;
3826 segment
= get_known_segmented_expression (&exp
);
3828 do_org (segment
, &exp
, 0);
3832 symbolP
= symbol_find_or_make (sym_name
);
3833 pseudo_set (symbolP
);
3837 mri_comment_end (stop
, stopc
);
3840 /* .include -- include a file at this point. */
3854 filename
= demand_copy_string (&i
);
3859 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
3860 && *input_line_pointer
!= ' '
3861 && *input_line_pointer
!= '\t')
3863 obstack_1grow (¬es
, *input_line_pointer
);
3864 ++input_line_pointer
;
3867 obstack_1grow (¬es
, '\0');
3868 filename
= obstack_finish (¬es
);
3869 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3870 ++input_line_pointer
;
3872 demand_empty_rest_of_line ();
3873 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
3874 for (i
= 0; i
< include_dir_count
; i
++)
3876 strcpy (path
, include_dirs
[i
]);
3878 strcat (path
, filename
);
3879 if (0 != (try = fopen (path
, "r")))
3888 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
3889 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
3890 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
3894 add_include_dir (path
)
3899 if (include_dir_count
== 0)
3901 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
3902 include_dirs
[0] = "."; /* Current dir */
3903 include_dir_count
= 2;
3907 include_dir_count
++;
3908 include_dirs
= (char **) realloc (include_dirs
,
3909 include_dir_count
* sizeof (*include_dirs
));
3912 include_dirs
[include_dir_count
- 1] = path
; /* New one */
3915 if (i
> include_dir_maxlen
)
3916 include_dir_maxlen
= i
;
3917 } /* add_include_dir() */
3923 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
3925 ++input_line_pointer
;
3927 ++input_line_pointer
;
3932 read_print_statistics (file
)
3935 hash_print_statistics (file
, "pseudo-op table", po_hash
);