1 /* read.c - read a source file -
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will
23 change this a bit. But then, GNU isn't
24 spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.)
28 #define MASK_CHAR ((int)(unsigned char)-1)
32 /* This is the largest known floating point format (for now). It will
33 grow when we do 4361 style flonums. */
35 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
37 /* Routines that read assembler source text to build spagetti in memory.
38 Another group of these functions is in the expr.c module. */
47 #include "libiberty.h"
51 #ifndef TC_START_LABEL
52 #define TC_START_LABEL(x,y) (x==':')
55 /* The NOP_OPCODE is for the alignment fill value.
56 * fill it a nop instruction so that the disassembler does not choke
60 #define NOP_OPCODE 0x00
63 char *input_line_pointer
; /*->next char of source file to parse. */
65 int generate_asm_lineno
= 0; /* flag to generate line stab for .s file */
67 #if BITS_PER_CHAR != 8
68 /* The following table is indexed by[(char)] and will break if
69 a char does not have exactly 256 states (hopefully 0:255!)! */
74 /* The m88k unfortunately uses @ as a label beginner. */
79 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
84 /* The Delta 68k assembler permits % inside label names. */
89 /* The PowerPC Windows NT assemblers permits ? inside label names. */
94 /* The a29k assembler does not permits labels to start with $. */
98 /* used by is_... macros. our ctype[] */
101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
103 0, 0, 0, 0, LEX_DOLLAR
, LEX_PCT
, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
104 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM
, /* 0123456789:;<=>? */
105 LEX_AT
, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
106 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 3, /* PQRSTUVWXYZ[\]^_ */
107 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
108 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR
, 0, LEX_BR
, 0, 0, /* pqrstuvwxyz{|}~. */
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
121 * Out: 1 if this character ends a line.
124 char is_end_of_line
[256] =
127 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, 99, _
, _
, /* @abcdefghijklmno */
129 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, _
, /* @abcdefghijklmno */
131 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
133 _
,99, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* _!"#$%&'()*+,-./ */
134 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* 0123456789:;<=>? */
136 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
137 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, 99, _
, _
, _
, _
, /* 0123456789:;<=>? */
139 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
140 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
141 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
142 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
143 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
144 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
145 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
146 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
147 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, /* */
151 /* Functions private to this file. */
153 static char *buffer
; /* 1st char of each buffer of lines is here. */
154 static char *buffer_limit
; /*->1 + last char in buffer. */
156 #ifdef TARGET_BYTES_BIG_ENDIAN
157 /* Hack to deal with tc-*.h defining TARGET_BYTES_BIG_ENDIAN to empty
158 instead of to 0 or 1. */
159 #if 5 - TARGET_BYTES_BIG_ENDIAN - 5 == 10
160 #undef TARGET_BYTES_BIG_ENDIAN
161 #define TARGET_BYTES_BIG_ENDIAN 1
163 int target_big_endian
= TARGET_BYTES_BIG_ENDIAN
;
165 int target_big_endian
/* = 0 */;
168 static char *old_buffer
; /* JF a hack */
169 static char *old_input
;
170 static char *old_limit
;
172 /* Variables for handling include file directory list. */
174 char **include_dirs
; /* List of pointers to directories to
175 search for .include's */
176 int include_dir_count
; /* How many are in the list */
177 int include_dir_maxlen
= 1;/* Length of longest in list */
179 #ifndef WORKING_DOT_WORD
180 struct broken_word
*broken_words
;
181 int new_broken_words
;
184 /* The current offset into the absolute section. We don't try to
185 build frags in the absolute section, since no data can be stored
186 there. We just keep track of the current offset. */
187 addressT abs_section_offset
;
189 /* If this line had an MRI style label, it is stored in this variable.
190 This is used by some of the MRI pseudo-ops. */
193 /* This global variable is used to support MRI common sections. We
194 translate such sections into a common symbol. This variable is
195 non-NULL when we are in an MRI common section. */
196 symbolS
*mri_common_symbol
;
198 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
199 need to align to an even byte boundary unless the next pseudo-op is
200 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
202 static int mri_pending_align
;
204 static int scrub_from_string
PARAMS ((char **));
205 static void do_align
PARAMS ((int, char *, int));
206 static int hex_float
PARAMS ((int, char *));
207 static void do_org
PARAMS ((segT
, expressionS
*, int));
208 char *demand_copy_string
PARAMS ((int *lenP
));
209 int is_it_end_of_statement
PARAMS ((void));
210 static segT get_segmented_expression
PARAMS ((expressionS
*expP
));
211 static segT get_known_segmented_expression
PARAMS ((expressionS
* expP
));
212 static void pobegin
PARAMS ((void));
213 static int get_line_sb
PARAMS ((sb
*));
222 obj_read_begin_hook ();
224 /* Something close -- but not too close -- to a multiple of 1024.
225 The debugging malloc I'm using has 24 bytes of overhead. */
226 obstack_begin (¬es
, chunksize
);
227 obstack_begin (&cond_obstack
, chunksize
);
229 /* Use machine dependent syntax */
230 for (p
= line_separator_chars
; *p
; p
++)
231 is_end_of_line
[(unsigned char) *p
] = 1;
232 /* Use more. FIXME-SOMEDAY. */
238 /* set up pseudo-op tables */
240 static struct hash_control
*po_hash
;
242 static const pseudo_typeS potable
[] =
244 {"abort", s_abort
, 0},
245 {"align", s_align_ptwo
, 0},
246 {"ascii", stringer
, 0},
247 {"asciz", stringer
, 1},
248 {"balign", s_align_bytes
, 0},
249 {"balignw", s_align_bytes
, -2},
250 {"balignl", s_align_bytes
, -4},
254 {"common", s_mri_common
, 0},
255 {"common.s", s_mri_common
, 1},
259 {"dc.d", float_cons
, 'd'},
261 {"dc.s", float_cons
, 'f'},
263 {"dc.x", float_cons
, 'x'},
265 {"dcb.b", s_space
, 1},
266 {"dcb.d", s_float_space
, 'd'},
267 {"dcb.l", s_space
, 4},
268 {"dcb.s", s_float_space
, 'f'},
269 {"dcb.w", s_space
, 2},
270 {"dcb.x", s_float_space
, 'x'},
272 {"ds.b", s_space
, 1},
273 {"ds.d", s_space
, 8},
274 {"ds.l", s_space
, 4},
275 {"ds.p", s_space
, 12},
276 {"ds.s", s_space
, 4},
277 {"ds.w", s_space
, 2},
278 {"ds.x", s_space
, 12},
279 {"debug", s_ignore
, 0},
284 {"double", float_cons
, 'd'},
286 {"eject", listing_eject
, 0}, /* Formfeed listing */
288 {"elsec", s_else
, 0},
290 {"endc", s_endif
, 0},
291 {"endif", s_endif
, 0},
295 {"exitm", s_mexit
, 0},
297 {"extern", s_ignore
, 0}, /* We treat all undef as ext */
298 {"appfile", s_app_file
, 1},
299 {"appline", s_app_line
, 0},
301 {"file", s_app_file
, 0},
303 {"float", float_cons
, 'f'},
304 {"format", s_ignore
, 0},
305 {"global", s_globl
, 0},
306 {"globl", s_globl
, 0},
308 {"if", s_if
, (int) O_ne
},
310 {"ifdef", s_ifdef
, 0},
311 {"ifeq", s_if
, (int) O_eq
},
312 {"ifeqs", s_ifeqs
, 0},
313 {"ifge", s_if
, (int) O_ge
},
314 {"ifgt", s_if
, (int) O_gt
},
315 {"ifle", s_if
, (int) O_le
},
316 {"iflt", s_if
, (int) O_lt
},
318 {"ifndef", s_ifdef
, 1},
319 {"ifne", s_if
, (int) O_ne
},
320 {"ifnes", s_ifeqs
, 1},
321 {"ifnotdef", s_ifdef
, 1},
322 {"include", s_include
, 0},
328 {"lcomm", s_lcomm
, 0},
329 {"lflags", listing_flags
, 0}, /* Listing flags */
330 {"linkonce", s_linkonce
, 0},
331 {"list", listing_list
, 1}, /* Turn listing on */
332 {"llen", listing_psize
, 1},
335 {"macro", s_macro
, 0},
336 {"mexit", s_mexit
, 0},
338 {".mri", s_mri
, 0}, /* Special case so .mri works in MRI mode. */
339 {"name", s_ignore
, 0},
340 {"noformat", s_ignore
, 0},
341 {"nolist", listing_list
, 0}, /* Turn listing off */
342 {"nopage", listing_nopage
, 0},
344 {"offset", s_struct
, 0},
346 {"p2align", s_align_ptwo
, 0},
347 {"p2alignw", s_align_ptwo
, -2},
348 {"p2alignl", s_align_ptwo
, -4},
349 {"page", listing_eject
, 0},
350 {"plen", listing_psize
, 0},
351 {"print", s_print
, 0},
352 {"psize", listing_psize
, 0}, /* set paper size */
353 {"purgem", s_purgem
, 0},
358 {"sbttl", listing_title
, 1}, /* Subtitle of listing */
363 {"single", float_cons
, 'f'},
365 {"space", s_space
, 0},
366 {"spc", s_ignore
, 0},
367 {"stabd", s_stab
, 'd'},
368 {"stabn", s_stab
, 'n'},
369 {"stabs", s_stab
, 's'},
370 {"string", stringer
, 1},
371 {"struct", s_struct
, 0},
375 /* This is for gcc to use. It's only just been added (2/94), so gcc
376 won't be able to use it for a while -- probably a year or more.
377 But once this has been released, check with gcc maintainers
378 before deleting it or even changing the spelling. */
379 {"this_GCC_requires_the_GNU_assembler", s_ignore
, 0},
380 /* If we're folding case -- done for some targets, not necessarily
381 all -- the above string in an input file will be converted to
382 this one. Match it either way... */
383 {"this_gcc_requires_the_gnu_assembler", s_ignore
, 0},
385 {"title", listing_title
, 0}, /* Listing title */
386 {"ttl", listing_title
, 0},
391 {"xdef", s_globl
, 0},
392 {"xref", s_ignore
, 0},
393 {"xstabs", s_xstab
, 's'},
395 {"zero", s_space
, 0},
396 {NULL
} /* end sentinel */
399 static int pop_override_ok
= 0;
400 static const char *pop_table_name
;
404 const pseudo_typeS
*table
;
407 const pseudo_typeS
*pop
;
408 for (pop
= table
; pop
->poc_name
; pop
++)
410 errtxt
= hash_insert (po_hash
, pop
->poc_name
, (char *) pop
);
411 if (errtxt
&& (!pop_override_ok
|| strcmp (errtxt
, "exists")))
412 as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name
,
417 #ifndef md_pop_insert
418 #define md_pop_insert() pop_insert(md_pseudo_table)
421 #ifndef obj_pop_insert
422 #define obj_pop_insert() pop_insert(obj_pseudo_table)
428 po_hash
= hash_new ();
430 /* Do the target-specific pseudo ops. */
431 pop_table_name
= "md";
434 /* Now object specific. Skip any that were in the target table. */
435 pop_table_name
= "obj";
439 /* Now portable ones. Skip any that we've seen already. */
440 pop_table_name
= "standard";
441 pop_insert (potable
);
444 #define HANDLE_CONDITIONAL_ASSEMBLY() \
445 if (ignore_input ()) \
447 while (! is_end_of_line[(unsigned char) *input_line_pointer++]) \
448 if (input_line_pointer == buffer_limit) \
454 /* This function is used when scrubbing the characters between #APP
457 static char *scrub_string
;
458 static char *scrub_string_end
;
461 scrub_from_string (from
)
466 *from
= scrub_string
;
467 size
= scrub_string_end
- scrub_string
;
468 scrub_string
= scrub_string_end
;
472 /* read_a_source_file()
474 * We read the file, putting things into a web that
475 * represents what we have been reading.
478 read_a_source_file (name
)
482 register char *s
; /* string of symbol, '\0' appended */
486 buffer
= input_scrub_new_file (name
);
489 listing_newline ("");
491 while ((buffer_limit
= input_scrub_next_buffer (&input_line_pointer
)) != 0)
492 { /* We have another line to parse. */
493 know (buffer_limit
[-1] == '\n'); /* Must have a sentinel. */
494 contin
: /* JF this goto is my fault I admit it.
495 Someone brave please re-write the whole
496 input section here? Pleeze??? */
497 while (input_line_pointer
< buffer_limit
)
499 /* We have more of this buffer to parse. */
502 * We now have input_line_pointer->1st char of next line.
503 * If input_line_pointer [-1] == '\n' then we just
504 * scanned another line: so bump line counters.
506 if (is_end_of_line
[(unsigned char) input_line_pointer
[-1]])
508 #ifdef md_start_line_hook
509 md_start_line_hook ();
512 if (input_line_pointer
[-1] == '\n')
513 bump_line_counters ();
518 #ifdef LABELS_WITHOUT_COLONS
523 /* Text at the start of a line must be a label, we
524 run down and stick a colon in. */
525 if (is_name_beginner (*input_line_pointer
))
527 char *line_start
= input_line_pointer
;
530 HANDLE_CONDITIONAL_ASSEMBLY ();
532 c
= get_symbol_end ();
534 /* In MRI mode, the EQU pseudoop must be
535 handled specially. */
538 char *rest
= input_line_pointer
+ 1;
542 if (*rest
== ' ' || *rest
== '\t')
544 if ((strncasecmp (rest
, "EQU", 3) == 0
545 || strncasecmp (rest
, "SET", 3) == 0)
546 && (rest
[3] == ' ' || rest
[3] == '\t'))
548 input_line_pointer
= rest
+ 3;
554 line_label
= colon (line_start
);
556 *input_line_pointer
= c
;
558 input_line_pointer
++;
564 * We are at the begining of a line, or similar place.
565 * We expect a well-formed assembler statement.
566 * A "symbol-name:" is a statement.
568 * Depending on what compiler is used, the order of these tests
569 * may vary to catch most common case 1st.
570 * Each test is independent of all other tests at the (top) level.
571 * PLEASE make a compiler that doesn't use this assembler.
572 * It is crufty to waste a compiler's time encoding things for this
573 * assembler, which then wastes more time decoding it.
574 * (And communicating via (linear) files is silly!
575 * If you must pass stuff, please pass a tree!)
577 if ((c
= *input_line_pointer
++) == '\t'
582 c
= *input_line_pointer
++;
584 know (c
!= ' '); /* No further leading whitespace. */
587 * C is the 1st significant character.
588 * Input_line_pointer points after that character.
590 if (is_name_beginner (c
))
592 /* want user-defined label or pseudo/opcode */
593 HANDLE_CONDITIONAL_ASSEMBLY ();
595 s
= --input_line_pointer
;
596 c
= get_symbol_end (); /* name's delimiter */
598 * C is character after symbol.
599 * That character's place in the input line is now '\0'.
600 * S points to the beginning of the symbol.
601 * [In case of pseudo-op, s->'.'.]
602 * Input_line_pointer->'\0' where c was.
604 if (TC_START_LABEL(c
, input_line_pointer
))
608 char *rest
= input_line_pointer
+ 1;
610 /* In MRI mode, \tsym: set 0 is permitted. */
614 if (*rest
== ' ' || *rest
== '\t')
616 if ((strncasecmp (rest
, "EQU", 3) == 0
617 || strncasecmp (rest
, "SET", 3) == 0)
618 && (rest
[3] == ' ' || rest
[3] == '\t'))
620 input_line_pointer
= rest
+ 3;
626 line_label
= colon (s
); /* user-defined label */
627 *input_line_pointer
++ = ':'; /* Put ':' back for error messages' sake. */
628 /* Input_line_pointer->after ':'. */
634 || (input_line_pointer
[1] == '='
635 #ifdef TC_EQUAL_IN_INSN
636 && ! TC_EQUAL_IN_INSN (c
, input_line_pointer
)
641 demand_empty_rest_of_line ();
644 { /* expect pseudo-op or machine instruction */
647 #define IGNORE_OPCODE_CASE
648 #ifdef IGNORE_OPCODE_CASE
666 /* The MRI assembler and the m88k use pseudo-ops
668 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
);
669 if (pop
!= NULL
&& pop
->poc_handler
== NULL
)
674 || (! flag_m68k_mri
&& *s
== '.'))
679 * WARNING: c has next char, which may be end-of-line.
680 * We lookup the pseudo-op table with s+1 because we
681 * already know that the pseudo-op begins with a '.'.
685 pop
= (pseudo_typeS
*) hash_find (po_hash
, s
+ 1);
687 /* In MRI mode, we may need to insert an
688 automatic alignment directive. What a hack
690 if (mri_pending_align
692 || ! ((pop
->poc_handler
== cons
693 && pop
->poc_val
== 1)
694 || (pop
->poc_handler
== s_space
695 && pop
->poc_val
== 1))))
697 do_align (1, (char *) NULL
, 0);
698 mri_pending_align
= 0;
701 /* Print the error msg now, while we still can */
704 as_bad ("Unknown pseudo-op: `%s'", s
);
705 *input_line_pointer
= c
;
710 /* Put it back for error messages etc. */
711 *input_line_pointer
= c
;
712 /* The following skip of whitespace is compulsory.
713 A well shaped space is sometimes all that separates
714 keyword from operands. */
715 if (c
== ' ' || c
== '\t')
716 input_line_pointer
++;
718 * Input_line is restored.
719 * Input_line_pointer->1st non-blank char
720 * after pseudo-operation.
722 (*pop
->poc_handler
) (pop
->poc_val
);
724 /* If that was .end, just get out now. */
725 if (pop
->poc_handler
== s_end
)
729 { /* machine instruction */
732 if (mri_pending_align
)
734 do_align (1, (char *) NULL
, 0);
735 mri_pending_align
= 0;
738 /* WARNING: c has char, which may be end-of-line. */
739 /* Also: input_line_pointer->`\0` where c was. */
740 *input_line_pointer
= c
;
741 while (!is_end_of_line
[(unsigned char) *input_line_pointer
]
743 #ifdef TC_EOL_IN_INSN
744 || TC_EOL_IN_INSN (input_line_pointer
)
748 if (flag_m68k_mri
&& *input_line_pointer
== '\'')
750 input_line_pointer
++;
753 c
= *input_line_pointer
;
754 *input_line_pointer
= '\0';
756 #ifdef OBJ_GENERATE_ASM_LINENO
757 if (generate_asm_lineno
== 0)
759 if (ecoff_no_current_file ())
760 generate_asm_lineno
= 1;
762 if (generate_asm_lineno
== 1)
767 as_where (&s
, &lineno
);
768 OBJ_GENERATE_ASM_LINENO (s
, lineno
);
777 if (check_macro (s
, &out
, '\0', &err
))
781 *input_line_pointer
++ = c
;
782 input_scrub_include_sb (&out
,
786 input_scrub_next_buffer (&input_line_pointer
);
791 md_assemble (s
); /* Assemble 1 instruction. */
793 *input_line_pointer
++ = c
;
795 /* We resume loop AFTER the end-of-line from
800 } /* if (is_name_beginner(c) */
803 /* Empty statement? */
804 if (is_end_of_line
[(unsigned char) c
])
807 if ((LOCAL_LABELS_DOLLAR
|| LOCAL_LABELS_FB
)
810 /* local label ("4:") */
811 char *backup
= input_line_pointer
;
813 HANDLE_CONDITIONAL_ASSEMBLY ();
817 while (isdigit (*input_line_pointer
))
819 temp
= (temp
* 10) + *input_line_pointer
- '0';
820 ++input_line_pointer
;
821 } /* read the whole number */
823 if (LOCAL_LABELS_DOLLAR
824 && *input_line_pointer
== '$'
825 && *(input_line_pointer
+ 1) == ':')
827 input_line_pointer
+= 2;
829 if (dollar_label_defined (temp
))
831 as_fatal ("label \"%d$\" redefined", temp
);
834 define_dollar_label (temp
);
835 colon (dollar_label_name (temp
, 0));
840 && *input_line_pointer
++ == ':')
842 fb_label_instance_inc (temp
);
843 colon (fb_label_name (temp
, 0));
847 input_line_pointer
= backup
;
848 } /* local label ("4:") */
850 if (c
&& strchr (line_comment_chars
, c
))
851 { /* Its a comment. Better say APP or NO_APP */
855 unsigned int new_length
;
858 bump_line_counters ();
859 s
= input_line_pointer
;
860 if (strncmp (s
, "APP\n", 4))
861 continue; /* We ignore it */
864 ends
= strstr (s
, "#NO_APP\n");
868 unsigned int tmp_len
;
871 /* The end of the #APP wasn't in this buffer. We
872 keep reading in buffers until we find the #NO_APP
873 that goes with this #APP There is one. The specs
875 tmp_len
= buffer_limit
- s
;
876 tmp_buf
= xmalloc (tmp_len
+ 1);
877 memcpy (tmp_buf
, s
, tmp_len
);
880 new_tmp
= input_scrub_next_buffer (&buffer
);
884 buffer_limit
= new_tmp
;
885 input_line_pointer
= buffer
;
886 ends
= strstr (buffer
, "#NO_APP\n");
890 num
= buffer_limit
- buffer
;
892 tmp_buf
= xrealloc (tmp_buf
, tmp_len
+ num
);
893 memcpy (tmp_buf
+ tmp_len
, buffer
, num
);
898 input_line_pointer
= ends
? ends
+ 8 : NULL
;
906 input_line_pointer
= ends
+ 8;
910 scrub_string_end
= ends
;
912 new_length
= ends
- s
;
913 new_buf
= (char *) xmalloc (new_length
);
920 space
= (new_buf
+ new_length
) - new_tmp
;
921 size
= do_scrub_chars (scrub_from_string
, new_tmp
, space
);
929 new_buf
= xrealloc (new_buf
, new_length
+ 100);
930 new_tmp
= new_buf
+ new_length
;
937 old_input
= input_line_pointer
;
938 old_limit
= buffer_limit
;
940 input_line_pointer
= new_buf
;
941 buffer_limit
= new_tmp
;
945 HANDLE_CONDITIONAL_ASSEMBLY ();
947 #ifdef tc_unrecognized_line
948 if (tc_unrecognized_line (c
))
952 /* as_warn("Junk character %d.",c); Now done by ignore_rest */
953 input_line_pointer
--; /* Report unknown char as ignored. */
954 ignore_rest_of_line ();
955 } /* while (input_line_pointer<buffer_limit) */
957 #ifdef md_after_pass_hook
958 md_after_pass_hook ();
964 bump_line_counters ();
968 input_line_pointer
= old_input
;
969 buffer_limit
= old_limit
;
974 } /* while (more buffers to scan) */
977 input_scrub_close (); /* Close the input file */
980 /* For most MRI pseudo-ops, the line actually ends at the first
981 nonquoted space. This function looks for that point, stuffs a null
982 in, and sets *STOPCP to the character that used to be there, and
983 returns the location.
985 Until I hear otherwise, I am going to assume that this is only true
986 for the m68k MRI assembler. */
989 mri_comment_field (stopcp
)
997 know (flag_m68k_mri
);
999 for (s
= input_line_pointer
;
1000 ((! is_end_of_line
[(unsigned char) *s
] && *s
!= ' ' && *s
!= '\t')
1005 inquote
= ! inquote
;
1015 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
1025 /* Skip to the end of an MRI comment field. */
1028 mri_comment_end (stop
, stopc
)
1034 input_line_pointer
= stop
;
1036 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1037 ++input_line_pointer
;
1044 as_fatal (".abort detected. Abandoning ship.");
1047 /* Guts of .align directive. */
1049 do_align (n
, fill
, len
)
1055 md_do_align (n
, fill
, len
, just_record_alignment
);
1059 /* @@ Fix this right for BFD! */
1061 static char nop_opcode
= NOP_OPCODE
;
1063 if (now_seg
!= data_section
&& now_seg
!= bss_section
)
1074 /* Only make a frag if we HAVE to. . . */
1075 if (n
&& !need_pass_2
)
1078 frag_align (n
, *fill
);
1080 frag_align_pattern (n
, fill
, len
);
1084 just_record_alignment
:
1087 record_alignment (now_seg
, n
);
1090 /* For machines where ".align 4" means align to a 4 byte boundary. */
1095 register unsigned int temp
;
1098 unsigned long max_alignment
= 1 << 15;
1103 stop
= mri_comment_field (&stopc
);
1105 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
1110 temp
= arg
; /* Default value from pseudo-op table */
1113 temp
= get_absolute_expression ();
1115 if (temp
> max_alignment
)
1117 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1120 /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1121 have to convert it. */
1124 for (i
= 0; (temp
& 1) == 0; temp
>>= 1, ++i
)
1128 as_bad ("Alignment not a power of 2");
1131 if (*input_line_pointer
== ',')
1136 input_line_pointer
++;
1137 fillval
= get_absolute_expression ();
1144 temp_fill
= fillval
;
1145 do_align (temp
, &temp_fill
, len
);
1151 if (len
> sizeof ab
)
1153 md_number_to_chars (ab
, fillval
, len
);
1154 do_align (temp
, ab
, len
);
1160 as_warn ("expected fill pattern missing");
1161 do_align (temp
, (char *) NULL
, 0);
1165 mri_comment_end (stop
, stopc
);
1167 demand_empty_rest_of_line ();
1170 /* For machines where ".align 4" means align to 2**4 boundary. */
1177 long max_alignment
= 15;
1182 stop
= mri_comment_field (&stopc
);
1184 temp
= get_absolute_expression ();
1185 if (temp
> max_alignment
)
1186 as_bad ("Alignment too large: %d. assumed.", temp
= max_alignment
);
1189 as_bad ("Alignment negative. 0 assumed.");
1192 if (*input_line_pointer
== ',')
1197 input_line_pointer
++;
1198 fillval
= get_absolute_expression ();
1205 temp_fill
= fillval
;
1206 do_align (temp
, &temp_fill
, len
);
1212 if (len
> sizeof ab
)
1214 md_number_to_chars (ab
, fillval
, len
);
1215 do_align (temp
, ab
, len
);
1221 as_warn ("expected fill pattern missing");
1222 do_align (temp
, (char *) NULL
, 0);
1226 mri_comment_end (stop
, stopc
);
1228 demand_empty_rest_of_line ();
1235 register char *name
;
1239 register symbolS
*symbolP
;
1244 stop
= mri_comment_field (&stopc
);
1246 name
= input_line_pointer
;
1247 c
= get_symbol_end ();
1248 /* just after name is now '\0' */
1249 p
= input_line_pointer
;
1252 if (*input_line_pointer
!= ',')
1254 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1256 mri_comment_end (stop
, stopc
);
1257 ignore_rest_of_line ();
1260 input_line_pointer
++; /* skip ',' */
1261 if ((temp
= get_absolute_expression ()) < 0)
1263 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp
);
1265 mri_comment_end (stop
, stopc
);
1266 ignore_rest_of_line ();
1270 symbolP
= symbol_find_or_make (name
);
1272 if (S_IS_DEFINED (symbolP
))
1274 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1275 S_GET_NAME (symbolP
));
1277 mri_comment_end (stop
, stopc
);
1278 ignore_rest_of_line ();
1281 if (S_GET_VALUE (symbolP
))
1283 if (S_GET_VALUE (symbolP
) != (valueT
) temp
)
1284 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1285 S_GET_NAME (symbolP
),
1286 (long) S_GET_VALUE (symbolP
),
1291 S_SET_VALUE (symbolP
, (valueT
) temp
);
1292 S_SET_EXTERNAL (symbolP
);
1296 extern int flag_one
;
1297 if ( (!temp
) || !flag_one
)
1298 S_GET_OTHER(symbolP
) = const_flag
;
1300 #endif /* not OBJ_VMS */
1301 know (symbolP
->sy_frag
== &zero_address_frag
);
1304 mri_comment_end (stop
, stopc
);
1306 demand_empty_rest_of_line ();
1309 /* The MRI COMMON pseudo-op. We handle this by creating a common
1310 symbol with the appropriate name. We make s_space do the right
1311 thing by increasing the size. */
1314 s_mri_common (small
)
1331 stop
= mri_comment_field (&stopc
);
1335 name
= input_line_pointer
;
1336 if (! isdigit ((unsigned char) *name
))
1337 c
= get_symbol_end ();
1342 ++input_line_pointer
;
1344 while (isdigit ((unsigned char) *input_line_pointer
));
1345 c
= *input_line_pointer
;
1346 *input_line_pointer
= '\0';
1348 if (line_label
!= NULL
)
1350 alc
= (char *) xmalloc (strlen (S_GET_NAME (line_label
))
1351 + (input_line_pointer
- name
)
1353 sprintf (alc
, "%s%s", name
, S_GET_NAME (line_label
));
1358 sym
= symbol_find_or_make (name
);
1359 *input_line_pointer
= c
;
1363 if (*input_line_pointer
!= ',')
1367 ++input_line_pointer
;
1368 align
= get_absolute_expression ();
1371 if (S_IS_DEFINED (sym
))
1373 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1374 if (! S_IS_COMMON (sym
))
1377 as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym
));
1378 mri_comment_end (stop
, stopc
);
1379 ignore_rest_of_line ();
1384 S_SET_EXTERNAL (sym
);
1385 mri_common_symbol
= sym
;
1389 S_SET_ALIGN (sym
, align
);
1392 if (line_label
!= NULL
)
1394 line_label
->sy_value
.X_op
= O_symbol
;
1395 line_label
->sy_value
.X_add_symbol
= sym
;
1396 line_label
->sy_value
.X_add_number
= S_GET_VALUE (sym
);
1397 line_label
->sy_frag
= &zero_address_frag
;
1398 S_SET_SEGMENT (line_label
, expr_section
);
1401 /* FIXME: We just ignore the small argument, which distinguishes
1402 COMMON and COMMON.S. I don't know what we can do about it. */
1404 /* Ignore the type and hptype. */
1405 if (*input_line_pointer
== ',')
1406 input_line_pointer
+= 2;
1407 if (*input_line_pointer
== ',')
1408 input_line_pointer
+= 2;
1410 mri_comment_end (stop
, stopc
);
1412 demand_empty_rest_of_line ();
1422 temp
= get_absolute_expression ();
1423 if (flag_readonly_data_in_text
)
1425 section
= text_section
;
1429 section
= data_section
;
1431 subseg_set (section
, (subsegT
) temp
);
1436 demand_empty_rest_of_line ();
1439 /* Handle the .appfile pseudo-op. This is automatically generated by
1440 do_scrub_chars when a preprocessor # line comment is seen with a
1441 file name. This default definition may be overridden by the object
1442 or CPU specific pseudo-ops. This function is also the default
1443 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1447 s_app_file (appfile
)
1453 /* Some assemblers tolerate immediately following '"' */
1454 if ((s
= demand_copy_string (&length
)) != 0)
1456 /* If this is a fake .appfile, a fake newline was inserted into
1457 the buffer. Passing -2 to new_logical_line tells it to
1459 new_logical_line (s
, appfile
? -2 : -1);
1461 /* In MRI mode, the preprocessor may have inserted an extraneous
1464 && *input_line_pointer
== '\''
1465 && is_end_of_line
[(unsigned char) input_line_pointer
[1]])
1466 ++input_line_pointer
;
1468 demand_empty_rest_of_line ();
1471 listing_source_file (s
);
1479 /* Handle the .appline pseudo-op. This is automatically generated by
1480 do_scrub_chars when a preprocessor # line comment is seen. This
1481 default definition may be overridden by the object or CPU specific
1490 /* The given number is that of the next line. */
1491 l
= get_absolute_expression () - 1;
1493 /* Some of the back ends can't deal with non-positive line numbers.
1494 Besides, it's silly. */
1495 as_warn ("Line numbers must be positive; line number %d rejected.", l
+1);
1498 new_logical_line ((char *) NULL
, l
);
1501 listing_source_line (l
);
1504 demand_empty_rest_of_line ();
1507 /* Handle the .end pseudo-op. Actually, the real work is done in
1508 read_a_source_file. */
1516 /* The MRI assembler permits the start symbol to follow .end,
1517 but we don't support that. */
1519 if (! is_end_of_line
[(unsigned char) *input_line_pointer
]
1520 && *input_line_pointer
!= '*'
1521 && *input_line_pointer
!= '!')
1522 as_warn ("start address not supported");
1526 /* Handle the .err pseudo-op. */
1532 as_bad (".err encountered");
1533 demand_empty_rest_of_line ();
1536 /* Handle the MRI fail pseudo-op. */
1547 stop
= mri_comment_field (&stopc
);
1549 temp
= get_absolute_expression ();
1551 as_warn (".fail %ld encountered", (long) temp
);
1553 as_bad (".fail %ld encountered", (long) temp
);
1556 mri_comment_end (stop
, stopc
);
1558 demand_empty_rest_of_line ();
1565 long temp_repeat
= 0;
1567 register long temp_fill
= 0;
1570 #ifdef md_flush_pending_output
1571 md_flush_pending_output ();
1574 temp_repeat
= get_absolute_expression ();
1575 if (*input_line_pointer
== ',')
1577 input_line_pointer
++;
1578 temp_size
= get_absolute_expression ();
1579 if (*input_line_pointer
== ',')
1581 input_line_pointer
++;
1582 temp_fill
= get_absolute_expression ();
1585 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1586 #define BSD_FILL_SIZE_CROCK_8 (8)
1587 if (temp_size
> BSD_FILL_SIZE_CROCK_8
)
1589 as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8
);
1590 temp_size
= BSD_FILL_SIZE_CROCK_8
;
1594 as_warn ("Size negative: .fill ignored.");
1597 else if (temp_repeat
<= 0)
1599 as_warn ("Repeat < 0, .fill ignored");
1603 if (temp_size
&& !need_pass_2
)
1605 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
, (relax_substateT
) 0, (symbolS
*) 0, temp_repeat
, (char *) 0);
1606 memset (p
, 0, (unsigned int) temp_size
);
1607 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1608 * flavoured AS. The following bizzare behaviour is to be
1609 * compatible with above. I guess they tried to take up to 8
1610 * bytes from a 4-byte expression and they forgot to sign
1611 * extend. Un*x Sux. */
1612 #define BSD_FILL_SIZE_CROCK_4 (4)
1613 md_number_to_chars (p
, (valueT
) temp_fill
,
1614 (temp_size
> BSD_FILL_SIZE_CROCK_4
1615 ? BSD_FILL_SIZE_CROCK_4
1616 : (int) temp_size
));
1617 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1618 * but emits no error message because it seems a legal thing to do.
1619 * It is a degenerate case of .fill but could be emitted by a compiler.
1622 demand_empty_rest_of_line ();
1636 stop
= mri_comment_field (&stopc
);
1640 name
= input_line_pointer
;
1641 c
= get_symbol_end ();
1642 symbolP
= symbol_find_or_make (name
);
1643 *input_line_pointer
= c
;
1645 S_SET_EXTERNAL (symbolP
);
1648 input_line_pointer
++;
1650 if (*input_line_pointer
== '\n')
1657 mri_comment_end (stop
, stopc
);
1659 demand_empty_rest_of_line ();
1662 /* Handle the MRI IRP and IRPC pseudo-ops. */
1674 as_where (&file
, &line
);
1677 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1678 sb_add_char (&s
, *input_line_pointer
++);
1682 err
= expand_irp (irpc
, 0, &s
, &out
, get_line_sb
, '\0');
1684 as_bad_where (file
, line
, "%s", err
);
1688 input_scrub_include_sb (&out
, input_line_pointer
);
1690 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
1693 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
1694 the section to only be linked once. However, this is not supported
1695 by most object file formats. This takes an optional argument,
1696 which is what to do about duplicates. */
1702 enum linkonce_type type
;
1706 type
= LINKONCE_DISCARD
;
1708 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
1713 s
= input_line_pointer
;
1714 c
= get_symbol_end ();
1715 if (strcasecmp (s
, "discard") == 0)
1716 type
= LINKONCE_DISCARD
;
1717 else if (strcasecmp (s
, "one_only") == 0)
1718 type
= LINKONCE_ONE_ONLY
;
1719 else if (strcasecmp (s
, "same_size") == 0)
1720 type
= LINKONCE_SAME_SIZE
;
1721 else if (strcasecmp (s
, "same_contents") == 0)
1722 type
= LINKONCE_SAME_CONTENTS
;
1724 as_warn ("unrecognized .linkonce type `%s'", s
);
1726 *input_line_pointer
= c
;
1729 #ifdef obj_handle_link_once
1730 obj_handle_link_once (type
);
1731 #else /* ! defined (obj_handle_link_once) */
1732 #ifdef BFD_ASSEMBLER
1736 if ((bfd_applicable_section_flags (stdoutput
) & SEC_LINK_ONCE
) == 0)
1737 as_warn (".linkonce is not supported for this object file format");
1739 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
1740 flags
|= SEC_LINK_ONCE
;
1745 case LINKONCE_DISCARD
:
1746 flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1748 case LINKONCE_ONE_ONLY
:
1749 flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1751 case LINKONCE_SAME_SIZE
:
1752 flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1754 case LINKONCE_SAME_CONTENTS
:
1755 flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1758 if (! bfd_set_section_flags (stdoutput
, now_seg
, flags
))
1759 as_bad ("bfd_set_section_flags: %s",
1760 bfd_errmsg (bfd_get_error ()));
1762 #else /* ! defined (BFD_ASSEMBLER) */
1763 as_warn (".linkonce is not supported for this object file format");
1764 #endif /* ! defined (BFD_ASSEMBLER) */
1765 #endif /* ! defined (obj_handle_link_once) */
1767 demand_empty_rest_of_line ();
1771 s_lcomm (needs_align
)
1772 /* 1 if this was a ".bss" directive, which may require a 3rd argument
1773 (alignment); 0 if it was an ".lcomm" (2 args only) */
1776 register char *name
;
1780 register symbolS
*symbolP
;
1781 segT current_seg
= now_seg
;
1782 subsegT current_subseg
= now_subseg
;
1783 const int max_alignment
= 15;
1785 segT bss_seg
= bss_section
;
1787 name
= input_line_pointer
;
1788 c
= get_symbol_end ();
1789 p
= input_line_pointer
;
1793 /* Accept an optional comma after the name. The comma used to be
1794 required, but Irix 5 cc does not generate it. */
1795 if (*input_line_pointer
== ',')
1797 ++input_line_pointer
;
1801 if (*input_line_pointer
== '\n')
1803 as_bad ("Missing size expression");
1807 if ((temp
= get_absolute_expression ()) < 0)
1809 as_warn ("BSS length (%d.) <0! Ignored.", temp
);
1810 ignore_rest_of_line ();
1814 #if defined (TC_MIPS) || defined (TC_ALPHA)
1815 if (OUTPUT_FLAVOR
== bfd_target_ecoff_flavour
1816 || OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
1818 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
1819 if (temp
<= bfd_get_gp_size (stdoutput
))
1821 bss_seg
= subseg_new (".sbss", 1);
1822 seg_info (bss_seg
)->bss
= 1;
1828 /* FIXME. This needs to be machine independent. */
1838 record_alignment(bss_seg
, align
);
1845 if (*input_line_pointer
!= ',')
1847 as_bad ("Expected comma after size");
1848 ignore_rest_of_line ();
1851 input_line_pointer
++;
1853 if (*input_line_pointer
== '\n')
1855 as_bad ("Missing alignment");
1858 align
= get_absolute_expression ();
1859 if (align
> max_alignment
)
1861 align
= max_alignment
;
1862 as_warn ("Alignment too large: %d. assumed.", align
);
1867 as_warn ("Alignment negative. 0 assumed.");
1869 record_alignment (bss_seg
, align
);
1870 } /* if needs align */
1873 /* Assume some objects may require alignment on some systems. */
1877 align
= ffs (temp
) - 1;
1878 if (temp
% (1 << align
))
1885 symbolP
= symbol_find_or_make (name
);
1889 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1890 S_GET_OTHER (symbolP
) == 0 &&
1891 S_GET_DESC (symbolP
) == 0 &&
1892 #endif /* OBJ_AOUT or OBJ_BOUT */
1893 (S_GET_SEGMENT (symbolP
) == bss_seg
1894 || (!S_IS_DEFINED (symbolP
) && S_GET_VALUE (symbolP
) == 0)))
1898 subseg_set (bss_seg
, 1);
1901 frag_align (align
, 0);
1902 /* detach from old frag */
1903 if (S_GET_SEGMENT (symbolP
) == bss_seg
)
1904 symbolP
->sy_frag
->fr_symbol
= NULL
;
1906 symbolP
->sy_frag
= frag_now
;
1907 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1911 S_SET_SEGMENT (symbolP
, bss_seg
);
1914 /* The symbol may already have been created with a preceding
1915 ".globl" directive -- be careful not to step on storage class
1916 in that case. Otherwise, set it to static. */
1917 if (S_GET_STORAGE_CLASS (symbolP
) != C_EXT
)
1919 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1921 #endif /* OBJ_COFF */
1924 S_SET_SIZE (symbolP
, temp
);
1928 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1929 S_GET_NAME (symbolP
));
1931 subseg_set (current_seg
, current_subseg
);
1933 demand_empty_rest_of_line ();
1940 register char *name
;
1944 register symbolS
*symbolP
;
1946 /* we permit ANY defined expression: BSD4.2 demands constants */
1947 name
= input_line_pointer
;
1948 c
= get_symbol_end ();
1949 p
= input_line_pointer
;
1952 if (*input_line_pointer
!= ',')
1955 as_bad ("Expected comma after name \"%s\"", name
);
1957 ignore_rest_of_line ();
1960 input_line_pointer
++;
1962 if (exp
.X_op
!= O_constant
1963 && exp
.X_op
!= O_register
)
1965 as_bad ("bad expression");
1966 ignore_rest_of_line ();
1970 symbolP
= symbol_find_or_make (name
);
1972 /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1973 symbolP->sy_desc == 0) out of this test because coff doesn't have
1974 those fields, and I can't see when they'd ever be tripped. I
1975 don't think I understand why they were here so I may have
1976 introduced a bug. As recently as 1.37 didn't have this test
1977 anyway. xoxorich. */
1979 if (S_GET_SEGMENT (symbolP
) == undefined_section
1980 && S_GET_VALUE (symbolP
) == 0)
1982 /* The name might be an undefined .global symbol; be sure to
1983 keep the "external" bit. */
1984 S_SET_SEGMENT (symbolP
,
1985 (exp
.X_op
== O_constant
1988 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
1992 as_bad ("Symbol %s already defined", name
);
1995 demand_empty_rest_of_line ();
1998 /* Read a line into an sb. */
2004 if (input_line_pointer
>= buffer_limit
)
2006 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2007 if (buffer_limit
== 0)
2011 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2012 sb_add_char (line
, *input_line_pointer
++);
2013 while (input_line_pointer
< buffer_limit
2014 && is_end_of_line
[(unsigned char) *input_line_pointer
])
2016 if (*input_line_pointer
== '\n')
2018 bump_line_counters ();
2021 ++input_line_pointer
;
2026 /* Define a macro. This is an interface to macro.c, which is shared
2027 between gas and gasp. */
2039 as_where (&file
, &line
);
2042 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2043 sb_add_char (&s
, *input_line_pointer
++);
2046 if (line_label
!= NULL
)
2047 sb_add_string (&label
, S_GET_NAME (line_label
));
2049 demand_empty_rest_of_line ();
2051 err
= define_macro (0, &s
, &label
, get_line_sb
);
2053 as_bad_where (file
, line
, "%s", err
);
2056 if (line_label
!= NULL
)
2058 S_SET_SEGMENT (line_label
, undefined_section
);
2059 S_SET_VALUE (line_label
, 0);
2060 line_label
->sy_frag
= &zero_address_frag
;
2067 /* Handle the .mexit pseudo-op, which immediately exits a macro
2074 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2077 /* Switch in and out of MRI mode. */
2085 on
= get_absolute_expression ();
2086 old_flag
= flag_mri
;
2100 #ifdef MRI_MODE_CHANGE
2102 MRI_MODE_CHANGE (on
);
2105 demand_empty_rest_of_line ();
2108 /* Handle changing the location counter. */
2111 do_org (segment
, exp
, fill
)
2116 if (segment
!= now_seg
&& segment
!= absolute_section
)
2117 as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2118 segment_name (segment
), segment_name (now_seg
));
2120 if (now_seg
== absolute_section
)
2123 as_warn ("ignoring fill value in absolute section");
2124 if (exp
->X_op
!= O_constant
)
2126 as_bad ("only constant offsets supported in absolute section");
2127 exp
->X_add_number
= 0;
2129 abs_section_offset
= exp
->X_add_number
;
2135 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, exp
->X_add_symbol
,
2136 exp
->X_add_number
, (char *) NULL
);
2145 register segT segment
;
2147 register long temp_fill
;
2149 /* The m68k MRI assembler has a different meaning for .org. It
2150 means to create an absolute section at a given address. We can't
2151 support that--use a linker script instead. */
2154 as_bad ("MRI style ORG pseudo-op not supported");
2155 ignore_rest_of_line ();
2159 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2160 thing as a sub-segment-relative origin. Any absolute origin is
2161 given a warning, then assumed to be segment-relative. Any
2162 segmented origin expression ("foo+42") had better be in the right
2163 segment or the .org is ignored.
2165 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2166 we never know sub-segment sizes when we are reading code. BSD
2167 will crash trying to emit negative numbers of filler bytes in
2168 certain .orgs. We don't crash, but see as-write for that code.
2170 Don't make frag if need_pass_2==1. */
2171 segment
= get_known_segmented_expression (&exp
);
2172 if (*input_line_pointer
== ',')
2174 input_line_pointer
++;
2175 temp_fill
= get_absolute_expression ();
2181 do_org (segment
, &exp
, temp_fill
);
2183 demand_empty_rest_of_line ();
2186 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2187 called by the obj-format routine which handles section changing
2188 when in MRI mode. It will create a new section, and return it. It
2189 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2190 'M' (mixed), or 'R' (romable). If BFD_ASSEMBLER is defined, the
2191 flags will be set in the section. */
2205 name
= input_line_pointer
;
2206 if (! isdigit ((unsigned char) *name
))
2207 c
= get_symbol_end ();
2212 ++input_line_pointer
;
2214 while (isdigit ((unsigned char) *input_line_pointer
));
2215 c
= *input_line_pointer
;
2216 *input_line_pointer
= '\0';
2219 name
= xstrdup (name
);
2221 *input_line_pointer
= c
;
2223 seg
= subseg_new (name
, 0);
2225 if (*input_line_pointer
== ',')
2229 ++input_line_pointer
;
2230 align
= get_absolute_expression ();
2231 record_alignment (seg
, align
);
2235 if (*input_line_pointer
== ',')
2237 c
= *++input_line_pointer
;
2238 c
= toupper ((unsigned char) c
);
2239 if (c
== 'C' || c
== 'D' || c
== 'M' || c
== 'R')
2242 as_bad ("unrecognized section type");
2243 ++input_line_pointer
;
2245 #ifdef BFD_ASSEMBLER
2249 flags
= SEC_NO_FLAGS
;
2251 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
;
2252 else if (*type
== 'D' || *type
== 'M')
2253 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
;
2254 else if (*type
== 'R')
2255 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_DATA
| SEC_READONLY
| SEC_ROM
;
2256 if (flags
!= SEC_NO_FLAGS
)
2258 if (! bfd_set_section_flags (stdoutput
, seg
, flags
))
2259 as_warn ("error setting flags for \"%s\": %s",
2260 bfd_section_name (stdoutput
, seg
),
2261 bfd_errmsg (bfd_get_error ()));
2267 /* Ignore the HP type. */
2268 if (*input_line_pointer
== ',')
2269 input_line_pointer
+= 2;
2271 demand_empty_rest_of_line ();
2273 #else /* ! TC_M68K */
2282 name
= input_line_pointer
;
2283 c
= get_symbol_end ();
2285 name
= xstrdup (name
);
2287 *input_line_pointer
= c
;
2289 seg
= subseg_new (name
, 0);
2291 if (*input_line_pointer
!= ',')
2297 ++input_line_pointer
;
2299 sectype
= input_line_pointer
;
2300 c
= get_symbol_end ();
2301 if (*sectype
== '\0')
2303 else if (strcasecmp (sectype
, "text") == 0)
2305 else if (strcasecmp (sectype
, "data") == 0)
2307 else if (strcasecmp (sectype
, "romdata") == 0)
2310 as_warn ("unrecognized section type `%s'", sectype
);
2311 *input_line_pointer
= c
;
2314 if (*input_line_pointer
== ',')
2318 ++input_line_pointer
;
2320 seccmd
= input_line_pointer
;
2321 c
= get_symbol_end ();
2322 if (strcasecmp (seccmd
, "absolute") == 0)
2324 as_bad ("absolute sections are not supported");
2325 *input_line_pointer
= c
;
2326 ignore_rest_of_line ();
2329 else if (strcasecmp (seccmd
, "align") == 0)
2333 *input_line_pointer
= c
;
2334 align
= get_absolute_expression ();
2335 record_alignment (seg
, align
);
2339 as_warn ("unrecognized section command `%s'", seccmd
);
2340 *input_line_pointer
= c
;
2344 demand_empty_rest_of_line ();
2346 #else /* ! TC_I960 */
2347 /* The MRI assembler seems to use different forms of .sect for
2348 different targets. */
2350 #endif /* ! TC_I960 */
2351 #endif /* ! TC_M68K */
2354 /* Handle the .print pseudo-op. */
2363 s
= demand_copy_C_string (&len
);
2365 demand_empty_rest_of_line ();
2368 /* Handle the .purgem pseudo-op. */
2374 if (is_it_end_of_statement ())
2376 demand_empty_rest_of_line ();
2386 name
= input_line_pointer
;
2387 c
= get_symbol_end ();
2388 delete_macro (name
);
2389 *input_line_pointer
= c
;
2392 while (*input_line_pointer
++ == ',');
2394 --input_line_pointer
;
2395 demand_empty_rest_of_line ();
2398 /* Handle the .rept pseudo-op. */
2408 count
= get_absolute_expression ();
2411 if (! buffer_and_nest ("REPT", "ENDR", &one
, get_line_sb
))
2413 as_bad ("rept without endr");
2419 sb_add_sb (&many
, &one
);
2423 input_scrub_include_sb (&many
, input_line_pointer
);
2425 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
2432 register char *name
;
2433 register char delim
;
2434 register char *end_name
;
2435 register symbolS
*symbolP
;
2438 * Especial apologies for the random logic:
2439 * this just grew, and could be parsed much more simply!
2442 name
= input_line_pointer
;
2443 delim
= get_symbol_end ();
2444 end_name
= input_line_pointer
;
2448 if (*input_line_pointer
!= ',')
2451 as_bad ("Expected comma after name \"%s\"", name
);
2453 ignore_rest_of_line ();
2457 input_line_pointer
++;
2460 if (name
[0] == '.' && name
[1] == '\0')
2462 /* Turn '. = mumble' into a .org mumble */
2463 register segT segment
;
2466 segment
= get_known_segmented_expression (&exp
);
2469 do_org (segment
, &exp
, 0);
2475 if ((symbolP
= symbol_find (name
)) == NULL
2476 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2478 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2480 /* "set" symbols are local unless otherwise specified. */
2481 SF_SET_LOCAL (symbolP
);
2482 #endif /* OBJ_COFF */
2484 } /* make a new symbol */
2486 symbol_table_insert (symbolP
);
2489 pseudo_set (symbolP
);
2490 demand_empty_rest_of_line ();
2503 #ifdef md_flush_pending_output
2504 md_flush_pending_output ();
2508 stop
= mri_comment_field (&stopc
);
2510 /* Just like .fill, but temp_size = 1 */
2512 if (exp
.X_op
== O_constant
)
2516 repeat
= exp
.X_add_number
;
2521 if (! flag_mri
|| repeat
< 0)
2522 as_warn (".space repeat count is %s, ignored",
2523 repeat
? "negative" : "zero");
2527 /* If we are in the absolute section, just bump the offset. */
2528 if (now_seg
== absolute_section
)
2530 abs_section_offset
+= repeat
;
2534 /* If we are secretly in an MRI common section, then creating
2535 space just increases the size of the common symbol. */
2536 if (mri_common_symbol
!= NULL
)
2538 S_SET_VALUE (mri_common_symbol
,
2539 S_GET_VALUE (mri_common_symbol
) + repeat
);
2544 p
= frag_var (rs_fill
, 1, 1, (relax_substateT
) 0, (symbolS
*) 0,
2545 repeat
, (char *) 0);
2549 if (now_seg
== absolute_section
)
2551 as_bad ("space allocation too complex in absolute section");
2552 subseg_set (text_section
, 0);
2554 if (mri_common_symbol
!= NULL
)
2556 as_bad ("space allocation too complex in common section");
2557 mri_common_symbol
= NULL
;
2560 p
= frag_var (rs_space
, 1, 1, (relax_substateT
) 0,
2561 make_expr_symbol (&exp
), 0L, (char *) 0);
2564 if (*input_line_pointer
== ',')
2566 input_line_pointer
++;
2567 temp_fill
= get_absolute_expression ();
2580 mri_comment_end (stop
, stopc
);
2582 demand_empty_rest_of_line ();
2585 /* This is like s_space, but the value is a floating point number with
2586 the given precision. This is for the MRI dcb.s pseudo-op and
2590 s_float_space (float_type
)
2595 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
2600 stop
= mri_comment_field (&stopc
);
2602 count
= get_absolute_expression ();
2605 if (*input_line_pointer
!= ',')
2607 as_bad ("missing value");
2609 mri_comment_end (stop
, stopc
);
2610 ignore_rest_of_line ();
2614 ++input_line_pointer
;
2618 /* Skip any 0{letter} that may be present. Don't even check if the
2619 * letter is legal. */
2620 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
2621 input_line_pointer
+= 2;
2623 /* Accept :xxxx, where the x's are hex digits, for a floating point
2624 with the exact digits specified. */
2625 if (input_line_pointer
[0] == ':')
2627 flen
= hex_float (float_type
, temp
);
2631 mri_comment_end (stop
, stopc
);
2632 ignore_rest_of_line ();
2640 err
= md_atof (float_type
, temp
, &flen
);
2641 know (flen
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
2645 as_bad ("Bad floating literal: %s", err
);
2647 mri_comment_end (stop
, stopc
);
2648 ignore_rest_of_line ();
2653 while (--count
>= 0)
2657 p
= frag_more (flen
);
2658 memcpy (p
, temp
, (unsigned int) flen
);
2662 mri_comment_end (stop
, stopc
);
2664 demand_empty_rest_of_line ();
2667 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
2677 stop
= mri_comment_field (&stopc
);
2678 abs_section_offset
= get_absolute_expression ();
2679 subseg_set (absolute_section
, 0);
2681 mri_comment_end (stop
, stopc
);
2682 demand_empty_rest_of_line ();
2691 temp
= get_absolute_expression ();
2692 subseg_set (text_section
, (subsegT
) temp
);
2693 demand_empty_rest_of_line ();
2695 const_flag
&= ~IN_DEFAULT_SECTION
;
2701 demand_empty_rest_of_line ()
2704 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
2706 input_line_pointer
++;
2710 ignore_rest_of_line ();
2712 /* Return having already swallowed end-of-line. */
2713 } /* Return pointing just after end-of-line. */
2716 ignore_rest_of_line () /* For suspect lines: gives warning. */
2718 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2720 if (isprint (*input_line_pointer
))
2721 as_bad ("Rest of line ignored. First ignored character is `%c'.",
2722 *input_line_pointer
);
2724 as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2725 *input_line_pointer
);
2726 while (input_line_pointer
< buffer_limit
2727 && !is_end_of_line
[(unsigned char) *input_line_pointer
])
2729 input_line_pointer
++;
2732 input_line_pointer
++; /* Return pointing just after end-of-line. */
2733 know (is_end_of_line
[(unsigned char) input_line_pointer
[-1]]);
2739 * In: Pointer to a symbol.
2740 * Input_line_pointer->expression.
2742 * Out: Input_line_pointer->just after any whitespace after expression.
2743 * Tried to set symbol to value of expression.
2744 * Will change symbols type, value, and frag;
2747 pseudo_set (symbolP
)
2751 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2753 #endif /* OBJ_AOUT or OBJ_BOUT */
2755 know (symbolP
); /* NULL pointer is logic error. */
2756 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2757 ext
= S_IS_EXTERNAL (symbolP
);
2758 #endif /* OBJ_AOUT or OBJ_BOUT */
2760 (void) expression (&exp
);
2762 if (exp
.X_op
== O_illegal
)
2763 as_bad ("illegal expression; zero assumed");
2764 else if (exp
.X_op
== O_absent
)
2765 as_bad ("missing expression; zero assumed");
2766 else if (exp
.X_op
== O_big
)
2767 as_bad ("%s number invalid; zero assumed",
2768 exp
.X_add_number
> 0 ? "bignum" : "floating point");
2769 else if (exp
.X_op
== O_subtract
2770 && (S_GET_SEGMENT (exp
.X_add_symbol
)
2771 == S_GET_SEGMENT (exp
.X_op_symbol
))
2772 && SEG_NORMAL (S_GET_SEGMENT (exp
.X_add_symbol
))
2773 && exp
.X_add_symbol
->sy_frag
== exp
.X_op_symbol
->sy_frag
)
2775 exp
.X_op
= O_constant
;
2776 exp
.X_add_number
= (S_GET_VALUE (exp
.X_add_symbol
)
2777 - S_GET_VALUE (exp
.X_op_symbol
));
2785 exp
.X_add_number
= 0;
2788 S_SET_SEGMENT (symbolP
, absolute_section
);
2789 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2791 S_SET_EXTERNAL (symbolP
);
2793 S_CLEAR_EXTERNAL (symbolP
);
2794 #endif /* OBJ_AOUT or OBJ_BOUT */
2795 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2796 symbolP
->sy_frag
= &zero_address_frag
;
2800 S_SET_SEGMENT (symbolP
, reg_section
);
2801 S_SET_VALUE (symbolP
, (valueT
) exp
.X_add_number
);
2802 symbolP
->sy_frag
= &zero_address_frag
;
2806 if (S_GET_SEGMENT (exp
.X_add_symbol
) == undefined_section
2807 || exp
.X_add_number
!= 0)
2808 symbolP
->sy_value
= exp
;
2811 symbolS
*s
= exp
.X_add_symbol
;
2813 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (s
));
2814 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2816 S_SET_EXTERNAL (symbolP
);
2818 S_CLEAR_EXTERNAL (symbolP
);
2819 #endif /* OBJ_AOUT or OBJ_BOUT */
2820 S_SET_VALUE (symbolP
,
2821 exp
.X_add_number
+ S_GET_VALUE (s
));
2822 symbolP
->sy_frag
= s
->sy_frag
;
2823 copy_symbol_attributes (symbolP
, s
);
2828 /* The value is some complex expression.
2829 FIXME: Should we set the segment to anything? */
2830 symbolP
->sy_value
= exp
;
2838 * CONStruct more frag of .bytes, or .words etc.
2839 * Should need_pass_2 be 1 then emit no frag(s).
2840 * This understands EXPRESSIONS.
2844 * This has a split personality. We use expression() to read the
2845 * value. We can detect if the value won't fit in a byte or word.
2846 * But we can't detect if expression() discarded significant digits
2847 * in the case of a long. Not worth the crocks required to fix it.
2850 /* Select a parser for cons expressions. */
2852 /* Some targets need to parse the expression in various fancy ways.
2853 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2854 (for example, the HPPA does this). Otherwise, you can define
2855 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2856 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
2857 are defined, which is the normal case, then only simple expressions
2861 parse_mri_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2863 #ifndef TC_PARSE_CONS_EXPRESSION
2864 #ifdef BITFIELD_CONS_EXPRESSIONS
2865 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2867 parse_bitfield_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2869 #ifdef REPEAT_CONS_EXPRESSIONS
2870 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2872 parse_repeat_cons
PARAMS ((expressionS
*exp
, unsigned int nbytes
));
2875 /* If we haven't gotten one yet, just call expression. */
2876 #ifndef TC_PARSE_CONS_EXPRESSION
2877 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2881 /* worker to do .byte etc statements */
2882 /* clobbers input_line_pointer, checks */
2885 cons_worker (nbytes
, rva
)
2886 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
2894 #ifdef md_flush_pending_output
2895 md_flush_pending_output ();
2899 stop
= mri_comment_field (&stopc
);
2901 if (is_it_end_of_statement ())
2904 mri_comment_end (stop
, stopc
);
2905 demand_empty_rest_of_line ();
2913 parse_mri_cons (&exp
, (unsigned int) nbytes
);
2915 TC_PARSE_CONS_EXPRESSION (&exp
, (unsigned int) nbytes
);
2919 if (exp
.X_op
== O_symbol
)
2920 exp
.X_op
= O_symbol_rva
;
2922 as_fatal ("rva without symbol");
2924 emit_expr (&exp
, (unsigned int) nbytes
);
2927 while (*input_line_pointer
++ == ',');
2929 /* In MRI mode, after an odd number of bytes, we must align to an
2930 even word boundary, unless the next instruction is a dc.b, ds.b
2932 if (flag_mri
&& nbytes
== 1 && (c
& 1) != 0)
2933 mri_pending_align
= 1;
2935 input_line_pointer
--; /* Put terminator back into stream. */
2938 mri_comment_end (stop
, stopc
);
2940 demand_empty_rest_of_line ();
2948 cons_worker (size
, 0);
2955 cons_worker (size
, 1);
2959 /* Put the contents of expression EXP into the object file using
2960 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
2963 emit_expr (exp
, nbytes
)
2965 unsigned int nbytes
;
2969 valueT extra_digit
= 0;
2971 /* Don't do anything if we are going to make another pass. */
2977 /* Allow `.word 0' in the absolute section. */
2978 if (now_seg
== absolute_section
)
2980 if (op
!= O_constant
|| exp
->X_add_number
!= 0)
2981 as_bad ("attempt to store value in absolute section");
2982 abs_section_offset
+= nbytes
;
2986 /* Handle a negative bignum. */
2988 && exp
->X_add_number
== 0
2989 && exp
->X_add_symbol
->sy_value
.X_op
== O_big
2990 && exp
->X_add_symbol
->sy_value
.X_add_number
> 0)
2993 unsigned long carry
;
2995 exp
= &exp
->X_add_symbol
->sy_value
;
2997 /* Negate the bignum: one's complement each digit and add 1. */
2999 for (i
= 0; i
< exp
->X_add_number
; i
++)
3003 next
= (((~ (generic_bignum
[i
] & LITTLENUM_MASK
))
3006 generic_bignum
[i
] = next
& LITTLENUM_MASK
;
3007 carry
= next
>> LITTLENUM_NUMBER_OF_BITS
;
3010 /* We can ignore any carry out, because it will be handled by
3011 extra_digit if it is needed. */
3013 extra_digit
= (valueT
) -1;
3017 if (op
== O_absent
|| op
== O_illegal
)
3019 as_warn ("zero assumed for missing expression");
3020 exp
->X_add_number
= 0;
3023 else if (op
== O_big
&& exp
->X_add_number
<= 0)
3025 as_bad ("floating point number invalid; zero assumed");
3026 exp
->X_add_number
= 0;
3029 else if (op
== O_register
)
3031 as_warn ("register value used as expression");
3035 p
= frag_more ((int) nbytes
);
3037 #ifndef WORKING_DOT_WORD
3038 /* If we have the difference of two symbols in a word, save it on
3039 the broken_words list. See the code in write.c. */
3040 if (op
== O_subtract
&& nbytes
== 2)
3042 struct broken_word
*x
;
3044 x
= (struct broken_word
*) xmalloc (sizeof (struct broken_word
));
3045 x
->next_broken_word
= broken_words
;
3048 x
->word_goes_here
= p
;
3050 x
->add
= exp
->X_add_symbol
;
3051 x
->sub
= exp
->X_op_symbol
;
3052 x
->addnum
= exp
->X_add_number
;
3059 /* If we have an integer, but the number of bytes is too large to
3060 pass to md_number_to_chars, handle it as a bignum. */
3061 if (op
== O_constant
&& nbytes
> sizeof (valueT
))
3066 if (! exp
->X_unsigned
&& exp
->X_add_number
< 0)
3067 extra_digit
= (valueT
) -1;
3068 val
= (valueT
) exp
->X_add_number
;
3072 generic_bignum
[gencnt
] = val
& LITTLENUM_MASK
;
3073 val
>>= LITTLENUM_NUMBER_OF_BITS
;
3077 op
= exp
->X_op
= O_big
;
3078 exp
->X_add_number
= gencnt
;
3081 if (op
== O_constant
)
3083 register valueT get
;
3084 register valueT use
;
3085 register valueT mask
;
3086 register valueT unmask
;
3088 /* JF << of >= number of bits in the object is undefined. In
3089 particular SPARC (Sun 4) has problems */
3090 if (nbytes
>= sizeof (valueT
))
3093 mask
= ~(valueT
) 0 << (BITS_PER_CHAR
* nbytes
); /* Don't store these bits. */
3095 unmask
= ~mask
; /* Do store these bits. */
3098 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3099 mask
= ~(unmask
>> 1); /* Includes sign bit now. */
3102 get
= exp
->X_add_number
;
3104 if ((get
& mask
) != 0 && (get
& mask
) != mask
)
3105 { /* Leading bits contain both 0s & 1s. */
3106 as_warn ("Value 0x%lx truncated to 0x%lx.", get
, use
);
3108 /* put bytes in right order. */
3109 md_number_to_chars (p
, use
, (int) nbytes
);
3111 else if (op
== O_big
)
3114 LITTLENUM_TYPE
*nums
;
3116 know (nbytes
% CHARS_PER_LITTLENUM
== 0);
3118 size
= exp
->X_add_number
* CHARS_PER_LITTLENUM
;
3121 as_warn ("Bignum truncated to %d bytes", nbytes
);
3125 if (target_big_endian
)
3127 while (nbytes
> size
)
3129 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3130 nbytes
-= CHARS_PER_LITTLENUM
;
3131 p
+= CHARS_PER_LITTLENUM
;
3134 nums
= generic_bignum
+ size
/ CHARS_PER_LITTLENUM
;
3138 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3139 size
-= CHARS_PER_LITTLENUM
;
3140 p
+= CHARS_PER_LITTLENUM
;
3145 nums
= generic_bignum
;
3148 md_number_to_chars (p
, (valueT
) *nums
, CHARS_PER_LITTLENUM
);
3150 size
-= CHARS_PER_LITTLENUM
;
3151 p
+= CHARS_PER_LITTLENUM
;
3152 nbytes
-= CHARS_PER_LITTLENUM
;
3157 md_number_to_chars (p
, extra_digit
, CHARS_PER_LITTLENUM
);
3158 nbytes
-= CHARS_PER_LITTLENUM
;
3159 p
+= CHARS_PER_LITTLENUM
;
3165 memset (p
, 0, nbytes
);
3167 /* Now we need to generate a fixS to record the symbol value.
3168 This is easy for BFD. For other targets it can be more
3169 complex. For very complex cases (currently, the HPPA and
3170 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3171 want. For simpler cases, you can define TC_CONS_RELOC to be
3172 the name of the reloc code that should be stored in the fixS.
3173 If neither is defined, the code uses NO_RELOC if it is
3174 defined, and otherwise uses 0. */
3176 #ifdef BFD_ASSEMBLER
3177 #ifdef TC_CONS_FIX_NEW
3178 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3180 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3181 /* @@ Should look at CPU word size. */
3182 nbytes
== 2 ? BFD_RELOC_16
3183 : nbytes
== 8 ? BFD_RELOC_64
3187 #ifdef TC_CONS_FIX_NEW
3188 TC_CONS_FIX_NEW (frag_now
, p
- frag_now
->fr_literal
, nbytes
, exp
);
3190 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3191 it is defined, otherwise use NO_RELOC if it is defined,
3193 #ifndef TC_CONS_RELOC
3195 #define TC_CONS_RELOC NO_RELOC
3197 #define TC_CONS_RELOC 0
3200 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, (int) nbytes
, exp
, 0,
3202 #endif /* TC_CONS_FIX_NEW */
3203 #endif /* BFD_ASSEMBLER */
3207 #ifdef BITFIELD_CONS_EXPRESSIONS
3209 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3210 w:x,y:z, where w and y are bitwidths and x and y are values. They
3211 then pack them all together. We do a little better in that we allow
3212 them in words, longs, etc. and we'll pack them in target byte order
3215 The rules are: pack least significat bit first, if a field doesn't
3216 entirely fit, put it in the next unit. Overflowing the bitfield is
3217 explicitly *not* even a warning. The bitwidth should be considered
3220 To use this function the tc-XXX.h file should define
3221 BITFIELD_CONS_EXPRESSIONS. */
3224 parse_bitfield_cons (exp
, nbytes
)
3226 unsigned int nbytes
;
3228 unsigned int bits_available
= BITS_PER_CHAR
* nbytes
;
3229 char *hold
= input_line_pointer
;
3231 (void) expression (exp
);
3233 if (*input_line_pointer
== ':')
3239 unsigned long width
;
3241 if (*input_line_pointer
!= ':')
3243 input_line_pointer
= hold
;
3245 } /* next piece is not a bitfield */
3247 /* In the general case, we can't allow
3248 full expressions with symbol
3249 differences and such. The relocation
3250 entries for symbols not defined in this
3251 assembly would require arbitrary field
3252 widths, positions, and masks which most
3253 of our current object formats don't
3256 In the specific case where a symbol
3257 *is* defined in this assembly, we
3258 *could* build fixups and track it, but
3259 this could lead to confusion for the
3260 backends. I'm lazy. I'll take any
3261 SEG_ABSOLUTE. I think that means that
3262 you can use a previous .set or
3263 .equ type symbol. xoxorich. */
3265 if (exp
->X_op
== O_absent
)
3267 as_warn ("using a bit field width of zero");
3268 exp
->X_add_number
= 0;
3269 exp
->X_op
= O_constant
;
3270 } /* implied zero width bitfield */
3272 if (exp
->X_op
!= O_constant
)
3274 *input_line_pointer
= '\0';
3275 as_bad ("field width \"%s\" too complex for a bitfield", hold
);
3276 *input_line_pointer
= ':';
3277 demand_empty_rest_of_line ();
3281 if ((width
= exp
->X_add_number
) > (BITS_PER_CHAR
* nbytes
))
3283 as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3284 width
, nbytes
, (BITS_PER_CHAR
* nbytes
));
3285 width
= BITS_PER_CHAR
* nbytes
;
3288 if (width
> bits_available
)
3290 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3291 input_line_pointer
= hold
;
3292 exp
->X_add_number
= value
;
3296 hold
= ++input_line_pointer
; /* skip ':' */
3298 (void) expression (exp
);
3299 if (exp
->X_op
!= O_constant
)
3301 char cache
= *input_line_pointer
;
3303 *input_line_pointer
= '\0';
3304 as_bad ("field value \"%s\" too complex for a bitfield", hold
);
3305 *input_line_pointer
= cache
;
3306 demand_empty_rest_of_line ();
3310 value
|= ((~(-1 << width
) & exp
->X_add_number
)
3311 << ((BITS_PER_CHAR
* nbytes
) - bits_available
));
3313 if ((bits_available
-= width
) == 0
3314 || is_it_end_of_statement ()
3315 || *input_line_pointer
!= ',')
3318 } /* all the bitfields we're gonna get */
3320 hold
= ++input_line_pointer
;
3321 (void) expression (exp
);
3322 } /* forever loop */
3324 exp
->X_add_number
= value
;
3325 exp
->X_op
= O_constant
;
3326 exp
->X_unsigned
= 1;
3327 } /* if looks like a bitfield */
3328 } /* parse_bitfield_cons() */
3330 #endif /* BITFIELD_CONS_EXPRESSIONS */
3332 /* Handle an MRI style string expression. */
3335 parse_mri_cons (exp
, nbytes
)
3337 unsigned int nbytes
;
3339 if (*input_line_pointer
!= '\''
3340 && (input_line_pointer
[1] != '\''
3341 || (*input_line_pointer
!= 'A'
3342 && *input_line_pointer
!= 'E')))
3343 TC_PARSE_CONS_EXPRESSION (exp
, nbytes
);
3347 unsigned int result
= 0;
3349 /* An MRI style string. Cut into as many bytes as will fit into
3350 a nbyte chunk, left justify if necessary, and separate with
3351 commas so we can try again later. */
3352 if (*input_line_pointer
== 'A')
3353 ++input_line_pointer
;
3354 else if (*input_line_pointer
== 'E')
3356 as_bad ("EBCDIC constants are not supported");
3357 ++input_line_pointer
;
3360 input_line_pointer
++;
3361 for (scan
= 0; scan
< nbytes
; scan
++)
3363 if (*input_line_pointer
== '\'')
3365 if (input_line_pointer
[1] == '\'')
3367 input_line_pointer
++;
3372 result
= (result
<< 8) | (*input_line_pointer
++);
3376 while (scan
< nbytes
)
3381 /* Create correct expression */
3382 exp
->X_op
= O_constant
;
3383 exp
->X_add_number
= result
;
3384 /* Fake it so that we can read the next char too */
3385 if (input_line_pointer
[0] != '\'' ||
3386 (input_line_pointer
[0] == '\'' && input_line_pointer
[1] == '\''))
3388 input_line_pointer
-= 2;
3389 input_line_pointer
[0] = ',';
3390 input_line_pointer
[1] = '\'';
3393 input_line_pointer
++;
3397 #ifdef REPEAT_CONS_EXPRESSIONS
3399 /* Parse a repeat expression for cons. This is used by the MIPS
3400 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3401 object file COUNT times.
3403 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3406 parse_repeat_cons (exp
, nbytes
)
3408 unsigned int nbytes
;
3415 if (*input_line_pointer
!= ':')
3417 /* No repeat count. */
3421 ++input_line_pointer
;
3422 expression (&count
);
3423 if (count
.X_op
!= O_constant
3424 || count
.X_add_number
<= 0)
3426 as_warn ("Unresolvable or nonpositive repeat count; using 1");
3430 /* The cons function is going to output this expression once. So we
3431 output it count - 1 times. */
3432 for (i
= count
.X_add_number
- 1; i
> 0; i
--)
3433 emit_expr (exp
, nbytes
);
3436 #endif /* REPEAT_CONS_EXPRESSIONS */
3438 /* Parse a floating point number represented as a hex constant. This
3439 permits users to specify the exact bits they want in the floating
3443 hex_float (float_type
, bytes
)
3477 as_bad ("Unknown floating type type '%c'", float_type
);
3481 /* It would be nice if we could go through expression to parse the
3482 hex constant, but if we get a bignum it's a pain to sort it into
3483 the buffer correctly. */
3485 while (hex_p (*input_line_pointer
) || *input_line_pointer
== '_')
3489 /* The MRI assembler accepts arbitrary underscores strewn about
3490 through the hex constant, so we ignore them as well. */
3491 if (*input_line_pointer
== '_')
3493 ++input_line_pointer
;
3499 as_warn ("Floating point constant too large");
3502 d
= hex_value (*input_line_pointer
) << 4;
3503 ++input_line_pointer
;
3504 while (*input_line_pointer
== '_')
3505 ++input_line_pointer
;
3506 if (hex_p (*input_line_pointer
))
3508 d
+= hex_value (*input_line_pointer
);
3509 ++input_line_pointer
;
3511 if (target_big_endian
)
3514 bytes
[length
- i
- 1] = d
;
3520 if (target_big_endian
)
3521 memset (bytes
+ i
, 0, length
- i
);
3523 memset (bytes
, 0, length
- i
);
3532 * CONStruct some more frag chars of .floats .ffloats etc.
3533 * Makes 0 or more new frags.
3534 * If need_pass_2 == 1, no frags are emitted.
3535 * This understands only floating literals, not expressions. Sorry.
3537 * A floating constant is defined by atof_generic(), except it is preceded
3538 * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3539 * reading, I decided to be incompatible. This always tries to give you
3540 * rounded bits to the precision of the pseudo-op. Former AS did premature
3541 * truncatation, restored noisy bits instead of trailing 0s AND gave you
3542 * a choice of 2 flavours of noise according to which of 2 floating-point
3543 * scanners you directed AS to use.
3545 * In: input_line_pointer->whitespace before, or '0' of flonum.
3550 float_cons (float_type
)
3551 /* Clobbers input_line-pointer, checks end-of-line. */
3552 register int float_type
; /* 'f':.ffloat ... 'F':.float ... */
3555 int length
; /* Number of chars in an object. */
3556 register char *err
; /* Error from scanning floating literal. */
3557 char temp
[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
];
3559 if (is_it_end_of_statement ())
3561 demand_empty_rest_of_line ();
3567 /* input_line_pointer->1st char of a flonum (we hope!). */
3570 /* Skip any 0{letter} that may be present. Don't even check if the
3571 * letter is legal. Someone may invent a "z" format and this routine
3572 * has no use for such information. Lusers beware: you get
3573 * diagnostics if your input is ill-conditioned.
3575 if (input_line_pointer
[0] == '0' && isalpha (input_line_pointer
[1]))
3576 input_line_pointer
+= 2;
3578 /* Accept :xxxx, where the x's are hex digits, for a floating
3579 point with the exact digits specified. */
3580 if (input_line_pointer
[0] == ':')
3582 ++input_line_pointer
;
3583 length
= hex_float (float_type
, temp
);
3586 ignore_rest_of_line ();
3592 err
= md_atof (float_type
, temp
, &length
);
3593 know (length
<= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT
);
3597 as_bad ("Bad floating literal: %s", err
);
3598 ignore_rest_of_line ();
3609 #ifdef REPEAT_CONS_EXPRESSIONS
3610 if (*input_line_pointer
== ':')
3612 expressionS count_exp
;
3614 ++input_line_pointer
;
3615 expression (&count_exp
);
3616 if (count_exp
.X_op
!= O_constant
3617 || count_exp
.X_add_number
<= 0)
3619 as_warn ("unresolvable or nonpositive repeat count; using 1");
3622 count
= count_exp
.X_add_number
;
3626 while (--count
>= 0)
3628 p
= frag_more (length
);
3629 memcpy (p
, temp
, (unsigned int) length
);
3634 while (*input_line_pointer
++ == ',');
3636 --input_line_pointer
; /* Put terminator back into stream. */
3637 demand_empty_rest_of_line ();
3638 } /* float_cons() */
3643 * We read 0 or more ',' seperated, double-quoted strings.
3645 * Caller should have checked need_pass_2 is FALSE because we don't check it.
3650 stringer (append_zero
) /* Worker to do .ascii etc statements. */
3651 /* Checks end-of-line. */
3652 register int append_zero
; /* 0: don't append '\0', else 1 */
3654 register unsigned int c
;
3656 #ifdef md_flush_pending_output
3657 md_flush_pending_output ();
3661 * The following awkward logic is to parse ZERO or more strings,
3662 * comma seperated. Recall a string expression includes spaces
3663 * before the opening '\"' and spaces after the closing '\"'.
3664 * We fake a leading ',' if there is (supposed to be)
3665 * a 1st, expression. We keep demanding expressions for each
3668 if (is_it_end_of_statement ())
3670 c
= 0; /* Skip loop. */
3671 ++input_line_pointer
; /* Compensate for end of loop. */
3675 c
= ','; /* Do loop. */
3677 while (c
== ',' || c
== '<' || c
== '"')
3680 switch (*input_line_pointer
)
3683 ++input_line_pointer
; /*->1st char of string. */
3684 while (is_a_char (c
= next_char_of_string ()))
3686 FRAG_APPEND_1_CHAR (c
);
3690 FRAG_APPEND_1_CHAR (0);
3692 know (input_line_pointer
[-1] == '\"');
3695 input_line_pointer
++;
3696 c
= get_single_number ();
3697 FRAG_APPEND_1_CHAR (c
);
3698 if (*input_line_pointer
!= '>')
3700 as_bad ("Expected <nn>");
3702 input_line_pointer
++;
3705 input_line_pointer
++;
3709 c
= *input_line_pointer
;
3712 demand_empty_rest_of_line ();
3715 /* FIXME-SOMEDAY: I had trouble here on characters with the
3716 high bits set. We'll probably also have trouble with
3717 multibyte chars, wide chars, etc. Also be careful about
3718 returning values bigger than 1 byte. xoxorich. */
3721 next_char_of_string ()
3723 register unsigned int c
;
3725 c
= *input_line_pointer
++ & CHAR_MASK
;
3732 #ifndef NO_STRING_ESCAPES
3734 switch (c
= *input_line_pointer
++)
3762 break; /* As itself. */
3778 for (i
= 0, number
= 0; isdigit (c
) && i
< 3; c
= *input_line_pointer
++, i
++)
3780 number
= number
* 8 + c
- '0';
3784 --input_line_pointer
;
3793 c
= *input_line_pointer
++;
3794 while (isxdigit (c
))
3797 number
= number
* 16 + c
- '0';
3798 else if (isupper (c
))
3799 number
= number
* 16 + c
- 'A' + 10;
3801 number
= number
* 16 + c
- 'a' + 10;
3802 c
= *input_line_pointer
++;
3805 --input_line_pointer
;
3810 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3811 as_warn ("Unterminated string: Newline inserted.");
3817 #ifdef ONLY_STANDARD_ESCAPES
3818 as_bad ("Bad escaped character in string, '?' assumed");
3820 #endif /* ONLY_STANDARD_ESCAPES */
3823 } /* switch on escaped char */
3825 #endif /* ! defined (NO_STRING_ESCAPES) */
3829 } /* switch on char */
3831 } /* next_char_of_string() */
3834 get_segmented_expression (expP
)
3835 register expressionS
*expP
;
3837 register segT retval
;
3839 retval
= expression (expP
);
3840 if (expP
->X_op
== O_illegal
3841 || expP
->X_op
== O_absent
3842 || expP
->X_op
== O_big
)
3844 as_bad ("expected address expression; zero assumed");
3845 expP
->X_op
= O_constant
;
3846 expP
->X_add_number
= 0;
3847 retval
= absolute_section
;
3853 get_known_segmented_expression (expP
)
3854 register expressionS
*expP
;
3856 register segT retval
;
3858 if ((retval
= get_segmented_expression (expP
)) == undefined_section
)
3860 /* There is no easy way to extract the undefined symbol from the
3862 if (expP
->X_add_symbol
!= NULL
3863 && S_GET_SEGMENT (expP
->X_add_symbol
) != expr_section
)
3864 as_warn ("symbol \"%s\" undefined; zero assumed",
3865 S_GET_NAME (expP
->X_add_symbol
));
3867 as_warn ("some symbol undefined; zero assumed");
3868 retval
= absolute_section
;
3869 expP
->X_op
= O_constant
;
3870 expP
->X_add_number
= 0;
3872 know (retval
== absolute_section
|| SEG_NORMAL (retval
));
3874 } /* get_known_segmented_expression() */
3877 get_absolute_expression ()
3882 if (exp
.X_op
!= O_constant
)
3884 if (exp
.X_op
!= O_absent
)
3885 as_bad ("bad or irreducible absolute expression; zero assumed");
3886 exp
.X_add_number
= 0;
3888 return exp
.X_add_number
;
3891 char /* return terminator */
3892 get_absolute_expression_and_terminator (val_pointer
)
3893 long *val_pointer
; /* return value of expression */
3895 /* FIXME: val_pointer should probably be offsetT *. */
3896 *val_pointer
= (long) get_absolute_expression ();
3897 return (*input_line_pointer
++);
3901 * demand_copy_C_string()
3903 * Like demand_copy_string, but return NULL if the string contains any '\0's.
3904 * Give a warning if that happens.
3907 demand_copy_C_string (len_pointer
)
3912 if ((s
= demand_copy_string (len_pointer
)) != 0)
3916 for (len
= *len_pointer
; len
> 0; len
--)
3923 as_bad ("This string may not contain \'\\0\'");
3931 * demand_copy_string()
3933 * Demand string, but return a safe (=private) copy of the string.
3934 * Return NULL if we can't read a string here.
3937 demand_copy_string (lenP
)
3940 register unsigned int c
;
3946 if (*input_line_pointer
== '\"')
3948 input_line_pointer
++; /* Skip opening quote. */
3950 while (is_a_char (c
= next_char_of_string ()))
3952 obstack_1grow (¬es
, c
);
3955 /* JF this next line is so demand_copy_C_string will return a
3956 null terminated string. */
3957 obstack_1grow (¬es
, '\0');
3958 retval
= obstack_finish (¬es
);
3962 as_warn ("Missing string");
3964 ignore_rest_of_line ();
3968 } /* demand_copy_string() */
3971 * is_it_end_of_statement()
3973 * In: Input_line_pointer->next character.
3975 * Do: Skip input_line_pointer over all whitespace.
3977 * Out: 1 if input_line_pointer->end-of-line.
3980 is_it_end_of_statement ()
3983 return (is_end_of_line
[(unsigned char) *input_line_pointer
]);
3984 } /* is_it_end_of_statement() */
3990 register symbolS
*symbolP
; /* symbol we are working with */
3994 input_line_pointer
++;
3995 if (*input_line_pointer
== '=')
3996 input_line_pointer
++;
3998 while (*input_line_pointer
== ' ' || *input_line_pointer
== '\t')
3999 input_line_pointer
++;
4002 stop
= mri_comment_field (&stopc
);
4004 if (sym_name
[0] == '.' && sym_name
[1] == '\0')
4006 /* Turn '. = mumble' into a .org mumble */
4007 register segT segment
;
4010 segment
= get_known_segmented_expression (&exp
);
4012 do_org (segment
, &exp
, 0);
4016 symbolP
= symbol_find_or_make (sym_name
);
4017 pseudo_set (symbolP
);
4021 mri_comment_end (stop
, stopc
);
4024 /* .include -- include a file at this point. */
4037 if (! flag_m68k_mri
)
4038 filename
= demand_copy_string (&i
);
4043 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
4044 && *input_line_pointer
!= ' '
4045 && *input_line_pointer
!= '\t')
4047 obstack_1grow (¬es
, *input_line_pointer
);
4048 ++input_line_pointer
;
4051 obstack_1grow (¬es
, '\0');
4052 filename
= obstack_finish (¬es
);
4053 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
4054 ++input_line_pointer
;
4056 demand_empty_rest_of_line ();
4057 path
= xmalloc ((unsigned long) i
+ include_dir_maxlen
+ 5 /* slop */ );
4058 for (i
= 0; i
< include_dir_count
; i
++)
4060 strcpy (path
, include_dirs
[i
]);
4062 strcat (path
, filename
);
4063 if (0 != (try = fopen (path
, "r")))
4072 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
4073 newbuf
= input_scrub_include_file (path
, input_line_pointer
);
4074 buffer_limit
= input_scrub_next_buffer (&input_line_pointer
);
4078 add_include_dir (path
)
4083 if (include_dir_count
== 0)
4085 include_dirs
= (char **) xmalloc (2 * sizeof (*include_dirs
));
4086 include_dirs
[0] = "."; /* Current dir */
4087 include_dir_count
= 2;
4091 include_dir_count
++;
4092 include_dirs
= (char **) realloc (include_dirs
,
4093 include_dir_count
* sizeof (*include_dirs
));
4096 include_dirs
[include_dir_count
- 1] = path
; /* New one */
4099 if (i
> include_dir_maxlen
)
4100 include_dir_maxlen
= i
;
4101 } /* add_include_dir() */
4107 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
4109 ++input_line_pointer
;
4111 ++input_line_pointer
;
4116 read_print_statistics (file
)
4119 hash_print_statistics (file
, "pseudo-op table", po_hash
);