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, _
, _
, /* @abcdefghijklmno */
133 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 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 pseud-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 (needs_align
)
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) */
1875 register char *name
;
1879 register symbolS
*symbolP
;
1880 segT current_seg
= now_seg
;
1881 subsegT current_subseg
= now_subseg
;
1882 const int max_alignment
= 15;
1884 segT bss_seg
= bss_section
;
1886 name
= input_line_pointer
;
1887 c
= get_symbol_end ();
1888 p
= input_line_pointer
;
1892 /* Accept an optional comma after the name. The comma used to be
1893 required, but Irix 5 cc does not generate it. */
1894 if (*input_line_pointer
== ',')
1896 ++input_line_pointer
;
1900 if (*input_line_pointer
== '\n')
1902 as_bad ("Missing size expression");
1906 if ((temp
= get_absolute_expression ()) < 0)
1908 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1909 ignore_rest_of_line ();
1913 #if defined (TC_MIPS) || defined (TC_ALPHA)
1914 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1915 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1917 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1918 if (temp
<= bfd_get_gp_size (stdoutput
))
1920 bss_seg
= subseg_new (".sbss", 1);
1921 seg_info (bss_seg
)->bss
= 1;
1922 #ifdef BFD_ASSEMBLER
1923 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1924 as_warn ("error setting flags for \".sbss\": %s",
1925 bfd_errmsg (bfd_get_error ()));
1932 /* FIXME. This needs to be machine independent. */
1943 /* FIXME: This needs to be done in a more general fashion. */
1947 record_alignment(bss_seg
, align
);
1954 if (*input_line_pointer
!= ',')
1956 as_bad ("Expected comma after size");
1957 ignore_rest_of_line ();
1960 input_line_pointer
++;
1962 if (*input_line_pointer
== '\n')
1964 as_bad ("Missing alignment");
1967 align
= get_absolute_expression ();
1968 if (align
> max_alignment
)
1970 align
= max_alignment
;
1971 as_warn ("Alignment too large: %d. assumed.", align
);
1976 as_warn ("Alignment negative. 0 assumed.");
1978 record_alignment (bss_seg
, align
);
1979 } /* if needs align */
1982 /* Assume some objects may require alignment on some systems. */
1983 #if defined (TC_ALPHA) && ! defined (VMS)
1986 align
= ffs (temp
) - 1;
1987 if (temp
% (1 << align
))
1994 symbolP
= symbol_find_or_make (name
);
1998 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1999 S_GET_OTHER (symbolP
) == 0 &&
2000 S_GET_DESC (symbolP
) == 0 &&
2001 #endif /* OBJ_AOUT or OBJ_BOUT */
2002 (S_GET_SEGMENT (symbolP
) == bss_seg
2003 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
2007 subseg_set (bss_seg
, 1);
2010 frag_align (align
, 0, 0);
2011 /* detach from old frag */
2012 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2013 symbolP
->sy_frag
->fr_symbol
= NULL
;
2015 symbolP
->sy_frag
= frag_now
;
2016 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2017 (offsetT
) temp
, (char *) 0);
2020 S_SET_SEGMENT (symbolP
, bss_seg
);
2023 /* The symbol may already have been created with a preceding
2024 ".globl" directive -- be careful not to step on storage class
2025 in that case. Otherwise, set it to static. */
2026 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2028 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2030 #endif /* OBJ_COFF */
2033 S_SET_SIZE (symbolP
, temp
);
2037 as_bad ("Ignoring attempt to re-define symbol `%s'.",
2038 S_GET_NAME (symbolP
));
2040 subseg_set (current_seg
, current_subseg
);
2042 demand_empty_rest_of_line ();
2049 register char *name
;
2053 register symbolS
*symbolP
;
2055 /* we permit ANY defined expression: BSD4.2 demands constants */
2056 name
= input_line_pointer
;
2057 c
= get_symbol_end ();
2058 p
= input_line_pointer
;
2061 if (*input_line_pointer
!= ',')
2064 as_bad ("Expected comma after name \"%s\"", name
);
2066 ignore_rest_of_line ();
2069 input_line_pointer
++;
2071 if (exp
.X_op
!= O_constant
2072 && exp
.X_op
!= O_register
)
2074 as_bad ("bad expression");
2075 ignore_rest_of_line ();
2079 symbolP
= symbol_find_or_make (name
);
2081 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2082 symbolP->sy_desc == 0) out of this test because coff doesn't have
2083 those fields, and I can't see when they'd ever be tripped. I
2084 don't think I understand why they were here so I may have
2085 introduced a bug. As recently as 1.37 didn't have this test
2086 anyway. xoxorich. */
2088 if (S_GET_SEGMENT (symbolP
) == undefined_section
2089 && S_GET_VALUE (symbolP
) == 0)
2091 /* The name might be an undefined .global symbol; be sure to
2092 keep the "external" bit. */
2093 S_SET_SEGMENT (symbolP
,
2094 (exp
.X_op
== O_constant
2097 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2101 as_bad ("Symbol %s already defined", name
);
2104 demand_empty_rest_of_line ();
2107 /* Read a line into an sb. */
2113 char quote1
, quote2
, inquote
;
2115 if (input_line_pointer
[-1] == '\n')
2116 bump_line_counters ();
2118 if (input_line_pointer
>= buffer_limit
)
2120 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2121 if (buffer_limit
== 0)
2125 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2126 code needs to be changed. */
2127 if (! flag_m68k_mri
)
2135 #ifdef LEX_IS_STRINGQUOTE
2140 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
2141 || (inquote
!= '\0' && *input_line_pointer
!= '\n'))
2143 if (inquote
== *input_line_pointer
)
2145 else if (inquote
== '\0')
2147 if (*input_line_pointer
== quote1
)
2149 else if (*input_line_pointer
== quote2
)
2152 sb_add_char (line
, *input_line_pointer
++);
2154 while (input_line_pointer
< buffer_limit
&& *input_line_pointer
== '\n')
2156 if (input_line_pointer
[-1] == '\n')
2157 bump_line_counters ();
2158 ++input_line_pointer
;
2163 /* Define a macro. This is an interface to macro.c, which is shared
2164 between gas and gasp. */
2177 as_where (&file
, &line
);
2180 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2181 sb_add_char (&s
, *input_line_pointer
++);
2184 if (line_label
!= NULL
)
2185 sb_add_string (&label
, S_GET_NAME (line_label
));
2187 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2189 as_bad_where (file
, line
, "%s", err
);
2192 if (line_label
!= NULL
)
2194 S_SET_SEGMENT (line_label
, undefined_section
);
2195 S_SET_VALUE (line_label
, 0);
2196 line_label
->sy_frag
= &zero_address_frag
;
2200 #ifdef NO_PSEUDO_DOT
2204 && hash_find (po_hash
, name
) != NULL
)
2207 && hash_find (po_hash
, name
+ 1) != NULL
))
2208 as_warn ("attempt to redefine pseudo-op `%s' ignored",
2215 /* Handle the .mexit pseudo-op, which immediately exits a macro
2222 cond_exit_macro (macro_nest
);
2223 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2226 /* Switch in and out of MRI mode. */
2234 on
= get_absolute_expression ();
2235 old_flag
= flag_mri
;
2249 #ifdef MRI_MODE_CHANGE
2251 MRI_MODE_CHANGE (on
);
2254 demand_empty_rest_of_line ();
2257 /* Handle changing the location counter. */
2260 do_org (segment
, exp
, fill
)
2265 if (segment
!= now_seg
&& segment
!= absolute_section
)
2266 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2267 segment_name (segment
), segment_name (now_seg
));
2269 if (now_seg
== absolute_section
)
2272 as_warn ("ignoring fill value in absolute section");
2273 if (exp
->X_op
!= O_constant
)
2275 as_bad ("only constant offsets supported in absolute section");
2276 exp
->X_add_number
= 0;
2278 abs_section_offset
= exp
->X_add_number
;
2284 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2285 exp
->X_add_number
, (char *) NULL
);
2294 register segT segment
;
2296 register long temp_fill
;
2298 /* The m68k MRI assembler has a different meaning for .org. It
2299 means to create an absolute section at a given address. We can't
2300 support that--use a linker script instead. */
2303 as_bad ("MRI style ORG pseudo-op not supported");
2304 ignore_rest_of_line ();
2308 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2309 thing as a sub-segment-relative origin. Any absolute origin is
2310 given a warning, then assumed to be segment-relative. Any
2311 segmented origin expression ("foo+42") had better be in the right
2312 segment or the .org is ignored.
2314 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2315 we never know sub-segment sizes when we are reading code. BSD
2316 will crash trying to emit negative numbers of filler bytes in
2317 certain .orgs. We don't crash, but see as-write for that code.
2319 Don't make frag if need_pass_2==1. */
2320 segment
= get_known_segmented_expression (&exp
);
2321 if (*input_line_pointer
== ',')
2323 input_line_pointer
++;
2324 temp_fill
= get_absolute_expression ();
2330 do_org (segment
, &exp
, temp_fill
);
2332 demand_empty_rest_of_line ();
2335 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2336 called by the obj-format routine which handles section changing
2337 when in MRI mode. It will create a new section, and return it. It
2338 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2339 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2340 flags will be set in the section. */
2354 name
= input_line_pointer
;
2355 if (! isdigit ((unsigned char) *name
))
2356 c
= get_symbol_end ();
2361 ++input_line_pointer
;
2363 while (isdigit ((unsigned char) *input_line_pointer
));
2364 c
= *input_line_pointer
;
2365 *input_line_pointer
= '\0';
2368 name
= xstrdup (name
);
2370 *input_line_pointer
= c
;
2372 seg
= subseg_new (name
, 0);
2374 if (*input_line_pointer
== ',')
2378 ++input_line_pointer
;
2379 align
= get_absolute_expression ();
2380 record_alignment (seg
, align
);
2384 if (*input_line_pointer
== ',')
2386 c
= *++input_line_pointer
;
2387 c
= toupper ((unsigned char) c
);
2388 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2391 as_bad ("unrecognized section type");
2392 ++input_line_pointer
;
2394 #ifdef BFD_ASSEMBLER
2398 flags
= SEC_NO_FLAGS
;
2400 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2401 else if (*type
== 'D' || *type
== 'M')
2402 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2403 else if (*type
== 'R')
2404 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2405 if (flags
!= SEC_NO_FLAGS
)
2407 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2408 as_warn ("error setting flags for \"%s\": %s",
2409 bfd_section_name (stdoutput
, seg
),
2410 bfd_errmsg (bfd_get_error ()));
2416 /* Ignore the HP type. */
2417 if (*input_line_pointer
== ',')
2418 input_line_pointer
+= 2;
2420 demand_empty_rest_of_line ();
2422 #else /* ! TC_M68K */
2431 name
= input_line_pointer
;
2432 c
= get_symbol_end ();
2434 name
= xstrdup (name
);
2436 *input_line_pointer
= c
;
2438 seg
= subseg_new (name
, 0);
2440 if (*input_line_pointer
!= ',')
2446 ++input_line_pointer
;
2448 sectype
= input_line_pointer
;
2449 c
= get_symbol_end ();
2450 if (*sectype
== '\0')
2452 else if (strcasecmp (sectype
, "text") == 0)
2454 else if (strcasecmp (sectype
, "data") == 0)
2456 else if (strcasecmp (sectype
, "romdata") == 0)
2459 as_warn ("unrecognized section type `%s'", sectype
);
2460 *input_line_pointer
= c
;
2463 if (*input_line_pointer
== ',')
2467 ++input_line_pointer
;
2469 seccmd
= input_line_pointer
;
2470 c
= get_symbol_end ();
2471 if (strcasecmp (seccmd
, "absolute") == 0)
2473 as_bad ("absolute sections are not supported");
2474 *input_line_pointer
= c
;
2475 ignore_rest_of_line ();
2478 else if (strcasecmp (seccmd
, "align") == 0)
2482 *input_line_pointer
= c
;
2483 align
= get_absolute_expression ();
2484 record_alignment (seg
, align
);
2488 as_warn ("unrecognized section command `%s'", seccmd
);
2489 *input_line_pointer
= c
;
2493 demand_empty_rest_of_line ();
2495 #else /* ! TC_I960 */
2496 /* The MRI assembler seems to use different forms of .sect for
2497 different targets. */
2499 #endif /* ! TC_I960 */
2500 #endif /* ! TC_M68K */
2503 /* Handle the .print pseudo-op. */
2512 s
= demand_copy_C_string (&len
);
2514 demand_empty_rest_of_line ();
2517 /* Handle the .purgem pseudo-op. */
2523 if (is_it_end_of_statement ())
2525 demand_empty_rest_of_line ();
2535 name
= input_line_pointer
;
2536 c
= get_symbol_end ();
2537 delete_macro (name
);
2538 *input_line_pointer
= c
;
2541 while (*input_line_pointer
++ == ',');
2543 --input_line_pointer
;
2544 demand_empty_rest_of_line ();
2547 /* Handle the .rept pseudo-op. */
2557 count
= get_absolute_expression ();
2560 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2562 as_bad ("rept without endr");
2568 sb_add_sb (&many
, &one
);
2572 input_scrub_include_sb (&many
, input_line_pointer
);
2574 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2577 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2578 this is .equiv, and it is an error if the symbol is already
2585 register char *name
;
2586 register char delim
;
2587 register char *end_name
;
2588 register symbolS
*symbolP
;
2591 * Especial apologies for the random logic:
2592 * this just grew, and could be parsed much more simply!
2595 name
= input_line_pointer
;
2596 delim
= get_symbol_end ();
2597 end_name
= input_line_pointer
;
2601 if (*input_line_pointer
!= ',')
2604 as_bad ("Expected comma after name \"%s\"", name
);
2606 ignore_rest_of_line ();
2610 input_line_pointer
++;
2613 if (name
[0] == '.' && name
[1] == '\0')
2615 /* Turn '. = mumble' into a .org mumble */
2616 register segT segment
;
2619 segment
= get_known_segmented_expression (&exp
);
2622 do_org (segment
, &exp
, 0);
2628 if ((symbolP
= symbol_find (name
)) == NULL
2629 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2631 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2633 /* "set" symbols are local unless otherwise specified. */
2634 SF_SET_LOCAL (symbolP
);
2635 #endif /* OBJ_COFF */
2637 } /* make a new symbol */
2639 symbol_table_insert (symbolP
);
2644 && S_IS_DEFINED (symbolP
)
2645 && S_GET_SEGMENT (symbolP
) != reg_section
)
2646 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
2648 pseudo_set (symbolP
);
2649 demand_empty_rest_of_line ();
2663 #ifdef md_flush_pending_output
2664 md_flush_pending_output ();
2668 stop
= mri_comment_field (&stopc
);
2670 /* In m68k MRI mode, we need to align to a word boundary, unless
2672 if (flag_m68k_mri
&& mult
> 1)
2674 if (now_seg
== absolute_section
)
2676 abs_section_offset
+= abs_section_offset
& 1;
2677 if (line_label
!= NULL
)
2678 S_SET_VALUE (line_label
, abs_section_offset
);
2680 else if (mri_common_symbol
!= NULL
)
2684 val
= S_GET_VALUE (mri_common_symbol
);
2687 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2688 if (line_label
!= NULL
)
2690 know (line_label
->sy_value
.X_op
== O_symbol
);
2691 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2692 line_label
->sy_value
.X_add_number
+= 1;
2698 do_align (1, (char *) NULL
, 0, 0);
2699 if (line_label
!= NULL
)
2701 line_label
->sy_frag
= frag_now
;
2702 S_SET_VALUE (line_label
, frag_now_fix ());
2712 if (*input_line_pointer
== ',')
2714 ++input_line_pointer
;
2719 val
.X_op
= O_constant
;
2720 val
.X_add_number
= 0;
2723 if (val
.X_op
!= O_constant
2724 || val
.X_add_number
< - 0x80
2725 || val
.X_add_number
> 0xff
2726 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2728 if (exp
.X_op
!= O_constant
)
2729 as_bad ("Unsupported variable size or fill value");
2736 bytes
= mult
* exp
.X_add_number
;
2737 for (i
= 0; i
< exp
.X_add_number
; i
++)
2738 emit_expr (&val
, mult
);
2743 if (exp
.X_op
== O_constant
)
2747 repeat
= exp
.X_add_number
;
2753 if (! flag_mri
|| repeat
< 0)
2754 as_warn (".space repeat count is %s, ignored",
2755 repeat
? "negative" : "zero");
2759 /* If we are in the absolute section, just bump the offset. */
2760 if (now_seg
== absolute_section
)
2762 abs_section_offset
+= repeat
;
2766 /* If we are secretly in an MRI common section, then
2767 creating space just increases the size of the common
2769 if (mri_common_symbol
!= NULL
)
2771 S_SET_VALUE (mri_common_symbol
,
2772 S_GET_VALUE (mri_common_symbol
) + repeat
);
2777 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2778 (offsetT
) repeat
, (char *) 0);
2782 if (now_seg
== absolute_section
)
2784 as_bad ("space allocation too complex in absolute section");
2785 subseg_set (text_section
, 0);
2787 if (mri_common_symbol
!= NULL
)
2789 as_bad ("space allocation too complex in common section");
2790 mri_common_symbol
= NULL
;
2793 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2794 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
2798 *p
= val
.X_add_number
;
2803 /* In MRI mode, after an odd number of bytes, we must align to an
2804 even word boundary, unless the next instruction is a dc.b, ds.b
2806 if (flag_mri
&& (bytes
& 1) != 0)
2807 mri_pending_align
= 1;
2810 mri_comment_end (stop
, stopc
);
2812 demand_empty_rest_of_line ();
2815 /* This is like s_space, but the value is a floating point number with
2816 the given precision. This is for the MRI dcb.s pseudo-op and
2820 s_float_space (float_type
)
2825 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2830 stop
= mri_comment_field (&stopc
);
2832 count
= get_absolute_expression ();
2835 if (*input_line_pointer
!= ',')
2837 as_bad ("missing value");
2839 mri_comment_end (stop
, stopc
);
2840 ignore_rest_of_line ();
2844 ++input_line_pointer
;
2848 /* Skip any 0{letter} that may be present. Don't even check if the
2849 * letter is legal. */
2850 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2851 input_line_pointer
+= 2;
2853 /* Accept :xxxx, where the x's are hex digits, for a floating point
2854 with the exact digits specified. */
2855 if (input_line_pointer
[0] == ':')
2857 flen
= hex_float (float_type
, temp
);
2861 mri_comment_end (stop
, stopc
);
2862 ignore_rest_of_line ();
2870 err
= md_atof (float_type
, temp
, &flen
);
2871 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2875 as_bad ("Bad floating literal: %s", err
);
2877 mri_comment_end (stop
, stopc
);
2878 ignore_rest_of_line ();
2883 while (--count
>= 0)
2887 p
= frag_more (flen
);
2888 memcpy (p
, temp
, (unsigned int) flen
);
2892 mri_comment_end (stop
, stopc
);
2894 demand_empty_rest_of_line ();
2897 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2907 stop
= mri_comment_field (&stopc
);
2908 abs_section_offset
= get_absolute_expression ();
2909 subseg_set (absolute_section
, 0);
2911 mri_comment_end (stop
, stopc
);
2912 demand_empty_rest_of_line ();
2921 temp
= get_absolute_expression ();
2922 subseg_set (text_section
, (subsegT
) temp
);
2923 demand_empty_rest_of_line ();
2925 const_flag
&= ~IN_DEFAULT_SECTION
;
2931 demand_empty_rest_of_line ()
2934 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2936 input_line_pointer
++;
2940 ignore_rest_of_line ();
2942 /* Return having already swallowed end-of-line. */
2943 } /* Return pointing just after end-of-line. */
2946 ignore_rest_of_line () /* For suspect lines: gives warning. */
2948 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2950 if (isprint (*input_line_pointer
))
2951 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2952 *input_line_pointer
);
2954 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2955 *input_line_pointer
);
2956 while (input_line_pointer
< buffer_limit
2957 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2959 input_line_pointer
++;
2962 input_line_pointer
++; /* Return pointing just after end-of-line. */
2963 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2969 * In: Pointer to a symbol.
2970 * Input_line_pointer->expression.
2972 * Out: Input_line_pointer->just after any whitespace after expression.
2973 * Tried to set symbol to value of expression.
2974 * Will change symbols type, value, and frag;
2977 pseudo_set (symbolP
)
2981 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2983 #endif /* OBJ_AOUT or OBJ_BOUT */
2985 know (symbolP
); /* NULL pointer is logic error. */
2986 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2987 ext
= S_IS_EXTERNAL (symbolP
);
2988 #endif /* OBJ_AOUT or OBJ_BOUT */
2990 (void) expression (&exp
);
2992 if (exp
.X_op
== O_illegal
)
2993 as_bad ("illegal expression; zero assumed");
2994 else if (exp
.X_op
== O_absent
)
2995 as_bad ("missing expression; zero assumed");
2996 else if (exp
.X_op
== O_big
)
2997 as_bad ("%s number invalid; zero assumed",
2998 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2999 else if (exp
.X_op
== O_subtract
3000 && (S_GET_SEGMENT (exp
.X_add_symbol
)
3001 == S_GET_SEGMENT (exp
.X_op_symbol
))
3002 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3003 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
3005 exp
.X_op
= O_constant
;
3006 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3007 - S_GET_VALUE (exp
.X_op_symbol
));
3015 exp
.X_add_number
= 0;
3018 S_SET_SEGMENT (symbolP
, absolute_section
);
3019 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3021 S_SET_EXTERNAL (symbolP
);
3023 S_CLEAR_EXTERNAL (symbolP
);
3024 #endif /* OBJ_AOUT or OBJ_BOUT */
3025 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3026 symbolP
->sy_frag
= &zero_address_frag
;
3030 S_SET_SEGMENT (symbolP
, reg_section
);
3031 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3032 symbolP
->sy_frag
= &zero_address_frag
;
3036 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
3037 || exp
.X_add_number
!= 0)
3038 symbolP
->sy_value
= exp
;
3041 symbolS
*s
= exp
.X_add_symbol
;
3043 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
3044 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3046 S_SET_EXTERNAL (symbolP
);
3048 S_CLEAR_EXTERNAL (symbolP
);
3049 #endif /* OBJ_AOUT or OBJ_BOUT */
3050 S_SET_VALUE (symbolP
,
3051 exp
.X_add_number
+ S_GET_VALUE (s
));
3052 symbolP
->sy_frag
= s
->sy_frag
;
3053 copy_symbol_attributes (symbolP
, s
);
3058 /* The value is some complex expression.
3059 FIXME: Should we set the segment to anything? */
3060 symbolP
->sy_value
= exp
;
3068 * CONStruct more frag of .bytes, or .words etc.
3069 * Should need_pass_2 be 1 then emit no frag(s).
3070 * This understands EXPRESSIONS.
3074 * This has a split personality. We use expression() to read the
3075 * value. We can detect if the value won't fit in a byte or word.
3076 * But we can't detect if expression() discarded significant digits
3077 * in the case of a long. Not worth the crocks required to fix it.
3080 /* Select a parser for cons expressions. */
3082 /* Some targets need to parse the expression in various fancy ways.
3083 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3084 (for example, the HPPA does this). Otherwise, you can define
3085 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3086 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3087 are defined, which is the normal case, then only simple expressions
3091 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3093 #ifndef TC_PARSE_CONS_EXPRESSION
3094 #ifdef BITFIELD_CONS_EXPRESSIONS
3095 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3097 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3099 #ifdef REPEAT_CONS_EXPRESSIONS
3100 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3102 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3105 /* If we haven't gotten one yet, just call expression. */
3106 #ifndef TC_PARSE_CONS_EXPRESSION
3107 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3111 /* worker to do .byte etc statements */
3112 /* clobbers input_line_pointer, checks */
3115 cons_worker (nbytes
, rva
)
3116 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3124 #ifdef md_flush_pending_output
3125 md_flush_pending_output ();
3129 stop
= mri_comment_field (&stopc
);
3131 if (is_it_end_of_statement ())
3134 mri_comment_end (stop
, stopc
);
3135 demand_empty_rest_of_line ();
3139 #ifdef md_cons_align
3140 md_cons_align (nbytes
);
3147 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3149 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3153 if (exp
.X_op
== O_symbol
)
3154 exp
.X_op
= O_symbol_rva
;
3156 as_fatal ("rva without symbol");
3158 emit_expr (&exp
, (unsigned int) nbytes
);
3161 while (*input_line_pointer
++ == ',');
3163 /* In MRI mode, after an odd number of bytes, we must align to an
3164 even word boundary, unless the next instruction is a dc.b, ds.b
3166 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3167 mri_pending_align
= 1;
3169 input_line_pointer
--; /* Put terminator back into stream. */
3172 mri_comment_end (stop
, stopc
);
3174 demand_empty_rest_of_line ();
3182 cons_worker (size
, 0);
3189 cons_worker (size
, 1);
3193 /* Put the contents of expression EXP into the object file using
3194 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3197 emit_expr (exp
, nbytes
)
3199 unsigned int nbytes
;
3203 valueT extra_digit
= 0;
3205 /* Don't do anything if we are going to make another pass. */
3211 /* Allow `.word 0' in the absolute section. */
3212 if (now_seg
== absolute_section
)
3214 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3215 as_bad ("attempt to store value in absolute section");
3216 abs_section_offset
+= nbytes
;
3220 /* Handle a negative bignum. */
3222 && exp
->X_add_number
== 0
3223 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3224 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3227 unsigned long carry
;
3229 exp
= &exp
->X_add_symbol
->sy_value
;
3231 /* Negate the bignum: one's complement each digit and add 1. */
3233 for (i
= 0; i
< exp
->X_add_number
; i
++)
3237 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3240 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3241 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3244 /* We can ignore any carry out, because it will be handled by
3245 extra_digit if it is needed. */
3247 extra_digit
= (valueT
) -1;
3251 if (op
== O_absent
|| op
== O_illegal
)
3253 as_warn ("zero assumed for missing expression");
3254 exp
->X_add_number
= 0;
3257 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3259 as_bad ("floating point number invalid; zero assumed");
3260 exp
->X_add_number
= 0;
3263 else if (op
== O_register
)
3265 as_warn ("register value used as expression");
3269 p
= frag_more ((int) nbytes
);
3271 #ifndef WORKING_DOT_WORD
3272 /* If we have the difference of two symbols in a word, save it on
3273 the broken_words list. See the code in write.c. */
3274 if (op
== O_subtract
&& nbytes
== 2)
3276 struct broken_word
*x
;
3278 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3279 x
->next_broken_word
= broken_words
;
3282 x
->word_goes_here
= p
;
3284 x
->add
= exp
->X_add_symbol
;
3285 x
->sub
= exp
->X_op_symbol
;
3286 x
->addnum
= exp
->X_add_number
;
3293 /* If we have an integer, but the number of bytes is too large to
3294 pass to md_number_to_chars, handle it as a bignum. */
3295 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3300 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3301 extra_digit
= (valueT
) -1;
3302 val
= (valueT
) exp
->X_add_number
;
3306 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3307 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3311 op
= exp
->X_op
= O_big
;
3312 exp
->X_add_number
= gencnt
;
3315 if (op
== O_constant
)
3317 register valueT get
;
3318 register valueT use
;
3319 register valueT mask
;
3321 register valueT unmask
;
3323 /* JF << of >= number of bits in the object is undefined. In
3324 particular SPARC (Sun 4) has problems */
3325 if (nbytes
>= sizeof (valueT
))
3328 if (nbytes
> sizeof (valueT
))
3331 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3335 /* Don't store these bits. */
3336 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3337 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3340 unmask
= ~mask
; /* Do store these bits. */
3343 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3344 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3347 get
= exp
->X_add_number
;
3349 if ((get
& mask
) != 0
3350 && ((get
& mask
) != mask
3351 || (get
& hibit
) == 0))
3352 { /* Leading bits contain both 0s & 1s. */
3353 as_warn ("Value 0x%lx truncated to 0x%lx.",
3354 (unsigned long) get
, (unsigned long) use
);
3356 /* put bytes in right order. */
3357 md_number_to_chars (p
, use
, (int) nbytes
);
3359 else if (op
== O_big
)
3362 LITTLENUM_TYPE
*nums
;
3364 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3366 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3369 as_warn ("Bignum truncated to %d bytes", nbytes
);
3373 if (target_big_endian
)
3375 while (nbytes
> size
)
3377 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3378 nbytes
-= CHARS_PER_LITTLENUM
;
3379 p
+= CHARS_PER_LITTLENUM
;
3382 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3386 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3387 size
-= CHARS_PER_LITTLENUM
;
3388 p
+= CHARS_PER_LITTLENUM
;
3393 nums
= generic_bignum
;
3396 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3398 size
-= CHARS_PER_LITTLENUM
;
3399 p
+= CHARS_PER_LITTLENUM
;
3400 nbytes
-= CHARS_PER_LITTLENUM
;
3405 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3406 nbytes
-= CHARS_PER_LITTLENUM
;
3407 p
+= CHARS_PER_LITTLENUM
;
3413 memset (p
, 0, nbytes
);
3415 /* Now we need to generate a fixS to record the symbol value.
3416 This is easy for BFD. For other targets it can be more
3417 complex. For very complex cases (currently, the HPPA and
3418 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3419 want. For simpler cases, you can define TC_CONS_RELOC to be
3420 the name of the reloc code that should be stored in the fixS.
3421 If neither is defined, the code uses NO_RELOC if it is
3422 defined, and otherwise uses 0. */
3424 #ifdef BFD_ASSEMBLER
3425 #ifdef TC_CONS_FIX_NEW
3426 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3429 bfd_reloc_code_real_type r
;
3446 as_bad ("unsupported BFD relocation size %u", nbytes
);
3450 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3455 #ifdef TC_CONS_FIX_NEW
3456 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3458 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3459 it is defined, otherwise use NO_RELOC if it is defined,
3461 #ifndef TC_CONS_RELOC
3463 #define TC_CONS_RELOC NO_RELOC
3465 #define TC_CONS_RELOC 0
3468 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3470 #endif /* TC_CONS_FIX_NEW */
3471 #endif /* BFD_ASSEMBLER */
3475 #ifdef BITFIELD_CONS_EXPRESSIONS
3477 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3478 w:x,y:z, where w and y are bitwidths and x and y are values. They
3479 then pack them all together. We do a little better in that we allow
3480 them in words, longs, etc. and we'll pack them in target byte order
3483 The rules are: pack least significat bit first, if a field doesn't
3484 entirely fit, put it in the next unit. Overflowing the bitfield is
3485 explicitly *not* even a warning. The bitwidth should be considered
3488 To use this function the tc-XXX.h file should define
3489 BITFIELD_CONS_EXPRESSIONS. */
3492 parse_bitfield_cons (exp
, nbytes
)
3494 unsigned int nbytes
;
3496 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3497 char *hold
= input_line_pointer
;
3499 (void) expression (exp
);
3501 if (*input_line_pointer
== ':')
3507 unsigned long width
;
3509 if (*input_line_pointer
!= ':')
3511 input_line_pointer
= hold
;
3513 } /* next piece is not a bitfield */
3515 /* In the general case, we can't allow
3516 full expressions with symbol
3517 differences and such. The relocation
3518 entries for symbols not defined in this
3519 assembly would require arbitrary field
3520 widths, positions, and masks which most
3521 of our current object formats don't
3524 In the specific case where a symbol
3525 *is* defined in this assembly, we
3526 *could* build fixups and track it, but
3527 this could lead to confusion for the
3528 backends. I'm lazy. I'll take any
3529 SEG_ABSOLUTE. I think that means that
3530 you can use a previous .set or
3531 .equ type symbol. xoxorich. */
3533 if (exp
->X_op
== O_absent
)
3535 as_warn ("using a bit field width of zero");
3536 exp
->X_add_number
= 0;
3537 exp
->X_op
= O_constant
;
3538 } /* implied zero width bitfield */
3540 if (exp
->X_op
!= O_constant
)
3542 *input_line_pointer
= '\0';
3543 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3544 *input_line_pointer
= ':';
3545 demand_empty_rest_of_line ();
3549 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3551 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3552 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3553 width
= BITS_PER_CHAR
* nbytes
;
3556 if (width
> bits_available
)
3558 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3559 input_line_pointer
= hold
;
3560 exp
->X_add_number
= value
;
3564 hold
= ++input_line_pointer
; /* skip ':' */
3566 (void) expression (exp
);
3567 if (exp
->X_op
!= O_constant
)
3569 char cache
= *input_line_pointer
;
3571 *input_line_pointer
= '\0';
3572 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3573 *input_line_pointer
= cache
;
3574 demand_empty_rest_of_line ();
3578 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3579 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3581 if ((bits_available
-= width
) == 0
3582 || is_it_end_of_statement ()
3583 || *input_line_pointer
!= ',')
3586 } /* all the bitfields we're gonna get */
3588 hold
= ++input_line_pointer
;
3589 (void) expression (exp
);
3590 } /* forever loop */
3592 exp
->X_add_number
= value
;
3593 exp
->X_op
= O_constant
;
3594 exp
->X_unsigned
= 1;
3595 } /* if looks like a bitfield */
3596 } /* parse_bitfield_cons() */
3598 #endif /* BITFIELD_CONS_EXPRESSIONS */
3600 /* Handle an MRI style string expression. */
3603 parse_mri_cons (exp
, nbytes
)
3605 unsigned int nbytes
;
3607 if (*input_line_pointer
!= '\''
3608 && (input_line_pointer
[1] != '\''
3609 || (*input_line_pointer
!= 'A'
3610 && *input_line_pointer
!= 'E')))
3611 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3615 unsigned int result
= 0;
3617 /* An MRI style string. Cut into as many bytes as will fit into
3618 a nbyte chunk, left justify if necessary, and separate with
3619 commas so we can try again later. */
3620 if (*input_line_pointer
== 'A')
3621 ++input_line_pointer
;
3622 else if (*input_line_pointer
== 'E')
3624 as_bad ("EBCDIC constants are not supported");
3625 ++input_line_pointer
;
3628 input_line_pointer
++;
3629 for (scan
= 0; scan
< nbytes
; scan
++)
3631 if (*input_line_pointer
== '\'')
3633 if (input_line_pointer
[1] == '\'')
3635 input_line_pointer
++;
3640 result
= (result
<< 8) | (*input_line_pointer
++);
3644 while (scan
< nbytes
)
3649 /* Create correct expression */
3650 exp
->X_op
= O_constant
;
3651 exp
->X_add_number
= result
;
3652 /* Fake it so that we can read the next char too */
3653 if (input_line_pointer
[0] != '\'' ||
3654 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3656 input_line_pointer
-= 2;
3657 input_line_pointer
[0] = ',';
3658 input_line_pointer
[1] = '\'';
3661 input_line_pointer
++;
3665 #ifdef REPEAT_CONS_EXPRESSIONS
3667 /* Parse a repeat expression for cons. This is used by the MIPS
3668 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3669 object file COUNT times.
3671 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3674 parse_repeat_cons (exp
, nbytes
)
3676 unsigned int nbytes
;
3683 if (*input_line_pointer
!= ':')
3685 /* No repeat count. */
3689 ++input_line_pointer
;
3690 expression (&count
);
3691 if (count
.X_op
!= O_constant
3692 || count
.X_add_number
<= 0)
3694 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3698 /* The cons function is going to output this expression once. So we
3699 output it count - 1 times. */
3700 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3701 emit_expr (exp
, nbytes
);
3704 #endif /* REPEAT_CONS_EXPRESSIONS */
3706 /* Parse a floating point number represented as a hex constant. This
3707 permits users to specify the exact bits they want in the floating
3711 hex_float (float_type
, bytes
)
3745 as_bad ("Unknown floating type type '%c'", float_type
);
3749 /* It would be nice if we could go through expression to parse the
3750 hex constant, but if we get a bignum it's a pain to sort it into
3751 the buffer correctly. */
3753 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3757 /* The MRI assembler accepts arbitrary underscores strewn about
3758 through the hex constant, so we ignore them as well. */
3759 if (*input_line_pointer
== '_')
3761 ++input_line_pointer
;
3767 as_warn ("Floating point constant too large");
3770 d
= hex_value (*input_line_pointer
) << 4;
3771 ++input_line_pointer
;
3772 while (*input_line_pointer
== '_')
3773 ++input_line_pointer
;
3774 if (hex_p (*input_line_pointer
))
3776 d
+= hex_value (*input_line_pointer
);
3777 ++input_line_pointer
;
3779 if (target_big_endian
)
3782 bytes
[length
- i
- 1] = d
;
3788 if (target_big_endian
)
3789 memset (bytes
+ i
, 0, length
- i
);
3791 memset (bytes
, 0, length
- i
);
3800 * CONStruct some more frag chars of .floats .ffloats etc.
3801 * Makes 0 or more new frags.
3802 * If need_pass_2 == 1, no frags are emitted.
3803 * This understands only floating literals, not expressions. Sorry.
3805 * A floating constant is defined by atof_generic(), except it is preceded
3806 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3807 * reading, I decided to be incompatible. This always tries to give you
3808 * rounded bits to the precision of the pseudo-op. Former AS did premature
3809 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3810 * a choice of 2 flavours of noise according to which of 2 floating-point
3811 * scanners you directed AS to use.
3813 * In: input_line_pointer->whitespace before, or '0' of flonum.
3818 float_cons (float_type
)
3819 /* Clobbers input_line-pointer, checks end-of-line. */
3820 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3823 int length
; /* Number of chars in an object. */
3824 register char *err
; /* Error from scanning floating literal. */
3825 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3827 if (is_it_end_of_statement ())
3829 demand_empty_rest_of_line ();
3833 #ifdef md_flush_pending_output
3834 md_flush_pending_output ();
3839 /* input_line_pointer->1st char of a flonum (we hope!). */
3842 /* Skip any 0{letter} that may be present. Don't even check if the
3843 * letter is legal. Someone may invent a "z" format and this routine
3844 * has no use for such information. Lusers beware: you get
3845 * diagnostics if your input is ill-conditioned.
3847 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3848 input_line_pointer
+= 2;
3850 /* Accept :xxxx, where the x's are hex digits, for a floating
3851 point with the exact digits specified. */
3852 if (input_line_pointer
[0] == ':')
3854 ++input_line_pointer
;
3855 length
= hex_float (float_type
, temp
);
3858 ignore_rest_of_line ();
3864 err
= md_atof (float_type
, temp
, &length
);
3865 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3869 as_bad ("Bad floating literal: %s", err
);
3870 ignore_rest_of_line ();
3881 #ifdef REPEAT_CONS_EXPRESSIONS
3882 if (*input_line_pointer
== ':')
3884 expressionS count_exp
;
3886 ++input_line_pointer
;
3887 expression (&count_exp
);
3888 if (count_exp
.X_op
!= O_constant
3889 || count_exp
.X_add_number
<= 0)
3891 as_warn ("unresolvable or nonpositive repeat count; using 1");
3894 count
= count_exp
.X_add_number
;
3898 while (--count
>= 0)
3900 p
= frag_more (length
);
3901 memcpy (p
, temp
, (unsigned int) length
);
3906 while (*input_line_pointer
++ == ',');
3908 --input_line_pointer
; /* Put terminator back into stream. */
3909 demand_empty_rest_of_line ();
3910 } /* float_cons() */
3912 /* Return the size of a LEB128 value */
3915 sizeof_sleb128 (value
)
3918 register int size
= 0;
3919 register unsigned byte
;
3923 byte
= (value
& 0x7f);
3924 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
3925 Fortunately, we can structure things so that the extra work reduces
3926 to a noop on systems that do things "properly". */
3927 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
3930 while (!(((value
== 0) && ((byte
& 0x40) == 0))
3931 || ((value
== -1) && ((byte
& 0x40) != 0))));
3937 sizeof_uleb128 (value
)
3940 register int size
= 0;
3941 register unsigned byte
;
3945 byte
= (value
& 0x7f);
3955 sizeof_leb128 (value
, sign
)
3960 return sizeof_sleb128 ((offsetT
) value
);
3962 return sizeof_uleb128 (value
);
3965 /* Output a LEB128 value. */
3968 output_sleb128 (p
, value
)
3972 register char *orig
= p
;
3977 unsigned byte
= (value
& 0x7f);
3979 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
3980 Fortunately, we can structure things so that the extra work reduces
3981 to a noop on systems that do things "properly". */
3982 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
3984 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
3985 || ((value
== -1) && ((byte
& 0x40) != 0))));
3997 output_uleb128 (p
, value
)
4005 unsigned byte
= (value
& 0x7f);
4008 /* More bytes to follow. */
4019 output_leb128 (p
, value
, sign
)
4025 return output_sleb128 (p
, (offsetT
) value
);
4027 return output_uleb128 (p
, value
);
4030 /* Do the same for bignums. We combine sizeof with output here in that
4031 we don't output for NULL values of P. It isn't really as critical as
4032 for "normal" values that this be streamlined. */
4035 output_big_sleb128 (p
, bignum
, size
)
4037 LITTLENUM_TYPE
*bignum
;
4045 /* Strip leading sign extensions off the bignum. */
4046 while (size
> 0 && bignum
[size
-1] == (LITTLENUM_TYPE
)-1)
4051 if (loaded
< 7 && size
> 0)
4053 val
|= (*bignum
<< loaded
);
4054 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4065 if ((val
== 0 && (byte
& 0x40) == 0)
4066 || (~(val
| ~(((valueT
)1 << loaded
) - 1)) == 0
4067 && (byte
& 0x40) != 0))
4075 while (byte
& 0x80);
4081 output_big_uleb128 (p
, bignum
, size
)
4083 LITTLENUM_TYPE
*bignum
;
4091 /* Strip leading zeros off the bignum. */
4092 /* XXX: Is this needed? */
4093 while (size
> 0 && bignum
[size
-1] == 0)
4098 if (loaded
< 7 && size
> 0)
4100 val
|= (*bignum
<< loaded
);
4101 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4110 if (size
> 0 || val
)
4117 while (byte
& 0x80);
4123 output_big_leb128 (p
, bignum
, size
, sign
)
4125 LITTLENUM_TYPE
*bignum
;
4129 return output_big_sleb128 (p
, bignum
, size
);
4131 return output_big_uleb128 (p
, bignum
, size
);
4134 /* Generate the appropriate fragments for a given expression to emit a
4138 emit_leb128_expr(exp
, sign
)
4142 operatorT op
= exp
->X_op
;
4144 if (op
== O_absent
|| op
== O_illegal
)
4146 as_warn ("zero assumed for missing expression");
4147 exp
->X_add_number
= 0;
4150 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4152 as_bad ("floating point number invalid; zero assumed");
4153 exp
->X_add_number
= 0;
4156 else if (op
== O_register
)
4158 as_warn ("register value used as expression");
4162 if (op
== O_constant
)
4164 /* If we've got a constant, emit the thing directly right now. */
4166 valueT value
= exp
->X_add_number
;
4170 size
= sizeof_leb128 (value
, sign
);
4171 p
= frag_more (size
);
4172 output_leb128 (p
, value
, sign
);
4174 else if (op
== O_big
)
4176 /* O_big is a different sort of constant. */
4181 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
4182 p
= frag_more (size
);
4183 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
4187 /* Otherwise, we have to create a variable sized fragment and
4188 resolve things later. */
4190 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
)0), 0, sign
,
4191 make_expr_symbol (exp
), 0, (char *) NULL
);
4195 /* Parse the .sleb128 and .uleb128 pseudos. */
4205 emit_leb128_expr (&exp
, sign
);
4206 } while (*input_line_pointer
++ == ',');
4208 input_line_pointer
--;
4209 demand_empty_rest_of_line ();
4215 * We read 0 or more ',' seperated, double-quoted strings.
4217 * Caller should have checked need_pass_2 is FALSE because we don't check it.
4222 stringer (append_zero
) /* Worker to do .ascii etc statements. */
4223 /* Checks end-of-line. */
4224 register int append_zero
; /* 0: don't append '\0', else 1 */
4226 register unsigned int c
;
4228 #ifdef md_flush_pending_output
4229 md_flush_pending_output ();
4233 * The following awkward logic is to parse ZERO or more strings,
4234 * comma seperated. Recall a string expression includes spaces
4235 * before the opening '\"' and spaces after the closing '\"'.
4236 * We fake a leading ',' if there is (supposed to be)
4237 * a 1st, expression. We keep demanding expressions for each
4240 if (is_it_end_of_statement ())
4242 c
= 0; /* Skip loop. */
4243 ++input_line_pointer
; /* Compensate for end of loop. */
4247 c
= ','; /* Do loop. */
4249 while (c
== ',' || c
== '<' || c
== '"')
4252 switch (*input_line_pointer
)
4255 ++input_line_pointer
; /*->1st char of string. */
4256 while (is_a_char (c
= next_char_of_string ()))
4258 FRAG_APPEND_1_CHAR (c
);
4262 FRAG_APPEND_1_CHAR (0);
4264 know (input_line_pointer
[-1] == '\"');
4267 input_line_pointer
++;
4268 c
= get_single_number ();
4269 FRAG_APPEND_1_CHAR (c
);
4270 if (*input_line_pointer
!= '>')
4272 as_bad ("Expected <nn>");
4274 input_line_pointer
++;
4277 input_line_pointer
++;
4281 c
= *input_line_pointer
;
4284 demand_empty_rest_of_line ();
4287 /* FIXME-SOMEDAY: I had trouble here on characters with the
4288 high bits set. We'll probably also have trouble with
4289 multibyte chars, wide chars, etc. Also be careful about
4290 returning values bigger than 1 byte. xoxorich. */
4293 next_char_of_string ()
4295 register unsigned int c
;
4297 c
= *input_line_pointer
++ & CHAR_MASK
;
4305 as_warn ("Unterminated string: Newline inserted.");
4306 bump_line_counters ();
4309 #ifndef NO_STRING_ESCAPES
4311 switch (c
= *input_line_pointer
++)
4339 break; /* As itself. */
4355 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
4357 number
= number
* 8 + c
- '0';
4361 --input_line_pointer
;
4370 c
= *input_line_pointer
++;
4371 while (isxdigit (c
))
4374 number
= number
* 16 + c
- '0';
4375 else if (isupper (c
))
4376 number
= number
* 16 + c
- 'A' + 10;
4378 number
= number
* 16 + c
- 'a' + 10;
4379 c
= *input_line_pointer
++;
4382 --input_line_pointer
;
4387 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4388 as_warn ("Unterminated string: Newline inserted.");
4390 bump_line_counters ();
4395 #ifdef ONLY_STANDARD_ESCAPES
4396 as_bad ("Bad escaped character in string, '?' assumed");
4398 #endif /* ONLY_STANDARD_ESCAPES */
4401 } /* switch on escaped char */
4403 #endif /* ! defined (NO_STRING_ESCAPES) */
4407 } /* switch on char */
4409 } /* next_char_of_string() */
4412 get_segmented_expression (expP
)
4413 register expressionS
*expP
;
4415 register segT retval
;
4417 retval
= expression (expP
);
4418 if (expP
->X_op
== O_illegal
4419 || expP
->X_op
== O_absent
4420 || expP
->X_op
== O_big
)
4422 as_bad ("expected address expression; zero assumed");
4423 expP
->X_op
= O_constant
;
4424 expP
->X_add_number
= 0;
4425 retval
= absolute_section
;
4431 get_known_segmented_expression (expP
)
4432 register expressionS
*expP
;
4434 register segT retval
;
4436 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4438 /* There is no easy way to extract the undefined symbol from the
4440 if (expP
->X_add_symbol
!= NULL
4441 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4442 as_warn ("symbol \"%s\" undefined; zero assumed",
4443 S_GET_NAME (expP
->X_add_symbol
));
4445 as_warn ("some symbol undefined; zero assumed");
4446 retval
= absolute_section
;
4447 expP
->X_op
= O_constant
;
4448 expP
->X_add_number
= 0;
4450 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4452 } /* get_known_segmented_expression() */
4455 get_absolute_expression ()
4460 if (exp
.X_op
!= O_constant
)
4462 if (exp
.X_op
!= O_absent
)
4463 as_bad ("bad or irreducible absolute expression; zero assumed");
4464 exp
.X_add_number
= 0;
4466 return exp
.X_add_number
;
4469 char /* return terminator */
4470 get_absolute_expression_and_terminator (val_pointer
)
4471 long *val_pointer
; /* return value of expression */
4473 /* FIXME: val_pointer should probably be offsetT *. */
4474 *val_pointer
= (long) get_absolute_expression ();
4475 return (*input_line_pointer
++);
4479 * demand_copy_C_string()
4481 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4482 * Give a warning if that happens.
4485 demand_copy_C_string (len_pointer
)
4490 if ((s
= demand_copy_string (len_pointer
)) != 0)
4494 for (len
= *len_pointer
; len
> 0; len
--)
4501 as_bad ("This string may not contain \'\\0\'");
4509 * demand_copy_string()
4511 * Demand string, but return a safe (=private) copy of the string.
4512 * Return NULL if we can't read a string here.
4515 demand_copy_string (lenP
)
4518 register unsigned int c
;
4524 if (*input_line_pointer
== '\"')
4526 input_line_pointer
++; /* Skip opening quote. */
4528 while (is_a_char (c
= next_char_of_string ()))
4530 obstack_1grow (¬es
, c
);
4533 /* JF this next line is so demand_copy_C_string will return a
4534 null terminated string. */
4535 obstack_1grow (¬es
, '\0');
4536 retval
= obstack_finish (¬es
);
4540 as_warn ("Missing string");
4542 ignore_rest_of_line ();
4546 } /* demand_copy_string() */
4549 * is_it_end_of_statement()
4551 * In: Input_line_pointer->next character.
4553 * Do: Skip input_line_pointer over all whitespace.
4555 * Out: 1 if input_line_pointer->end-of-line.
4558 is_it_end_of_statement ()
4561 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4562 } /* is_it_end_of_statement() */
4565 equals (sym_name
, reassign
)
4569 register symbolS
*symbolP
; /* symbol we are working with */
4573 input_line_pointer
++;
4574 if (*input_line_pointer
== '=')
4575 input_line_pointer
++;
4577 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4578 input_line_pointer
++;
4581 stop
= mri_comment_field (&stopc
);
4583 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4585 /* Turn '. = mumble' into a .org mumble */
4586 register segT segment
;
4589 segment
= get_known_segmented_expression (&exp
);
4591 do_org (segment
, &exp
, 0);
4595 symbolP
= symbol_find_or_make (sym_name
);
4596 /* Permit register names to be redefined. */
4598 && S_IS_DEFINED (symbolP
)
4599 && S_GET_SEGMENT (symbolP
) != reg_section
)
4600 as_bad ("symbol `%s' already defined", S_GET_NAME (symbolP
));
4601 pseudo_set (symbolP
);
4605 mri_comment_end (stop
, stopc
);
4608 /* .include -- include a file at this point. */
4621 if (! flag_m68k_mri
)
4622 filename
= demand_copy_string (&i
);
4627 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4628 && *input_line_pointer
!= ' '
4629 && *input_line_pointer
!= '\t')
4631 obstack_1grow (¬es
, *input_line_pointer
);
4632 ++input_line_pointer
;
4635 obstack_1grow (¬es
, '\0');
4636 filename
= obstack_finish (¬es
);
4637 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4638 ++input_line_pointer
;
4640 demand_empty_rest_of_line ();
4641 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4642 for (i
= 0; i
< include_dir_count
; i
++)
4644 strcpy (path
, include_dirs
[i
]);
4646 strcat (path
, filename
);
4647 if (0 != (try = fopen (path
, "r")))
4656 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4657 register_dependency (path
);
4658 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4659 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4663 add_include_dir (path
)
4668 if (include_dir_count
== 0)
4670 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4671 include_dirs
[0] = "."; /* Current dir */
4672 include_dir_count
= 2;
4676 include_dir_count
++;
4677 include_dirs
= (char **) realloc (include_dirs
,
4678 include_dir_count
* sizeof (*include_dirs
));
4681 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4684 if (i
> include_dir_maxlen
)
4685 include_dir_maxlen
= i
;
4686 } /* add_include_dir() */
4692 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4694 ++input_line_pointer
;
4696 ++input_line_pointer
;
4701 read_print_statistics (file
)
4704 hash_print_statistics (file
, "pseudo-op table", po_hash
);