1 /* read.c - read a source file -
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000 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 /* If your chars aren't 8 bits, you will change this a bit.
24 But then, GNU isn't spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.) */
26 #define MASK_CHAR (0xFF)
28 #define MASK_CHAR ((int)(unsigned char) -1)
31 /* This is the largest known floating point format (for now). It will
32 grow when we do 4361 style flonums. */
33 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
35 /* Routines that read assembler source text to build spagetti in memory.
36 Another group of these functions is in the expr.c module. */
49 #ifndef TC_START_LABEL
50 #define TC_START_LABEL(x,y) (x==':')
53 /* Set by the object-format or the target. */
54 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
55 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
60 else if ((SIZE) >= 4) \
62 else if ((SIZE) >= 2) \
70 char *input_line_pointer; /*->next char of source file to parse. */
72 #if BITS_PER_CHAR != 8
73 /* The following table is indexed by[(char)] and will break if
74 a char does not have exactly 256 states (hopefully 0:255!)! */
79 /* The m88k unfortunately uses @ as a label beginner. */
84 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
89 /* The Delta 68k assembler permits % inside label names. */
94 /* The PowerPC Windows NT assemblers permits ? inside label names. */
99 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
100 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
105 /* The a29k assembler does not permits labels to start with $. */
110 /* The Delta 68k assembler permits ~ at start of label names. */
114 /* Used by is_... macros. our ctype[]. */
115 char lex_type[256] = {
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
117 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
118 0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM, /* 0123456789:;<=>? */
120 LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
122 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
126 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
127 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
128 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
129 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
130 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
131 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
135 Out: 1 if this character ends a line. */
136 char is_end_of_line[256] = {
138 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
140 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
155 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
156 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* */
159 #ifdef IGNORE_OPCODE_CASE
160 char original_case_string[128];
163 /* Functions private to this file. */
165 static char *buffer; /* 1st char of each buffer of lines is here. */
166 static char *buffer_limit; /*->1 + last char in buffer. */
168 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
169 in the tc-<CPU>.h file. See the "Porting GAS" section of the
171 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
173 static char *old_buffer; /* JF a hack. */
174 static char *old_input;
175 static char *old_limit;
177 /* Variables for handling include file directory table. */
179 /* Table of pointers to directories to search for .include's. */
182 /* How many are in the table. */
183 int include_dir_count;
185 /* Length of longest in table. */
186 int include_dir_maxlen = 1;
188 #ifndef WORKING_DOT_WORD
189 struct broken_word *broken_words;
190 int new_broken_words;
193 /* The current offset into the absolute section. We don't try to
194 build frags in the absolute section, since no data can be stored
195 there. We just keep track of the current offset. */
196 addressT abs_section_offset;
198 /* If this line had an MRI style label, it is stored in this variable.
199 This is used by some of the MRI pseudo-ops. */
202 /* This global variable is used to support MRI common sections. We
203 translate such sections into a common symbol. This variable is
204 non-NULL when we are in an MRI common section. */
205 symbolS *mri_common_symbol;
207 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
208 need to align to an even byte boundary unless the next pseudo-op is
209 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
211 static int mri_pending_align;
215 /* This variable is set to be non-zero if the next string we see might
216 be the name of the source file in DWARF debugging information. See
217 the comment in emit_expr for the format we look for. */
218 static int dwarf_file_string;
222 static void cons_worker PARAMS ((int, int));
223 static int scrub_from_string PARAMS ((char *, int));
224 static void do_align PARAMS ((int, char *, int, int));
225 static void s_align PARAMS ((int, int));
226 static void s_lcomm_internal PARAMS ((int, int));
227 static int hex_float PARAMS ((int, char *));
228 static inline int sizeof_sleb128 PARAMS ((offsetT));
229 static inline int sizeof_uleb128 PARAMS ((valueT));
230 static inline int output_sleb128 PARAMS ((char *, offsetT));
231 static inline int output_uleb128 PARAMS ((char *, valueT));
232 static inline int output_big_sleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
233 static inline int output_big_uleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
234 static int output_big_leb128 PARAMS ((char *, LITTLENUM_TYPE *, int, int));
235 static void do_org PARAMS ((segT, expressionS *, int));
236 char *demand_copy_string PARAMS ((int *lenP));
237 static segT get_segmented_expression PARAMS ((expressionS *expP));
238 static segT get_known_segmented_expression PARAMS ((expressionS * expP));
239 static void pobegin PARAMS ((void));
240 static int get_line_sb PARAMS ((sb *));
241 static void generate_file_debug PARAMS ((void));
249 obj_read_begin_hook ();
251 /* Something close -- but not too close -- to a multiple of 1024.
252 The debugging malloc I'm using has 24 bytes of overhead. */
253 obstack_begin (¬es, chunksize);
254 obstack_begin (&cond_obstack, chunksize);
256 /* Use machine dependent syntax. */
257 for (p = line_separator_chars; *p; p++)
258 is_end_of_line[(unsigned char) *p] = 1;
259 /* Use more. FIXME-SOMEDAY. */
265 /* Set up pseudo-op tables. */
267 static struct hash_control *po_hash;
269 static const pseudo_typeS potable[] = {
270 {"abort", s_abort, 0},
271 {"align", s_align_ptwo, 0},
272 {"ascii", stringer, 0},
273 {"asciz", stringer, 1},
274 {"balign", s_align_bytes, 0},
275 {"balignw", s_align_bytes, -2},
276 {"balignl", s_align_bytes, -4},
280 {"common", s_mri_common, 0},
281 {"common.s", s_mri_common, 1},
285 {"dc.d", float_cons, 'd'},
287 {"dc.s", float_cons, 'f'},
289 {"dc.x", float_cons, 'x'},
291 {"dcb.b", s_space, 1},
292 {"dcb.d", s_float_space, 'd'},
293 {"dcb.l", s_space, 4},
294 {"dcb.s", s_float_space, 'f'},
295 {"dcb.w", s_space, 2},
296 {"dcb.x", s_float_space, 'x'},
298 {"ds.b", s_space, 1},
299 {"ds.d", s_space, 8},
300 {"ds.l", s_space, 4},
301 {"ds.p", s_space, 12},
302 {"ds.s", s_space, 4},
303 {"ds.w", s_space, 2},
304 {"ds.x", s_space, 12},
305 {"debug", s_ignore, 0},
310 {"double", float_cons, 'd'},
312 {"eject", listing_eject, 0}, /* Formfeed listing. */
314 {"elsec", s_else, 0},
315 {"elseif", s_elseif, (int) O_ne},
317 {"endc", s_endif, 0},
318 {"endfunc", s_func, 1},
319 {"endif", s_endif, 0},
324 {"exitm", s_mexit, 0},
326 {"extern", s_ignore, 0}, /* We treat all undef as ext. */
327 {"appfile", s_app_file, 1},
328 {"appline", s_app_line, 0},
330 {"file", s_app_file, 0},
332 {"float", float_cons, 'f'},
333 {"format", s_ignore, 0},
335 {"global", s_globl, 0},
336 {"globl", s_globl, 0},
338 {"if", s_if, (int) O_ne},
340 {"ifdef", s_ifdef, 0},
341 {"ifeq", s_if, (int) O_eq},
342 {"ifeqs", s_ifeqs, 0},
343 {"ifge", s_if, (int) O_ge},
344 {"ifgt", s_if, (int) O_gt},
345 {"ifle", s_if, (int) O_le},
346 {"iflt", s_if, (int) O_lt},
348 {"ifndef", s_ifdef, 1},
349 {"ifne", s_if, (int) O_ne},
350 {"ifnes", s_ifeqs, 1},
351 {"ifnotdef", s_ifdef, 1},
352 {"include", s_include, 0},
358 {"lcomm", s_lcomm, 0},
359 {"lflags", listing_flags, 0}, /* Listing flags. */
360 {"linkonce", s_linkonce, 0},
361 {"list", listing_list, 1}, /* Turn listing on. */
362 {"llen", listing_psize, 1},
365 {"macro", s_macro, 0},
366 {"mexit", s_mexit, 0},
368 {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */
369 {"name", s_ignore, 0},
370 {"noformat", s_ignore, 0},
371 {"nolist", listing_list, 0}, /* Turn listing off. */
372 {"nopage", listing_nopage, 0},
374 {"offset", s_struct, 0},
376 {"p2align", s_align_ptwo, 0},
377 {"p2alignw", s_align_ptwo, -2},
378 {"p2alignl", s_align_ptwo, -4},
379 {"page", listing_eject, 0},
380 {"plen", listing_psize, 0},
381 {"print", s_print, 0},
382 {"psize", listing_psize, 0}, /* Set paper size. */
383 {"purgem", s_purgem, 0},
388 {"sbttl", listing_title, 1}, /* Subtitle of listing. */
393 {"single", float_cons, 'f'},
395 {"space", s_space, 0},
396 {"skip", s_space, 0},
397 {"sleb128", s_leb128, 1},
398 {"spc", s_ignore, 0},
399 {"stabd", s_stab, 'd'},
400 {"stabn", s_stab, 'n'},
401 {"stabs", s_stab, 's'},
402 {"string", stringer, 1},
403 {"struct", s_struct, 0},
407 /* This is for gcc to use. It's only just been added (2/94), so gcc
408 won't be able to use it for a while -- probably a year or more.
409 But once this has been released, check with gcc maintainers
410 before deleting it or even changing the spelling. */
411 {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
412 /* If we're folding case -- done for some targets, not necessarily
413 all -- the above string in an input file will be converted to
414 this one. Match it either way... */
415 {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
417 {"title", listing_title, 0}, /* Listing title. */
418 {"ttl", listing_title, 0},
420 {"uleb128", s_leb128, 0},
424 {"xdef", s_globl, 0},
425 {"xref", s_ignore, 0},
426 {"xstabs", s_xstab, 's'},
428 {"zero", s_space, 0},
429 {NULL, NULL, 0} /* End sentinel. */
432 static int pop_override_ok = 0;
433 static const char *pop_table_name;
437 const pseudo_typeS *table;
440 const pseudo_typeS *pop;
441 for (pop = table; pop->poc_name; pop++)
443 errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
444 if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
445 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
450 #ifndef md_pop_insert
451 #define md_pop_insert() pop_insert(md_pseudo_table)
454 #ifndef obj_pop_insert
455 #define obj_pop_insert() pop_insert(obj_pseudo_table)
461 po_hash = hash_new ();
463 /* Do the target-specific pseudo ops. */
464 pop_table_name = "md";
467 /* Now object specific. Skip any that were in the target table. */
468 pop_table_name = "obj";
472 /* Now portable ones. Skip any that we've seen already. */
473 pop_table_name = "standard";
474 pop_insert (potable);
477 #define HANDLE_CONDITIONAL_ASSEMBLY() \
478 if (ignore_input ()) \
480 while (!is_end_of_line[(unsigned char) *input_line_pointer++]) \
481 if (input_line_pointer == buffer_limit) \
486 /* This function is used when scrubbing the characters between #APP
489 static char *scrub_string;
490 static char *scrub_string_end;
493 scrub_from_string (buf, buflen)
499 copy = scrub_string_end - scrub_string;
502 memcpy (buf, scrub_string, copy);
503 scrub_string += copy;
507 /* We read the file, putting things into a web that represents what we
508 have been reading. */
510 read_a_source_file (name)
514 register char *s; /* String of symbol, '\0' appended. */
522 buffer = input_scrub_new_file (name);
525 listing_newline (NULL);
526 register_dependency (name);
528 /* Generate debugging information before we've read anything in to denote
529 this file as the "main" source file and not a subordinate one
530 (e.g. N_SO vs N_SOL in stabs). */
531 generate_file_debug ();
533 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
534 { /* We have another line to parse. */
535 know (buffer_limit[-1] == '\n'); /* Must have a sentinel. */
536 contin: /* JF this goto is my fault I admit it.
537 Someone brave please re-write the whole
538 input section here? Pleeze??? */
539 while (input_line_pointer < buffer_limit)
541 /* We have more of this buffer to parse. */
543 /* We now have input_line_pointer->1st char of next line.
544 If input_line_pointer [-1] == '\n' then we just
545 scanned another line: so bump line counters. */
546 if (is_end_of_line[(unsigned char) input_line_pointer[-1]])
548 #ifdef md_start_line_hook
549 md_start_line_hook ();
551 if (input_line_pointer[-1] == '\n')
552 bump_line_counters ();
556 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
558 /* Text at the start of a line must be a label, we
559 run down and stick a colon in. */
560 if (is_name_beginner (*input_line_pointer))
562 char *line_start = input_line_pointer;
567 HANDLE_CONDITIONAL_ASSEMBLY ();
569 c = get_symbol_end ();
571 /* In MRI mode, the EQU and MACRO pseudoops must
572 be handled specially. */
576 char *rest = input_line_pointer + 1;
580 if (*rest == ' ' || *rest == '\t')
582 if ((strncasecmp (rest, "EQU", 3) == 0
583 || strncasecmp (rest, "SET", 3) == 0)
584 && (rest[3] == ' ' || rest[3] == '\t'))
586 input_line_pointer = rest + 3;
588 strncasecmp (rest, "SET", 3) == 0);
591 if (strncasecmp (rest, "MACRO", 5) == 0
594 || is_end_of_line[(unsigned char) rest[5]]))
598 /* In MRI mode, we need to handle the MACRO
599 pseudo-op specially: we don't want to put the
600 symbol in the symbol table. */
602 #ifdef TC_START_LABEL_WITHOUT_COLON
603 && TC_START_LABEL_WITHOUT_COLON(c,
607 line_label = colon (line_start);
609 line_label = symbol_create (line_start,
614 *input_line_pointer = c;
616 input_line_pointer++;
621 /* We are at the begining of a line, or similar place.
622 We expect a well-formed assembler statement.
623 A "symbol-name:" is a statement.
625 Depending on what compiler is used, the order of these tests
626 may vary to catch most common case 1st.
627 Each test is independent of all other tests at the (top) level.
628 PLEASE make a compiler that doesn't use this assembler.
629 It is crufty to waste a compiler's time encoding things for this
630 assembler, which then wastes more time decoding it.
631 (And communicating via (linear) files is silly!
632 If you must pass stuff, please pass a tree!) */
633 if ((c = *input_line_pointer++) == '\t'
637 c = *input_line_pointer++;
639 know (c != ' '); /* No further leading whitespace. */
642 /* If listing is on, and we are expanding a macro, then give
643 the listing code the contents of the expanded line. */
646 if ((listing & LISTING_MACEXP) && macro_nest > 0)
651 /* Find the end of the current expanded macro line. */
652 for (s = input_line_pointer - 1; *s; ++s)
653 if (is_end_of_line[(unsigned char) *s])
656 /* Copy it for safe keeping. Also give an indication of
657 how much macro nesting is involved at this point. */
658 len = s - (input_line_pointer - 1);
659 copy = (char *) xmalloc (len + macro_nest + 2);
660 memset (copy, '>', macro_nest);
661 copy[macro_nest] = ' ';
662 memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
663 copy[macro_nest + 1 + len] = '\0';
665 /* Install the line with the listing facility. */
666 listing_newline (copy);
669 listing_newline (NULL);
672 /* C is the 1st significant character.
673 Input_line_pointer points after that character. */
674 if (is_name_beginner (c))
676 /* Want user-defined label or pseudo/opcode. */
677 HANDLE_CONDITIONAL_ASSEMBLY ();
679 s = --input_line_pointer;
680 c = get_symbol_end (); /* name's delimiter. */
682 /* C is character after symbol.
683 That character's place in the input line is now '\0'.
684 S points to the beginning of the symbol.
685 [In case of pseudo-op, s->'.'.]
686 Input_line_pointer->'\0' where c was. */
687 if (TC_START_LABEL (c, input_line_pointer))
691 char *rest = input_line_pointer + 1;
693 /* In MRI mode, \tsym: set 0 is permitted. */
697 if (*rest == ' ' || *rest == '\t')
700 if ((strncasecmp (rest, "EQU", 3) == 0
701 || strncasecmp (rest, "SET", 3) == 0)
702 && (rest[3] == ' ' || rest[3] == '\t'))
704 input_line_pointer = rest + 3;
710 line_label = colon (s); /* User-defined label. */
711 /* Put ':' back for error messages' sake. */
712 *input_line_pointer++ = ':';
713 /* Input_line_pointer->after ':'. */
717 || ((c == ' ' || c == '\t')
718 && input_line_pointer[1] == '='
719 #ifdef TC_EQUAL_IN_INSN
720 && !TC_EQUAL_IN_INSN (c, input_line_pointer)
725 demand_empty_rest_of_line ();
729 /* Expect pseudo-op or machine instruction. */
732 #ifdef IGNORE_OPCODE_CASE
736 strncpy (original_case_string, s2, sizeof (original_case_string));
737 original_case_string[sizeof (original_case_string) - 1] = 0;
741 if (isupper ((unsigned char) *s2))
747 if (NO_PSEUDO_DOT || flag_m68k_mri)
749 /* The MRI assembler and the m88k use pseudo-ops
751 pop = (pseudo_typeS *) hash_find (po_hash, s);
752 if (pop != NULL && pop->poc_handler == NULL)
757 || (!flag_m68k_mri && *s == '.'))
761 WARNING: c has next char, which may be end-of-line.
762 We lookup the pseudo-op table with s+1 because we
763 already know that the pseudo-op begins with a '.'. */
766 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
768 /* In MRI mode, we may need to insert an
769 automatic alignment directive. What a hack
771 if (mri_pending_align
773 || !((pop->poc_handler == cons
774 && pop->poc_val == 1)
775 || (pop->poc_handler == s_space
776 && pop->poc_val == 1)
777 #ifdef tc_conditional_pseudoop
778 || tc_conditional_pseudoop (pop)
780 || pop->poc_handler == s_if
781 || pop->poc_handler == s_ifdef
782 || pop->poc_handler == s_ifc
783 || pop->poc_handler == s_ifeqs
784 || pop->poc_handler == s_else
785 || pop->poc_handler == s_endif
786 || pop->poc_handler == s_globl
787 || pop->poc_handler == s_ignore)))
789 do_align (1, (char *) NULL, 0, 0);
790 mri_pending_align = 0;
792 if (line_label != NULL)
794 symbol_set_frag (line_label, frag_now);
795 S_SET_VALUE (line_label, frag_now_fix ());
799 /* Print the error msg now, while we still can. */
802 as_bad (_("Unknown pseudo-op: `%s'"), s);
803 *input_line_pointer = c;
808 /* Put it back for error messages etc. */
809 *input_line_pointer = c;
810 /* The following skip of whitespace is compulsory.
811 A well shaped space is sometimes all that separates
812 keyword from operands. */
813 if (c == ' ' || c == '\t')
814 input_line_pointer++;
816 /* Input_line is restored.
817 Input_line_pointer->1st non-blank char
818 after pseudo-operation. */
819 (*pop->poc_handler) (pop->poc_val);
821 /* If that was .end, just get out now. */
822 if (pop->poc_handler == s_end)
828 #ifdef QUOTES_IN_INSN
832 /* WARNING: c has char, which may be end-of-line. */
833 /* Also: input_line_pointer->`\0` where c was. */
834 *input_line_pointer = c;
835 while (!is_end_of_line[(unsigned char) *input_line_pointer]
837 #ifdef TC_EOL_IN_INSN
838 || TC_EOL_IN_INSN (input_line_pointer)
842 if (flag_m68k_mri && *input_line_pointer == '\'')
844 #ifdef QUOTES_IN_INSN
847 else if (*input_line_pointer == '"')
849 else if (*input_line_pointer == '\\')
852 input_line_pointer++;
855 c = *input_line_pointer;
856 *input_line_pointer = '\0';
858 generate_lineno_debug ();
866 if (check_macro (s, &out, '\0', &err, ¯o))
870 *input_line_pointer++ = c;
871 input_scrub_include_sb (&out,
872 input_line_pointer, 1);
875 input_scrub_next_buffer (&input_line_pointer);
877 md_macro_info (macro);
883 if (mri_pending_align)
885 do_align (1, (char *) NULL, 0, 0);
886 mri_pending_align = 0;
887 if (line_label != NULL)
889 symbol_set_frag (line_label, frag_now);
890 S_SET_VALUE (line_label, frag_now_fix ());
894 md_assemble (s); /* Assemble 1 instruction. */
896 *input_line_pointer++ = c;
898 /* We resume loop AFTER the end-of-line from
905 /* Empty statement? */
906 if (is_end_of_line[(unsigned char) c])
909 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB)
910 && isdigit ((unsigned char) c))
912 /* local label ("4:") */
913 char *backup = input_line_pointer;
915 HANDLE_CONDITIONAL_ASSEMBLY ();
919 /* Read the whole number. */
920 while (isdigit ((unsigned char) *input_line_pointer))
922 temp = (temp * 10) + *input_line_pointer - '0';
923 ++input_line_pointer;
926 if (LOCAL_LABELS_DOLLAR
927 && *input_line_pointer == '$'
928 && *(input_line_pointer + 1) == ':')
930 input_line_pointer += 2;
932 if (dollar_label_defined (temp))
934 as_fatal (_("label \"%d$\" redefined"), temp);
937 define_dollar_label (temp);
938 colon (dollar_label_name (temp, 0));
943 && *input_line_pointer++ == ':')
945 fb_label_instance_inc (temp);
946 colon (fb_label_name (temp, 0));
950 input_line_pointer = backup;
951 } /* local label ("4:") */
953 if (c && strchr (line_comment_chars, c))
954 { /* Its a comment. Better say APP or NO_APP. */
958 unsigned int new_length;
961 bump_line_counters ();
962 s = input_line_pointer;
963 if (strncmp (s, "APP\n", 4))
964 continue; /* We ignore it */
967 ends = strstr (s, "#NO_APP\n");
971 unsigned int tmp_len;
974 /* The end of the #APP wasn't in this buffer. We
975 keep reading in buffers until we find the #NO_APP
976 that goes with this #APP There is one. The specs
978 tmp_len = buffer_limit - s;
979 tmp_buf = xmalloc (tmp_len + 1);
980 memcpy (tmp_buf, s, tmp_len);
983 new_tmp = input_scrub_next_buffer (&buffer);
987 buffer_limit = new_tmp;
988 input_line_pointer = buffer;
989 ends = strstr (buffer, "#NO_APP\n");
993 num = buffer_limit - buffer;
995 tmp_buf = xrealloc (tmp_buf, tmp_len + num);
996 memcpy (tmp_buf + tmp_len, buffer, num);
1001 input_line_pointer = ends ? ends + 8 : NULL;
1009 input_line_pointer = ends + 8;
1013 scrub_string_end = ends;
1015 new_length = ends - s;
1016 new_buf = (char *) xmalloc (new_length);
1023 space = (new_buf + new_length) - new_tmp;
1024 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1032 new_buf = xrealloc (new_buf, new_length + 100);
1033 new_tmp = new_buf + new_length;
1039 old_buffer = buffer;
1040 old_input = input_line_pointer;
1041 old_limit = buffer_limit;
1043 input_line_pointer = new_buf;
1044 buffer_limit = new_tmp;
1049 HANDLE_CONDITIONAL_ASSEMBLY ();
1051 #ifdef tc_unrecognized_line
1052 if (tc_unrecognized_line (c))
1055 /* as_warn (_("Junk character %d."),c); Now done by ignore_rest. */
1056 input_line_pointer--; /* Report unknown char as ignored. */
1057 ignore_rest_of_line ();
1060 #ifdef md_after_pass_hook
1061 md_after_pass_hook ();
1067 bump_line_counters ();
1070 buffer = old_buffer;
1071 input_line_pointer = old_input;
1072 buffer_limit = old_limit;
1084 /* Close the input file. */
1085 input_scrub_close ();
1086 #ifdef WARN_COMMENTS
1088 if (warn_comment && found_comment)
1089 as_warn_where (found_comment_file, found_comment,
1090 "first comment found here");
1095 /* For most MRI pseudo-ops, the line actually ends at the first
1096 nonquoted space. This function looks for that point, stuffs a null
1097 in, and sets *STOPCP to the character that used to be there, and
1098 returns the location.
1100 Until I hear otherwise, I am going to assume that this is only true
1101 for the m68k MRI assembler. */
1104 mri_comment_field (stopcp)
1111 know (flag_m68k_mri);
1113 for (s = input_line_pointer;
1114 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1122 for (s = input_line_pointer;
1123 !is_end_of_line[(unsigned char) *s];
1133 /* Skip to the end of an MRI comment field. */
1136 mri_comment_end (stop, stopc)
1142 input_line_pointer = stop;
1144 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1145 ++input_line_pointer;
1150 int ignore ATTRIBUTE_UNUSED;
1152 as_fatal (_(".abort detected. Abandoning ship."));
1155 /* Guts of .align directive. N is the power of two to which to align.
1156 FILL may be NULL, or it may point to the bytes of the fill pattern.
1157 LEN is the length of whatever FILL points to, if anything. MAX is
1158 the maximum number of characters to skip when doing the alignment,
1159 or 0 if there is no maximum. */
1162 do_align (n, fill, len, max)
1169 md_do_align (n, fill, len, max, just_record_alignment);
1172 /* Only make a frag if we HAVE to... */
1173 if (n != 0 && !need_pass_2)
1177 if (subseg_text_p (now_seg))
1178 frag_align_code (n, max);
1180 frag_align (n, 0, max);
1183 frag_align (n, *fill, max);
1185 frag_align_pattern (n, fill, len, max);
1189 just_record_alignment:
1192 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1195 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1196 (in bytes). A negative ARG is the negative of the length of the
1197 fill pattern. BYTES_P is non-zero if the alignment value should be
1198 interpreted as the byte boundary, rather than the power of 2. */
1201 s_align (arg, bytes_p)
1205 register unsigned int align;
1213 stop = mri_comment_field (&stopc);
1215 if (is_end_of_line[(unsigned char) *input_line_pointer])
1220 align = arg; /* Default value from pseudo-op table. */
1224 align = get_absolute_expression ();
1230 /* Convert to a power of 2. */
1235 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1238 as_bad (_("Alignment not a power of 2"));
1247 as_bad (_("Alignment too large: %u assumed"), align);
1250 if (*input_line_pointer != ',')
1257 ++input_line_pointer;
1258 if (*input_line_pointer == ',')
1262 fill = get_absolute_expression ();
1267 if (*input_line_pointer != ',')
1271 ++input_line_pointer;
1272 max = get_absolute_expression ();
1279 as_warn (_("expected fill pattern missing"));
1280 do_align (align, (char *) NULL, 0, max);
1295 do_align (align, &fill_char, fill_len, max);
1301 if ((size_t) fill_len > sizeof ab)
1303 md_number_to_chars (ab, fill, fill_len);
1304 do_align (align, ab, fill_len, max);
1308 demand_empty_rest_of_line ();
1311 mri_comment_end (stop, stopc);
1314 /* Handle the .align pseudo-op on machines where ".align 4" means
1315 align to a 4 byte boundary. */
1324 /* Handle the .align pseudo-op on machines where ".align 4" means align
1325 to a 2**4 boundary. */
1336 int ignore ATTRIBUTE_UNUSED;
1338 register char *name;
1342 register symbolS *symbolP;
1347 stop = mri_comment_field (&stopc);
1349 name = input_line_pointer;
1350 c = get_symbol_end ();
1351 /* Just after name is now '\0'. */
1352 p = input_line_pointer;
1356 if (*input_line_pointer != ',')
1358 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1359 ignore_rest_of_line ();
1361 mri_comment_end (stop, stopc);
1365 input_line_pointer++; /* skip ',' */
1367 if ((temp = get_absolute_expression ()) < 0)
1369 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
1370 ignore_rest_of_line ();
1372 mri_comment_end (stop, stopc);
1377 symbolP = symbol_find_or_make (name);
1380 if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
1382 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1383 S_GET_NAME (symbolP));
1384 ignore_rest_of_line ();
1386 mri_comment_end (stop, stopc);
1390 if (S_GET_VALUE (symbolP))
1392 if (S_GET_VALUE (symbolP) != (valueT) temp)
1393 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
1394 S_GET_NAME (symbolP),
1395 (long) S_GET_VALUE (symbolP),
1400 S_SET_VALUE (symbolP, (valueT) temp);
1401 S_SET_EXTERNAL (symbolP);
1405 extern int flag_one;
1406 if (!temp || !flag_one)
1407 S_GET_OTHER(symbolP) = const_flag;
1409 #endif /* not OBJ_VMS */
1410 know (symbolP->sy_frag == &zero_address_frag);
1412 demand_empty_rest_of_line ();
1415 mri_comment_end (stop, stopc);
1418 /* The MRI COMMON pseudo-op. We handle this by creating a common
1419 symbol with the appropriate name. We make s_space do the right
1420 thing by increasing the size. */
1423 s_mri_common (small)
1424 int small ATTRIBUTE_UNUSED;
1440 stop = mri_comment_field (&stopc);
1444 name = input_line_pointer;
1445 if (!isdigit ((unsigned char) *name))
1446 c = get_symbol_end ();
1451 ++input_line_pointer;
1453 while (isdigit ((unsigned char) *input_line_pointer));
1455 c = *input_line_pointer;
1456 *input_line_pointer = '\0';
1458 if (line_label != NULL)
1460 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1461 + (input_line_pointer - name)
1463 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1468 sym = symbol_find_or_make (name);
1469 *input_line_pointer = c;
1473 if (*input_line_pointer != ',')
1477 ++input_line_pointer;
1478 align = get_absolute_expression ();
1481 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1483 as_bad (_("attempt to re-define symbol `%s'"), S_GET_NAME (sym));
1484 ignore_rest_of_line ();
1485 mri_comment_end (stop, stopc);
1489 S_SET_EXTERNAL (sym);
1490 mri_common_symbol = sym;
1494 S_SET_ALIGN (sym, align);
1497 if (line_label != NULL)
1500 exp.X_op = O_symbol;
1501 exp.X_add_symbol = sym;
1502 exp.X_add_number = 0;
1503 symbol_set_value_expression (line_label, &exp);
1504 symbol_set_frag (line_label, &zero_address_frag);
1505 S_SET_SEGMENT (line_label, expr_section);
1508 /* FIXME: We just ignore the small argument, which distinguishes
1509 COMMON and COMMON.S. I don't know what we can do about it. */
1511 /* Ignore the type and hptype. */
1512 if (*input_line_pointer == ',')
1513 input_line_pointer += 2;
1514 if (*input_line_pointer == ',')
1515 input_line_pointer += 2;
1517 demand_empty_rest_of_line ();
1519 mri_comment_end (stop, stopc);
1524 int ignore ATTRIBUTE_UNUSED;
1529 temp = get_absolute_expression ();
1530 if (flag_readonly_data_in_text)
1532 section = text_section;
1536 section = data_section;
1538 subseg_set (section, (subsegT) temp);
1543 demand_empty_rest_of_line ();
1546 /* Handle the .appfile pseudo-op. This is automatically generated by
1547 do_scrub_chars when a preprocessor # line comment is seen with a
1548 file name. This default definition may be overridden by the object
1549 or CPU specific pseudo-ops. This function is also the default
1550 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1554 s_app_file (appfile)
1560 /* Some assemblers tolerate immediately following '"'. */
1561 if ((s = demand_copy_string (&length)) != 0)
1563 /* If this is a fake .appfile, a fake newline was inserted into
1564 the buffer. Passing -2 to new_logical_line tells it to
1567 = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
1569 /* In MRI mode, the preprocessor may have inserted an extraneous
1572 && *input_line_pointer == '\''
1573 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1574 ++input_line_pointer;
1576 demand_empty_rest_of_line ();
1581 listing_source_file (s);
1583 register_dependency (s);
1591 /* Handle the .appline pseudo-op. This is automatically generated by
1592 do_scrub_chars when a preprocessor # line comment is seen. This
1593 default definition may be overridden by the object or CPU specific
1598 int ignore ATTRIBUTE_UNUSED;
1602 /* The given number is that of the next line. */
1603 l = get_absolute_expression () - 1;
1605 /* Some of the back ends can't deal with non-positive line numbers.
1606 Besides, it's silly. */
1607 as_warn (_("Line numbers must be positive; line number %d rejected."),
1611 new_logical_line ((char *) NULL, l);
1614 listing_source_line (l);
1617 demand_empty_rest_of_line ();
1620 /* Handle the .end pseudo-op. Actually, the real work is done in
1621 read_a_source_file. */
1625 int ignore ATTRIBUTE_UNUSED;
1629 /* The MRI assembler permits the start symbol to follow .end,
1630 but we don't support that. */
1632 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1633 && *input_line_pointer != '*'
1634 && *input_line_pointer != '!')
1635 as_warn (_("start address not supported"));
1639 /* Handle the .err pseudo-op. */
1643 int ignore ATTRIBUTE_UNUSED;
1645 as_bad (_(".err encountered"));
1646 demand_empty_rest_of_line ();
1649 /* Handle the MRI fail pseudo-op. */
1653 int ignore ATTRIBUTE_UNUSED;
1660 stop = mri_comment_field (&stopc);
1662 temp = get_absolute_expression ();
1664 as_warn (_(".fail %ld encountered"), (long) temp);
1666 as_bad (_(".fail %ld encountered"), (long) temp);
1668 demand_empty_rest_of_line ();
1671 mri_comment_end (stop, stopc);
1676 int ignore ATTRIBUTE_UNUSED;
1678 expressionS rep_exp;
1680 register long fill = 0;
1683 #ifdef md_flush_pending_output
1684 md_flush_pending_output ();
1687 get_known_segmented_expression (&rep_exp);
1688 if (*input_line_pointer == ',')
1690 input_line_pointer++;
1691 size = get_absolute_expression ();
1692 if (*input_line_pointer == ',')
1694 input_line_pointer++;
1695 fill = get_absolute_expression ();
1699 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1700 #define BSD_FILL_SIZE_CROCK_8 (8)
1701 if (size > BSD_FILL_SIZE_CROCK_8)
1703 as_warn (_(".fill size clamped to %d."), BSD_FILL_SIZE_CROCK_8);
1704 size = BSD_FILL_SIZE_CROCK_8;
1708 as_warn (_("Size negative: .fill ignored."));
1711 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1713 if (rep_exp.X_add_number < 0)
1714 as_warn (_("Repeat < 0, .fill ignored"));
1718 if (size && !need_pass_2)
1720 if (rep_exp.X_op == O_constant)
1722 p = frag_var (rs_fill, (int) size, (int) size,
1723 (relax_substateT) 0, (symbolS *) 0,
1724 (offsetT) rep_exp.X_add_number,
1729 /* We don't have a constant repeat count, so we can't use
1730 rs_fill. We can get the same results out of rs_space,
1731 but its argument is in bytes, so we must multiply the
1732 repeat count by size. */
1735 rep_sym = make_expr_symbol (&rep_exp);
1738 expressionS size_exp;
1739 size_exp.X_op = O_constant;
1740 size_exp.X_add_number = size;
1742 rep_exp.X_op = O_multiply;
1743 rep_exp.X_add_symbol = rep_sym;
1744 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1745 rep_exp.X_add_number = 0;
1746 rep_sym = make_expr_symbol (&rep_exp);
1749 p = frag_var (rs_space, (int) size, (int) size,
1750 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1753 memset (p, 0, (unsigned int) size);
1755 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1756 flavoured AS. The following bizarre behaviour is to be
1757 compatible with above. I guess they tried to take up to 8
1758 bytes from a 4-byte expression and they forgot to sign
1760 #define BSD_FILL_SIZE_CROCK_4 (4)
1761 md_number_to_chars (p, (valueT) fill,
1762 (size > BSD_FILL_SIZE_CROCK_4
1763 ? BSD_FILL_SIZE_CROCK_4
1765 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1766 but emits no error message because it seems a legal thing to do.
1767 It is a degenerate case of .fill but could be emitted by a
1770 demand_empty_rest_of_line ();
1775 int ignore ATTRIBUTE_UNUSED;
1784 stop = mri_comment_field (&stopc);
1788 name = input_line_pointer;
1789 c = get_symbol_end ();
1790 symbolP = symbol_find_or_make (name);
1791 S_SET_EXTERNAL (symbolP);
1793 *input_line_pointer = c;
1795 c = *input_line_pointer;
1798 input_line_pointer++;
1800 if (*input_line_pointer == '\n')
1806 demand_empty_rest_of_line ();
1809 mri_comment_end (stop, stopc);
1812 /* Handle the MRI IRP and IRPC pseudo-ops. */
1824 as_where (&file, &line);
1827 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1828 sb_add_char (&s, *input_line_pointer++);
1832 err = expand_irp (irpc, 0, &s, &out, get_line_sb, '\0');
1834 as_bad_where (file, line, "%s", err);
1838 input_scrub_include_sb (&out, input_line_pointer, 1);
1840 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1843 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1844 the section to only be linked once. However, this is not supported
1845 by most object file formats. This takes an optional argument,
1846 which is what to do about duplicates. */
1850 int ignore ATTRIBUTE_UNUSED;
1852 enum linkonce_type type;
1856 type = LINKONCE_DISCARD;
1858 if (!is_end_of_line[(unsigned char) *input_line_pointer])
1863 s = input_line_pointer;
1864 c = get_symbol_end ();
1865 if (strcasecmp (s, "discard") == 0)
1866 type = LINKONCE_DISCARD;
1867 else if (strcasecmp (s, "one_only") == 0)
1868 type = LINKONCE_ONE_ONLY;
1869 else if (strcasecmp (s, "same_size") == 0)
1870 type = LINKONCE_SAME_SIZE;
1871 else if (strcasecmp (s, "same_contents") == 0)
1872 type = LINKONCE_SAME_CONTENTS;
1874 as_warn (_("unrecognized .linkonce type `%s'"), s);
1876 *input_line_pointer = c;
1879 #ifdef obj_handle_link_once
1880 obj_handle_link_once (type);
1881 #else /* ! defined (obj_handle_link_once) */
1882 #ifdef BFD_ASSEMBLER
1886 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
1887 as_warn (_(".linkonce is not supported for this object file format"));
1889 flags = bfd_get_section_flags (stdoutput, now_seg);
1890 flags |= SEC_LINK_ONCE;
1895 case LINKONCE_DISCARD:
1896 flags |= SEC_LINK_DUPLICATES_DISCARD;
1898 case LINKONCE_ONE_ONLY:
1899 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1901 case LINKONCE_SAME_SIZE:
1902 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
1904 case LINKONCE_SAME_CONTENTS:
1905 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
1908 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
1909 as_bad (_("bfd_set_section_flags: %s"),
1910 bfd_errmsg (bfd_get_error ()));
1912 #else /* ! defined (BFD_ASSEMBLER) */
1913 as_warn (_(".linkonce is not supported for this object file format"));
1914 #endif /* ! defined (BFD_ASSEMBLER) */
1915 #endif /* ! defined (obj_handle_link_once) */
1917 demand_empty_rest_of_line ();
1921 s_lcomm_internal (needs_align, bytes_p)
1922 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1923 (alignment); 0 if it was an ".lcomm" (2 args only). */
1925 /* 1 if the alignment value should be interpreted as the byte boundary,
1926 rather than the power of 2. */
1929 register char *name;
1933 register symbolS *symbolP;
1934 segT current_seg = now_seg;
1935 subsegT current_subseg = now_subseg;
1936 const int max_alignment = 15;
1938 segT bss_seg = bss_section;
1940 name = input_line_pointer;
1941 c = get_symbol_end ();
1942 p = input_line_pointer;
1946 /* Accept an optional comma after the name. The comma used to be
1947 required, but Irix 5 cc does not generate it. */
1948 if (*input_line_pointer == ',')
1950 ++input_line_pointer;
1954 if (*input_line_pointer == '\n')
1956 as_bad (_("Missing size expression"));
1960 if ((temp = get_absolute_expression ()) < 0)
1962 as_warn (_("BSS length (%d.) <0! Ignored."), temp);
1963 ignore_rest_of_line ();
1967 #if defined (TC_MIPS) || defined (TC_ALPHA)
1968 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
1969 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
1971 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1972 if (temp <= bfd_get_gp_size (stdoutput))
1974 bss_seg = subseg_new (".sbss", 1);
1975 seg_info (bss_seg)->bss = 1;
1976 #ifdef BFD_ASSEMBLER
1977 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
1978 as_warn (_("error setting flags for \".sbss\": %s"),
1979 bfd_errmsg (bfd_get_error ()));
1987 TC_IMPLICIT_LCOMM_ALIGNMENT (temp, align);
1989 /* Still zero unless TC_IMPLICIT_LCOMM_ALIGNMENT set it. */
1991 record_alignment (bss_seg, align);
1999 if (*input_line_pointer != ',')
2001 as_bad (_("Expected comma after size"));
2002 ignore_rest_of_line ();
2006 input_line_pointer++;
2009 if (*input_line_pointer == '\n')
2011 as_bad (_("Missing alignment"));
2015 align = get_absolute_expression ();
2019 /* Convert to a power of 2. */
2024 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
2027 as_bad (_("Alignment not a power of 2"));
2032 if (align > max_alignment)
2034 align = max_alignment;
2035 as_warn (_("Alignment too large: %d. assumed."), align);
2040 as_warn (_("Alignment negative. 0 assumed."));
2043 record_alignment (bss_seg, align);
2047 /* Assume some objects may require alignment on some systems. */
2048 #if defined (TC_ALPHA) && ! defined (VMS)
2051 align = ffs (temp) - 1;
2052 if (temp % (1 << align))
2059 symbolP = symbol_find_or_make (name);
2063 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) \
2064 || defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))
2065 #ifdef BFD_ASSEMBLER
2066 (OUTPUT_FLAVOR != bfd_target_aout_flavour
2067 || (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&
2069 (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&
2072 (S_GET_SEGMENT (symbolP) == bss_seg
2073 || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
2077 subseg_set (bss_seg, 1);
2080 frag_align (align, 0, 0);
2082 /* Detach from old frag. */
2083 if (S_GET_SEGMENT (symbolP) == bss_seg)
2084 symbol_get_frag (symbolP)->fr_symbol = NULL;
2086 symbol_set_frag (symbolP, frag_now);
2087 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
2088 (offsetT) temp, (char *) 0);
2091 S_SET_SEGMENT (symbolP, bss_seg);
2094 /* The symbol may already have been created with a preceding
2095 ".globl" directive -- be careful not to step on storage class
2096 in that case. Otherwise, set it to static. */
2097 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2099 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2101 #endif /* OBJ_COFF */
2104 S_SET_SIZE (symbolP, temp);
2108 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
2109 S_GET_NAME (symbolP));
2111 subseg_set (current_seg, current_subseg);
2113 demand_empty_rest_of_line ();
2117 s_lcomm (needs_align)
2120 s_lcomm_internal (needs_align, 0);
2124 s_lcomm_bytes (needs_align)
2127 s_lcomm_internal (needs_align, 1);
2132 int ignore ATTRIBUTE_UNUSED;
2134 register char *name;
2138 register symbolS *symbolP;
2140 /* We permit ANY defined expression: BSD4.2 demands constants. */
2141 name = input_line_pointer;
2142 c = get_symbol_end ();
2143 p = input_line_pointer;
2147 if (*input_line_pointer != ',')
2150 as_bad (_("Expected comma after name \"%s\""), name);
2152 ignore_rest_of_line ();
2156 input_line_pointer++;
2159 if (exp.X_op != O_constant
2160 && exp.X_op != O_register)
2162 as_bad (_("bad expression"));
2163 ignore_rest_of_line ();
2168 symbolP = symbol_find_or_make (name);
2170 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
2171 symbolP->sy_desc == 0) out of this test because coff doesn't have
2172 those fields, and I can't see when they'd ever be tripped. I
2173 don't think I understand why they were here so I may have
2174 introduced a bug. As recently as 1.37 didn't have this test
2175 anyway. xoxorich. */
2177 if (S_GET_SEGMENT (symbolP) == undefined_section
2178 && S_GET_VALUE (symbolP) == 0)
2180 /* The name might be an undefined .global symbol; be sure to
2181 keep the "external" bit. */
2182 S_SET_SEGMENT (symbolP,
2183 (exp.X_op == O_constant
2186 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2190 as_bad (_("Symbol %s already defined"), name);
2194 demand_empty_rest_of_line ();
2197 /* Read a line into an sb. */
2203 char quote1, quote2, inquote;
2205 if (input_line_pointer[-1] == '\n')
2206 bump_line_counters ();
2208 if (input_line_pointer >= buffer_limit)
2210 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2211 if (buffer_limit == 0)
2215 /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
2216 code needs to be changed. */
2225 #ifdef LEX_IS_STRINGQUOTE
2231 while (!is_end_of_line[(unsigned char) *input_line_pointer]
2232 || (inquote != '\0' && *input_line_pointer != '\n'))
2234 if (inquote == *input_line_pointer)
2236 else if (inquote == '\0')
2238 if (*input_line_pointer == quote1)
2240 else if (*input_line_pointer == quote2)
2244 sb_add_char (line, *input_line_pointer++);
2247 while (input_line_pointer < buffer_limit
2248 && is_end_of_line[(unsigned char) *input_line_pointer])
2250 if (input_line_pointer[-1] == '\n')
2251 bump_line_counters ();
2252 ++input_line_pointer;
2258 /* Define a macro. This is an interface to macro.c, which is shared
2259 between gas and gasp. */
2263 int ignore ATTRIBUTE_UNUSED;
2272 as_where (&file, &line);
2275 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2276 sb_add_char (&s, *input_line_pointer++);
2279 if (line_label != NULL)
2280 sb_add_string (&label, S_GET_NAME (line_label));
2282 err = define_macro (0, &s, &label, get_line_sb, &name);
2284 as_bad_where (file, line, "%s", err);
2287 if (line_label != NULL)
2289 S_SET_SEGMENT (line_label, undefined_section);
2290 S_SET_VALUE (line_label, 0);
2291 symbol_set_frag (line_label, &zero_address_frag);
2294 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2295 && hash_find (po_hash, name) != NULL)
2298 && hash_find (po_hash, name + 1) != NULL))
2299 as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
2306 /* Handle the .mexit pseudo-op, which immediately exits a macro
2311 int ignore ATTRIBUTE_UNUSED;
2313 cond_exit_macro (macro_nest);
2314 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2317 /* Switch in and out of MRI mode. */
2321 int ignore ATTRIBUTE_UNUSED;
2325 on = get_absolute_expression ();
2326 old_flag = flag_mri;
2344 /* Operator precedence changes in m68k MRI mode, so we need to
2345 update the operator rankings. */
2346 expr_set_precedence ();
2348 #ifdef MRI_MODE_CHANGE
2350 MRI_MODE_CHANGE (on);
2353 demand_empty_rest_of_line ();
2356 /* Handle changing the location counter. */
2359 do_org (segment, exp, fill)
2364 if (segment != now_seg && segment != absolute_section)
2365 as_bad (_("invalid segment \"%s\"; segment \"%s\" assumed"),
2366 segment_name (segment), segment_name (now_seg));
2368 if (now_seg == absolute_section)
2371 as_warn (_("ignoring fill value in absolute section"));
2372 if (exp->X_op != O_constant)
2374 as_bad (_("only constant offsets supported in absolute section"));
2375 exp->X_add_number = 0;
2377 abs_section_offset = exp->X_add_number;
2382 symbolS *sym = exp->X_add_symbol;
2383 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2385 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2387 /* Handle complex expressions. */
2388 sym = make_expr_symbol (exp);
2392 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2399 int ignore ATTRIBUTE_UNUSED;
2401 register segT segment;
2403 register long temp_fill;
2405 #ifdef md_flush_pending_output
2406 md_flush_pending_output ();
2409 /* The m68k MRI assembler has a different meaning for .org. It
2410 means to create an absolute section at a given address. We can't
2411 support that--use a linker script instead. */
2414 as_bad (_("MRI style ORG pseudo-op not supported"));
2415 ignore_rest_of_line ();
2419 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2420 thing as a sub-segment-relative origin. Any absolute origin is
2421 given a warning, then assumed to be segment-relative. Any
2422 segmented origin expression ("foo+42") had better be in the right
2423 segment or the .org is ignored.
2425 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2426 we never know sub-segment sizes when we are reading code. BSD
2427 will crash trying to emit negative numbers of filler bytes in
2428 certain .orgs. We don't crash, but see as-write for that code.
2430 Don't make frag if need_pass_2==1. */
2431 segment = get_known_segmented_expression (&exp);
2432 if (*input_line_pointer == ',')
2434 input_line_pointer++;
2435 temp_fill = get_absolute_expression ();
2441 do_org (segment, &exp, temp_fill);
2443 demand_empty_rest_of_line ();
2446 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2447 called by the obj-format routine which handles section changing
2448 when in MRI mode. It will create a new section, and return it. It
2449 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2450 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2451 flags will be set in the section. */
2455 char *type ATTRIBUTE_UNUSED;
2465 name = input_line_pointer;
2466 if (!isdigit ((unsigned char) *name))
2467 c = get_symbol_end ();
2472 ++input_line_pointer;
2474 while (isdigit ((unsigned char) *input_line_pointer));
2476 c = *input_line_pointer;
2477 *input_line_pointer = '\0';
2480 name = xstrdup (name);
2482 *input_line_pointer = c;
2484 seg = subseg_new (name, 0);
2486 if (*input_line_pointer == ',')
2490 ++input_line_pointer;
2491 align = get_absolute_expression ();
2492 record_alignment (seg, align);
2496 if (*input_line_pointer == ',')
2498 c = *++input_line_pointer;
2499 c = toupper ((unsigned char) c);
2500 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2503 as_bad (_("unrecognized section type"));
2504 ++input_line_pointer;
2506 #ifdef BFD_ASSEMBLER
2510 flags = SEC_NO_FLAGS;
2512 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2513 else if (*type == 'D' || *type == 'M')
2514 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2515 else if (*type == 'R')
2516 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2517 if (flags != SEC_NO_FLAGS)
2519 if (!bfd_set_section_flags (stdoutput, seg, flags))
2520 as_warn (_("error setting flags for \"%s\": %s"),
2521 bfd_section_name (stdoutput, seg),
2522 bfd_errmsg (bfd_get_error ()));
2528 /* Ignore the HP type. */
2529 if (*input_line_pointer == ',')
2530 input_line_pointer += 2;
2532 demand_empty_rest_of_line ();
2534 #else /* ! TC_M68K */
2543 name = input_line_pointer;
2544 c = get_symbol_end ();
2546 name = xstrdup (name);
2548 *input_line_pointer = c;
2550 seg = subseg_new (name, 0);
2552 if (*input_line_pointer != ',')
2558 ++input_line_pointer;
2560 sectype = input_line_pointer;
2561 c = get_symbol_end ();
2562 if (*sectype == '\0')
2564 else if (strcasecmp (sectype, "text") == 0)
2566 else if (strcasecmp (sectype, "data") == 0)
2568 else if (strcasecmp (sectype, "romdata") == 0)
2571 as_warn (_("unrecognized section type `%s'"), sectype);
2572 *input_line_pointer = c;
2575 if (*input_line_pointer == ',')
2579 ++input_line_pointer;
2581 seccmd = input_line_pointer;
2582 c = get_symbol_end ();
2583 if (strcasecmp (seccmd, "absolute") == 0)
2585 as_bad (_("absolute sections are not supported"));
2586 *input_line_pointer = c;
2587 ignore_rest_of_line ();
2590 else if (strcasecmp (seccmd, "align") == 0)
2594 *input_line_pointer = c;
2595 align = get_absolute_expression ();
2596 record_alignment (seg, align);
2600 as_warn (_("unrecognized section command `%s'"), seccmd);
2601 *input_line_pointer = c;
2605 demand_empty_rest_of_line ();
2607 #else /* ! TC_I960 */
2608 /* The MRI assembler seems to use different forms of .sect for
2609 different targets. */
2610 as_bad ("MRI mode not supported for this target");
2611 ignore_rest_of_line ();
2612 #endif /* ! TC_I960 */
2613 #endif /* ! TC_M68K */
2616 /* Handle the .print pseudo-op. */
2620 int ignore ATTRIBUTE_UNUSED;
2625 s = demand_copy_C_string (&len);
2627 demand_empty_rest_of_line ();
2630 /* Handle the .purgem pseudo-op. */
2634 int ignore ATTRIBUTE_UNUSED;
2636 if (is_it_end_of_statement ())
2638 demand_empty_rest_of_line ();
2648 name = input_line_pointer;
2649 c = get_symbol_end ();
2650 delete_macro (name);
2651 *input_line_pointer = c;
2654 while (*input_line_pointer++ == ',');
2656 --input_line_pointer;
2657 demand_empty_rest_of_line ();
2660 /* Handle the .rept pseudo-op. */
2664 int ignore ATTRIBUTE_UNUSED;
2668 count = get_absolute_expression ();
2670 do_repeat (count, "REPT", "ENDR");
2673 /* This function provides a generic repeat block implementation. It allows
2674 different directives to be used as the start/end keys. */
2677 do_repeat (count, start, end)
2686 if (!buffer_and_nest (start, end, &one, get_line_sb))
2688 as_bad (_("%s without %s"), start, end);
2694 sb_add_sb (&many, &one);
2698 input_scrub_include_sb (&many, input_line_pointer, 1);
2700 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2703 /* Skip to end of current repeat loop; EXTRA indicates how many additional
2704 input buffers to skip. Assumes that conditionals preceding the loop end
2705 are properly nested.
2707 This function makes it easier to implement a premature "break" out of the
2708 loop. The EXTRA arg accounts for other buffers we might have inserted,
2709 such as line substitutions. */
2715 cond_exit_macro (macro_nest);
2716 while (extra-- >= 0)
2717 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2720 /* Handle the .equ, .equiv and .set directives. If EQUIV is 1, then
2721 this is .equiv, and it is an error if the symbol is already
2728 register char *name;
2729 register char delim;
2730 register char *end_name;
2731 register symbolS *symbolP;
2733 /* Especial apologies for the random logic:
2734 this just grew, and could be parsed much more simply!
2736 name = input_line_pointer;
2737 delim = get_symbol_end ();
2738 end_name = input_line_pointer;
2742 if (*input_line_pointer != ',')
2745 as_bad (_("Expected comma after name \"%s\""), name);
2747 ignore_rest_of_line ();
2751 input_line_pointer++;
2754 if (name[0] == '.' && name[1] == '\0')
2756 /* Turn '. = mumble' into a .org mumble. */
2757 register segT segment;
2760 segment = get_known_segmented_expression (&exp);
2763 do_org (segment, &exp, 0);
2769 if ((symbolP = symbol_find (name)) == NULL
2770 && (symbolP = md_undefined_symbol (name)) == NULL)
2773 /* When doing symbol listings, play games with dummy fragments living
2774 outside the normal fragment chain to record the file and line info
2776 if (listing & LISTING_SYMBOLS)
2778 extern struct list_info_struct *listing_tail;
2779 fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
2780 memset (dummy_frag, 0, sizeof (fragS));
2781 dummy_frag->fr_type = rs_fill;
2782 dummy_frag->line = listing_tail;
2783 symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2784 dummy_frag->fr_symbol = symbolP;
2788 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2791 /* "set" symbols are local unless otherwise specified. */
2792 SF_SET_LOCAL (symbolP);
2793 #endif /* OBJ_COFF */
2796 symbol_table_insert (symbolP);
2801 && S_IS_DEFINED (symbolP)
2802 && S_GET_SEGMENT (symbolP) != reg_section)
2803 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2805 pseudo_set (symbolP);
2806 demand_empty_rest_of_line ();
2820 #ifdef md_flush_pending_output
2821 md_flush_pending_output ();
2825 stop = mri_comment_field (&stopc);
2827 /* In m68k MRI mode, we need to align to a word boundary, unless
2829 if (flag_m68k_mri && mult > 1)
2831 if (now_seg == absolute_section)
2833 abs_section_offset += abs_section_offset & 1;
2834 if (line_label != NULL)
2835 S_SET_VALUE (line_label, abs_section_offset);
2837 else if (mri_common_symbol != NULL)
2841 val = S_GET_VALUE (mri_common_symbol);
2844 S_SET_VALUE (mri_common_symbol, val + 1);
2845 if (line_label != NULL)
2847 expressionS *symexp;
2849 symexp = symbol_get_value_expression (line_label);
2850 know (symexp->X_op == O_symbol);
2851 know (symexp->X_add_symbol == mri_common_symbol);
2852 symexp->X_add_number += 1;
2858 do_align (1, (char *) NULL, 0, 0);
2859 if (line_label != NULL)
2861 symbol_set_frag (line_label, frag_now);
2862 S_SET_VALUE (line_label, frag_now_fix ());
2872 if (*input_line_pointer == ',')
2874 ++input_line_pointer;
2879 val.X_op = O_constant;
2880 val.X_add_number = 0;
2883 if (val.X_op != O_constant
2884 || val.X_add_number < - 0x80
2885 || val.X_add_number > 0xff
2886 || (mult != 0 && mult != 1 && val.X_add_number != 0))
2888 if (exp.X_op != O_constant)
2889 as_bad (_("Unsupported variable size or fill value"));
2896 bytes = mult * exp.X_add_number;
2897 for (i = 0; i < exp.X_add_number; i++)
2898 emit_expr (&val, mult);
2903 if (exp.X_op == O_constant)
2907 repeat = exp.X_add_number;
2914 as_warn (_(".space repeat count is zero, ignored"));
2915 else if (repeat < 0)
2916 as_warn (_(".space repeat count is negative, ignored"));
2920 /* If we are in the absolute section, just bump the offset. */
2921 if (now_seg == absolute_section)
2923 abs_section_offset += repeat;
2927 /* If we are secretly in an MRI common section, then
2928 creating space just increases the size of the common
2930 if (mri_common_symbol != NULL)
2932 S_SET_VALUE (mri_common_symbol,
2933 S_GET_VALUE (mri_common_symbol) + repeat);
2938 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2939 (offsetT) repeat, (char *) 0);
2943 if (now_seg == absolute_section)
2945 as_bad (_("space allocation too complex in absolute section"));
2946 subseg_set (text_section, 0);
2949 if (mri_common_symbol != NULL)
2951 as_bad (_("space allocation too complex in common section"));
2952 mri_common_symbol = NULL;
2956 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2957 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
2961 *p = val.X_add_number;
2966 /* In MRI mode, after an odd number of bytes, we must align to an
2967 even word boundary, unless the next instruction is a dc.b, ds.b
2969 if (flag_mri && (bytes & 1) != 0)
2970 mri_pending_align = 1;
2972 demand_empty_rest_of_line ();
2975 mri_comment_end (stop, stopc);
2978 /* This is like s_space, but the value is a floating point number with
2979 the given precision. This is for the MRI dcb.s pseudo-op and
2983 s_float_space (float_type)
2988 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
2993 stop = mri_comment_field (&stopc);
2995 count = get_absolute_expression ();
2998 if (*input_line_pointer != ',')
3000 as_bad (_("missing value"));
3001 ignore_rest_of_line ();
3003 mri_comment_end (stop, stopc);
3007 ++input_line_pointer;
3011 /* Skip any 0{letter} that may be present. Don't even check if the
3012 * letter is legal. */
3013 if (input_line_pointer[0] == '0'
3014 && isalpha ((unsigned char) input_line_pointer[1]))
3015 input_line_pointer += 2;
3017 /* Accept :xxxx, where the x's are hex digits, for a floating point
3018 with the exact digits specified. */
3019 if (input_line_pointer[0] == ':')
3021 flen = hex_float (float_type, temp);
3024 ignore_rest_of_line ();
3026 mri_comment_end (stop, stopc);
3034 err = md_atof (float_type, temp, &flen);
3035 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3039 as_bad (_("Bad floating literal: %s"), err);
3040 ignore_rest_of_line ();
3042 mri_comment_end (stop, stopc);
3047 while (--count >= 0)
3051 p = frag_more (flen);
3052 memcpy (p, temp, (unsigned int) flen);
3055 demand_empty_rest_of_line ();
3058 mri_comment_end (stop, stopc);
3061 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3065 int ignore ATTRIBUTE_UNUSED;
3071 stop = mri_comment_field (&stopc);
3072 abs_section_offset = get_absolute_expression ();
3073 subseg_set (absolute_section, 0);
3074 demand_empty_rest_of_line ();
3076 mri_comment_end (stop, stopc);
3081 int ignore ATTRIBUTE_UNUSED;
3085 temp = get_absolute_expression ();
3086 subseg_set (text_section, (subsegT) temp);
3087 demand_empty_rest_of_line ();
3089 const_flag &= ~IN_DEFAULT_SECTION;
3094 demand_empty_rest_of_line ()
3097 if (is_end_of_line[(unsigned char) *input_line_pointer])
3098 input_line_pointer++;
3100 ignore_rest_of_line ();
3102 /* Return having already swallowed end-of-line. */
3106 ignore_rest_of_line ()
3108 /* For suspect lines: gives warning. */
3109 if (!is_end_of_line[(unsigned char) *input_line_pointer])
3111 if (isprint ((unsigned char) *input_line_pointer))
3112 as_bad (_("Rest of line ignored. First ignored character is `%c'."),
3113 *input_line_pointer);
3115 as_bad (_("Rest of line ignored. First ignored character valued 0x%x."),
3116 *input_line_pointer);
3118 while (input_line_pointer < buffer_limit
3119 && !is_end_of_line[(unsigned char) *input_line_pointer])
3120 input_line_pointer++;
3123 input_line_pointer++;
3125 /* Return pointing just after end-of-line. */
3126 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3130 discard_rest_of_line ()
3132 while (input_line_pointer < buffer_limit
3133 && !is_end_of_line[(unsigned char) *input_line_pointer])
3134 input_line_pointer++;
3136 input_line_pointer++;
3138 /* Return pointing just after end-of-line. */
3139 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3142 /* In: Pointer to a symbol.
3143 Input_line_pointer->expression.
3145 Out: Input_line_pointer->just after any whitespace after expression.
3146 Tried to set symbol to value of expression.
3147 Will change symbols type, value, and frag; */
3150 pseudo_set (symbolP)
3154 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3156 #endif /* OBJ_AOUT or OBJ_BOUT */
3158 know (symbolP); /* NULL pointer is logic error. */
3159 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3160 ext = S_IS_EXTERNAL (symbolP);
3161 #endif /* OBJ_AOUT or OBJ_BOUT */
3163 (void) expression (&exp);
3165 if (exp.X_op == O_illegal)
3166 as_bad (_("illegal expression; zero assumed"));
3167 else if (exp.X_op == O_absent)
3168 as_bad (_("missing expression; zero assumed"));
3169 else if (exp.X_op == O_big)
3171 if (exp.X_add_number > 0)
3172 as_bad (_("bignum invalid; zero assumed"));
3174 as_bad (_("floating point number invalid; zero assumed"));
3176 else if (exp.X_op == O_subtract
3177 && (S_GET_SEGMENT (exp.X_add_symbol)
3178 == S_GET_SEGMENT (exp.X_op_symbol))
3179 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3180 && (symbol_get_frag (exp.X_add_symbol)
3181 == symbol_get_frag (exp.X_op_symbol)))
3183 exp.X_op = O_constant;
3184 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3185 - S_GET_VALUE (exp.X_op_symbol));
3193 exp.X_add_number = 0;
3196 S_SET_SEGMENT (symbolP, absolute_section);
3197 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3199 S_SET_EXTERNAL (symbolP);
3201 S_CLEAR_EXTERNAL (symbolP);
3202 #endif /* OBJ_AOUT or OBJ_BOUT */
3203 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3204 if (exp.X_op != O_constant)
3205 symbol_set_frag (symbolP, &zero_address_frag);
3209 S_SET_SEGMENT (symbolP, reg_section);
3210 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3211 symbol_set_frag (symbolP, &zero_address_frag);
3215 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3216 || exp.X_add_number != 0)
3217 symbol_set_value_expression (symbolP, &exp);
3218 else if (symbol_section_p (symbolP))
3219 as_bad ("invalid attempt to set value of section symbol");
3222 symbolS *s = exp.X_add_symbol;
3224 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3225 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3227 S_SET_EXTERNAL (symbolP);
3229 S_CLEAR_EXTERNAL (symbolP);
3230 #endif /* OBJ_AOUT or OBJ_BOUT */
3231 S_SET_VALUE (symbolP,
3232 exp.X_add_number + S_GET_VALUE (s));
3233 symbol_set_frag (symbolP, symbol_get_frag (s));
3234 copy_symbol_attributes (symbolP, s);
3239 /* The value is some complex expression.
3240 FIXME: Should we set the segment to anything? */
3241 symbol_set_value_expression (symbolP, &exp);
3248 CONStruct more frag of .bytes, or .words etc.
3249 Should need_pass_2 be 1 then emit no frag(s).
3250 This understands EXPRESSIONS.
3254 This has a split personality. We use expression() to read the
3255 value. We can detect if the value won't fit in a byte or word.
3256 But we can't detect if expression() discarded significant digits
3257 in the case of a long. Not worth the crocks required to fix it. */
3259 /* Select a parser for cons expressions. */
3261 /* Some targets need to parse the expression in various fancy ways.
3262 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3263 (for example, the HPPA does this). Otherwise, you can define
3264 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3265 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3266 are defined, which is the normal case, then only simple expressions
3271 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3274 #ifndef TC_PARSE_CONS_EXPRESSION
3275 #ifdef BITFIELD_CONS_EXPRESSIONS
3276 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3278 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3280 #ifdef REPEAT_CONS_EXPRESSIONS
3281 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3283 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3286 /* If we haven't gotten one yet, just call expression. */
3287 #ifndef TC_PARSE_CONS_EXPRESSION
3288 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3292 /* Worker to do .byte etc statements.
3293 Clobbers input_line_pointer and checks end-of-line. */
3296 cons_worker (nbytes, rva)
3297 register int nbytes; /* 1=.byte, 2=.word, 4=.long. */
3305 #ifdef md_flush_pending_output
3306 md_flush_pending_output ();
3310 stop = mri_comment_field (&stopc);
3312 if (is_it_end_of_statement ())
3314 demand_empty_rest_of_line ();
3316 mri_comment_end (stop, stopc);
3320 #ifdef md_cons_align
3321 md_cons_align (nbytes);
3329 parse_mri_cons (&exp, (unsigned int) nbytes);
3332 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3336 if (exp.X_op == O_symbol)
3337 exp.X_op = O_symbol_rva;
3339 as_fatal (_("rva without symbol"));
3341 emit_expr (&exp, (unsigned int) nbytes);
3344 while (*input_line_pointer++ == ',');
3346 /* In MRI mode, after an odd number of bytes, we must align to an
3347 even word boundary, unless the next instruction is a dc.b, ds.b
3349 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3350 mri_pending_align = 1;
3352 input_line_pointer--; /* Put terminator back into stream. */
3354 demand_empty_rest_of_line ();
3357 mri_comment_end (stop, stopc);
3364 cons_worker (size, 0);
3371 cons_worker (size, 1);
3374 /* Put the contents of expression EXP into the object file using
3375 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3378 emit_expr (exp, nbytes)
3380 unsigned int nbytes;
3384 valueT extra_digit = 0;
3386 /* Don't do anything if we are going to make another pass. */
3392 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3393 appear as a four byte positive constant in the .line section,
3394 followed by a 2 byte 0xffff. Look for that case here. */
3396 static int dwarf_line = -1;
3398 if (strcmp (segment_name (now_seg), ".line") != 0)
3400 else if (dwarf_line >= 0
3402 && exp->X_op == O_constant
3403 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3404 listing_source_line ((unsigned int) dwarf_line);
3405 else if (nbytes == 4
3406 && exp->X_op == O_constant
3407 && exp->X_add_number >= 0)
3408 dwarf_line = exp->X_add_number;
3413 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3414 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3415 AT_sibling (0x12) followed by a four byte address of the sibling
3416 followed by a 2 byte AT_name (0x38) followed by the name of the
3417 file. We look for that case here. */
3419 static int dwarf_file = 0;
3421 if (strcmp (segment_name (now_seg), ".debug") != 0)
3423 else if (dwarf_file == 0
3425 && exp->X_op == O_constant
3426 && exp->X_add_number == 0x11)
3428 else if (dwarf_file == 1
3430 && exp->X_op == O_constant
3431 && exp->X_add_number == 0x12)
3433 else if (dwarf_file == 2
3436 else if (dwarf_file == 3
3438 && exp->X_op == O_constant
3439 && exp->X_add_number == 0x38)
3444 /* The variable dwarf_file_string tells stringer that the string
3445 may be the name of the source file. */
3446 if (dwarf_file == 4)
3447 dwarf_file_string = 1;
3449 dwarf_file_string = 0;
3454 if (check_eh_frame (exp, &nbytes))
3459 /* Allow `.word 0' in the absolute section. */
3460 if (now_seg == absolute_section)
3462 if (op != O_constant || exp->X_add_number != 0)
3463 as_bad (_("attempt to store value in absolute section"));
3464 abs_section_offset += nbytes;
3468 /* Handle a negative bignum. */
3470 && exp->X_add_number == 0
3471 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3472 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
3475 unsigned long carry;
3477 exp = symbol_get_value_expression (exp->X_add_symbol);
3479 /* Negate the bignum: one's complement each digit and add 1. */
3481 for (i = 0; i < exp->X_add_number; i++)
3485 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
3488 generic_bignum[i] = next & LITTLENUM_MASK;
3489 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3492 /* We can ignore any carry out, because it will be handled by
3493 extra_digit if it is needed. */
3495 extra_digit = (valueT) -1;
3499 if (op == O_absent || op == O_illegal)
3501 as_warn (_("zero assumed for missing expression"));
3502 exp->X_add_number = 0;
3505 else if (op == O_big && exp->X_add_number <= 0)
3507 as_bad (_("floating point number invalid; zero assumed"));
3508 exp->X_add_number = 0;
3511 else if (op == O_register)
3513 as_warn (_("register value used as expression"));
3517 p = frag_more ((int) nbytes);
3519 #ifndef WORKING_DOT_WORD
3520 /* If we have the difference of two symbols in a word, save it on
3521 the broken_words list. See the code in write.c. */
3522 if (op == O_subtract && nbytes == 2)
3524 struct broken_word *x;
3526 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3527 x->next_broken_word = broken_words;
3530 x->subseg = now_subseg;
3532 x->word_goes_here = p;
3534 x->add = exp->X_add_symbol;
3535 x->sub = exp->X_op_symbol;
3536 x->addnum = exp->X_add_number;
3543 /* If we have an integer, but the number of bytes is too large to
3544 pass to md_number_to_chars, handle it as a bignum. */
3545 if (op == O_constant && nbytes > sizeof (valueT))
3550 if (!exp->X_unsigned && exp->X_add_number < 0)
3551 extra_digit = (valueT) -1;
3552 val = (valueT) exp->X_add_number;
3556 generic_bignum[gencnt] = val & LITTLENUM_MASK;
3557 val >>= LITTLENUM_NUMBER_OF_BITS;
3561 op = exp->X_op = O_big;
3562 exp->X_add_number = gencnt;
3565 if (op == O_constant)
3567 register valueT get;
3568 register valueT use;
3569 register valueT mask;
3571 register valueT unmask;
3573 /* JF << of >= number of bits in the object is undefined. In
3574 particular SPARC (Sun 4) has problems. */
3575 if (nbytes >= sizeof (valueT))
3578 if (nbytes > sizeof (valueT))
3581 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3585 /* Don't store these bits. */
3586 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3587 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3590 unmask = ~mask; /* Do store these bits. */
3593 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3594 mask = ~(unmask >> 1); /* Includes sign bit now. */
3597 get = exp->X_add_number;
3599 if ((get & mask) != 0
3600 && ((get & mask) != mask
3601 || (get & hibit) == 0))
3602 { /* Leading bits contain both 0s & 1s. */
3603 as_warn (_("Value 0x%lx truncated to 0x%lx."),
3604 (unsigned long) get, (unsigned long) use);
3606 /* Put bytes in right order. */
3607 md_number_to_chars (p, use, (int) nbytes);
3609 else if (op == O_big)
3612 LITTLENUM_TYPE *nums;
3614 know (nbytes % CHARS_PER_LITTLENUM == 0);
3616 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3619 as_warn (_("Bignum truncated to %d bytes"), nbytes);
3623 if (target_big_endian)
3625 while (nbytes > size)
3627 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3628 nbytes -= CHARS_PER_LITTLENUM;
3629 p += CHARS_PER_LITTLENUM;
3632 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3636 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3637 size -= CHARS_PER_LITTLENUM;
3638 p += CHARS_PER_LITTLENUM;
3643 nums = generic_bignum;
3646 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3648 size -= CHARS_PER_LITTLENUM;
3649 p += CHARS_PER_LITTLENUM;
3650 nbytes -= CHARS_PER_LITTLENUM;
3655 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3656 nbytes -= CHARS_PER_LITTLENUM;
3657 p += CHARS_PER_LITTLENUM;
3663 memset (p, 0, nbytes);
3665 /* Now we need to generate a fixS to record the symbol value.
3666 This is easy for BFD. For other targets it can be more
3667 complex. For very complex cases (currently, the HPPA and
3668 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3669 want. For simpler cases, you can define TC_CONS_RELOC to be
3670 the name of the reloc code that should be stored in the fixS.
3671 If neither is defined, the code uses NO_RELOC if it is
3672 defined, and otherwise uses 0. */
3674 #ifdef BFD_ASSEMBLER
3675 #ifdef TC_CONS_FIX_NEW
3676 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3679 bfd_reloc_code_real_type r;
3696 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3700 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3705 #ifdef TC_CONS_FIX_NEW
3706 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3708 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3709 it is defined, otherwise use NO_RELOC if it is defined,
3711 #ifndef TC_CONS_RELOC
3713 #define TC_CONS_RELOC NO_RELOC
3715 #define TC_CONS_RELOC 0
3718 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3720 #endif /* TC_CONS_FIX_NEW */
3721 #endif /* BFD_ASSEMBLER */
3725 #ifdef BITFIELD_CONS_EXPRESSIONS
3727 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3728 w:x,y:z, where w and y are bitwidths and x and y are values. They
3729 then pack them all together. We do a little better in that we allow
3730 them in words, longs, etc. and we'll pack them in target byte order
3733 The rules are: pack least significat bit first, if a field doesn't
3734 entirely fit, put it in the next unit. Overflowing the bitfield is
3735 explicitly *not* even a warning. The bitwidth should be considered
3738 To use this function the tc-XXX.h file should define
3739 BITFIELD_CONS_EXPRESSIONS. */
3742 parse_bitfield_cons (exp, nbytes)
3744 unsigned int nbytes;
3746 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3747 char *hold = input_line_pointer;
3749 (void) expression (exp);
3751 if (*input_line_pointer == ':')
3758 unsigned long width;
3760 if (*input_line_pointer != ':')
3762 input_line_pointer = hold;
3764 } /* Next piece is not a bitfield. */
3766 /* In the general case, we can't allow
3767 full expressions with symbol
3768 differences and such. The relocation
3769 entries for symbols not defined in this
3770 assembly would require arbitrary field
3771 widths, positions, and masks which most
3772 of our current object formats don't
3775 In the specific case where a symbol
3776 *is* defined in this assembly, we
3777 *could* build fixups and track it, but
3778 this could lead to confusion for the
3779 backends. I'm lazy. I'll take any
3780 SEG_ABSOLUTE. I think that means that
3781 you can use a previous .set or
3782 .equ type symbol. xoxorich. */
3784 if (exp->X_op == O_absent)
3786 as_warn (_("using a bit field width of zero"));
3787 exp->X_add_number = 0;
3788 exp->X_op = O_constant;
3789 } /* Implied zero width bitfield. */
3791 if (exp->X_op != O_constant)
3793 *input_line_pointer = '\0';
3794 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3795 *input_line_pointer = ':';
3796 demand_empty_rest_of_line ();
3798 } /* Too complex. */
3800 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3802 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3803 width, nbytes, (BITS_PER_CHAR * nbytes));
3804 width = BITS_PER_CHAR * nbytes;
3807 if (width > bits_available)
3809 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3810 input_line_pointer = hold;
3811 exp->X_add_number = value;
3816 hold = ++input_line_pointer;
3818 (void) expression (exp);
3819 if (exp->X_op != O_constant)
3821 char cache = *input_line_pointer;
3823 *input_line_pointer = '\0';
3824 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3825 *input_line_pointer = cache;
3826 demand_empty_rest_of_line ();
3828 } /* Too complex. */
3830 value |= ((~(-1 << width) & exp->X_add_number)
3831 << ((BITS_PER_CHAR * nbytes) - bits_available));
3833 if ((bits_available -= width) == 0
3834 || is_it_end_of_statement ()
3835 || *input_line_pointer != ',')
3838 } /* All the bitfields we're gonna get. */
3840 hold = ++input_line_pointer;
3841 (void) expression (exp);
3844 exp->X_add_number = value;
3845 exp->X_op = O_constant;
3846 exp->X_unsigned = 1;
3850 #endif /* BITFIELD_CONS_EXPRESSIONS */
3852 /* Handle an MRI style string expression. */
3856 parse_mri_cons (exp, nbytes)
3858 unsigned int nbytes;
3860 if (*input_line_pointer != '\''
3861 && (input_line_pointer[1] != '\''
3862 || (*input_line_pointer != 'A'
3863 && *input_line_pointer != 'E')))
3864 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3868 unsigned int result = 0;
3870 /* An MRI style string. Cut into as many bytes as will fit into
3871 a nbyte chunk, left justify if necessary, and separate with
3872 commas so we can try again later. */
3873 if (*input_line_pointer == 'A')
3874 ++input_line_pointer;
3875 else if (*input_line_pointer == 'E')
3877 as_bad (_("EBCDIC constants are not supported"));
3878 ++input_line_pointer;
3881 input_line_pointer++;
3882 for (scan = 0; scan < nbytes; scan++)
3884 if (*input_line_pointer == '\'')
3886 if (input_line_pointer[1] == '\'')
3888 input_line_pointer++;
3893 result = (result << 8) | (*input_line_pointer++);
3897 while (scan < nbytes)
3903 /* Create correct expression. */
3904 exp->X_op = O_constant;
3905 exp->X_add_number = result;
3907 /* Fake it so that we can read the next char too. */
3908 if (input_line_pointer[0] != '\'' ||
3909 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3911 input_line_pointer -= 2;
3912 input_line_pointer[0] = ',';
3913 input_line_pointer[1] = '\'';
3916 input_line_pointer++;
3919 #endif /* TC_M68K */
3921 #ifdef REPEAT_CONS_EXPRESSIONS
3923 /* Parse a repeat expression for cons. This is used by the MIPS
3924 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3925 object file COUNT times.
3927 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3930 parse_repeat_cons (exp, nbytes)
3932 unsigned int nbytes;
3939 if (*input_line_pointer != ':')
3941 /* No repeat count. */
3945 ++input_line_pointer;
3946 expression (&count);
3947 if (count.X_op != O_constant
3948 || count.X_add_number <= 0)
3950 as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
3954 /* The cons function is going to output this expression once. So we
3955 output it count - 1 times. */
3956 for (i = count.X_add_number - 1; i > 0; i--)
3957 emit_expr (exp, nbytes);
3960 #endif /* REPEAT_CONS_EXPRESSIONS */
3962 /* Parse a floating point number represented as a hex constant. This
3963 permits users to specify the exact bits they want in the floating
3967 hex_float (float_type, bytes)
4001 as_bad (_("Unknown floating type type '%c'"), float_type);
4005 /* It would be nice if we could go through expression to parse the
4006 hex constant, but if we get a bignum it's a pain to sort it into
4007 the buffer correctly. */
4009 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4013 /* The MRI assembler accepts arbitrary underscores strewn about
4014 through the hex constant, so we ignore them as well. */
4015 if (*input_line_pointer == '_')
4017 ++input_line_pointer;
4023 as_warn (_("Floating point constant too large"));
4026 d = hex_value (*input_line_pointer) << 4;
4027 ++input_line_pointer;
4028 while (*input_line_pointer == '_')
4029 ++input_line_pointer;
4030 if (hex_p (*input_line_pointer))
4032 d += hex_value (*input_line_pointer);
4033 ++input_line_pointer;
4035 if (target_big_endian)
4038 bytes[length - i - 1] = d;
4044 if (target_big_endian)
4045 memset (bytes + i, 0, length - i);
4047 memset (bytes, 0, length - i);
4055 CONStruct some more frag chars of .floats .ffloats etc.
4056 Makes 0 or more new frags.
4057 If need_pass_2 == 1, no frags are emitted.
4058 This understands only floating literals, not expressions. Sorry.
4060 A floating constant is defined by atof_generic(), except it is preceded
4061 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4062 reading, I decided to be incompatible. This always tries to give you
4063 rounded bits to the precision of the pseudo-op. Former AS did premature
4064 truncatation, restored noisy bits instead of trailing 0s AND gave you
4065 a choice of 2 flavours of noise according to which of 2 floating-point
4066 scanners you directed AS to use.
4068 In: input_line_pointer->whitespace before, or '0' of flonum. */
4071 float_cons (float_type)
4072 /* Clobbers input_line-pointer, checks end-of-line. */
4073 register int float_type; /* 'f':.ffloat ... 'F':.float ... */
4076 int length; /* Number of chars in an object. */
4077 register char *err; /* Error from scanning floating literal. */
4078 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4080 if (is_it_end_of_statement ())
4082 demand_empty_rest_of_line ();
4086 #ifdef md_flush_pending_output
4087 md_flush_pending_output ();
4092 /* input_line_pointer->1st char of a flonum (we hope!). */
4095 /* Skip any 0{letter} that may be present. Don't even check if the
4096 letter is legal. Someone may invent a "z" format and this routine
4097 has no use for such information. Lusers beware: you get
4098 diagnostics if your input is ill-conditioned. */
4099 if (input_line_pointer[0] == '0'
4100 && isalpha ((unsigned char) input_line_pointer[1]))
4101 input_line_pointer += 2;
4103 /* Accept :xxxx, where the x's are hex digits, for a floating
4104 point with the exact digits specified. */
4105 if (input_line_pointer[0] == ':')
4107 ++input_line_pointer;
4108 length = hex_float (float_type, temp);
4111 ignore_rest_of_line ();
4117 err = md_atof (float_type, temp, &length);
4118 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4122 as_bad (_("Bad floating literal: %s"), err);
4123 ignore_rest_of_line ();
4134 #ifdef REPEAT_CONS_EXPRESSIONS
4135 if (*input_line_pointer == ':')
4137 expressionS count_exp;
4139 ++input_line_pointer;
4140 expression (&count_exp);
4142 if (count_exp.X_op != O_constant
4143 || count_exp.X_add_number <= 0)
4144 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4146 count = count_exp.X_add_number;
4150 while (--count >= 0)
4152 p = frag_more (length);
4153 memcpy (p, temp, (unsigned int) length);
4158 while (*input_line_pointer++ == ',');
4160 /* Put terminator back into stream. */
4161 --input_line_pointer;
4162 demand_empty_rest_of_line ();
4165 /* Return the size of a LEB128 value. */
4168 sizeof_sleb128 (value)
4171 register int size = 0;
4172 register unsigned byte;
4176 byte = (value & 0x7f);
4177 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4178 Fortunately, we can structure things so that the extra work reduces
4179 to a noop on systems that do things "properly". */
4180 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4183 while (!(((value == 0) && ((byte & 0x40) == 0))
4184 || ((value == -1) && ((byte & 0x40) != 0))));
4190 sizeof_uleb128 (value)
4193 register int size = 0;
4194 register unsigned byte;
4198 byte = (value & 0x7f);
4208 sizeof_leb128 (value, sign)
4213 return sizeof_sleb128 ((offsetT) value);
4215 return sizeof_uleb128 (value);
4218 /* Output a LEB128 value. */
4221 output_sleb128 (p, value)
4225 register char *orig = p;
4230 unsigned byte = (value & 0x7f);
4232 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4233 Fortunately, we can structure things so that the extra work reduces
4234 to a noop on systems that do things "properly". */
4235 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4237 more = !((((value == 0) && ((byte & 0x40) == 0))
4238 || ((value == -1) && ((byte & 0x40) != 0))));
4250 output_uleb128 (p, value)
4258 unsigned byte = (value & 0x7f);
4261 /* More bytes to follow. */
4272 output_leb128 (p, value, sign)
4278 return output_sleb128 (p, (offsetT) value);
4280 return output_uleb128 (p, value);
4283 /* Do the same for bignums. We combine sizeof with output here in that
4284 we don't output for NULL values of P. It isn't really as critical as
4285 for "normal" values that this be streamlined. */
4288 output_big_sleb128 (p, bignum, size)
4290 LITTLENUM_TYPE *bignum;
4298 /* Strip leading sign extensions off the bignum. */
4299 while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
4304 if (loaded < 7 && size > 0)
4306 val |= (*bignum << loaded);
4307 loaded += 8 * CHARS_PER_LITTLENUM;
4318 if ((val == 0 && (byte & 0x40) == 0)
4319 || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
4320 && (byte & 0x40) != 0))
4328 while (byte & 0x80);
4334 output_big_uleb128 (p, bignum, size)
4336 LITTLENUM_TYPE *bignum;
4344 /* Strip leading zeros off the bignum. */
4345 /* XXX: Is this needed? */
4346 while (size > 0 && bignum[size - 1] == 0)
4351 if (loaded < 7 && size > 0)
4353 val |= (*bignum << loaded);
4354 loaded += 8 * CHARS_PER_LITTLENUM;
4363 if (size > 0 || val)
4370 while (byte & 0x80);
4376 output_big_leb128 (p, bignum, size, sign)
4378 LITTLENUM_TYPE *bignum;
4382 return output_big_sleb128 (p, bignum, size);
4384 return output_big_uleb128 (p, bignum, size);
4387 /* Generate the appropriate fragments for a given expression to emit a
4391 emit_leb128_expr (exp, sign)
4395 operatorT op = exp->X_op;
4398 if (op == O_absent || op == O_illegal)
4400 as_warn (_("zero assumed for missing expression"));
4401 exp->X_add_number = 0;
4404 else if (op == O_big && exp->X_add_number <= 0)
4406 as_bad (_("floating point number invalid; zero assumed"));
4407 exp->X_add_number = 0;
4410 else if (op == O_register)
4412 as_warn (_("register value used as expression"));
4416 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4417 a signal that this is leb128 data. It shouldn't optimize this away. */
4419 if (check_eh_frame (exp, &nbytes))
4422 /* Let the backend know that subsequent data may be byte aligned. */
4423 #ifdef md_cons_align
4427 if (op == O_constant)
4429 /* If we've got a constant, emit the thing directly right now. */
4431 valueT value = exp->X_add_number;
4435 size = sizeof_leb128 (value, sign);
4436 p = frag_more (size);
4437 output_leb128 (p, value, sign);
4439 else if (op == O_big)
4441 /* O_big is a different sort of constant. */
4446 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4447 p = frag_more (size);
4448 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4452 /* Otherwise, we have to create a variable sized fragment and
4453 resolve things later. */
4455 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
4456 make_expr_symbol (exp), 0, (char *) NULL);
4460 /* Parse the .sleb128 and .uleb128 pseudos. */
4471 emit_leb128_expr (&exp, sign);
4473 while (*input_line_pointer++ == ',');
4475 input_line_pointer--;
4476 demand_empty_rest_of_line ();
4479 /* We read 0 or more ',' separated, double-quoted strings.
4480 Caller should have checked need_pass_2 is FALSE because we don't
4484 stringer (append_zero) /* Worker to do .ascii etc statements. */
4485 /* Checks end-of-line. */
4486 register int append_zero; /* 0: don't append '\0', else 1. */
4488 register unsigned int c;
4491 #ifdef md_flush_pending_output
4492 md_flush_pending_output ();
4495 /* The following awkward logic is to parse ZERO or more strings,
4496 comma separated. Recall a string expression includes spaces
4497 before the opening '\"' and spaces after the closing '\"'.
4498 We fake a leading ',' if there is (supposed to be)
4499 a 1st, expression. We keep demanding expressions for each ','. */
4500 if (is_it_end_of_statement ())
4502 c = 0; /* Skip loop. */
4503 ++input_line_pointer; /* Compensate for end of loop. */
4507 c = ','; /* Do loop. */
4509 while (c == ',' || c == '<' || c == '"')
4512 switch (*input_line_pointer)
4515 ++input_line_pointer; /*->1st char of string. */
4516 start = input_line_pointer;
4517 while (is_a_char (c = next_char_of_string ()))
4519 FRAG_APPEND_1_CHAR (c);
4523 FRAG_APPEND_1_CHAR (0);
4525 know (input_line_pointer[-1] == '\"');
4529 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4530 will emit .string with a filename in the .debug section
4531 after a sequence of constants. See the comment in
4532 emit_expr for the sequence. emit_expr will set
4533 dwarf_file_string to non-zero if this string might be a
4534 source file name. */
4535 if (strcmp (segment_name (now_seg), ".debug") != 0)
4536 dwarf_file_string = 0;
4537 else if (dwarf_file_string)
4539 c = input_line_pointer[-1];
4540 input_line_pointer[-1] = '\0';
4541 listing_source_file (start);
4542 input_line_pointer[-1] = c;
4549 input_line_pointer++;
4550 c = get_single_number ();
4551 FRAG_APPEND_1_CHAR (c);
4552 if (*input_line_pointer != '>')
4554 as_bad (_("Expected <nn>"));
4556 input_line_pointer++;
4559 input_line_pointer++;
4563 c = *input_line_pointer;
4566 demand_empty_rest_of_line ();
4569 /* FIXME-SOMEDAY: I had trouble here on characters with the
4570 high bits set. We'll probably also have trouble with
4571 multibyte chars, wide chars, etc. Also be careful about
4572 returning values bigger than 1 byte. xoxorich. */
4575 next_char_of_string ()
4577 register unsigned int c;
4579 c = *input_line_pointer++ & CHAR_MASK;
4587 as_warn (_("Unterminated string: Newline inserted."));
4588 bump_line_counters ();
4591 #ifndef NO_STRING_ESCAPES
4593 switch (c = *input_line_pointer++)
4621 break; /* As itself. */
4637 for (i = 0, number = 0;
4638 isdigit (c) && i < 3;
4639 c = *input_line_pointer++, i++)
4641 number = number * 8 + c - '0';
4646 --input_line_pointer;
4655 c = *input_line_pointer++;
4656 while (isxdigit (c))
4659 number = number * 16 + c - '0';
4660 else if (isupper (c))
4661 number = number * 16 + c - 'A' + 10;
4663 number = number * 16 + c - 'a' + 10;
4664 c = *input_line_pointer++;
4667 --input_line_pointer;
4672 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
4673 as_warn (_("Unterminated string: Newline inserted."));
4675 bump_line_counters ();
4680 #ifdef ONLY_STANDARD_ESCAPES
4681 as_bad (_("Bad escaped character in string, '?' assumed"));
4683 #endif /* ONLY_STANDARD_ESCAPES */
4688 #endif /* ! defined (NO_STRING_ESCAPES) */
4697 get_segmented_expression (expP)
4698 register expressionS *expP;
4700 register segT retval;
4702 retval = expression (expP);
4703 if (expP->X_op == O_illegal
4704 || expP->X_op == O_absent
4705 || expP->X_op == O_big)
4707 as_bad (_("expected address expression; zero assumed"));
4708 expP->X_op = O_constant;
4709 expP->X_add_number = 0;
4710 retval = absolute_section;
4716 get_known_segmented_expression (expP)
4717 register expressionS *expP;
4719 register segT retval;
4721 if ((retval = get_segmented_expression (expP)) == undefined_section)
4723 /* There is no easy way to extract the undefined symbol from the
4725 if (expP->X_add_symbol != NULL
4726 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4727 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4728 S_GET_NAME (expP->X_add_symbol));
4730 as_warn (_("some symbol undefined; zero assumed"));
4731 retval = absolute_section;
4732 expP->X_op = O_constant;
4733 expP->X_add_number = 0;
4735 know (retval == absolute_section || SEG_NORMAL (retval));
4740 get_absolute_expression ()
4745 if (exp.X_op != O_constant)
4747 if (exp.X_op != O_absent)
4748 as_bad (_("bad or irreducible absolute expression; zero assumed"));
4749 exp.X_add_number = 0;
4751 return exp.X_add_number;
4754 char /* Return terminator. */
4755 get_absolute_expression_and_terminator (val_pointer)
4756 long *val_pointer; /* Return value of expression. */
4758 /* FIXME: val_pointer should probably be offsetT *. */
4759 *val_pointer = (long) get_absolute_expression ();
4760 return (*input_line_pointer++);
4763 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
4764 Give a warning if that happens. */
4767 demand_copy_C_string (len_pointer)
4772 if ((s = demand_copy_string (len_pointer)) != 0)
4776 for (len = *len_pointer; len > 0; len--)
4783 as_bad (_("This string may not contain \'\\0\'"));
4791 /* Demand string, but return a safe (=private) copy of the string.
4792 Return NULL if we can't read a string here. */
4795 demand_copy_string (lenP)
4798 register unsigned int c;
4804 if (*input_line_pointer == '\"')
4806 input_line_pointer++; /* Skip opening quote. */
4808 while (is_a_char (c = next_char_of_string ()))
4810 obstack_1grow (¬es, c);
4813 /* JF this next line is so demand_copy_C_string will return a
4814 null terminated string. */
4815 obstack_1grow (¬es, '\0');
4816 retval = obstack_finish (¬es);
4820 as_warn (_("Missing string"));
4822 ignore_rest_of_line ();
4828 /* In: Input_line_pointer->next character.
4830 Do: Skip input_line_pointer over all whitespace.
4832 Out: 1 if input_line_pointer->end-of-line. */
4835 is_it_end_of_statement ()
4838 return (is_end_of_line[(unsigned char) *input_line_pointer]);
4842 equals (sym_name, reassign)
4846 register symbolS *symbolP; /* Symbol we are working with. */
4850 input_line_pointer++;
4851 if (*input_line_pointer == '=')
4852 input_line_pointer++;
4854 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4855 input_line_pointer++;
4858 stop = mri_comment_field (&stopc);
4860 if (sym_name[0] == '.' && sym_name[1] == '\0')
4862 /* Turn '. = mumble' into a .org mumble. */
4863 register segT segment;
4866 segment = get_known_segmented_expression (&exp);
4868 do_org (segment, &exp, 0);
4875 symbolP = symbol_find (sym_name);
4876 local = symbolP == NULL;
4878 #endif /* OBJ_COFF */
4879 symbolP = symbol_find_or_make (sym_name);
4880 /* Permit register names to be redefined. */
4882 && S_IS_DEFINED (symbolP)
4883 && S_GET_SEGMENT (symbolP) != reg_section)
4884 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
4887 /* "set" symbols are local unless otherwise specified. */
4889 SF_SET_LOCAL (symbolP);
4890 #endif /* OBJ_COFF */
4892 pseudo_set (symbolP);
4897 /* Check garbage after the expression. */
4898 ignore_rest_of_line ();
4899 mri_comment_end (stop, stopc);
4903 /* .include -- include a file at this point. */
4907 int arg ATTRIBUTE_UNUSED;
4916 filename = demand_copy_string (&i);
4917 if (filename == NULL)
4919 /* demand_copy_string has already printed an error and
4920 called ignore_rest_of_line. */
4928 while (!is_end_of_line[(unsigned char) *input_line_pointer]
4929 && *input_line_pointer != ' '
4930 && *input_line_pointer != '\t')
4932 obstack_1grow (¬es, *input_line_pointer);
4933 ++input_line_pointer;
4937 obstack_1grow (¬es, '\0');
4938 filename = obstack_finish (¬es);
4939 while (!is_end_of_line[(unsigned char) *input_line_pointer])
4940 ++input_line_pointer;
4943 demand_empty_rest_of_line ();
4944 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4946 for (i = 0; i < include_dir_count; i++)
4948 strcpy (path, include_dirs[i]);
4950 strcat (path, filename);
4951 if (0 != (try = fopen (path, "r")))
4961 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4962 register_dependency (path);
4963 input_scrub_insert_file (path);
4967 add_include_dir (path)
4972 if (include_dir_count == 0)
4974 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4975 include_dirs[0] = "."; /* Current dir. */
4976 include_dir_count = 2;
4980 include_dir_count++;
4982 (char **) realloc (include_dirs,
4983 include_dir_count * sizeof (*include_dirs));
4986 include_dirs[include_dir_count - 1] = path; /* New one. */
4989 if (i > include_dir_maxlen)
4990 include_dir_maxlen = i;
4993 /* Output debugging information to denote the source file. */
4996 generate_file_debug ()
4998 if (debug_type == DEBUG_STABS)
4999 stabs_generate_asm_file ();
5002 /* Output line number debugging information for the current source line. */
5005 generate_lineno_debug ()
5009 case DEBUG_UNSPECIFIED:
5014 stabs_generate_asm_lineno ();
5017 ecoff_generate_asm_lineno ();
5020 /* ??? We could here indicate to dwarf2dbg.c that something
5021 has changed. However, since there is additional backend
5022 support that is required (calling dwarf2_emit_insn), we
5023 let dwarf2dbg.c call as_where on its own. */
5028 /* Output debugging information to mark a function entry point or end point.
5029 END_P is zero for .func, and non-zero for .endfunc. */
5035 do_s_func (end_p, NULL);
5038 /* Subroutine of s_func so targets can choose a different default prefix.
5039 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5042 do_s_func (end_p, default_prefix)
5044 const char *default_prefix;
5046 /* Record the current function so that we can issue an error message for
5047 misplaced .func,.endfunc, and also so that .endfunc needs no
5049 static char *current_name;
5050 static char *current_label;
5054 if (current_name == NULL)
5056 as_bad (_("missing .func"));
5057 ignore_rest_of_line ();
5061 if (debug_type == DEBUG_STABS)
5062 stabs_generate_asm_endfunc (current_name, current_label);
5064 current_name = current_label = NULL;
5069 char delim1, delim2;
5071 if (current_name != NULL)
5073 as_bad (_(".endfunc missing for previous .func"));
5074 ignore_rest_of_line ();
5078 name = input_line_pointer;
5079 delim1 = get_symbol_end ();
5080 name = xstrdup (name);
5081 *input_line_pointer = delim1;
5083 if (*input_line_pointer != ',')
5086 asprintf (&label, "%s%s", default_prefix, name);
5089 char leading_char = 0;
5090 #ifdef BFD_ASSEMBLER
5091 leading_char = bfd_get_symbol_leading_char (stdoutput);
5093 /* Missing entry point, use function's name with the leading
5096 asprintf (&label, "%c%s", leading_char, name);
5103 ++input_line_pointer;
5105 label = input_line_pointer;
5106 delim2 = get_symbol_end ();
5107 label = xstrdup (label);
5108 *input_line_pointer = delim2;
5111 if (debug_type == DEBUG_STABS)
5112 stabs_generate_asm_func (name, label);
5114 current_name = name;
5115 current_label = label;
5118 demand_empty_rest_of_line ();
5123 int arg ATTRIBUTE_UNUSED;
5125 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5127 ++input_line_pointer;
5129 ++input_line_pointer;
5133 read_print_statistics (file)
5136 hash_print_statistics (file, "pseudo-op table", po_hash);
5139 /* Inserts the given line into the input stream.
5141 This call avoids macro/conditionals nesting checking, since the contents of
5142 the line are assumed to replace the contents of a line already scanned.
5144 An appropriate use of this function would be substition of input lines when
5145 called by md_start_line_hook(). The given line is assumed to already be
5146 properly scrubbed. */
5149 input_scrub_insert_line (line)
5154 sb_add_string (&newline, line);
5155 input_scrub_include_sb (&newline, input_line_pointer, 0);
5157 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5160 /* Insert a file into the input stream; the path must resolve to an actual
5161 file; no include path searching or dependency registering is performed. */
5164 input_scrub_insert_file (path)
5167 input_scrub_include_file (path, input_line_pointer);
5168 buffer_limit = input_scrub_next_buffer (&input_line_pointer);