1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 1997
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 list. */
170 char **include_dirs
; /* List of pointers to directories to
171 search for .include's */
172 int include_dir_count
; /* How many are in the list */
173 int include_dir_maxlen
= 1;/* Length of longest in list */
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
;
200 static void cons_worker
PARAMS ((int, int));
201 static int scrub_from_string
PARAMS ((char **));
202 static void do_align
PARAMS ((int, char *, int, int));
203 static void s_align
PARAMS ((int, int));
204 static int hex_float
PARAMS ((int, char *));
205 static void do_org
PARAMS ((segT
, expressionS
*, int));
206 char *demand_copy_string
PARAMS ((int *lenP
));
207 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
208 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
209 static void pobegin
PARAMS ((void));
210 static int get_line_sb
PARAMS ((sb
*));
219 obj_read_begin_hook ();
221 /* Something close -- but not too close -- to a multiple of 1024.
222 The debugging malloc I'm using has 24 bytes of overhead. */
223 obstack_begin (¬es
, chunksize
);
224 obstack_begin (&cond_obstack
, chunksize
);
226 /* Use machine dependent syntax */
227 for (p
= line_separator_chars
; *p
; p
++)
228 is_end_of_line
[(unsigned char) *p
] = 1;
229 /* Use more. FIXME-SOMEDAY. */
235 /* set up pseudo-op tables */
237 static struct hash_control
*po_hash
;
239 static const pseudo_typeS potable
[] =
241 {"abort", s_abort
, 0},
242 {"align", s_align_ptwo
, 0},
243 {"ascii", stringer
, 0},
244 {"asciz", stringer
, 1},
245 {"balign", s_align_bytes
, 0},
246 {"balignw", s_align_bytes
, -2},
247 {"balignl", s_align_bytes
, -4},
251 {"common", s_mri_common
, 0},
252 {"common.s", s_mri_common
, 1},
256 {"dc.d", float_cons
, 'd'},
258 {"dc.s", float_cons
, 'f'},
260 {"dc.x", float_cons
, 'x'},
262 {"dcb.b", s_space
, 1},
263 {"dcb.d", s_float_space
, 'd'},
264 {"dcb.l", s_space
, 4},
265 {"dcb.s", s_float_space
, 'f'},
266 {"dcb.w", s_space
, 2},
267 {"dcb.x", s_float_space
, 'x'},
269 {"ds.b", s_space
, 1},
270 {"ds.d", s_space
, 8},
271 {"ds.l", s_space
, 4},
272 {"ds.p", s_space
, 12},
273 {"ds.s", s_space
, 4},
274 {"ds.w", s_space
, 2},
275 {"ds.x", s_space
, 12},
276 {"debug", s_ignore
, 0},
281 {"double", float_cons
, 'd'},
283 {"eject", listing_eject
, 0}, /* Formfeed listing */
285 {"elsec", s_else
, 0},
287 {"endc", s_endif
, 0},
288 {"endif", s_endif
, 0},
293 {"exitm", s_mexit
, 0},
295 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
296 {"appfile", s_app_file
, 1},
297 {"appline", s_app_line
, 0},
299 {"file", s_app_file
, 0},
301 {"float", float_cons
, 'f'},
302 {"format", s_ignore
, 0},
303 {"global", s_globl
, 0},
304 {"globl", s_globl
, 0},
306 {"if", s_if
, (int) O_ne
},
308 {"ifdef", s_ifdef
, 0},
309 {"ifeq", s_if
, (int) O_eq
},
310 {"ifeqs", s_ifeqs
, 0},
311 {"ifge", s_if
, (int) O_ge
},
312 {"ifgt", s_if
, (int) O_gt
},
313 {"ifle", s_if
, (int) O_le
},
314 {"iflt", s_if
, (int) O_lt
},
316 {"ifndef", s_ifdef
, 1},
317 {"ifne", s_if
, (int) O_ne
},
318 {"ifnes", s_ifeqs
, 1},
319 {"ifnotdef", s_ifdef
, 1},
320 {"include", s_include
, 0},
326 {"lcomm", s_lcomm
, 0},
327 {"lflags", listing_flags
, 0}, /* Listing flags */
328 {"linkonce", s_linkonce
, 0},
329 {"list", listing_list
, 1}, /* Turn listing on */
330 {"llen", listing_psize
, 1},
333 {"macro", s_macro
, 0},
334 {"mexit", s_mexit
, 0},
336 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
337 {"name", s_ignore
, 0},
338 {"noformat", s_ignore
, 0},
339 {"nolist", listing_list
, 0}, /* Turn listing off */
340 {"nopage", listing_nopage
, 0},
342 {"offset", s_struct
, 0},
344 {"p2align", s_align_ptwo
, 0},
345 {"p2alignw", s_align_ptwo
, -2},
346 {"p2alignl", s_align_ptwo
, -4},
347 {"page", listing_eject
, 0},
348 {"plen", listing_psize
, 0},
349 {"print", s_print
, 0},
350 {"psize", listing_psize
, 0}, /* set paper size */
351 {"purgem", s_purgem
, 0},
356 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
361 {"single", float_cons
, 'f'},
363 {"space", s_space
, 0},
364 {"skip", s_space
, 0},
365 {"sleb128", s_leb128
, 1},
366 {"spc", s_ignore
, 0},
367 {"stabd", s_stab
, 'd'},
368 {"stabn", s_stab
, 'n'},
369 {"stabs", s_stab
, 's'},
370 {"string", stringer
, 1},
371 {"struct", s_struct
, 0},
375 /* This is for gcc to use. It's only just been added (2/94), so gcc
376 won't be able to use it for a while -- probably a year or more.
377 But once this has been released, check with gcc maintainers
378 before deleting it or even changing the spelling. */
379 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
380 /* If we're folding case -- done for some targets, not necessarily
381 all -- the above string in an input file will be converted to
382 this one. Match it either way... */
383 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
385 {"title", listing_title
, 0}, /* Listing title */
386 {"ttl", listing_title
, 0},
388 {"uleb128", s_leb128
, 0},
392 {"xdef", s_globl
, 0},
393 {"xref", s_ignore
, 0},
394 {"xstabs", s_xstab
, 's'},
396 {"zero", s_space
, 0},
397 {NULL
} /* end sentinel */
400 static int pop_override_ok
= 0;
401 static const char *pop_table_name
;
405 const pseudo_typeS
*table
;
408 const pseudo_typeS
*pop
;
409 for (pop
= table
; pop
->poc_name
; pop
++)
411 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
412 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
413 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
418 #ifndef md_pop_insert
419 #define md_pop_insert() pop_insert(md_pseudo_table)
422 #ifndef obj_pop_insert
423 #define obj_pop_insert() pop_insert(obj_pseudo_table)
429 po_hash
= hash_new ();
431 /* Do the target-specific pseudo ops. */
432 pop_table_name
= "md";
435 /* Now object specific. Skip any that were in the target table. */
436 pop_table_name
= "obj";
440 /* Now portable ones. Skip any that we've seen already. */
441 pop_table_name
= "standard";
442 pop_insert (potable
);
445 #define HANDLE_CONDITIONAL_ASSEMBLY() \
446 if (ignore_input ()) \
448 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
449 if (input_line_pointer == buffer_limit) \
455 /* This function is used when scrubbing the characters between #APP
458 static char *scrub_string
;
459 static char *scrub_string_end
;
462 scrub_from_string (from
)
467 *from
= scrub_string
;
468 size
= scrub_string_end
- scrub_string
;
469 scrub_string
= scrub_string_end
;
473 /* read_a_source_file()
475 * We read the file, putting things into a web that
476 * represents what we have been reading.
479 read_a_source_file (name
)
483 register char *s
; /* string of symbol, '\0' appended */
487 buffer
= input_scrub_new_file (name
);
490 listing_newline (NULL
);
491 register_dependency (name
);
493 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
494 { /* We have another line to parse. */
495 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
496 contin
: /* JF this goto is my fault I admit it.
497 Someone brave please re-write the whole
498 input section here? Pleeze??? */
499 while (input_line_pointer
< buffer_limit
)
501 /* We have more of this buffer to parse. */
504 * We now have input_line_pointer->1st char of next line.
505 * If input_line_pointer [-1] == '\n' then we just
506 * scanned another line: so bump line counters.
508 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
510 #ifdef md_start_line_hook
511 md_start_line_hook ();
514 if (input_line_pointer
[-1] == '\n')
515 bump_line_counters ();
520 #ifdef LABELS_WITHOUT_COLONS
525 /* Text at the start of a line must be a label, we
526 run down and stick a colon in. */
527 if (is_name_beginner (*input_line_pointer
))
529 char *line_start
= input_line_pointer
;
534 HANDLE_CONDITIONAL_ASSEMBLY ();
536 c
= get_symbol_end ();
538 /* In MRI mode, the EQU and MACRO pseudoops must
539 be handled specially. */
543 char *rest
= input_line_pointer
+ 1;
547 if (*rest
== ' ' || *rest
== '\t')
549 if ((strncasecmp (rest
, "EQU", 3) == 0
550 || strncasecmp (rest
, "SET", 3) == 0)
551 && (rest
[3] == ' ' || rest
[3] == '\t'))
553 input_line_pointer
= rest
+ 3;
555 strncasecmp (rest
, "SET", 3) == 0);
558 if (strncasecmp (rest
, "MACRO", 5) == 0
561 || is_end_of_line
[(unsigned char) rest
[5]]))
565 /* In MRI mode, we need to handle the MACRO
566 pseudo-op specially: we don't want to put the
567 symbol in the symbol table. */
568 if (! mri_line_macro
)
569 line_label
= colon (line_start
);
571 line_label
= symbol_create (line_start
,
576 *input_line_pointer
= c
;
578 input_line_pointer
++;
584 * We are at the begining of a line, or similar place.
585 * We expect a well-formed assembler statement.
586 * A "symbol-name:" is a statement.
588 * Depending on what compiler is used, the order of these tests
589 * may vary to catch most common case 1st.
590 * Each test is independent of all other tests at the (top) level.
591 * PLEASE make a compiler that doesn't use this assembler.
592 * It is crufty to waste a compiler's time encoding things for this
593 * assembler, which then wastes more time decoding it.
594 * (And communicating via (linear) files is silly!
595 * If you must pass stuff, please pass a tree!)
597 if ((c
= *input_line_pointer
++) == '\t'
602 c
= *input_line_pointer
++;
604 know (c
!= ' '); /* No further leading whitespace. */
607 /* If listing is on, and we are expanding a macro, then give
608 the listing code the contents of the expanded line. */
611 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
616 /* Find the end of the current expanded macro line. */
617 for (s
= input_line_pointer
-1; *s
; ++s
)
618 if (is_end_of_line
[(unsigned char) *s
])
621 /* Copy it for safe keeping. Also give an indication of
622 how much macro nesting is involved at this point. */
623 len
= s
- (input_line_pointer
-1);
624 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
625 memset (copy
, '>', macro_nest
);
626 copy
[macro_nest
] = ' ';
627 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
-1, len
);
628 copy
[macro_nest
+1+len
] = '\0';
630 /* Install the line with the listing facility. */
631 listing_newline (copy
);
634 listing_newline (NULL
);
639 * C is the 1st significant character.
640 * Input_line_pointer points after that character.
642 if (is_name_beginner (c
))
644 /* want user-defined label or pseudo/opcode */
645 HANDLE_CONDITIONAL_ASSEMBLY ();
647 s
= --input_line_pointer
;
648 c
= get_symbol_end (); /* name's delimiter */
650 * C is character after symbol.
651 * That character's place in the input line is now '\0'.
652 * S points to the beginning of the symbol.
653 * [In case of pseudo-op, s->'.'.]
654 * Input_line_pointer->'\0' where c was.
656 if (TC_START_LABEL(c
, input_line_pointer
))
660 char *rest
= input_line_pointer
+ 1;
662 /* In MRI mode, \tsym: set 0 is permitted. */
666 if (*rest
== ' ' || *rest
== '\t')
668 if ((strncasecmp (rest
, "EQU", 3) == 0
669 || strncasecmp (rest
, "SET", 3) == 0)
670 && (rest
[3] == ' ' || rest
[3] == '\t'))
672 input_line_pointer
= rest
+ 3;
678 line_label
= colon (s
); /* user-defined label */
679 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
680 /* Input_line_pointer->after ':'. */
686 || ((c
== ' ' || c
== '\t')
687 && input_line_pointer
[1] == '='
688 #ifdef TC_EQUAL_IN_INSN
689 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
694 demand_empty_rest_of_line ();
697 { /* expect pseudo-op or machine instruction */
700 #define IGNORE_OPCODE_CASE
701 #ifdef IGNORE_OPCODE_CASE
719 /* The MRI assembler and the m88k use pseudo-ops
721 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
722 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
727 || (! flag_m68k_mri
&& *s
== '.'))
732 * WARNING: c has next char, which may be end-of-line.
733 * We lookup the pseudo-op table with s+1 because we
734 * already know that the pseudo-op begins with a '.'.
738 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
740 /* In MRI mode, we may need to insert an
741 automatic alignment directive. What a hack
743 if (mri_pending_align
745 || ! ((pop
->poc_handler
== cons
746 && pop
->poc_val
== 1)
747 || (pop
->poc_handler
== s_space
748 && pop
->poc_val
== 1)
749 #ifdef tc_conditional_pseudoop
750 || tc_conditional_pseudoop (pop
)
752 || pop
->poc_handler
== s_if
753 || pop
->poc_handler
== s_ifdef
754 || pop
->poc_handler
== s_ifc
755 || pop
->poc_handler
== s_ifeqs
756 || pop
->poc_handler
== s_else
757 || pop
->poc_handler
== s_endif
758 || pop
->poc_handler
== s_globl
759 || pop
->poc_handler
== s_ignore
)))
761 do_align (1, (char *) NULL
, 0, 0);
762 mri_pending_align
= 0;
763 if (line_label
!= NULL
)
765 line_label
->sy_frag
= frag_now
;
766 S_SET_VALUE (line_label
, frag_now_fix ());
770 /* Print the error msg now, while we still can */
773 as_bad ("Unknown pseudo-op: `%s'", s
);
774 *input_line_pointer
= c
;
779 /* Put it back for error messages etc. */
780 *input_line_pointer
= c
;
781 /* The following skip of whitespace is compulsory.
782 A well shaped space is sometimes all that separates
783 keyword from operands. */
784 if (c
== ' ' || c
== '\t')
785 input_line_pointer
++;
787 * Input_line is restored.
788 * Input_line_pointer->1st non-blank char
789 * after pseudo-operation.
791 (*pop
->poc_handler
) (pop
->poc_val
);
793 /* If that was .end, just get out now. */
794 if (pop
->poc_handler
== s_end
)
801 /* WARNING: c has char, which may be end-of-line. */
802 /* Also: input_line_pointer->`\0` where c was. */
803 *input_line_pointer
= c
;
804 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
806 #ifdef TC_EOL_IN_INSN
807 || TC_EOL_IN_INSN (input_line_pointer
)
811 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
813 input_line_pointer
++;
816 c
= *input_line_pointer
;
817 *input_line_pointer
= '\0';
819 if (debug_type
== DEBUG_STABS
)
820 stabs_generate_asm_lineno ();
822 #ifdef OBJ_GENERATE_ASM_LINENO
823 #ifdef ECOFF_DEBUGGING
824 /* ECOFF assemblers automatically generate
825 debugging information. FIXME: This should
826 probably be handled elsewhere. */
827 if (debug_type
== DEBUG_NONE
)
829 if (ecoff_no_current_file ())
830 debug_type
= DEBUG_ECOFF
;
833 if (debug_type
== DEBUG_ECOFF
)
838 as_where (&s
, &lineno
);
839 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
849 if (check_macro (s
, &out
, '\0', &err
))
853 *input_line_pointer
++ = c
;
854 input_scrub_include_sb (&out
,
858 input_scrub_next_buffer (&input_line_pointer
);
863 if (mri_pending_align
)
865 do_align (1, (char *) NULL
, 0, 0);
866 mri_pending_align
= 0;
867 if (line_label
!= NULL
)
869 line_label
->sy_frag
= frag_now
;
870 S_SET_VALUE (line_label
, frag_now_fix ());
874 md_assemble (s
); /* Assemble 1 instruction. */
876 *input_line_pointer
++ = c
;
878 /* We resume loop AFTER the end-of-line from
883 } /* if (is_name_beginner(c) */
886 /* Empty statement? */
887 if (is_end_of_line
[(unsigned char) c
])
890 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
893 /* local label ("4:") */
894 char *backup
= input_line_pointer
;
896 HANDLE_CONDITIONAL_ASSEMBLY ();
900 while (isdigit (*input_line_pointer
))
902 temp
= (temp
* 10) + *input_line_pointer
- '0';
903 ++input_line_pointer
;
904 } /* read the whole number */
906 if (LOCAL_LABELS_DOLLAR
907 && *input_line_pointer
== '$'
908 && *(input_line_pointer
+ 1) == ':')
910 input_line_pointer
+= 2;
912 if (dollar_label_defined (temp
))
914 as_fatal ("label \"%d$\" redefined", temp
);
917 define_dollar_label (temp
);
918 colon (dollar_label_name (temp
, 0));
923 && *input_line_pointer
++ == ':')
925 fb_label_instance_inc (temp
);
926 colon (fb_label_name (temp
, 0));
930 input_line_pointer
= backup
;
931 } /* local label ("4:") */
933 if (c
&& strchr (line_comment_chars
, c
))
934 { /* Its a comment. Better say APP or NO_APP */
938 unsigned int new_length
;
941 bump_line_counters ();
942 s
= input_line_pointer
;
943 if (strncmp (s
, "APP\n", 4))
944 continue; /* We ignore it */
947 ends
= strstr (s
, "#NO_APP\n");
951 unsigned int tmp_len
;
954 /* The end of the #APP wasn't in this buffer. We
955 keep reading in buffers until we find the #NO_APP
956 that goes with this #APP There is one. The specs
958 tmp_len
= buffer_limit
- s
;
959 tmp_buf
= xmalloc (tmp_len
+ 1);
960 memcpy (tmp_buf
, s
, tmp_len
);
963 new_tmp
= input_scrub_next_buffer (&buffer
);
967 buffer_limit
= new_tmp
;
968 input_line_pointer
= buffer
;
969 ends
= strstr (buffer
, "#NO_APP\n");
973 num
= buffer_limit
- buffer
;
975 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
976 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
981 input_line_pointer
= ends
? ends
+ 8 : NULL
;
989 input_line_pointer
= ends
+ 8;
993 scrub_string_end
= ends
;
995 new_length
= ends
- s
;
996 new_buf
= (char *) xmalloc (new_length
);
1003 space
= (new_buf
+ new_length
) - new_tmp
;
1004 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1012 new_buf
= xrealloc (new_buf
, new_length
+ 100);
1013 new_tmp
= new_buf
+ new_length
;
1019 old_buffer
= buffer
;
1020 old_input
= input_line_pointer
;
1021 old_limit
= buffer_limit
;
1023 input_line_pointer
= new_buf
;
1024 buffer_limit
= new_tmp
;
1028 HANDLE_CONDITIONAL_ASSEMBLY ();
1030 #ifdef tc_unrecognized_line
1031 if (tc_unrecognized_line (c
))
1035 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
1036 input_line_pointer
--; /* Report unknown char as ignored. */
1037 ignore_rest_of_line ();
1038 } /* while (input_line_pointer<buffer_limit) */
1040 #ifdef md_after_pass_hook
1041 md_after_pass_hook ();
1047 bump_line_counters ();
1050 buffer
= old_buffer
;
1051 input_line_pointer
= old_input
;
1052 buffer_limit
= old_limit
;
1057 } /* while (more buffers to scan) */
1064 input_scrub_close (); /* Close the input file */
1067 /* For most MRI pseudo-ops, the line actually ends at the first
1068 nonquoted space. This function looks for that point, stuffs a null
1069 in, and sets *STOPCP to the character that used to be there, and
1070 returns the location.
1072 Until I hear otherwise, I am going to assume that this is only true
1073 for the m68k MRI assembler. */
1076 mri_comment_field (stopcp
)
1084 know (flag_m68k_mri
);
1086 for (s
= input_line_pointer
;
1087 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1092 inquote
= ! inquote
;
1102 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1112 /* Skip to the end of an MRI comment field. */
1115 mri_comment_end (stop
, stopc
)
1121 input_line_pointer
= stop
;
1123 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1124 ++input_line_pointer
;
1131 as_fatal (".abort detected. Abandoning ship.");
1134 /* Guts of .align directive. N is the power of two to which to align.
1135 FILL may be NULL, or it may point to the bytes of the fill pattern.
1136 LEN is the length of whatever FILL points to, if anything. MAX is
1137 the maximum number of characters to skip when doing the alignment,
1138 or 0 if there is no maximum. */
1141 do_align (n
, fill
, len
, max
)
1150 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1157 #ifdef BFD_ASSEMBLER
1158 if ((bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
1163 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1170 default_fill
= NOP_OPCODE
;
1173 fill
= &default_fill
;
1177 /* Only make a frag if we HAVE to. . . */
1178 if (n
!= 0 && !need_pass_2
)
1181 frag_align (n
, *fill
, max
);
1183 frag_align_pattern (n
, fill
, len
, max
);
1187 just_record_alignment
:
1190 record_alignment (now_seg
, n
);
1193 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1194 (in bytes). A negative ARG is the negative of the length of the
1195 fill pattern. BYTES_P is non-zero if the alignment value should be
1196 interpreted as the byte boundary, rather than the power of 2. */
1199 s_align (arg
, bytes_p
)
1203 register unsigned int align
;
1211 stop
= mri_comment_field (&stopc
);
1213 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1218 align
= arg
; /* Default value from pseudo-op table */
1222 align
= get_absolute_expression ();
1228 /* Convert to a power of 2. */
1233 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1236 as_bad ("Alignment not a power of 2");
1244 as_bad ("Alignment too large: %u assumed", align
);
1247 if (*input_line_pointer
!= ',')
1254 ++input_line_pointer
;
1255 if (*input_line_pointer
== ',')
1259 fill
= get_absolute_expression ();
1264 if (*input_line_pointer
!= ',')
1268 ++input_line_pointer
;
1269 max
= get_absolute_expression ();
1276 as_warn ("expected fill pattern missing");
1277 do_align (align
, (char *) NULL
, 0, max
);
1292 do_align (align
, &fill_char
, fill_len
, max
);
1298 if (fill_len
> sizeof ab
)
1300 md_number_to_chars (ab
, fill
, fill_len
);
1301 do_align (align
, ab
, fill_len
, max
);
1306 mri_comment_end (stop
, stopc
);
1308 demand_empty_rest_of_line ();
1311 /* Handle the .align pseudo-op on machines where ".align 4" means
1312 align to a 4 byte boundary. */
1321 /* Handle the .align pseudo-op on machines where ".align 4" means align
1322 to a 2**4 boundary. */
1335 register char *name
;
1339 register symbolS
*symbolP
;
1344 stop
= mri_comment_field (&stopc
);
1346 name
= input_line_pointer
;
1347 c
= get_symbol_end ();
1348 /* just after name is now '\0' */
1349 p
= input_line_pointer
;
1352 if (*input_line_pointer
!= ',')
1354 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1356 mri_comment_end (stop
, stopc
);
1357 ignore_rest_of_line ();
1360 input_line_pointer
++; /* skip ',' */
1361 if ((temp
= get_absolute_expression ()) < 0)
1363 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1365 mri_comment_end (stop
, stopc
);
1366 ignore_rest_of_line ();
1370 symbolP
= symbol_find_or_make (name
);
1372 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1374 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1375 S_GET_NAME (symbolP
));
1377 mri_comment_end (stop
, stopc
);
1378 ignore_rest_of_line ();
1381 if (S_GET_VALUE (symbolP
))
1383 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1384 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1385 S_GET_NAME (symbolP
),
1386 (long) S_GET_VALUE (symbolP
),
1391 S_SET_VALUE (symbolP
, (valueT
) temp
);
1392 S_SET_EXTERNAL (symbolP
);
1396 extern int flag_one
;
1397 if ( (!temp
) || !flag_one
)
1398 S_GET_OTHER(symbolP
) = const_flag
;
1400 #endif /* not OBJ_VMS */
1401 know (symbolP
->sy_frag
== &zero_address_frag
);
1404 mri_comment_end (stop
, stopc
);
1406 demand_empty_rest_of_line ();
1409 /* The MRI COMMON pseudo-op. We handle this by creating a common
1410 symbol with the appropriate name. We make s_space do the right
1411 thing by increasing the size. */
1414 s_mri_common (small
)
1431 stop
= mri_comment_field (&stopc
);
1435 name
= input_line_pointer
;
1436 if (! isdigit ((unsigned char) *name
))
1437 c
= get_symbol_end ();
1442 ++input_line_pointer
;
1444 while (isdigit ((unsigned char) *input_line_pointer
));
1445 c
= *input_line_pointer
;
1446 *input_line_pointer
= '\0';
1448 if (line_label
!= NULL
)
1450 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1451 + (input_line_pointer
- name
)
1453 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1458 sym
= symbol_find_or_make (name
);
1459 *input_line_pointer
= c
;
1463 if (*input_line_pointer
!= ',')
1467 ++input_line_pointer
;
1468 align
= get_absolute_expression ();
1471 if (S_IS_DEFINED (sym
) && ! S_IS_COMMON (sym
))
1473 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1474 mri_comment_end (stop
, stopc
);
1475 ignore_rest_of_line ();
1479 S_SET_EXTERNAL (sym
);
1480 mri_common_symbol
= sym
;
1484 S_SET_ALIGN (sym
, align
);
1487 if (line_label
!= NULL
)
1489 line_label
->sy_value
.X_op
= O_symbol
;
1490 line_label
->sy_value
.X_add_symbol
= sym
;
1491 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1492 line_label
->sy_frag
= &zero_address_frag
;
1493 S_SET_SEGMENT (line_label
, expr_section
);
1496 /* FIXME: We just ignore the small argument, which distinguishes
1497 COMMON and COMMON.S. I don't know what we can do about it. */
1499 /* Ignore the type and hptype. */
1500 if (*input_line_pointer
== ',')
1501 input_line_pointer
+= 2;
1502 if (*input_line_pointer
== ',')
1503 input_line_pointer
+= 2;
1505 mri_comment_end (stop
, stopc
);
1507 demand_empty_rest_of_line ();
1517 temp
= get_absolute_expression ();
1518 if (flag_readonly_data_in_text
)
1520 section
= text_section
;
1524 section
= data_section
;
1526 subseg_set (section
, (subsegT
) temp
);
1531 demand_empty_rest_of_line ();
1534 /* Handle the .appfile pseudo-op. This is automatically generated by
1535 do_scrub_chars when a preprocessor # line comment is seen with a
1536 file name. This default definition may be overridden by the object
1537 or CPU specific pseudo-ops. This function is also the default
1538 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1542 s_app_file (appfile
)
1548 /* Some assemblers tolerate immediately following '"' */
1549 if ((s
= demand_copy_string (&length
)) != 0)
1551 /* If this is a fake .appfile, a fake newline was inserted into
1552 the buffer. Passing -2 to new_logical_line tells it to
1554 new_logical_line (s
, appfile
? -2 : -1);
1556 /* In MRI mode, the preprocessor may have inserted an extraneous
1559 && *input_line_pointer
== '\''
1560 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1561 ++input_line_pointer
;
1563 demand_empty_rest_of_line ();
1566 listing_source_file (s
);
1568 register_dependency (s
);
1575 /* Handle the .appline pseudo-op. This is automatically generated by
1576 do_scrub_chars when a preprocessor # line comment is seen. This
1577 default definition may be overridden by the object or CPU specific
1586 /* The given number is that of the next line. */
1587 l
= get_absolute_expression () - 1;
1589 /* Some of the back ends can't deal with non-positive line numbers.
1590 Besides, it's silly. */
1591 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1594 new_logical_line ((char *) NULL
, l
);
1597 listing_source_line (l
);
1600 demand_empty_rest_of_line ();
1603 /* Handle the .end pseudo-op. Actually, the real work is done in
1604 read_a_source_file. */
1612 /* The MRI assembler permits the start symbol to follow .end,
1613 but we don't support that. */
1615 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1616 && *input_line_pointer
!= '*'
1617 && *input_line_pointer
!= '!')
1618 as_warn ("start address not supported");
1622 /* Handle the .err pseudo-op. */
1628 as_bad (".err encountered");
1629 demand_empty_rest_of_line ();
1632 /* Handle the MRI fail pseudo-op. */
1643 stop
= mri_comment_field (&stopc
);
1645 temp
= get_absolute_expression ();
1647 as_warn (".fail %ld encountered", (long) temp
);
1649 as_bad (".fail %ld encountered", (long) temp
);
1652 mri_comment_end (stop
, stopc
);
1654 demand_empty_rest_of_line ();
1661 long temp_repeat
= 0;
1663 register long temp_fill
= 0;
1666 #ifdef md_flush_pending_output
1667 md_flush_pending_output ();
1670 temp_repeat
= get_absolute_expression ();
1671 if (*input_line_pointer
== ',')
1673 input_line_pointer
++;
1674 temp_size
= get_absolute_expression ();
1675 if (*input_line_pointer
== ',')
1677 input_line_pointer
++;
1678 temp_fill
= get_absolute_expression ();
1681 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1682 #define BSD_FILL_SIZE_CROCK_8 (8)
1683 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1685 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1686 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1690 as_warn ("Size negative: .fill ignored.");
1693 else if (temp_repeat
<= 0)
1695 if (temp_repeat
< 0)
1696 as_warn ("Repeat < 0, .fill ignored");
1700 if (temp_size
&& !need_pass_2
)
1702 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
,
1703 (relax_substateT
) 0, (symbolS
*) 0, (offsetT
) temp_repeat
,
1705 memset (p
, 0, (unsigned int) temp_size
);
1706 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1707 * flavoured AS. The following bizzare behaviour is to be
1708 * compatible with above. I guess they tried to take up to 8
1709 * bytes from a 4-byte expression and they forgot to sign
1710 * extend. Un*x Sux. */
1711 #define BSD_FILL_SIZE_CROCK_4 (4)
1712 md_number_to_chars (p
, (valueT
) temp_fill
,
1713 (temp_size
> BSD_FILL_SIZE_CROCK_4
1714 ? BSD_FILL_SIZE_CROCK_4
1715 : (int) temp_size
));
1716 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1717 * but emits no error message because it seems a legal thing to do.
1718 * It is a degenerate case of .fill but could be emitted by a compiler.
1721 demand_empty_rest_of_line ();
1735 stop
= mri_comment_field (&stopc
);
1739 name
= input_line_pointer
;
1740 c
= get_symbol_end ();
1741 symbolP
= symbol_find_or_make (name
);
1742 *input_line_pointer
= c
;
1744 S_SET_EXTERNAL (symbolP
);
1747 input_line_pointer
++;
1749 if (*input_line_pointer
== '\n')
1756 mri_comment_end (stop
, stopc
);
1758 demand_empty_rest_of_line ();
1761 /* Handle the MRI IRP and IRPC pseudo-ops. */
1773 as_where (&file
, &line
);
1776 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1777 sb_add_char (&s
, *input_line_pointer
++);
1781 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1783 as_bad_where (file
, line
, "%s", err
);
1787 input_scrub_include_sb (&out
, input_line_pointer
);
1789 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1792 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1793 the section to only be linked once. However, this is not supported
1794 by most object file formats. This takes an optional argument,
1795 which is what to do about duplicates. */
1801 enum linkonce_type type
;
1805 type
= LINKONCE_DISCARD
;
1807 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1812 s
= input_line_pointer
;
1813 c
= get_symbol_end ();
1814 if (strcasecmp (s
, "discard") == 0)
1815 type
= LINKONCE_DISCARD
;
1816 else if (strcasecmp (s
, "one_only") == 0)
1817 type
= LINKONCE_ONE_ONLY
;
1818 else if (strcasecmp (s
, "same_size") == 0)
1819 type
= LINKONCE_SAME_SIZE
;
1820 else if (strcasecmp (s
, "same_contents") == 0)
1821 type
= LINKONCE_SAME_CONTENTS
;
1823 as_warn ("unrecognized .linkonce type `%s'", s
);
1825 *input_line_pointer
= c
;
1828 #ifdef obj_handle_link_once
1829 obj_handle_link_once (type
);
1830 #else /* ! defined (obj_handle_link_once) */
1831 #ifdef BFD_ASSEMBLER
1835 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1836 as_warn (".linkonce is not supported for this object file format");
1838 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1839 flags
|= SEC_LINK_ONCE
;
1844 case LINKONCE_DISCARD
:
1845 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1847 case LINKONCE_ONE_ONLY
:
1848 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1850 case LINKONCE_SAME_SIZE
:
1851 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1853 case LINKONCE_SAME_CONTENTS
:
1854 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1857 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1858 as_bad ("bfd_set_section_flags: %s",
1859 bfd_errmsg (bfd_get_error ()));
1861 #else /* ! defined (BFD_ASSEMBLER) */
1862 as_warn (".linkonce is not supported for this object file format");
1863 #endif /* ! defined (BFD_ASSEMBLER) */
1864 #endif /* ! defined (obj_handle_link_once) */
1866 demand_empty_rest_of_line ();
1870 s_lcomm_internal (needs_align
, bytes_p
)
1871 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1872 (alignment); 0 if it was an ".lcomm" (2 args only) */
1874 /* 1 if the alignment value should be interpreted as the byte boundary,
1875 rather than the power of 2. */
1878 register char *name
;
1882 register symbolS
*symbolP
;
1883 segT current_seg
= now_seg
;
1884 subsegT current_subseg
= now_subseg
;
1885 const int max_alignment
= 15;
1887 segT bss_seg
= bss_section
;
1889 name
= input_line_pointer
;
1890 c
= get_symbol_end ();
1891 p
= input_line_pointer
;
1895 /* Accept an optional comma after the name. The comma used to be
1896 required, but Irix 5 cc does not generate it. */
1897 if (*input_line_pointer
== ',')
1899 ++input_line_pointer
;
1903 if (*input_line_pointer
== '\n')
1905 as_bad ("Missing size expression");
1909 if ((temp
= get_absolute_expression ()) < 0)
1911 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1912 ignore_rest_of_line ();
1916 #if defined (TC_MIPS) || defined (TC_ALPHA)
1917 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1918 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1920 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1921 if (temp
<= bfd_get_gp_size (stdoutput
))
1923 bss_seg
= subseg_new (".sbss", 1);
1924 seg_info (bss_seg
)->bss
= 1;
1925 #ifdef BFD_ASSEMBLER
1926 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1927 as_warn ("error setting flags for \".sbss\": %s",
1928 bfd_errmsg (bfd_get_error ()));
1935 /* FIXME. This needs to be machine independent. */
1946 /* FIXME: This needs to be done in a more general fashion. */
1950 record_alignment(bss_seg
, align
);
1957 if (*input_line_pointer
!= ',')
1959 as_bad ("Expected comma after size");
1960 ignore_rest_of_line ();
1963 input_line_pointer
++;
1965 if (*input_line_pointer
== '\n')
1967 as_bad ("Missing alignment");
1970 align
= get_absolute_expression ();
1973 /* Convert to a power of 2. */
1978 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1981 as_bad ("Alignment not a power of 2");
1985 if (align
> max_alignment
)
1987 align
= max_alignment
;
1988 as_warn ("Alignment too large: %d. assumed.", align
);
1993 as_warn ("Alignment negative. 0 assumed.");
1995 record_alignment (bss_seg
, align
);
1996 } /* if needs align */
1999 /* Assume some objects may require alignment on some systems. */
2000 #if defined (TC_ALPHA) && ! defined (VMS)
2003 align
= ffs (temp
) - 1;
2004 if (temp
% (1 << align
))
2011 symbolP
= symbol_find_or_make (name
);
2015 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
2016 S_GET_OTHER (symbolP
) == 0 &&
2017 S_GET_DESC (symbolP
) == 0 &&
2018 #endif /* OBJ_AOUT or OBJ_BOUT */
2019 (S_GET_SEGMENT (symbolP
) == bss_seg
2020 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
2024 subseg_set (bss_seg
, 1);
2027 frag_align (align
, 0, 0);
2028 /* detach from old frag */
2029 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2030 symbolP
->sy_frag
->fr_symbol
= NULL
;
2032 symbolP
->sy_frag
= frag_now
;
2033 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2034 (offsetT
) temp
, (char *) 0);
2037 S_SET_SEGMENT (symbolP
, bss_seg
);
2040 /* The symbol may already have been created with a preceding
2041 ".globl" directive -- be careful not to step on storage class
2042 in that case. Otherwise, set it to static. */
2043 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2045 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2047 #endif /* OBJ_COFF */
2050 S_SET_SIZE (symbolP
, temp
);
2054 as_bad ("Ignoring attempt to re-define symbol `%s'.",
2055 S_GET_NAME (symbolP
));
2057 subseg_set (current_seg
, current_subseg
);
2059 demand_empty_rest_of_line ();
2060 } /* s_lcomm_internal() */
2063 s_lcomm (needs_align
)
2066 s_lcomm_internal (needs_align
, 0);
2069 void s_lcomm_bytes (needs_align
)
2072 s_lcomm_internal (needs_align
, 1);
2079 register char *name
;
2083 register symbolS
*symbolP
;
2085 /* we permit ANY defined expression: BSD4.2 demands constants */
2086 name
= input_line_pointer
;
2087 c
= get_symbol_end ();
2088 p
= input_line_pointer
;
2091 if (*input_line_pointer
!= ',')
2094 as_bad ("Expected comma after name \"%s\"", name
);
2096 ignore_rest_of_line ();
2099 input_line_pointer
++;
2101 if (exp
.X_op
!= O_constant
2102 && exp
.X_op
!= O_register
)
2104 as_bad ("bad expression");
2105 ignore_rest_of_line ();
2109 symbolP
= symbol_find_or_make (name
);
2111 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2112 symbolP->sy_desc == 0) out of this test because coff doesn't have
2113 those fields, and I can't see when they'd ever be tripped. I
2114 don't think I understand why they were here so I may have
2115 introduced a bug. As recently as 1.37 didn't have this test
2116 anyway. xoxorich. */
2118 if (S_GET_SEGMENT (symbolP
) == undefined_section
2119 && S_GET_VALUE (symbolP
) == 0)
2121 /* The name might be an undefined .global symbol; be sure to
2122 keep the "external" bit. */
2123 S_SET_SEGMENT (symbolP
,
2124 (exp
.X_op
== O_constant
2127 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2131 as_bad ("Symbol %s already defined", name
);
2134 demand_empty_rest_of_line ();
2137 /* Read a line into an sb. */
2143 char quote1
, quote2
, inquote
;
2145 if (input_line_pointer
[-1] == '\n')
2146 bump_line_counters ();
2148 if (input_line_pointer
>= buffer_limit
)
2150 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2151 if (buffer_limit
== 0)
2155 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2156 code needs to be changed. */
2157 if (! flag_m68k_mri
)
2165 #ifdef LEX_IS_STRINGQUOTE
2170 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
2171 || (inquote
!= '\0' && *input_line_pointer
!= '\n'))
2173 if (inquote
== *input_line_pointer
)
2175 else if (inquote
== '\0')
2177 if (*input_line_pointer
== quote1
)
2179 else if (*input_line_pointer
== quote2
)
2182 sb_add_char (line
, *input_line_pointer
++);
2184 while (input_line_pointer
< buffer_limit
&& *input_line_pointer
== '\n')
2186 if (input_line_pointer
[-1] == '\n')
2187 bump_line_counters ();
2188 ++input_line_pointer
;
2193 /* Define a macro. This is an interface to macro.c, which is shared
2194 between gas and gasp. */
2207 as_where (&file
, &line
);
2210 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2211 sb_add_char (&s
, *input_line_pointer
++);
2214 if (line_label
!= NULL
)
2215 sb_add_string (&label
, S_GET_NAME (line_label
));
2217 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2219 as_bad_where (file
, line
, "%s", err
);
2222 if (line_label
!= NULL
)
2224 S_SET_SEGMENT (line_label
, undefined_section
);
2225 S_SET_VALUE (line_label
, 0);
2226 line_label
->sy_frag
= &zero_address_frag
;
2230 #ifdef NO_PSEUDO_DOT
2234 && hash_find (po_hash
, name
) != NULL
)
2237 && hash_find (po_hash
, name
+ 1) != NULL
))
2238 as_warn ("attempt to redefine pseudo-op `%s' ignored",
2245 /* Handle the .mexit pseudo-op, which immediately exits a macro
2252 cond_exit_macro (macro_nest
);
2253 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2256 /* Switch in and out of MRI mode. */
2264 on
= get_absolute_expression ();
2265 old_flag
= flag_mri
;
2279 #ifdef MRI_MODE_CHANGE
2281 MRI_MODE_CHANGE (on
);
2284 demand_empty_rest_of_line ();
2287 /* Handle changing the location counter. */
2290 do_org (segment
, exp
, fill
)
2295 if (segment
!= now_seg
&& segment
!= absolute_section
)
2296 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2297 segment_name (segment
), segment_name (now_seg
));
2299 if (now_seg
== absolute_section
)
2302 as_warn ("ignoring fill value in absolute section");
2303 if (exp
->X_op
!= O_constant
)
2305 as_bad ("only constant offsets supported in absolute section");
2306 exp
->X_add_number
= 0;
2308 abs_section_offset
= exp
->X_add_number
;
2314 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2315 exp
->X_add_number
, (char *) NULL
);
2324 register segT segment
;
2326 register long temp_fill
;
2328 /* The m68k MRI assembler has a different meaning for .org. It
2329 means to create an absolute section at a given address. We can't
2330 support that--use a linker script instead. */
2333 as_bad ("MRI style ORG pseudo-op not supported");
2334 ignore_rest_of_line ();
2338 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2339 thing as a sub-segment-relative origin. Any absolute origin is
2340 given a warning, then assumed to be segment-relative. Any
2341 segmented origin expression ("foo+42") had better be in the right
2342 segment or the .org is ignored.
2344 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2345 we never know sub-segment sizes when we are reading code. BSD
2346 will crash trying to emit negative numbers of filler bytes in
2347 certain .orgs. We don't crash, but see as-write for that code.
2349 Don't make frag if need_pass_2==1. */
2350 segment
= get_known_segmented_expression (&exp
);
2351 if (*input_line_pointer
== ',')
2353 input_line_pointer
++;
2354 temp_fill
= get_absolute_expression ();
2360 do_org (segment
, &exp
, temp_fill
);
2362 demand_empty_rest_of_line ();
2365 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2366 called by the obj-format routine which handles section changing
2367 when in MRI mode. It will create a new section, and return it. It
2368 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2369 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2370 flags will be set in the section. */
2384 name
= input_line_pointer
;
2385 if (! isdigit ((unsigned char) *name
))
2386 c
= get_symbol_end ();
2391 ++input_line_pointer
;
2393 while (isdigit ((unsigned char) *input_line_pointer
));
2394 c
= *input_line_pointer
;
2395 *input_line_pointer
= '\0';
2398 name
= xstrdup (name
);
2400 *input_line_pointer
= c
;
2402 seg
= subseg_new (name
, 0);
2404 if (*input_line_pointer
== ',')
2408 ++input_line_pointer
;
2409 align
= get_absolute_expression ();
2410 record_alignment (seg
, align
);
2414 if (*input_line_pointer
== ',')
2416 c
= *++input_line_pointer
;
2417 c
= toupper ((unsigned char) c
);
2418 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2421 as_bad ("unrecognized section type");
2422 ++input_line_pointer
;
2424 #ifdef BFD_ASSEMBLER
2428 flags
= SEC_NO_FLAGS
;
2430 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2431 else if (*type
== 'D' || *type
== 'M')
2432 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2433 else if (*type
== 'R')
2434 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2435 if (flags
!= SEC_NO_FLAGS
)
2437 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2438 as_warn ("error setting flags for \"%s\": %s",
2439 bfd_section_name (stdoutput
, seg
),
2440 bfd_errmsg (bfd_get_error ()));
2446 /* Ignore the HP type. */
2447 if (*input_line_pointer
== ',')
2448 input_line_pointer
+= 2;
2450 demand_empty_rest_of_line ();
2452 #else /* ! TC_M68K */
2461 name
= input_line_pointer
;
2462 c
= get_symbol_end ();
2464 name
= xstrdup (name
);
2466 *input_line_pointer
= c
;
2468 seg
= subseg_new (name
, 0);
2470 if (*input_line_pointer
!= ',')
2476 ++input_line_pointer
;
2478 sectype
= input_line_pointer
;
2479 c
= get_symbol_end ();
2480 if (*sectype
== '\0')
2482 else if (strcasecmp (sectype
, "text") == 0)
2484 else if (strcasecmp (sectype
, "data") == 0)
2486 else if (strcasecmp (sectype
, "romdata") == 0)
2489 as_warn ("unrecognized section type `%s'", sectype
);
2490 *input_line_pointer
= c
;
2493 if (*input_line_pointer
== ',')
2497 ++input_line_pointer
;
2499 seccmd
= input_line_pointer
;
2500 c
= get_symbol_end ();
2501 if (strcasecmp (seccmd
, "absolute") == 0)
2503 as_bad ("absolute sections are not supported");
2504 *input_line_pointer
= c
;
2505 ignore_rest_of_line ();
2508 else if (strcasecmp (seccmd
, "align") == 0)
2512 *input_line_pointer
= c
;
2513 align
= get_absolute_expression ();
2514 record_alignment (seg
, align
);
2518 as_warn ("unrecognized section command `%s'", seccmd
);
2519 *input_line_pointer
= c
;
2523 demand_empty_rest_of_line ();
2525 #else /* ! TC_I960 */
2526 /* The MRI assembler seems to use different forms of .sect for
2527 different targets. */
2529 #endif /* ! TC_I960 */
2530 #endif /* ! TC_M68K */
2533 /* Handle the .print pseudo-op. */
2542 s
= demand_copy_C_string (&len
);
2544 demand_empty_rest_of_line ();
2547 /* Handle the .purgem pseudo-op. */
2553 if (is_it_end_of_statement ())
2555 demand_empty_rest_of_line ();
2565 name
= input_line_pointer
;
2566 c
= get_symbol_end ();
2567 delete_macro (name
);
2568 *input_line_pointer
= c
;
2571 while (*input_line_pointer
++ == ',');
2573 --input_line_pointer
;
2574 demand_empty_rest_of_line ();
2577 /* Handle the .rept pseudo-op. */
2587 count
= get_absolute_expression ();
2590 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2592 as_bad ("rept without endr");
2598 sb_add_sb (&many
, &one
);
2602 input_scrub_include_sb (&many
, input_line_pointer
);
2604 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2607 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2608 this is .equiv, and it is an error if the symbol is already
2615 register char *name
;
2616 register char delim
;
2617 register char *end_name
;
2618 register symbolS
*symbolP
;
2621 * Especial apologies for the random logic:
2622 * this just grew, and could be parsed much more simply!
2625 name
= input_line_pointer
;
2626 delim
= get_symbol_end ();
2627 end_name
= input_line_pointer
;
2631 if (*input_line_pointer
!= ',')
2634 as_bad ("Expected comma after name \"%s\"", name
);
2636 ignore_rest_of_line ();
2640 input_line_pointer
++;
2643 if (name
[0] == '.' && name
[1] == '\0')
2645 /* Turn '. = mumble' into a .org mumble */
2646 register segT segment
;
2649 segment
= get_known_segmented_expression (&exp
);
2652 do_org (segment
, &exp
, 0);
2658 if ((symbolP
= symbol_find (name
)) == NULL
2659 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2661 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2663 /* "set" symbols are local unless otherwise specified. */
2664 SF_SET_LOCAL (symbolP
);
2665 #endif /* OBJ_COFF */
2667 } /* make a new symbol */
2669 symbol_table_insert (symbolP
);
2674 && S_IS_DEFINED (symbolP
)
2675 && S_GET_SEGMENT (symbolP
) != reg_section
)
2676 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
2678 pseudo_set (symbolP
);
2679 demand_empty_rest_of_line ();
2693 #ifdef md_flush_pending_output
2694 md_flush_pending_output ();
2698 stop
= mri_comment_field (&stopc
);
2700 /* In m68k MRI mode, we need to align to a word boundary, unless
2702 if (flag_m68k_mri
&& mult
> 1)
2704 if (now_seg
== absolute_section
)
2706 abs_section_offset
+= abs_section_offset
& 1;
2707 if (line_label
!= NULL
)
2708 S_SET_VALUE (line_label
, abs_section_offset
);
2710 else if (mri_common_symbol
!= NULL
)
2714 val
= S_GET_VALUE (mri_common_symbol
);
2717 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2718 if (line_label
!= NULL
)
2720 know (line_label
->sy_value
.X_op
== O_symbol
);
2721 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2722 line_label
->sy_value
.X_add_number
+= 1;
2728 do_align (1, (char *) NULL
, 0, 0);
2729 if (line_label
!= NULL
)
2731 line_label
->sy_frag
= frag_now
;
2732 S_SET_VALUE (line_label
, frag_now_fix ());
2742 if (*input_line_pointer
== ',')
2744 ++input_line_pointer
;
2749 val
.X_op
= O_constant
;
2750 val
.X_add_number
= 0;
2753 if (val
.X_op
!= O_constant
2754 || val
.X_add_number
< - 0x80
2755 || val
.X_add_number
> 0xff
2756 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2758 if (exp
.X_op
!= O_constant
)
2759 as_bad ("Unsupported variable size or fill value");
2766 bytes
= mult
* exp
.X_add_number
;
2767 for (i
= 0; i
< exp
.X_add_number
; i
++)
2768 emit_expr (&val
, mult
);
2773 if (exp
.X_op
== O_constant
)
2777 repeat
= exp
.X_add_number
;
2783 if (! flag_mri
|| repeat
< 0)
2784 as_warn (".space repeat count is %s, ignored",
2785 repeat
? "negative" : "zero");
2789 /* If we are in the absolute section, just bump the offset. */
2790 if (now_seg
== absolute_section
)
2792 abs_section_offset
+= repeat
;
2796 /* If we are secretly in an MRI common section, then
2797 creating space just increases the size of the common
2799 if (mri_common_symbol
!= NULL
)
2801 S_SET_VALUE (mri_common_symbol
,
2802 S_GET_VALUE (mri_common_symbol
) + repeat
);
2807 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2808 (offsetT
) repeat
, (char *) 0);
2812 if (now_seg
== absolute_section
)
2814 as_bad ("space allocation too complex in absolute section");
2815 subseg_set (text_section
, 0);
2817 if (mri_common_symbol
!= NULL
)
2819 as_bad ("space allocation too complex in common section");
2820 mri_common_symbol
= NULL
;
2823 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2824 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
2828 *p
= val
.X_add_number
;
2833 /* In MRI mode, after an odd number of bytes, we must align to an
2834 even word boundary, unless the next instruction is a dc.b, ds.b
2836 if (flag_mri
&& (bytes
& 1) != 0)
2837 mri_pending_align
= 1;
2840 mri_comment_end (stop
, stopc
);
2842 demand_empty_rest_of_line ();
2845 /* This is like s_space, but the value is a floating point number with
2846 the given precision. This is for the MRI dcb.s pseudo-op and
2850 s_float_space (float_type
)
2855 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2860 stop
= mri_comment_field (&stopc
);
2862 count
= get_absolute_expression ();
2865 if (*input_line_pointer
!= ',')
2867 as_bad ("missing value");
2869 mri_comment_end (stop
, stopc
);
2870 ignore_rest_of_line ();
2874 ++input_line_pointer
;
2878 /* Skip any 0{letter} that may be present. Don't even check if the
2879 * letter is legal. */
2880 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2881 input_line_pointer
+= 2;
2883 /* Accept :xxxx, where the x's are hex digits, for a floating point
2884 with the exact digits specified. */
2885 if (input_line_pointer
[0] == ':')
2887 flen
= hex_float (float_type
, temp
);
2891 mri_comment_end (stop
, stopc
);
2892 ignore_rest_of_line ();
2900 err
= md_atof (float_type
, temp
, &flen
);
2901 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2905 as_bad ("Bad floating literal: %s", err
);
2907 mri_comment_end (stop
, stopc
);
2908 ignore_rest_of_line ();
2913 while (--count
>= 0)
2917 p
= frag_more (flen
);
2918 memcpy (p
, temp
, (unsigned int) flen
);
2922 mri_comment_end (stop
, stopc
);
2924 demand_empty_rest_of_line ();
2927 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2937 stop
= mri_comment_field (&stopc
);
2938 abs_section_offset
= get_absolute_expression ();
2939 subseg_set (absolute_section
, 0);
2941 mri_comment_end (stop
, stopc
);
2942 demand_empty_rest_of_line ();
2951 temp
= get_absolute_expression ();
2952 subseg_set (text_section
, (subsegT
) temp
);
2953 demand_empty_rest_of_line ();
2955 const_flag
&= ~IN_DEFAULT_SECTION
;
2961 demand_empty_rest_of_line ()
2964 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2966 input_line_pointer
++;
2970 ignore_rest_of_line ();
2972 /* Return having already swallowed end-of-line. */
2973 } /* Return pointing just after end-of-line. */
2976 ignore_rest_of_line () /* For suspect lines: gives warning. */
2978 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2980 if (isprint (*input_line_pointer
))
2981 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2982 *input_line_pointer
);
2984 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2985 *input_line_pointer
);
2986 while (input_line_pointer
< buffer_limit
2987 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2989 input_line_pointer
++;
2992 input_line_pointer
++; /* Return pointing just after end-of-line. */
2993 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2999 * In: Pointer to a symbol.
3000 * Input_line_pointer->expression.
3002 * Out: Input_line_pointer->just after any whitespace after expression.
3003 * Tried to set symbol to value of expression.
3004 * Will change symbols type, value, and frag;
3007 pseudo_set (symbolP
)
3011 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3013 #endif /* OBJ_AOUT or OBJ_BOUT */
3015 know (symbolP
); /* NULL pointer is logic error. */
3016 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3017 ext
= S_IS_EXTERNAL (symbolP
);
3018 #endif /* OBJ_AOUT or OBJ_BOUT */
3020 (void) expression (&exp
);
3022 if (exp
.X_op
== O_illegal
)
3023 as_bad ("illegal expression; zero assumed");
3024 else if (exp
.X_op
== O_absent
)
3025 as_bad ("missing expression; zero assumed");
3026 else if (exp
.X_op
== O_big
)
3027 as_bad ("%s number invalid; zero assumed",
3028 exp
.X_add_number
> 0 ? "bignum" : "floating point");
3029 else if (exp
.X_op
== O_subtract
3030 && (S_GET_SEGMENT (exp
.X_add_symbol
)
3031 == S_GET_SEGMENT (exp
.X_op_symbol
))
3032 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3033 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
3035 exp
.X_op
= O_constant
;
3036 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3037 - S_GET_VALUE (exp
.X_op_symbol
));
3045 exp
.X_add_number
= 0;
3048 S_SET_SEGMENT (symbolP
, absolute_section
);
3049 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3051 S_SET_EXTERNAL (symbolP
);
3053 S_CLEAR_EXTERNAL (symbolP
);
3054 #endif /* OBJ_AOUT or OBJ_BOUT */
3055 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3056 symbolP
->sy_frag
= &zero_address_frag
;
3060 S_SET_SEGMENT (symbolP
, reg_section
);
3061 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3062 symbolP
->sy_frag
= &zero_address_frag
;
3066 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
3067 || exp
.X_add_number
!= 0)
3068 symbolP
->sy_value
= exp
;
3071 symbolS
*s
= exp
.X_add_symbol
;
3073 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
3074 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3076 S_SET_EXTERNAL (symbolP
);
3078 S_CLEAR_EXTERNAL (symbolP
);
3079 #endif /* OBJ_AOUT or OBJ_BOUT */
3080 S_SET_VALUE (symbolP
,
3081 exp
.X_add_number
+ S_GET_VALUE (s
));
3082 symbolP
->sy_frag
= s
->sy_frag
;
3083 copy_symbol_attributes (symbolP
, s
);
3088 /* The value is some complex expression.
3089 FIXME: Should we set the segment to anything? */
3090 symbolP
->sy_value
= exp
;
3098 * CONStruct more frag of .bytes, or .words etc.
3099 * Should need_pass_2 be 1 then emit no frag(s).
3100 * This understands EXPRESSIONS.
3104 * This has a split personality. We use expression() to read the
3105 * value. We can detect if the value won't fit in a byte or word.
3106 * But we can't detect if expression() discarded significant digits
3107 * in the case of a long. Not worth the crocks required to fix it.
3110 /* Select a parser for cons expressions. */
3112 /* Some targets need to parse the expression in various fancy ways.
3113 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3114 (for example, the HPPA does this). Otherwise, you can define
3115 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3116 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3117 are defined, which is the normal case, then only simple expressions
3121 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3123 #ifndef TC_PARSE_CONS_EXPRESSION
3124 #ifdef BITFIELD_CONS_EXPRESSIONS
3125 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3127 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3129 #ifdef REPEAT_CONS_EXPRESSIONS
3130 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3132 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3135 /* If we haven't gotten one yet, just call expression. */
3136 #ifndef TC_PARSE_CONS_EXPRESSION
3137 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3141 /* worker to do .byte etc statements */
3142 /* clobbers input_line_pointer, checks */
3145 cons_worker (nbytes
, rva
)
3146 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3154 #ifdef md_flush_pending_output
3155 md_flush_pending_output ();
3159 stop
= mri_comment_field (&stopc
);
3161 if (is_it_end_of_statement ())
3164 mri_comment_end (stop
, stopc
);
3165 demand_empty_rest_of_line ();
3169 #ifdef md_cons_align
3170 md_cons_align (nbytes
);
3177 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3179 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3183 if (exp
.X_op
== O_symbol
)
3184 exp
.X_op
= O_symbol_rva
;
3186 as_fatal ("rva without symbol");
3188 emit_expr (&exp
, (unsigned int) nbytes
);
3191 while (*input_line_pointer
++ == ',');
3193 /* In MRI mode, after an odd number of bytes, we must align to an
3194 even word boundary, unless the next instruction is a dc.b, ds.b
3196 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3197 mri_pending_align
= 1;
3199 input_line_pointer
--; /* Put terminator back into stream. */
3202 mri_comment_end (stop
, stopc
);
3204 demand_empty_rest_of_line ();
3212 cons_worker (size
, 0);
3219 cons_worker (size
, 1);
3223 /* Put the contents of expression EXP into the object file using
3224 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3227 emit_expr (exp
, nbytes
)
3229 unsigned int nbytes
;
3233 valueT extra_digit
= 0;
3235 /* Don't do anything if we are going to make another pass. */
3241 /* Allow `.word 0' in the absolute section. */
3242 if (now_seg
== absolute_section
)
3244 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3245 as_bad ("attempt to store value in absolute section");
3246 abs_section_offset
+= nbytes
;
3250 /* Handle a negative bignum. */
3252 && exp
->X_add_number
== 0
3253 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3254 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3257 unsigned long carry
;
3259 exp
= &exp
->X_add_symbol
->sy_value
;
3261 /* Negate the bignum: one's complement each digit and add 1. */
3263 for (i
= 0; i
< exp
->X_add_number
; i
++)
3267 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3270 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3271 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3274 /* We can ignore any carry out, because it will be handled by
3275 extra_digit if it is needed. */
3277 extra_digit
= (valueT
) -1;
3281 if (op
== O_absent
|| op
== O_illegal
)
3283 as_warn ("zero assumed for missing expression");
3284 exp
->X_add_number
= 0;
3287 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3289 as_bad ("floating point number invalid; zero assumed");
3290 exp
->X_add_number
= 0;
3293 else if (op
== O_register
)
3295 as_warn ("register value used as expression");
3299 p
= frag_more ((int) nbytes
);
3301 #ifndef WORKING_DOT_WORD
3302 /* If we have the difference of two symbols in a word, save it on
3303 the broken_words list. See the code in write.c. */
3304 if (op
== O_subtract
&& nbytes
== 2)
3306 struct broken_word
*x
;
3308 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3309 x
->next_broken_word
= broken_words
;
3312 x
->word_goes_here
= p
;
3314 x
->add
= exp
->X_add_symbol
;
3315 x
->sub
= exp
->X_op_symbol
;
3316 x
->addnum
= exp
->X_add_number
;
3323 /* If we have an integer, but the number of bytes is too large to
3324 pass to md_number_to_chars, handle it as a bignum. */
3325 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3330 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3331 extra_digit
= (valueT
) -1;
3332 val
= (valueT
) exp
->X_add_number
;
3336 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3337 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3341 op
= exp
->X_op
= O_big
;
3342 exp
->X_add_number
= gencnt
;
3345 if (op
== O_constant
)
3347 register valueT get
;
3348 register valueT use
;
3349 register valueT mask
;
3351 register valueT unmask
;
3353 /* JF << of >= number of bits in the object is undefined. In
3354 particular SPARC (Sun 4) has problems */
3355 if (nbytes
>= sizeof (valueT
))
3358 if (nbytes
> sizeof (valueT
))
3361 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3365 /* Don't store these bits. */
3366 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3367 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3370 unmask
= ~mask
; /* Do store these bits. */
3373 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3374 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3377 get
= exp
->X_add_number
;
3379 if ((get
& mask
) != 0
3380 && ((get
& mask
) != mask
3381 || (get
& hibit
) == 0))
3382 { /* Leading bits contain both 0s & 1s. */
3383 as_warn ("Value 0x%lx truncated to 0x%lx.",
3384 (unsigned long) get
, (unsigned long) use
);
3386 /* put bytes in right order. */
3387 md_number_to_chars (p
, use
, (int) nbytes
);
3389 else if (op
== O_big
)
3392 LITTLENUM_TYPE
*nums
;
3394 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3396 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3399 as_warn ("Bignum truncated to %d bytes", nbytes
);
3403 if (target_big_endian
)
3405 while (nbytes
> size
)
3407 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3408 nbytes
-= CHARS_PER_LITTLENUM
;
3409 p
+= CHARS_PER_LITTLENUM
;
3412 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3416 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3417 size
-= CHARS_PER_LITTLENUM
;
3418 p
+= CHARS_PER_LITTLENUM
;
3423 nums
= generic_bignum
;
3426 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3428 size
-= CHARS_PER_LITTLENUM
;
3429 p
+= CHARS_PER_LITTLENUM
;
3430 nbytes
-= CHARS_PER_LITTLENUM
;
3435 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3436 nbytes
-= CHARS_PER_LITTLENUM
;
3437 p
+= CHARS_PER_LITTLENUM
;
3443 memset (p
, 0, nbytes
);
3445 /* Now we need to generate a fixS to record the symbol value.
3446 This is easy for BFD. For other targets it can be more
3447 complex. For very complex cases (currently, the HPPA and
3448 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3449 want. For simpler cases, you can define TC_CONS_RELOC to be
3450 the name of the reloc code that should be stored in the fixS.
3451 If neither is defined, the code uses NO_RELOC if it is
3452 defined, and otherwise uses 0. */
3454 #ifdef BFD_ASSEMBLER
3455 #ifdef TC_CONS_FIX_NEW
3456 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3459 bfd_reloc_code_real_type r
;
3476 as_bad ("unsupported BFD relocation size %u", nbytes
);
3480 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3485 #ifdef TC_CONS_FIX_NEW
3486 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3488 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3489 it is defined, otherwise use NO_RELOC if it is defined,
3491 #ifndef TC_CONS_RELOC
3493 #define TC_CONS_RELOC NO_RELOC
3495 #define TC_CONS_RELOC 0
3498 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3500 #endif /* TC_CONS_FIX_NEW */
3501 #endif /* BFD_ASSEMBLER */
3505 #ifdef BITFIELD_CONS_EXPRESSIONS
3507 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3508 w:x,y:z, where w and y are bitwidths and x and y are values. They
3509 then pack them all together. We do a little better in that we allow
3510 them in words, longs, etc. and we'll pack them in target byte order
3513 The rules are: pack least significat bit first, if a field doesn't
3514 entirely fit, put it in the next unit. Overflowing the bitfield is
3515 explicitly *not* even a warning. The bitwidth should be considered
3518 To use this function the tc-XXX.h file should define
3519 BITFIELD_CONS_EXPRESSIONS. */
3522 parse_bitfield_cons (exp
, nbytes
)
3524 unsigned int nbytes
;
3526 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3527 char *hold
= input_line_pointer
;
3529 (void) expression (exp
);
3531 if (*input_line_pointer
== ':')
3537 unsigned long width
;
3539 if (*input_line_pointer
!= ':')
3541 input_line_pointer
= hold
;
3543 } /* next piece is not a bitfield */
3545 /* In the general case, we can't allow
3546 full expressions with symbol
3547 differences and such. The relocation
3548 entries for symbols not defined in this
3549 assembly would require arbitrary field
3550 widths, positions, and masks which most
3551 of our current object formats don't
3554 In the specific case where a symbol
3555 *is* defined in this assembly, we
3556 *could* build fixups and track it, but
3557 this could lead to confusion for the
3558 backends. I'm lazy. I'll take any
3559 SEG_ABSOLUTE. I think that means that
3560 you can use a previous .set or
3561 .equ type symbol. xoxorich. */
3563 if (exp
->X_op
== O_absent
)
3565 as_warn ("using a bit field width of zero");
3566 exp
->X_add_number
= 0;
3567 exp
->X_op
= O_constant
;
3568 } /* implied zero width bitfield */
3570 if (exp
->X_op
!= O_constant
)
3572 *input_line_pointer
= '\0';
3573 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3574 *input_line_pointer
= ':';
3575 demand_empty_rest_of_line ();
3579 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3581 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3582 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3583 width
= BITS_PER_CHAR
* nbytes
;
3586 if (width
> bits_available
)
3588 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3589 input_line_pointer
= hold
;
3590 exp
->X_add_number
= value
;
3594 hold
= ++input_line_pointer
; /* skip ':' */
3596 (void) expression (exp
);
3597 if (exp
->X_op
!= O_constant
)
3599 char cache
= *input_line_pointer
;
3601 *input_line_pointer
= '\0';
3602 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3603 *input_line_pointer
= cache
;
3604 demand_empty_rest_of_line ();
3608 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3609 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3611 if ((bits_available
-= width
) == 0
3612 || is_it_end_of_statement ()
3613 || *input_line_pointer
!= ',')
3616 } /* all the bitfields we're gonna get */
3618 hold
= ++input_line_pointer
;
3619 (void) expression (exp
);
3620 } /* forever loop */
3622 exp
->X_add_number
= value
;
3623 exp
->X_op
= O_constant
;
3624 exp
->X_unsigned
= 1;
3625 } /* if looks like a bitfield */
3626 } /* parse_bitfield_cons() */
3628 #endif /* BITFIELD_CONS_EXPRESSIONS */
3630 /* Handle an MRI style string expression. */
3633 parse_mri_cons (exp
, nbytes
)
3635 unsigned int nbytes
;
3637 if (*input_line_pointer
!= '\''
3638 && (input_line_pointer
[1] != '\''
3639 || (*input_line_pointer
!= 'A'
3640 && *input_line_pointer
!= 'E')))
3641 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3645 unsigned int result
= 0;
3647 /* An MRI style string. Cut into as many bytes as will fit into
3648 a nbyte chunk, left justify if necessary, and separate with
3649 commas so we can try again later. */
3650 if (*input_line_pointer
== 'A')
3651 ++input_line_pointer
;
3652 else if (*input_line_pointer
== 'E')
3654 as_bad ("EBCDIC constants are not supported");
3655 ++input_line_pointer
;
3658 input_line_pointer
++;
3659 for (scan
= 0; scan
< nbytes
; scan
++)
3661 if (*input_line_pointer
== '\'')
3663 if (input_line_pointer
[1] == '\'')
3665 input_line_pointer
++;
3670 result
= (result
<< 8) | (*input_line_pointer
++);
3674 while (scan
< nbytes
)
3679 /* Create correct expression */
3680 exp
->X_op
= O_constant
;
3681 exp
->X_add_number
= result
;
3682 /* Fake it so that we can read the next char too */
3683 if (input_line_pointer
[0] != '\'' ||
3684 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3686 input_line_pointer
-= 2;
3687 input_line_pointer
[0] = ',';
3688 input_line_pointer
[1] = '\'';
3691 input_line_pointer
++;
3695 #ifdef REPEAT_CONS_EXPRESSIONS
3697 /* Parse a repeat expression for cons. This is used by the MIPS
3698 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3699 object file COUNT times.
3701 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3704 parse_repeat_cons (exp
, nbytes
)
3706 unsigned int nbytes
;
3713 if (*input_line_pointer
!= ':')
3715 /* No repeat count. */
3719 ++input_line_pointer
;
3720 expression (&count
);
3721 if (count
.X_op
!= O_constant
3722 || count
.X_add_number
<= 0)
3724 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3728 /* The cons function is going to output this expression once. So we
3729 output it count - 1 times. */
3730 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3731 emit_expr (exp
, nbytes
);
3734 #endif /* REPEAT_CONS_EXPRESSIONS */
3736 /* Parse a floating point number represented as a hex constant. This
3737 permits users to specify the exact bits they want in the floating
3741 hex_float (float_type
, bytes
)
3775 as_bad ("Unknown floating type type '%c'", float_type
);
3779 /* It would be nice if we could go through expression to parse the
3780 hex constant, but if we get a bignum it's a pain to sort it into
3781 the buffer correctly. */
3783 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3787 /* The MRI assembler accepts arbitrary underscores strewn about
3788 through the hex constant, so we ignore them as well. */
3789 if (*input_line_pointer
== '_')
3791 ++input_line_pointer
;
3797 as_warn ("Floating point constant too large");
3800 d
= hex_value (*input_line_pointer
) << 4;
3801 ++input_line_pointer
;
3802 while (*input_line_pointer
== '_')
3803 ++input_line_pointer
;
3804 if (hex_p (*input_line_pointer
))
3806 d
+= hex_value (*input_line_pointer
);
3807 ++input_line_pointer
;
3809 if (target_big_endian
)
3812 bytes
[length
- i
- 1] = d
;
3818 if (target_big_endian
)
3819 memset (bytes
+ i
, 0, length
- i
);
3821 memset (bytes
, 0, length
- i
);
3830 * CONStruct some more frag chars of .floats .ffloats etc.
3831 * Makes 0 or more new frags.
3832 * If need_pass_2 == 1, no frags are emitted.
3833 * This understands only floating literals, not expressions. Sorry.
3835 * A floating constant is defined by atof_generic(), except it is preceded
3836 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3837 * reading, I decided to be incompatible. This always tries to give you
3838 * rounded bits to the precision of the pseudo-op. Former AS did premature
3839 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3840 * a choice of 2 flavours of noise according to which of 2 floating-point
3841 * scanners you directed AS to use.
3843 * In: input_line_pointer->whitespace before, or '0' of flonum.
3848 float_cons (float_type
)
3849 /* Clobbers input_line-pointer, checks end-of-line. */
3850 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3853 int length
; /* Number of chars in an object. */
3854 register char *err
; /* Error from scanning floating literal. */
3855 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3857 if (is_it_end_of_statement ())
3859 demand_empty_rest_of_line ();
3863 #ifdef md_flush_pending_output
3864 md_flush_pending_output ();
3869 /* input_line_pointer->1st char of a flonum (we hope!). */
3872 /* Skip any 0{letter} that may be present. Don't even check if the
3873 * letter is legal. Someone may invent a "z" format and this routine
3874 * has no use for such information. Lusers beware: you get
3875 * diagnostics if your input is ill-conditioned.
3877 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3878 input_line_pointer
+= 2;
3880 /* Accept :xxxx, where the x's are hex digits, for a floating
3881 point with the exact digits specified. */
3882 if (input_line_pointer
[0] == ':')
3884 ++input_line_pointer
;
3885 length
= hex_float (float_type
, temp
);
3888 ignore_rest_of_line ();
3894 err
= md_atof (float_type
, temp
, &length
);
3895 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3899 as_bad ("Bad floating literal: %s", err
);
3900 ignore_rest_of_line ();
3911 #ifdef REPEAT_CONS_EXPRESSIONS
3912 if (*input_line_pointer
== ':')
3914 expressionS count_exp
;
3916 ++input_line_pointer
;
3917 expression (&count_exp
);
3918 if (count_exp
.X_op
!= O_constant
3919 || count_exp
.X_add_number
<= 0)
3921 as_warn ("unresolvable or nonpositive repeat count; using 1");
3924 count
= count_exp
.X_add_number
;
3928 while (--count
>= 0)
3930 p
= frag_more (length
);
3931 memcpy (p
, temp
, (unsigned int) length
);
3936 while (*input_line_pointer
++ == ',');
3938 --input_line_pointer
; /* Put terminator back into stream. */
3939 demand_empty_rest_of_line ();
3940 } /* float_cons() */
3942 /* Return the size of a LEB128 value */
3945 sizeof_sleb128 (value
)
3948 register int size
= 0;
3949 register unsigned byte
;
3953 byte
= (value
& 0x7f);
3954 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
3955 Fortunately, we can structure things so that the extra work reduces
3956 to a noop on systems that do things "properly". */
3957 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
3960 while (!(((value
== 0) && ((byte
& 0x40) == 0))
3961 || ((value
== -1) && ((byte
& 0x40) != 0))));
3967 sizeof_uleb128 (value
)
3970 register int size
= 0;
3971 register unsigned byte
;
3975 byte
= (value
& 0x7f);
3985 sizeof_leb128 (value
, sign
)
3990 return sizeof_sleb128 ((offsetT
) value
);
3992 return sizeof_uleb128 (value
);
3995 /* Output a LEB128 value. */
3998 output_sleb128 (p
, value
)
4002 register char *orig
= p
;
4007 unsigned byte
= (value
& 0x7f);
4009 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4010 Fortunately, we can structure things so that the extra work reduces
4011 to a noop on systems that do things "properly". */
4012 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4014 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4015 || ((value
== -1) && ((byte
& 0x40) != 0))));
4027 output_uleb128 (p
, value
)
4035 unsigned byte
= (value
& 0x7f);
4038 /* More bytes to follow. */
4049 output_leb128 (p
, value
, sign
)
4055 return output_sleb128 (p
, (offsetT
) value
);
4057 return output_uleb128 (p
, value
);
4060 /* Do the same for bignums. We combine sizeof with output here in that
4061 we don't output for NULL values of P. It isn't really as critical as
4062 for "normal" values that this be streamlined. */
4065 output_big_sleb128 (p
, bignum
, size
)
4067 LITTLENUM_TYPE
*bignum
;
4075 /* Strip leading sign extensions off the bignum. */
4076 while (size
> 0 && bignum
[size
-1] == (LITTLENUM_TYPE
)-1)
4081 if (loaded
< 7 && size
> 0)
4083 val
|= (*bignum
<< loaded
);
4084 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4095 if ((val
== 0 && (byte
& 0x40) == 0)
4096 || (~(val
| ~(((valueT
)1 << loaded
) - 1)) == 0
4097 && (byte
& 0x40) != 0))
4105 while (byte
& 0x80);
4111 output_big_uleb128 (p
, bignum
, size
)
4113 LITTLENUM_TYPE
*bignum
;
4121 /* Strip leading zeros off the bignum. */
4122 /* XXX: Is this needed? */
4123 while (size
> 0 && bignum
[size
-1] == 0)
4128 if (loaded
< 7 && size
> 0)
4130 val
|= (*bignum
<< loaded
);
4131 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4140 if (size
> 0 || val
)
4147 while (byte
& 0x80);
4153 output_big_leb128 (p
, bignum
, size
, sign
)
4155 LITTLENUM_TYPE
*bignum
;
4159 return output_big_sleb128 (p
, bignum
, size
);
4161 return output_big_uleb128 (p
, bignum
, size
);
4164 /* Generate the appropriate fragments for a given expression to emit a
4168 emit_leb128_expr(exp
, sign
)
4172 operatorT op
= exp
->X_op
;
4174 if (op
== O_absent
|| op
== O_illegal
)
4176 as_warn ("zero assumed for missing expression");
4177 exp
->X_add_number
= 0;
4180 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4182 as_bad ("floating point number invalid; zero assumed");
4183 exp
->X_add_number
= 0;
4186 else if (op
== O_register
)
4188 as_warn ("register value used as expression");
4192 if (op
== O_constant
)
4194 /* If we've got a constant, emit the thing directly right now. */
4196 valueT value
= exp
->X_add_number
;
4200 size
= sizeof_leb128 (value
, sign
);
4201 p
= frag_more (size
);
4202 output_leb128 (p
, value
, sign
);
4204 else if (op
== O_big
)
4206 /* O_big is a different sort of constant. */
4211 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
4212 p
= frag_more (size
);
4213 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
4217 /* Otherwise, we have to create a variable sized fragment and
4218 resolve things later. */
4220 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
)0), 0, sign
,
4221 make_expr_symbol (exp
), 0, (char *) NULL
);
4225 /* Parse the .sleb128 and .uleb128 pseudos. */
4235 emit_leb128_expr (&exp
, sign
);
4236 } while (*input_line_pointer
++ == ',');
4238 input_line_pointer
--;
4239 demand_empty_rest_of_line ();
4245 * We read 0 or more ',' seperated, double-quoted strings.
4247 * Caller should have checked need_pass_2 is FALSE because we don't check it.
4252 stringer (append_zero
) /* Worker to do .ascii etc statements. */
4253 /* Checks end-of-line. */
4254 register int append_zero
; /* 0: don't append '\0', else 1 */
4256 register unsigned int c
;
4258 #ifdef md_flush_pending_output
4259 md_flush_pending_output ();
4263 * The following awkward logic is to parse ZERO or more strings,
4264 * comma seperated. Recall a string expression includes spaces
4265 * before the opening '\"' and spaces after the closing '\"'.
4266 * We fake a leading ',' if there is (supposed to be)
4267 * a 1st, expression. We keep demanding expressions for each
4270 if (is_it_end_of_statement ())
4272 c
= 0; /* Skip loop. */
4273 ++input_line_pointer
; /* Compensate for end of loop. */
4277 c
= ','; /* Do loop. */
4279 while (c
== ',' || c
== '<' || c
== '"')
4282 switch (*input_line_pointer
)
4285 ++input_line_pointer
; /*->1st char of string. */
4286 while (is_a_char (c
= next_char_of_string ()))
4288 FRAG_APPEND_1_CHAR (c
);
4292 FRAG_APPEND_1_CHAR (0);
4294 know (input_line_pointer
[-1] == '\"');
4297 input_line_pointer
++;
4298 c
= get_single_number ();
4299 FRAG_APPEND_1_CHAR (c
);
4300 if (*input_line_pointer
!= '>')
4302 as_bad ("Expected <nn>");
4304 input_line_pointer
++;
4307 input_line_pointer
++;
4311 c
= *input_line_pointer
;
4314 demand_empty_rest_of_line ();
4317 /* FIXME-SOMEDAY: I had trouble here on characters with the
4318 high bits set. We'll probably also have trouble with
4319 multibyte chars, wide chars, etc. Also be careful about
4320 returning values bigger than 1 byte. xoxorich. */
4323 next_char_of_string ()
4325 register unsigned int c
;
4327 c
= *input_line_pointer
++ & CHAR_MASK
;
4335 as_warn ("Unterminated string: Newline inserted.");
4336 bump_line_counters ();
4339 #ifndef NO_STRING_ESCAPES
4341 switch (c
= *input_line_pointer
++)
4369 break; /* As itself. */
4385 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
4387 number
= number
* 8 + c
- '0';
4391 --input_line_pointer
;
4400 c
= *input_line_pointer
++;
4401 while (isxdigit (c
))
4404 number
= number
* 16 + c
- '0';
4405 else if (isupper (c
))
4406 number
= number
* 16 + c
- 'A' + 10;
4408 number
= number
* 16 + c
- 'a' + 10;
4409 c
= *input_line_pointer
++;
4412 --input_line_pointer
;
4417 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4418 as_warn ("Unterminated string: Newline inserted.");
4420 bump_line_counters ();
4425 #ifdef ONLY_STANDARD_ESCAPES
4426 as_bad ("Bad escaped character in string, '?' assumed");
4428 #endif /* ONLY_STANDARD_ESCAPES */
4431 } /* switch on escaped char */
4433 #endif /* ! defined (NO_STRING_ESCAPES) */
4437 } /* switch on char */
4439 } /* next_char_of_string() */
4442 get_segmented_expression (expP
)
4443 register expressionS
*expP
;
4445 register segT retval
;
4447 retval
= expression (expP
);
4448 if (expP
->X_op
== O_illegal
4449 || expP
->X_op
== O_absent
4450 || expP
->X_op
== O_big
)
4452 as_bad ("expected address expression; zero assumed");
4453 expP
->X_op
= O_constant
;
4454 expP
->X_add_number
= 0;
4455 retval
= absolute_section
;
4461 get_known_segmented_expression (expP
)
4462 register expressionS
*expP
;
4464 register segT retval
;
4466 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4468 /* There is no easy way to extract the undefined symbol from the
4470 if (expP
->X_add_symbol
!= NULL
4471 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4472 as_warn ("symbol \"%s\" undefined; zero assumed",
4473 S_GET_NAME (expP
->X_add_symbol
));
4475 as_warn ("some symbol undefined; zero assumed");
4476 retval
= absolute_section
;
4477 expP
->X_op
= O_constant
;
4478 expP
->X_add_number
= 0;
4480 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4482 } /* get_known_segmented_expression() */
4485 get_absolute_expression ()
4490 if (exp
.X_op
!= O_constant
)
4492 if (exp
.X_op
!= O_absent
)
4493 as_bad ("bad or irreducible absolute expression; zero assumed");
4494 exp
.X_add_number
= 0;
4496 return exp
.X_add_number
;
4499 char /* return terminator */
4500 get_absolute_expression_and_terminator (val_pointer
)
4501 long *val_pointer
; /* return value of expression */
4503 /* FIXME: val_pointer should probably be offsetT *. */
4504 *val_pointer
= (long) get_absolute_expression ();
4505 return (*input_line_pointer
++);
4509 * demand_copy_C_string()
4511 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4512 * Give a warning if that happens.
4515 demand_copy_C_string (len_pointer
)
4520 if ((s
= demand_copy_string (len_pointer
)) != 0)
4524 for (len
= *len_pointer
; len
> 0; len
--)
4531 as_bad ("This string may not contain \'\\0\'");
4539 * demand_copy_string()
4541 * Demand string, but return a safe (=private) copy of the string.
4542 * Return NULL if we can't read a string here.
4545 demand_copy_string (lenP
)
4548 register unsigned int c
;
4554 if (*input_line_pointer
== '\"')
4556 input_line_pointer
++; /* Skip opening quote. */
4558 while (is_a_char (c
= next_char_of_string ()))
4560 obstack_1grow (¬es
, c
);
4563 /* JF this next line is so demand_copy_C_string will return a
4564 null terminated string. */
4565 obstack_1grow (¬es
, '\0');
4566 retval
= obstack_finish (¬es
);
4570 as_warn ("Missing string");
4572 ignore_rest_of_line ();
4576 } /* demand_copy_string() */
4579 * is_it_end_of_statement()
4581 * In: Input_line_pointer->next character.
4583 * Do: Skip input_line_pointer over all whitespace.
4585 * Out: 1 if input_line_pointer->end-of-line.
4588 is_it_end_of_statement ()
4591 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4592 } /* is_it_end_of_statement() */
4595 equals (sym_name
, reassign
)
4599 register symbolS
*symbolP
; /* symbol we are working with */
4603 input_line_pointer
++;
4604 if (*input_line_pointer
== '=')
4605 input_line_pointer
++;
4607 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4608 input_line_pointer
++;
4611 stop
= mri_comment_field (&stopc
);
4613 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4615 /* Turn '. = mumble' into a .org mumble */
4616 register segT segment
;
4619 segment
= get_known_segmented_expression (&exp
);
4621 do_org (segment
, &exp
, 0);
4625 symbolP
= symbol_find_or_make (sym_name
);
4626 /* Permit register names to be redefined. */
4628 && S_IS_DEFINED (symbolP
)
4629 && S_GET_SEGMENT (symbolP
) != reg_section
)
4630 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
4631 pseudo_set (symbolP
);
4635 mri_comment_end (stop
, stopc
);
4638 /* .include -- include a file at this point. */
4651 if (! flag_m68k_mri
)
4652 filename
= demand_copy_string (&i
);
4657 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4658 && *input_line_pointer
!= ' '
4659 && *input_line_pointer
!= '\t')
4661 obstack_1grow (¬es
, *input_line_pointer
);
4662 ++input_line_pointer
;
4665 obstack_1grow (¬es
, '\0');
4666 filename
= obstack_finish (¬es
);
4667 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4668 ++input_line_pointer
;
4670 demand_empty_rest_of_line ();
4671 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4672 for (i
= 0; i
< include_dir_count
; i
++)
4674 strcpy (path
, include_dirs
[i
]);
4676 strcat (path
, filename
);
4677 if (0 != (try = fopen (path
, "r")))
4686 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4687 register_dependency (path
);
4688 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4689 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4693 add_include_dir (path
)
4698 if (include_dir_count
== 0)
4700 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4701 include_dirs
[0] = "."; /* Current dir */
4702 include_dir_count
= 2;
4706 include_dir_count
++;
4707 include_dirs
= (char **) realloc (include_dirs
,
4708 include_dir_count
* sizeof (*include_dirs
));
4711 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4714 if (i
> include_dir_maxlen
)
4715 include_dir_maxlen
= i
;
4716 } /* add_include_dir() */
4722 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4724 ++input_line_pointer
;
4726 ++input_line_pointer
;
4731 read_print_statistics (file
)
4734 hash_print_statistics (file
, "pseudo-op table", po_hash
);