1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
24 change this a bit. But then, GNU isn't
25 spozed to run on your machine anyway.
26 (RMS is so shortsighted sometimes.)
29 #define MASK_CHAR ((int)(unsigned char)-1)
33 /* This is the largest known floating point format (for now). It will
34 grow when we do 4361 style flonums. */
36 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
38 /* Routines that read assembler source text to build spagetti in memory.
39 Another group of these functions is in the expr.c module. */
52 #ifndef TC_START_LABEL
53 #define TC_START_LABEL(x,y) (x==':')
56 /* The NOP_OPCODE is for the alignment fill value.
57 * fill it a nop instruction so that the disassembler does not choke
61 #define NOP_OPCODE 0x00
64 char *input_line_pointer
; /*->next char of source file to parse. */
66 #if BITS_PER_CHAR != 8
67 /* The following table is indexed by[(char)] and will break if
68 a char does not have exactly 256 states (hopefully 0:255!)! */
73 /* The m88k unfortunately uses @ as a label beginner. */
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
83 /* The Delta 68k assembler permits % inside label names. */
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
93 /* The a29k assembler does not permits labels to start with $. */
98 /* The Delta 68k assembler permits ~ at start of label names. */
102 /* used by is_... macros. our ctype[] */
105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
107 0, 0, 0, 0, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
109 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
110 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
111 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
112 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, LEX_TILDE
, 0, /* pqrstuvwxyz{|}~. */
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
117 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
125 * Out: 1 if this character ends a line.
128 char is_end_of_line
[256] =
131 99, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, 99, Z_
, Z_
, 99, Z_
, Z_
, /* @abcdefghijklmno */
133 99, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, 99, Z_
, Z_
, Z_
, Z_
, Z_
, /* @abcdefghijklmno */
135 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
137 Z_
,99, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* _!"#$%&'()*+,-./ */
138 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* 0123456789:;<=>? */
140 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
141 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, 99, Z_
, Z_
, Z_
, Z_
, /* 0123456789:;<=>? */
143 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
144 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
145 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
146 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
147 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
148 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
149 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
150 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
151 Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, Z_
, /* */
155 /* Functions private to this file. */
157 static char *buffer
; /* 1st char of each buffer of lines is here. */
158 static char *buffer_limit
; /*->1 + last char in buffer. */
160 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1 in the
161 tc-<CPU>.h file. See the "Porting GAS" section of the internals manual. */
162 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
164 static char *old_buffer
; /* JF a hack */
165 static char *old_input
;
166 static char *old_limit
;
168 /* Variables for handling include file directory table. */
170 char **include_dirs
; /* Table of pointers to directories to
171 search for .include's */
172 int include_dir_count
; /* How many are in the table */
173 int include_dir_maxlen
= 1;/* Length of longest in table */
175 #ifndef WORKING_DOT_WORD
176 struct broken_word
*broken_words
;
177 int new_broken_words
;
180 /* The current offset into the absolute section. We don't try to
181 build frags in the absolute section, since no data can be stored
182 there. We just keep track of the current offset. */
183 addressT abs_section_offset
;
185 /* If this line had an MRI style label, it is stored in this variable.
186 This is used by some of the MRI pseudo-ops. */
189 /* This global variable is used to support MRI common sections. We
190 translate such sections into a common symbol. This variable is
191 non-NULL when we are in an MRI common section. */
192 symbolS
*mri_common_symbol
;
194 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
195 need to align to an even byte boundary unless the next pseudo-op is
196 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
198 static int mri_pending_align
;
202 /* This variable is set to be non-zero if the next string we see might
203 be the name of the source file in DWARF debugging information. See
204 the comment in emit_expr for the format we look for. */
205 static int dwarf_file_string
;
209 static void cons_worker
PARAMS ((int, int));
210 static int scrub_from_string
PARAMS ((char **));
211 static void do_align
PARAMS ((int, char *, int, int));
212 static void s_align
PARAMS ((int, int));
213 static int hex_float
PARAMS ((int, char *));
214 static void do_org
PARAMS ((segT
, expressionS
*, int));
215 char *demand_copy_string
PARAMS ((int *lenP
));
216 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
217 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
218 static void pobegin
PARAMS ((void));
219 static int get_line_sb
PARAMS ((sb
*));
220 static void generate_file_debug
PARAMS ((void));
221 static void generate_lineno_debug
PARAMS ((void));
230 obj_read_begin_hook ();
232 /* Something close -- but not too close -- to a multiple of 1024.
233 The debugging malloc I'm using has 24 bytes of overhead. */
234 obstack_begin (¬es
, chunksize
);
235 obstack_begin (&cond_obstack
, chunksize
);
237 /* Use machine dependent syntax */
238 for (p
= line_separator_chars
; *p
; p
++)
239 is_end_of_line
[(unsigned char) *p
] = 1;
240 /* Use more. FIXME-SOMEDAY. */
246 /* set up pseudo-op tables */
248 static struct hash_control
*po_hash
;
250 static const pseudo_typeS potable
[] =
252 {"abort", s_abort
, 0},
253 {"align", s_align_ptwo
, 0},
254 {"ascii", stringer
, 0},
255 {"asciz", stringer
, 1},
256 {"balign", s_align_bytes
, 0},
257 {"balignw", s_align_bytes
, -2},
258 {"balignl", s_align_bytes
, -4},
262 {"common", s_mri_common
, 0},
263 {"common.s", s_mri_common
, 1},
267 {"dc.d", float_cons
, 'd'},
269 {"dc.s", float_cons
, 'f'},
271 {"dc.x", float_cons
, 'x'},
273 {"dcb.b", s_space
, 1},
274 {"dcb.d", s_float_space
, 'd'},
275 {"dcb.l", s_space
, 4},
276 {"dcb.s", s_float_space
, 'f'},
277 {"dcb.w", s_space
, 2},
278 {"dcb.x", s_float_space
, 'x'},
280 {"ds.b", s_space
, 1},
281 {"ds.d", s_space
, 8},
282 {"ds.l", s_space
, 4},
283 {"ds.p", s_space
, 12},
284 {"ds.s", s_space
, 4},
285 {"ds.w", s_space
, 2},
286 {"ds.x", s_space
, 12},
287 {"debug", s_ignore
, 0},
292 {"double", float_cons
, 'd'},
294 {"eject", listing_eject
, 0}, /* Formfeed listing */
296 {"elsec", s_else
, 0},
298 {"endc", s_endif
, 0},
299 {"endfunc", s_func
, 1},
300 {"endif", s_endif
, 0},
305 {"exitm", s_mexit
, 0},
307 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
308 {"appfile", s_app_file
, 1},
309 {"appline", s_app_line
, 0},
311 {"file", s_app_file
, 0},
313 {"float", float_cons
, 'f'},
314 {"format", s_ignore
, 0},
316 {"global", s_globl
, 0},
317 {"globl", s_globl
, 0},
319 {"if", s_if
, (int) O_ne
},
321 {"ifdef", s_ifdef
, 0},
322 {"ifeq", s_if
, (int) O_eq
},
323 {"ifeqs", s_ifeqs
, 0},
324 {"ifge", s_if
, (int) O_ge
},
325 {"ifgt", s_if
, (int) O_gt
},
326 {"ifle", s_if
, (int) O_le
},
327 {"iflt", s_if
, (int) O_lt
},
329 {"ifndef", s_ifdef
, 1},
330 {"ifne", s_if
, (int) O_ne
},
331 {"ifnes", s_ifeqs
, 1},
332 {"ifnotdef", s_ifdef
, 1},
333 {"include", s_include
, 0},
339 {"lcomm", s_lcomm
, 0},
340 {"lflags", listing_flags
, 0}, /* Listing flags */
341 {"linkonce", s_linkonce
, 0},
342 {"list", listing_list
, 1}, /* Turn listing on */
343 {"llen", listing_psize
, 1},
346 {"macro", s_macro
, 0},
347 {"mexit", s_mexit
, 0},
349 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
350 {"name", s_ignore
, 0},
351 {"noformat", s_ignore
, 0},
352 {"nolist", listing_list
, 0}, /* Turn listing off */
353 {"nopage", listing_nopage
, 0},
355 {"offset", s_struct
, 0},
357 {"p2align", s_align_ptwo
, 0},
358 {"p2alignw", s_align_ptwo
, -2},
359 {"p2alignl", s_align_ptwo
, -4},
360 {"page", listing_eject
, 0},
361 {"plen", listing_psize
, 0},
362 {"print", s_print
, 0},
363 {"psize", listing_psize
, 0}, /* set paper size */
364 {"purgem", s_purgem
, 0},
369 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
374 {"single", float_cons
, 'f'},
376 {"space", s_space
, 0},
377 {"skip", s_space
, 0},
378 {"sleb128", s_leb128
, 1},
379 {"spc", s_ignore
, 0},
380 {"stabd", s_stab
, 'd'},
381 {"stabn", s_stab
, 'n'},
382 {"stabs", s_stab
, 's'},
383 {"string", stringer
, 1},
384 {"struct", s_struct
, 0},
388 /* This is for gcc to use. It's only just been added (2/94), so gcc
389 won't be able to use it for a while -- probably a year or more.
390 But once this has been released, check with gcc maintainers
391 before deleting it or even changing the spelling. */
392 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
393 /* If we're folding case -- done for some targets, not necessarily
394 all -- the above string in an input file will be converted to
395 this one. Match it either way... */
396 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
398 {"title", listing_title
, 0}, /* Listing title */
399 {"ttl", listing_title
, 0},
401 {"uleb128", s_leb128
, 0},
405 {"xdef", s_globl
, 0},
406 {"xref", s_ignore
, 0},
407 {"xstabs", s_xstab
, 's'},
409 {"zero", s_space
, 0},
410 {NULL
} /* end sentinel */
413 static int pop_override_ok
= 0;
414 static const char *pop_table_name
;
418 const pseudo_typeS
*table
;
421 const pseudo_typeS
*pop
;
422 for (pop
= table
; pop
->poc_name
; pop
++)
424 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
425 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
426 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name
,
431 #ifndef md_pop_insert
432 #define md_pop_insert() pop_insert(md_pseudo_table)
435 #ifndef obj_pop_insert
436 #define obj_pop_insert() pop_insert(obj_pseudo_table)
442 po_hash
= hash_new ();
444 /* Do the target-specific pseudo ops. */
445 pop_table_name
= "md";
448 /* Now object specific. Skip any that were in the target table. */
449 pop_table_name
= "obj";
453 /* Now portable ones. Skip any that we've seen already. */
454 pop_table_name
= "standard";
455 pop_insert (potable
);
458 #define HANDLE_CONDITIONAL_ASSEMBLY() \
459 if (ignore_input ()) \
461 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
462 if (input_line_pointer == buffer_limit) \
468 /* This function is used when scrubbing the characters between #APP
471 static char *scrub_string
;
472 static char *scrub_string_end
;
475 scrub_from_string (from
)
480 *from
= scrub_string
;
481 size
= scrub_string_end
- scrub_string
;
482 scrub_string
= scrub_string_end
;
486 /* read_a_source_file()
488 * We read the file, putting things into a web that
489 * represents what we have been reading.
492 read_a_source_file (name
)
496 register char *s
; /* string of symbol, '\0' appended */
500 buffer
= input_scrub_new_file (name
);
503 listing_newline (NULL
);
504 register_dependency (name
);
506 /* Generate debugging information before we've read anything in to denote
507 this file as the "main" source file and not a subordinate one
508 (e.g. N_SO vs N_SOL in stabs). */
509 generate_file_debug ();
511 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
512 { /* We have another line to parse. */
513 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
514 contin
: /* JF this goto is my fault I admit it.
515 Someone brave please re-write the whole
516 input section here? Pleeze??? */
517 while (input_line_pointer
< buffer_limit
)
519 /* We have more of this buffer to parse. */
522 * We now have input_line_pointer->1st char of next line.
523 * If input_line_pointer [-1] == '\n' then we just
524 * scanned another line: so bump line counters.
526 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
528 #ifdef md_start_line_hook
529 md_start_line_hook ();
532 if (input_line_pointer
[-1] == '\n')
533 bump_line_counters ();
538 #ifdef LABELS_WITHOUT_COLONS
543 /* Text at the start of a line must be a label, we
544 run down and stick a colon in. */
545 if (is_name_beginner (*input_line_pointer
))
547 char *line_start
= input_line_pointer
;
552 HANDLE_CONDITIONAL_ASSEMBLY ();
554 c
= get_symbol_end ();
556 /* In MRI mode, the EQU and MACRO pseudoops must
557 be handled specially. */
561 char *rest
= input_line_pointer
+ 1;
565 if (*rest
== ' ' || *rest
== '\t')
567 if ((strncasecmp (rest
, "EQU", 3) == 0
568 || strncasecmp (rest
, "SET", 3) == 0)
569 && (rest
[3] == ' ' || rest
[3] == '\t'))
571 input_line_pointer
= rest
+ 3;
573 strncasecmp (rest
, "SET", 3) == 0);
576 if (strncasecmp (rest
, "MACRO", 5) == 0
579 || is_end_of_line
[(unsigned char) rest
[5]]))
583 /* In MRI mode, we need to handle the MACRO
584 pseudo-op specially: we don't want to put the
585 symbol in the symbol table. */
586 if (! mri_line_macro
)
587 line_label
= colon (line_start
);
589 line_label
= symbol_create (line_start
,
594 *input_line_pointer
= c
;
596 input_line_pointer
++;
602 * We are at the begining of a line, or similar place.
603 * We expect a well-formed assembler statement.
604 * A "symbol-name:" is a statement.
606 * Depending on what compiler is used, the order of these tests
607 * may vary to catch most common case 1st.
608 * Each test is independent of all other tests at the (top) level.
609 * PLEASE make a compiler that doesn't use this assembler.
610 * It is crufty to waste a compiler's time encoding things for this
611 * assembler, which then wastes more time decoding it.
612 * (And communicating via (linear) files is silly!
613 * If you must pass stuff, please pass a tree!)
615 if ((c
= *input_line_pointer
++) == '\t'
620 c
= *input_line_pointer
++;
622 know (c
!= ' '); /* No further leading whitespace. */
625 /* If listing is on, and we are expanding a macro, then give
626 the listing code the contents of the expanded line. */
629 if ((listing
& LISTING_MACEXP
) && macro_nest
> 0)
634 /* Find the end of the current expanded macro line. */
635 for (s
= input_line_pointer
-1; *s
; ++s
)
636 if (is_end_of_line
[(unsigned char) *s
])
639 /* Copy it for safe keeping. Also give an indication of
640 how much macro nesting is involved at this point. */
641 len
= s
- (input_line_pointer
-1);
642 copy
= (char *) xmalloc (len
+ macro_nest
+ 2);
643 memset (copy
, '>', macro_nest
);
644 copy
[macro_nest
] = ' ';
645 memcpy (copy
+ macro_nest
+ 1, input_line_pointer
-1, len
);
646 copy
[macro_nest
+1+len
] = '\0';
648 /* Install the line with the listing facility. */
649 listing_newline (copy
);
652 listing_newline (NULL
);
657 * C is the 1st significant character.
658 * Input_line_pointer points after that character.
660 if (is_name_beginner (c
))
662 /* want user-defined label or pseudo/opcode */
663 HANDLE_CONDITIONAL_ASSEMBLY ();
665 s
= --input_line_pointer
;
666 c
= get_symbol_end (); /* name's delimiter */
668 * C is character after symbol.
669 * That character's place in the input line is now '\0'.
670 * S points to the beginning of the symbol.
671 * [In case of pseudo-op, s->'.'.]
672 * Input_line_pointer->'\0' where c was.
674 if (TC_START_LABEL(c
, input_line_pointer
))
678 char *rest
= input_line_pointer
+ 1;
680 /* In MRI mode, \tsym: set 0 is permitted. */
684 if (*rest
== ' ' || *rest
== '\t')
686 if ((strncasecmp (rest
, "EQU", 3) == 0
687 || strncasecmp (rest
, "SET", 3) == 0)
688 && (rest
[3] == ' ' || rest
[3] == '\t'))
690 input_line_pointer
= rest
+ 3;
696 line_label
= colon (s
); /* user-defined label */
697 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
698 /* Input_line_pointer->after ':'. */
704 || ((c
== ' ' || c
== '\t')
705 && input_line_pointer
[1] == '='
706 #ifdef TC_EQUAL_IN_INSN
707 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
712 demand_empty_rest_of_line ();
715 { /* expect pseudo-op or machine instruction */
718 #define IGNORE_OPCODE_CASE
719 #ifdef IGNORE_OPCODE_CASE
724 if (isupper ((unsigned char) *s2
))
737 /* The MRI assembler and the m88k use pseudo-ops
739 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
740 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
745 || (! flag_m68k_mri
&& *s
== '.'))
750 * WARNING: c has next char, which may be end-of-line.
751 * We lookup the pseudo-op table with s+1 because we
752 * already know that the pseudo-op begins with a '.'.
756 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
758 /* In MRI mode, we may need to insert an
759 automatic alignment directive. What a hack
761 if (mri_pending_align
763 || ! ((pop
->poc_handler
== cons
764 && pop
->poc_val
== 1)
765 || (pop
->poc_handler
== s_space
766 && pop
->poc_val
== 1)
767 #ifdef tc_conditional_pseudoop
768 || tc_conditional_pseudoop (pop
)
770 || pop
->poc_handler
== s_if
771 || pop
->poc_handler
== s_ifdef
772 || pop
->poc_handler
== s_ifc
773 || pop
->poc_handler
== s_ifeqs
774 || pop
->poc_handler
== s_else
775 || pop
->poc_handler
== s_endif
776 || pop
->poc_handler
== s_globl
777 || pop
->poc_handler
== s_ignore
)))
779 do_align (1, (char *) NULL
, 0, 0);
780 mri_pending_align
= 0;
781 if (line_label
!= NULL
)
783 line_label
->sy_frag
= frag_now
;
784 S_SET_VALUE (line_label
, frag_now_fix ());
788 /* Print the error msg now, while we still can */
791 as_bad (_("Unknown pseudo-op: `%s'"), s
);
792 *input_line_pointer
= c
;
797 /* Put it back for error messages etc. */
798 *input_line_pointer
= c
;
799 /* The following skip of whitespace is compulsory.
800 A well shaped space is sometimes all that separates
801 keyword from operands. */
802 if (c
== ' ' || c
== '\t')
803 input_line_pointer
++;
805 * Input_line is restored.
806 * Input_line_pointer->1st non-blank char
807 * after pseudo-operation.
809 (*pop
->poc_handler
) (pop
->poc_val
);
811 /* If that was .end, just get out now. */
812 if (pop
->poc_handler
== s_end
)
819 /* WARNING: c has char, which may be end-of-line. */
820 /* Also: input_line_pointer->`\0` where c was. */
821 *input_line_pointer
= c
;
822 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
824 #ifdef TC_EOL_IN_INSN
825 || TC_EOL_IN_INSN (input_line_pointer
)
829 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
831 input_line_pointer
++;
834 c
= *input_line_pointer
;
835 *input_line_pointer
= '\0';
837 generate_lineno_debug ();
844 if (check_macro (s
, &out
, '\0', &err
))
848 *input_line_pointer
++ = c
;
849 input_scrub_include_sb (&out
,
853 input_scrub_next_buffer (&input_line_pointer
);
858 if (mri_pending_align
)
860 do_align (1, (char *) NULL
, 0, 0);
861 mri_pending_align
= 0;
862 if (line_label
!= NULL
)
864 line_label
->sy_frag
= frag_now
;
865 S_SET_VALUE (line_label
, frag_now_fix ());
869 md_assemble (s
); /* Assemble 1 instruction. */
871 *input_line_pointer
++ = c
;
873 /* We resume loop AFTER the end-of-line from
878 } /* if (is_name_beginner(c) */
881 /* Empty statement? */
882 if (is_end_of_line
[(unsigned char) c
])
885 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
886 && isdigit ((unsigned char) c
))
888 /* local label ("4:") */
889 char *backup
= input_line_pointer
;
891 HANDLE_CONDITIONAL_ASSEMBLY ();
895 while (isdigit ((unsigned char) *input_line_pointer
))
897 temp
= (temp
* 10) + *input_line_pointer
- '0';
898 ++input_line_pointer
;
899 } /* read the whole number */
901 if (LOCAL_LABELS_DOLLAR
902 && *input_line_pointer
== '$'
903 && *(input_line_pointer
+ 1) == ':')
905 input_line_pointer
+= 2;
907 if (dollar_label_defined (temp
))
909 as_fatal (_("label \"%d$\" redefined"), temp
);
912 define_dollar_label (temp
);
913 colon (dollar_label_name (temp
, 0));
918 && *input_line_pointer
++ == ':')
920 fb_label_instance_inc (temp
);
921 colon (fb_label_name (temp
, 0));
925 input_line_pointer
= backup
;
926 } /* local label ("4:") */
928 if (c
&& strchr (line_comment_chars
, c
))
929 { /* Its a comment. Better say APP or NO_APP */
933 unsigned int new_length
;
936 bump_line_counters ();
937 s
= input_line_pointer
;
938 if (strncmp (s
, "APP\n", 4))
939 continue; /* We ignore it */
942 ends
= strstr (s
, "#NO_APP\n");
946 unsigned int tmp_len
;
949 /* The end of the #APP wasn't in this buffer. We
950 keep reading in buffers until we find the #NO_APP
951 that goes with this #APP There is one. The specs
953 tmp_len
= buffer_limit
- s
;
954 tmp_buf
= xmalloc (tmp_len
+ 1);
955 memcpy (tmp_buf
, s
, tmp_len
);
958 new_tmp
= input_scrub_next_buffer (&buffer
);
962 buffer_limit
= new_tmp
;
963 input_line_pointer
= buffer
;
964 ends
= strstr (buffer
, "#NO_APP\n");
968 num
= buffer_limit
- buffer
;
970 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
971 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
976 input_line_pointer
= ends
? ends
+ 8 : NULL
;
984 input_line_pointer
= ends
+ 8;
988 scrub_string_end
= ends
;
990 new_length
= ends
- s
;
991 new_buf
= (char *) xmalloc (new_length
);
998 space
= (new_buf
+ new_length
) - new_tmp
;
999 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
1007 new_buf
= xrealloc (new_buf
, new_length
+ 100);
1008 new_tmp
= new_buf
+ new_length
;
1014 old_buffer
= buffer
;
1015 old_input
= input_line_pointer
;
1016 old_limit
= buffer_limit
;
1018 input_line_pointer
= new_buf
;
1019 buffer_limit
= new_tmp
;
1023 HANDLE_CONDITIONAL_ASSEMBLY ();
1025 #ifdef tc_unrecognized_line
1026 if (tc_unrecognized_line (c
))
1030 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
1031 input_line_pointer
--; /* Report unknown char as ignored. */
1032 ignore_rest_of_line ();
1033 } /* while (input_line_pointer<buffer_limit) */
1035 #ifdef md_after_pass_hook
1036 md_after_pass_hook ();
1042 bump_line_counters ();
1045 buffer
= old_buffer
;
1046 input_line_pointer
= old_input
;
1047 buffer_limit
= old_limit
;
1052 } /* while (more buffers to scan) */
1059 input_scrub_close (); /* Close the input file */
1062 /* For most MRI pseudo-ops, the line actually ends at the first
1063 nonquoted space. This function looks for that point, stuffs a null
1064 in, and sets *STOPCP to the character that used to be there, and
1065 returns the location.
1067 Until I hear otherwise, I am going to assume that this is only true
1068 for the m68k MRI assembler. */
1071 mri_comment_field (stopcp
)
1079 know (flag_m68k_mri
);
1081 for (s
= input_line_pointer
;
1082 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1087 inquote
= ! inquote
;
1097 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1107 /* Skip to the end of an MRI comment field. */
1110 mri_comment_end (stop
, stopc
)
1116 input_line_pointer
= stop
;
1118 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1119 ++input_line_pointer
;
1126 as_fatal (_(".abort detected. Abandoning ship."));
1129 /* Guts of .align directive. N is the power of two to which to align.
1130 FILL may be NULL, or it may point to the bytes of the fill pattern.
1131 LEN is the length of whatever FILL points to, if anything. MAX is
1132 the maximum number of characters to skip when doing the alignment,
1133 or 0 if there is no maximum. */
1136 do_align (n
, fill
, len
, max
)
1145 md_do_align (n
, fill
, len
, max
, just_record_alignment
);
1152 #ifdef BFD_ASSEMBLER
1153 if ((bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
1158 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1165 default_fill
= NOP_OPCODE
;
1168 fill
= &default_fill
;
1172 /* Only make a frag if we HAVE to. . . */
1173 if (n
!= 0 && !need_pass_2
)
1176 frag_align (n
, *fill
, max
);
1178 frag_align_pattern (n
, fill
, len
, max
);
1182 just_record_alignment
:
1185 record_alignment (now_seg
, n
);
1188 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1189 (in bytes). A negative ARG is the negative of the length of the
1190 fill pattern. BYTES_P is non-zero if the alignment value should be
1191 interpreted as the byte boundary, rather than the power of 2. */
1194 s_align (arg
, bytes_p
)
1198 register unsigned int align
;
1206 stop
= mri_comment_field (&stopc
);
1208 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1213 align
= arg
; /* Default value from pseudo-op table */
1217 align
= get_absolute_expression ();
1223 /* Convert to a power of 2. */
1228 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
1231 as_bad (_("Alignment not a power of 2"));
1239 as_bad (_("Alignment too large: %u assumed"), align
);
1242 if (*input_line_pointer
!= ',')
1249 ++input_line_pointer
;
1250 if (*input_line_pointer
== ',')
1254 fill
= get_absolute_expression ();
1259 if (*input_line_pointer
!= ',')
1263 ++input_line_pointer
;
1264 max
= get_absolute_expression ();
1271 as_warn (_("expected fill pattern missing"));
1272 do_align (align
, (char *) NULL
, 0, max
);
1287 do_align (align
, &fill_char
, fill_len
, max
);
1293 if ((size_t) fill_len
> sizeof ab
)
1295 md_number_to_chars (ab
, fill
, fill_len
);
1296 do_align (align
, ab
, fill_len
, max
);
1301 mri_comment_end (stop
, stopc
);
1303 demand_empty_rest_of_line ();
1306 /* Handle the .align pseudo-op on machines where ".align 4" means
1307 align to a 4 byte boundary. */
1316 /* Handle the .align pseudo-op on machines where ".align 4" means align
1317 to a 2**4 boundary. */
1330 register char *name
;
1334 register symbolS
*symbolP
;
1339 stop
= mri_comment_field (&stopc
);
1341 name
= input_line_pointer
;
1342 c
= get_symbol_end ();
1343 /* just after name is now '\0' */
1344 p
= input_line_pointer
;
1347 if (*input_line_pointer
!= ',')
1349 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1351 mri_comment_end (stop
, stopc
);
1352 ignore_rest_of_line ();
1355 input_line_pointer
++; /* skip ',' */
1356 if ((temp
= get_absolute_expression ()) < 0)
1358 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp
);
1360 mri_comment_end (stop
, stopc
);
1361 ignore_rest_of_line ();
1365 symbolP
= symbol_find_or_make (name
);
1367 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1369 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1370 S_GET_NAME (symbolP
));
1372 mri_comment_end (stop
, stopc
);
1373 ignore_rest_of_line ();
1376 if (S_GET_VALUE (symbolP
))
1378 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1379 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
1380 S_GET_NAME (symbolP
),
1381 (long) S_GET_VALUE (symbolP
),
1386 S_SET_VALUE (symbolP
, (valueT
) temp
);
1387 S_SET_EXTERNAL (symbolP
);
1391 extern int flag_one
;
1392 if ( (!temp
) || !flag_one
)
1393 S_GET_OTHER(symbolP
) = const_flag
;
1395 #endif /* not OBJ_VMS */
1396 know (symbolP
->sy_frag
== &zero_address_frag
);
1399 mri_comment_end (stop
, stopc
);
1401 demand_empty_rest_of_line ();
1404 /* The MRI COMMON pseudo-op. We handle this by creating a common
1405 symbol with the appropriate name. We make s_space do the right
1406 thing by increasing the size. */
1409 s_mri_common (small
)
1426 stop
= mri_comment_field (&stopc
);
1430 name
= input_line_pointer
;
1431 if (! isdigit ((unsigned char) *name
))
1432 c
= get_symbol_end ();
1437 ++input_line_pointer
;
1439 while (isdigit ((unsigned char) *input_line_pointer
));
1440 c
= *input_line_pointer
;
1441 *input_line_pointer
= '\0';
1443 if (line_label
!= NULL
)
1445 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1446 + (input_line_pointer
- name
)
1448 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1453 sym
= symbol_find_or_make (name
);
1454 *input_line_pointer
= c
;
1458 if (*input_line_pointer
!= ',')
1462 ++input_line_pointer
;
1463 align
= get_absolute_expression ();
1466 if (S_IS_DEFINED (sym
) && ! S_IS_COMMON (sym
))
1468 as_bad (_("attempt to re-define symbol `%s'"), S_GET_NAME (sym
));
1469 mri_comment_end (stop
, stopc
);
1470 ignore_rest_of_line ();
1474 S_SET_EXTERNAL (sym
);
1475 mri_common_symbol
= sym
;
1479 S_SET_ALIGN (sym
, align
);
1482 if (line_label
!= NULL
)
1484 line_label
->sy_value
.X_op
= O_symbol
;
1485 line_label
->sy_value
.X_add_symbol
= sym
;
1486 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1487 line_label
->sy_frag
= &zero_address_frag
;
1488 S_SET_SEGMENT (line_label
, expr_section
);
1491 /* FIXME: We just ignore the small argument, which distinguishes
1492 COMMON and COMMON.S. I don't know what we can do about it. */
1494 /* Ignore the type and hptype. */
1495 if (*input_line_pointer
== ',')
1496 input_line_pointer
+= 2;
1497 if (*input_line_pointer
== ',')
1498 input_line_pointer
+= 2;
1500 mri_comment_end (stop
, stopc
);
1502 demand_empty_rest_of_line ();
1512 temp
= get_absolute_expression ();
1513 if (flag_readonly_data_in_text
)
1515 section
= text_section
;
1519 section
= data_section
;
1521 subseg_set (section
, (subsegT
) temp
);
1526 demand_empty_rest_of_line ();
1529 /* Handle the .appfile pseudo-op. This is automatically generated by
1530 do_scrub_chars when a preprocessor # line comment is seen with a
1531 file name. This default definition may be overridden by the object
1532 or CPU specific pseudo-ops. This function is also the default
1533 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1537 s_app_file (appfile
)
1543 /* Some assemblers tolerate immediately following '"' */
1544 if ((s
= demand_copy_string (&length
)) != 0)
1546 /* If this is a fake .appfile, a fake newline was inserted into
1547 the buffer. Passing -2 to new_logical_line tells it to
1550 = (! new_logical_line (s
, appfile
? -2 : -1) && appfile
);
1552 /* In MRI mode, the preprocessor may have inserted an extraneous
1555 && *input_line_pointer
== '\''
1556 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1557 ++input_line_pointer
;
1559 demand_empty_rest_of_line ();
1564 listing_source_file (s
);
1566 register_dependency (s
);
1574 /* Handle the .appline pseudo-op. This is automatically generated by
1575 do_scrub_chars when a preprocessor # line comment is seen. This
1576 default definition may be overridden by the object or CPU specific
1585 /* The given number is that of the next line. */
1586 l
= get_absolute_expression () - 1;
1588 /* Some of the back ends can't deal with non-positive line numbers.
1589 Besides, it's silly. */
1590 as_warn (_("Line numbers must be positive; line number %d rejected."), l
+1);
1593 new_logical_line ((char *) NULL
, l
);
1596 listing_source_line (l
);
1599 demand_empty_rest_of_line ();
1602 /* Handle the .end pseudo-op. Actually, the real work is done in
1603 read_a_source_file. */
1611 /* The MRI assembler permits the start symbol to follow .end,
1612 but we don't support that. */
1614 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1615 && *input_line_pointer
!= '*'
1616 && *input_line_pointer
!= '!')
1617 as_warn (_("start address not supported"));
1621 /* Handle the .err pseudo-op. */
1627 as_bad (_(".err encountered"));
1628 demand_empty_rest_of_line ();
1631 /* Handle the MRI fail pseudo-op. */
1642 stop
= mri_comment_field (&stopc
);
1644 temp
= get_absolute_expression ();
1646 as_warn (_(".fail %ld encountered"), (long) temp
);
1648 as_bad (_(".fail %ld encountered"), (long) temp
);
1651 mri_comment_end (stop
, stopc
);
1653 demand_empty_rest_of_line ();
1660 expressionS rep_exp
;
1662 register long fill
= 0;
1665 #ifdef md_flush_pending_output
1666 md_flush_pending_output ();
1669 get_known_segmented_expression (&rep_exp
);
1670 if (*input_line_pointer
== ',')
1672 input_line_pointer
++;
1673 size
= get_absolute_expression ();
1674 if (*input_line_pointer
== ',')
1676 input_line_pointer
++;
1677 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 (size
> BSD_FILL_SIZE_CROCK_8
)
1685 as_warn (_(".fill size clamped to %d."), BSD_FILL_SIZE_CROCK_8
);
1686 size
= BSD_FILL_SIZE_CROCK_8
;
1690 as_warn (_("Size negative: .fill ignored."));
1693 else if (rep_exp
.X_op
== O_constant
&& rep_exp
.X_add_number
<= 0)
1695 if (rep_exp
.X_add_number
< 0)
1696 as_warn (_("Repeat < 0, .fill ignored"));
1700 if (size
&& !need_pass_2
)
1702 if (rep_exp
.X_op
== O_constant
)
1704 p
= frag_var (rs_fill
, (int) size
, (int) size
,
1705 (relax_substateT
) 0, (symbolS
*) 0,
1706 (offsetT
) rep_exp
.X_add_number
,
1711 /* We don't have a constant repeat count, so we can't use
1712 rs_fill. We can get the same results out of rs_space,
1713 but its argument is in bytes, so we must multiply the
1714 repeat count by size. */
1717 rep_sym
= make_expr_symbol (&rep_exp
);
1720 expressionS size_exp
;
1721 size_exp
.X_op
= O_constant
;
1722 size_exp
.X_add_number
= size
;
1724 rep_exp
.X_op
= O_multiply
;
1725 rep_exp
.X_add_symbol
= rep_sym
;
1726 rep_exp
.X_op_symbol
= make_expr_symbol (&size_exp
);
1727 rep_exp
.X_add_number
= 0;
1728 rep_sym
= make_expr_symbol (&rep_exp
);
1731 p
= frag_var (rs_space
, (int) size
, (int) size
,
1732 (relax_substateT
) 0, rep_sym
, (offsetT
) 0, (char *) 0);
1734 memset (p
, 0, (unsigned int) size
);
1735 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1736 * flavoured AS. The following bizzare behaviour is to be
1737 * compatible with above. I guess they tried to take up to 8
1738 * bytes from a 4-byte expression and they forgot to sign
1739 * extend. Un*x Sux. */
1740 #define BSD_FILL_SIZE_CROCK_4 (4)
1741 md_number_to_chars (p
, (valueT
) fill
,
1742 (size
> BSD_FILL_SIZE_CROCK_4
1743 ? BSD_FILL_SIZE_CROCK_4
1745 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1746 * but emits no error message because it seems a legal thing to do.
1747 * It is a degenerate case of .fill but could be emitted by a compiler.
1750 demand_empty_rest_of_line ();
1764 stop
= mri_comment_field (&stopc
);
1768 name
= input_line_pointer
;
1769 c
= get_symbol_end ();
1770 symbolP
= symbol_find_or_make (name
);
1771 *input_line_pointer
= c
;
1773 S_SET_EXTERNAL (symbolP
);
1776 input_line_pointer
++;
1778 if (*input_line_pointer
== '\n')
1785 mri_comment_end (stop
, stopc
);
1787 demand_empty_rest_of_line ();
1790 /* Handle the MRI IRP and IRPC pseudo-ops. */
1802 as_where (&file
, &line
);
1805 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1806 sb_add_char (&s
, *input_line_pointer
++);
1810 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1812 as_bad_where (file
, line
, "%s", err
);
1816 input_scrub_include_sb (&out
, input_line_pointer
);
1818 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1821 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1822 the section to only be linked once. However, this is not supported
1823 by most object file formats. This takes an optional argument,
1824 which is what to do about duplicates. */
1830 enum linkonce_type type
;
1834 type
= LINKONCE_DISCARD
;
1836 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1841 s
= input_line_pointer
;
1842 c
= get_symbol_end ();
1843 if (strcasecmp (s
, "discard") == 0)
1844 type
= LINKONCE_DISCARD
;
1845 else if (strcasecmp (s
, "one_only") == 0)
1846 type
= LINKONCE_ONE_ONLY
;
1847 else if (strcasecmp (s
, "same_size") == 0)
1848 type
= LINKONCE_SAME_SIZE
;
1849 else if (strcasecmp (s
, "same_contents") == 0)
1850 type
= LINKONCE_SAME_CONTENTS
;
1852 as_warn (_("unrecognized .linkonce type `%s'"), s
);
1854 *input_line_pointer
= c
;
1857 #ifdef obj_handle_link_once
1858 obj_handle_link_once (type
);
1859 #else /* ! defined (obj_handle_link_once) */
1860 #ifdef BFD_ASSEMBLER
1864 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1865 as_warn (_(".linkonce is not supported for this object file format"));
1867 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1868 flags
|= SEC_LINK_ONCE
;
1873 case LINKONCE_DISCARD
:
1874 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1876 case LINKONCE_ONE_ONLY
:
1877 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1879 case LINKONCE_SAME_SIZE
:
1880 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1882 case LINKONCE_SAME_CONTENTS
:
1883 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1886 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1887 as_bad (_("bfd_set_section_flags: %s"),
1888 bfd_errmsg (bfd_get_error ()));
1890 #else /* ! defined (BFD_ASSEMBLER) */
1891 as_warn (_(".linkonce is not supported for this object file format"));
1892 #endif /* ! defined (BFD_ASSEMBLER) */
1893 #endif /* ! defined (obj_handle_link_once) */
1895 demand_empty_rest_of_line ();
1899 s_lcomm_internal (needs_align
, bytes_p
)
1900 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1901 (alignment); 0 if it was an ".lcomm" (2 args only) */
1903 /* 1 if the alignment value should be interpreted as the byte boundary,
1904 rather than the power of 2. */
1907 register char *name
;
1911 register symbolS
*symbolP
;
1912 segT current_seg
= now_seg
;
1913 subsegT current_subseg
= now_subseg
;
1914 const int max_alignment
= 15;
1916 segT bss_seg
= bss_section
;
1918 name
= input_line_pointer
;
1919 c
= get_symbol_end ();
1920 p
= input_line_pointer
;
1924 /* Accept an optional comma after the name. The comma used to be
1925 required, but Irix 5 cc does not generate it. */
1926 if (*input_line_pointer
== ',')
1928 ++input_line_pointer
;
1932 if (*input_line_pointer
== '\n')
1934 as_bad (_("Missing size expression"));
1938 if ((temp
= get_absolute_expression ()) < 0)
1940 as_warn (_("BSS length (%d.) <0! Ignored."), temp
);
1941 ignore_rest_of_line ();
1945 #if defined (TC_MIPS) || defined (TC_ALPHA)
1946 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1947 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1949 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1950 if (temp
<= bfd_get_gp_size (stdoutput
))
1952 bss_seg
= subseg_new (".sbss", 1);
1953 seg_info (bss_seg
)->bss
= 1;
1954 #ifdef BFD_ASSEMBLER
1955 if (! bfd_set_section_flags (stdoutput
, bss_seg
, SEC_ALLOC
))
1956 as_warn (_("error setting flags for \".sbss\": %s"),
1957 bfd_errmsg (bfd_get_error ()));
1964 /* FIXME. This needs to be machine independent. */
1975 /* FIXME: This needs to be done in a more general fashion. */
1979 record_alignment(bss_seg
, align
);
1986 if (*input_line_pointer
!= ',')
1988 as_bad (_("Expected comma after size"));
1989 ignore_rest_of_line ();
1992 input_line_pointer
++;
1994 if (*input_line_pointer
== '\n')
1996 as_bad (_("Missing alignment"));
1999 align
= get_absolute_expression ();
2002 /* Convert to a power of 2. */
2007 for (i
= 0; (align
& 1) == 0; align
>>= 1, ++i
)
2010 as_bad (_("Alignment not a power of 2"));
2014 if (align
> max_alignment
)
2016 align
= max_alignment
;
2017 as_warn (_("Alignment too large: %d. assumed."), align
);
2022 as_warn (_("Alignment negative. 0 assumed."));
2024 record_alignment (bss_seg
, align
);
2025 } /* if needs align */
2028 /* Assume some objects may require alignment on some systems. */
2029 #if defined (TC_ALPHA) && ! defined (VMS)
2032 align
= ffs (temp
) - 1;
2033 if (temp
% (1 << align
))
2040 symbolP
= symbol_find_or_make (name
);
2044 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
2045 S_GET_OTHER (symbolP
) == 0 &&
2046 S_GET_DESC (symbolP
) == 0 &&
2047 #endif /* OBJ_AOUT or OBJ_BOUT */
2048 (S_GET_SEGMENT (symbolP
) == bss_seg
2049 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
2053 subseg_set (bss_seg
, 1);
2056 frag_align (align
, 0, 0);
2057 /* detach from old frag */
2058 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
2059 symbolP
->sy_frag
->fr_symbol
= NULL
;
2061 symbolP
->sy_frag
= frag_now
;
2062 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2063 (offsetT
) temp
, (char *) 0);
2066 S_SET_SEGMENT (symbolP
, bss_seg
);
2069 /* The symbol may already have been created with a preceding
2070 ".globl" directive -- be careful not to step on storage class
2071 in that case. Otherwise, set it to static. */
2072 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
2074 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2076 #endif /* OBJ_COFF */
2079 S_SET_SIZE (symbolP
, temp
);
2083 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2084 S_GET_NAME (symbolP
));
2086 subseg_set (current_seg
, current_subseg
);
2088 demand_empty_rest_of_line ();
2089 } /* s_lcomm_internal() */
2092 s_lcomm (needs_align
)
2095 s_lcomm_internal (needs_align
, 0);
2098 void s_lcomm_bytes (needs_align
)
2101 s_lcomm_internal (needs_align
, 1);
2108 register char *name
;
2112 register symbolS
*symbolP
;
2114 /* we permit ANY defined expression: BSD4.2 demands constants */
2115 name
= input_line_pointer
;
2116 c
= get_symbol_end ();
2117 p
= input_line_pointer
;
2120 if (*input_line_pointer
!= ',')
2123 as_bad (_("Expected comma after name \"%s\""), name
);
2125 ignore_rest_of_line ();
2128 input_line_pointer
++;
2130 if (exp
.X_op
!= O_constant
2131 && exp
.X_op
!= O_register
)
2133 as_bad (_("bad expression"));
2134 ignore_rest_of_line ();
2138 symbolP
= symbol_find_or_make (name
);
2140 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2141 symbolP->sy_desc == 0) out of this test because coff doesn't have
2142 those fields, and I can't see when they'd ever be tripped. I
2143 don't think I understand why they were here so I may have
2144 introduced a bug. As recently as 1.37 didn't have this test
2145 anyway. xoxorich. */
2147 if (S_GET_SEGMENT (symbolP
) == undefined_section
2148 && S_GET_VALUE (symbolP
) == 0)
2150 /* The name might be an undefined .global symbol; be sure to
2151 keep the "external" bit. */
2152 S_SET_SEGMENT (symbolP
,
2153 (exp
.X_op
== O_constant
2156 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2160 as_bad (_("Symbol %s already defined"), name
);
2163 demand_empty_rest_of_line ();
2166 /* Read a line into an sb. */
2172 char quote1
, quote2
, inquote
;
2174 if (input_line_pointer
[-1] == '\n')
2175 bump_line_counters ();
2177 if (input_line_pointer
>= buffer_limit
)
2179 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2180 if (buffer_limit
== 0)
2184 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2185 code needs to be changed. */
2186 if (! flag_m68k_mri
)
2194 #ifdef LEX_IS_STRINGQUOTE
2199 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
2200 || (inquote
!= '\0' && *input_line_pointer
!= '\n'))
2202 if (inquote
== *input_line_pointer
)
2204 else if (inquote
== '\0')
2206 if (*input_line_pointer
== quote1
)
2208 else if (*input_line_pointer
== quote2
)
2211 sb_add_char (line
, *input_line_pointer
++);
2213 while (input_line_pointer
< buffer_limit
2214 && is_end_of_line
[(unsigned char) *input_line_pointer
])
2216 if (input_line_pointer
[-1] == '\n')
2217 bump_line_counters ();
2218 ++input_line_pointer
;
2223 /* Define a macro. This is an interface to macro.c, which is shared
2224 between gas and gasp. */
2237 as_where (&file
, &line
);
2240 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2241 sb_add_char (&s
, *input_line_pointer
++);
2244 if (line_label
!= NULL
)
2245 sb_add_string (&label
, S_GET_NAME (line_label
));
2247 err
= define_macro (0, &s
, &label
, get_line_sb
, &name
);
2249 as_bad_where (file
, line
, "%s", err
);
2252 if (line_label
!= NULL
)
2254 S_SET_SEGMENT (line_label
, undefined_section
);
2255 S_SET_VALUE (line_label
, 0);
2256 line_label
->sy_frag
= &zero_address_frag
;
2260 #ifdef NO_PSEUDO_DOT
2264 && hash_find (po_hash
, name
) != NULL
)
2267 && hash_find (po_hash
, name
+ 1) != NULL
))
2268 as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2275 /* Handle the .mexit pseudo-op, which immediately exits a macro
2282 cond_exit_macro (macro_nest
);
2283 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2286 /* Switch in and out of MRI mode. */
2294 on
= get_absolute_expression ();
2295 old_flag
= flag_mri
;
2309 #ifdef MRI_MODE_CHANGE
2311 MRI_MODE_CHANGE (on
);
2314 demand_empty_rest_of_line ();
2317 /* Handle changing the location counter. */
2320 do_org (segment
, exp
, fill
)
2325 if (segment
!= now_seg
&& segment
!= absolute_section
)
2326 as_bad (_("invalid segment \"%s\"; segment \"%s\" assumed"),
2327 segment_name (segment
), segment_name (now_seg
));
2329 if (now_seg
== absolute_section
)
2332 as_warn (_("ignoring fill value in absolute section"));
2333 if (exp
->X_op
!= O_constant
)
2335 as_bad (_("only constant offsets supported in absolute section"));
2336 exp
->X_add_number
= 0;
2338 abs_section_offset
= exp
->X_add_number
;
2344 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2345 exp
->X_add_number
, (char *) NULL
);
2354 register segT segment
;
2356 register long temp_fill
;
2358 #ifdef md_flush_pending_output
2359 md_flush_pending_output ();
2362 /* The m68k MRI assembler has a different meaning for .org. It
2363 means to create an absolute section at a given address. We can't
2364 support that--use a linker script instead. */
2367 as_bad (_("MRI style ORG pseudo-op not supported"));
2368 ignore_rest_of_line ();
2372 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2373 thing as a sub-segment-relative origin. Any absolute origin is
2374 given a warning, then assumed to be segment-relative. Any
2375 segmented origin expression ("foo+42") had better be in the right
2376 segment or the .org is ignored.
2378 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2379 we never know sub-segment sizes when we are reading code. BSD
2380 will crash trying to emit negative numbers of filler bytes in
2381 certain .orgs. We don't crash, but see as-write for that code.
2383 Don't make frag if need_pass_2==1. */
2384 segment
= get_known_segmented_expression (&exp
);
2385 if (*input_line_pointer
== ',')
2387 input_line_pointer
++;
2388 temp_fill
= get_absolute_expression ();
2394 do_org (segment
, &exp
, temp_fill
);
2396 demand_empty_rest_of_line ();
2399 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2400 called by the obj-format routine which handles section changing
2401 when in MRI mode. It will create a new section, and return it. It
2402 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2403 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2404 flags will be set in the section. */
2418 name
= input_line_pointer
;
2419 if (! isdigit ((unsigned char) *name
))
2420 c
= get_symbol_end ();
2425 ++input_line_pointer
;
2427 while (isdigit ((unsigned char) *input_line_pointer
));
2428 c
= *input_line_pointer
;
2429 *input_line_pointer
= '\0';
2432 name
= xstrdup (name
);
2434 *input_line_pointer
= c
;
2436 seg
= subseg_new (name
, 0);
2438 if (*input_line_pointer
== ',')
2442 ++input_line_pointer
;
2443 align
= get_absolute_expression ();
2444 record_alignment (seg
, align
);
2448 if (*input_line_pointer
== ',')
2450 c
= *++input_line_pointer
;
2451 c
= toupper ((unsigned char) c
);
2452 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2455 as_bad (_("unrecognized section type"));
2456 ++input_line_pointer
;
2458 #ifdef BFD_ASSEMBLER
2462 flags
= SEC_NO_FLAGS
;
2464 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2465 else if (*type
== 'D' || *type
== 'M')
2466 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2467 else if (*type
== 'R')
2468 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2469 if (flags
!= SEC_NO_FLAGS
)
2471 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2472 as_warn (_("error setting flags for \"%s\": %s"),
2473 bfd_section_name (stdoutput
, seg
),
2474 bfd_errmsg (bfd_get_error ()));
2480 /* Ignore the HP type. */
2481 if (*input_line_pointer
== ',')
2482 input_line_pointer
+= 2;
2484 demand_empty_rest_of_line ();
2486 #else /* ! TC_M68K */
2495 name
= input_line_pointer
;
2496 c
= get_symbol_end ();
2498 name
= xstrdup (name
);
2500 *input_line_pointer
= c
;
2502 seg
= subseg_new (name
, 0);
2504 if (*input_line_pointer
!= ',')
2510 ++input_line_pointer
;
2512 sectype
= input_line_pointer
;
2513 c
= get_symbol_end ();
2514 if (*sectype
== '\0')
2516 else if (strcasecmp (sectype
, "text") == 0)
2518 else if (strcasecmp (sectype
, "data") == 0)
2520 else if (strcasecmp (sectype
, "romdata") == 0)
2523 as_warn (_("unrecognized section type `%s'"), sectype
);
2524 *input_line_pointer
= c
;
2527 if (*input_line_pointer
== ',')
2531 ++input_line_pointer
;
2533 seccmd
= input_line_pointer
;
2534 c
= get_symbol_end ();
2535 if (strcasecmp (seccmd
, "absolute") == 0)
2537 as_bad (_("absolute sections are not supported"));
2538 *input_line_pointer
= c
;
2539 ignore_rest_of_line ();
2542 else if (strcasecmp (seccmd
, "align") == 0)
2546 *input_line_pointer
= c
;
2547 align
= get_absolute_expression ();
2548 record_alignment (seg
, align
);
2552 as_warn (_("unrecognized section command `%s'"), seccmd
);
2553 *input_line_pointer
= c
;
2557 demand_empty_rest_of_line ();
2559 #else /* ! TC_I960 */
2560 /* The MRI assembler seems to use different forms of .sect for
2561 different targets. */
2562 as_bad ("MRI mode not supported for this target");
2563 ignore_rest_of_line ();
2564 #endif /* ! TC_I960 */
2565 #endif /* ! TC_M68K */
2568 /* Handle the .print pseudo-op. */
2577 s
= demand_copy_C_string (&len
);
2579 demand_empty_rest_of_line ();
2582 /* Handle the .purgem pseudo-op. */
2588 if (is_it_end_of_statement ())
2590 demand_empty_rest_of_line ();
2600 name
= input_line_pointer
;
2601 c
= get_symbol_end ();
2602 delete_macro (name
);
2603 *input_line_pointer
= c
;
2606 while (*input_line_pointer
++ == ',');
2608 --input_line_pointer
;
2609 demand_empty_rest_of_line ();
2612 /* Handle the .rept pseudo-op. */
2622 count
= get_absolute_expression ();
2625 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2627 as_bad (_("rept without endr"));
2633 sb_add_sb (&many
, &one
);
2637 input_scrub_include_sb (&many
, input_line_pointer
);
2639 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2642 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2643 this is .equiv, and it is an error if the symbol is already
2650 register char *name
;
2651 register char delim
;
2652 register char *end_name
;
2653 register symbolS
*symbolP
;
2656 * Especial apologies for the random logic:
2657 * this just grew, and could be parsed much more simply!
2660 name
= input_line_pointer
;
2661 delim
= get_symbol_end ();
2662 end_name
= input_line_pointer
;
2666 if (*input_line_pointer
!= ',')
2669 as_bad (_("Expected comma after name \"%s\""), name
);
2671 ignore_rest_of_line ();
2675 input_line_pointer
++;
2678 if (name
[0] == '.' && name
[1] == '\0')
2680 /* Turn '. = mumble' into a .org mumble */
2681 register segT segment
;
2684 segment
= get_known_segmented_expression (&exp
);
2687 do_org (segment
, &exp
, 0);
2693 if ((symbolP
= symbol_find (name
)) == NULL
2694 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2697 /* When doing symbol listings, play games with dummy fragments living
2698 outside the normal fragment chain to record the file and line info
2700 if (listing
& LISTING_SYMBOLS
)
2702 extern struct list_info_struct
*listing_tail
;
2703 fragS
*dummy_frag
= (fragS
*) xmalloc (sizeof(fragS
));
2704 memset (dummy_frag
, 0, sizeof(fragS
));
2705 dummy_frag
->fr_type
= rs_fill
;
2706 dummy_frag
->line
= listing_tail
;
2707 symbolP
= symbol_new (name
, undefined_section
, 0, dummy_frag
);
2708 dummy_frag
->fr_symbol
= symbolP
;
2712 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2715 /* "set" symbols are local unless otherwise specified. */
2716 SF_SET_LOCAL (symbolP
);
2717 #endif /* OBJ_COFF */
2719 } /* make a new symbol */
2721 symbol_table_insert (symbolP
);
2726 && S_IS_DEFINED (symbolP
)
2727 && S_GET_SEGMENT (symbolP
) != reg_section
)
2728 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP
));
2730 pseudo_set (symbolP
);
2731 demand_empty_rest_of_line ();
2745 #ifdef md_flush_pending_output
2746 md_flush_pending_output ();
2750 stop
= mri_comment_field (&stopc
);
2752 /* In m68k MRI mode, we need to align to a word boundary, unless
2754 if (flag_m68k_mri
&& mult
> 1)
2756 if (now_seg
== absolute_section
)
2758 abs_section_offset
+= abs_section_offset
& 1;
2759 if (line_label
!= NULL
)
2760 S_SET_VALUE (line_label
, abs_section_offset
);
2762 else if (mri_common_symbol
!= NULL
)
2766 val
= S_GET_VALUE (mri_common_symbol
);
2769 S_SET_VALUE (mri_common_symbol
, val
+ 1);
2770 if (line_label
!= NULL
)
2772 know (line_label
->sy_value
.X_op
== O_symbol
);
2773 know (line_label
->sy_value
.X_add_symbol
== mri_common_symbol
);
2774 line_label
->sy_value
.X_add_number
+= 1;
2780 do_align (1, (char *) NULL
, 0, 0);
2781 if (line_label
!= NULL
)
2783 line_label
->sy_frag
= frag_now
;
2784 S_SET_VALUE (line_label
, frag_now_fix ());
2794 if (*input_line_pointer
== ',')
2796 ++input_line_pointer
;
2801 val
.X_op
= O_constant
;
2802 val
.X_add_number
= 0;
2805 if (val
.X_op
!= O_constant
2806 || val
.X_add_number
< - 0x80
2807 || val
.X_add_number
> 0xff
2808 || (mult
!= 0 && mult
!= 1 && val
.X_add_number
!= 0))
2810 if (exp
.X_op
!= O_constant
)
2811 as_bad (_("Unsupported variable size or fill value"));
2818 bytes
= mult
* exp
.X_add_number
;
2819 for (i
= 0; i
< exp
.X_add_number
; i
++)
2820 emit_expr (&val
, mult
);
2825 if (exp
.X_op
== O_constant
)
2829 repeat
= exp
.X_add_number
;
2836 as_warn (_(".space repeat count is zero, ignored"));
2837 else if (repeat
< 0)
2838 as_warn (_(".space repeat count is negative, ignored"));
2842 /* If we are in the absolute section, just bump the offset. */
2843 if (now_seg
== absolute_section
)
2845 abs_section_offset
+= repeat
;
2849 /* If we are secretly in an MRI common section, then
2850 creating space just increases the size of the common
2852 if (mri_common_symbol
!= NULL
)
2854 S_SET_VALUE (mri_common_symbol
,
2855 S_GET_VALUE (mri_common_symbol
) + repeat
);
2860 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2861 (offsetT
) repeat
, (char *) 0);
2865 if (now_seg
== absolute_section
)
2867 as_bad (_("space allocation too complex in absolute section"));
2868 subseg_set (text_section
, 0);
2870 if (mri_common_symbol
!= NULL
)
2872 as_bad (_("space allocation too complex in common section"));
2873 mri_common_symbol
= NULL
;
2876 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2877 make_expr_symbol (&exp
), (offsetT
) 0, (char *) 0);
2881 *p
= val
.X_add_number
;
2886 /* In MRI mode, after an odd number of bytes, we must align to an
2887 even word boundary, unless the next instruction is a dc.b, ds.b
2889 if (flag_mri
&& (bytes
& 1) != 0)
2890 mri_pending_align
= 1;
2893 mri_comment_end (stop
, stopc
);
2895 demand_empty_rest_of_line ();
2898 /* This is like s_space, but the value is a floating point number with
2899 the given precision. This is for the MRI dcb.s pseudo-op and
2903 s_float_space (float_type
)
2908 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2913 stop
= mri_comment_field (&stopc
);
2915 count
= get_absolute_expression ();
2918 if (*input_line_pointer
!= ',')
2920 as_bad (_("missing value"));
2922 mri_comment_end (stop
, stopc
);
2923 ignore_rest_of_line ();
2927 ++input_line_pointer
;
2931 /* Skip any 0{letter} that may be present. Don't even check if the
2932 * letter is legal. */
2933 if (input_line_pointer
[0] == '0'
2934 && isalpha ((unsigned char) input_line_pointer
[1]))
2935 input_line_pointer
+= 2;
2937 /* Accept :xxxx, where the x's are hex digits, for a floating point
2938 with the exact digits specified. */
2939 if (input_line_pointer
[0] == ':')
2941 flen
= hex_float (float_type
, temp
);
2945 mri_comment_end (stop
, stopc
);
2946 ignore_rest_of_line ();
2954 err
= md_atof (float_type
, temp
, &flen
);
2955 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2959 as_bad (_("Bad floating literal: %s"), err
);
2961 mri_comment_end (stop
, stopc
);
2962 ignore_rest_of_line ();
2967 while (--count
>= 0)
2971 p
= frag_more (flen
);
2972 memcpy (p
, temp
, (unsigned int) flen
);
2976 mri_comment_end (stop
, stopc
);
2978 demand_empty_rest_of_line ();
2981 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2991 stop
= mri_comment_field (&stopc
);
2992 abs_section_offset
= get_absolute_expression ();
2993 subseg_set (absolute_section
, 0);
2995 mri_comment_end (stop
, stopc
);
2996 demand_empty_rest_of_line ();
3005 temp
= get_absolute_expression ();
3006 subseg_set (text_section
, (subsegT
) temp
);
3007 demand_empty_rest_of_line ();
3009 const_flag
&= ~IN_DEFAULT_SECTION
;
3015 demand_empty_rest_of_line ()
3018 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
3020 input_line_pointer
++;
3024 ignore_rest_of_line ();
3026 /* Return having already swallowed end-of-line. */
3027 } /* Return pointing just after end-of-line. */
3030 ignore_rest_of_line () /* For suspect lines: gives warning. */
3032 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
3034 if (isprint ((unsigned char) *input_line_pointer
))
3035 as_bad (_("Rest of line ignored. First ignored character is `%c'."),
3036 *input_line_pointer
);
3038 as_bad (_("Rest of line ignored. First ignored character valued 0x%x."),
3039 *input_line_pointer
);
3040 while (input_line_pointer
< buffer_limit
3041 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
3043 input_line_pointer
++;
3046 input_line_pointer
++; /* Return pointing just after end-of-line. */
3047 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
3053 * In: Pointer to a symbol.
3054 * Input_line_pointer->expression.
3056 * Out: Input_line_pointer->just after any whitespace after expression.
3057 * Tried to set symbol to value of expression.
3058 * Will change symbols type, value, and frag;
3061 pseudo_set (symbolP
)
3065 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3067 #endif /* OBJ_AOUT or OBJ_BOUT */
3069 know (symbolP
); /* NULL pointer is logic error. */
3070 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3071 ext
= S_IS_EXTERNAL (symbolP
);
3072 #endif /* OBJ_AOUT or OBJ_BOUT */
3074 (void) expression (&exp
);
3076 if (exp
.X_op
== O_illegal
)
3077 as_bad (_("illegal expression; zero assumed"));
3078 else if (exp
.X_op
== O_absent
)
3079 as_bad (_("missing expression; zero assumed"));
3080 else if (exp
.X_op
== O_big
)
3082 if (exp
.X_add_number
> 0)
3083 as_bad (_("bignum invalid; zero assumed"));
3085 as_bad (_("floating point number invalid; zero assumed"));
3087 else if (exp
.X_op
== O_subtract
3088 && (S_GET_SEGMENT (exp
.X_add_symbol
)
3089 == S_GET_SEGMENT (exp
.X_op_symbol
))
3090 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
3091 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
3093 exp
.X_op
= O_constant
;
3094 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
3095 - S_GET_VALUE (exp
.X_op_symbol
));
3103 exp
.X_add_number
= 0;
3106 S_SET_SEGMENT (symbolP
, absolute_section
);
3107 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3109 S_SET_EXTERNAL (symbolP
);
3111 S_CLEAR_EXTERNAL (symbolP
);
3112 #endif /* OBJ_AOUT or OBJ_BOUT */
3113 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3114 if (exp
.X_op
!= O_constant
)
3115 symbolP
->sy_frag
= &zero_address_frag
;
3119 S_SET_SEGMENT (symbolP
, reg_section
);
3120 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
3121 symbolP
->sy_frag
= &zero_address_frag
;
3125 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
3126 || exp
.X_add_number
!= 0)
3127 symbolP
->sy_value
= exp
;
3130 symbolS
*s
= exp
.X_add_symbol
;
3132 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
3133 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3135 S_SET_EXTERNAL (symbolP
);
3137 S_CLEAR_EXTERNAL (symbolP
);
3138 #endif /* OBJ_AOUT or OBJ_BOUT */
3139 S_SET_VALUE (symbolP
,
3140 exp
.X_add_number
+ S_GET_VALUE (s
));
3141 symbolP
->sy_frag
= s
->sy_frag
;
3142 copy_symbol_attributes (symbolP
, s
);
3147 /* The value is some complex expression.
3148 FIXME: Should we set the segment to anything? */
3149 symbolP
->sy_value
= exp
;
3157 * CONStruct more frag of .bytes, or .words etc.
3158 * Should need_pass_2 be 1 then emit no frag(s).
3159 * This understands EXPRESSIONS.
3163 * This has a split personality. We use expression() to read the
3164 * value. We can detect if the value won't fit in a byte or word.
3165 * But we can't detect if expression() discarded significant digits
3166 * in the case of a long. Not worth the crocks required to fix it.
3169 /* Select a parser for cons expressions. */
3171 /* Some targets need to parse the expression in various fancy ways.
3172 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3173 (for example, the HPPA does this). Otherwise, you can define
3174 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3175 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3176 are defined, which is the normal case, then only simple expressions
3180 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3182 #ifndef TC_PARSE_CONS_EXPRESSION
3183 #ifdef BITFIELD_CONS_EXPRESSIONS
3184 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3186 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3188 #ifdef REPEAT_CONS_EXPRESSIONS
3189 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3191 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
3194 /* If we haven't gotten one yet, just call expression. */
3195 #ifndef TC_PARSE_CONS_EXPRESSION
3196 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3200 /* worker to do .byte etc statements */
3201 /* clobbers input_line_pointer, checks */
3204 cons_worker (nbytes
, rva
)
3205 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
3213 #ifdef md_flush_pending_output
3214 md_flush_pending_output ();
3218 stop
= mri_comment_field (&stopc
);
3220 if (is_it_end_of_statement ())
3223 mri_comment_end (stop
, stopc
);
3224 demand_empty_rest_of_line ();
3228 #ifdef md_cons_align
3229 md_cons_align (nbytes
);
3236 parse_mri_cons (&exp
, (unsigned int) nbytes
);
3238 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
3242 if (exp
.X_op
== O_symbol
)
3243 exp
.X_op
= O_symbol_rva
;
3245 as_fatal (_("rva without symbol"));
3247 emit_expr (&exp
, (unsigned int) nbytes
);
3250 while (*input_line_pointer
++ == ',');
3252 /* In MRI mode, after an odd number of bytes, we must align to an
3253 even word boundary, unless the next instruction is a dc.b, ds.b
3255 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
3256 mri_pending_align
= 1;
3258 input_line_pointer
--; /* Put terminator back into stream. */
3261 mri_comment_end (stop
, stopc
);
3263 demand_empty_rest_of_line ();
3271 cons_worker (size
, 0);
3278 cons_worker (size
, 1);
3281 /* Put the contents of expression EXP into the object file using
3282 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3285 emit_expr (exp
, nbytes
)
3287 unsigned int nbytes
;
3291 valueT extra_digit
= 0;
3293 /* Don't do anything if we are going to make another pass. */
3299 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3300 appear as a four byte positive constant in the .line section,
3301 followed by a 2 byte 0xffff. Look for that case here. */
3303 static int dwarf_line
= -1;
3305 if (strcmp (segment_name (now_seg
), ".line") != 0)
3307 else if (dwarf_line
>= 0
3309 && exp
->X_op
== O_constant
3310 && (exp
->X_add_number
== -1 || exp
->X_add_number
== 0xffff))
3311 listing_source_line ((unsigned int) dwarf_line
);
3312 else if (nbytes
== 4
3313 && exp
->X_op
== O_constant
3314 && exp
->X_add_number
>= 0)
3315 dwarf_line
= exp
->X_add_number
;
3320 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3321 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3322 AT_sibling (0x12) followed by a four byte address of the sibling
3323 followed by a 2 byte AT_name (0x38) followed by the name of the
3324 file. We look for that case here. */
3326 static int dwarf_file
= 0;
3328 if (strcmp (segment_name (now_seg
), ".debug") != 0)
3330 else if (dwarf_file
== 0
3332 && exp
->X_op
== O_constant
3333 && exp
->X_add_number
== 0x11)
3335 else if (dwarf_file
== 1
3337 && exp
->X_op
== O_constant
3338 && exp
->X_add_number
== 0x12)
3340 else if (dwarf_file
== 2
3343 else if (dwarf_file
== 3
3345 && exp
->X_op
== O_constant
3346 && exp
->X_add_number
== 0x38)
3351 /* The variable dwarf_file_string tells stringer that the string
3352 may be the name of the source file. */
3353 if (dwarf_file
== 4)
3354 dwarf_file_string
= 1;
3356 dwarf_file_string
= 0;
3361 if (check_eh_frame (exp
, &nbytes
))
3366 /* Allow `.word 0' in the absolute section. */
3367 if (now_seg
== absolute_section
)
3369 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
3370 as_bad (_("attempt to store value in absolute section"));
3371 abs_section_offset
+= nbytes
;
3375 /* Handle a negative bignum. */
3377 && exp
->X_add_number
== 0
3378 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
3379 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
3382 unsigned long carry
;
3384 exp
= &exp
->X_add_symbol
->sy_value
;
3386 /* Negate the bignum: one's complement each digit and add 1. */
3388 for (i
= 0; i
< exp
->X_add_number
; i
++)
3392 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3395 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3396 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3399 /* We can ignore any carry out, because it will be handled by
3400 extra_digit if it is needed. */
3402 extra_digit
= (valueT
) -1;
3406 if (op
== O_absent
|| op
== O_illegal
)
3408 as_warn (_("zero assumed for missing expression"));
3409 exp
->X_add_number
= 0;
3412 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3414 as_bad (_("floating point number invalid; zero assumed"));
3415 exp
->X_add_number
= 0;
3418 else if (op
== O_register
)
3420 as_warn (_("register value used as expression"));
3424 p
= frag_more ((int) nbytes
);
3426 #ifndef WORKING_DOT_WORD
3427 /* If we have the difference of two symbols in a word, save it on
3428 the broken_words list. See the code in write.c. */
3429 if (op
== O_subtract
&& nbytes
== 2)
3431 struct broken_word
*x
;
3433 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3434 x
->next_broken_word
= broken_words
;
3437 x
->subseg
= now_subseg
;
3439 x
->word_goes_here
= p
;
3441 x
->add
= exp
->X_add_symbol
;
3442 x
->sub
= exp
->X_op_symbol
;
3443 x
->addnum
= exp
->X_add_number
;
3450 /* If we have an integer, but the number of bytes is too large to
3451 pass to md_number_to_chars, handle it as a bignum. */
3452 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3457 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3458 extra_digit
= (valueT
) -1;
3459 val
= (valueT
) exp
->X_add_number
;
3463 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3464 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3468 op
= exp
->X_op
= O_big
;
3469 exp
->X_add_number
= gencnt
;
3472 if (op
== O_constant
)
3474 register valueT get
;
3475 register valueT use
;
3476 register valueT mask
;
3478 register valueT unmask
;
3480 /* JF << of >= number of bits in the object is undefined. In
3481 particular SPARC (Sun 4) has problems */
3482 if (nbytes
>= sizeof (valueT
))
3485 if (nbytes
> sizeof (valueT
))
3488 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3492 /* Don't store these bits. */
3493 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
);
3494 hibit
= (valueT
) 1 << (nbytes
* BITS_PER_CHAR
- 1);
3497 unmask
= ~mask
; /* Do store these bits. */
3500 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3501 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3504 get
= exp
->X_add_number
;
3506 if ((get
& mask
) != 0
3507 && ((get
& mask
) != mask
3508 || (get
& hibit
) == 0))
3509 { /* Leading bits contain both 0s & 1s. */
3510 as_warn (_("Value 0x%lx truncated to 0x%lx."),
3511 (unsigned long) get
, (unsigned long) use
);
3513 /* put bytes in right order. */
3514 md_number_to_chars (p
, use
, (int) nbytes
);
3516 else if (op
== O_big
)
3519 LITTLENUM_TYPE
*nums
;
3521 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3523 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3526 as_warn (_("Bignum truncated to %d bytes"), nbytes
);
3530 if (target_big_endian
)
3532 while (nbytes
> size
)
3534 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3535 nbytes
-= CHARS_PER_LITTLENUM
;
3536 p
+= CHARS_PER_LITTLENUM
;
3539 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3543 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3544 size
-= CHARS_PER_LITTLENUM
;
3545 p
+= CHARS_PER_LITTLENUM
;
3550 nums
= generic_bignum
;
3553 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3555 size
-= CHARS_PER_LITTLENUM
;
3556 p
+= CHARS_PER_LITTLENUM
;
3557 nbytes
-= CHARS_PER_LITTLENUM
;
3562 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3563 nbytes
-= CHARS_PER_LITTLENUM
;
3564 p
+= CHARS_PER_LITTLENUM
;
3570 memset (p
, 0, nbytes
);
3572 /* Now we need to generate a fixS to record the symbol value.
3573 This is easy for BFD. For other targets it can be more
3574 complex. For very complex cases (currently, the HPPA and
3575 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3576 want. For simpler cases, you can define TC_CONS_RELOC to be
3577 the name of the reloc code that should be stored in the fixS.
3578 If neither is defined, the code uses NO_RELOC if it is
3579 defined, and otherwise uses 0. */
3581 #ifdef BFD_ASSEMBLER
3582 #ifdef TC_CONS_FIX_NEW
3583 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3586 bfd_reloc_code_real_type r
;
3603 as_bad (_("unsupported BFD relocation size %u"), nbytes
);
3607 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
,
3612 #ifdef TC_CONS_FIX_NEW
3613 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3615 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3616 it is defined, otherwise use NO_RELOC if it is defined,
3618 #ifndef TC_CONS_RELOC
3620 #define TC_CONS_RELOC NO_RELOC
3622 #define TC_CONS_RELOC 0
3625 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3627 #endif /* TC_CONS_FIX_NEW */
3628 #endif /* BFD_ASSEMBLER */
3632 #ifdef BITFIELD_CONS_EXPRESSIONS
3634 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3635 w:x,y:z, where w and y are bitwidths and x and y are values. They
3636 then pack them all together. We do a little better in that we allow
3637 them in words, longs, etc. and we'll pack them in target byte order
3640 The rules are: pack least significat bit first, if a field doesn't
3641 entirely fit, put it in the next unit. Overflowing the bitfield is
3642 explicitly *not* even a warning. The bitwidth should be considered
3645 To use this function the tc-XXX.h file should define
3646 BITFIELD_CONS_EXPRESSIONS. */
3649 parse_bitfield_cons (exp
, nbytes
)
3651 unsigned int nbytes
;
3653 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3654 char *hold
= input_line_pointer
;
3656 (void) expression (exp
);
3658 if (*input_line_pointer
== ':')
3664 unsigned long width
;
3666 if (*input_line_pointer
!= ':')
3668 input_line_pointer
= hold
;
3670 } /* next piece is not a bitfield */
3672 /* In the general case, we can't allow
3673 full expressions with symbol
3674 differences and such. The relocation
3675 entries for symbols not defined in this
3676 assembly would require arbitrary field
3677 widths, positions, and masks which most
3678 of our current object formats don't
3681 In the specific case where a symbol
3682 *is* defined in this assembly, we
3683 *could* build fixups and track it, but
3684 this could lead to confusion for the
3685 backends. I'm lazy. I'll take any
3686 SEG_ABSOLUTE. I think that means that
3687 you can use a previous .set or
3688 .equ type symbol. xoxorich. */
3690 if (exp
->X_op
== O_absent
)
3692 as_warn (_("using a bit field width of zero"));
3693 exp
->X_add_number
= 0;
3694 exp
->X_op
= O_constant
;
3695 } /* implied zero width bitfield */
3697 if (exp
->X_op
!= O_constant
)
3699 *input_line_pointer
= '\0';
3700 as_bad (_("field width \"%s\" too complex for a bitfield"), hold
);
3701 *input_line_pointer
= ':';
3702 demand_empty_rest_of_line ();
3706 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3708 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3709 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3710 width
= BITS_PER_CHAR
* nbytes
;
3713 if (width
> bits_available
)
3715 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3716 input_line_pointer
= hold
;
3717 exp
->X_add_number
= value
;
3721 hold
= ++input_line_pointer
; /* skip ':' */
3723 (void) expression (exp
);
3724 if (exp
->X_op
!= O_constant
)
3726 char cache
= *input_line_pointer
;
3728 *input_line_pointer
= '\0';
3729 as_bad (_("field value \"%s\" too complex for a bitfield"), hold
);
3730 *input_line_pointer
= cache
;
3731 demand_empty_rest_of_line ();
3735 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3736 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3738 if ((bits_available
-= width
) == 0
3739 || is_it_end_of_statement ()
3740 || *input_line_pointer
!= ',')
3743 } /* all the bitfields we're gonna get */
3745 hold
= ++input_line_pointer
;
3746 (void) expression (exp
);
3747 } /* forever loop */
3749 exp
->X_add_number
= value
;
3750 exp
->X_op
= O_constant
;
3751 exp
->X_unsigned
= 1;
3752 } /* if looks like a bitfield */
3753 } /* parse_bitfield_cons() */
3755 #endif /* BITFIELD_CONS_EXPRESSIONS */
3757 /* Handle an MRI style string expression. */
3760 parse_mri_cons (exp
, nbytes
)
3762 unsigned int nbytes
;
3764 if (*input_line_pointer
!= '\''
3765 && (input_line_pointer
[1] != '\''
3766 || (*input_line_pointer
!= 'A'
3767 && *input_line_pointer
!= 'E')))
3768 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3772 unsigned int result
= 0;
3774 /* An MRI style string. Cut into as many bytes as will fit into
3775 a nbyte chunk, left justify if necessary, and separate with
3776 commas so we can try again later. */
3777 if (*input_line_pointer
== 'A')
3778 ++input_line_pointer
;
3779 else if (*input_line_pointer
== 'E')
3781 as_bad (_("EBCDIC constants are not supported"));
3782 ++input_line_pointer
;
3785 input_line_pointer
++;
3786 for (scan
= 0; scan
< nbytes
; scan
++)
3788 if (*input_line_pointer
== '\'')
3790 if (input_line_pointer
[1] == '\'')
3792 input_line_pointer
++;
3797 result
= (result
<< 8) | (*input_line_pointer
++);
3801 while (scan
< nbytes
)
3806 /* Create correct expression */
3807 exp
->X_op
= O_constant
;
3808 exp
->X_add_number
= result
;
3809 /* Fake it so that we can read the next char too */
3810 if (input_line_pointer
[0] != '\'' ||
3811 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3813 input_line_pointer
-= 2;
3814 input_line_pointer
[0] = ',';
3815 input_line_pointer
[1] = '\'';
3818 input_line_pointer
++;
3822 #ifdef REPEAT_CONS_EXPRESSIONS
3824 /* Parse a repeat expression for cons. This is used by the MIPS
3825 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3826 object file COUNT times.
3828 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3831 parse_repeat_cons (exp
, nbytes
)
3833 unsigned int nbytes
;
3840 if (*input_line_pointer
!= ':')
3842 /* No repeat count. */
3846 ++input_line_pointer
;
3847 expression (&count
);
3848 if (count
.X_op
!= O_constant
3849 || count
.X_add_number
<= 0)
3851 as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
3855 /* The cons function is going to output this expression once. So we
3856 output it count - 1 times. */
3857 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3858 emit_expr (exp
, nbytes
);
3861 #endif /* REPEAT_CONS_EXPRESSIONS */
3863 /* Parse a floating point number represented as a hex constant. This
3864 permits users to specify the exact bits they want in the floating
3868 hex_float (float_type
, bytes
)
3902 as_bad (_("Unknown floating type type '%c'"), float_type
);
3906 /* It would be nice if we could go through expression to parse the
3907 hex constant, but if we get a bignum it's a pain to sort it into
3908 the buffer correctly. */
3910 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3914 /* The MRI assembler accepts arbitrary underscores strewn about
3915 through the hex constant, so we ignore them as well. */
3916 if (*input_line_pointer
== '_')
3918 ++input_line_pointer
;
3924 as_warn (_("Floating point constant too large"));
3927 d
= hex_value (*input_line_pointer
) << 4;
3928 ++input_line_pointer
;
3929 while (*input_line_pointer
== '_')
3930 ++input_line_pointer
;
3931 if (hex_p (*input_line_pointer
))
3933 d
+= hex_value (*input_line_pointer
);
3934 ++input_line_pointer
;
3936 if (target_big_endian
)
3939 bytes
[length
- i
- 1] = d
;
3945 if (target_big_endian
)
3946 memset (bytes
+ i
, 0, length
- i
);
3948 memset (bytes
, 0, length
- i
);
3957 * CONStruct some more frag chars of .floats .ffloats etc.
3958 * Makes 0 or more new frags.
3959 * If need_pass_2 == 1, no frags are emitted.
3960 * This understands only floating literals, not expressions. Sorry.
3962 * A floating constant is defined by atof_generic(), except it is preceded
3963 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3964 * reading, I decided to be incompatible. This always tries to give you
3965 * rounded bits to the precision of the pseudo-op. Former AS did premature
3966 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3967 * a choice of 2 flavours of noise according to which of 2 floating-point
3968 * scanners you directed AS to use.
3970 * In: input_line_pointer->whitespace before, or '0' of flonum.
3975 float_cons (float_type
)
3976 /* Clobbers input_line-pointer, checks end-of-line. */
3977 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3980 int length
; /* Number of chars in an object. */
3981 register char *err
; /* Error from scanning floating literal. */
3982 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3984 if (is_it_end_of_statement ())
3986 demand_empty_rest_of_line ();
3990 #ifdef md_flush_pending_output
3991 md_flush_pending_output ();
3996 /* input_line_pointer->1st char of a flonum (we hope!). */
3999 /* Skip any 0{letter} that may be present. Don't even check if the
4000 * letter is legal. Someone may invent a "z" format and this routine
4001 * has no use for such information. Lusers beware: you get
4002 * diagnostics if your input is ill-conditioned.
4004 if (input_line_pointer
[0] == '0'
4005 && isalpha ((unsigned char) input_line_pointer
[1]))
4006 input_line_pointer
+= 2;
4008 /* Accept :xxxx, where the x's are hex digits, for a floating
4009 point with the exact digits specified. */
4010 if (input_line_pointer
[0] == ':')
4012 ++input_line_pointer
;
4013 length
= hex_float (float_type
, temp
);
4016 ignore_rest_of_line ();
4022 err
= md_atof (float_type
, temp
, &length
);
4023 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
4027 as_bad (_("Bad floating literal: %s"), err
);
4028 ignore_rest_of_line ();
4039 #ifdef REPEAT_CONS_EXPRESSIONS
4040 if (*input_line_pointer
== ':')
4042 expressionS count_exp
;
4044 ++input_line_pointer
;
4045 expression (&count_exp
);
4046 if (count_exp
.X_op
!= O_constant
4047 || count_exp
.X_add_number
<= 0)
4049 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4052 count
= count_exp
.X_add_number
;
4056 while (--count
>= 0)
4058 p
= frag_more (length
);
4059 memcpy (p
, temp
, (unsigned int) length
);
4064 while (*input_line_pointer
++ == ',');
4066 --input_line_pointer
; /* Put terminator back into stream. */
4067 demand_empty_rest_of_line ();
4068 } /* float_cons() */
4070 /* Return the size of a LEB128 value */
4073 sizeof_sleb128 (value
)
4076 register int size
= 0;
4077 register unsigned byte
;
4081 byte
= (value
& 0x7f);
4082 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4083 Fortunately, we can structure things so that the extra work reduces
4084 to a noop on systems that do things "properly". */
4085 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4088 while (!(((value
== 0) && ((byte
& 0x40) == 0))
4089 || ((value
== -1) && ((byte
& 0x40) != 0))));
4095 sizeof_uleb128 (value
)
4098 register int size
= 0;
4099 register unsigned byte
;
4103 byte
= (value
& 0x7f);
4113 sizeof_leb128 (value
, sign
)
4118 return sizeof_sleb128 ((offsetT
) value
);
4120 return sizeof_uleb128 (value
);
4123 /* Output a LEB128 value. */
4126 output_sleb128 (p
, value
)
4130 register char *orig
= p
;
4135 unsigned byte
= (value
& 0x7f);
4137 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4138 Fortunately, we can structure things so that the extra work reduces
4139 to a noop on systems that do things "properly". */
4140 value
= (value
>> 7) | ~(-(offsetT
)1 >> 7);
4142 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
4143 || ((value
== -1) && ((byte
& 0x40) != 0))));
4155 output_uleb128 (p
, value
)
4163 unsigned byte
= (value
& 0x7f);
4166 /* More bytes to follow. */
4177 output_leb128 (p
, value
, sign
)
4183 return output_sleb128 (p
, (offsetT
) value
);
4185 return output_uleb128 (p
, value
);
4188 /* Do the same for bignums. We combine sizeof with output here in that
4189 we don't output for NULL values of P. It isn't really as critical as
4190 for "normal" values that this be streamlined. */
4193 output_big_sleb128 (p
, bignum
, size
)
4195 LITTLENUM_TYPE
*bignum
;
4203 /* Strip leading sign extensions off the bignum. */
4204 while (size
> 0 && bignum
[size
-1] == (LITTLENUM_TYPE
)-1)
4209 if (loaded
< 7 && size
> 0)
4211 val
|= (*bignum
<< loaded
);
4212 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4223 if ((val
== 0 && (byte
& 0x40) == 0)
4224 || (~(val
| ~(((valueT
)1 << loaded
) - 1)) == 0
4225 && (byte
& 0x40) != 0))
4233 while (byte
& 0x80);
4239 output_big_uleb128 (p
, bignum
, size
)
4241 LITTLENUM_TYPE
*bignum
;
4249 /* Strip leading zeros off the bignum. */
4250 /* XXX: Is this needed? */
4251 while (size
> 0 && bignum
[size
-1] == 0)
4256 if (loaded
< 7 && size
> 0)
4258 val
|= (*bignum
<< loaded
);
4259 loaded
+= 8 * CHARS_PER_LITTLENUM
;
4268 if (size
> 0 || val
)
4275 while (byte
& 0x80);
4281 output_big_leb128 (p
, bignum
, size
, sign
)
4283 LITTLENUM_TYPE
*bignum
;
4287 return output_big_sleb128 (p
, bignum
, size
);
4289 return output_big_uleb128 (p
, bignum
, size
);
4292 /* Generate the appropriate fragments for a given expression to emit a
4296 emit_leb128_expr(exp
, sign
)
4300 operatorT op
= exp
->X_op
;
4302 if (op
== O_absent
|| op
== O_illegal
)
4304 as_warn (_("zero assumed for missing expression"));
4305 exp
->X_add_number
= 0;
4308 else if (op
== O_big
&& exp
->X_add_number
<= 0)
4310 as_bad (_("floating point number invalid; zero assumed"));
4311 exp
->X_add_number
= 0;
4314 else if (op
== O_register
)
4316 as_warn (_("register value used as expression"));
4320 if (op
== O_constant
)
4322 /* If we've got a constant, emit the thing directly right now. */
4324 valueT value
= exp
->X_add_number
;
4328 size
= sizeof_leb128 (value
, sign
);
4329 p
= frag_more (size
);
4330 output_leb128 (p
, value
, sign
);
4332 else if (op
== O_big
)
4334 /* O_big is a different sort of constant. */
4339 size
= output_big_leb128 (NULL
, generic_bignum
, exp
->X_add_number
, sign
);
4340 p
= frag_more (size
);
4341 output_big_leb128 (p
, generic_bignum
, exp
->X_add_number
, sign
);
4345 /* Otherwise, we have to create a variable sized fragment and
4346 resolve things later. */
4348 frag_var (rs_leb128
, sizeof_uleb128 (~(valueT
)0), 0, sign
,
4349 make_expr_symbol (exp
), 0, (char *) NULL
);
4353 /* Parse the .sleb128 and .uleb128 pseudos. */
4363 emit_leb128_expr (&exp
, sign
);
4364 } while (*input_line_pointer
++ == ',');
4366 input_line_pointer
--;
4367 demand_empty_rest_of_line ();
4373 * We read 0 or more ',' seperated, double-quoted strings.
4375 * Caller should have checked need_pass_2 is FALSE because we don't check it.
4380 stringer (append_zero
) /* Worker to do .ascii etc statements. */
4381 /* Checks end-of-line. */
4382 register int append_zero
; /* 0: don't append '\0', else 1 */
4384 register unsigned int c
;
4387 #ifdef md_flush_pending_output
4388 md_flush_pending_output ();
4392 * The following awkward logic is to parse ZERO or more strings,
4393 * comma seperated. Recall a string expression includes spaces
4394 * before the opening '\"' and spaces after the closing '\"'.
4395 * We fake a leading ',' if there is (supposed to be)
4396 * a 1st, expression. We keep demanding expressions for each
4399 if (is_it_end_of_statement ())
4401 c
= 0; /* Skip loop. */
4402 ++input_line_pointer
; /* Compensate for end of loop. */
4406 c
= ','; /* Do loop. */
4408 while (c
== ',' || c
== '<' || c
== '"')
4411 switch (*input_line_pointer
)
4414 ++input_line_pointer
; /*->1st char of string. */
4415 start
= input_line_pointer
;
4416 while (is_a_char (c
= next_char_of_string ()))
4418 FRAG_APPEND_1_CHAR (c
);
4422 FRAG_APPEND_1_CHAR (0);
4424 know (input_line_pointer
[-1] == '\"');
4428 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4429 will emit .string with a filename in the .debug section
4430 after a sequence of constants. See the comment in
4431 emit_expr for the sequence. emit_expr will set
4432 dwarf_file_string to non-zero if this string might be a
4433 source file name. */
4434 if (strcmp (segment_name (now_seg
), ".debug") != 0)
4435 dwarf_file_string
= 0;
4436 else if (dwarf_file_string
)
4438 c
= input_line_pointer
[-1];
4439 input_line_pointer
[-1] = '\0';
4440 listing_source_file (start
);
4441 input_line_pointer
[-1] = c
;
4448 input_line_pointer
++;
4449 c
= get_single_number ();
4450 FRAG_APPEND_1_CHAR (c
);
4451 if (*input_line_pointer
!= '>')
4453 as_bad (_("Expected <nn>"));
4455 input_line_pointer
++;
4458 input_line_pointer
++;
4462 c
= *input_line_pointer
;
4465 demand_empty_rest_of_line ();
4468 /* FIXME-SOMEDAY: I had trouble here on characters with the
4469 high bits set. We'll probably also have trouble with
4470 multibyte chars, wide chars, etc. Also be careful about
4471 returning values bigger than 1 byte. xoxorich. */
4474 next_char_of_string ()
4476 register unsigned int c
;
4478 c
= *input_line_pointer
++ & CHAR_MASK
;
4486 as_warn (_("Unterminated string: Newline inserted."));
4487 bump_line_counters ();
4490 #ifndef NO_STRING_ESCAPES
4492 switch (c
= *input_line_pointer
++)
4520 break; /* As itself. */
4536 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
4538 number
= number
* 8 + c
- '0';
4542 --input_line_pointer
;
4551 c
= *input_line_pointer
++;
4552 while (isxdigit (c
))
4555 number
= number
* 16 + c
- '0';
4556 else if (isupper (c
))
4557 number
= number
* 16 + c
- 'A' + 10;
4559 number
= number
* 16 + c
- 'a' + 10;
4560 c
= *input_line_pointer
++;
4563 --input_line_pointer
;
4568 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4569 as_warn (_("Unterminated string: Newline inserted."));
4571 bump_line_counters ();
4576 #ifdef ONLY_STANDARD_ESCAPES
4577 as_bad (_("Bad escaped character in string, '?' assumed"));
4579 #endif /* ONLY_STANDARD_ESCAPES */
4582 } /* switch on escaped char */
4584 #endif /* ! defined (NO_STRING_ESCAPES) */
4588 } /* switch on char */
4590 } /* next_char_of_string() */
4593 get_segmented_expression (expP
)
4594 register expressionS
*expP
;
4596 register segT retval
;
4598 retval
= expression (expP
);
4599 if (expP
->X_op
== O_illegal
4600 || expP
->X_op
== O_absent
4601 || expP
->X_op
== O_big
)
4603 as_bad (_("expected address expression; zero assumed"));
4604 expP
->X_op
= O_constant
;
4605 expP
->X_add_number
= 0;
4606 retval
= absolute_section
;
4612 get_known_segmented_expression (expP
)
4613 register expressionS
*expP
;
4615 register segT retval
;
4617 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
4619 /* There is no easy way to extract the undefined symbol from the
4621 if (expP
->X_add_symbol
!= NULL
4622 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
4623 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4624 S_GET_NAME (expP
->X_add_symbol
));
4626 as_warn (_("some symbol undefined; zero assumed"));
4627 retval
= absolute_section
;
4628 expP
->X_op
= O_constant
;
4629 expP
->X_add_number
= 0;
4631 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
4633 } /* get_known_segmented_expression() */
4636 get_absolute_expression ()
4641 if (exp
.X_op
!= O_constant
)
4643 if (exp
.X_op
!= O_absent
)
4644 as_bad (_("bad or irreducible absolute expression; zero assumed"));
4645 exp
.X_add_number
= 0;
4647 return exp
.X_add_number
;
4650 char /* return terminator */
4651 get_absolute_expression_and_terminator (val_pointer
)
4652 long *val_pointer
; /* return value of expression */
4654 /* FIXME: val_pointer should probably be offsetT *. */
4655 *val_pointer
= (long) get_absolute_expression ();
4656 return (*input_line_pointer
++);
4660 * demand_copy_C_string()
4662 * Like demand_copy_string, but return NULL if the string contains any '\0's.
4663 * Give a warning if that happens.
4666 demand_copy_C_string (len_pointer
)
4671 if ((s
= demand_copy_string (len_pointer
)) != 0)
4675 for (len
= *len_pointer
; len
> 0; len
--)
4682 as_bad (_("This string may not contain \'\\0\'"));
4690 * demand_copy_string()
4692 * Demand string, but return a safe (=private) copy of the string.
4693 * Return NULL if we can't read a string here.
4696 demand_copy_string (lenP
)
4699 register unsigned int c
;
4705 if (*input_line_pointer
== '\"')
4707 input_line_pointer
++; /* Skip opening quote. */
4709 while (is_a_char (c
= next_char_of_string ()))
4711 obstack_1grow (¬es
, c
);
4714 /* JF this next line is so demand_copy_C_string will return a
4715 null terminated string. */
4716 obstack_1grow (¬es
, '\0');
4717 retval
= obstack_finish (¬es
);
4721 as_warn (_("Missing string"));
4723 ignore_rest_of_line ();
4727 } /* demand_copy_string() */
4730 * is_it_end_of_statement()
4732 * In: Input_line_pointer->next character.
4734 * Do: Skip input_line_pointer over all whitespace.
4736 * Out: 1 if input_line_pointer->end-of-line.
4739 is_it_end_of_statement ()
4742 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
4743 } /* is_it_end_of_statement() */
4746 equals (sym_name
, reassign
)
4750 register symbolS
*symbolP
; /* symbol we are working with */
4754 input_line_pointer
++;
4755 if (*input_line_pointer
== '=')
4756 input_line_pointer
++;
4758 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
4759 input_line_pointer
++;
4762 stop
= mri_comment_field (&stopc
);
4764 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4766 /* Turn '. = mumble' into a .org mumble */
4767 register segT segment
;
4770 segment
= get_known_segmented_expression (&exp
);
4772 do_org (segment
, &exp
, 0);
4776 symbolP
= symbol_find_or_make (sym_name
);
4777 /* Permit register names to be redefined. */
4779 && S_IS_DEFINED (symbolP
)
4780 && S_GET_SEGMENT (symbolP
) != reg_section
)
4781 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP
));
4782 pseudo_set (symbolP
);
4786 mri_comment_end (stop
, stopc
);
4789 /* .include -- include a file at this point. */
4802 if (! flag_m68k_mri
)
4804 filename
= demand_copy_string (&i
);
4805 if (filename
== NULL
)
4807 /* demand_copy_string has already printed an error and
4808 called ignore_rest_of_line. */
4816 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4817 && *input_line_pointer
!= ' '
4818 && *input_line_pointer
!= '\t')
4820 obstack_1grow (¬es
, *input_line_pointer
);
4821 ++input_line_pointer
;
4824 obstack_1grow (¬es
, '\0');
4825 filename
= obstack_finish (¬es
);
4826 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4827 ++input_line_pointer
;
4829 demand_empty_rest_of_line ();
4830 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4831 for (i
= 0; i
< include_dir_count
; i
++)
4833 strcpy (path
, include_dirs
[i
]);
4835 strcat (path
, filename
);
4836 if (0 != (try = fopen (path
, "r")))
4845 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4846 register_dependency (path
);
4847 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4848 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4852 add_include_dir (path
)
4857 if (include_dir_count
== 0)
4859 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4860 include_dirs
[0] = "."; /* Current dir */
4861 include_dir_count
= 2;
4865 include_dir_count
++;
4866 include_dirs
= (char **) realloc (include_dirs
,
4867 include_dir_count
* sizeof (*include_dirs
));
4870 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4873 if (i
> include_dir_maxlen
)
4874 include_dir_maxlen
= i
;
4875 } /* add_include_dir() */
4877 /* Output debugging information to denote the source file. */
4880 generate_file_debug ()
4882 if (debug_type
== DEBUG_STABS
)
4883 stabs_generate_asm_file ();
4886 /* Output line number debugging information for the current source line. */
4889 generate_lineno_debug ()
4891 if (debug_type
== DEBUG_STABS
)
4892 stabs_generate_asm_lineno ();
4894 #ifdef OBJ_GENERATE_ASM_LINENO
4895 #ifdef ECOFF_DEBUGGING
4896 /* ECOFF assemblers automatically generate
4897 debugging information. FIXME: This should
4898 probably be handled elsewhere. */
4899 if (debug_type
== DEBUG_NONE
)
4901 if (ecoff_no_current_file ())
4902 debug_type
= DEBUG_ECOFF
;
4905 if (debug_type
== DEBUG_ECOFF
)
4907 unsigned int lineno
;
4910 as_where (&s
, &lineno
);
4911 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
4917 /* Output debugging information to mark a function entry point or end point.
4918 END_P is zero for .func, and non-zero for .endfunc. */
4924 /* Record the current function so that we can issue an error message for
4925 misplaced .func,.endfunc, and also so that .endfunc needs no
4927 static char *current_name
;
4928 static char *current_label
;
4932 if (current_name
== NULL
)
4934 as_bad (_("missing .func"));
4935 ignore_rest_of_line ();
4939 if (debug_type
== DEBUG_STABS
)
4940 stabs_generate_asm_endfunc (current_name
, current_label
);
4942 current_name
= current_label
= NULL
;
4949 if (current_name
!= NULL
)
4951 as_bad (_(".endfunc missing for previous .func"));
4952 ignore_rest_of_line ();
4956 name
= input_line_pointer
;
4957 delim1
= get_symbol_end ();
4958 name
= xstrdup (name
);
4959 *input_line_pointer
= delim1
;
4961 if (*input_line_pointer
!= ',')
4963 char leading_char
= 0;
4964 #ifdef BFD_ASSEMBLER
4965 leading_char
= bfd_get_symbol_leading_char (stdoutput
);
4967 /* Missing entry point, use function's name with the leading
4970 asprintf (&label
, "%c%s", leading_char
, name
);
4976 ++input_line_pointer
;
4978 label
= input_line_pointer
;
4979 delim2
= get_symbol_end ();
4980 label
= xstrdup (label
);
4981 *input_line_pointer
= delim2
;
4984 if (debug_type
== DEBUG_STABS
)
4985 stabs_generate_asm_func (name
, label
);
4987 current_name
= name
;
4988 current_label
= label
;
4991 demand_empty_rest_of_line ();
4998 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
5000 ++input_line_pointer
;
5002 ++input_line_pointer
;
5007 read_print_statistics (file
)
5010 hash_print_statistics (file
, "pseudo-op table", po_hash
);