1 /* read.c - read a source file -
2 Copyright (C) 1986, 1987, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
22 change this a bit. But then, GNU isn't
23 spozed to run on your machine anyway.
24 (RMS is so shortsighted sometimes.)
27 #define MASK_CHAR ((int)(unsigned char)-1)
30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
31 /* This is the largest known floating point */
32 /* format (for now). It will grow when we */
33 /* do 4361 style flonums. */
36 /* Routines that read assembler source text to build spagetti in memory.
37 Another group of these functions is in the expr.c module. */
46 /* The NOP_OPCODE is for the alignment fill value.
47 * fill it a nop instruction so that the disassembler does not choke
51 #define NOP_OPCODE 0x00
54 char *input_line_pointer
; /*->next char of source file to parse. */
56 #if BITS_PER_CHAR != 8
57 /* The following table is indexed by[(char)] and will break if
58 a char does not have exactly 256 states (hopefully 0:255!)! */
62 /* used by is_... macros. our ctype[] */
63 const char lex_type
[256] =
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
66 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
67 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
68 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
69 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
70 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, /* PQRSTUVWXYZ[\]^_ */
71 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
72 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, /* pqrstuvwxyz{|}~. */
73 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
74 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
75 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
76 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
77 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
85 * Out: 1 if this character ends a line.
88 char is_end_of_line
[256] =
91 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
93 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
95 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
96 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
97 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
98 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
99 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
100 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
101 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
102 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
103 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
104 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
105 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
106 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
110 /* Functions private to this file. */
112 static char *buffer
; /* 1st char of each buffer of lines is here. */
113 static char *buffer_limit
; /*->1 + last char in buffer. */
115 static char *bignum_low
; /* Lowest char of bignum. */
116 static char *bignum_limit
; /* 1st illegal address of bignum. */
117 static char *bignum_high
; /* Highest char of bignum. */
118 /* May point to (bignum_start-1). */
119 /* Never >= bignum_limit. */
121 static char *old_buffer
= 0; /* JF a hack */
122 static char *old_input
;
123 static char *old_limit
;
125 /* Variables for handling include file directory list. */
127 char **include_dirs
; /* List of pointers to directories to
128 search for .include's */
129 int include_dir_count
; /* How many are in the list */
130 int include_dir_maxlen
= 1;/* Length of longest in list */
132 #ifndef WORKING_DOT_WORD
133 struct broken_word
*broken_words
;
134 int new_broken_words
= 0;
137 static char *demand_copy_string
PARAMS ((int *lenP
));
138 int is_it_end_of_statement
PARAMS ((void));
139 unsigned int next_char_of_string
PARAMS ((void));
140 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
141 static void grow_bignum
PARAMS ((void));
142 static void pobegin
PARAMS ((void));
143 void stringer
PARAMS ((int append_zero
));
154 obj_read_begin_hook ();
156 obstack_begin (¬es
, 5000);
157 obstack_begin (&cond_obstack
, 960);
159 #define BIGNUM_BEGIN_SIZE (16)
160 bignum_low
= xmalloc ((long) BIGNUM_BEGIN_SIZE
);
161 bignum_limit
= bignum_low
+ BIGNUM_BEGIN_SIZE
;
163 /* Use machine dependent syntax */
164 for (p
= line_separator_chars
; *p
; p
++)
165 is_end_of_line
[*p
] = 1;
166 /* Use more. FIXME-SOMEDAY. */
169 /* set up pseudo-op tables */
171 struct hash_control
*po_hash
= NULL
; /* use before set up: NULL->address error */
174 void s_gdbline (), s_gdblinetab ();
175 void s_gdbbeg (), s_gdbblock (), s_gdbend (), s_gdbsym ();
178 static const pseudo_typeS potable
[] =
180 {"abort", s_abort
, 0},
181 {"align", s_align_ptwo
, 0},
182 {"ascii", stringer
, 0},
183 {"asciz", stringer
, 1},
189 {"double", float_cons
, 'd'},
191 {"eject", listing_eject
, 0}, /* Formfeed listing */
194 {"endif", s_endif
, 0},
199 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
200 {"app-file", s_app_file
, 0},
201 {"file", s_app_file
, 0},
203 {"float", float_cons
, 'f'},
205 {"gdbbeg", s_gdbbeg
, 0},
206 {"gdbblock", s_gdbblock
, 0},
207 {"gdbend", s_gdbend
, 0},
208 {"gdbsym", s_gdbsym
, 0},
209 {"gdbline", s_gdbline
, 0},
210 {"gdblinetab", s_gdblinetab
, 0},
212 {"global", s_globl
, 0},
213 {"globl", s_globl
, 0},
216 {"ifdef", s_ifdef
, 0},
217 {"ifeqs", s_ifeqs
, 0},
218 {"ifndef", s_ifdef
, 1},
219 {"ifnes", s_ifeqs
, 1},
220 {"ifnotdef", s_ifdef
, 1},
221 {"include", s_include
, 0},
223 {"lcomm", s_lcomm
, 0},
224 {"lflags", listing_flags
, 0}, /* Listing flags */
225 {"list", listing_list
, 1}, /* Turn listing on */
228 {"nolist", listing_list
, 0}, /* Turn listing off */
229 {"octa", big_cons
, 16},
231 {"psize", listing_psize
, 0}, /* set paper size */
233 {"quad", big_cons
, 8},
234 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
239 {"single", float_cons
, 'f'},
241 {"space", s_space
, 0},
244 {"title", listing_title
, 0}, /* Listing title */
249 {NULL
} /* end sentinel */
255 char *errtxt
; /* error text */
256 const pseudo_typeS
*pop
;
258 po_hash
= hash_new ();
260 /* Do the target-specific pseudo ops. */
261 for (pop
= md_pseudo_table
; pop
->poc_name
; pop
++)
263 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
264 if (errtxt
&& *errtxt
)
266 as_fatal ("error constructing md pseudo-op table");
270 /* Now object specific. Skip any that were in the target table. */
271 for (pop
= obj_pseudo_table
; pop
->poc_name
; pop
++)
273 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
274 if (errtxt
&& *errtxt
)
276 if (!strcmp (errtxt
, "exists"))
278 #ifdef DIE_ON_OVERRIDES
279 as_fatal ("pseudo op \".%s\" overridden.\n", pop
->poc_name
);
280 #endif /* DIE_ON_OVERRIDES */
281 continue; /* OK if target table overrides. */
285 as_fatal ("error constructing obj pseudo-op table");
286 } /* if overridden */
290 /* Now portable ones. Skip any that we've seen already. */
291 for (pop
= potable
; pop
->poc_name
; pop
++)
293 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
294 if (errtxt
&& *errtxt
)
296 if (!strcmp (errtxt
, "exists"))
298 #ifdef DIE_ON_OVERRIDES
299 as_fatal ("pseudo op \".%s\" overridden.\n", pop
->poc_name
);
300 #endif /* DIE_ON_OVERRIDES */
301 continue; /* OK if target table overrides. */
305 as_fatal ("error constructing obj pseudo-op table");
306 } /* if overridden */
313 #define HANDLE_CONDITIONAL_ASSEMBLY() \
314 if (ignore_input ()) \
316 while (! is_end_of_line[*input_line_pointer++]) \
317 if (input_line_pointer == buffer_limit) \
323 /* read_a_source_file()
325 * We read the file, putting things into a web that
326 * represents what we have been reading.
329 read_a_source_file (name
)
333 register char *s
; /* string of symbol, '\0' appended */
335 /* register struct frag * fragP; JF unused *//* a frag we just made */
338 void gdb_block_beg ();
339 void gdb_block_position ();
340 void gdb_block_end ();
341 void gdb_symbols_fixup ();
344 buffer
= input_scrub_new_file (name
);
347 listing_newline ("");
349 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
350 { /* We have another line to parse. */
351 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
352 contin
: /* JF this goto is my fault I admit it. Someone brave please re-write
353 the whole input section here? Pleeze??? */
354 while (input_line_pointer
< buffer_limit
)
355 { /* We have more of this buffer to parse. */
358 * We now have input_line_pointer->1st char of next line.
359 * If input_line_pointer [-1] == '\n' then we just
360 * scanned another line: so bump line counters.
362 if (input_line_pointer
[-1] == '\n')
364 bump_line_counters ();
367 /* Text at the start of a line must be a label, we run down and stick a colon in */
368 if (is_name_beginner (*input_line_pointer
))
370 char *line_start
= input_line_pointer
;
371 char c
= get_symbol_end ();
373 *input_line_pointer
= c
;
375 input_line_pointer
++;
379 } /* just passed a newline */
386 * We are at the begining of a line, or similar place.
387 * We expect a well-formed assembler statement.
388 * A "symbol-name:" is a statement.
390 * Depending on what compiler is used, the order of these tests
391 * may vary to catch most common case 1st.
392 * Each test is independent of all other tests at the (top) level.
393 * PLEASE make a compiler that doesn't use this assembler.
394 * It is crufty to waste a compiler's time encoding things for this
395 * assembler, which then wastes more time decoding it.
396 * (And communicating via (linear) files is silly!
397 * If you must pass stuff, please pass a tree!)
399 if ((c
= *input_line_pointer
++) == '\t' || c
== ' ' || c
== '\f' || c
== 0)
401 c
= *input_line_pointer
++;
403 know (c
!= ' '); /* No further leading whitespace. */
406 * C is the 1st significant character.
407 * Input_line_pointer points after that character.
409 if (is_name_beginner (c
))
410 { /* want user-defined label or pseudo/opcode */
411 HANDLE_CONDITIONAL_ASSEMBLY ();
413 s
= --input_line_pointer
;
414 c
= get_symbol_end (); /* name's delimiter */
416 * C is character after symbol.
417 * That character's place in the input line is now '\0'.
418 * S points to the beginning of the symbol.
419 * [In case of pseudo-op, s->'.'.]
420 * Input_line_pointer->'\0' where c was.
424 colon (s
); /* user-defined label */
425 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
426 /* Input_line_pointer->after ':'. */
431 else if (c
== '=' || input_line_pointer
[1] == '=')
432 { /* JF deal with FOO=BAR */
434 demand_empty_rest_of_line ();
437 { /* expect pseudo-op or machine instruction */
439 if (!done_pseudo (s
))
447 * WARNING: c has next char, which may be end-of-line.
448 * We lookup the pseudo-op table with s+1 because we
449 * already know that the pseudo-op begins with a '.'.
452 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
454 /* Print the error msg now, while we still can */
457 as_bad ("Unknown pseudo-op: `%s'", s
);
458 *input_line_pointer
= c
;
463 /* Put it back for error messages etc. */
464 *input_line_pointer
= c
;
465 /* The following skip of whitespace is compulsory. */
466 /* A well shaped space is sometimes all that separates keyword from operands. */
467 if (c
== ' ' || c
== '\t')
469 input_line_pointer
++;
470 } /* Skip seperator after keyword. */
472 * Input_line is restored.
473 * Input_line_pointer->1st non-blank char
474 * after pseudo-operation.
478 ignore_rest_of_line ();
483 (*pop
->poc_handler
) (pop
->poc_val
);
484 } /* if we have one */
488 { /* machine instruction */
489 /* WARNING: c has char, which may be end-of-line. */
490 /* Also: input_line_pointer->`\0` where c was. */
491 *input_line_pointer
= c
;
492 while (!is_end_of_line
[*input_line_pointer
])
494 input_line_pointer
++;
497 c
= *input_line_pointer
;
498 *input_line_pointer
= '\0';
500 md_assemble (s
); /* Assemble 1 instruction. */
502 *input_line_pointer
++ = c
;
504 /* We resume loop AFTER the end-of-line from this instruction */
509 } /* if (is_name_beginner(c) */
512 if (is_end_of_line
[c
])
515 } /* empty statement */
518 #if defined(LOCAL_LABELS_DOLLAR) || defined(LOCAL_LABELS_FB)
520 { /* local label ("4:") */
521 char *backup
= input_line_pointer
;
523 HANDLE_CONDITIONAL_ASSEMBLY ();
527 while (isdigit (*input_line_pointer
))
529 temp
= (temp
* 10) + *input_line_pointer
- '0';
530 ++input_line_pointer
;
531 } /* read the whole number */
533 #ifdef LOCAL_LABELS_DOLLAR
534 if (*input_line_pointer
== '$'
535 && *(input_line_pointer
+ 1) == ':')
537 input_line_pointer
+= 2;
539 if (dollar_label_defined (temp
))
541 as_fatal ("label \"%d$\" redefined", temp
);
544 define_dollar_label (temp
);
545 colon (dollar_label_name (temp
, 0));
548 #endif /* LOCAL_LABELS_DOLLAR */
550 #ifdef LOCAL_LABELS_FB
551 if (*input_line_pointer
++ == ':')
553 fb_label_instance_inc (temp
);
554 colon (fb_label_name (temp
, 0));
557 #endif /* LOCAL_LABELS_FB */
559 input_line_pointer
= backup
;
560 } /* local label ("4:") */
561 #endif /* LOCAL_LABELS_DOLLAR or LOCAL_LABELS_FB */
563 if (c
&& strchr (line_comment_chars
, c
))
564 { /* Its a comment. Better say APP or NO_APP */
570 extern char *scrub_string
, *scrub_last_string
;
572 bump_line_counters ();
573 s
= input_line_pointer
;
574 if (strncmp (s
, "APP\n", 4))
575 continue; /* We ignore it */
578 ends
= strstr (s
, "#NO_APP\n");
585 /* The end of the #APP wasn't in this buffer. We
586 keep reading in buffers until we find the #NO_APP
587 that goes with this #APP There is one. The specs
589 tmp_len
= buffer_limit
- s
;
590 tmp_buf
= xmalloc (tmp_len
);
591 bcopy (s
, tmp_buf
, tmp_len
);
594 new_tmp
= input_scrub_next_buffer (&buffer
);
598 buffer_limit
= new_tmp
;
599 input_line_pointer
= buffer
;
600 ends
= strstr (buffer
, "#NO_APP\n");
604 num
= buffer_limit
- buffer
;
606 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
607 bcopy (buffer
, tmp_buf
+ tmp_len
, num
);
612 input_line_pointer
= ends
? ends
+ 8 : NULL
;
620 input_line_pointer
= ends
+ 8;
622 new_buf
= xmalloc (100);
627 scrub_last_string
= ends
;
632 ch
= do_scrub_next_char (scrub_from_string
, scrub_to_string
);
636 if (new_tmp
== new_buf
+ new_length
)
638 new_buf
= xrealloc (new_buf
, new_length
+ 100);
639 new_tmp
= new_buf
+ new_length
;
647 old_input
= input_line_pointer
;
648 old_limit
= buffer_limit
;
650 input_line_pointer
= new_buf
;
651 buffer_limit
= new_tmp
;
655 HANDLE_CONDITIONAL_ASSEMBLY ();
657 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
658 input_line_pointer
--; /* Report unknown char as ignored. */
659 ignore_rest_of_line ();
660 } /* while (input_line_pointer<buffer_limit) */
663 bump_line_counters ();
667 input_line_pointer
= old_input
;
668 buffer_limit
= old_limit
;
673 } /* while (more buffers to scan) */
674 input_scrub_close (); /* Close the input file */
676 } /* read_a_source_file() */
681 as_fatal (".abort detected. Abandoning ship.");
684 /* For machines where ".align 4" means align to a 4 byte boundary. */
689 register unsigned int temp
;
690 register long temp_fill
;
692 unsigned long max_alignment
= 1 << 15;
694 if (is_end_of_line
[*input_line_pointer
])
695 temp
= arg
; /* Default value from pseudo-op table */
697 temp
= get_absolute_expression ();
699 if (temp
> max_alignment
)
701 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
705 * For the sparc, `.align (1<<n)' actually means `.align n'
706 * so we have to convert it.
710 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
714 as_bad ("Alignment not a power of 2");
717 if (*input_line_pointer
== ',')
719 input_line_pointer
++;
720 temp_fill
= get_absolute_expression ();
722 else if (now_seg
!= SEG_DATA
&& now_seg
!= SEG_BSS
)
723 temp_fill
= NOP_OPCODE
;
726 /* Only make a frag if we HAVE to. . . */
727 if (temp
&& !need_pass_2
)
728 frag_align (temp
, (int) temp_fill
);
730 demand_empty_rest_of_line ();
731 } /* s_align_bytes() */
733 /* For machines where ".align 4" means align to 2**4 boundary. */
738 register long temp_fill
;
739 long max_alignment
= 15;
741 temp
= get_absolute_expression ();
742 if (temp
> max_alignment
)
743 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
746 as_bad ("Alignment negative. 0 assumed.");
749 if (*input_line_pointer
== ',')
751 input_line_pointer
++;
752 temp_fill
= get_absolute_expression ();
754 else if (now_seg
!= SEG_DATA
&& now_seg
!= SEG_BSS
)
755 temp_fill
= NOP_OPCODE
;
758 /* Only make a frag if we HAVE to. . . */
759 if (temp
&& !need_pass_2
)
760 frag_align (temp
, (int) temp_fill
);
762 record_alignment (now_seg
, temp
);
764 demand_empty_rest_of_line ();
765 } /* s_align_ptwo() */
774 register symbolS
*symbolP
;
776 name
= input_line_pointer
;
777 c
= get_symbol_end ();
778 /* just after name is now '\0' */
779 p
= input_line_pointer
;
782 if (*input_line_pointer
!= ',')
784 as_bad ("Expected comma after symbol-name: rest of line ignored.");
785 ignore_rest_of_line ();
788 input_line_pointer
++; /* skip ',' */
789 if ((temp
= get_absolute_expression ()) < 0)
791 as_warn (".COMMon length (%d.) <0! Ignored.", temp
);
792 ignore_rest_of_line ();
796 symbolP
= symbol_find_or_make (name
);
798 if (S_IS_DEFINED (symbolP
))
800 as_bad ("Ignoring attempt to re-define symbol");
801 ignore_rest_of_line ();
804 if (S_GET_VALUE (symbolP
))
806 if (S_GET_VALUE (symbolP
) != temp
)
807 as_bad ("Length of .comm \"%s\" is already %d. Not changed to %d.",
808 S_GET_NAME (symbolP
),
809 S_GET_VALUE (symbolP
),
814 S_SET_VALUE (symbolP
, temp
);
815 S_SET_EXTERNAL (symbolP
);
819 symbolP
->sy_other
= const_flag
;
821 know (symbolP
->sy_frag
== &zero_address_frag
);
822 demand_empty_rest_of_line ();
830 temp
= get_absolute_expression ();
832 subseg_new (SEG_E1
, (subsegT
) temp
);
834 subseg_new (SEG_DATA
, (subsegT
) temp
);
840 demand_empty_rest_of_line ();
849 /* Some assemblers tolerate immediately following '"' */
850 if ((s
= demand_copy_string (&length
)) != 0)
852 new_logical_line (s
, -1);
853 demand_empty_rest_of_line ();
856 c_dot_file_symbol (s
);
857 #endif /* OBJ_COFF */
863 long temp_repeat
= 0;
865 register long temp_fill
= 0;
869 temp_repeat
= get_absolute_expression ();
870 if (*input_line_pointer
== ',')
872 input_line_pointer
++;
873 temp_size
= get_absolute_expression ();
874 if (*input_line_pointer
== ',')
876 input_line_pointer
++;
877 temp_fill
= get_absolute_expression ();
881 * This is to be compatible with BSD 4.2 AS, not for any rational reason.
883 #define BSD_FILL_SIZE_CROCK_8 (8)
884 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
886 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
887 temp_size
= BSD_FILL_SIZE_CROCK_8
;
891 as_warn ("Size negative: .fill ignored.");
894 else if (temp_repeat
<= 0)
896 as_warn ("Repeat < 0, .fill ignored");
900 if (temp_size
&& !need_pass_2
)
902 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
903 bzero (p
, (int) temp_size
);
905 * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX flavoured AS.
906 * The following bizzare behaviour is to be compatible with above.
907 * I guess they tried to take up to 8 bytes from a 4-byte expression
908 * and they forgot to sign extend. Un*x Sux.
910 #define BSD_FILL_SIZE_CROCK_4 (4)
911 md_number_to_chars (p
, temp_fill
, temp_size
> BSD_FILL_SIZE_CROCK_4
? BSD_FILL_SIZE_CROCK_4
: (int) temp_size
);
913 * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
914 * but emits no error message because it seems a legal thing to do.
915 * It is a degenerate case of .fill but could be emitted by a compiler.
918 demand_empty_rest_of_line ();
927 temp
= get_absolute_expression ();
929 as_warn ("Block number <0. Ignored.");
930 else if (flagseen
['G'])
931 gdb_block_beg ((long) temp
, frag_now
, (long) (obstack_next_free (&frags
) - frag_now
->fr_literal
));
932 demand_empty_rest_of_line ();
938 register int position
;
941 if (get_absolute_expression_and_terminator (&temp
) != ',')
943 as_bad ("expected comma before position in .gdbblock");
944 --input_line_pointer
;
945 ignore_rest_of_line ();
948 position
= get_absolute_expression ();
950 gdb_block_position ((long) temp
, (long) position
);
951 demand_empty_rest_of_line ();
959 temp
= get_absolute_expression ();
961 as_warn ("Block number <0. Ignored.");
962 else if (flagseen
['G'])
963 gdb_block_end ((long) temp
, frag_now
, (long) (obstack_next_free (&frags
) - frag_now
->fr_literal
));
964 demand_empty_rest_of_line ();
970 register char *name
, *p
;
972 register symbolS
*symbolP
;
975 name
= input_line_pointer
;
976 c
= get_symbol_end ();
977 p
= input_line_pointer
;
978 symbolP
= symbol_find_or_make (name
);
981 if (*input_line_pointer
!= ',')
983 as_bad ("Expected comma after name");
984 ignore_rest_of_line ();
987 input_line_pointer
++;
988 if ((temp
= get_absolute_expression ()) < 0)
990 as_bad ("Bad GDB symbol file offset (%d.) <0! Ignored.", temp
);
991 ignore_rest_of_line ();
995 gdb_symbols_fixup (symbolP
, (long) temp
);
996 demand_empty_rest_of_line ();
1002 int file_number
, lineno
;
1004 if (get_absolute_expression_and_terminator (&file_number
) != ',')
1006 as_bad ("expected comman after filenum in .gdbline");
1007 ignore_rest_of_line ();
1010 lineno
= get_absolute_expression ();
1012 gdb_line (file_number
, lineno
);
1013 demand_empty_rest_of_line ();
1020 int file_number
, offset
;
1022 if (get_absolute_expression_and_terminator (&file_number
) != ',')
1024 as_bad ("expected comma after filenum in .gdblinetab");
1025 ignore_rest_of_line ();
1028 offset
= get_absolute_expression ();
1030 gdb_line_tab (file_number
, offset
);
1031 demand_empty_rest_of_line ();
1039 register char *name
;
1041 register symbolS
*symbolP
;
1045 name
= input_line_pointer
;
1046 c
= get_symbol_end ();
1047 symbolP
= symbol_find_or_make (name
);
1048 *input_line_pointer
= c
;
1050 S_SET_EXTERNAL (symbolP
);
1053 input_line_pointer
++;
1055 if (*input_line_pointer
== '\n')
1060 demand_empty_rest_of_line ();
1064 s_lcomm (needs_align
)
1065 int needs_align
; /* 1 if this was a ".bss" directive, which may require
1066 * a 3rd argument (alignment).
1067 * 0 if it was an ".lcomm" (2 args only)
1070 register char *name
;
1074 register symbolS
*symbolP
;
1075 const int max_alignment
= 15;
1078 name
= input_line_pointer
;
1079 c
= get_symbol_end ();
1080 p
= input_line_pointer
;
1083 if (*input_line_pointer
!= ',')
1085 as_bad ("Expected comma after name");
1086 ignore_rest_of_line ();
1090 ++input_line_pointer
;
1092 if (*input_line_pointer
== '\n')
1094 as_bad ("Missing size expression");
1098 if ((temp
= get_absolute_expression ()) < 0)
1100 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1101 ignore_rest_of_line ();
1109 if (*input_line_pointer
!= ',')
1111 as_bad ("Expected comma after size");
1112 ignore_rest_of_line ();
1115 input_line_pointer
++;
1117 if (*input_line_pointer
== '\n')
1119 as_bad ("Missing alignment");
1122 align
= get_absolute_expression ();
1123 if (align
> max_alignment
)
1125 align
= max_alignment
;
1126 as_warn ("Alignment too large: %d. assumed.", align
);
1131 as_warn ("Alignment negative. 0 assumed.");
1133 #ifdef MANY_SEGMENTS
1134 #define SEG_BSS SEG_E2
1135 record_alignment (SEG_E2
, align
);
1137 record_alignment (SEG_BSS
, align
);
1139 } /* if needs align */
1142 symbolP
= symbol_find_or_make (name
);
1146 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1147 S_GET_OTHER (symbolP
) == 0 &&
1148 S_GET_DESC (symbolP
) == 0 &&
1149 #endif /* OBJ_AOUT or OBJ_BOUT */
1150 (((S_GET_SEGMENT (symbolP
) == SEG_BSS
) && (S_GET_VALUE (symbolP
) == local_bss_counter
))
1151 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1156 align
= ~((~0) << align
); /* Convert to a mask */
1158 (local_bss_counter
+ align
) & (~align
);
1161 S_SET_VALUE (symbolP
, local_bss_counter
);
1162 S_SET_SEGMENT (symbolP
, SEG_BSS
);
1164 /* The symbol may already have been created with a preceding
1165 * ".globl" directive -- be careful not to step on storage
1166 * class in that case. Otherwise, set it to static.
1168 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1170 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1172 #endif /* OBJ_COFF */
1173 symbolP
->sy_frag
= &bss_address_frag
;
1174 local_bss_counter
+= temp
;
1178 as_bad ("Ignoring attempt to re-define symbol from %d. to %d.",
1179 S_GET_VALUE (symbolP
), local_bss_counter
);
1181 demand_empty_rest_of_line ();
1201 register char *name
;
1204 register segT segment
;
1206 register symbolS
*symbolP
;
1208 /* we permit ANY defined expression: BSD4.2 demands constants */
1209 name
= input_line_pointer
;
1210 c
= get_symbol_end ();
1211 p
= input_line_pointer
;
1214 if (*input_line_pointer
!= ',')
1217 as_bad ("Expected comma after name \"%s\"", name
);
1219 ignore_rest_of_line ();
1222 input_line_pointer
++;
1223 segment
= expression (&exp
);
1224 if (segment
!= SEG_ABSOLUTE
1225 #ifdef MANY_SEGMENTS
1226 && !(segment
>= SEG_E0
&& segment
<= SEG_UNKNOWN
)
1228 && segment
!= SEG_DATA
1229 && segment
!= SEG_TEXT
1230 && segment
!= SEG_BSS
1232 && segment
!= SEG_REGISTER
)
1234 as_bad ("Bad expression: %s", segment_name (segment
));
1235 ignore_rest_of_line ();
1239 symbolP
= symbol_find_or_make (name
);
1241 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0
1242 && symbolP->sy_desc == 0) out of this test
1243 because coff doesn't have those fields, and I
1244 can't see when they'd ever be tripped. I don't
1245 think I understand why they were here so I may
1246 have introduced a bug. As recently as 1.37 didn't
1247 have this test anyway. xoxorich. */
1249 if (S_GET_SEGMENT (symbolP
) == SEG_UNKNOWN
1250 && S_GET_VALUE (symbolP
) == 0)
1252 /* The name might be an undefined .global symbol; be
1253 sure to keep the "external" bit. */
1254 S_SET_SEGMENT (symbolP
, segment
);
1255 S_SET_VALUE (symbolP
, (valueT
) (exp
.X_add_number
));
1259 as_bad ("Symbol %s already defined", name
);
1262 demand_empty_rest_of_line ();
1268 register segT segment
;
1270 register long temp_fill
;
1273 * Don't believe the documentation of BSD 4.2 AS.
1274 * There is no such thing as a sub-segment-relative origin.
1275 * Any absolute origin is given a warning, then assumed to be segment-relative.
1276 * Any segmented origin expression ("foo+42") had better be in the right
1277 * segment or the .org is ignored.
1279 * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
1280 * never know sub-segment sizes when we are reading code.
1281 * BSD will crash trying to emit -ve numbers of filler bytes in certain
1282 * .orgs. We don't crash, but see as-write for that code.
1285 * Don't make frag if need_pass_2==1.
1287 segment
= get_known_segmented_expression (&exp
);
1288 if (*input_line_pointer
== ',')
1290 input_line_pointer
++;
1291 temp_fill
= get_absolute_expression ();
1297 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
1298 as_bad ("Invalid segment \"%s\". Segment \"%s\" assumed.",
1299 segment_name (segment
), segment_name (now_seg
));
1300 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
1301 exp
.X_add_number
, (char *) 0);
1303 } /* if (ok to make frag) */
1304 demand_empty_rest_of_line ();
1310 register char *name
;
1311 register char delim
;
1312 register char *end_name
;
1313 register symbolS
*symbolP
;
1316 * Especial apologies for the random logic:
1317 * this just grew, and could be parsed much more simply!
1320 name
= input_line_pointer
;
1321 delim
= get_symbol_end ();
1322 end_name
= input_line_pointer
;
1326 if (*input_line_pointer
!= ',')
1329 as_bad ("Expected comma after name \"%s\"", name
);
1331 ignore_rest_of_line ();
1335 input_line_pointer
++;
1338 if (name
[0] == '.' && name
[1] == '\0')
1340 /* Turn '. = mumble' into a .org mumble */
1341 register segT segment
;
1345 segment
= get_known_segmented_expression (&exp
);
1349 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
1350 as_bad ("Invalid segment \"%s\". Segment \"%s\" assumed.",
1351 segment_name (segment
),
1352 segment_name (now_seg
));
1353 ptr
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
1354 exp
.X_add_number
, (char *) 0);
1356 } /* if (ok to make frag) */
1362 if ((symbolP
= symbol_find (name
)) == NULL
1363 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
1365 symbolP
= symbol_new (name
,
1368 &zero_address_frag
);
1370 /* "set" symbols are local unless otherwise specified. */
1371 SF_SET_LOCAL (symbolP
);
1372 #endif /* OBJ_COFF */
1374 } /* make a new symbol */
1376 symbol_table_insert (symbolP
);
1379 pseudo_set (symbolP
);
1380 demand_empty_rest_of_line ();
1388 register long temp_fill
;
1391 /* Just like .fill, but temp_size = 1 */
1392 if (get_absolute_expression_and_terminator (&temp_repeat
) == ',')
1394 temp_fill
= get_absolute_expression ();
1398 input_line_pointer
--; /* Backup over what was not a ','. */
1405 if (temp_repeat
<= 0)
1407 as_warn ("Repeat < 0, .space ignored");
1408 ignore_rest_of_line ();
1413 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
1414 temp_repeat
, (char *) 0);
1417 demand_empty_rest_of_line ();
1425 temp
= get_absolute_expression ();
1426 #ifdef MANY_SEGMENTS
1427 subseg_new (SEG_E0
, (subsegT
) temp
);
1429 subseg_new (SEG_TEXT
, (subsegT
) temp
);
1431 demand_empty_rest_of_line ();
1435 /*(JF was static, but can't be if machine dependent pseudo-ops are to use it */
1438 demand_empty_rest_of_line ()
1441 if (is_end_of_line
[*input_line_pointer
])
1443 input_line_pointer
++;
1447 ignore_rest_of_line ();
1449 /* Return having already swallowed end-of-line. */
1450 } /* Return pointing just after end-of-line. */
1453 ignore_rest_of_line () /* For suspect lines: gives warning. */
1455 if (!is_end_of_line
[*input_line_pointer
])
1457 if (isprint (*input_line_pointer
))
1458 as_bad ("Rest of line ignored. First ignored character is `%c'.",
1459 *input_line_pointer
);
1461 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
1462 *input_line_pointer
);
1463 while (input_line_pointer
< buffer_limit
1464 && !is_end_of_line
[*input_line_pointer
])
1466 input_line_pointer
++;
1469 input_line_pointer
++; /* Return pointing just after end-of-line. */
1470 know (is_end_of_line
[input_line_pointer
[-1]]);
1476 * In: Pointer to a symbol.
1477 * Input_line_pointer->expression.
1479 * Out: Input_line_pointer->just after any whitespace after expression.
1480 * Tried to set symbol to value of expression.
1481 * Will change symbols type, value, and frag;
1482 * May set need_pass_2 == 1.
1485 pseudo_set (symbolP
)
1489 register segT segment
;
1490 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1492 #endif /* OBJ_AOUT or OBJ_BOUT */
1494 know (symbolP
); /* NULL pointer is logic error. */
1495 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1496 ext
= S_IS_EXTERNAL (symbolP
);
1497 #endif /* OBJ_AOUT or OBJ_BOUT */
1499 if ((segment
= expression (&exp
)) == SEG_ABSENT
)
1501 as_bad ("Missing expression: absolute 0 assumed");
1502 exp
.X_seg
= SEG_ABSOLUTE
;
1503 exp
.X_add_number
= 0;
1509 S_SET_SEGMENT (symbolP
, SEG_REGISTER
);
1510 S_SET_VALUE (symbolP
, exp
.X_add_number
);
1511 symbolP
->sy_frag
= &zero_address_frag
;
1515 as_bad ("%s number invalid. Absolute 0 assumed.",
1516 exp
.X_add_number
> 0 ? "Bignum" : "Floating-Point");
1517 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1518 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1519 ext
? S_SET_EXTERNAL (symbolP
) :
1520 S_CLEAR_EXTERNAL (symbolP
);
1521 #endif /* OBJ_AOUT or OBJ_BOUT */
1522 S_SET_VALUE (symbolP
, 0);
1523 symbolP
->sy_frag
= &zero_address_frag
;
1527 as_warn ("No expression: Using absolute 0");
1528 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1529 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1530 ext
? S_SET_EXTERNAL (symbolP
) :
1531 S_CLEAR_EXTERNAL (symbolP
);
1532 #endif /* OBJ_AOUT or OBJ_BOUT */
1533 S_SET_VALUE (symbolP
, 0);
1534 symbolP
->sy_frag
= &zero_address_frag
;
1537 case SEG_DIFFERENCE
:
1538 if (exp
.X_add_symbol
&& exp
.X_subtract_symbol
1539 && (S_GET_SEGMENT (exp
.X_add_symbol
) ==
1540 S_GET_SEGMENT (exp
.X_subtract_symbol
)))
1542 if (exp
.X_add_symbol
->sy_frag
!= exp
.X_subtract_symbol
->sy_frag
)
1544 as_bad ("Unknown expression: symbols %s and %s are in different frags.",
1545 S_GET_NAME (exp
.X_add_symbol
), S_GET_NAME (exp
.X_subtract_symbol
));
1548 exp
.X_add_number
+= S_GET_VALUE (exp
.X_add_symbol
) -
1549 S_GET_VALUE (exp
.X_subtract_symbol
);
1552 as_bad ("Complex expression. Absolute segment assumed.");
1554 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1555 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1556 ext
? S_SET_EXTERNAL (symbolP
) :
1557 S_CLEAR_EXTERNAL (symbolP
);
1558 #endif /* OBJ_AOUT or OBJ_BOUT */
1559 S_SET_VALUE (symbolP
, exp
.X_add_number
);
1560 symbolP
->sy_frag
= &zero_address_frag
;
1564 #ifdef MANY_SEGMENTS
1565 S_SET_SEGMENT (symbolP
, segment
);
1570 S_SET_SEGMENT (symbolP
, SEG_DATA
);
1573 S_SET_SEGMENT (symbolP
, SEG_TEXT
);
1576 S_SET_SEGMENT (symbolP
, SEG_BSS
);
1580 as_fatal ("failed sanity check.");
1581 } /* switch on segment */
1583 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1586 S_SET_EXTERNAL (symbolP
);
1590 S_CLEAR_EXTERNAL (symbolP
);
1592 #endif /* OBJ_AOUT or OBJ_BOUT */
1594 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
1595 symbolP
->sy_frag
= exp
.X_add_symbol
->sy_frag
;
1598 case SEG_PASS1
: /* Not an error. Just try another pass. */
1599 symbolP
->sy_forward
= exp
.X_add_symbol
;
1600 as_bad ("Unknown expression");
1601 know (need_pass_2
== 1);
1605 symbolP
->sy_forward
= exp
.X_add_symbol
;
1606 /* as_warn("unknown symbol"); */
1607 /* need_pass_2 = 1; */
1618 * CONStruct more frag of .bytes, or .words etc.
1619 * Should need_pass_2 be 1 then emit no frag(s).
1620 * This understands EXPRESSIONS, as opposed to big_cons().
1624 * This has a split personality. We use expression() to read the
1625 * value. We can detect if the value won't fit in a byte or word.
1626 * But we can't detect if expression() discarded significant digits
1627 * in the case of a long. Not worth the crocks required to fix it.
1630 /* worker to do .byte etc statements */
1631 /* clobbers input_line_pointer, checks */
1635 register unsigned int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1638 register long mask
; /* High-order bits we will left-truncate, */
1639 /* but includes sign bit also. */
1640 register long get
; /* what we get */
1641 register long use
; /* get after truncation. */
1642 register long unmask
; /* what bits we will store */
1644 register segT segment
;
1648 * Input_line_pointer->1st char after pseudo-op-code and could legally
1649 * be a end-of-line. (Or, less legally an eof - which we cope with.)
1651 /* JF << of >= number of bits in the object is undefined. In particular
1652 SPARC (Sun 4) has problems */
1654 if (nbytes
>= sizeof (long))
1660 mask
= ~0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
1661 } /* bigger than a long */
1663 unmask
= ~mask
; /* Do store these bits. */
1666 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
1667 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
1671 * The following awkward logic is to parse ZERO or more expressions,
1672 * comma seperated. Recall an expression includes its leading &
1673 * trailing blanks. We fake a leading ',' if there is (supposed to
1674 * be) a 1st expression, and keep demanding 1 expression for each ','.
1676 if (is_it_end_of_statement ())
1678 c
= 0; /* Skip loop. */
1679 input_line_pointer
++; /* Matches end-of-loop 'correction'. */
1684 } /* if the end else fake it */
1689 #ifdef WANT_BITFIELDS
1690 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
1691 /* used for error messages and rescanning */
1692 char *hold
= input_line_pointer
;
1693 #endif /* WANT_BITFIELDS */
1695 if (*input_line_pointer
== '\'')
1697 /* An MRI style string, cut into as many bytes as will fit
1698 into a nbyte chunk, left justify if necessary, and sepatate
1699 with commas so we can try again later */
1701 unsigned int result
= 0;
1702 input_line_pointer
++;
1703 for (scan
= 0; scan
< nbytes
; scan
++)
1705 if (*input_line_pointer
== '\'')
1707 if (input_line_pointer
[1] == '\'')
1709 input_line_pointer
++;
1714 result
= (result
<< 8) | (*input_line_pointer
++);
1718 while (scan
< nbytes
)
1723 /* Create correct expression */
1724 exp
.X_add_symbol
= 0;
1725 exp
.X_add_number
= result
;
1726 exp
.X_seg
= segment
= SEG_ABSOLUTE
;
1727 /* Fake it so that we can read the next char too */
1728 if (input_line_pointer
[0] != '\'' ||
1729 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
1731 input_line_pointer
-= 2;
1732 input_line_pointer
[0] = ',';
1733 input_line_pointer
[1] = '\'';
1736 input_line_pointer
++;
1741 /* At least scan over the expression. */
1742 segment
= expression (&exp
);
1744 #ifdef WANT_BITFIELDS
1745 /* Some other assemblers, (eg, asm960), allow
1746 bitfields after ".byte" as w:x,y:z, where w and
1747 y are bitwidths and x and y are values. They
1748 then pack them all together. We do a little
1749 better in that we allow them in words, longs,
1750 etc. and we'll pack them in target byte order
1753 The rules are: pack least significat bit first,
1754 if a field doesn't entirely fit, put it in the
1755 next unit. Overflowing the bitfield is
1756 explicitly *not* even a warning. The bitwidth
1757 should be considered a "mask".
1759 FIXME-SOMEDAY: If this is considered generally
1760 useful, this logic should probably be reworked.
1763 if (*input_line_pointer
== ':')
1769 unsigned long width
;
1771 if (*input_line_pointer
!= ':')
1773 input_line_pointer
= hold
;
1775 } /* next piece is not a bitfield */
1777 /* In the general case, we can't allow
1778 full expressions with symbol
1779 differences and such. The relocation
1780 entries for symbols not defined in this
1781 assembly would require arbitrary field
1782 widths, positions, and masks which most
1783 of our current object formats don't
1786 In the specific case where a symbol
1787 *is* defined in this assembly, we
1788 *could* build fixups and track it, but
1789 this could lead to confusion for the
1790 backends. I'm lazy. I'll take any
1791 SEG_ABSOLUTE. I think that means that
1792 you can use a previous .set or
1793 .equ type symbol. xoxorich. */
1795 if (segment
== SEG_ABSENT
)
1797 as_warn ("Using a bit field width of zero.");
1798 exp
.X_add_number
= 0;
1799 segment
= SEG_ABSOLUTE
;
1800 } /* implied zero width bitfield */
1802 if (segment
!= SEG_ABSOLUTE
)
1804 *input_line_pointer
= '\0';
1805 as_bad ("Field width \"%s\" too complex for a bitfield.\n", hold
);
1806 *input_line_pointer
= ':';
1807 demand_empty_rest_of_line ();
1811 if ((width
= exp
.X_add_number
) > (BITS_PER_CHAR
* nbytes
))
1813 as_warn ("Field width %d too big to fit in %d bytes: truncated to %d bits.",
1814 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
1815 width
= BITS_PER_CHAR
* nbytes
;
1818 if (width
> bits_available
)
1820 /* FIXME-SOMEDAY: backing up and
1821 reparsing is wasteful */
1822 input_line_pointer
= hold
;
1823 exp
.X_add_number
= value
;
1827 hold
= ++input_line_pointer
; /* skip ':' */
1829 if ((segment
= expression (&exp
)) != SEG_ABSOLUTE
)
1831 char cache
= *input_line_pointer
;
1833 *input_line_pointer
= '\0';
1834 as_bad ("Field value \"%s\" too complex for a bitfield.\n", hold
);
1835 *input_line_pointer
= cache
;
1836 demand_empty_rest_of_line ();
1840 value
|= (~(-1 << width
) & exp
.X_add_number
)
1841 << ((BITS_PER_CHAR
* nbytes
) - bits_available
);
1843 if ((bits_available
-= width
) == 0
1844 || is_it_end_of_statement ()
1845 || *input_line_pointer
!= ',')
1848 } /* all the bitfields we're gonna get */
1850 hold
= ++input_line_pointer
;
1851 segment
= expression (&exp
);
1852 } /* forever loop */
1854 exp
.X_add_number
= value
;
1855 segment
= SEG_ABSOLUTE
;
1856 } /* if looks like a bitfield */
1857 #endif /* WANT_BITFIELDS */
1860 { /* Still worthwhile making frags. */
1862 /* Don't call this if we are going to junk this pass anyway! */
1863 know (segment
!= SEG_PASS1
);
1865 if (segment
== SEG_DIFFERENCE
&& exp
.X_add_symbol
== NULL
)
1867 as_bad ("Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
1868 S_GET_NAME (exp
.X_subtract_symbol
),
1869 segment_name (S_GET_SEGMENT (exp
.X_subtract_symbol
)));
1870 segment
= SEG_ABSOLUTE
;
1871 /* Leave exp . X_add_number alone. */
1873 p
= frag_more (nbytes
);
1877 as_bad ("%s number invalid. Absolute 0 assumed.",
1878 exp
.X_add_number
> 0 ? "Bignum" : "Floating-Point");
1879 md_number_to_chars (p
, (long) 0, nbytes
);
1883 as_warn ("0 assumed for missing expression");
1884 exp
.X_add_number
= 0;
1885 know (exp
.X_add_symbol
== NULL
);
1886 /* fall into SEG_ABSOLUTE */
1888 get
= exp
.X_add_number
;
1890 if ((get
& mask
) && (get
& mask
) != mask
)
1891 { /* Leading bits contain both 0s & 1s. */
1892 as_warn ("Value 0x%x truncated to 0x%x.", get
, use
);
1894 md_number_to_chars (p
, use
, nbytes
); /* put bytes in right order. */
1897 case SEG_DIFFERENCE
:
1898 #ifndef WORKING_DOT_WORD
1901 struct broken_word
*x
;
1903 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
1904 x
->next_broken_word
= broken_words
;
1907 x
->word_goes_here
= p
;
1909 x
->add
= exp
.X_add_symbol
;
1910 x
->sub
= exp
.X_subtract_symbol
;
1911 x
->addnum
= exp
.X_add_number
;
1916 /* Else Fall through into. . . */
1921 fix_new_ns32k (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1922 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1923 exp
.X_add_number
, 0, 0, 2, 0, 0);
1925 # if defined(TC_SPARC) || defined(TC_A29K)
1926 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1927 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1928 exp
.X_add_number
, 0, RELOC_32
);
1930 # if defined(TC_H8300)
1931 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1932 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1933 exp
.X_add_number
, 0, R_RELWORD
);
1937 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1938 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1939 exp
.X_add_number
, 0, NO_RELOC
);
1941 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1942 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1943 exp
.X_add_number
, 0, 0);
1944 #endif /* NO_RELOC */
1945 # endif /* tc_h8300 */
1946 # endif /* tc_sparc|tc_a29k */
1947 #endif /* TC_NS32K */
1949 } /* switch(segment) */
1950 } /* if (!need_pass_2) */
1951 c
= *input_line_pointer
++;
1952 } /* while(c==',') */
1953 input_line_pointer
--; /* Put terminator back into stream. */
1954 demand_empty_rest_of_line ();
1960 * CONStruct more frag(s) of .quads, or .octa etc.
1961 * Makes 0 or more new frags.
1962 * If need_pass_2 == 1, generate no frag.
1963 * This understands only bignums, not expressions. Cons() understands
1966 * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
1968 * This creates objects with struct obstack_control objs, destroying
1969 * any context objs held about a partially completed object. Beware!
1972 * I think it sucks to have 2 different types of integers, with 2
1973 * routines to read them, store them etc.
1974 * It would be nicer to permit bignums in expressions and only
1975 * complain if the result overflowed. However, due to "efficiency"...
1977 /* worker to do .quad etc statements */
1978 /* clobbers input_line_pointer, checks */
1980 /* 8=.quad 16=.octa ... */
1984 register int nbytes
;
1986 register char c
; /* input_line_pointer->c. */
1988 register long length
; /* Number of chars in an object. */
1989 register int digit
; /* Value of 1 digit. */
1990 register int carry
; /* For multi-precision arithmetic. */
1991 register int work
; /* For multi-precision arithmetic. */
1992 register char *p
; /* For multi-precision arithmetic. */
1994 extern char hex_value
[]; /* In hex_value.c. */
1997 * The following awkward logic is to parse ZERO or more strings,
1998 * comma seperated. Recall an expression includes its leading &
1999 * trailing blanks. We fake a leading ',' if there is (supposed to
2000 * be) a 1st expression, and keep demanding 1 expression for each ','.
2002 if (is_it_end_of_statement ())
2004 c
= 0; /* Skip loop. */
2008 c
= ','; /* Do loop. */
2009 --input_line_pointer
;
2013 ++input_line_pointer
;
2015 c
= *input_line_pointer
;
2016 /* C contains 1st non-blank character of what we hope is a number. */
2019 c
= *++input_line_pointer
;
2020 if (c
== 'x' || c
== 'X')
2022 c
= *++input_line_pointer
;
2035 * This feature (?) is here to stop people worrying about
2036 * mysterious zero constants: which is what they get when
2037 * they completely omit digits.
2039 if (hex_value
[c
] >= radix
)
2041 as_bad ("Missing digits. 0 assumed.");
2043 bignum_high
= bignum_low
- 1; /* Start constant with 0 chars. */
2044 for (; (digit
= hex_value
[c
]) < radix
; c
= *++input_line_pointer
)
2046 /* Multiply existing number by radix, then add digit. */
2048 for (p
= bignum_low
; p
<= bignum_high
; p
++)
2050 work
= (*p
& MASK_CHAR
) * radix
+ carry
;
2051 *p
= work
& MASK_CHAR
;
2052 carry
= work
>> BITS_PER_CHAR
;
2057 *bignum_high
= carry
& MASK_CHAR
;
2058 know ((carry
& ~MASK_CHAR
) == 0);
2061 length
= bignum_high
- bignum_low
+ 1;
2062 if (length
> nbytes
)
2064 as_warn ("Most significant bits truncated in integer constant.");
2068 register long leading_zeroes
;
2070 for (leading_zeroes
= nbytes
- length
;
2080 p
= frag_more (nbytes
);
2081 bcopy (bignum_low
, p
, (int) nbytes
);
2083 /* C contains character after number. */
2085 c
= *input_line_pointer
;
2086 /* C contains 1st non-blank character after number. */
2088 demand_empty_rest_of_line ();
2091 /* Extend bignum by 1 char. */
2095 register long length
;
2098 if (bignum_high
>= bignum_limit
)
2100 length
= bignum_limit
- bignum_low
;
2101 bignum_low
= xrealloc (bignum_low
, length
+ length
);
2102 bignum_high
= bignum_low
+ length
;
2103 bignum_limit
= bignum_low
+ length
+ length
;
2105 } /* grow_bignum(); */
2110 * CONStruct some more frag chars of .floats .ffloats etc.
2111 * Makes 0 or more new frags.
2112 * If need_pass_2 == 1, no frags are emitted.
2113 * This understands only floating literals, not expressions. Sorry.
2115 * A floating constant is defined by atof_generic(), except it is preceded
2116 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
2117 * reading, I decided to be incompatible. This always tries to give you
2118 * rounded bits to the precision of the pseudo-op. Former AS did premature
2119 * truncatation, restored noisy bits instead of trailing 0s AND gave you
2120 * a choice of 2 flavours of noise according to which of 2 floating-point
2121 * scanners you directed AS to use.
2123 * In: input_line_pointer->whitespace before, or '0' of flonum.
2127 void /* JF was static, but can't be if VAX.C is goning to use it */
2128 float_cons (float_type
) /* Worker to do .float etc statements. */
2129 /* Clobbers input_line-pointer, checks end-of-line. */
2130 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
2134 int length
; /* Number of chars in an object. */
2135 register char *err
; /* Error from scanning floating literal. */
2136 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2139 * The following awkward logic is to parse ZERO or more strings,
2140 * comma seperated. Recall an expression includes its leading &
2141 * trailing blanks. We fake a leading ',' if there is (supposed to
2142 * be) a 1st expression, and keep demanding 1 expression for each ','.
2144 if (is_it_end_of_statement ())
2146 c
= 0; /* Skip loop. */
2147 ++input_line_pointer
; /*->past termintor. */
2151 c
= ','; /* Do loop. */
2155 /* input_line_pointer->1st char of a flonum (we hope!). */
2157 /* Skip any 0{letter} that may be present. Don't even check if the
2158 * letter is legal. Someone may invent a "z" format and this routine
2159 * has no use for such information. Lusers beware: you get
2160 * diagnostics if your input is ill-conditioned.
2163 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2164 input_line_pointer
+= 2;
2166 err
= md_atof (float_type
, temp
, &length
);
2167 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2171 as_bad ("Bad floating literal: %s", err
);
2172 ignore_rest_of_line ();
2173 /* Input_line_pointer->just after end-of-line. */
2174 c
= 0; /* Break out of loop. */
2180 p
= frag_more (length
);
2181 bcopy (temp
, p
, length
);
2184 c
= *input_line_pointer
++;
2185 /* C contains 1st non-white character after number. */
2186 /* input_line_pointer->just after terminator (c). */
2189 --input_line_pointer
; /*->terminator (is not ','). */
2190 demand_empty_rest_of_line ();
2191 } /* float_cons() */
2196 * We read 0 or more ',' seperated, double-quoted strings.
2198 * Caller should have checked need_pass_2 is FALSE because we don't check it.
2203 stringer (append_zero
) /* Worker to do .ascii etc statements. */
2204 /* Checks end-of-line. */
2205 register int append_zero
; /* 0: don't append '\0', else 1 */
2207 /* register char * p; JF unused */
2208 /* register int length; JF unused *//* Length of string we read, excluding */
2209 /* trailing '\0' implied by closing quote. */
2210 /* register char * where; JF unused */
2211 /* register fragS * fragP; JF unused */
2212 register unsigned int c
;
2215 * The following awkward logic is to parse ZERO or more strings,
2216 * comma seperated. Recall a string expression includes spaces
2217 * before the opening '\"' and spaces after the closing '\"'.
2218 * We fake a leading ',' if there is (supposed to be)
2219 * a 1st, expression. We keep demanding expressions for each
2222 if (is_it_end_of_statement ())
2224 c
= 0; /* Skip loop. */
2225 ++input_line_pointer
; /* Compensate for end of loop. */
2229 c
= ','; /* Do loop. */
2231 while (c
== ',' || c
== '<' || c
== '"')
2234 switch (*input_line_pointer
)
2237 ++input_line_pointer
; /*->1st char of string. */
2238 while (is_a_char (c
= next_char_of_string ()))
2240 FRAG_APPEND_1_CHAR (c
);
2244 FRAG_APPEND_1_CHAR (0);
2246 know (input_line_pointer
[-1] == '\"');
2249 input_line_pointer
++;
2250 c
= get_single_number ();
2251 FRAG_APPEND_1_CHAR (c
);
2252 if (*input_line_pointer
!= '>')
2254 as_bad ("Expected <nn>");
2256 input_line_pointer
++;
2259 input_line_pointer
++;
2263 c
= *input_line_pointer
;
2266 demand_empty_rest_of_line ();
2269 /* FIXME-SOMEDAY: I had trouble here on characters with the
2270 high bits set. We'll probably also have trouble with
2271 multibyte chars, wide chars, etc. Also be careful about
2272 returning values bigger than 1 byte. xoxorich. */
2275 next_char_of_string ()
2277 register unsigned int c
;
2279 c
= *input_line_pointer
++ & CHAR_MASK
;
2287 switch (c
= *input_line_pointer
++)
2317 break; /* As itself. */
2332 for (number
= 0; isdigit (c
); c
= *input_line_pointer
++)
2334 number
= number
* 8 + c
- '0';
2338 --input_line_pointer
;
2342 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
2343 as_warn ("Unterminated string: Newline inserted.");
2349 #ifdef ONLY_STANDARD_ESCAPES
2350 as_bad ("Bad escaped character in string, '?' assumed");
2352 #endif /* ONLY_STANDARD_ESCAPES */
2355 } /* switch on escaped char */
2360 } /* switch on char */
2362 } /* next_char_of_string() */
2365 get_segmented_expression (expP
)
2366 register expressionS
*expP
;
2368 register segT retval
;
2370 if ((retval
= expression (expP
)) == SEG_PASS1
|| retval
== SEG_ABSENT
|| retval
== SEG_BIG
)
2372 as_bad ("Expected address expression: absolute 0 assumed");
2373 retval
= expP
->X_seg
= SEG_ABSOLUTE
;
2374 expP
->X_add_number
= 0;
2375 expP
->X_add_symbol
= expP
->X_subtract_symbol
= 0;
2377 return (retval
); /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
2381 get_known_segmented_expression (expP
)
2382 register expressionS
*expP
;
2384 register segT retval
;
2385 register char *name1
;
2386 register char *name2
;
2388 if ((retval
= get_segmented_expression (expP
)) == SEG_UNKNOWN
)
2390 name1
= expP
->X_add_symbol
? S_GET_NAME (expP
->X_add_symbol
) : "";
2391 name2
= expP
->X_subtract_symbol
?
2392 S_GET_NAME (expP
->X_subtract_symbol
) :
2396 as_warn ("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
2401 as_warn ("Symbol \"%s\" undefined: absolute 0 assumed.",
2402 name1
? name1
: name2
);
2404 retval
= expP
->X_seg
= SEG_ABSOLUTE
;
2405 expP
->X_add_number
= 0;
2406 expP
->X_add_symbol
= expP
->X_subtract_symbol
= NULL
;
2408 #ifndef MANY_SEGMENTS
2409 know (retval
== SEG_ABSOLUTE
|| retval
== SEG_DATA
|| retval
== SEG_TEXT
|| retval
== SEG_BSS
|| retval
== SEG_DIFFERENCE
);
2413 } /* get_known_segmented_expression() */
2417 /* static */ long /* JF was static, but can't be if the MD pseudos are to use it */
2418 get_absolute_expression ()
2423 if ((s
= expression (&exp
)) != SEG_ABSOLUTE
)
2425 if (s
!= SEG_ABSENT
)
2427 as_bad ("Bad Absolute Expression, absolute 0 assumed.");
2429 exp
.X_add_number
= 0;
2431 return (exp
.X_add_number
);
2434 char /* return terminator */
2435 get_absolute_expression_and_terminator (val_pointer
)
2436 long *val_pointer
; /* return value of expression */
2438 *val_pointer
= get_absolute_expression ();
2439 return (*input_line_pointer
++);
2443 * demand_copy_C_string()
2445 * Like demand_copy_string, but return NULL if the string contains any '\0's.
2446 * Give a warning if that happens.
2449 demand_copy_C_string (len_pointer
)
2454 if ((s
= demand_copy_string (len_pointer
)) != 0)
2458 for (len
= *len_pointer
;
2467 as_bad ("This string may not contain \'\\0\'");
2475 * demand_copy_string()
2477 * Demand string, but return a safe (=private) copy of the string.
2478 * Return NULL if we can't read a string here.
2481 demand_copy_string (lenP
)
2484 register unsigned int c
;
2490 if (*input_line_pointer
== '\"')
2492 input_line_pointer
++; /* Skip opening quote. */
2494 while (is_a_char (c
= next_char_of_string ()))
2496 obstack_1grow (¬es
, c
);
2499 /* JF this next line is so demand_copy_C_string will return a null
2500 termanated string. */
2501 obstack_1grow (¬es
, '\0');
2502 retval
= obstack_finish (¬es
);
2506 as_warn ("Missing string");
2508 ignore_rest_of_line ();
2512 } /* demand_copy_string() */
2515 * is_it_end_of_statement()
2517 * In: Input_line_pointer->next character.
2519 * Do: Skip input_line_pointer over all whitespace.
2521 * Out: 1 if input_line_pointer->end-of-line.
2524 is_it_end_of_statement ()
2527 return (is_end_of_line
[*input_line_pointer
]);
2528 } /* is_it_end_of_statement() */
2534 register symbolS
*symbolP
; /* symbol we are working with */
2536 input_line_pointer
++;
2537 if (*input_line_pointer
== '=')
2538 input_line_pointer
++;
2540 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
2541 input_line_pointer
++;
2543 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
2545 /* Turn '. = mumble' into a .org mumble */
2546 register segT segment
;
2550 segment
= get_known_segmented_expression (&exp
);
2553 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
2554 as_warn ("Illegal segment \"%s\". Segment \"%s\" assumed.",
2555 segment_name (segment
),
2556 segment_name (now_seg
));
2557 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
2558 exp
.X_add_number
, (char *) 0);
2560 } /* if (ok to make frag) */
2564 symbolP
= symbol_find_or_make (sym_name
);
2565 pseudo_set (symbolP
);
2569 /* .include -- include a file at this point. */
2582 filename
= demand_copy_string (&i
);
2583 demand_empty_rest_of_line ();
2584 path
= xmalloc (i
+ include_dir_maxlen
+ 5 /* slop */ );
2585 for (i
= 0; i
< include_dir_count
; i
++)
2587 strcpy (path
, include_dirs
[i
]);
2589 strcat (path
, filename
);
2590 if (0 != (try = fopen (path
, "r")))
2599 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
2600 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
2601 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2605 add_include_dir (path
)
2610 if (include_dir_count
== 0)
2612 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
2613 include_dirs
[0] = "."; /* Current dir */
2614 include_dir_count
= 2;
2618 include_dir_count
++;
2619 include_dirs
= (char **) realloc (include_dirs
,
2620 include_dir_count
* sizeof (*include_dirs
));
2623 include_dirs
[include_dir_count
- 1] = path
; /* New one */
2626 if (i
> include_dir_maxlen
)
2627 include_dir_maxlen
= i
;
2628 } /* add_include_dir() */
2634 extern char is_end_of_line
[];
2636 while (!is_end_of_line
[*input_line_pointer
])
2638 ++input_line_pointer
;
2640 ++input_line_pointer
;