1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
24 change this a bit. But then, GNU isn't
25 spozed to run on your machine anyway.
26 (RMS is so shortsighted sometimes.)
29 #define MASK_CHAR ((int)(unsigned char)-1)
33 /* This is the largest known floating point format (for now). It will
34 grow when we do 4361 style flonums. */
36 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
38 /* Routines that read assembler source text to build spagetti in memory.
39 Another group of these functions is in the expr.c module. */
52 #ifndef TC_START_LABEL
53 #define TC_START_LABEL(x,y) (x==':')
56 /* The NOP_OPCODE is for the alignment fill value.
57 * fill it a nop instruction so that the disassembler does not choke
61 #define NOP_OPCODE 0x00
64 char *input_line_pointer
; /*->next char of source file to parse. */
66 #if BITS_PER_CHAR != 8
67 /* The following table is indexed by[(char)] and will break if
68 a char does not have exactly 256 states (hopefully 0:255!)! */
73 /* The m88k unfortunately uses @ as a label beginner. */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The a29k assembler does not permits labels to start with $. */
98 /* The Delta 68k assembler permits ~ at start of label names. */
102 /* used by is_... macros. our ctype[] */
105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
107 0, 0, 0, 0, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
109 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
110 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
111 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
112 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
117 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
125 * Out: 1 if this character ends a line.
128 char is_end_of_line
[256] =
131 99, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
133 99, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
135 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
137 _
,99, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* _!"#$%&'()*+,-./ */
138 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* 0123456789:;<=>? */
140 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
141 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
143 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
144 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
145 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
146 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
147 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
148 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
149 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
150 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
151 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
155 /* Functions private to this file. */
157 static char *buffer
; /* 1st char of each buffer of lines is here. */
158 static char *buffer_limit
; /*->1 + last char in buffer. */
160 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1 in the
161 tc-<CPU>.h file. See the "Porting GAS" section of the internals manual. */
162 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
164 static char *old_buffer
; /* JF a hack */
165 static char *old_input
;
166 static char *old_limit
;
168 /* Variables for handling include file directory table. */
170 char **include_dirs
; /* Table of pointers to directories to
171 search for .include's */
172 int include_dir_count
; /* How many are in the table */
173 int include_dir_maxlen
= 1;/* Length of longest in table */
175 #ifndef WORKING_DOT_WORD
176 struct broken_word
*broken_words
;
177 int new_broken_words
;
180 /* The current offset into the absolute section. We don't try to
181 build frags in the absolute section, since no data can be stored
182 there. We just keep track of the current offset. */
183 addressT abs_section_offset
;
185 /* If this line had an MRI style label, it is stored in this variable.
186 This is used by some of the MRI pseudo-ops. */
189 /* This global variable is used to support MRI common sections. We
190 translate such sections into a common symbol. This variable is
191 non-NULL when we are in an MRI common section. */
192 symbolS
*mri_common_symbol
;
194 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
195 need to align to an even byte boundary unless the next pseudo-op is
196 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
198 static int mri_pending_align
;
202 /* This variable is set to be non-zero if the next string we see might
203 be the name of the source file in DWARF debugging information. See
204 the comment in emit_expr for the format we look for. */
205 static int dwarf_file_string
;
209 static void cons_worker
PARAMS ((int, int));
210 static int scrub_from_string
PARAMS ((char **));
211 static void do_align
PARAMS ((int, char *, int, int));
212 static void s_align
PARAMS ((int, int));
213 static int hex_float
PARAMS ((int, char *));
214 static void do_org
PARAMS ((segT
, expressionS
*, int));
215 char *demand_copy_string
PARAMS ((int *lenP
));
216 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
217 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
218 static void pobegin
PARAMS ((void));
219 static int get_line_sb
PARAMS ((sb
*));
228 obj_read_begin_hook ();
230 /* Something close -- but not too close -- to a multiple of 1024.
231 The debugging malloc I'm using has 24 bytes of overhead. */
232 obstack_begin (¬es
, chunksize
);
233 obstack_begin (&cond_obstack
, chunksize
);
235 /* Use machine dependent syntax */
236 for (p
= line_separator_chars
; *p
; p
++)
237 is_end_of_line
[(unsigned char) *p
] = 1;
238 /* Use more. FIXME-SOMEDAY. */
244 /* set up pseudo-op tables */
246 static struct hash_control
*po_hash
;
248 static const pseudo_typeS potable
[] =
250 {"abort", s_abort
, 0},
251 {"align", s_align_ptwo
, 0},
252 {"ascii", stringer
, 0},
253 {"asciz", stringer
, 1},
254 {"balign", s_align_bytes
, 0},
255 {"balignw", s_align_bytes
, -2},
256 {"balignl", s_align_bytes
, -4},
260 {"common", s_mri_common
, 0},
261 {"common.s", s_mri_common
, 1},
265 {"dc.d", float_cons
, 'd'},
267 {"dc.s", float_cons
, 'f'},
269 {"dc.x", float_cons
, 'x'},
271 {"dcb.b", s_space
, 1},
272 {"dcb.d", s_float_space
, 'd'},
273 {"dcb.l", s_space
, 4},
274 {"dcb.s", s_float_space
, 'f'},
275 {"dcb.w", s_space
, 2},
276 {"dcb.x", s_float_space
, 'x'},
278 {"ds.b", s_space
, 1},
279 {"ds.d", s_space
, 8},
280 {"ds.l", s_space
, 4},
281 {"ds.p", s_space
, 12},
282 {"ds.s", s_space
, 4},
283 {"ds.w", s_space
, 2},
284 {"ds.x", s_space
, 12},
285 {"debug", s_ignore
, 0},
290 {"double", float_cons
, 'd'},
292 {"eject", listing_eject
, 0}, /* Formfeed listing */
294 {"elsec", s_else
, 0},
296 {"endc", s_endif
, 0},
297 {"endif", s_endif
, 0},
302 {"exitm", s_mexit
, 0},
304 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
305 {"appfile", s_app_file
, 1},
306 {"appline", s_app_line
, 0},
308 {"file", s_app_file
, 0},
310 {"float", float_cons
, 'f'},
311 {"format", s_ignore
, 0},
312 {"global", s_globl
, 0},
313 {"globl", s_globl
, 0},
315 {"if", s_if
, (int) O_ne
},
317 {"ifdef", s_ifdef
, 0},
318 {"ifeq", s_if
, (int) O_eq
},
319 {"ifeqs", s_ifeqs
, 0},
320 {"ifge", s_if
, (int) O_ge
},
321 {"ifgt", s_if
, (int) O_gt
},
322 {"ifle", s_if
, (int) O_le
},
323 {"iflt", s_if
, (int) O_lt
},
325 {"ifndef", s_ifdef
, 1},
326 {"ifne", s_if
, (int) O_ne
},
327 {"ifnes", s_ifeqs
, 1},
328 {"ifnotdef", s_ifdef
, 1},
329 {"include", s_include
, 0},
335 {"lcomm", s_lcomm
, 0},
336 {"lflags", listing_flags
, 0}, /* Listing flags */
337 {"linkonce", s_linkonce
, 0},
338 {"list", listing_list
, 1}, /* Turn listing on */
339 {"llen", listing_psize
, 1},
342 {"macro", s_macro
, 0},
343 {"mexit", s_mexit
, 0},
345 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
346 {"name", s_ignore
, 0},
347 {"noformat", s_ignore
, 0},
348 {"nolist", listing_list
, 0}, /* Turn listing off */
349 {"nopage", listing_nopage
, 0},
351 {"offset", s_struct
, 0},
353 {"p2align", s_align_ptwo
, 0},
354 {"p2alignw", s_align_ptwo
, -2},
355 {"p2alignl", s_align_ptwo
, -4},
356 {"page", listing_eject
, 0},
357 {"plen", listing_psize
, 0},
358 {"print", s_print
, 0},
359 {"psize", listing_psize
, 0}, /* set paper size */
360 {"purgem", s_purgem
, 0},
365 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
370 {"single", float_cons
, 'f'},
372 {"space", s_space
, 0},
373 {"skip", s_space
, 0},
374 {"sleb128", s_leb128
, 1},
375 {"spc", s_ignore
, 0},
376 {"stabd", s_stab
, 'd'},
377 {"stabn", s_stab
, 'n'},
378 {"stabs", s_stab
, 's'},
379 {"string", stringer
, 1},
380 {"struct", s_struct
, 0},
384 /* This is for gcc to use. It's only just been added (2/94), so gcc
385 won't be able to use it for a while -- probably a year or more.
386 But once this has been released, check with gcc maintainers
387 before deleting it or even changing the spelling. */
388 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
389 /* If we're folding case -- done for some targets, not necessarily
390 all -- the above string in an input file will be converted to
391 this one. Match it either way... */
392 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
394 {"title", listing_title
, 0}, /* Listing title */
395 {"ttl", listing_title
, 0},
397 {"uleb128", s_leb128
, 0},
401 {"xdef", s_globl
, 0},
402 {"xref", s_ignore
, 0},
403 {"xstabs", s_xstab
, 's'},
405 {"zero", s_space
, 0},
406 {NULL
} /* end sentinel */
409 static int pop_override_ok
= 0;
410 static const char *pop_table_name
;
414 const pseudo_typeS
*table
;
417 const pseudo_typeS
*pop
;
418 for (pop
= table
; pop
->poc_name
; pop
++)
420 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
421 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
422 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
427 #ifndef md_pop_insert
428 #define md_pop_insert() pop_insert(md_pseudo_table)
431 #ifndef obj_pop_insert
432 #define obj_pop_insert() pop_insert(obj_pseudo_table)
438 po_hash
= hash_new ();
440 /* Do the target-specific pseudo ops. */
441 pop_table_name
= "md";
444 /* Now object specific. Skip any that were in the target table. */
445 pop_table_name
= "obj";
449 /* Now portable ones. Skip any that we've seen already. */
450 pop_table_name
= "standard";
451 pop_insert (potable
);
454 #define HANDLE_CONDITIONAL_ASSEMBLY() \
455 if (ignore_input ()) \
457 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
458 if (input_line_pointer == buffer_limit) \
464 /* This function is used when scrubbing the characters between #APP
467 static char *scrub_string
;
468 static char *scrub_string_end
;
471 scrub_from_string (from
)
476 *from
= scrub_string
;
477 size
= scrub_string_end
- scrub_string
;
478 scrub_string
= scrub_string_end
;
482 /* read_a_source_file()
484 * We read the file, putting things into a web that
485 * represents what we have been reading.
488 read_a_source_file (name
)
492 register char *s
; /* string of symbol, '\0' appended */
496 buffer
= input_scrub_new_file (name
);
499 listing_newline (NULL
);
500 register_dependency (name
);
502 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
503 { /* We have another line to parse. */
504 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
505 contin
: /* JF this goto is my fault I admit it.
506 Someone brave please re-write the whole
507 input section here? Pleeze??? */
508 while (input_line_pointer
< buffer_limit
)
510 /* We have more of this buffer to parse. */
513 * We now have input_line_pointer->1st char of next line.
514 * If input_line_pointer [-1] == '\n' then we just
515 * scanned another line: so bump line counters.
517 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
519 #ifdef md_start_line_hook
520 md_start_line_hook ();
523 if (input_line_pointer
[-1] == '\n')
524 bump_line_counters ();
529 #ifdef LABELS_WITHOUT_COLONS
534 /* Text at the start of a line must be a label, we
535 run down and stick a colon in. */
536 if (is_name_beginner (*input_line_pointer
))
538 char *line_start
= input_line_pointer
;
543 HANDLE_CONDITIONAL_ASSEMBLY ();
545 c
= get_symbol_end ();
547 /* In MRI mode, the EQU and MACRO pseudoops must
548 be handled specially. */
552 char *rest
= input_line_pointer
+ 1;
556 if (*rest
== ' ' || *rest
== '\t')
558 if ((strncasecmp (rest
, "EQU", 3) == 0
559 || strncasecmp (rest
, "SET", 3) == 0)
560 && (rest
[3] == ' ' || rest
[3] == '\t'))
562 input_line_pointer
= rest
+ 3;
564 strncasecmp (rest
, "SET", 3) == 0);
567 if (strncasecmp (rest
, "MACRO", 5) == 0
570 || is_end_of_line
[(unsigned char) rest
[5]]))
574 /* In MRI mode, we need to handle the MACRO
575 pseudo-op specially: we don't want to put the
576 symbol in the symbol table. */
577 if (! mri_line_macro
)
578 line_label
= colon (line_start
);
580 line_label
= symbol_create (line_start
,
585 *input_line_pointer
= c
;
587 input_line_pointer
++;
593 * We are at the begining of a line, or similar place.
594 * We expect a well-formed assembler statement.
595 * A "symbol-name:" is a statement.
597 * Depending on what compiler is used, the order of these tests
598 * may vary to catch most common case 1st.
599 * Each test is independent of all other tests at the (top) level.
600 * PLEASE make a compiler that doesn't use this assembler.
601 * It is crufty to waste a compiler's time encoding things for this
602 * assembler, which then wastes more time decoding it.
603 * (And communicating via (linear) files is silly!
604 * If you must pass stuff, please pass a tree!)
606 if ((c
= *input_line_pointer
++) == '\t'
611 c
= *input_line_pointer
++;
613 know (c
!= ' '); /* No further leading whitespace. */
616 /* If listing is on, and we are expanding a macro, then give
617 the listing code the contents of the expanded line. */
620 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
625 /* Find the end of the current expanded macro line. */
626 for (s
= input_line_pointer
-1; *s
; ++s
)
627 if (is_end_of_line
[(unsigned char) *s
])
630 /* Copy it for safe keeping. Also give an indication of
631 how much macro nesting is involved at this point. */
632 len
= s
- (input_line_pointer
-1);
633 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
634 memset (copy
, '>', macro_nest
);
635 copy
[macro_nest
] = ' ';
636 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
-1, len
);
637 copy
[macro_nest
+1+len
] = '\0';
639 /* Install the line with the listing facility. */
640 listing_newline (copy
);
643 listing_newline (NULL
);
648 * C is the 1st significant character.
649 * Input_line_pointer points after that character.
651 if (is_name_beginner (c
))
653 /* want user-defined label or pseudo/opcode */
654 HANDLE_CONDITIONAL_ASSEMBLY ();
656 s
= --input_line_pointer
;
657 c
= get_symbol_end (); /* name's delimiter */
659 * C is character after symbol.
660 * That character's place in the input line is now '\0'.
661 * S points to the beginning of the symbol.
662 * [In case of pseudo-op, s->'.'.]
663 * Input_line_pointer->'\0' where c was.
665 if (TC_START_LABEL(c
, input_line_pointer
))
669 char *rest
= input_line_pointer
+ 1;
671 /* In MRI mode, \tsym: set 0 is permitted. */
675 if (*rest
== ' ' || *rest
== '\t')
677 if ((strncasecmp (rest
, "EQU", 3) == 0
678 || strncasecmp (rest
, "SET", 3) == 0)
679 && (rest
[3] == ' ' || rest
[3] == '\t'))
681 input_line_pointer
= rest
+ 3;
687 line_label
= colon (s
); /* user-defined label */
688 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
689 /* Input_line_pointer->after ':'. */
695 || ((c
== ' ' || c
== '\t')
696 && input_line_pointer
[1] == '='
697 #ifdef TC_EQUAL_IN_INSN
698 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
703 demand_empty_rest_of_line ();
706 { /* expect pseudo-op or machine instruction */
709 #define IGNORE_OPCODE_CASE
710 #ifdef IGNORE_OPCODE_CASE
728 /* The MRI assembler and the m88k use pseudo-ops
730 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
731 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
736 || (! flag_m68k_mri
&& *s
== '.'))
741 * WARNING: c has next char, which may be end-of-line.
742 * We lookup the pseudo-op table with s+1 because we
743 * already know that the pseudo-op begins with a '.'.
747 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
749 /* In MRI mode, we may need to insert an
750 automatic alignment directive. What a hack
752 if (mri_pending_align
754 || ! ((pop
->poc_handler
== cons
755 && pop
->poc_val
== 1)
756 || (pop
->poc_handler
== s_space
757 && pop
->poc_val
== 1)
758 #ifdef tc_conditional_pseudoop
759 || tc_conditional_pseudoop (pop
)
761 || pop
->poc_handler
== s_if
762 || pop
->poc_handler
== s_ifdef
763 || pop
->poc_handler
== s_ifc
764 || pop
->poc_handler
== s_ifeqs
765 || pop
->poc_handler
== s_else
766 || pop
->poc_handler
== s_endif
767 || pop
->poc_handler
== s_globl
768 || pop
->poc_handler
== s_ignore
)))
770 do_align (1, (char *) NULL
, 0, 0);
771 mri_pending_align
= 0;
772 if (line_label
!= NULL
)
774 line_label
->sy_frag
= frag_now
;
775 S_SET_VALUE (line_label
, frag_now_fix ());
779 /* Print the error msg now, while we still can */
782 as_bad ("Unknown pseudo-op: `%s'", s
);
783 *input_line_pointer
= c
;
788 /* Put it back for error messages etc. */
789 *input_line_pointer
= c
;
790 /* The following skip of whitespace is compulsory.
791 A well shaped space is sometimes all that separates
792 keyword from operands. */
793 if (c
== ' ' || c
== '\t')
794 input_line_pointer
++;
796 * Input_line is restored.
797 * Input_line_pointer->1st non-blank char
798 * after pseudo-operation.
800 (*pop
->poc_handler
) (pop
->poc_val
);
802 /* If that was .end, just get out now. */
803 if (pop
->poc_handler
== s_end
)
810 /* WARNING: c has char, which may be end-of-line. */
811 /* Also: input_line_pointer->`\0` where c was. */
812 *input_line_pointer
= c
;
813 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
815 #ifdef TC_EOL_IN_INSN
816 || TC_EOL_IN_INSN (input_line_pointer
)
820 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
822 input_line_pointer
++;
825 c
= *input_line_pointer
;
826 *input_line_pointer
= '\0';
828 if (debug_type
== DEBUG_STABS
)
829 stabs_generate_asm_lineno ();
831 #ifdef OBJ_GENERATE_ASM_LINENO
832 #ifdef ECOFF_DEBUGGING
833 /* ECOFF assemblers automatically generate
834 debugging information. FIXME: This should
835 probably be handled elsewhere. */
836 if (debug_type
== DEBUG_NONE
)
838 if (ecoff_no_current_file ())
839 debug_type
= DEBUG_ECOFF
;
842 if (debug_type
== DEBUG_ECOFF
)
847 as_where (&s
, &lineno
);
848 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
858 if (check_macro (s
, &out
, '\0', &err
))
862 *input_line_pointer
++ = c
;
863 input_scrub_include_sb (&out
,
867 input_scrub_next_buffer (&input_line_pointer
);
872 if (mri_pending_align
)
874 do_align (1, (char *) NULL
, 0, 0);
875 mri_pending_align
= 0;
876 if (line_label
!= NULL
)
878 line_label
->sy_frag
= frag_now
;
879 S_SET_VALUE (line_label
, frag_now_fix ());
883 md_assemble (s
); /* Assemble 1 instruction. */
885 *input_line_pointer
++ = c
;
887 /* We resume loop AFTER the end-of-line from
892 } /* if (is_name_beginner(c) */
895 /* Empty statement? */
896 if (is_end_of_line
[(unsigned char) c
])
899 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
902 /* local label ("4:") */
903 char *backup
= input_line_pointer
;
905 HANDLE_CONDITIONAL_ASSEMBLY ();
909 while (isdigit (*input_line_pointer
))
911 temp
= (temp
* 10) + *input_line_pointer
- '0';
912 ++input_line_pointer
;
913 } /* read the whole number */
915 if (LOCAL_LABELS_DOLLAR
916 && *input_line_pointer
== '$'
917 && *(input_line_pointer
+ 1) == ':')
919 input_line_pointer
+= 2;
921 if (dollar_label_defined (temp
))
923 as_fatal ("label \"%d$\" redefined", temp
);
926 define_dollar_label (temp
);
927 colon (dollar_label_name (temp
, 0));
932 && *input_line_pointer
++ == ':')
934 fb_label_instance_inc (temp
);
935 colon (fb_label_name (temp
, 0));
939 input_line_pointer
= backup
;
940 } /* local label ("4:") */
942 if (c
&& strchr (line_comment_chars
, c
))
943 { /* Its a comment. Better say APP or NO_APP */
947 unsigned int new_length
;
950 bump_line_counters ();
951 s
= input_line_pointer
;
952 if (strncmp (s
, "APP\n", 4))
953 continue; /* We ignore it */
956 ends
= strstr (s
, "#NO_APP\n");
960 unsigned int tmp_len
;
963 /* The end of the #APP wasn't in this buffer. We
964 keep reading in buffers until we find the #NO_APP
965 that goes with this #APP There is one. The specs
967 tmp_len
= buffer_limit
- s
;
968 tmp_buf
= xmalloc (tmp_len
+ 1);
969 memcpy (tmp_buf
, s
, tmp_len
);
972 new_tmp
= input_scrub_next_buffer (&buffer
);
976 buffer_limit
= new_tmp
;
977 input_line_pointer
= buffer
;
978 ends
= strstr (buffer
, "#NO_APP\n");
982 num
= buffer_limit
- buffer
;
984 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
985 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
990 input_line_pointer
= ends
? ends
+ 8 : NULL
;
998 input_line_pointer
= ends
+ 8;
1002 scrub_string_end
= ends
;
1004 new_length
= ends
- s
;
1005 new_buf
= (char *) xmalloc (new_length
);
1012 space
= (new_buf
+ new_length
) - new_tmp
;
1013 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1021 new_buf
= xrealloc (new_buf
, new_length
+ 100);
1022 new_tmp
= new_buf
+ new_length
;
1028 old_buffer
= buffer
;
1029 old_input
= input_line_pointer
;
1030 old_limit
= buffer_limit
;
1032 input_line_pointer
= new_buf
;
1033 buffer_limit
= new_tmp
;
1037 HANDLE_CONDITIONAL_ASSEMBLY ();
1039 #ifdef tc_unrecognized_line
1040 if (tc_unrecognized_line (c
))
1044 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
1045 input_line_pointer
--; /* Report unknown char as ignored. */
1046 ignore_rest_of_line ();
1047 } /* while (input_line_pointer<buffer_limit) */
1049 #ifdef md_after_pass_hook
1050 md_after_pass_hook ();
1056 bump_line_counters ();
1059 buffer
= old_buffer
;
1060 input_line_pointer
= old_input
;
1061 buffer_limit
= old_limit
;
1066 } /* while (more buffers to scan) */
1073 input_scrub_close (); /* Close the input file */
1076 /* For most MRI pseudo-ops, the line actually ends at the first
1077 nonquoted space. This function looks for that point, stuffs a null
1078 in, and sets *STOPCP to the character that used to be there, and
1079 returns the location.
1081 Until I hear otherwise, I am going to assume that this is only true
1082 for the m68k MRI assembler. */
1085 mri_comment_field (stopcp
)
1093 know (flag_m68k_mri
);
1095 for (s
= input_line_pointer
;
1096 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1101 inquote
= ! inquote
;
1111 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1121 /* Skip to the end of an MRI comment field. */
1124 mri_comment_end (stop
, stopc
)
1130 input_line_pointer
= stop
;
1132 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1133 ++input_line_pointer
;
1140 as_fatal (".abort detected. Abandoning ship.");
1143 /* Guts of .align directive. N is the power of two to which to align.
1144 FILL may be NULL, or it may point to the bytes of the fill pattern.
1145 LEN is the length of whatever FILL points to, if anything. MAX is
1146 the maximum number of characters to skip when doing the alignment,
1147 or 0 if there is no maximum. */
1150 do_align (n
, fill
, len
, max
)
1159 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1166 #ifdef BFD_ASSEMBLER
1167 if ((bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
1172 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1179 default_fill
= NOP_OPCODE
;
1182 fill
= &default_fill
;
1186 /* Only make a frag if we HAVE to. . . */
1187 if (n
!= 0 && !need_pass_2
)
1190 frag_align (n
, *fill
, max
);
1192 frag_align_pattern (n
, fill
, len
, max
);
1196 just_record_alignment
:
1199 record_alignment (now_seg
, n
);
1202 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1203 (in bytes). A negative ARG is the negative of the length of the
1204 fill pattern. BYTES_P is non-zero if the alignment value should be
1205 interpreted as the byte boundary, rather than the power of 2. */
1208 s_align (arg
, bytes_p
)
1212 register unsigned int align
;
1220 stop
= mri_comment_field (&stopc
);
1222 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1227 align
= arg
; /* Default value from pseudo-op table */
1231 align
= get_absolute_expression ();
1237 /* Convert to a power of 2. */
1242 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1245 as_bad ("Alignment not a power of 2");
1253 as_bad ("Alignment too large: %u assumed", align
);
1256 if (*input_line_pointer
!= ',')
1263 ++input_line_pointer
;
1264 if (*input_line_pointer
== ',')
1268 fill
= get_absolute_expression ();
1273 if (*input_line_pointer
!= ',')
1277 ++input_line_pointer
;
1278 max
= get_absolute_expression ();
1285 as_warn ("expected fill pattern missing");
1286 do_align (align
, (char *) NULL
, 0, max
);
1301 do_align (align
, &fill_char
, fill_len
, max
);
1307 if (fill_len
> sizeof ab
)
1309 md_number_to_chars (ab
, fill
, fill_len
);
1310 do_align (align
, ab
, fill_len
, max
);
1315 mri_comment_end (stop
, stopc
);
1317 demand_empty_rest_of_line ();
1320 /* Handle the .align pseudo-op on machines where ".align 4" means
1321 align to a 4 byte boundary. */
1330 /* Handle the .align pseudo-op on machines where ".align 4" means align
1331 to a 2**4 boundary. */
1344 register char *name
;
1348 register symbolS
*symbolP
;
1353 stop
= mri_comment_field (&stopc
);
1355 name
= input_line_pointer
;
1356 c
= get_symbol_end ();
1357 /* just after name is now '\0' */
1358 p
= input_line_pointer
;
1361 if (*input_line_pointer
!= ',')
1363 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1365 mri_comment_end (stop
, stopc
);
1366 ignore_rest_of_line ();
1369 input_line_pointer
++; /* skip ',' */
1370 if ((temp
= get_absolute_expression ()) < 0)
1372 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1374 mri_comment_end (stop
, stopc
);
1375 ignore_rest_of_line ();
1379 symbolP
= symbol_find_or_make (name
);
1381 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1383 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1384 S_GET_NAME (symbolP
));
1386 mri_comment_end (stop
, stopc
);
1387 ignore_rest_of_line ();
1390 if (S_GET_VALUE (symbolP
))
1392 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1393 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1394 S_GET_NAME (symbolP
),
1395 (long) S_GET_VALUE (symbolP
),
1400 S_SET_VALUE (symbolP
, (valueT
) temp
);
1401 S_SET_EXTERNAL (symbolP
);
1405 extern int flag_one
;
1406 if ( (!temp
) || !flag_one
)
1407 S_GET_OTHER(symbolP
) = const_flag
;
1409 #endif /* not OBJ_VMS */
1410 know (symbolP
->sy_frag
== &zero_address_frag
);
1413 mri_comment_end (stop
, stopc
);
1415 demand_empty_rest_of_line ();
1418 /* The MRI COMMON pseudo-op. We handle this by creating a common
1419 symbol with the appropriate name. We make s_space do the right
1420 thing by increasing the size. */
1423 s_mri_common (small
)
1440 stop
= mri_comment_field (&stopc
);
1444 name
= input_line_pointer
;
1445 if (! isdigit ((unsigned char) *name
))
1446 c
= get_symbol_end ();
1451 ++input_line_pointer
;
1453 while (isdigit ((unsigned char) *input_line_pointer
));
1454 c
= *input_line_pointer
;
1455 *input_line_pointer
= '\0';
1457 if (line_label
!= NULL
)
1459 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1460 + (input_line_pointer
- name
)
1462 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1467 sym
= symbol_find_or_make (name
);
1468 *input_line_pointer
= c
;
1472 if (*input_line_pointer
!= ',')
1476 ++input_line_pointer
;
1477 align
= get_absolute_expression ();
1480 if (S_IS_DEFINED (sym
) && ! S_IS_COMMON (sym
))
1482 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1483 mri_comment_end (stop
, stopc
);
1484 ignore_rest_of_line ();
1488 S_SET_EXTERNAL (sym
);
1489 mri_common_symbol
= sym
;
1493 S_SET_ALIGN (sym
, align
);
1496 if (line_label
!= NULL
)
1498 line_label
->sy_value
.X_op
= O_symbol
;
1499 line_label
->sy_value
.X_add_symbol
= sym
;
1500 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1501 line_label
->sy_frag
= &zero_address_frag
;
1502 S_SET_SEGMENT (line_label
, expr_section
);
1505 /* FIXME: We just ignore the small argument, which distinguishes
1506 COMMON and COMMON.S. I don't know what we can do about it. */
1508 /* Ignore the type and hptype. */
1509 if (*input_line_pointer
== ',')
1510 input_line_pointer
+= 2;
1511 if (*input_line_pointer
== ',')
1512 input_line_pointer
+= 2;
1514 mri_comment_end (stop
, stopc
);
1516 demand_empty_rest_of_line ();
1526 temp
= get_absolute_expression ();
1527 if (flag_readonly_data_in_text
)
1529 section
= text_section
;
1533 section
= data_section
;
1535 subseg_set (section
, (subsegT
) temp
);
1540 demand_empty_rest_of_line ();
1543 /* Handle the .appfile pseudo-op. This is automatically generated by
1544 do_scrub_chars when a preprocessor # line comment is seen with a
1545 file name. This default definition may be overridden by the object
1546 or CPU specific pseudo-ops. This function is also the default
1547 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1551 s_app_file (appfile
)
1557 /* Some assemblers tolerate immediately following '"' */
1558 if ((s
= demand_copy_string (&length
)) != 0)
1560 /* If this is a fake .appfile, a fake newline was inserted into
1561 the buffer. Passing -2 to new_logical_line tells it to
1564 = (! new_logical_line (s
, appfile
? -2 : -1) && appfile
);
1566 /* In MRI mode, the preprocessor may have inserted an extraneous
1569 && *input_line_pointer
== '\''
1570 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1571 ++input_line_pointer
;
1573 demand_empty_rest_of_line ();
1578 listing_source_file (s
);
1580 register_dependency (s
);
1588 /* Handle the .appline pseudo-op. This is automatically generated by
1589 do_scrub_chars when a preprocessor # line comment is seen. This
1590 default definition may be overridden by the object or CPU specific
1599 /* The given number is that of the next line. */
1600 l
= get_absolute_expression () - 1;
1602 /* Some of the back ends can't deal with non-positive line numbers.
1603 Besides, it's silly. */
1604 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1607 new_logical_line ((char *) NULL
, l
);
1610 listing_source_line (l
);
1613 demand_empty_rest_of_line ();
1616 /* Handle the .end pseudo-op. Actually, the real work is done in
1617 read_a_source_file. */
1625 /* The MRI assembler permits the start symbol to follow .end,
1626 but we don't support that. */
1628 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1629 && *input_line_pointer
!= '*'
1630 && *input_line_pointer
!= '!')
1631 as_warn ("start address not supported");
1635 /* Handle the .err pseudo-op. */
1641 as_bad (".err encountered");
1642 demand_empty_rest_of_line ();
1645 /* Handle the MRI fail pseudo-op. */
1656 stop
= mri_comment_field (&stopc
);
1658 temp
= get_absolute_expression ();
1660 as_warn (".fail %ld encountered", (long) temp
);
1662 as_bad (".fail %ld encountered", (long) temp
);
1665 mri_comment_end (stop
, stopc
);
1667 demand_empty_rest_of_line ();
1674 long temp_repeat
= 0;
1676 register long temp_fill
= 0;
1679 #ifdef md_flush_pending_output
1680 md_flush_pending_output ();
1683 temp_repeat
= get_absolute_expression ();
1684 if (*input_line_pointer
== ',')
1686 input_line_pointer
++;
1687 temp_size
= get_absolute_expression ();
1688 if (*input_line_pointer
== ',')
1690 input_line_pointer
++;
1691 temp_fill
= get_absolute_expression ();
1694 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1695 #define BSD_FILL_SIZE_CROCK_8 (8)
1696 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1698 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1699 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1703 as_warn ("Size negative: .fill ignored.");
1706 else if (temp_repeat
<= 0)
1708 if (temp_repeat
< 0)
1709 as_warn ("Repeat < 0, .fill ignored");
1713 if (temp_size
&& !need_pass_2
)
1715 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
,
1716 (relax_substateT
) 0, (symbolS
*) 0, (offsetT
) temp_repeat
,
1718 memset (p
, 0, (unsigned int) temp_size
);
1719 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1720 * flavoured AS. The following bizzare behaviour is to be
1721 * compatible with above. I guess they tried to take up to 8
1722 * bytes from a 4-byte expression and they forgot to sign
1723 * extend. Un*x Sux. */
1724 #define BSD_FILL_SIZE_CROCK_4 (4)
1725 md_number_to_chars (p
, (valueT
) temp_fill
,
1726 (temp_size
> BSD_FILL_SIZE_CROCK_4
1727 ? BSD_FILL_SIZE_CROCK_4
1728 : (int) temp_size
));
1729 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1730 * but emits no error message because it seems a legal thing to do.
1731 * It is a degenerate case of .fill but could be emitted by a compiler.
1734 demand_empty_rest_of_line ();
1748 stop
= mri_comment_field (&stopc
);
1752 name
= input_line_pointer
;
1753 c
= get_symbol_end ();
1754 symbolP
= symbol_find_or_make (name
);
1755 *input_line_pointer
= c
;
1757 S_SET_EXTERNAL (symbolP
);
1760 input_line_pointer
++;
1762 if (*input_line_pointer
== '\n')
1769 mri_comment_end (stop
, stopc
);
1771 demand_empty_rest_of_line ();
1774 /* Handle the MRI IRP and IRPC pseudo-ops. */
1786 as_where (&file
, &line
);
1789 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1790 sb_add_char (&s
, *input_line_pointer
++);
1794 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1796 as_bad_where (file
, line
, "%s", err
);
1800 input_scrub_include_sb (&out
, input_line_pointer
);
1802 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1805 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1806 the section to only be linked once. However, this is not supported
1807 by most object file formats. This takes an optional argument,
1808 which is what to do about duplicates. */
1814 enum linkonce_type type
;
1818 type
= LINKONCE_DISCARD
;
1820 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1825 s
= input_line_pointer
;
1826 c
= get_symbol_end ();
1827 if (strcasecmp (s
, "discard") == 0)
1828 type
= LINKONCE_DISCARD
;
1829 else if (strcasecmp (s
, "one_only") == 0)
1830 type
= LINKONCE_ONE_ONLY
;
1831 else if (strcasecmp (s
, "same_size") == 0)
1832 type
= LINKONCE_SAME_SIZE
;
1833 else if (strcasecmp (s
, "same_contents") == 0)
1834 type
= LINKONCE_SAME_CONTENTS
;
1836 as_warn ("unrecognized .linkonce type `%s'", s
);
1838 *input_line_pointer
= c
;
1841 #ifdef obj_handle_link_once
1842 obj_handle_link_once (type
);
1843 #else /* ! defined (obj_handle_link_once) */
1844 #ifdef BFD_ASSEMBLER
1848 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1849 as_warn (".linkonce is not supported for this object file format");
1851 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1852 flags
|= SEC_LINK_ONCE
;
1857 case LINKONCE_DISCARD
:
1858 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1860 case LINKONCE_ONE_ONLY
:
1861 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1863 case LINKONCE_SAME_SIZE
:
1864 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1866 case LINKONCE_SAME_CONTENTS
:
1867 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1870 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1871 as_bad ("bfd_set_section_flags: %s",
1872 bfd_errmsg (bfd_get_error ()));
1874 #else /* ! defined (BFD_ASSEMBLER) */
1875 as_warn (".linkonce is not supported for this object file format");
1876 #endif /* ! defined (BFD_ASSEMBLER) */
1877 #endif /* ! defined (obj_handle_link_once) */
1879 demand_empty_rest_of_line ();
1883 s_lcomm_internal (needs_align
, bytes_p
)
1884 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1885 (alignment); 0 if it was an ".lcomm" (2 args only) */
1887 /* 1 if the alignment value should be interpreted as the byte boundary,
1888 rather than the power of 2. */
1891 register char *name
;
1895 register symbolS
*symbolP
;
1896 segT current_seg
= now_seg
;
1897 subsegT current_subseg
= now_subseg
;
1898 const int max_alignment
= 15;
1900 segT bss_seg
= bss_section
;
1902 name
= input_line_pointer
;
1903 c
= get_symbol_end ();
1904 p
= input_line_pointer
;
1908 /* Accept an optional comma after the name. The comma used to be
1909 required, but Irix 5 cc does not generate it. */
1910 if (*input_line_pointer
== ',')
1912 ++input_line_pointer
;
1916 if (*input_line_pointer
== '\n')
1918 as_bad ("Missing size expression");
1922 if ((temp
= get_absolute_expression ()) < 0)
1924 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1925 ignore_rest_of_line ();
1929 #if defined (TC_MIPS) || defined (TC_ALPHA)
1930 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1931 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1933 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1934 if (temp
<= bfd_get_gp_size (stdoutput
))
1936 bss_seg
= subseg_new (".sbss", 1);
1937 seg_info (bss_seg
)->bss
= 1;
1938 #ifdef BFD_ASSEMBLER
1939 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1940 as_warn ("error setting flags for \".sbss\": %s",
1941 bfd_errmsg (bfd_get_error ()));
1948 /* FIXME. This needs to be machine independent. */
1959 /* FIXME: This needs to be done in a more general fashion. */
1963 record_alignment(bss_seg
, align
);
1970 if (*input_line_pointer
!= ',')
1972 as_bad ("Expected comma after size");
1973 ignore_rest_of_line ();
1976 input_line_pointer
++;
1978 if (*input_line_pointer
== '\n')
1980 as_bad ("Missing alignment");
1983 align
= get_absolute_expression ();
1986 /* Convert to a power of 2. */
1991 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1994 as_bad ("Alignment not a power of 2");
1998 if (align
> max_alignment
)
2000 align
= max_alignment
;
2001 as_warn ("Alignment too large: %d. assumed.", align
);
2006 as_warn ("Alignment negative. 0 assumed.");
2008 record_alignment (bss_seg
, align
);
2009 } /* if needs align */
2012 /* Assume some objects may require alignment on some systems. */
2013 #if defined (TC_ALPHA) && ! defined (VMS)
2016 align
= ffs (temp
) - 1;
2017 if (temp
% (1 << align
))
2024 symbolP
= symbol_find_or_make (name
);
2028 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
2029 S_GET_OTHER (symbolP
) == 0 &&
2030 S_GET_DESC (symbolP
) == 0 &&
2031 #endif /* OBJ_AOUT or OBJ_BOUT */
2032 (S_GET_SEGMENT (symbolP
) == bss_seg
2033 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
2037 subseg_set (bss_seg
, 1);
2040 frag_align (align
, 0, 0);
2041 /* detach from old frag */
2042 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2043 symbolP
->sy_frag
->fr_symbol
= NULL
;
2045 symbolP
->sy_frag
= frag_now
;
2046 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2047 (offsetT
) temp
, (char *) 0);
2050 S_SET_SEGMENT (symbolP
, bss_seg
);
2053 /* The symbol may already have been created with a preceding
2054 ".globl" directive -- be careful not to step on storage class
2055 in that case. Otherwise, set it to static. */
2056 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2058 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2060 #endif /* OBJ_COFF */
2063 S_SET_SIZE (symbolP
, temp
);
2067 as_bad ("Ignoring attempt to re-define symbol `%s'.",
2068 S_GET_NAME (symbolP
));
2070 subseg_set (current_seg
, current_subseg
);
2072 demand_empty_rest_of_line ();
2073 } /* s_lcomm_internal() */
2076 s_lcomm (needs_align
)
2079 s_lcomm_internal (needs_align
, 0);
2082 void s_lcomm_bytes (needs_align
)
2085 s_lcomm_internal (needs_align
, 1);
2092 register char *name
;
2096 register symbolS
*symbolP
;
2098 /* we permit ANY defined expression: BSD4.2 demands constants */
2099 name
= input_line_pointer
;
2100 c
= get_symbol_end ();
2101 p
= input_line_pointer
;
2104 if (*input_line_pointer
!= ',')
2107 as_bad ("Expected comma after name \"%s\"", name
);
2109 ignore_rest_of_line ();
2112 input_line_pointer
++;
2114 if (exp
.X_op
!= O_constant
2115 && exp
.X_op
!= O_register
)
2117 as_bad ("bad expression");
2118 ignore_rest_of_line ();
2122 symbolP
= symbol_find_or_make (name
);
2124 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2125 symbolP->sy_desc == 0) out of this test because coff doesn't have
2126 those fields, and I can't see when they'd ever be tripped. I
2127 don't think I understand why they were here so I may have
2128 introduced a bug. As recently as 1.37 didn't have this test
2129 anyway. xoxorich. */
2131 if (S_GET_SEGMENT (symbolP
) == undefined_section
2132 && S_GET_VALUE (symbolP
) == 0)
2134 /* The name might be an undefined .global symbol; be sure to
2135 keep the "external" bit. */
2136 S_SET_SEGMENT (symbolP
,
2137 (exp
.X_op
== O_constant
2140 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2144 as_bad ("Symbol %s already defined", name
);
2147 demand_empty_rest_of_line ();
2150 /* Read a line into an sb. */
2156 char quote1
, quote2
, inquote
;
2158 if (input_line_pointer
[-1] == '\n')
2159 bump_line_counters ();
2161 if (input_line_pointer
>= buffer_limit
)
2163 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2164 if (buffer_limit
== 0)
2168 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2169 code needs to be changed. */
2170 if (! flag_m68k_mri
)
2178 #ifdef LEX_IS_STRINGQUOTE
2183 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
2184 || (inquote
!= '\0' && *input_line_pointer
!= '\n'))
2186 if (inquote
== *input_line_pointer
)
2188 else if (inquote
== '\0')
2190 if (*input_line_pointer
== quote1
)
2192 else if (*input_line_pointer
== quote2
)
2195 sb_add_char (line
, *input_line_pointer
++);
2197 while (input_line_pointer
< buffer_limit
2198 && is_end_of_line
[(unsigned char) *input_line_pointer
])
2200 if (input_line_pointer
[-1] == '\n')
2201 bump_line_counters ();
2202 ++input_line_pointer
;
2207 /* Define a macro. This is an interface to macro.c, which is shared
2208 between gas and gasp. */
2221 as_where (&file
, &line
);
2224 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2225 sb_add_char (&s
, *input_line_pointer
++);
2228 if (line_label
!= NULL
)
2229 sb_add_string (&label
, S_GET_NAME (line_label
));
2231 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2233 as_bad_where (file
, line
, "%s", err
);
2236 if (line_label
!= NULL
)
2238 S_SET_SEGMENT (line_label
, undefined_section
);
2239 S_SET_VALUE (line_label
, 0);
2240 line_label
->sy_frag
= &zero_address_frag
;
2244 #ifdef NO_PSEUDO_DOT
2248 && hash_find (po_hash
, name
) != NULL
)
2251 && hash_find (po_hash
, name
+ 1) != NULL
))
2252 as_warn ("attempt to redefine pseudo-op `%s' ignored",
2259 /* Handle the .mexit pseudo-op, which immediately exits a macro
2266 cond_exit_macro (macro_nest
);
2267 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2270 /* Switch in and out of MRI mode. */
2278 on
= get_absolute_expression ();
2279 old_flag
= flag_mri
;
2293 #ifdef MRI_MODE_CHANGE
2295 MRI_MODE_CHANGE (on
);
2298 demand_empty_rest_of_line ();
2301 /* Handle changing the location counter. */
2304 do_org (segment
, exp
, fill
)
2309 if (segment
!= now_seg
&& segment
!= absolute_section
)
2310 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2311 segment_name (segment
), segment_name (now_seg
));
2313 if (now_seg
== absolute_section
)
2316 as_warn ("ignoring fill value in absolute section");
2317 if (exp
->X_op
!= O_constant
)
2319 as_bad ("only constant offsets supported in absolute section");
2320 exp
->X_add_number
= 0;
2322 abs_section_offset
= exp
->X_add_number
;
2328 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2329 exp
->X_add_number
, (char *) NULL
);
2338 register segT segment
;
2340 register long temp_fill
;
2342 /* The m68k MRI assembler has a different meaning for .org. It
2343 means to create an absolute section at a given address. We can't
2344 support that--use a linker script instead. */
2347 as_bad ("MRI style ORG pseudo-op not supported");
2348 ignore_rest_of_line ();
2352 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2353 thing as a sub-segment-relative origin. Any absolute origin is
2354 given a warning, then assumed to be segment-relative. Any
2355 segmented origin expression ("foo+42") had better be in the right
2356 segment or the .org is ignored.
2358 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2359 we never know sub-segment sizes when we are reading code. BSD
2360 will crash trying to emit negative numbers of filler bytes in
2361 certain .orgs. We don't crash, but see as-write for that code.
2363 Don't make frag if need_pass_2==1. */
2364 segment
= get_known_segmented_expression (&exp
);
2365 if (*input_line_pointer
== ',')
2367 input_line_pointer
++;
2368 temp_fill
= get_absolute_expression ();
2374 do_org (segment
, &exp
, temp_fill
);
2376 demand_empty_rest_of_line ();
2379 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2380 called by the obj-format routine which handles section changing
2381 when in MRI mode. It will create a new section, and return it. It
2382 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2383 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2384 flags will be set in the section. */
2398 name
= input_line_pointer
;
2399 if (! isdigit ((unsigned char) *name
))
2400 c
= get_symbol_end ();
2405 ++input_line_pointer
;
2407 while (isdigit ((unsigned char) *input_line_pointer
));
2408 c
= *input_line_pointer
;
2409 *input_line_pointer
= '\0';
2412 name
= xstrdup (name
);
2414 *input_line_pointer
= c
;
2416 seg
= subseg_new (name
, 0);
2418 if (*input_line_pointer
== ',')
2422 ++input_line_pointer
;
2423 align
= get_absolute_expression ();
2424 record_alignment (seg
, align
);
2428 if (*input_line_pointer
== ',')
2430 c
= *++input_line_pointer
;
2431 c
= toupper ((unsigned char) c
);
2432 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2435 as_bad ("unrecognized section type");
2436 ++input_line_pointer
;
2438 #ifdef BFD_ASSEMBLER
2442 flags
= SEC_NO_FLAGS
;
2444 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2445 else if (*type
== 'D' || *type
== 'M')
2446 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2447 else if (*type
== 'R')
2448 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2449 if (flags
!= SEC_NO_FLAGS
)
2451 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2452 as_warn ("error setting flags for \"%s\": %s",
2453 bfd_section_name (stdoutput
, seg
),
2454 bfd_errmsg (bfd_get_error ()));
2460 /* Ignore the HP type. */
2461 if (*input_line_pointer
== ',')
2462 input_line_pointer
+= 2;
2464 demand_empty_rest_of_line ();
2466 #else /* ! TC_M68K */
2475 name
= input_line_pointer
;
2476 c
= get_symbol_end ();
2478 name
= xstrdup (name
);
2480 *input_line_pointer
= c
;
2482 seg
= subseg_new (name
, 0);
2484 if (*input_line_pointer
!= ',')
2490 ++input_line_pointer
;
2492 sectype
= input_line_pointer
;
2493 c
= get_symbol_end ();
2494 if (*sectype
== '\0')
2496 else if (strcasecmp (sectype
, "text") == 0)
2498 else if (strcasecmp (sectype
, "data") == 0)
2500 else if (strcasecmp (sectype
, "romdata") == 0)
2503 as_warn ("unrecognized section type `%s'", sectype
);
2504 *input_line_pointer
= c
;
2507 if (*input_line_pointer
== ',')
2511 ++input_line_pointer
;
2513 seccmd
= input_line_pointer
;
2514 c
= get_symbol_end ();
2515 if (strcasecmp (seccmd
, "absolute") == 0)
2517 as_bad ("absolute sections are not supported");
2518 *input_line_pointer
= c
;
2519 ignore_rest_of_line ();
2522 else if (strcasecmp (seccmd
, "align") == 0)
2526 *input_line_pointer
= c
;
2527 align
= get_absolute_expression ();
2528 record_alignment (seg
, align
);
2532 as_warn ("unrecognized section command `%s'", seccmd
);
2533 *input_line_pointer
= c
;
2537 demand_empty_rest_of_line ();
2539 #else /* ! TC_I960 */
2540 /* The MRI assembler seems to use different forms of .sect for
2541 different targets. */
2543 #endif /* ! TC_I960 */
2544 #endif /* ! TC_M68K */
2547 /* Handle the .print pseudo-op. */
2556 s
= demand_copy_C_string (&len
);
2558 demand_empty_rest_of_line ();
2561 /* Handle the .purgem pseudo-op. */
2567 if (is_it_end_of_statement ())
2569 demand_empty_rest_of_line ();
2579 name
= input_line_pointer
;
2580 c
= get_symbol_end ();
2581 delete_macro (name
);
2582 *input_line_pointer
= c
;
2585 while (*input_line_pointer
++ == ',');
2587 --input_line_pointer
;
2588 demand_empty_rest_of_line ();
2591 /* Handle the .rept pseudo-op. */
2601 count
= get_absolute_expression ();
2604 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2606 as_bad ("rept without endr");
2612 sb_add_sb (&many
, &one
);
2616 input_scrub_include_sb (&many
, input_line_pointer
);
2618 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2621 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2622 this is .equiv, and it is an error if the symbol is already
2629 register char *name
;
2630 register char delim
;
2631 register char *end_name
;
2632 register symbolS
*symbolP
;
2635 * Especial apologies for the random logic:
2636 * this just grew, and could be parsed much more simply!
2639 name
= input_line_pointer
;
2640 delim
= get_symbol_end ();
2641 end_name
= input_line_pointer
;
2645 if (*input_line_pointer
!= ',')
2648 as_bad ("Expected comma after name \"%s\"", name
);
2650 ignore_rest_of_line ();
2654 input_line_pointer
++;
2657 if (name
[0] == '.' && name
[1] == '\0')
2659 /* Turn '. = mumble' into a .org mumble */
2660 register segT segment
;
2663 segment
= get_known_segmented_expression (&exp
);
2666 do_org (segment
, &exp
, 0);
2672 if ((symbolP
= symbol_find (name
)) == NULL
2673 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2675 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2677 /* "set" symbols are local unless otherwise specified. */
2678 SF_SET_LOCAL (symbolP
);
2679 #endif /* OBJ_COFF */
2681 } /* make a new symbol */
2683 symbol_table_insert (symbolP
);
2688 && S_IS_DEFINED (symbolP
)
2689 && S_GET_SEGMENT (symbolP
) != reg_section
)
2690 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
2692 pseudo_set (symbolP
);
2693 demand_empty_rest_of_line ();
2707 #ifdef md_flush_pending_output
2708 md_flush_pending_output ();
2712 stop
= mri_comment_field (&stopc
);
2714 /* In m68k MRI mode, we need to align to a word boundary, unless
2716 if (flag_m68k_mri
&& mult
> 1)
2718 if (now_seg
== absolute_section
)
2720 abs_section_offset
+= abs_section_offset
& 1;
2721 if (line_label
!= NULL
)
2722 S_SET_VALUE (line_label
, abs_section_offset
);
2724 else if (mri_common_symbol
!= NULL
)
2728 val
= S_GET_VALUE (mri_common_symbol
);
2731 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2732 if (line_label
!= NULL
)
2734 know (line_label
->sy_value
.X_op
== O_symbol
);
2735 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2736 line_label
->sy_value
.X_add_number
+= 1;
2742 do_align (1, (char *) NULL
, 0, 0);
2743 if (line_label
!= NULL
)
2745 line_label
->sy_frag
= frag_now
;
2746 S_SET_VALUE (line_label
, frag_now_fix ());
2756 if (*input_line_pointer
== ',')
2758 ++input_line_pointer
;
2763 val
.X_op
= O_constant
;
2764 val
.X_add_number
= 0;
2767 if (val
.X_op
!= O_constant
2768 || val
.X_add_number
< - 0x80
2769 || val
.X_add_number
> 0xff
2770 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2772 if (exp
.X_op
!= O_constant
)
2773 as_bad ("Unsupported variable size or fill value");
2780 bytes
= mult
* exp
.X_add_number
;
2781 for (i
= 0; i
< exp
.X_add_number
; i
++)
2782 emit_expr (&val
, mult
);
2787 if (exp
.X_op
== O_constant
)
2791 repeat
= exp
.X_add_number
;
2797 if (! flag_mri
|| repeat
< 0)
2798 as_warn (".space repeat count is %s, ignored",
2799 repeat
? "negative" : "zero");
2803 /* If we are in the absolute section, just bump the offset. */
2804 if (now_seg
== absolute_section
)
2806 abs_section_offset
+= repeat
;
2810 /* If we are secretly in an MRI common section, then
2811 creating space just increases the size of the common
2813 if (mri_common_symbol
!= NULL
)
2815 S_SET_VALUE (mri_common_symbol
,
2816 S_GET_VALUE (mri_common_symbol
) + repeat
);
2821 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2822 (offsetT
) repeat
, (char *) 0);
2826 if (now_seg
== absolute_section
)
2828 as_bad ("space allocation too complex in absolute section");
2829 subseg_set (text_section
, 0);
2831 if (mri_common_symbol
!= NULL
)
2833 as_bad ("space allocation too complex in common section");
2834 mri_common_symbol
= NULL
;
2837 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2838 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
2842 *p
= val
.X_add_number
;
2847 /* In MRI mode, after an odd number of bytes, we must align to an
2848 even word boundary, unless the next instruction is a dc.b, ds.b
2850 if (flag_mri
&& (bytes
& 1) != 0)
2851 mri_pending_align
= 1;
2854 mri_comment_end (stop
, stopc
);
2856 demand_empty_rest_of_line ();
2859 /* This is like s_space, but the value is a floating point number with
2860 the given precision. This is for the MRI dcb.s pseudo-op and
2864 s_float_space (float_type
)
2869 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2874 stop
= mri_comment_field (&stopc
);
2876 count
= get_absolute_expression ();
2879 if (*input_line_pointer
!= ',')
2881 as_bad ("missing value");
2883 mri_comment_end (stop
, stopc
);
2884 ignore_rest_of_line ();
2888 ++input_line_pointer
;
2892 /* Skip any 0{letter} that may be present. Don't even check if the
2893 * letter is legal. */
2894 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2895 input_line_pointer
+= 2;
2897 /* Accept :xxxx, where the x's are hex digits, for a floating point
2898 with the exact digits specified. */
2899 if (input_line_pointer
[0] == ':')
2901 flen
= hex_float (float_type
, temp
);
2905 mri_comment_end (stop
, stopc
);
2906 ignore_rest_of_line ();
2914 err
= md_atof (float_type
, temp
, &flen
);
2915 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2919 as_bad ("Bad floating literal: %s", err
);
2921 mri_comment_end (stop
, stopc
);
2922 ignore_rest_of_line ();
2927 while (--count
>= 0)
2931 p
= frag_more (flen
);
2932 memcpy (p
, temp
, (unsigned int) flen
);
2936 mri_comment_end (stop
, stopc
);
2938 demand_empty_rest_of_line ();
2941 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2951 stop
= mri_comment_field (&stopc
);
2952 abs_section_offset
= get_absolute_expression ();
2953 subseg_set (absolute_section
, 0);
2955 mri_comment_end (stop
, stopc
);
2956 demand_empty_rest_of_line ();
2965 temp
= get_absolute_expression ();
2966 subseg_set (text_section
, (subsegT
) temp
);
2967 demand_empty_rest_of_line ();
2969 const_flag
&= ~IN_DEFAULT_SECTION
;
2975 demand_empty_rest_of_line ()
2978 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2980 input_line_pointer
++;
2984 ignore_rest_of_line ();
2986 /* Return having already swallowed end-of-line. */
2987 } /* Return pointing just after end-of-line. */
2990 ignore_rest_of_line () /* For suspect lines: gives warning. */
2992 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2994 if (isprint (*input_line_pointer
))
2995 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2996 *input_line_pointer
);
2998 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2999 *input_line_pointer
);
3000 while (input_line_pointer
< buffer_limit
3001 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3003 input_line_pointer
++;
3006 input_line_pointer
++; /* Return pointing just after end-of-line. */
3007 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3013 * In: Pointer to a symbol.
3014 * Input_line_pointer->expression.
3016 * Out: Input_line_pointer->just after any whitespace after expression.
3017 * Tried to set symbol to value of expression.
3018 * Will change symbols type, value, and frag;
3021 pseudo_set (symbolP
)
3025 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3027 #endif /* OBJ_AOUT or OBJ_BOUT */
3029 know (symbolP
); /* NULL pointer is logic error. */
3030 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3031 ext
= S_IS_EXTERNAL (symbolP
);
3032 #endif /* OBJ_AOUT or OBJ_BOUT */
3034 (void) expression (&exp
);
3036 if (exp
.X_op
== O_illegal
)
3037 as_bad ("illegal expression; zero assumed");
3038 else if (exp
.X_op
== O_absent
)
3039 as_bad ("missing expression; zero assumed");
3040 else if (exp
.X_op
== O_big
)
3041 as_bad ("%s number invalid; zero assumed",
3042 exp
.X_add_number
> 0 ? "bignum" : "floating point");
3043 else if (exp
.X_op
== O_subtract
3044 && (S_GET_SEGMENT (exp
.X_add_symbol
)
3045 == S_GET_SEGMENT (exp
.X_op_symbol
))
3046 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3047 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
3049 exp
.X_op
= O_constant
;
3050 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3051 - S_GET_VALUE (exp
.X_op_symbol
));
3059 exp
.X_add_number
= 0;
3062 S_SET_SEGMENT (symbolP
, absolute_section
);
3063 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3065 S_SET_EXTERNAL (symbolP
);
3067 S_CLEAR_EXTERNAL (symbolP
);
3068 #endif /* OBJ_AOUT or OBJ_BOUT */
3069 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3070 symbolP
->sy_frag
= &zero_address_frag
;
3074 S_SET_SEGMENT (symbolP
, reg_section
);
3075 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3076 symbolP
->sy_frag
= &zero_address_frag
;
3080 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
3081 || exp
.X_add_number
!= 0)
3082 symbolP
->sy_value
= exp
;
3085 symbolS
*s
= exp
.X_add_symbol
;
3087 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
3088 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3090 S_SET_EXTERNAL (symbolP
);
3092 S_CLEAR_EXTERNAL (symbolP
);
3093 #endif /* OBJ_AOUT or OBJ_BOUT */
3094 S_SET_VALUE (symbolP
,
3095 exp
.X_add_number
+ S_GET_VALUE (s
));
3096 symbolP
->sy_frag
= s
->sy_frag
;
3097 copy_symbol_attributes (symbolP
, s
);
3102 /* The value is some complex expression.
3103 FIXME: Should we set the segment to anything? */
3104 symbolP
->sy_value
= exp
;
3112 * CONStruct more frag of .bytes, or .words etc.
3113 * Should need_pass_2 be 1 then emit no frag(s).
3114 * This understands EXPRESSIONS.
3118 * This has a split personality. We use expression() to read the
3119 * value. We can detect if the value won't fit in a byte or word.
3120 * But we can't detect if expression() discarded significant digits
3121 * in the case of a long. Not worth the crocks required to fix it.
3124 /* Select a parser for cons expressions. */
3126 /* Some targets need to parse the expression in various fancy ways.
3127 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3128 (for example, the HPPA does this). Otherwise, you can define
3129 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3130 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3131 are defined, which is the normal case, then only simple expressions
3135 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3137 #ifndef TC_PARSE_CONS_EXPRESSION
3138 #ifdef BITFIELD_CONS_EXPRESSIONS
3139 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3141 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3143 #ifdef REPEAT_CONS_EXPRESSIONS
3144 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3146 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3149 /* If we haven't gotten one yet, just call expression. */
3150 #ifndef TC_PARSE_CONS_EXPRESSION
3151 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3155 /* worker to do .byte etc statements */
3156 /* clobbers input_line_pointer, checks */
3159 cons_worker (nbytes
, rva
)
3160 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3168 #ifdef md_flush_pending_output
3169 md_flush_pending_output ();
3173 stop
= mri_comment_field (&stopc
);
3175 if (is_it_end_of_statement ())
3178 mri_comment_end (stop
, stopc
);
3179 demand_empty_rest_of_line ();
3183 #ifdef md_cons_align
3184 md_cons_align (nbytes
);
3191 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3193 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3197 if (exp
.X_op
== O_symbol
)
3198 exp
.X_op
= O_symbol_rva
;
3200 as_fatal ("rva without symbol");
3202 emit_expr (&exp
, (unsigned int) nbytes
);
3205 while (*input_line_pointer
++ == ',');
3207 /* In MRI mode, after an odd number of bytes, we must align to an
3208 even word boundary, unless the next instruction is a dc.b, ds.b
3210 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3211 mri_pending_align
= 1;
3213 input_line_pointer
--; /* Put terminator back into stream. */
3216 mri_comment_end (stop
, stopc
);
3218 demand_empty_rest_of_line ();
3226 cons_worker (size
, 0);
3233 cons_worker (size
, 1);
3237 /* Put the contents of expression EXP into the object file using
3238 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3241 emit_expr (exp
, nbytes
)
3243 unsigned int nbytes
;
3247 valueT extra_digit
= 0;
3249 /* Don't do anything if we are going to make another pass. */
3255 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3256 appear as a four byte positive constant in the .line section,
3257 followed by a 2 byte 0xffff. Look for that case here. */
3259 static int dwarf_line
= -1;
3261 if (strcmp (segment_name (now_seg
), ".line") != 0)
3263 else if (dwarf_line
>= 0
3265 && exp
->X_op
== O_constant
3266 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
3267 listing_source_line ((unsigned int) dwarf_line
);
3268 else if (nbytes
== 4
3269 && exp
->X_op
== O_constant
3270 && exp
->X_add_number
>= 0)
3271 dwarf_line
= exp
->X_add_number
;
3276 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3277 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3278 AT_sibling (0x12) followed by a four byte address of the sibling
3279 followed by a 2 byte AT_name (0x38) followed by the name of the
3280 file. We look for that case here. */
3282 static int dwarf_file
= 0;
3284 if (strcmp (segment_name (now_seg
), ".debug") != 0)
3286 else if (dwarf_file
== 0
3288 && exp
->X_op
== O_constant
3289 && exp
->X_add_number
== 0x11)
3291 else if (dwarf_file
== 1
3293 && exp
->X_op
== O_constant
3294 && exp
->X_add_number
== 0x12)
3296 else if (dwarf_file
== 2
3299 else if (dwarf_file
== 3
3301 && exp
->X_op
== O_constant
3302 && exp
->X_add_number
== 0x38)
3307 /* The variable dwarf_file_string tells stringer that the string
3308 may be the name of the source file. */
3309 if (dwarf_file
== 4)
3310 dwarf_file_string
= 1;
3312 dwarf_file_string
= 0;
3319 /* Allow `.word 0' in the absolute section. */
3320 if (now_seg
== absolute_section
)
3322 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3323 as_bad ("attempt to store value in absolute section");
3324 abs_section_offset
+= nbytes
;
3328 /* Handle a negative bignum. */
3330 && exp
->X_add_number
== 0
3331 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3332 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3335 unsigned long carry
;
3337 exp
= &exp
->X_add_symbol
->sy_value
;
3339 /* Negate the bignum: one's complement each digit and add 1. */
3341 for (i
= 0; i
< exp
->X_add_number
; i
++)
3345 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3348 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3349 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3352 /* We can ignore any carry out, because it will be handled by
3353 extra_digit if it is needed. */
3355 extra_digit
= (valueT
) -1;
3359 if (op
== O_absent
|| op
== O_illegal
)
3361 as_warn ("zero assumed for missing expression");
3362 exp
->X_add_number
= 0;
3365 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3367 as_bad ("floating point number invalid; zero assumed");
3368 exp
->X_add_number
= 0;
3371 else if (op
== O_register
)
3373 as_warn ("register value used as expression");
3377 p
= frag_more ((int) nbytes
);
3379 #ifndef WORKING_DOT_WORD
3380 /* If we have the difference of two symbols in a word, save it on
3381 the broken_words list. See the code in write.c. */
3382 if (op
== O_subtract
&& nbytes
== 2)
3384 struct broken_word
*x
;
3386 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3387 x
->next_broken_word
= broken_words
;
3390 x
->word_goes_here
= p
;
3392 x
->add
= exp
->X_add_symbol
;
3393 x
->sub
= exp
->X_op_symbol
;
3394 x
->addnum
= exp
->X_add_number
;
3401 /* If we have an integer, but the number of bytes is too large to
3402 pass to md_number_to_chars, handle it as a bignum. */
3403 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3408 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3409 extra_digit
= (valueT
) -1;
3410 val
= (valueT
) exp
->X_add_number
;
3414 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3415 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3419 op
= exp
->X_op
= O_big
;
3420 exp
->X_add_number
= gencnt
;
3423 if (op
== O_constant
)
3425 register valueT get
;
3426 register valueT use
;
3427 register valueT mask
;
3429 register valueT unmask
;
3431 /* JF << of >= number of bits in the object is undefined. In
3432 particular SPARC (Sun 4) has problems */
3433 if (nbytes
>= sizeof (valueT
))
3436 if (nbytes
> sizeof (valueT
))
3439 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3443 /* Don't store these bits. */
3444 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3445 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3448 unmask
= ~mask
; /* Do store these bits. */
3451 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3452 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3455 get
= exp
->X_add_number
;
3457 if ((get
& mask
) != 0
3458 && ((get
& mask
) != mask
3459 || (get
& hibit
) == 0))
3460 { /* Leading bits contain both 0s & 1s. */
3461 as_warn ("Value 0x%lx truncated to 0x%lx.",
3462 (unsigned long) get
, (unsigned long) use
);
3464 /* put bytes in right order. */
3465 md_number_to_chars (p
, use
, (int) nbytes
);
3467 else if (op
== O_big
)
3470 LITTLENUM_TYPE
*nums
;
3472 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3474 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3477 as_warn ("Bignum truncated to %d bytes", nbytes
);
3481 if (target_big_endian
)
3483 while (nbytes
> size
)
3485 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3486 nbytes
-= CHARS_PER_LITTLENUM
;
3487 p
+= CHARS_PER_LITTLENUM
;
3490 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3494 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3495 size
-= CHARS_PER_LITTLENUM
;
3496 p
+= CHARS_PER_LITTLENUM
;
3501 nums
= generic_bignum
;
3504 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3506 size
-= CHARS_PER_LITTLENUM
;
3507 p
+= CHARS_PER_LITTLENUM
;
3508 nbytes
-= CHARS_PER_LITTLENUM
;
3513 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3514 nbytes
-= CHARS_PER_LITTLENUM
;
3515 p
+= CHARS_PER_LITTLENUM
;
3521 memset (p
, 0, nbytes
);
3523 /* Now we need to generate a fixS to record the symbol value.
3524 This is easy for BFD. For other targets it can be more
3525 complex. For very complex cases (currently, the HPPA and
3526 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3527 want. For simpler cases, you can define TC_CONS_RELOC to be
3528 the name of the reloc code that should be stored in the fixS.
3529 If neither is defined, the code uses NO_RELOC if it is
3530 defined, and otherwise uses 0. */
3532 #ifdef BFD_ASSEMBLER
3533 #ifdef TC_CONS_FIX_NEW
3534 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3537 bfd_reloc_code_real_type r
;
3554 as_bad ("unsupported BFD relocation size %u", nbytes
);
3558 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3563 #ifdef TC_CONS_FIX_NEW
3564 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3566 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3567 it is defined, otherwise use NO_RELOC if it is defined,
3569 #ifndef TC_CONS_RELOC
3571 #define TC_CONS_RELOC NO_RELOC
3573 #define TC_CONS_RELOC 0
3576 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3578 #endif /* TC_CONS_FIX_NEW */
3579 #endif /* BFD_ASSEMBLER */
3583 #ifdef BITFIELD_CONS_EXPRESSIONS
3585 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3586 w:x,y:z, where w and y are bitwidths and x and y are values. They
3587 then pack them all together. We do a little better in that we allow
3588 them in words, longs, etc. and we'll pack them in target byte order
3591 The rules are: pack least significat bit first, if a field doesn't
3592 entirely fit, put it in the next unit. Overflowing the bitfield is
3593 explicitly *not* even a warning. The bitwidth should be considered
3596 To use this function the tc-XXX.h file should define
3597 BITFIELD_CONS_EXPRESSIONS. */
3600 parse_bitfield_cons (exp
, nbytes
)
3602 unsigned int nbytes
;
3604 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3605 char *hold
= input_line_pointer
;
3607 (void) expression (exp
);
3609 if (*input_line_pointer
== ':')
3615 unsigned long width
;
3617 if (*input_line_pointer
!= ':')
3619 input_line_pointer
= hold
;
3621 } /* next piece is not a bitfield */
3623 /* In the general case, we can't allow
3624 full expressions with symbol
3625 differences and such. The relocation
3626 entries for symbols not defined in this
3627 assembly would require arbitrary field
3628 widths, positions, and masks which most
3629 of our current object formats don't
3632 In the specific case where a symbol
3633 *is* defined in this assembly, we
3634 *could* build fixups and track it, but
3635 this could lead to confusion for the
3636 backends. I'm lazy. I'll take any
3637 SEG_ABSOLUTE. I think that means that
3638 you can use a previous .set or
3639 .equ type symbol. xoxorich. */
3641 if (exp
->X_op
== O_absent
)
3643 as_warn ("using a bit field width of zero");
3644 exp
->X_add_number
= 0;
3645 exp
->X_op
= O_constant
;
3646 } /* implied zero width bitfield */
3648 if (exp
->X_op
!= O_constant
)
3650 *input_line_pointer
= '\0';
3651 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3652 *input_line_pointer
= ':';
3653 demand_empty_rest_of_line ();
3657 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3659 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3660 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3661 width
= BITS_PER_CHAR
* nbytes
;
3664 if (width
> bits_available
)
3666 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3667 input_line_pointer
= hold
;
3668 exp
->X_add_number
= value
;
3672 hold
= ++input_line_pointer
; /* skip ':' */
3674 (void) expression (exp
);
3675 if (exp
->X_op
!= O_constant
)
3677 char cache
= *input_line_pointer
;
3679 *input_line_pointer
= '\0';
3680 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3681 *input_line_pointer
= cache
;
3682 demand_empty_rest_of_line ();
3686 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3687 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3689 if ((bits_available
-= width
) == 0
3690 || is_it_end_of_statement ()
3691 || *input_line_pointer
!= ',')
3694 } /* all the bitfields we're gonna get */
3696 hold
= ++input_line_pointer
;
3697 (void) expression (exp
);
3698 } /* forever loop */
3700 exp
->X_add_number
= value
;
3701 exp
->X_op
= O_constant
;
3702 exp
->X_unsigned
= 1;
3703 } /* if looks like a bitfield */
3704 } /* parse_bitfield_cons() */
3706 #endif /* BITFIELD_CONS_EXPRESSIONS */
3708 /* Handle an MRI style string expression. */
3711 parse_mri_cons (exp
, nbytes
)
3713 unsigned int nbytes
;
3715 if (*input_line_pointer
!= '\''
3716 && (input_line_pointer
[1] != '\''
3717 || (*input_line_pointer
!= 'A'
3718 && *input_line_pointer
!= 'E')))
3719 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3723 unsigned int result
= 0;
3725 /* An MRI style string. Cut into as many bytes as will fit into
3726 a nbyte chunk, left justify if necessary, and separate with
3727 commas so we can try again later. */
3728 if (*input_line_pointer
== 'A')
3729 ++input_line_pointer
;
3730 else if (*input_line_pointer
== 'E')
3732 as_bad ("EBCDIC constants are not supported");
3733 ++input_line_pointer
;
3736 input_line_pointer
++;
3737 for (scan
= 0; scan
< nbytes
; scan
++)
3739 if (*input_line_pointer
== '\'')
3741 if (input_line_pointer
[1] == '\'')
3743 input_line_pointer
++;
3748 result
= (result
<< 8) | (*input_line_pointer
++);
3752 while (scan
< nbytes
)
3757 /* Create correct expression */
3758 exp
->X_op
= O_constant
;
3759 exp
->X_add_number
= result
;
3760 /* Fake it so that we can read the next char too */
3761 if (input_line_pointer
[0] != '\'' ||
3762 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3764 input_line_pointer
-= 2;
3765 input_line_pointer
[0] = ',';
3766 input_line_pointer
[1] = '\'';
3769 input_line_pointer
++;
3773 #ifdef REPEAT_CONS_EXPRESSIONS
3775 /* Parse a repeat expression for cons. This is used by the MIPS
3776 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3777 object file COUNT times.
3779 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3782 parse_repeat_cons (exp
, nbytes
)
3784 unsigned int nbytes
;
3791 if (*input_line_pointer
!= ':')
3793 /* No repeat count. */
3797 ++input_line_pointer
;
3798 expression (&count
);
3799 if (count
.X_op
!= O_constant
3800 || count
.X_add_number
<= 0)
3802 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3806 /* The cons function is going to output this expression once. So we
3807 output it count - 1 times. */
3808 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3809 emit_expr (exp
, nbytes
);
3812 #endif /* REPEAT_CONS_EXPRESSIONS */
3814 /* Parse a floating point number represented as a hex constant. This
3815 permits users to specify the exact bits they want in the floating
3819 hex_float (float_type
, bytes
)
3853 as_bad ("Unknown floating type type '%c'", float_type
);
3857 /* It would be nice if we could go through expression to parse the
3858 hex constant, but if we get a bignum it's a pain to sort it into
3859 the buffer correctly. */
3861 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3865 /* The MRI assembler accepts arbitrary underscores strewn about
3866 through the hex constant, so we ignore them as well. */
3867 if (*input_line_pointer
== '_')
3869 ++input_line_pointer
;
3875 as_warn ("Floating point constant too large");
3878 d
= hex_value (*input_line_pointer
) << 4;
3879 ++input_line_pointer
;
3880 while (*input_line_pointer
== '_')
3881 ++input_line_pointer
;
3882 if (hex_p (*input_line_pointer
))
3884 d
+= hex_value (*input_line_pointer
);
3885 ++input_line_pointer
;
3887 if (target_big_endian
)
3890 bytes
[length
- i
- 1] = d
;
3896 if (target_big_endian
)
3897 memset (bytes
+ i
, 0, length
- i
);
3899 memset (bytes
, 0, length
- i
);
3908 * CONStruct some more frag chars of .floats .ffloats etc.
3909 * Makes 0 or more new frags.
3910 * If need_pass_2 == 1, no frags are emitted.
3911 * This understands only floating literals, not expressions. Sorry.
3913 * A floating constant is defined by atof_generic(), except it is preceded
3914 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3915 * reading, I decided to be incompatible. This always tries to give you
3916 * rounded bits to the precision of the pseudo-op. Former AS did premature
3917 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3918 * a choice of 2 flavours of noise according to which of 2 floating-point
3919 * scanners you directed AS to use.
3921 * In: input_line_pointer->whitespace before, or '0' of flonum.
3926 float_cons (float_type
)
3927 /* Clobbers input_line-pointer, checks end-of-line. */
3928 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3931 int length
; /* Number of chars in an object. */
3932 register char *err
; /* Error from scanning floating literal. */
3933 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3935 if (is_it_end_of_statement ())
3937 demand_empty_rest_of_line ();
3941 #ifdef md_flush_pending_output
3942 md_flush_pending_output ();
3947 /* input_line_pointer->1st char of a flonum (we hope!). */
3950 /* Skip any 0{letter} that may be present. Don't even check if the
3951 * letter is legal. Someone may invent a "z" format and this routine
3952 * has no use for such information. Lusers beware: you get
3953 * diagnostics if your input is ill-conditioned.
3955 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3956 input_line_pointer
+= 2;
3958 /* Accept :xxxx, where the x's are hex digits, for a floating
3959 point with the exact digits specified. */
3960 if (input_line_pointer
[0] == ':')
3962 ++input_line_pointer
;
3963 length
= hex_float (float_type
, temp
);
3966 ignore_rest_of_line ();
3972 err
= md_atof (float_type
, temp
, &length
);
3973 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3977 as_bad ("Bad floating literal: %s", err
);
3978 ignore_rest_of_line ();
3989 #ifdef REPEAT_CONS_EXPRESSIONS
3990 if (*input_line_pointer
== ':')
3992 expressionS count_exp
;
3994 ++input_line_pointer
;
3995 expression (&count_exp
);
3996 if (count_exp
.X_op
!= O_constant
3997 || count_exp
.X_add_number
<= 0)
3999 as_warn ("unresolvable or nonpositive repeat count; using 1");
4002 count
= count_exp
.X_add_number
;
4006 while (--count
>= 0)
4008 p
= frag_more (length
);
4009 memcpy (p
, temp
, (unsigned int) length
);
4014 while (*input_line_pointer
++ == ',');
4016 --input_line_pointer
; /* Put terminator back into stream. */
4017 demand_empty_rest_of_line ();
4018 } /* float_cons() */
4020 /* Return the size of a LEB128 value */
4023 sizeof_sleb128 (value
)
4026 register int size
= 0;
4027 register unsigned byte
;
4031 byte
= (value
& 0x7f);
4032 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4033 Fortunately, we can structure things so that the extra work reduces
4034 to a noop on systems that do things "properly". */
4035 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4038 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4039 || ((value
== -1) && ((byte
& 0x40) != 0))));
4045 sizeof_uleb128 (value
)
4048 register int size
= 0;
4049 register unsigned byte
;
4053 byte
= (value
& 0x7f);
4063 sizeof_leb128 (value
, sign
)
4068 return sizeof_sleb128 ((offsetT
) value
);
4070 return sizeof_uleb128 (value
);
4073 /* Output a LEB128 value. */
4076 output_sleb128 (p
, value
)
4080 register char *orig
= p
;
4085 unsigned byte
= (value
& 0x7f);
4087 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4088 Fortunately, we can structure things so that the extra work reduces
4089 to a noop on systems that do things "properly". */
4090 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4092 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4093 || ((value
== -1) && ((byte
& 0x40) != 0))));
4105 output_uleb128 (p
, value
)
4113 unsigned byte
= (value
& 0x7f);
4116 /* More bytes to follow. */
4127 output_leb128 (p
, value
, sign
)
4133 return output_sleb128 (p
, (offsetT
) value
);
4135 return output_uleb128 (p
, value
);
4138 /* Do the same for bignums. We combine sizeof with output here in that
4139 we don't output for NULL values of P. It isn't really as critical as
4140 for "normal" values that this be streamlined. */
4143 output_big_sleb128 (p
, bignum
, size
)
4145 LITTLENUM_TYPE
*bignum
;
4153 /* Strip leading sign extensions off the bignum. */
4154 while (size
> 0 && bignum
[size
-1] == (LITTLENUM_TYPE
)-1)
4159 if (loaded
< 7 && size
> 0)
4161 val
|= (*bignum
<< loaded
);
4162 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4173 if ((val
== 0 && (byte
& 0x40) == 0)
4174 || (~(val
| ~(((valueT
)1 << loaded
) - 1)) == 0
4175 && (byte
& 0x40) != 0))
4183 while (byte
& 0x80);
4189 output_big_uleb128 (p
, bignum
, size
)
4191 LITTLENUM_TYPE
*bignum
;
4199 /* Strip leading zeros off the bignum. */
4200 /* XXX: Is this needed? */
4201 while (size
> 0 && bignum
[size
-1] == 0)
4206 if (loaded
< 7 && size
> 0)
4208 val
|= (*bignum
<< loaded
);
4209 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4218 if (size
> 0 || val
)
4225 while (byte
& 0x80);
4231 output_big_leb128 (p
, bignum
, size
, sign
)
4233 LITTLENUM_TYPE
*bignum
;
4237 return output_big_sleb128 (p
, bignum
, size
);
4239 return output_big_uleb128 (p
, bignum
, size
);
4242 /* Generate the appropriate fragments for a given expression to emit a
4246 emit_leb128_expr(exp
, sign
)
4250 operatorT op
= exp
->X_op
;
4252 if (op
== O_absent
|| op
== O_illegal
)
4254 as_warn ("zero assumed for missing expression");
4255 exp
->X_add_number
= 0;
4258 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4260 as_bad ("floating point number invalid; zero assumed");
4261 exp
->X_add_number
= 0;
4264 else if (op
== O_register
)
4266 as_warn ("register value used as expression");
4270 if (op
== O_constant
)
4272 /* If we've got a constant, emit the thing directly right now. */
4274 valueT value
= exp
->X_add_number
;
4278 size
= sizeof_leb128 (value
, sign
);
4279 p
= frag_more (size
);
4280 output_leb128 (p
, value
, sign
);
4282 else if (op
== O_big
)
4284 /* O_big is a different sort of constant. */
4289 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
4290 p
= frag_more (size
);
4291 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
4295 /* Otherwise, we have to create a variable sized fragment and
4296 resolve things later. */
4298 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
)0), 0, sign
,
4299 make_expr_symbol (exp
), 0, (char *) NULL
);
4303 /* Parse the .sleb128 and .uleb128 pseudos. */
4313 emit_leb128_expr (&exp
, sign
);
4314 } while (*input_line_pointer
++ == ',');
4316 input_line_pointer
--;
4317 demand_empty_rest_of_line ();
4323 * We read 0 or more ',' seperated, double-quoted strings.
4325 * Caller should have checked need_pass_2 is FALSE because we don't check it.
4330 stringer (append_zero
) /* Worker to do .ascii etc statements. */
4331 /* Checks end-of-line. */
4332 register int append_zero
; /* 0: don't append '\0', else 1 */
4334 register unsigned int c
;
4337 #ifdef md_flush_pending_output
4338 md_flush_pending_output ();
4342 * The following awkward logic is to parse ZERO or more strings,
4343 * comma seperated. Recall a string expression includes spaces
4344 * before the opening '\"' and spaces after the closing '\"'.
4345 * We fake a leading ',' if there is (supposed to be)
4346 * a 1st, expression. We keep demanding expressions for each
4349 if (is_it_end_of_statement ())
4351 c
= 0; /* Skip loop. */
4352 ++input_line_pointer
; /* Compensate for end of loop. */
4356 c
= ','; /* Do loop. */
4358 while (c
== ',' || c
== '<' || c
== '"')
4361 switch (*input_line_pointer
)
4364 ++input_line_pointer
; /*->1st char of string. */
4365 start
= input_line_pointer
;
4366 while (is_a_char (c
= next_char_of_string ()))
4368 FRAG_APPEND_1_CHAR (c
);
4372 FRAG_APPEND_1_CHAR (0);
4374 know (input_line_pointer
[-1] == '\"');
4378 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4379 will emit .string with a filename in the .debug section
4380 after a sequence of constants. See the comment in
4381 emit_expr for the sequence. emit_expr will set
4382 dwarf_file_string to non-zero if this string might be a
4383 source file name. */
4384 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4385 dwarf_file_string
= 0;
4386 else if (dwarf_file_string
)
4388 c
= input_line_pointer
[-1];
4389 input_line_pointer
[-1] = '\0';
4390 listing_source_file (start
);
4391 input_line_pointer
[-1] = c
;
4398 input_line_pointer
++;
4399 c
= get_single_number ();
4400 FRAG_APPEND_1_CHAR (c
);
4401 if (*input_line_pointer
!= '>')
4403 as_bad ("Expected <nn>");
4405 input_line_pointer
++;
4408 input_line_pointer
++;
4412 c
= *input_line_pointer
;
4415 demand_empty_rest_of_line ();
4418 /* FIXME-SOMEDAY: I had trouble here on characters with the
4419 high bits set. We'll probably also have trouble with
4420 multibyte chars, wide chars, etc. Also be careful about
4421 returning values bigger than 1 byte. xoxorich. */
4424 next_char_of_string ()
4426 register unsigned int c
;
4428 c
= *input_line_pointer
++ & CHAR_MASK
;
4436 as_warn ("Unterminated string: Newline inserted.");
4437 bump_line_counters ();
4440 #ifndef NO_STRING_ESCAPES
4442 switch (c
= *input_line_pointer
++)
4470 break; /* As itself. */
4486 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
4488 number
= number
* 8 + c
- '0';
4492 --input_line_pointer
;
4501 c
= *input_line_pointer
++;
4502 while (isxdigit (c
))
4505 number
= number
* 16 + c
- '0';
4506 else if (isupper (c
))
4507 number
= number
* 16 + c
- 'A' + 10;
4509 number
= number
* 16 + c
- 'a' + 10;
4510 c
= *input_line_pointer
++;
4513 --input_line_pointer
;
4518 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4519 as_warn ("Unterminated string: Newline inserted.");
4521 bump_line_counters ();
4526 #ifdef ONLY_STANDARD_ESCAPES
4527 as_bad ("Bad escaped character in string, '?' assumed");
4529 #endif /* ONLY_STANDARD_ESCAPES */
4532 } /* switch on escaped char */
4534 #endif /* ! defined (NO_STRING_ESCAPES) */
4538 } /* switch on char */
4540 } /* next_char_of_string() */
4543 get_segmented_expression (expP
)
4544 register expressionS
*expP
;
4546 register segT retval
;
4548 retval
= expression (expP
);
4549 if (expP
->X_op
== O_illegal
4550 || expP
->X_op
== O_absent
4551 || expP
->X_op
== O_big
)
4553 as_bad ("expected address expression; zero assumed");
4554 expP
->X_op
= O_constant
;
4555 expP
->X_add_number
= 0;
4556 retval
= absolute_section
;
4562 get_known_segmented_expression (expP
)
4563 register expressionS
*expP
;
4565 register segT retval
;
4567 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4569 /* There is no easy way to extract the undefined symbol from the
4571 if (expP
->X_add_symbol
!= NULL
4572 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4573 as_warn ("symbol \"%s\" undefined; zero assumed",
4574 S_GET_NAME (expP
->X_add_symbol
));
4576 as_warn ("some symbol undefined; zero assumed");
4577 retval
= absolute_section
;
4578 expP
->X_op
= O_constant
;
4579 expP
->X_add_number
= 0;
4581 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4583 } /* get_known_segmented_expression() */
4586 get_absolute_expression ()
4591 if (exp
.X_op
!= O_constant
)
4593 if (exp
.X_op
!= O_absent
)
4594 as_bad ("bad or irreducible absolute expression; zero assumed");
4595 exp
.X_add_number
= 0;
4597 return exp
.X_add_number
;
4600 char /* return terminator */
4601 get_absolute_expression_and_terminator (val_pointer
)
4602 long *val_pointer
; /* return value of expression */
4604 /* FIXME: val_pointer should probably be offsetT *. */
4605 *val_pointer
= (long) get_absolute_expression ();
4606 return (*input_line_pointer
++);
4610 * demand_copy_C_string()
4612 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4613 * Give a warning if that happens.
4616 demand_copy_C_string (len_pointer
)
4621 if ((s
= demand_copy_string (len_pointer
)) != 0)
4625 for (len
= *len_pointer
; len
> 0; len
--)
4632 as_bad ("This string may not contain \'\\0\'");
4640 * demand_copy_string()
4642 * Demand string, but return a safe (=private) copy of the string.
4643 * Return NULL if we can't read a string here.
4646 demand_copy_string (lenP
)
4649 register unsigned int c
;
4655 if (*input_line_pointer
== '\"')
4657 input_line_pointer
++; /* Skip opening quote. */
4659 while (is_a_char (c
= next_char_of_string ()))
4661 obstack_1grow (¬es
, c
);
4664 /* JF this next line is so demand_copy_C_string will return a
4665 null terminated string. */
4666 obstack_1grow (¬es
, '\0');
4667 retval
= obstack_finish (¬es
);
4671 as_warn ("Missing string");
4673 ignore_rest_of_line ();
4677 } /* demand_copy_string() */
4680 * is_it_end_of_statement()
4682 * In: Input_line_pointer->next character.
4684 * Do: Skip input_line_pointer over all whitespace.
4686 * Out: 1 if input_line_pointer->end-of-line.
4689 is_it_end_of_statement ()
4692 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4693 } /* is_it_end_of_statement() */
4696 equals (sym_name
, reassign
)
4700 register symbolS
*symbolP
; /* symbol we are working with */
4704 input_line_pointer
++;
4705 if (*input_line_pointer
== '=')
4706 input_line_pointer
++;
4708 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4709 input_line_pointer
++;
4712 stop
= mri_comment_field (&stopc
);
4714 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4716 /* Turn '. = mumble' into a .org mumble */
4717 register segT segment
;
4720 segment
= get_known_segmented_expression (&exp
);
4722 do_org (segment
, &exp
, 0);
4726 symbolP
= symbol_find_or_make (sym_name
);
4727 /* Permit register names to be redefined. */
4729 && S_IS_DEFINED (symbolP
)
4730 && S_GET_SEGMENT (symbolP
) != reg_section
)
4731 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
4732 pseudo_set (symbolP
);
4736 mri_comment_end (stop
, stopc
);
4739 /* .include -- include a file at this point. */
4752 if (! flag_m68k_mri
)
4754 filename
= demand_copy_string (&i
);
4755 if (filename
== NULL
)
4757 /* demand_copy_string has already printed an error and
4758 called ignore_rest_of_line. */
4766 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4767 && *input_line_pointer
!= ' '
4768 && *input_line_pointer
!= '\t')
4770 obstack_1grow (¬es
, *input_line_pointer
);
4771 ++input_line_pointer
;
4774 obstack_1grow (¬es
, '\0');
4775 filename
= obstack_finish (¬es
);
4776 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4777 ++input_line_pointer
;
4779 demand_empty_rest_of_line ();
4780 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4781 for (i
= 0; i
< include_dir_count
; i
++)
4783 strcpy (path
, include_dirs
[i
]);
4785 strcat (path
, filename
);
4786 if (0 != (try = fopen (path
, "r")))
4795 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4796 register_dependency (path
);
4797 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4798 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4802 add_include_dir (path
)
4807 if (include_dir_count
== 0)
4809 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4810 include_dirs
[0] = "."; /* Current dir */
4811 include_dir_count
= 2;
4815 include_dir_count
++;
4816 include_dirs
= (char **) realloc (include_dirs
,
4817 include_dir_count
* sizeof (*include_dirs
));
4820 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4823 if (i
> include_dir_maxlen
)
4824 include_dir_maxlen
= i
;
4825 } /* add_include_dir() */
4831 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4833 ++input_line_pointer
;
4835 ++input_line_pointer
;
4840 read_print_statistics (file
)
4843 hash_print_statistics (file
, "pseudo-op table", po_hash
);