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
+ 1);
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
1151 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1154 segT current_seg
= now_seg
;
1155 subsegT current_subseg
= now_subseg
;
1157 subseg_new (SEG_BSS
, 1);
1160 frag_align (align
, 0);
1161 /* detach from old frag */
1162 if (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1163 symbolP
->sy_frag
->fr_symbol
= NULL
;
1165 symbolP
->sy_frag
= frag_now
;
1166 p
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1170 S_SET_SEGMENT (symbolP
, SEG_BSS
);
1173 /* The symbol may already have been created with a preceding
1174 * ".globl" directive -- be careful not to step on storage
1175 * class in that case. Otherwise, set it to static.
1177 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1179 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1181 #endif /* OBJ_COFF */
1182 subseg_new (current_seg
, current_subseg
);
1186 as_bad ("Ignoring attempt to re-define symbol %s.", name
);
1188 demand_empty_rest_of_line ();
1208 register char *name
;
1211 register segT segment
;
1213 register symbolS
*symbolP
;
1215 /* we permit ANY defined expression: BSD4.2 demands constants */
1216 name
= input_line_pointer
;
1217 c
= get_symbol_end ();
1218 p
= input_line_pointer
;
1221 if (*input_line_pointer
!= ',')
1224 as_bad ("Expected comma after name \"%s\"", name
);
1226 ignore_rest_of_line ();
1229 input_line_pointer
++;
1230 segment
= expression (&exp
);
1231 if (segment
!= SEG_ABSOLUTE
1232 #ifdef MANY_SEGMENTS
1233 && !(segment
>= SEG_E0
&& segment
<= SEG_UNKNOWN
)
1235 && segment
!= SEG_DATA
1236 && segment
!= SEG_TEXT
1237 && segment
!= SEG_BSS
1239 && segment
!= SEG_REGISTER
)
1241 as_bad ("Bad expression: %s", segment_name (segment
));
1242 ignore_rest_of_line ();
1246 symbolP
= symbol_find_or_make (name
);
1248 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0
1249 && symbolP->sy_desc == 0) out of this test
1250 because coff doesn't have those fields, and I
1251 can't see when they'd ever be tripped. I don't
1252 think I understand why they were here so I may
1253 have introduced a bug. As recently as 1.37 didn't
1254 have this test anyway. xoxorich. */
1256 if (S_GET_SEGMENT (symbolP
) == SEG_UNKNOWN
1257 && S_GET_VALUE (symbolP
) == 0)
1259 /* The name might be an undefined .global symbol; be
1260 sure to keep the "external" bit. */
1261 S_SET_SEGMENT (symbolP
, segment
);
1262 S_SET_VALUE (symbolP
, (valueT
) (exp
.X_add_number
));
1266 as_bad ("Symbol %s already defined", name
);
1269 demand_empty_rest_of_line ();
1275 register segT segment
;
1277 register long temp_fill
;
1280 * Don't believe the documentation of BSD 4.2 AS.
1281 * There is no such thing as a sub-segment-relative origin.
1282 * Any absolute origin is given a warning, then assumed to be segment-relative.
1283 * Any segmented origin expression ("foo+42") had better be in the right
1284 * segment or the .org is ignored.
1286 * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
1287 * never know sub-segment sizes when we are reading code.
1288 * BSD will crash trying to emit -ve numbers of filler bytes in certain
1289 * .orgs. We don't crash, but see as-write for that code.
1292 * Don't make frag if need_pass_2==1.
1294 segment
= get_known_segmented_expression (&exp
);
1295 if (*input_line_pointer
== ',')
1297 input_line_pointer
++;
1298 temp_fill
= get_absolute_expression ();
1304 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
1305 as_bad ("Invalid segment \"%s\". Segment \"%s\" assumed.",
1306 segment_name (segment
), segment_name (now_seg
));
1307 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
1308 exp
.X_add_number
, (char *) 0);
1310 } /* if (ok to make frag) */
1311 demand_empty_rest_of_line ();
1317 register char *name
;
1318 register char delim
;
1319 register char *end_name
;
1320 register symbolS
*symbolP
;
1323 * Especial apologies for the random logic:
1324 * this just grew, and could be parsed much more simply!
1327 name
= input_line_pointer
;
1328 delim
= get_symbol_end ();
1329 end_name
= input_line_pointer
;
1333 if (*input_line_pointer
!= ',')
1336 as_bad ("Expected comma after name \"%s\"", name
);
1338 ignore_rest_of_line ();
1342 input_line_pointer
++;
1345 if (name
[0] == '.' && name
[1] == '\0')
1347 /* Turn '. = mumble' into a .org mumble */
1348 register segT segment
;
1352 segment
= get_known_segmented_expression (&exp
);
1356 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
1357 as_bad ("Invalid segment \"%s\". Segment \"%s\" assumed.",
1358 segment_name (segment
),
1359 segment_name (now_seg
));
1360 ptr
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
1361 exp
.X_add_number
, (char *) 0);
1363 } /* if (ok to make frag) */
1369 if ((symbolP
= symbol_find (name
)) == NULL
1370 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
1372 symbolP
= symbol_new (name
,
1375 &zero_address_frag
);
1377 /* "set" symbols are local unless otherwise specified. */
1378 SF_SET_LOCAL (symbolP
);
1379 #endif /* OBJ_COFF */
1381 } /* make a new symbol */
1383 symbol_table_insert (symbolP
);
1386 pseudo_set (symbolP
);
1387 demand_empty_rest_of_line ();
1395 register long temp_fill
;
1398 /* Just like .fill, but temp_size = 1 */
1399 if (get_absolute_expression_and_terminator (&temp_repeat
) == ',')
1401 temp_fill
= get_absolute_expression ();
1405 input_line_pointer
--; /* Backup over what was not a ','. */
1412 if (temp_repeat
<= 0)
1414 as_warn ("Repeat < 0, .space ignored");
1415 ignore_rest_of_line ();
1420 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
1421 temp_repeat
, (char *) 0);
1424 demand_empty_rest_of_line ();
1432 temp
= get_absolute_expression ();
1433 #ifdef MANY_SEGMENTS
1434 subseg_new (SEG_E0
, (subsegT
) temp
);
1436 subseg_new (SEG_TEXT
, (subsegT
) temp
);
1438 demand_empty_rest_of_line ();
1442 /*(JF was static, but can't be if machine dependent pseudo-ops are to use it */
1445 demand_empty_rest_of_line ()
1448 if (is_end_of_line
[*input_line_pointer
])
1450 input_line_pointer
++;
1454 ignore_rest_of_line ();
1456 /* Return having already swallowed end-of-line. */
1457 } /* Return pointing just after end-of-line. */
1460 ignore_rest_of_line () /* For suspect lines: gives warning. */
1462 if (!is_end_of_line
[*input_line_pointer
])
1464 if (isprint (*input_line_pointer
))
1465 as_bad ("Rest of line ignored. First ignored character is `%c'.",
1466 *input_line_pointer
);
1468 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
1469 *input_line_pointer
);
1470 while (input_line_pointer
< buffer_limit
1471 && !is_end_of_line
[*input_line_pointer
])
1473 input_line_pointer
++;
1476 input_line_pointer
++; /* Return pointing just after end-of-line. */
1477 know (is_end_of_line
[input_line_pointer
[-1]]);
1483 * In: Pointer to a symbol.
1484 * Input_line_pointer->expression.
1486 * Out: Input_line_pointer->just after any whitespace after expression.
1487 * Tried to set symbol to value of expression.
1488 * Will change symbols type, value, and frag;
1489 * May set need_pass_2 == 1.
1492 pseudo_set (symbolP
)
1496 register segT segment
;
1497 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1499 #endif /* OBJ_AOUT or OBJ_BOUT */
1501 know (symbolP
); /* NULL pointer is logic error. */
1502 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1503 ext
= S_IS_EXTERNAL (symbolP
);
1504 #endif /* OBJ_AOUT or OBJ_BOUT */
1506 if ((segment
= expression (&exp
)) == SEG_ABSENT
)
1508 as_bad ("Missing expression: absolute 0 assumed");
1509 exp
.X_seg
= SEG_ABSOLUTE
;
1510 exp
.X_add_number
= 0;
1516 S_SET_SEGMENT (symbolP
, SEG_REGISTER
);
1517 S_SET_VALUE (symbolP
, exp
.X_add_number
);
1518 symbolP
->sy_frag
= &zero_address_frag
;
1522 as_bad ("%s number invalid. Absolute 0 assumed.",
1523 exp
.X_add_number
> 0 ? "Bignum" : "Floating-Point");
1524 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1525 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1526 ext
? S_SET_EXTERNAL (symbolP
) :
1527 S_CLEAR_EXTERNAL (symbolP
);
1528 #endif /* OBJ_AOUT or OBJ_BOUT */
1529 S_SET_VALUE (symbolP
, 0);
1530 symbolP
->sy_frag
= &zero_address_frag
;
1534 as_warn ("No expression: Using absolute 0");
1535 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1536 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1537 ext
? S_SET_EXTERNAL (symbolP
) :
1538 S_CLEAR_EXTERNAL (symbolP
);
1539 #endif /* OBJ_AOUT or OBJ_BOUT */
1540 S_SET_VALUE (symbolP
, 0);
1541 symbolP
->sy_frag
= &zero_address_frag
;
1544 case SEG_DIFFERENCE
:
1545 if (exp
.X_add_symbol
&& exp
.X_subtract_symbol
1546 && (S_GET_SEGMENT (exp
.X_add_symbol
) ==
1547 S_GET_SEGMENT (exp
.X_subtract_symbol
)))
1549 if (exp
.X_add_symbol
->sy_frag
!= exp
.X_subtract_symbol
->sy_frag
)
1551 as_bad ("Unknown expression: symbols %s and %s are in different frags.",
1552 S_GET_NAME (exp
.X_add_symbol
), S_GET_NAME (exp
.X_subtract_symbol
));
1555 exp
.X_add_number
+= S_GET_VALUE (exp
.X_add_symbol
) -
1556 S_GET_VALUE (exp
.X_subtract_symbol
);
1559 as_bad ("Complex expression. Absolute segment assumed.");
1561 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
1562 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1563 ext
? S_SET_EXTERNAL (symbolP
) :
1564 S_CLEAR_EXTERNAL (symbolP
);
1565 #endif /* OBJ_AOUT or OBJ_BOUT */
1566 S_SET_VALUE (symbolP
, exp
.X_add_number
);
1567 symbolP
->sy_frag
= &zero_address_frag
;
1571 #ifdef MANY_SEGMENTS
1572 S_SET_SEGMENT (symbolP
, segment
);
1577 S_SET_SEGMENT (symbolP
, SEG_DATA
);
1580 S_SET_SEGMENT (symbolP
, SEG_TEXT
);
1583 S_SET_SEGMENT (symbolP
, SEG_BSS
);
1587 as_fatal ("failed sanity check.");
1588 } /* switch on segment */
1590 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1593 S_SET_EXTERNAL (symbolP
);
1597 S_CLEAR_EXTERNAL (symbolP
);
1599 #endif /* OBJ_AOUT or OBJ_BOUT */
1601 S_SET_VALUE (symbolP
, exp
.X_add_number
+ S_GET_VALUE (exp
.X_add_symbol
));
1602 symbolP
->sy_frag
= exp
.X_add_symbol
->sy_frag
;
1605 case SEG_PASS1
: /* Not an error. Just try another pass. */
1606 symbolP
->sy_forward
= exp
.X_add_symbol
;
1607 as_bad ("Unknown expression");
1608 know (need_pass_2
== 1);
1612 symbolP
->sy_forward
= exp
.X_add_symbol
;
1613 /* as_warn("unknown symbol"); */
1614 /* need_pass_2 = 1; */
1625 * CONStruct more frag of .bytes, or .words etc.
1626 * Should need_pass_2 be 1 then emit no frag(s).
1627 * This understands EXPRESSIONS, as opposed to big_cons().
1631 * This has a split personality. We use expression() to read the
1632 * value. We can detect if the value won't fit in a byte or word.
1633 * But we can't detect if expression() discarded significant digits
1634 * in the case of a long. Not worth the crocks required to fix it.
1637 /* worker to do .byte etc statements */
1638 /* clobbers input_line_pointer, checks */
1642 register unsigned int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1645 register long mask
; /* High-order bits we will left-truncate, */
1646 /* but includes sign bit also. */
1647 register long get
; /* what we get */
1648 register long use
; /* get after truncation. */
1649 register long unmask
; /* what bits we will store */
1651 register segT segment
;
1655 * Input_line_pointer->1st char after pseudo-op-code and could legally
1656 * be a end-of-line. (Or, less legally an eof - which we cope with.)
1658 /* JF << of >= number of bits in the object is undefined. In particular
1659 SPARC (Sun 4) has problems */
1661 if (nbytes
>= sizeof (long))
1667 mask
= ~0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
1668 } /* bigger than a long */
1670 unmask
= ~mask
; /* Do store these bits. */
1673 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
1674 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
1678 * The following awkward logic is to parse ZERO or more expressions,
1679 * comma seperated. Recall an expression includes its leading &
1680 * trailing blanks. We fake a leading ',' if there is (supposed to
1681 * be) a 1st expression, and keep demanding 1 expression for each ','.
1683 if (is_it_end_of_statement ())
1685 c
= 0; /* Skip loop. */
1686 input_line_pointer
++; /* Matches end-of-loop 'correction'. */
1691 } /* if the end else fake it */
1696 #ifdef WANT_BITFIELDS
1697 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
1698 /* used for error messages and rescanning */
1699 char *hold
= input_line_pointer
;
1700 #endif /* WANT_BITFIELDS */
1702 if (*input_line_pointer
== '\'')
1704 /* An MRI style string, cut into as many bytes as will fit
1705 into a nbyte chunk, left justify if necessary, and sepatate
1706 with commas so we can try again later */
1708 unsigned int result
= 0;
1709 input_line_pointer
++;
1710 for (scan
= 0; scan
< nbytes
; scan
++)
1712 if (*input_line_pointer
== '\'')
1714 if (input_line_pointer
[1] == '\'')
1716 input_line_pointer
++;
1721 result
= (result
<< 8) | (*input_line_pointer
++);
1725 while (scan
< nbytes
)
1730 /* Create correct expression */
1731 exp
.X_add_symbol
= 0;
1732 exp
.X_add_number
= result
;
1733 exp
.X_seg
= segment
= SEG_ABSOLUTE
;
1734 /* Fake it so that we can read the next char too */
1735 if (input_line_pointer
[0] != '\'' ||
1736 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
1738 input_line_pointer
-= 2;
1739 input_line_pointer
[0] = ',';
1740 input_line_pointer
[1] = '\'';
1743 input_line_pointer
++;
1748 /* At least scan over the expression. */
1749 segment
= expression (&exp
);
1751 #ifdef WANT_BITFIELDS
1752 /* Some other assemblers, (eg, asm960), allow
1753 bitfields after ".byte" as w:x,y:z, where w and
1754 y are bitwidths and x and y are values. They
1755 then pack them all together. We do a little
1756 better in that we allow them in words, longs,
1757 etc. and we'll pack them in target byte order
1760 The rules are: pack least significat bit first,
1761 if a field doesn't entirely fit, put it in the
1762 next unit. Overflowing the bitfield is
1763 explicitly *not* even a warning. The bitwidth
1764 should be considered a "mask".
1766 FIXME-SOMEDAY: If this is considered generally
1767 useful, this logic should probably be reworked.
1770 if (*input_line_pointer
== ':')
1776 unsigned long width
;
1778 if (*input_line_pointer
!= ':')
1780 input_line_pointer
= hold
;
1782 } /* next piece is not a bitfield */
1784 /* In the general case, we can't allow
1785 full expressions with symbol
1786 differences and such. The relocation
1787 entries for symbols not defined in this
1788 assembly would require arbitrary field
1789 widths, positions, and masks which most
1790 of our current object formats don't
1793 In the specific case where a symbol
1794 *is* defined in this assembly, we
1795 *could* build fixups and track it, but
1796 this could lead to confusion for the
1797 backends. I'm lazy. I'll take any
1798 SEG_ABSOLUTE. I think that means that
1799 you can use a previous .set or
1800 .equ type symbol. xoxorich. */
1802 if (segment
== SEG_ABSENT
)
1804 as_warn ("Using a bit field width of zero.");
1805 exp
.X_add_number
= 0;
1806 segment
= SEG_ABSOLUTE
;
1807 } /* implied zero width bitfield */
1809 if (segment
!= SEG_ABSOLUTE
)
1811 *input_line_pointer
= '\0';
1812 as_bad ("Field width \"%s\" too complex for a bitfield.\n", hold
);
1813 *input_line_pointer
= ':';
1814 demand_empty_rest_of_line ();
1818 if ((width
= exp
.X_add_number
) > (BITS_PER_CHAR
* nbytes
))
1820 as_warn ("Field width %d too big to fit in %d bytes: truncated to %d bits.",
1821 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
1822 width
= BITS_PER_CHAR
* nbytes
;
1825 if (width
> bits_available
)
1827 /* FIXME-SOMEDAY: backing up and
1828 reparsing is wasteful */
1829 input_line_pointer
= hold
;
1830 exp
.X_add_number
= value
;
1834 hold
= ++input_line_pointer
; /* skip ':' */
1836 if ((segment
= expression (&exp
)) != SEG_ABSOLUTE
)
1838 char cache
= *input_line_pointer
;
1840 *input_line_pointer
= '\0';
1841 as_bad ("Field value \"%s\" too complex for a bitfield.\n", hold
);
1842 *input_line_pointer
= cache
;
1843 demand_empty_rest_of_line ();
1847 value
|= (~(-1 << width
) & exp
.X_add_number
)
1848 << ((BITS_PER_CHAR
* nbytes
) - bits_available
);
1850 if ((bits_available
-= width
) == 0
1851 || is_it_end_of_statement ()
1852 || *input_line_pointer
!= ',')
1855 } /* all the bitfields we're gonna get */
1857 hold
= ++input_line_pointer
;
1858 segment
= expression (&exp
);
1859 } /* forever loop */
1861 exp
.X_add_number
= value
;
1862 segment
= SEG_ABSOLUTE
;
1863 } /* if looks like a bitfield */
1864 #endif /* WANT_BITFIELDS */
1867 { /* Still worthwhile making frags. */
1869 /* Don't call this if we are going to junk this pass anyway! */
1870 know (segment
!= SEG_PASS1
);
1872 if (segment
== SEG_DIFFERENCE
&& exp
.X_add_symbol
== NULL
)
1874 as_bad ("Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
1875 S_GET_NAME (exp
.X_subtract_symbol
),
1876 segment_name (S_GET_SEGMENT (exp
.X_subtract_symbol
)));
1877 segment
= SEG_ABSOLUTE
;
1878 /* Leave exp . X_add_number alone. */
1880 p
= frag_more (nbytes
);
1884 as_bad ("%s number invalid. Absolute 0 assumed.",
1885 exp
.X_add_number
> 0 ? "Bignum" : "Floating-Point");
1886 md_number_to_chars (p
, (long) 0, nbytes
);
1890 as_warn ("0 assumed for missing expression");
1891 exp
.X_add_number
= 0;
1892 know (exp
.X_add_symbol
== NULL
);
1893 /* fall into SEG_ABSOLUTE */
1895 get
= exp
.X_add_number
;
1897 if ((get
& mask
) && (get
& mask
) != mask
)
1898 { /* Leading bits contain both 0s & 1s. */
1899 as_warn ("Value 0x%x truncated to 0x%x.", get
, use
);
1901 md_number_to_chars (p
, use
, nbytes
); /* put bytes in right order. */
1904 case SEG_DIFFERENCE
:
1905 #ifndef WORKING_DOT_WORD
1908 struct broken_word
*x
;
1910 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
1911 x
->next_broken_word
= broken_words
;
1914 x
->word_goes_here
= p
;
1916 x
->add
= exp
.X_add_symbol
;
1917 x
->sub
= exp
.X_subtract_symbol
;
1918 x
->addnum
= exp
.X_add_number
;
1923 /* Else Fall through into. . . */
1928 fix_new_ns32k (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1929 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1930 exp
.X_add_number
, 0, 0, 2, 0, 0);
1932 # if defined(TC_SPARC) || defined(TC_A29K)
1933 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1934 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1935 exp
.X_add_number
, 0, RELOC_32
);
1937 # if defined(TC_H8300)
1938 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1939 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1940 exp
.X_add_number
, 0, R_RELWORD
);
1944 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1945 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1946 exp
.X_add_number
, 0, NO_RELOC
);
1948 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
1949 exp
.X_add_symbol
, exp
.X_subtract_symbol
,
1950 exp
.X_add_number
, 0, 0);
1951 #endif /* NO_RELOC */
1952 # endif /* tc_h8300 */
1953 # endif /* tc_sparc|tc_a29k */
1954 #endif /* TC_NS32K */
1956 } /* switch(segment) */
1957 } /* if (!need_pass_2) */
1958 c
= *input_line_pointer
++;
1959 } /* while(c==',') */
1960 input_line_pointer
--; /* Put terminator back into stream. */
1961 demand_empty_rest_of_line ();
1967 * CONStruct more frag(s) of .quads, or .octa etc.
1968 * Makes 0 or more new frags.
1969 * If need_pass_2 == 1, generate no frag.
1970 * This understands only bignums, not expressions. Cons() understands
1973 * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
1975 * This creates objects with struct obstack_control objs, destroying
1976 * any context objs held about a partially completed object. Beware!
1979 * I think it sucks to have 2 different types of integers, with 2
1980 * routines to read them, store them etc.
1981 * It would be nicer to permit bignums in expressions and only
1982 * complain if the result overflowed. However, due to "efficiency"...
1984 /* worker to do .quad etc statements */
1985 /* clobbers input_line_pointer, checks */
1987 /* 8=.quad 16=.octa ... */
1991 register int nbytes
;
1993 register char c
; /* input_line_pointer->c. */
1995 register long length
; /* Number of chars in an object. */
1996 register int digit
; /* Value of 1 digit. */
1997 register int carry
; /* For multi-precision arithmetic. */
1998 register int work
; /* For multi-precision arithmetic. */
1999 register char *p
; /* For multi-precision arithmetic. */
2001 extern char hex_value
[]; /* In hex_value.c. */
2004 * The following awkward logic is to parse ZERO or more strings,
2005 * comma seperated. Recall an expression includes its leading &
2006 * trailing blanks. We fake a leading ',' if there is (supposed to
2007 * be) a 1st expression, and keep demanding 1 expression for each ','.
2009 if (is_it_end_of_statement ())
2011 c
= 0; /* Skip loop. */
2015 c
= ','; /* Do loop. */
2016 --input_line_pointer
;
2020 ++input_line_pointer
;
2022 c
= *input_line_pointer
;
2023 /* C contains 1st non-blank character of what we hope is a number. */
2026 c
= *++input_line_pointer
;
2027 if (c
== 'x' || c
== 'X')
2029 c
= *++input_line_pointer
;
2042 * This feature (?) is here to stop people worrying about
2043 * mysterious zero constants: which is what they get when
2044 * they completely omit digits.
2046 if (hex_value
[c
] >= radix
)
2048 as_bad ("Missing digits. 0 assumed.");
2050 bignum_high
= bignum_low
- 1; /* Start constant with 0 chars. */
2051 for (; (digit
= hex_value
[c
]) < radix
; c
= *++input_line_pointer
)
2053 /* Multiply existing number by radix, then add digit. */
2055 for (p
= bignum_low
; p
<= bignum_high
; p
++)
2057 work
= (*p
& MASK_CHAR
) * radix
+ carry
;
2058 *p
= work
& MASK_CHAR
;
2059 carry
= work
>> BITS_PER_CHAR
;
2064 *bignum_high
= carry
& MASK_CHAR
;
2065 know ((carry
& ~MASK_CHAR
) == 0);
2068 length
= bignum_high
- bignum_low
+ 1;
2069 if (length
> nbytes
)
2071 as_warn ("Most significant bits truncated in integer constant.");
2075 register long leading_zeroes
;
2077 for (leading_zeroes
= nbytes
- length
;
2087 p
= frag_more (nbytes
);
2088 bcopy (bignum_low
, p
, (int) nbytes
);
2090 /* C contains character after number. */
2092 c
= *input_line_pointer
;
2093 /* C contains 1st non-blank character after number. */
2095 demand_empty_rest_of_line ();
2098 /* Extend bignum by 1 char. */
2102 register long length
;
2105 if (bignum_high
>= bignum_limit
)
2107 length
= bignum_limit
- bignum_low
;
2108 bignum_low
= xrealloc (bignum_low
, length
+ length
);
2109 bignum_high
= bignum_low
+ length
;
2110 bignum_limit
= bignum_low
+ length
+ length
;
2112 } /* grow_bignum(); */
2117 * CONStruct some more frag chars of .floats .ffloats etc.
2118 * Makes 0 or more new frags.
2119 * If need_pass_2 == 1, no frags are emitted.
2120 * This understands only floating literals, not expressions. Sorry.
2122 * A floating constant is defined by atof_generic(), except it is preceded
2123 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
2124 * reading, I decided to be incompatible. This always tries to give you
2125 * rounded bits to the precision of the pseudo-op. Former AS did premature
2126 * truncatation, restored noisy bits instead of trailing 0s AND gave you
2127 * a choice of 2 flavours of noise according to which of 2 floating-point
2128 * scanners you directed AS to use.
2130 * In: input_line_pointer->whitespace before, or '0' of flonum.
2134 void /* JF was static, but can't be if VAX.C is goning to use it */
2135 float_cons (float_type
) /* Worker to do .float etc statements. */
2136 /* Clobbers input_line-pointer, checks end-of-line. */
2137 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
2141 int length
; /* Number of chars in an object. */
2142 register char *err
; /* Error from scanning floating literal. */
2143 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2146 * The following awkward logic is to parse ZERO or more strings,
2147 * comma seperated. Recall an expression includes its leading &
2148 * trailing blanks. We fake a leading ',' if there is (supposed to
2149 * be) a 1st expression, and keep demanding 1 expression for each ','.
2151 if (is_it_end_of_statement ())
2153 c
= 0; /* Skip loop. */
2154 ++input_line_pointer
; /*->past termintor. */
2158 c
= ','; /* Do loop. */
2162 /* input_line_pointer->1st char of a flonum (we hope!). */
2164 /* Skip any 0{letter} that may be present. Don't even check if the
2165 * letter is legal. Someone may invent a "z" format and this routine
2166 * has no use for such information. Lusers beware: you get
2167 * diagnostics if your input is ill-conditioned.
2170 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2171 input_line_pointer
+= 2;
2173 err
= md_atof (float_type
, temp
, &length
);
2174 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2178 as_bad ("Bad floating literal: %s", err
);
2179 ignore_rest_of_line ();
2180 /* Input_line_pointer->just after end-of-line. */
2181 c
= 0; /* Break out of loop. */
2187 p
= frag_more (length
);
2188 bcopy (temp
, p
, length
);
2191 c
= *input_line_pointer
++;
2192 /* C contains 1st non-white character after number. */
2193 /* input_line_pointer->just after terminator (c). */
2196 --input_line_pointer
; /*->terminator (is not ','). */
2197 demand_empty_rest_of_line ();
2198 } /* float_cons() */
2203 * We read 0 or more ',' seperated, double-quoted strings.
2205 * Caller should have checked need_pass_2 is FALSE because we don't check it.
2210 stringer (append_zero
) /* Worker to do .ascii etc statements. */
2211 /* Checks end-of-line. */
2212 register int append_zero
; /* 0: don't append '\0', else 1 */
2214 /* register char * p; JF unused */
2215 /* register int length; JF unused *//* Length of string we read, excluding */
2216 /* trailing '\0' implied by closing quote. */
2217 /* register char * where; JF unused */
2218 /* register fragS * fragP; JF unused */
2219 register unsigned int c
;
2222 * The following awkward logic is to parse ZERO or more strings,
2223 * comma seperated. Recall a string expression includes spaces
2224 * before the opening '\"' and spaces after the closing '\"'.
2225 * We fake a leading ',' if there is (supposed to be)
2226 * a 1st, expression. We keep demanding expressions for each
2229 if (is_it_end_of_statement ())
2231 c
= 0; /* Skip loop. */
2232 ++input_line_pointer
; /* Compensate for end of loop. */
2236 c
= ','; /* Do loop. */
2238 while (c
== ',' || c
== '<' || c
== '"')
2241 switch (*input_line_pointer
)
2244 ++input_line_pointer
; /*->1st char of string. */
2245 while (is_a_char (c
= next_char_of_string ()))
2247 FRAG_APPEND_1_CHAR (c
);
2251 FRAG_APPEND_1_CHAR (0);
2253 know (input_line_pointer
[-1] == '\"');
2256 input_line_pointer
++;
2257 c
= get_single_number ();
2258 FRAG_APPEND_1_CHAR (c
);
2259 if (*input_line_pointer
!= '>')
2261 as_bad ("Expected <nn>");
2263 input_line_pointer
++;
2266 input_line_pointer
++;
2270 c
= *input_line_pointer
;
2273 demand_empty_rest_of_line ();
2276 /* FIXME-SOMEDAY: I had trouble here on characters with the
2277 high bits set. We'll probably also have trouble with
2278 multibyte chars, wide chars, etc. Also be careful about
2279 returning values bigger than 1 byte. xoxorich. */
2282 next_char_of_string ()
2284 register unsigned int c
;
2286 c
= *input_line_pointer
++ & CHAR_MASK
;
2294 switch (c
= *input_line_pointer
++)
2324 break; /* As itself. */
2339 for (number
= 0; isdigit (c
); c
= *input_line_pointer
++)
2341 number
= number
* 8 + c
- '0';
2345 --input_line_pointer
;
2349 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
2350 as_warn ("Unterminated string: Newline inserted.");
2356 #ifdef ONLY_STANDARD_ESCAPES
2357 as_bad ("Bad escaped character in string, '?' assumed");
2359 #endif /* ONLY_STANDARD_ESCAPES */
2362 } /* switch on escaped char */
2367 } /* switch on char */
2369 } /* next_char_of_string() */
2372 get_segmented_expression (expP
)
2373 register expressionS
*expP
;
2375 register segT retval
;
2377 if ((retval
= expression (expP
)) == SEG_PASS1
|| retval
== SEG_ABSENT
|| retval
== SEG_BIG
)
2379 as_bad ("Expected address expression: absolute 0 assumed");
2380 retval
= expP
->X_seg
= SEG_ABSOLUTE
;
2381 expP
->X_add_number
= 0;
2382 expP
->X_add_symbol
= expP
->X_subtract_symbol
= 0;
2384 return (retval
); /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
2388 get_known_segmented_expression (expP
)
2389 register expressionS
*expP
;
2391 register segT retval
;
2392 register char *name1
;
2393 register char *name2
;
2395 if ((retval
= get_segmented_expression (expP
)) == SEG_UNKNOWN
)
2397 name1
= expP
->X_add_symbol
? S_GET_NAME (expP
->X_add_symbol
) : "";
2398 name2
= expP
->X_subtract_symbol
?
2399 S_GET_NAME (expP
->X_subtract_symbol
) :
2403 as_warn ("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
2408 as_warn ("Symbol \"%s\" undefined: absolute 0 assumed.",
2409 name1
? name1
: name2
);
2411 retval
= expP
->X_seg
= SEG_ABSOLUTE
;
2412 expP
->X_add_number
= 0;
2413 expP
->X_add_symbol
= expP
->X_subtract_symbol
= NULL
;
2415 #ifndef MANY_SEGMENTS
2416 know (retval
== SEG_ABSOLUTE
|| retval
== SEG_DATA
|| retval
== SEG_TEXT
|| retval
== SEG_BSS
|| retval
== SEG_DIFFERENCE
);
2420 } /* get_known_segmented_expression() */
2424 /* static */ long /* JF was static, but can't be if the MD pseudos are to use it */
2425 get_absolute_expression ()
2430 if ((s
= expression (&exp
)) != SEG_ABSOLUTE
)
2432 if (s
!= SEG_ABSENT
)
2434 as_bad ("Bad Absolute Expression, absolute 0 assumed.");
2436 exp
.X_add_number
= 0;
2438 return (exp
.X_add_number
);
2441 char /* return terminator */
2442 get_absolute_expression_and_terminator (val_pointer
)
2443 long *val_pointer
; /* return value of expression */
2445 *val_pointer
= get_absolute_expression ();
2446 return (*input_line_pointer
++);
2450 * demand_copy_C_string()
2452 * Like demand_copy_string, but return NULL if the string contains any '\0's.
2453 * Give a warning if that happens.
2456 demand_copy_C_string (len_pointer
)
2461 if ((s
= demand_copy_string (len_pointer
)) != 0)
2465 for (len
= *len_pointer
;
2474 as_bad ("This string may not contain \'\\0\'");
2482 * demand_copy_string()
2484 * Demand string, but return a safe (=private) copy of the string.
2485 * Return NULL if we can't read a string here.
2488 demand_copy_string (lenP
)
2491 register unsigned int c
;
2497 if (*input_line_pointer
== '\"')
2499 input_line_pointer
++; /* Skip opening quote. */
2501 while (is_a_char (c
= next_char_of_string ()))
2503 obstack_1grow (¬es
, c
);
2506 /* JF this next line is so demand_copy_C_string will return a null
2507 termanated string. */
2508 obstack_1grow (¬es
, '\0');
2509 retval
= obstack_finish (¬es
);
2513 as_warn ("Missing string");
2515 ignore_rest_of_line ();
2519 } /* demand_copy_string() */
2522 * is_it_end_of_statement()
2524 * In: Input_line_pointer->next character.
2526 * Do: Skip input_line_pointer over all whitespace.
2528 * Out: 1 if input_line_pointer->end-of-line.
2531 is_it_end_of_statement ()
2534 return (is_end_of_line
[*input_line_pointer
]);
2535 } /* is_it_end_of_statement() */
2541 register symbolS
*symbolP
; /* symbol we are working with */
2543 input_line_pointer
++;
2544 if (*input_line_pointer
== '=')
2545 input_line_pointer
++;
2547 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
2548 input_line_pointer
++;
2550 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
2552 /* Turn '. = mumble' into a .org mumble */
2553 register segT segment
;
2557 segment
= get_known_segmented_expression (&exp
);
2560 if (segment
!= now_seg
&& segment
!= SEG_ABSOLUTE
)
2561 as_warn ("Illegal segment \"%s\". Segment \"%s\" assumed.",
2562 segment_name (segment
),
2563 segment_name (now_seg
));
2564 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
.X_add_symbol
,
2565 exp
.X_add_number
, (char *) 0);
2567 } /* if (ok to make frag) */
2571 symbolP
= symbol_find_or_make (sym_name
);
2572 pseudo_set (symbolP
);
2576 /* .include -- include a file at this point. */
2589 filename
= demand_copy_string (&i
);
2590 demand_empty_rest_of_line ();
2591 path
= xmalloc (i
+ include_dir_maxlen
+ 5 /* slop */ );
2592 for (i
= 0; i
< include_dir_count
; i
++)
2594 strcpy (path
, include_dirs
[i
]);
2596 strcat (path
, filename
);
2597 if (0 != (try = fopen (path
, "r")))
2606 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
2607 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
2608 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2612 add_include_dir (path
)
2617 if (include_dir_count
== 0)
2619 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
2620 include_dirs
[0] = "."; /* Current dir */
2621 include_dir_count
= 2;
2625 include_dir_count
++;
2626 include_dirs
= (char **) realloc (include_dirs
,
2627 include_dir_count
* sizeof (*include_dirs
));
2630 include_dirs
[include_dir_count
- 1] = path
; /* New one */
2633 if (i
> include_dir_maxlen
)
2634 include_dir_maxlen
= i
;
2635 } /* add_include_dir() */
2641 extern char is_end_of_line
[];
2643 while (!is_end_of_line
[*input_line_pointer
])
2645 ++input_line_pointer
;
2647 ++input_line_pointer
;