daily update
[binutils.git] / gas / read.c
blobad9363a60449f2f09756fefba889344df8b65a2a
1 /* read.c - read a source file -
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
24 But then, GNU isn't spozed to run on your machine anyway.
25 (RMS is so shortsighted sometimes.) */
26 #define MASK_CHAR ((int)(unsigned char) -1)
28 /* This is the largest known floating point format (for now). It will
29 grow when we do 4361 style flonums. */
30 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
32 /* Routines that read assembler source text to build spaghetti in memory.
33 Another group of these functions is in the expr.c module. */
35 #include "as.h"
36 #include "safe-ctype.h"
37 #include "subsegs.h"
38 #include "sb.h"
39 #include "macro.h"
40 #include "obstack.h"
41 #include "ecoff.h"
42 #include "dw2gencfi.h"
44 #ifndef TC_START_LABEL
45 #define TC_START_LABEL(x,y,z) (x == ':')
46 #endif
48 /* Set by the object-format or the target. */
49 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
50 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
51 do \
52 { \
53 if ((SIZE) >= 8) \
54 (P2VAR) = 3; \
55 else if ((SIZE) >= 4) \
56 (P2VAR) = 2; \
57 else if ((SIZE) >= 2) \
58 (P2VAR) = 1; \
59 else \
60 (P2VAR) = 0; \
61 } \
62 while (0)
63 #endif
65 char *input_line_pointer; /*->next char of source file to parse. */
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!)! */
70 die horribly;
71 #endif
73 #ifndef LEX_AT
74 #define LEX_AT 0
75 #endif
77 #ifndef LEX_BR
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
79 #define LEX_BR 0
80 #endif
82 #ifndef LEX_PCT
83 /* The Delta 68k assembler permits % inside label names. */
84 #define LEX_PCT 0
85 #endif
87 #ifndef LEX_QM
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
89 #define LEX_QM 0
90 #endif
92 #ifndef LEX_HASH
93 /* The IA-64 assembler uses # as a suffix designating a symbol. We include
94 it in the symbol and strip it out in tc_canonicalize_symbol_name. */
95 #define LEX_HASH 0
96 #endif
98 #ifndef LEX_DOLLAR
99 #define LEX_DOLLAR 3
100 #endif
102 #ifndef LEX_TILDE
103 /* The Delta 68k assembler permits ~ at start of label names. */
104 #define LEX_TILDE 0
105 #endif
107 /* Used by is_... macros. our ctype[]. */
108 char lex_type[256] = {
109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */
110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */
111 0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM, /* 0123456789:;<=>? */
113 LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */
114 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
115 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */
116 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~. */
117 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
118 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
119 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
120 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
122 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
123 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
127 /* In: a character.
128 Out: 1 if this character ends a line.
129 2 if this character is a line separator. */
130 char is_end_of_line[256] = {
131 #ifdef CR_EOL
132 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, /* @abcdefghijklmno */
133 #else
134 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* @abcdefghijklmno */
135 #endif
136 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* _!"#$%&'()*+,-./ */
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */
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, /* */
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 /* */
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string[128];
155 #endif
157 /* Functions private to this file. */
159 static char *buffer; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit; /*->1 + last char in buffer. */
162 /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
163 in the tc-<CPU>.h file. See the "Porting GAS" section of the
164 internals manual. */
165 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
167 /* Variables for handling include file directory table. */
169 /* Table of pointers to directories to search for .include's. */
170 char **include_dirs;
172 /* How many are in the table. */
173 int include_dir_count;
175 /* Length of longest in table. */
176 int include_dir_maxlen = 1;
178 #ifndef WORKING_DOT_WORD
179 struct broken_word *broken_words;
180 int new_broken_words;
181 #endif
183 /* The current offset into the absolute section. We don't try to
184 build frags in the absolute section, since no data can be stored
185 there. We just keep track of the current offset. */
186 addressT abs_section_offset;
188 /* If this line had an MRI style label, it is stored in this variable.
189 This is used by some of the MRI pseudo-ops. */
190 symbolS *line_label;
192 /* This global variable is used to support MRI common sections. We
193 translate such sections into a common symbol. This variable is
194 non-NULL when we are in an MRI common section. */
195 symbolS *mri_common_symbol;
197 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
198 need to align to an even byte boundary unless the next pseudo-op is
199 dc.b, ds.b, or dcb.b. This variable is set to 1 if an alignment
200 may be needed. */
201 static int mri_pending_align;
203 #ifndef NO_LISTING
204 #ifdef OBJ_ELF
205 /* This variable is set to be non-zero if the next string we see might
206 be the name of the source file in DWARF debugging information. See
207 the comment in emit_expr for the format we look for. */
208 static int dwarf_file_string;
209 #endif
210 #endif
212 static void do_s_func (int end_p, const char *default_prefix);
213 static void do_align (int, char *, int, int);
214 static void s_align (int, int);
215 static void s_altmacro (int);
216 static void s_bad_end (int);
217 #ifdef OBJ_ELF
218 static void s_gnu_attribute (int);
219 #endif
220 static void s_reloc (int);
221 static int hex_float (int, char *);
222 static segT get_known_segmented_expression (expressionS * expP);
223 static void pobegin (void);
224 static int get_non_macro_line_sb (sb *);
225 static void generate_file_debug (void);
226 static char *_find_end_of_line (char *, int, int, int);
228 void
229 read_begin (void)
231 const char *p;
233 pobegin ();
234 obj_read_begin_hook ();
236 /* Something close -- but not too close -- to a multiple of 1024.
237 The debugging malloc I'm using has 24 bytes of overhead. */
238 obstack_begin (&notes, chunksize);
239 obstack_begin (&cond_obstack, chunksize);
241 /* Use machine dependent syntax. */
242 for (p = line_separator_chars; *p; p++)
243 is_end_of_line[(unsigned char) *p] = 2;
244 /* Use more. FIXME-SOMEDAY. */
246 if (flag_mri)
247 lex_type['?'] = 3;
250 #ifndef TC_ADDRESS_BYTES
251 #define TC_ADDRESS_BYTES address_bytes
253 static inline int
254 address_bytes (void)
256 /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
257 contain an address. */
258 int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
259 n |= n >> 1;
260 n |= n >> 2;
261 n += 1;
262 return n;
264 #endif
266 /* Set up pseudo-op tables. */
268 static struct hash_control *po_hash;
270 static const pseudo_typeS potable[] = {
271 {"abort", s_abort, 0},
272 {"align", s_align_ptwo, 0},
273 {"altmacro", s_altmacro, 1},
274 {"ascii", stringer, 8+0},
275 {"asciz", stringer, 8+1},
276 {"balign", s_align_bytes, 0},
277 {"balignw", s_align_bytes, -2},
278 {"balignl", s_align_bytes, -4},
279 /* block */
280 {"byte", cons, 1},
281 {"comm", s_comm, 0},
282 {"common", s_mri_common, 0},
283 {"common.s", s_mri_common, 1},
284 {"data", s_data, 0},
285 {"dc", cons, 2},
286 #ifdef TC_ADDRESS_BYTES
287 {"dc.a", cons, 0},
288 #endif
289 {"dc.b", cons, 1},
290 {"dc.d", float_cons, 'd'},
291 {"dc.l", cons, 4},
292 {"dc.s", float_cons, 'f'},
293 {"dc.w", cons, 2},
294 {"dc.x", float_cons, 'x'},
295 {"dcb", s_space, 2},
296 {"dcb.b", s_space, 1},
297 {"dcb.d", s_float_space, 'd'},
298 {"dcb.l", s_space, 4},
299 {"dcb.s", s_float_space, 'f'},
300 {"dcb.w", s_space, 2},
301 {"dcb.x", s_float_space, 'x'},
302 {"ds", s_space, 2},
303 {"ds.b", s_space, 1},
304 {"ds.d", s_space, 8},
305 {"ds.l", s_space, 4},
306 {"ds.p", s_space, 12},
307 {"ds.s", s_space, 4},
308 {"ds.w", s_space, 2},
309 {"ds.x", s_space, 12},
310 {"debug", s_ignore, 0},
311 #ifdef S_SET_DESC
312 {"desc", s_desc, 0},
313 #endif
314 /* dim */
315 {"double", float_cons, 'd'},
316 /* dsect */
317 {"eject", listing_eject, 0}, /* Formfeed listing. */
318 {"else", s_else, 0},
319 {"elsec", s_else, 0},
320 {"elseif", s_elseif, (int) O_ne},
321 {"end", s_end, 0},
322 {"endc", s_endif, 0},
323 {"endfunc", s_func, 1},
324 {"endif", s_endif, 0},
325 {"endm", s_bad_end, 0},
326 {"endr", s_bad_end, 1},
327 /* endef */
328 {"equ", s_set, 0},
329 {"equiv", s_set, 1},
330 {"eqv", s_set, -1},
331 {"err", s_err, 0},
332 {"error", s_errwarn, 1},
333 {"exitm", s_mexit, 0},
334 /* extend */
335 {"extern", s_ignore, 0}, /* We treat all undef as ext. */
336 {"appfile", s_app_file, 1},
337 {"appline", s_app_line, 1},
338 {"fail", s_fail, 0},
339 {"file", s_app_file, 0},
340 {"fill", s_fill, 0},
341 {"float", float_cons, 'f'},
342 {"format", s_ignore, 0},
343 {"func", s_func, 0},
344 {"global", s_globl, 0},
345 {"globl", s_globl, 0},
346 #ifdef OBJ_ELF
347 {"gnu_attribute", s_gnu_attribute, 0},
348 #endif
349 {"hword", cons, 2},
350 {"if", s_if, (int) O_ne},
351 {"ifb", s_ifb, 1},
352 {"ifc", s_ifc, 0},
353 {"ifdef", s_ifdef, 0},
354 {"ifeq", s_if, (int) O_eq},
355 {"ifeqs", s_ifeqs, 0},
356 {"ifge", s_if, (int) O_ge},
357 {"ifgt", s_if, (int) O_gt},
358 {"ifle", s_if, (int) O_le},
359 {"iflt", s_if, (int) O_lt},
360 {"ifnb", s_ifb, 0},
361 {"ifnc", s_ifc, 1},
362 {"ifndef", s_ifdef, 1},
363 {"ifne", s_if, (int) O_ne},
364 {"ifnes", s_ifeqs, 1},
365 {"ifnotdef", s_ifdef, 1},
366 {"incbin", s_incbin, 0},
367 {"include", s_include, 0},
368 {"int", cons, 4},
369 {"irp", s_irp, 0},
370 {"irep", s_irp, 0},
371 {"irpc", s_irp, 1},
372 {"irepc", s_irp, 1},
373 {"lcomm", s_lcomm, 0},
374 {"lflags", s_ignore, 0}, /* Listing flags. */
375 {"linefile", s_app_line, 0},
376 {"linkonce", s_linkonce, 0},
377 {"list", listing_list, 1}, /* Turn listing on. */
378 {"llen", listing_psize, 1},
379 {"long", cons, 4},
380 {"lsym", s_lsym, 0},
381 {"macro", s_macro, 0},
382 {"mexit", s_mexit, 0},
383 {"mri", s_mri, 0},
384 {".mri", s_mri, 0}, /* Special case so .mri works in MRI mode. */
385 {"name", s_ignore, 0},
386 {"noaltmacro", s_altmacro, 0},
387 {"noformat", s_ignore, 0},
388 {"nolist", listing_list, 0}, /* Turn listing off. */
389 {"nopage", listing_nopage, 0},
390 {"octa", cons, 16},
391 {"offset", s_struct, 0},
392 {"org", s_org, 0},
393 {"p2align", s_align_ptwo, 0},
394 {"p2alignw", s_align_ptwo, -2},
395 {"p2alignl", s_align_ptwo, -4},
396 {"page", listing_eject, 0},
397 {"plen", listing_psize, 0},
398 {"print", s_print, 0},
399 {"psize", listing_psize, 0}, /* Set paper size. */
400 {"purgem", s_purgem, 0},
401 {"quad", cons, 8},
402 {"reloc", s_reloc, 0},
403 {"rep", s_rept, 0},
404 {"rept", s_rept, 0},
405 {"rva", s_rva, 4},
406 {"sbttl", listing_title, 1}, /* Subtitle of listing. */
407 /* scl */
408 /* sect */
409 {"set", s_set, 0},
410 {"short", cons, 2},
411 {"single", float_cons, 'f'},
412 /* size */
413 {"space", s_space, 0},
414 {"skip", s_space, 0},
415 {"sleb128", s_leb128, 1},
416 {"spc", s_ignore, 0},
417 {"stabd", s_stab, 'd'},
418 {"stabn", s_stab, 'n'},
419 {"stabs", s_stab, 's'},
420 {"string", stringer, 8+1},
421 {"string8", stringer, 8+1},
422 {"string16", stringer, 16+1},
423 {"string32", stringer, 32+1},
424 {"string64", stringer, 64+1},
425 {"struct", s_struct, 0},
426 /* tag */
427 {"text", s_text, 0},
429 /* This is for gcc to use. It's only just been added (2/94), so gcc
430 won't be able to use it for a while -- probably a year or more.
431 But once this has been released, check with gcc maintainers
432 before deleting it or even changing the spelling. */
433 {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
434 /* If we're folding case -- done for some targets, not necessarily
435 all -- the above string in an input file will be converted to
436 this one. Match it either way... */
437 {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
439 {"title", listing_title, 0}, /* Listing title. */
440 {"ttl", listing_title, 0},
441 /* type */
442 {"uleb128", s_leb128, 0},
443 /* use */
444 /* val */
445 {"xcom", s_comm, 0},
446 {"xdef", s_globl, 0},
447 {"xref", s_ignore, 0},
448 {"xstabs", s_xstab, 's'},
449 {"warning", s_errwarn, 0},
450 {"weakref", s_weakref, 0},
451 {"word", cons, 2},
452 {"zero", s_space, 0},
453 {NULL, NULL, 0} /* End sentinel. */
456 static offsetT
457 get_absolute_expr (expressionS *exp)
459 expression_and_evaluate (exp);
460 if (exp->X_op != O_constant)
462 if (exp->X_op != O_absent)
463 as_bad (_("bad or irreducible absolute expression"));
464 exp->X_add_number = 0;
466 return exp->X_add_number;
469 offsetT
470 get_absolute_expression (void)
472 expressionS exp;
474 return get_absolute_expr (&exp);
477 static int pop_override_ok = 0;
478 static const char *pop_table_name;
480 void
481 pop_insert (const pseudo_typeS *table)
483 const char *errtxt;
484 const pseudo_typeS *pop;
485 for (pop = table; pop->poc_name; pop++)
487 errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
488 if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
489 as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
490 errtxt);
494 #ifndef md_pop_insert
495 #define md_pop_insert() pop_insert(md_pseudo_table)
496 #endif
498 #ifndef obj_pop_insert
499 #define obj_pop_insert() pop_insert(obj_pseudo_table)
500 #endif
502 #ifndef cfi_pop_insert
503 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
504 #endif
506 static void
507 pobegin (void)
509 po_hash = hash_new ();
511 /* Do the target-specific pseudo ops. */
512 pop_table_name = "md";
513 md_pop_insert ();
515 /* Now object specific. Skip any that were in the target table. */
516 pop_table_name = "obj";
517 pop_override_ok = 1;
518 obj_pop_insert ();
520 /* Now portable ones. Skip any that we've seen already. */
521 pop_table_name = "standard";
522 pop_insert (potable);
524 #ifdef TARGET_USE_CFIPOP
525 pop_table_name = "cfi";
526 pop_override_ok = 1;
527 cfi_pop_insert ();
528 #endif
531 #define HANDLE_CONDITIONAL_ASSEMBLY() \
532 if (ignore_input ()) \
534 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
535 input_line_pointer = (input_line_pointer <= buffer_limit \
536 && eol >= buffer_limit) \
537 ? buffer_limit \
538 : eol + 1; \
539 continue; \
542 /* This function is used when scrubbing the characters between #APP
543 and #NO_APP. */
545 static char *scrub_string;
546 static char *scrub_string_end;
548 static int
549 scrub_from_string (char *buf, int buflen)
551 int copy;
553 copy = scrub_string_end - scrub_string;
554 if (copy > buflen)
555 copy = buflen;
556 memcpy (buf, scrub_string, copy);
557 scrub_string += copy;
558 return copy;
561 /* Helper function of read_a_source_file, which tries to expand a macro. */
562 static int
563 try_macro (char term, const char *line)
565 sb out;
566 const char *err;
567 macro_entry *macro;
569 if (check_macro (line, &out, &err, &macro))
571 if (err != NULL)
572 as_bad ("%s", err);
573 *input_line_pointer++ = term;
574 input_scrub_include_sb (&out,
575 input_line_pointer, 1);
576 sb_kill (&out);
577 buffer_limit =
578 input_scrub_next_buffer (&input_line_pointer);
579 #ifdef md_macro_info
580 md_macro_info (macro);
581 #endif
582 return 1;
584 return 0;
587 /* We read the file, putting things into a web that represents what we
588 have been reading. */
589 void
590 read_a_source_file (char *name)
592 char c;
593 char *s; /* String of symbol, '\0' appended. */
594 int temp;
595 pseudo_typeS *pop;
597 #ifdef WARN_COMMENTS
598 found_comment = 0;
599 #endif
601 buffer = input_scrub_new_file (name);
603 listing_file (name);
604 listing_newline (NULL);
605 register_dependency (name);
607 /* Generate debugging information before we've read anything in to denote
608 this file as the "main" source file and not a subordinate one
609 (e.g. N_SO vs N_SOL in stabs). */
610 generate_file_debug ();
612 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
613 { /* We have another line to parse. */
614 #ifndef NO_LISTING
615 /* In order to avoid listing macro expansion lines with labels
616 multiple times, keep track of which line was last issued. */
617 static char *last_eol;
619 last_eol = NULL;
620 #endif
621 while (input_line_pointer < buffer_limit)
623 bfd_boolean was_new_line;
624 /* We have more of this buffer to parse. */
626 /* We now have input_line_pointer->1st char of next line.
627 If input_line_pointer [-1] == '\n' then we just
628 scanned another line: so bump line counters. */
629 was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
630 if (was_new_line)
632 symbol_set_value_now (&dot_symbol);
633 #ifdef md_start_line_hook
634 md_start_line_hook ();
635 #endif
636 if (input_line_pointer[-1] == '\n')
637 bump_line_counters ();
640 #ifndef NO_LISTING
641 /* If listing is on, and we are expanding a macro, then give
642 the listing code the contents of the expanded line. */
643 if (listing)
645 if ((listing & LISTING_MACEXP) && macro_nest > 0)
647 /* Find the end of the current expanded macro line. */
648 s = find_end_of_line (input_line_pointer, flag_m68k_mri);
650 if (s != last_eol)
652 char *copy;
653 int len;
655 last_eol = 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;
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, len);
663 copy[macro_nest + 1 + len] = '\0';
665 /* Install the line with the listing facility. */
666 listing_newline (copy);
669 else
670 listing_newline (NULL);
672 #endif
673 if (was_new_line)
675 line_label = NULL;
677 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
679 /* Text at the start of a line must be a label, we
680 run down and stick a colon in. */
681 if (is_name_beginner (*input_line_pointer))
683 char *line_start = input_line_pointer;
684 int mri_line_macro;
686 HANDLE_CONDITIONAL_ASSEMBLY ();
688 c = get_symbol_end ();
690 /* In MRI mode, the EQU and MACRO pseudoops must
691 be handled specially. */
692 mri_line_macro = 0;
693 if (flag_m68k_mri)
695 char *rest = input_line_pointer + 1;
697 if (*rest == ':')
698 ++rest;
699 if (*rest == ' ' || *rest == '\t')
700 ++rest;
701 if ((strncasecmp (rest, "EQU", 3) == 0
702 || strncasecmp (rest, "SET", 3) == 0)
703 && (rest[3] == ' ' || rest[3] == '\t'))
705 input_line_pointer = rest + 3;
706 equals (line_start,
707 strncasecmp (rest, "SET", 3) == 0);
708 continue;
710 if (strncasecmp (rest, "MACRO", 5) == 0
711 && (rest[5] == ' '
712 || rest[5] == '\t'
713 || is_end_of_line[(unsigned char) rest[5]]))
714 mri_line_macro = 1;
717 /* In MRI mode, we need to handle the MACRO
718 pseudo-op specially: we don't want to put the
719 symbol in the symbol table. */
720 if (!mri_line_macro
721 #ifdef TC_START_LABEL_WITHOUT_COLON
722 && TC_START_LABEL_WITHOUT_COLON(c,
723 input_line_pointer)
724 #endif
726 line_label = colon (line_start);
727 else
728 line_label = symbol_create (line_start,
729 absolute_section,
730 (valueT) 0,
731 &zero_address_frag);
733 *input_line_pointer = c;
734 if (c == ':')
735 input_line_pointer++;
740 /* We are at the beginning of a line, or similar place.
741 We expect a well-formed assembler statement.
742 A "symbol-name:" is a statement.
744 Depending on what compiler is used, the order of these tests
745 may vary to catch most common case 1st.
746 Each test is independent of all other tests at the (top)
747 level. */
749 c = *input_line_pointer++;
750 while (c == '\t' || c == ' ' || c == '\f');
752 /* C is the 1st significant character.
753 Input_line_pointer points after that character. */
754 if (is_name_beginner (c))
756 /* Want user-defined label or pseudo/opcode. */
757 HANDLE_CONDITIONAL_ASSEMBLY ();
759 s = --input_line_pointer;
760 c = get_symbol_end (); /* name's delimiter. */
762 /* C is character after symbol.
763 That character's place in the input line is now '\0'.
764 S points to the beginning of the symbol.
765 [In case of pseudo-op, s->'.'.]
766 Input_line_pointer->'\0' where c was. */
767 if (TC_START_LABEL (c, s, input_line_pointer))
769 if (flag_m68k_mri)
771 char *rest = input_line_pointer + 1;
773 /* In MRI mode, \tsym: set 0 is permitted. */
774 if (*rest == ':')
775 ++rest;
777 if (*rest == ' ' || *rest == '\t')
778 ++rest;
780 if ((strncasecmp (rest, "EQU", 3) == 0
781 || strncasecmp (rest, "SET", 3) == 0)
782 && (rest[3] == ' ' || rest[3] == '\t'))
784 input_line_pointer = rest + 3;
785 equals (s, 1);
786 continue;
790 line_label = colon (s); /* User-defined label. */
791 /* Put ':' back for error messages' sake. */
792 *input_line_pointer++ = ':';
793 #ifdef tc_check_label
794 tc_check_label (line_label);
795 #endif
796 /* Input_line_pointer->after ':'. */
797 SKIP_WHITESPACE ();
799 else if ((c == '=' && input_line_pointer[1] == '=')
800 || ((c == ' ' || c == '\t')
801 && input_line_pointer[1] == '='
802 && input_line_pointer[2] == '='))
804 equals (s, -1);
805 demand_empty_rest_of_line ();
807 else if ((c == '='
808 || ((c == ' ' || c == '\t')
809 && input_line_pointer[1] == '='))
810 #ifdef TC_EQUAL_IN_INSN
811 && !TC_EQUAL_IN_INSN (c, s)
812 #endif
815 equals (s, 1);
816 demand_empty_rest_of_line ();
818 else
820 /* Expect pseudo-op or machine instruction. */
821 pop = NULL;
823 #ifndef TC_CASE_SENSITIVE
825 char *s2 = s;
827 strncpy (original_case_string, s2, sizeof (original_case_string));
828 original_case_string[sizeof (original_case_string) - 1] = 0;
830 while (*s2)
832 *s2 = TOLOWER (*s2);
833 s2++;
836 #endif
837 if (NO_PSEUDO_DOT || flag_m68k_mri)
839 /* The MRI assembler uses pseudo-ops without
840 a period. */
841 pop = (pseudo_typeS *) hash_find (po_hash, s);
842 if (pop != NULL && pop->poc_handler == NULL)
843 pop = NULL;
846 if (pop != NULL
847 || (!flag_m68k_mri && *s == '.'))
849 /* PSEUDO - OP.
851 WARNING: c has next char, which may be end-of-line.
852 We lookup the pseudo-op table with s+1 because we
853 already know that the pseudo-op begins with a '.'. */
855 if (pop == NULL)
856 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
857 if (pop && !pop->poc_handler)
858 pop = NULL;
860 /* In MRI mode, we may need to insert an
861 automatic alignment directive. What a hack
862 this is. */
863 if (mri_pending_align
864 && (pop == NULL
865 || !((pop->poc_handler == cons
866 && pop->poc_val == 1)
867 || (pop->poc_handler == s_space
868 && pop->poc_val == 1)
869 #ifdef tc_conditional_pseudoop
870 || tc_conditional_pseudoop (pop)
871 #endif
872 || pop->poc_handler == s_if
873 || pop->poc_handler == s_ifdef
874 || pop->poc_handler == s_ifc
875 || pop->poc_handler == s_ifeqs
876 || pop->poc_handler == s_else
877 || pop->poc_handler == s_endif
878 || pop->poc_handler == s_globl
879 || pop->poc_handler == s_ignore)))
881 do_align (1, (char *) NULL, 0, 0);
882 mri_pending_align = 0;
884 if (line_label != NULL)
886 symbol_set_frag (line_label, frag_now);
887 S_SET_VALUE (line_label, frag_now_fix ());
891 /* Print the error msg now, while we still can. */
892 if (pop == NULL)
894 char *end = input_line_pointer;
896 *input_line_pointer = c;
897 s_ignore (0);
898 c = *--input_line_pointer;
899 *input_line_pointer = '\0';
900 if (! macro_defined || ! try_macro (c, s))
902 *end = '\0';
903 as_bad (_("unknown pseudo-op: `%s'"), s);
904 *input_line_pointer++ = c;
906 continue;
909 /* Put it back for error messages etc. */
910 *input_line_pointer = c;
911 /* The following skip of whitespace is compulsory.
912 A well shaped space is sometimes all that separates
913 keyword from operands. */
914 if (c == ' ' || c == '\t')
915 input_line_pointer++;
917 /* Input_line is restored.
918 Input_line_pointer->1st non-blank char
919 after pseudo-operation. */
920 (*pop->poc_handler) (pop->poc_val);
922 /* If that was .end, just get out now. */
923 if (pop->poc_handler == s_end)
924 goto quit;
926 else
928 /* WARNING: c has char, which may be end-of-line. */
929 /* Also: input_line_pointer->`\0` where c was. */
930 *input_line_pointer = c;
931 input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
932 c = *input_line_pointer;
933 *input_line_pointer = '\0';
935 generate_lineno_debug ();
937 if (macro_defined && try_macro (c, s))
938 continue;
940 if (mri_pending_align)
942 do_align (1, (char *) NULL, 0, 0);
943 mri_pending_align = 0;
944 if (line_label != NULL)
946 symbol_set_frag (line_label, frag_now);
947 S_SET_VALUE (line_label, frag_now_fix ());
951 md_assemble (s); /* Assemble 1 instruction. */
953 *input_line_pointer++ = c;
955 /* We resume loop AFTER the end-of-line from
956 this instruction. */
959 continue;
962 /* Empty statement? */
963 if (is_end_of_line[(unsigned char) c])
964 continue;
966 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
968 /* local label ("4:") */
969 char *backup = input_line_pointer;
971 HANDLE_CONDITIONAL_ASSEMBLY ();
973 temp = c - '0';
975 /* Read the whole number. */
976 while (ISDIGIT (*input_line_pointer))
978 temp = (temp * 10) + *input_line_pointer - '0';
979 ++input_line_pointer;
982 if (LOCAL_LABELS_DOLLAR
983 && *input_line_pointer == '$'
984 && *(input_line_pointer + 1) == ':')
986 input_line_pointer += 2;
988 if (dollar_label_defined (temp))
990 as_fatal (_("label \"%d$\" redefined"), temp);
993 define_dollar_label (temp);
994 colon (dollar_label_name (temp, 0));
995 continue;
998 if (LOCAL_LABELS_FB
999 && *input_line_pointer++ == ':')
1001 fb_label_instance_inc (temp);
1002 colon (fb_label_name (temp, 0));
1003 continue;
1006 input_line_pointer = backup;
1007 } /* local label ("4:") */
1009 if (c && strchr (line_comment_chars, c))
1010 { /* Its a comment. Better say APP or NO_APP. */
1011 sb sbuf;
1012 char *ends;
1013 char *new_buf;
1014 char *new_tmp;
1015 unsigned int new_length;
1016 char *tmp_buf = 0;
1018 s = input_line_pointer;
1019 if (strncmp (s, "APP\n", 4))
1021 /* We ignore it. */
1022 ignore_rest_of_line ();
1023 continue;
1025 bump_line_counters ();
1026 s += 4;
1028 sb_new (&sbuf);
1029 ends = strstr (s, "#NO_APP\n");
1031 if (!ends)
1033 unsigned int tmp_len;
1034 unsigned int num;
1036 /* The end of the #APP wasn't in this buffer. We
1037 keep reading in buffers until we find the #NO_APP
1038 that goes with this #APP There is one. The specs
1039 guarantee it... */
1040 tmp_len = buffer_limit - s;
1041 tmp_buf = (char *) xmalloc (tmp_len + 1);
1042 memcpy (tmp_buf, s, tmp_len);
1045 new_tmp = input_scrub_next_buffer (&buffer);
1046 if (!new_tmp)
1047 break;
1048 else
1049 buffer_limit = new_tmp;
1050 input_line_pointer = buffer;
1051 ends = strstr (buffer, "#NO_APP\n");
1052 if (ends)
1053 num = ends - buffer;
1054 else
1055 num = buffer_limit - buffer;
1057 tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
1058 memcpy (tmp_buf + tmp_len, buffer, num);
1059 tmp_len += num;
1061 while (!ends);
1063 input_line_pointer = ends ? ends + 8 : NULL;
1065 s = tmp_buf;
1066 ends = s + tmp_len;
1069 else
1071 input_line_pointer = ends + 8;
1074 scrub_string = s;
1075 scrub_string_end = ends;
1077 new_length = ends - s;
1078 new_buf = (char *) xmalloc (new_length);
1079 new_tmp = new_buf;
1080 for (;;)
1082 int space;
1083 int size;
1085 space = (new_buf + new_length) - new_tmp;
1086 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1088 if (size < space)
1090 new_tmp[size] = 0;
1091 break;
1094 new_buf = (char *) xrealloc (new_buf, new_length + 100);
1095 new_tmp = new_buf + new_length;
1096 new_length += 100;
1099 if (tmp_buf)
1100 free (tmp_buf);
1102 /* We've "scrubbed" input to the preferred format. In the
1103 process we may have consumed the whole of the remaining
1104 file (and included files). We handle this formatted
1105 input similar to that of macro expansion, letting
1106 actual macro expansion (possibly nested) and other
1107 input expansion work. Beware that in messages, line
1108 numbers and possibly file names will be incorrect. */
1109 sb_add_string (&sbuf, new_buf);
1110 input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1111 sb_kill (&sbuf);
1112 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1113 free (new_buf);
1114 continue;
1117 HANDLE_CONDITIONAL_ASSEMBLY ();
1119 #ifdef tc_unrecognized_line
1120 if (tc_unrecognized_line (c))
1121 continue;
1122 #endif
1123 input_line_pointer--;
1124 /* Report unknown char as error. */
1125 demand_empty_rest_of_line ();
1128 #ifdef md_after_pass_hook
1129 md_after_pass_hook ();
1130 #endif
1132 symbol_set_value_now (&dot_symbol);
1134 quit:
1136 #ifdef md_cleanup
1137 md_cleanup ();
1138 #endif
1139 /* Close the input file. */
1140 input_scrub_close ();
1141 #ifdef WARN_COMMENTS
1143 if (warn_comment && found_comment)
1144 as_warn_where (found_comment_file, found_comment,
1145 "first comment found here");
1147 #endif
1150 /* Convert O_constant expression EXP into the equivalent O_big representation.
1151 Take the sign of the number from X_unsigned rather than X_add_number. */
1153 static void
1154 convert_to_bignum (expressionS *exp)
1156 valueT value;
1157 unsigned int i;
1159 value = exp->X_add_number;
1160 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1162 generic_bignum[i] = value & LITTLENUM_MASK;
1163 value >>= LITTLENUM_NUMBER_OF_BITS;
1165 /* Add a sequence of sign bits if the top bit of X_add_number is not
1166 the sign of the original value. */
1167 if ((exp->X_add_number < 0) != !exp->X_unsigned)
1168 generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1169 exp->X_op = O_big;
1170 exp->X_add_number = i;
1173 /* For most MRI pseudo-ops, the line actually ends at the first
1174 nonquoted space. This function looks for that point, stuffs a null
1175 in, and sets *STOPCP to the character that used to be there, and
1176 returns the location.
1178 Until I hear otherwise, I am going to assume that this is only true
1179 for the m68k MRI assembler. */
1181 char *
1182 mri_comment_field (char *stopcp)
1184 char *s;
1185 #ifdef TC_M68K
1186 int inquote = 0;
1188 know (flag_m68k_mri);
1190 for (s = input_line_pointer;
1191 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1192 || inquote);
1193 s++)
1195 if (*s == '\'')
1196 inquote = !inquote;
1198 #else
1199 for (s = input_line_pointer;
1200 !is_end_of_line[(unsigned char) *s];
1201 s++)
1203 #endif
1204 *stopcp = *s;
1205 *s = '\0';
1207 return s;
1210 /* Skip to the end of an MRI comment field. */
1212 void
1213 mri_comment_end (char *stop, int stopc)
1215 know (flag_mri);
1217 input_line_pointer = stop;
1218 *stop = stopc;
1219 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1220 ++input_line_pointer;
1223 void
1224 s_abort (int ignore ATTRIBUTE_UNUSED)
1226 as_fatal (_(".abort detected. Abandoning ship."));
1229 /* Guts of .align directive. N is the power of two to which to align.
1230 FILL may be NULL, or it may point to the bytes of the fill pattern.
1231 LEN is the length of whatever FILL points to, if anything. MAX is
1232 the maximum number of characters to skip when doing the alignment,
1233 or 0 if there is no maximum. */
1235 static void
1236 do_align (int n, char *fill, int len, int max)
1238 if (now_seg == absolute_section)
1240 if (fill != NULL)
1241 while (len-- > 0)
1242 if (*fill++ != '\0')
1244 as_warn (_("ignoring fill value in absolute section"));
1245 break;
1247 fill = NULL;
1248 len = 0;
1251 #ifdef md_flush_pending_output
1252 md_flush_pending_output ();
1253 #endif
1254 #ifdef md_do_align
1255 md_do_align (n, fill, len, max, just_record_alignment);
1256 #endif
1258 /* Only make a frag if we HAVE to... */
1259 if (n != 0 && !need_pass_2)
1261 if (fill == NULL)
1263 if (subseg_text_p (now_seg))
1264 frag_align_code (n, max);
1265 else
1266 frag_align (n, 0, max);
1268 else if (len <= 1)
1269 frag_align (n, *fill, max);
1270 else
1271 frag_align_pattern (n, fill, len, max);
1274 #ifdef md_do_align
1275 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1276 #endif
1278 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1281 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1282 (in bytes). A negative ARG is the negative of the length of the
1283 fill pattern. BYTES_P is non-zero if the alignment value should be
1284 interpreted as the byte boundary, rather than the power of 2. */
1285 #ifndef TC_ALIGN_LIMIT
1286 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1287 #endif
1289 static void
1290 s_align (int arg, int bytes_p)
1292 unsigned int align_limit = TC_ALIGN_LIMIT;
1293 unsigned int align;
1294 char *stop = NULL;
1295 char stopc = 0;
1296 offsetT fill = 0;
1297 int max;
1298 int fill_p;
1300 if (flag_mri)
1301 stop = mri_comment_field (&stopc);
1303 if (is_end_of_line[(unsigned char) *input_line_pointer])
1305 if (arg < 0)
1306 align = 0;
1307 else
1308 align = arg; /* Default value from pseudo-op table. */
1310 else
1312 align = get_absolute_expression ();
1313 SKIP_WHITESPACE ();
1316 if (bytes_p)
1318 /* Convert to a power of 2. */
1319 if (align != 0)
1321 unsigned int i;
1323 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1325 if (align != 1)
1326 as_bad (_("alignment not a power of 2"));
1328 align = i;
1332 if (align > align_limit)
1334 align = align_limit;
1335 as_warn (_("alignment too large: %u assumed"), align);
1338 if (*input_line_pointer != ',')
1340 fill_p = 0;
1341 max = 0;
1343 else
1345 ++input_line_pointer;
1346 if (*input_line_pointer == ',')
1347 fill_p = 0;
1348 else
1350 fill = get_absolute_expression ();
1351 SKIP_WHITESPACE ();
1352 fill_p = 1;
1355 if (*input_line_pointer != ',')
1356 max = 0;
1357 else
1359 ++input_line_pointer;
1360 max = get_absolute_expression ();
1364 if (!fill_p)
1366 if (arg < 0)
1367 as_warn (_("expected fill pattern missing"));
1368 do_align (align, (char *) NULL, 0, max);
1370 else
1372 int fill_len;
1374 if (arg >= 0)
1375 fill_len = 1;
1376 else
1377 fill_len = -arg;
1378 if (fill_len <= 1)
1380 char fill_char;
1382 fill_char = fill;
1383 do_align (align, &fill_char, fill_len, max);
1385 else
1387 char ab[16];
1389 if ((size_t) fill_len > sizeof ab)
1390 abort ();
1391 md_number_to_chars (ab, fill, fill_len);
1392 do_align (align, ab, fill_len, max);
1396 demand_empty_rest_of_line ();
1398 if (flag_mri)
1399 mri_comment_end (stop, stopc);
1402 /* Handle the .align pseudo-op on machines where ".align 4" means
1403 align to a 4 byte boundary. */
1405 void
1406 s_align_bytes (int arg)
1408 s_align (arg, 1);
1411 /* Handle the .align pseudo-op on machines where ".align 4" means align
1412 to a 2**4 boundary. */
1414 void
1415 s_align_ptwo (int arg)
1417 s_align (arg, 0);
1420 /* Switch in and out of alternate macro mode. */
1422 void
1423 s_altmacro (int on)
1425 demand_empty_rest_of_line ();
1426 macro_set_alternate (on);
1429 symbolS *
1430 s_comm_internal (int param,
1431 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1433 char *name;
1434 char c;
1435 char *p;
1436 offsetT temp, size;
1437 symbolS *symbolP = NULL;
1438 char *stop = NULL;
1439 char stopc = 0;
1440 expressionS exp;
1442 if (flag_mri)
1443 stop = mri_comment_field (&stopc);
1445 name = input_line_pointer;
1446 c = get_symbol_end ();
1447 /* Just after name is now '\0'. */
1448 p = input_line_pointer;
1449 *p = c;
1451 if (name == p)
1453 as_bad (_("expected symbol name"));
1454 ignore_rest_of_line ();
1455 goto out;
1458 SKIP_WHITESPACE ();
1460 /* Accept an optional comma after the name. The comma used to be
1461 required, but Irix 5 cc does not generate it for .lcomm. */
1462 if (*input_line_pointer == ',')
1463 input_line_pointer++;
1465 temp = get_absolute_expr (&exp);
1466 size = temp;
1467 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1468 if (exp.X_op == O_absent)
1470 as_bad (_("missing size expression"));
1471 ignore_rest_of_line ();
1472 goto out;
1474 else if (temp != size || !exp.X_unsigned)
1476 as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1477 ignore_rest_of_line ();
1478 goto out;
1481 *p = 0;
1482 symbolP = symbol_find_or_make (name);
1483 if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
1484 && !S_IS_COMMON (symbolP))
1486 if (!S_IS_VOLATILE (symbolP))
1488 symbolP = NULL;
1489 as_bad (_("symbol `%s' is already defined"), name);
1490 *p = c;
1491 ignore_rest_of_line ();
1492 goto out;
1494 symbolP = symbol_clone (symbolP, 1);
1495 S_SET_SEGMENT (symbolP, undefined_section);
1496 S_SET_VALUE (symbolP, 0);
1497 symbol_set_frag (symbolP, &zero_address_frag);
1498 S_CLEAR_VOLATILE (symbolP);
1501 size = S_GET_VALUE (symbolP);
1502 if (size == 0)
1503 size = temp;
1504 else if (size != temp)
1505 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1506 name, (long) size, (long) temp);
1508 *p = c;
1509 if (comm_parse_extra != NULL)
1510 symbolP = (*comm_parse_extra) (param, symbolP, size);
1511 else
1513 S_SET_VALUE (symbolP, (valueT) size);
1514 S_SET_EXTERNAL (symbolP);
1515 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
1516 #ifdef OBJ_VMS
1518 extern int flag_one;
1519 if (size == 0 || !flag_one)
1520 S_GET_OTHER (symbolP) = const_flag;
1522 #endif
1525 demand_empty_rest_of_line ();
1526 out:
1527 if (flag_mri)
1528 mri_comment_end (stop, stopc);
1529 return symbolP;
1532 void
1533 s_comm (int ignore)
1535 s_comm_internal (ignore, NULL);
1538 /* The MRI COMMON pseudo-op. We handle this by creating a common
1539 symbol with the appropriate name. We make s_space do the right
1540 thing by increasing the size. */
1542 void
1543 s_mri_common (int small ATTRIBUTE_UNUSED)
1545 char *name;
1546 char c;
1547 char *alc = NULL;
1548 symbolS *sym;
1549 offsetT align;
1550 char *stop = NULL;
1551 char stopc = 0;
1553 if (!flag_mri)
1555 s_comm (0);
1556 return;
1559 stop = mri_comment_field (&stopc);
1561 SKIP_WHITESPACE ();
1563 name = input_line_pointer;
1564 if (!ISDIGIT (*name))
1565 c = get_symbol_end ();
1566 else
1570 ++input_line_pointer;
1572 while (ISDIGIT (*input_line_pointer));
1574 c = *input_line_pointer;
1575 *input_line_pointer = '\0';
1577 if (line_label != NULL)
1579 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1580 + (input_line_pointer - name)
1581 + 1);
1582 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1583 name = alc;
1587 sym = symbol_find_or_make (name);
1588 *input_line_pointer = c;
1589 if (alc != NULL)
1590 free (alc);
1592 if (*input_line_pointer != ',')
1593 align = 0;
1594 else
1596 ++input_line_pointer;
1597 align = get_absolute_expression ();
1600 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1602 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1603 ignore_rest_of_line ();
1604 mri_comment_end (stop, stopc);
1605 return;
1608 S_SET_EXTERNAL (sym);
1609 S_SET_SEGMENT (sym, bfd_com_section_ptr);
1610 mri_common_symbol = sym;
1612 #ifdef S_SET_ALIGN
1613 if (align != 0)
1614 S_SET_ALIGN (sym, align);
1615 #else
1616 (void) align;
1617 #endif
1619 if (line_label != NULL)
1621 expressionS exp;
1622 exp.X_op = O_symbol;
1623 exp.X_add_symbol = sym;
1624 exp.X_add_number = 0;
1625 symbol_set_value_expression (line_label, &exp);
1626 symbol_set_frag (line_label, &zero_address_frag);
1627 S_SET_SEGMENT (line_label, expr_section);
1630 /* FIXME: We just ignore the small argument, which distinguishes
1631 COMMON and COMMON.S. I don't know what we can do about it. */
1633 /* Ignore the type and hptype. */
1634 if (*input_line_pointer == ',')
1635 input_line_pointer += 2;
1636 if (*input_line_pointer == ',')
1637 input_line_pointer += 2;
1639 demand_empty_rest_of_line ();
1641 mri_comment_end (stop, stopc);
1644 void
1645 s_data (int ignore ATTRIBUTE_UNUSED)
1647 segT section;
1648 int temp;
1650 temp = get_absolute_expression ();
1651 if (flag_readonly_data_in_text)
1653 section = text_section;
1654 temp += 1000;
1656 else
1657 section = data_section;
1659 subseg_set (section, (subsegT) temp);
1661 #ifdef OBJ_VMS
1662 const_flag = 0;
1663 #endif
1664 demand_empty_rest_of_line ();
1667 /* Handle the .appfile pseudo-op. This is automatically generated by
1668 do_scrub_chars when a preprocessor # line comment is seen with a
1669 file name. This default definition may be overridden by the object
1670 or CPU specific pseudo-ops. This function is also the default
1671 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1672 .file. */
1674 void
1675 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1677 #ifdef LISTING
1678 if (listing)
1679 listing_source_file (file);
1680 #endif
1681 register_dependency (file);
1682 #ifdef obj_app_file
1683 obj_app_file (file, appfile);
1684 #endif
1687 void
1688 s_app_file (int appfile)
1690 char *s;
1691 int length;
1693 /* Some assemblers tolerate immediately following '"'. */
1694 if ((s = demand_copy_string (&length)) != 0)
1696 int may_omit
1697 = (!new_logical_line_flags (s, -1, 1) && appfile);
1699 /* In MRI mode, the preprocessor may have inserted an extraneous
1700 backquote. */
1701 if (flag_m68k_mri
1702 && *input_line_pointer == '\''
1703 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1704 ++input_line_pointer;
1706 demand_empty_rest_of_line ();
1707 if (!may_omit)
1708 s_app_file_string (s, appfile);
1712 static int
1713 get_linefile_number (int *flag)
1715 SKIP_WHITESPACE ();
1717 if (*input_line_pointer < '0' || *input_line_pointer > '9')
1718 return 0;
1720 *flag = get_absolute_expression ();
1722 return 1;
1725 /* Handle the .appline pseudo-op. This is automatically generated by
1726 do_scrub_chars when a preprocessor # line comment is seen. This
1727 default definition may be overridden by the object or CPU specific
1728 pseudo-ops. */
1730 void
1731 s_app_line (int appline)
1733 char *file = NULL;
1734 int l;
1736 /* The given number is that of the next line. */
1737 if (appline)
1738 l = get_absolute_expression ();
1739 else if (!get_linefile_number (&l))
1741 ignore_rest_of_line ();
1742 return;
1745 l--;
1747 if (l < -1)
1748 /* Some of the back ends can't deal with non-positive line numbers.
1749 Besides, it's silly. GCC however will generate a line number of
1750 zero when it is pre-processing builtins for assembler-with-cpp files:
1752 # 0 "<built-in>"
1754 We do not want to barf on this, especially since such files are used
1755 in the GCC and GDB testsuites. So we check for negative line numbers
1756 rather than non-positive line numbers. */
1757 as_warn (_("line numbers must be positive; line number %d rejected"),
1758 l + 1);
1759 else
1761 int flags = 0;
1762 int length = 0;
1764 if (!appline)
1766 SKIP_WHITESPACE ();
1768 if (*input_line_pointer == '"')
1769 file = demand_copy_string (&length);
1771 if (file)
1773 int this_flag;
1775 while (get_linefile_number (&this_flag))
1776 switch (this_flag)
1778 /* From GCC's cpp documentation:
1779 1: start of a new file.
1780 2: returning to a file after having included
1781 another file.
1782 3: following text comes from a system header file.
1783 4: following text should be treated as extern "C".
1785 4 is nonsensical for the assembler; 3, we don't
1786 care about, so we ignore it just in case a
1787 system header file is included while
1788 preprocessing assembly. So 1 and 2 are all we
1789 care about, and they are mutually incompatible.
1790 new_logical_line_flags() demands this. */
1791 case 1:
1792 case 2:
1793 if (flags && flags != (1 << this_flag))
1794 as_warn (_("incompatible flag %i in line directive"),
1795 this_flag);
1796 else
1797 flags |= 1 << this_flag;
1798 break;
1800 case 3:
1801 case 4:
1802 /* We ignore these. */
1803 break;
1805 default:
1806 as_warn (_("unsupported flag %i in line directive"),
1807 this_flag);
1808 break;
1811 if (!is_end_of_line[(unsigned char)*input_line_pointer])
1812 file = 0;
1816 if (appline || file)
1818 new_logical_line_flags (file, l, flags);
1819 #ifdef LISTING
1820 if (listing)
1821 listing_source_line (l);
1822 #endif
1825 if (appline || file)
1826 demand_empty_rest_of_line ();
1827 else
1828 ignore_rest_of_line ();
1831 /* Handle the .end pseudo-op. Actually, the real work is done in
1832 read_a_source_file. */
1834 void
1835 s_end (int ignore ATTRIBUTE_UNUSED)
1837 if (flag_mri)
1839 /* The MRI assembler permits the start symbol to follow .end,
1840 but we don't support that. */
1841 SKIP_WHITESPACE ();
1842 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1843 && *input_line_pointer != '*'
1844 && *input_line_pointer != '!')
1845 as_warn (_("start address not supported"));
1849 /* Handle the .err pseudo-op. */
1851 void
1852 s_err (int ignore ATTRIBUTE_UNUSED)
1854 as_bad (_(".err encountered"));
1855 demand_empty_rest_of_line ();
1858 /* Handle the .error and .warning pseudo-ops. */
1860 void
1861 s_errwarn (int err)
1863 int len;
1864 /* The purpose for the conditional assignment is not to
1865 internationalize the directive itself, but that we need a
1866 self-contained message, one that can be passed like the
1867 demand_copy_C_string return value, and with no assumption on the
1868 location of the name of the directive within the message. */
1869 char *msg
1870 = (err ? _(".error directive invoked in source file")
1871 : _(".warning directive invoked in source file"));
1873 if (!is_it_end_of_statement ())
1875 if (*input_line_pointer != '\"')
1877 as_bad (_("%s argument must be a string"),
1878 err ? ".error" : ".warning");
1879 ignore_rest_of_line ();
1880 return;
1883 msg = demand_copy_C_string (&len);
1884 if (msg == NULL)
1885 return;
1888 if (err)
1889 as_bad ("%s", msg);
1890 else
1891 as_warn ("%s", msg);
1892 demand_empty_rest_of_line ();
1895 /* Handle the MRI fail pseudo-op. */
1897 void
1898 s_fail (int ignore ATTRIBUTE_UNUSED)
1900 offsetT temp;
1901 char *stop = NULL;
1902 char stopc = 0;
1904 if (flag_mri)
1905 stop = mri_comment_field (&stopc);
1907 temp = get_absolute_expression ();
1908 if (temp >= 500)
1909 as_warn (_(".fail %ld encountered"), (long) temp);
1910 else
1911 as_bad (_(".fail %ld encountered"), (long) temp);
1913 demand_empty_rest_of_line ();
1915 if (flag_mri)
1916 mri_comment_end (stop, stopc);
1919 void
1920 s_fill (int ignore ATTRIBUTE_UNUSED)
1922 expressionS rep_exp;
1923 long size = 1;
1924 long fill = 0;
1925 char *p;
1927 #ifdef md_flush_pending_output
1928 md_flush_pending_output ();
1929 #endif
1931 #ifdef md_cons_align
1932 md_cons_align (1);
1933 #endif
1935 get_known_segmented_expression (&rep_exp);
1936 if (*input_line_pointer == ',')
1938 input_line_pointer++;
1939 size = get_absolute_expression ();
1940 if (*input_line_pointer == ',')
1942 input_line_pointer++;
1943 fill = get_absolute_expression ();
1947 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1948 #define BSD_FILL_SIZE_CROCK_8 (8)
1949 if (size > BSD_FILL_SIZE_CROCK_8)
1951 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1952 size = BSD_FILL_SIZE_CROCK_8;
1954 if (size < 0)
1956 as_warn (_("size negative; .fill ignored"));
1957 size = 0;
1959 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1961 if (rep_exp.X_add_number < 0)
1962 as_warn (_("repeat < 0; .fill ignored"));
1963 size = 0;
1966 if (size && !need_pass_2)
1968 if (rep_exp.X_op == O_constant)
1970 p = frag_var (rs_fill, (int) size, (int) size,
1971 (relax_substateT) 0, (symbolS *) 0,
1972 (offsetT) rep_exp.X_add_number,
1973 (char *) 0);
1975 else
1977 /* We don't have a constant repeat count, so we can't use
1978 rs_fill. We can get the same results out of rs_space,
1979 but its argument is in bytes, so we must multiply the
1980 repeat count by size. */
1982 symbolS *rep_sym;
1983 rep_sym = make_expr_symbol (&rep_exp);
1984 if (size != 1)
1986 expressionS size_exp;
1987 size_exp.X_op = O_constant;
1988 size_exp.X_add_number = size;
1990 rep_exp.X_op = O_multiply;
1991 rep_exp.X_add_symbol = rep_sym;
1992 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1993 rep_exp.X_add_number = 0;
1994 rep_sym = make_expr_symbol (&rep_exp);
1997 p = frag_var (rs_space, (int) size, (int) size,
1998 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
2001 memset (p, 0, (unsigned int) size);
2003 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2004 flavoured AS. The following bizarre behaviour is to be
2005 compatible with above. I guess they tried to take up to 8
2006 bytes from a 4-byte expression and they forgot to sign
2007 extend. */
2008 #define BSD_FILL_SIZE_CROCK_4 (4)
2009 md_number_to_chars (p, (valueT) fill,
2010 (size > BSD_FILL_SIZE_CROCK_4
2011 ? BSD_FILL_SIZE_CROCK_4
2012 : (int) size));
2013 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2014 but emits no error message because it seems a legal thing to do.
2015 It is a degenerate case of .fill but could be emitted by a
2016 compiler. */
2018 demand_empty_rest_of_line ();
2021 void
2022 s_globl (int ignore ATTRIBUTE_UNUSED)
2024 char *name;
2025 int c;
2026 symbolS *symbolP;
2027 char *stop = NULL;
2028 char stopc = 0;
2030 if (flag_mri)
2031 stop = mri_comment_field (&stopc);
2035 name = input_line_pointer;
2036 c = get_symbol_end ();
2037 symbolP = symbol_find_or_make (name);
2038 S_SET_EXTERNAL (symbolP);
2040 *input_line_pointer = c;
2041 SKIP_WHITESPACE ();
2042 c = *input_line_pointer;
2043 if (c == ',')
2045 input_line_pointer++;
2046 SKIP_WHITESPACE ();
2047 if (is_end_of_line[(unsigned char) *input_line_pointer])
2048 c = '\n';
2051 while (c == ',');
2053 demand_empty_rest_of_line ();
2055 if (flag_mri)
2056 mri_comment_end (stop, stopc);
2059 #ifdef OBJ_ELF
2060 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
2062 static inline int
2063 skip_past_char (char ** str, char c)
2065 if (**str == c)
2067 (*str)++;
2068 return 0;
2070 else
2071 return -1;
2073 #define skip_past_comma(str) skip_past_char (str, ',')
2075 /* Parse an attribute directive for VENDOR.
2076 Returns the attribute number read, or zero on error. */
2078 s_vendor_attribute (int vendor)
2080 expressionS exp;
2081 int type;
2082 int tag;
2083 unsigned int i = 0;
2084 char *s = NULL;
2086 /* Read the first number or name. */
2087 skip_whitespace (input_line_pointer);
2088 s = input_line_pointer;
2089 if (ISDIGIT (*input_line_pointer))
2091 expression (& exp);
2092 if (exp.X_op != O_constant)
2093 goto bad;
2094 tag = exp.X_add_number;
2096 else
2098 char *name;
2100 /* A name may contain '_', but no other punctuation. */
2101 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2102 ++input_line_pointer)
2103 i++;
2104 if (i == 0)
2105 goto bad;
2107 name = (char *) alloca (i + 1);
2108 memcpy (name, s, i);
2109 name[i] = '\0';
2111 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2112 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2113 #endif
2115 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2116 if (tag == -1)
2118 as_bad (_("Attribute name not recognised: %s"), name);
2119 ignore_rest_of_line ();
2120 return 0;
2124 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2126 if (skip_past_comma (&input_line_pointer) == -1)
2127 goto bad;
2128 if (type & 1)
2130 expression (& exp);
2131 if (exp.X_op != O_constant)
2133 as_bad (_("expected numeric constant"));
2134 ignore_rest_of_line ();
2135 return 0;
2137 i = exp.X_add_number;
2139 if ((type & 3) == 3
2140 && skip_past_comma (&input_line_pointer) == -1)
2142 as_bad (_("expected comma"));
2143 ignore_rest_of_line ();
2144 return 0;
2146 if (type & 2)
2148 int len;
2150 skip_whitespace (input_line_pointer);
2151 if (*input_line_pointer != '"')
2152 goto bad_string;
2153 s = demand_copy_C_string (&len);
2156 switch (type & 3)
2158 case 3:
2159 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2160 break;
2161 case 2:
2162 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2163 break;
2164 case 1:
2165 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2166 break;
2167 default:
2168 abort ();
2171 demand_empty_rest_of_line ();
2172 return tag;
2173 bad_string:
2174 as_bad (_("bad string constant"));
2175 ignore_rest_of_line ();
2176 return 0;
2177 bad:
2178 as_bad (_("expected <tag> , <value>"));
2179 ignore_rest_of_line ();
2180 return 0;
2183 /* Parse a .gnu_attribute directive. */
2185 static void
2186 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2188 s_vendor_attribute (OBJ_ATTR_GNU);
2190 #endif /* OBJ_ELF */
2192 /* Handle the MRI IRP and IRPC pseudo-ops. */
2194 void
2195 s_irp (int irpc)
2197 char *file, *eol;
2198 unsigned int line;
2199 sb s;
2200 const char *err;
2201 sb out;
2203 as_where (&file, &line);
2205 sb_new (&s);
2206 eol = find_end_of_line (input_line_pointer, 0);
2207 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2208 input_line_pointer = eol;
2210 sb_new (&out);
2212 err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2213 if (err != NULL)
2214 as_bad_where (file, line, "%s", err);
2216 sb_kill (&s);
2218 input_scrub_include_sb (&out, input_line_pointer, 1);
2219 sb_kill (&out);
2220 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2223 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2224 the section to only be linked once. However, this is not supported
2225 by most object file formats. This takes an optional argument,
2226 which is what to do about duplicates. */
2228 void
2229 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2231 enum linkonce_type type;
2233 SKIP_WHITESPACE ();
2235 type = LINKONCE_DISCARD;
2237 if (!is_end_of_line[(unsigned char) *input_line_pointer])
2239 char *s;
2240 char c;
2242 s = input_line_pointer;
2243 c = get_symbol_end ();
2244 if (strcasecmp (s, "discard") == 0)
2245 type = LINKONCE_DISCARD;
2246 else if (strcasecmp (s, "one_only") == 0)
2247 type = LINKONCE_ONE_ONLY;
2248 else if (strcasecmp (s, "same_size") == 0)
2249 type = LINKONCE_SAME_SIZE;
2250 else if (strcasecmp (s, "same_contents") == 0)
2251 type = LINKONCE_SAME_CONTENTS;
2252 else
2253 as_warn (_("unrecognized .linkonce type `%s'"), s);
2255 *input_line_pointer = c;
2258 #ifdef obj_handle_link_once
2259 obj_handle_link_once (type);
2260 #else /* ! defined (obj_handle_link_once) */
2262 flagword flags;
2264 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2265 as_warn (_(".linkonce is not supported for this object file format"));
2267 flags = bfd_get_section_flags (stdoutput, now_seg);
2268 flags |= SEC_LINK_ONCE;
2269 switch (type)
2271 default:
2272 abort ();
2273 case LINKONCE_DISCARD:
2274 flags |= SEC_LINK_DUPLICATES_DISCARD;
2275 break;
2276 case LINKONCE_ONE_ONLY:
2277 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2278 break;
2279 case LINKONCE_SAME_SIZE:
2280 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2281 break;
2282 case LINKONCE_SAME_CONTENTS:
2283 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2284 break;
2286 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2287 as_bad (_("bfd_set_section_flags: %s"),
2288 bfd_errmsg (bfd_get_error ()));
2290 #endif /* ! defined (obj_handle_link_once) */
2292 demand_empty_rest_of_line ();
2295 void
2296 bss_alloc (symbolS *symbolP, addressT size, int align)
2298 char *pfrag;
2299 segT current_seg = now_seg;
2300 subsegT current_subseg = now_subseg;
2301 segT bss_seg = bss_section;
2303 #if defined (TC_MIPS) || defined (TC_ALPHA)
2304 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2305 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2307 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2308 if (size <= bfd_get_gp_size (stdoutput))
2310 bss_seg = subseg_new (".sbss", 1);
2311 seg_info (bss_seg)->bss = 1;
2312 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2313 as_warn (_("error setting flags for \".sbss\": %s"),
2314 bfd_errmsg (bfd_get_error ()));
2317 #endif
2318 subseg_set (bss_seg, 1);
2320 if (align)
2322 record_alignment (bss_seg, align);
2323 frag_align (align, 0, 0);
2326 /* Detach from old frag. */
2327 if (S_GET_SEGMENT (symbolP) == bss_seg)
2328 symbol_get_frag (symbolP)->fr_symbol = NULL;
2330 symbol_set_frag (symbolP, frag_now);
2331 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2332 *pfrag = 0;
2334 #ifdef S_SET_SIZE
2335 S_SET_SIZE (symbolP, size);
2336 #endif
2337 S_SET_SEGMENT (symbolP, bss_seg);
2339 #ifdef OBJ_COFF
2340 /* The symbol may already have been created with a preceding
2341 ".globl" directive -- be careful not to step on storage class
2342 in that case. Otherwise, set it to static. */
2343 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2344 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2345 #endif /* OBJ_COFF */
2347 subseg_set (current_seg, current_subseg);
2350 offsetT
2351 parse_align (int align_bytes)
2353 expressionS exp;
2354 addressT align;
2356 SKIP_WHITESPACE ();
2357 if (*input_line_pointer != ',')
2359 no_align:
2360 as_bad (_("expected alignment after size"));
2361 ignore_rest_of_line ();
2362 return -1;
2365 input_line_pointer++;
2366 SKIP_WHITESPACE ();
2368 align = get_absolute_expr (&exp);
2369 if (exp.X_op == O_absent)
2370 goto no_align;
2372 if (!exp.X_unsigned)
2374 as_warn (_("alignment negative; 0 assumed"));
2375 align = 0;
2378 if (align_bytes && align != 0)
2380 /* convert to a power of 2 alignment */
2381 unsigned int alignp2 = 0;
2382 while ((align & 1) == 0)
2383 align >>= 1, ++alignp2;
2384 if (align != 1)
2386 as_bad (_("alignment not a power of 2"));
2387 ignore_rest_of_line ();
2388 return -1;
2390 align = alignp2;
2392 return align;
2395 /* Called from s_comm_internal after symbol name and size have been
2396 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2397 1 if this was a ".bss" directive which has a 3rd argument
2398 (alignment as a power of 2), or 2 if this was a ".bss" directive
2399 with alignment in bytes. */
2401 symbolS *
2402 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2404 addressT align = 0;
2406 if (needs_align)
2408 align = parse_align (needs_align - 1);
2409 if (align == (addressT) -1)
2410 return NULL;
2412 else
2413 /* Assume some objects may require alignment on some systems. */
2414 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2416 bss_alloc (symbolP, size, align);
2417 return symbolP;
2420 void
2421 s_lcomm (int needs_align)
2423 s_comm_internal (needs_align, s_lcomm_internal);
2426 void
2427 s_lcomm_bytes (int needs_align)
2429 s_comm_internal (needs_align * 2, s_lcomm_internal);
2432 void
2433 s_lsym (int ignore ATTRIBUTE_UNUSED)
2435 char *name;
2436 char c;
2437 char *p;
2438 expressionS exp;
2439 symbolS *symbolP;
2441 /* We permit ANY defined expression: BSD4.2 demands constants. */
2442 name = input_line_pointer;
2443 c = get_symbol_end ();
2444 p = input_line_pointer;
2445 *p = c;
2447 if (name == p)
2449 as_bad (_("expected symbol name"));
2450 ignore_rest_of_line ();
2451 return;
2454 SKIP_WHITESPACE ();
2456 if (*input_line_pointer != ',')
2458 *p = 0;
2459 as_bad (_("expected comma after \"%s\""), name);
2460 *p = c;
2461 ignore_rest_of_line ();
2462 return;
2465 input_line_pointer++;
2466 expression_and_evaluate (&exp);
2468 if (exp.X_op != O_constant
2469 && exp.X_op != O_register)
2471 as_bad (_("bad expression"));
2472 ignore_rest_of_line ();
2473 return;
2476 *p = 0;
2477 symbolP = symbol_find_or_make (name);
2479 if (S_GET_SEGMENT (symbolP) == undefined_section)
2481 /* The name might be an undefined .global symbol; be sure to
2482 keep the "external" bit. */
2483 S_SET_SEGMENT (symbolP,
2484 (exp.X_op == O_constant
2485 ? absolute_section
2486 : reg_section));
2487 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2489 else
2491 as_bad (_("symbol `%s' is already defined"), name);
2494 *p = c;
2495 demand_empty_rest_of_line ();
2498 /* Read a line into an sb. Returns the character that ended the line
2499 or zero if there are no more lines. */
2501 static int
2502 get_line_sb (sb *line, int in_macro)
2504 char *eol;
2506 if (input_line_pointer[-1] == '\n')
2507 bump_line_counters ();
2509 if (input_line_pointer >= buffer_limit)
2511 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2512 if (buffer_limit == 0)
2513 return 0;
2516 eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2517 sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2518 input_line_pointer = eol;
2520 /* Don't skip multiple end-of-line characters, because that breaks support
2521 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2522 characters but isn't. Instead just skip one end of line character and
2523 return the character skipped so that the caller can re-insert it if
2524 necessary. */
2525 return *input_line_pointer++;
2528 static int
2529 get_non_macro_line_sb (sb *line)
2531 return get_line_sb (line, 0);
2534 static int
2535 get_macro_line_sb (sb *line)
2537 return get_line_sb (line, 1);
2540 /* Define a macro. This is an interface to macro.c. */
2542 void
2543 s_macro (int ignore ATTRIBUTE_UNUSED)
2545 char *file, *eol;
2546 unsigned int line;
2547 sb s;
2548 const char *err;
2549 const char *name;
2551 as_where (&file, &line);
2553 sb_new (&s);
2554 eol = find_end_of_line (input_line_pointer, 0);
2555 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2556 input_line_pointer = eol;
2558 if (line_label != NULL)
2560 sb label;
2562 sb_new (&label);
2563 sb_add_string (&label, S_GET_NAME (line_label));
2564 err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2565 sb_kill (&label);
2567 else
2568 err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2569 if (err != NULL)
2570 as_bad_where (file, line, err, name);
2571 else
2573 if (line_label != NULL)
2575 S_SET_SEGMENT (line_label, absolute_section);
2576 S_SET_VALUE (line_label, 0);
2577 symbol_set_frag (line_label, &zero_address_frag);
2580 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2581 && hash_find (po_hash, name) != NULL)
2582 || (!flag_m68k_mri
2583 && *name == '.'
2584 && hash_find (po_hash, name + 1) != NULL))
2585 as_warn_where (file,
2586 line,
2587 _("attempt to redefine pseudo-op `%s' ignored"),
2588 name);
2591 sb_kill (&s);
2594 /* Handle the .mexit pseudo-op, which immediately exits a macro
2595 expansion. */
2597 void
2598 s_mexit (int ignore ATTRIBUTE_UNUSED)
2600 if (macro_nest)
2602 cond_exit_macro (macro_nest);
2603 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2605 else
2606 as_warn (_("ignoring macro exit outside a macro definition."));
2609 /* Switch in and out of MRI mode. */
2611 void
2612 s_mri (int ignore ATTRIBUTE_UNUSED)
2614 int on;
2615 #ifdef MRI_MODE_CHANGE
2616 int old_flag;
2617 #endif
2619 on = get_absolute_expression ();
2620 #ifdef MRI_MODE_CHANGE
2621 old_flag = flag_mri;
2622 #endif
2623 if (on != 0)
2625 flag_mri = 1;
2626 #ifdef TC_M68K
2627 flag_m68k_mri = 1;
2628 #endif
2629 macro_mri_mode (1);
2631 else
2633 flag_mri = 0;
2634 #ifdef TC_M68K
2635 flag_m68k_mri = 0;
2636 #endif
2637 macro_mri_mode (0);
2640 /* Operator precedence changes in m68k MRI mode, so we need to
2641 update the operator rankings. */
2642 expr_set_precedence ();
2644 #ifdef MRI_MODE_CHANGE
2645 if (on != old_flag)
2646 MRI_MODE_CHANGE (on);
2647 #endif
2649 demand_empty_rest_of_line ();
2652 /* Handle changing the location counter. */
2654 static void
2655 do_org (segT segment, expressionS *exp, int fill)
2657 if (segment != now_seg && segment != absolute_section)
2658 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2660 if (now_seg == absolute_section)
2662 if (fill != 0)
2663 as_warn (_("ignoring fill value in absolute section"));
2664 if (exp->X_op != O_constant)
2666 as_bad (_("only constant offsets supported in absolute section"));
2667 exp->X_add_number = 0;
2669 abs_section_offset = exp->X_add_number;
2671 else
2673 char *p;
2674 symbolS *sym = exp->X_add_symbol;
2675 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2677 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2679 /* Handle complex expressions. */
2680 sym = make_expr_symbol (exp);
2681 off = 0;
2684 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2685 *p = fill;
2689 void
2690 s_org (int ignore ATTRIBUTE_UNUSED)
2692 segT segment;
2693 expressionS exp;
2694 long temp_fill;
2696 #ifdef md_flush_pending_output
2697 md_flush_pending_output ();
2698 #endif
2700 /* The m68k MRI assembler has a different meaning for .org. It
2701 means to create an absolute section at a given address. We can't
2702 support that--use a linker script instead. */
2703 if (flag_m68k_mri)
2705 as_bad (_("MRI style ORG pseudo-op not supported"));
2706 ignore_rest_of_line ();
2707 return;
2710 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2711 thing as a sub-segment-relative origin. Any absolute origin is
2712 given a warning, then assumed to be segment-relative. Any
2713 segmented origin expression ("foo+42") had better be in the right
2714 segment or the .org is ignored.
2716 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2717 we never know sub-segment sizes when we are reading code. BSD
2718 will crash trying to emit negative numbers of filler bytes in
2719 certain .orgs. We don't crash, but see as-write for that code.
2721 Don't make frag if need_pass_2==1. */
2722 segment = get_known_segmented_expression (&exp);
2723 if (*input_line_pointer == ',')
2725 input_line_pointer++;
2726 temp_fill = get_absolute_expression ();
2728 else
2729 temp_fill = 0;
2731 if (!need_pass_2)
2732 do_org (segment, &exp, temp_fill);
2734 demand_empty_rest_of_line ();
2737 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2738 called by the obj-format routine which handles section changing
2739 when in MRI mode. It will create a new section, and return it. It
2740 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2741 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2743 void
2744 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2746 #ifdef TC_M68K
2748 char *name;
2749 char c;
2750 segT seg;
2752 SKIP_WHITESPACE ();
2754 name = input_line_pointer;
2755 if (!ISDIGIT (*name))
2756 c = get_symbol_end ();
2757 else
2761 ++input_line_pointer;
2763 while (ISDIGIT (*input_line_pointer));
2765 c = *input_line_pointer;
2766 *input_line_pointer = '\0';
2769 name = xstrdup (name);
2771 *input_line_pointer = c;
2773 seg = subseg_new (name, 0);
2775 if (*input_line_pointer == ',')
2777 int align;
2779 ++input_line_pointer;
2780 align = get_absolute_expression ();
2781 record_alignment (seg, align);
2784 *type = 'C';
2785 if (*input_line_pointer == ',')
2787 c = *++input_line_pointer;
2788 c = TOUPPER (c);
2789 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2790 *type = c;
2791 else
2792 as_bad (_("unrecognized section type"));
2793 ++input_line_pointer;
2796 flagword flags;
2798 flags = SEC_NO_FLAGS;
2799 if (*type == 'C')
2800 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2801 else if (*type == 'D' || *type == 'M')
2802 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2803 else if (*type == 'R')
2804 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2805 if (flags != SEC_NO_FLAGS)
2807 if (!bfd_set_section_flags (stdoutput, seg, flags))
2808 as_warn (_("error setting flags for \"%s\": %s"),
2809 bfd_section_name (stdoutput, seg),
2810 bfd_errmsg (bfd_get_error ()));
2815 /* Ignore the HP type. */
2816 if (*input_line_pointer == ',')
2817 input_line_pointer += 2;
2819 demand_empty_rest_of_line ();
2821 #else /* ! TC_M68K */
2822 #ifdef TC_I960
2824 char *name;
2825 char c;
2826 segT seg;
2828 SKIP_WHITESPACE ();
2830 name = input_line_pointer;
2831 c = get_symbol_end ();
2833 name = xstrdup (name);
2835 *input_line_pointer = c;
2837 seg = subseg_new (name, 0);
2839 if (*input_line_pointer != ',')
2840 *type = 'C';
2841 else
2843 char *sectype;
2845 ++input_line_pointer;
2846 SKIP_WHITESPACE ();
2847 sectype = input_line_pointer;
2848 c = get_symbol_end ();
2849 if (*sectype == '\0')
2850 *type = 'C';
2851 else if (strcasecmp (sectype, "text") == 0)
2852 *type = 'C';
2853 else if (strcasecmp (sectype, "data") == 0)
2854 *type = 'D';
2855 else if (strcasecmp (sectype, "romdata") == 0)
2856 *type = 'R';
2857 else
2858 as_warn (_("unrecognized section type `%s'"), sectype);
2859 *input_line_pointer = c;
2862 if (*input_line_pointer == ',')
2864 char *seccmd;
2866 ++input_line_pointer;
2867 SKIP_WHITESPACE ();
2868 seccmd = input_line_pointer;
2869 c = get_symbol_end ();
2870 if (strcasecmp (seccmd, "absolute") == 0)
2872 as_bad (_("absolute sections are not supported"));
2873 *input_line_pointer = c;
2874 ignore_rest_of_line ();
2875 return;
2877 else if (strcasecmp (seccmd, "align") == 0)
2879 int align;
2881 *input_line_pointer = c;
2882 align = get_absolute_expression ();
2883 record_alignment (seg, align);
2885 else
2887 as_warn (_("unrecognized section command `%s'"), seccmd);
2888 *input_line_pointer = c;
2892 demand_empty_rest_of_line ();
2894 #else /* ! TC_I960 */
2895 /* The MRI assembler seems to use different forms of .sect for
2896 different targets. */
2897 as_bad ("MRI mode not supported for this target");
2898 ignore_rest_of_line ();
2899 #endif /* ! TC_I960 */
2900 #endif /* ! TC_M68K */
2903 /* Handle the .print pseudo-op. */
2905 void
2906 s_print (int ignore ATTRIBUTE_UNUSED)
2908 char *s;
2909 int len;
2911 s = demand_copy_C_string (&len);
2912 if (s != NULL)
2913 printf ("%s\n", s);
2914 demand_empty_rest_of_line ();
2917 /* Handle the .purgem pseudo-op. */
2919 void
2920 s_purgem (int ignore ATTRIBUTE_UNUSED)
2922 if (is_it_end_of_statement ())
2924 demand_empty_rest_of_line ();
2925 return;
2930 char *name;
2931 char c;
2933 SKIP_WHITESPACE ();
2934 name = input_line_pointer;
2935 c = get_symbol_end ();
2936 delete_macro (name);
2937 *input_line_pointer = c;
2938 SKIP_WHITESPACE ();
2940 while (*input_line_pointer++ == ',');
2942 --input_line_pointer;
2943 demand_empty_rest_of_line ();
2946 /* Handle the .endm/.endr pseudo-ops. */
2948 static void
2949 s_bad_end (int endr)
2951 as_warn (_(".end%c encountered without preceeding %s"),
2952 endr ? 'r' : 'm',
2953 endr ? ".rept, .irp, or .irpc" : ".macro");
2954 demand_empty_rest_of_line ();
2957 /* Handle the .rept pseudo-op. */
2959 void
2960 s_rept (int ignore ATTRIBUTE_UNUSED)
2962 int count;
2964 count = get_absolute_expression ();
2966 do_repeat (count, "REPT", "ENDR");
2969 /* This function provides a generic repeat block implementation. It allows
2970 different directives to be used as the start/end keys. */
2972 void
2973 do_repeat (int count, const char *start, const char *end)
2975 sb one;
2976 sb many;
2978 sb_new (&one);
2979 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2981 as_bad (_("%s without %s"), start, end);
2982 return;
2985 sb_new (&many);
2986 while (count-- > 0)
2987 sb_add_sb (&many, &one);
2989 sb_kill (&one);
2991 input_scrub_include_sb (&many, input_line_pointer, 1);
2992 sb_kill (&many);
2993 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2996 /* Like do_repeat except that any text matching EXPANDER in the
2997 block is replaced by the itteration count. */
2999 void
3000 do_repeat_with_expander (int count,
3001 const char * start,
3002 const char * end,
3003 const char * expander)
3005 sb one;
3006 sb many;
3008 sb_new (&one);
3009 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3011 as_bad (_("%s without %s"), start, end);
3012 return;
3015 sb_new (&many);
3017 if (expander != NULL && strstr (one.ptr, expander) != NULL)
3019 while (count -- > 0)
3021 int len;
3022 char * sub;
3023 sb processed;
3025 sb_new (& processed);
3026 sb_add_sb (& processed, & one);
3027 sub = strstr (processed.ptr, expander);
3028 len = sprintf (sub, "%d", count);
3029 gas_assert (len < 8);
3030 strcpy (sub + len, sub + 8);
3031 processed.len -= (8 - len);
3032 sb_add_sb (& many, & processed);
3033 sb_kill (& processed);
3036 else
3037 while (count-- > 0)
3038 sb_add_sb (&many, &one);
3040 sb_kill (&one);
3042 input_scrub_include_sb (&many, input_line_pointer, 1);
3043 sb_kill (&many);
3044 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3047 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3048 input buffers to skip. Assumes that conditionals preceding the loop end
3049 are properly nested.
3051 This function makes it easier to implement a premature "break" out of the
3052 loop. The EXTRA arg accounts for other buffers we might have inserted,
3053 such as line substitutions. */
3055 void
3056 end_repeat (int extra)
3058 cond_exit_macro (macro_nest);
3059 while (extra-- >= 0)
3060 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3063 static void
3064 assign_symbol (char *name, int mode)
3066 symbolS *symbolP;
3068 if (name[0] == '.' && name[1] == '\0')
3070 /* Turn '. = mumble' into a .org mumble. */
3071 segT segment;
3072 expressionS exp;
3074 segment = get_known_segmented_expression (&exp);
3076 if (!need_pass_2)
3077 do_org (segment, &exp, 0);
3079 return;
3082 if ((symbolP = symbol_find (name)) == NULL
3083 && (symbolP = md_undefined_symbol (name)) == NULL)
3085 symbolP = symbol_find_or_make (name);
3086 #ifndef NO_LISTING
3087 /* When doing symbol listings, play games with dummy fragments living
3088 outside the normal fragment chain to record the file and line info
3089 for this symbol. */
3090 if (listing & LISTING_SYMBOLS)
3092 extern struct list_info_struct *listing_tail;
3093 fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3094 dummy_frag->line = listing_tail;
3095 dummy_frag->fr_symbol = symbolP;
3096 symbol_set_frag (symbolP, dummy_frag);
3098 #endif
3099 #ifdef OBJ_COFF
3100 /* "set" symbols are local unless otherwise specified. */
3101 SF_SET_LOCAL (symbolP);
3102 #endif
3105 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3107 /* Permit register names to be redefined. */
3108 if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3109 && S_GET_SEGMENT (symbolP) != reg_section)
3111 as_bad (_("symbol `%s' is already defined"), name);
3112 symbolP = symbol_clone (symbolP, 0);
3114 /* If the symbol is volatile, copy the symbol and replace the
3115 original with the copy, so that previous uses of the symbol will
3116 retain the value of the symbol at the point of use. */
3117 else if (S_IS_VOLATILE (symbolP))
3118 symbolP = symbol_clone (symbolP, 1);
3121 if (mode == 0)
3122 S_SET_VOLATILE (symbolP);
3123 else if (mode < 0)
3124 S_SET_FORWARD_REF (symbolP);
3126 pseudo_set (symbolP);
3129 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3130 then this is .equiv, and it is an error if the symbol is already
3131 defined. If EQUIV is -1, the symbol additionally is a forward
3132 reference. */
3134 void
3135 s_set (int equiv)
3137 char *name;
3138 char delim;
3139 char *end_name;
3141 /* Especial apologies for the random logic:
3142 this just grew, and could be parsed much more simply!
3143 Dean in haste. */
3144 name = input_line_pointer;
3145 delim = get_symbol_end ();
3146 end_name = input_line_pointer;
3147 *end_name = delim;
3149 if (name == end_name)
3151 as_bad (_("expected symbol name"));
3152 ignore_rest_of_line ();
3153 return;
3156 SKIP_WHITESPACE ();
3158 if (*input_line_pointer != ',')
3160 *end_name = 0;
3161 as_bad (_("expected comma after \"%s\""), name);
3162 *end_name = delim;
3163 ignore_rest_of_line ();
3164 return;
3167 input_line_pointer++;
3168 *end_name = 0;
3170 assign_symbol (name, equiv);
3171 *end_name = delim;
3173 demand_empty_rest_of_line ();
3176 void
3177 s_space (int mult)
3179 expressionS exp;
3180 expressionS val;
3181 char *p = 0;
3182 char *stop = NULL;
3183 char stopc = 0;
3184 int bytes;
3186 #ifdef md_flush_pending_output
3187 md_flush_pending_output ();
3188 #endif
3190 #ifdef md_cons_align
3191 md_cons_align (1);
3192 #endif
3194 if (flag_mri)
3195 stop = mri_comment_field (&stopc);
3197 /* In m68k MRI mode, we need to align to a word boundary, unless
3198 this is ds.b. */
3199 if (flag_m68k_mri && mult > 1)
3201 if (now_seg == absolute_section)
3203 abs_section_offset += abs_section_offset & 1;
3204 if (line_label != NULL)
3205 S_SET_VALUE (line_label, abs_section_offset);
3207 else if (mri_common_symbol != NULL)
3209 valueT mri_val;
3211 mri_val = S_GET_VALUE (mri_common_symbol);
3212 if ((mri_val & 1) != 0)
3214 S_SET_VALUE (mri_common_symbol, mri_val + 1);
3215 if (line_label != NULL)
3217 expressionS *symexp;
3219 symexp = symbol_get_value_expression (line_label);
3220 know (symexp->X_op == O_symbol);
3221 know (symexp->X_add_symbol == mri_common_symbol);
3222 symexp->X_add_number += 1;
3226 else
3228 do_align (1, (char *) NULL, 0, 0);
3229 if (line_label != NULL)
3231 symbol_set_frag (line_label, frag_now);
3232 S_SET_VALUE (line_label, frag_now_fix ());
3237 bytes = mult;
3239 expression (&exp);
3241 SKIP_WHITESPACE ();
3242 if (*input_line_pointer == ',')
3244 ++input_line_pointer;
3245 expression (&val);
3247 else
3249 val.X_op = O_constant;
3250 val.X_add_number = 0;
3253 if (val.X_op != O_constant
3254 || val.X_add_number < - 0x80
3255 || val.X_add_number > 0xff
3256 || (mult != 0 && mult != 1 && val.X_add_number != 0))
3258 resolve_expression (&exp);
3259 if (exp.X_op != O_constant)
3260 as_bad (_("unsupported variable size or fill value"));
3261 else
3263 offsetT i;
3265 if (mult == 0)
3266 mult = 1;
3267 bytes = mult * exp.X_add_number;
3268 for (i = 0; i < exp.X_add_number; i++)
3269 emit_expr (&val, mult);
3272 else
3274 if (now_seg == absolute_section || mri_common_symbol != NULL)
3275 resolve_expression (&exp);
3277 if (exp.X_op == O_constant)
3279 offsetT repeat;
3281 repeat = exp.X_add_number;
3282 if (mult)
3283 repeat *= mult;
3284 bytes = repeat;
3285 if (repeat <= 0)
3287 if (!flag_mri)
3288 as_warn (_(".space repeat count is zero, ignored"));
3289 else if (repeat < 0)
3290 as_warn (_(".space repeat count is negative, ignored"));
3291 goto getout;
3294 /* If we are in the absolute section, just bump the offset. */
3295 if (now_seg == absolute_section)
3297 abs_section_offset += repeat;
3298 goto getout;
3301 /* If we are secretly in an MRI common section, then
3302 creating space just increases the size of the common
3303 symbol. */
3304 if (mri_common_symbol != NULL)
3306 S_SET_VALUE (mri_common_symbol,
3307 S_GET_VALUE (mri_common_symbol) + repeat);
3308 goto getout;
3311 if (!need_pass_2)
3312 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3313 (offsetT) repeat, (char *) 0);
3315 else
3317 if (now_seg == absolute_section)
3319 as_bad (_("space allocation too complex in absolute section"));
3320 subseg_set (text_section, 0);
3323 if (mri_common_symbol != NULL)
3325 as_bad (_("space allocation too complex in common section"));
3326 mri_common_symbol = NULL;
3329 if (!need_pass_2)
3330 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3331 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3334 if (p)
3335 *p = val.X_add_number;
3338 getout:
3340 /* In MRI mode, after an odd number of bytes, we must align to an
3341 even word boundary, unless the next instruction is a dc.b, ds.b
3342 or dcb.b. */
3343 if (flag_mri && (bytes & 1) != 0)
3344 mri_pending_align = 1;
3346 demand_empty_rest_of_line ();
3348 if (flag_mri)
3349 mri_comment_end (stop, stopc);
3352 /* This is like s_space, but the value is a floating point number with
3353 the given precision. This is for the MRI dcb.s pseudo-op and
3354 friends. */
3356 void
3357 s_float_space (int float_type)
3359 offsetT count;
3360 int flen;
3361 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3362 char *stop = NULL;
3363 char stopc = 0;
3365 #ifdef md_cons_align
3366 md_cons_align (1);
3367 #endif
3369 if (flag_mri)
3370 stop = mri_comment_field (&stopc);
3372 count = get_absolute_expression ();
3374 SKIP_WHITESPACE ();
3375 if (*input_line_pointer != ',')
3377 as_bad (_("missing value"));
3378 ignore_rest_of_line ();
3379 if (flag_mri)
3380 mri_comment_end (stop, stopc);
3381 return;
3384 ++input_line_pointer;
3386 SKIP_WHITESPACE ();
3388 /* Skip any 0{letter} that may be present. Don't even check if the
3389 * letter is legal. */
3390 if (input_line_pointer[0] == '0'
3391 && ISALPHA (input_line_pointer[1]))
3392 input_line_pointer += 2;
3394 /* Accept :xxxx, where the x's are hex digits, for a floating point
3395 with the exact digits specified. */
3396 if (input_line_pointer[0] == ':')
3398 flen = hex_float (float_type, temp);
3399 if (flen < 0)
3401 ignore_rest_of_line ();
3402 if (flag_mri)
3403 mri_comment_end (stop, stopc);
3404 return;
3407 else
3409 char *err;
3411 err = md_atof (float_type, temp, &flen);
3412 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3413 know (err != NULL || flen > 0);
3414 if (err)
3416 as_bad (_("bad floating literal: %s"), err);
3417 ignore_rest_of_line ();
3418 if (flag_mri)
3419 mri_comment_end (stop, stopc);
3420 return;
3424 while (--count >= 0)
3426 char *p;
3428 p = frag_more (flen);
3429 memcpy (p, temp, (unsigned int) flen);
3432 demand_empty_rest_of_line ();
3434 if (flag_mri)
3435 mri_comment_end (stop, stopc);
3438 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3440 void
3441 s_struct (int ignore ATTRIBUTE_UNUSED)
3443 char *stop = NULL;
3444 char stopc = 0;
3446 if (flag_mri)
3447 stop = mri_comment_field (&stopc);
3448 abs_section_offset = get_absolute_expression ();
3449 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3450 /* The ELF backend needs to know that we are changing sections, so
3451 that .previous works correctly. */
3452 if (IS_ELF)
3453 obj_elf_section_change_hook ();
3454 #endif
3455 subseg_set (absolute_section, 0);
3456 demand_empty_rest_of_line ();
3457 if (flag_mri)
3458 mri_comment_end (stop, stopc);
3461 void
3462 s_text (int ignore ATTRIBUTE_UNUSED)
3464 int temp;
3466 temp = get_absolute_expression ();
3467 subseg_set (text_section, (subsegT) temp);
3468 demand_empty_rest_of_line ();
3469 #ifdef OBJ_VMS
3470 const_flag &= ~IN_DEFAULT_SECTION;
3471 #endif
3474 /* .weakref x, y sets x as an alias to y that, as long as y is not
3475 referenced directly, will cause y to become a weak symbol. */
3476 void
3477 s_weakref (int ignore ATTRIBUTE_UNUSED)
3479 char *name;
3480 char delim;
3481 char *end_name;
3482 symbolS *symbolP;
3483 symbolS *symbolP2;
3484 expressionS exp;
3486 name = input_line_pointer;
3487 delim = get_symbol_end ();
3488 end_name = input_line_pointer;
3490 if (name == end_name)
3492 as_bad (_("expected symbol name"));
3493 *end_name = delim;
3494 ignore_rest_of_line ();
3495 return;
3498 symbolP = symbol_find_or_make (name);
3500 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3502 if (!S_IS_VOLATILE (symbolP))
3504 as_bad (_("symbol `%s' is already defined"), name);
3505 *end_name = delim;
3506 ignore_rest_of_line ();
3507 return;
3509 symbolP = symbol_clone (symbolP, 1);
3510 S_CLEAR_VOLATILE (symbolP);
3513 *end_name = delim;
3515 SKIP_WHITESPACE ();
3517 if (*input_line_pointer != ',')
3519 *end_name = 0;
3520 as_bad (_("expected comma after \"%s\""), name);
3521 *end_name = delim;
3522 ignore_rest_of_line ();
3523 return;
3526 input_line_pointer++;
3528 SKIP_WHITESPACE ();
3530 name = input_line_pointer;
3531 delim = get_symbol_end ();
3532 end_name = input_line_pointer;
3534 if (name == end_name)
3536 as_bad (_("expected symbol name"));
3537 ignore_rest_of_line ();
3538 return;
3541 if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3542 && (symbolP2 = md_undefined_symbol (name)) == NULL)
3544 symbolP2 = symbol_find_or_make (name);
3545 S_SET_WEAKREFD (symbolP2);
3547 else
3549 symbolS *symp = symbolP2;
3551 while (S_IS_WEAKREFR (symp) && symp != symbolP)
3553 expressionS *expP = symbol_get_value_expression (symp);
3555 gas_assert (expP->X_op == O_symbol
3556 && expP->X_add_number == 0);
3557 symp = expP->X_add_symbol;
3559 if (symp == symbolP)
3561 char *loop;
3563 loop = concat (S_GET_NAME (symbolP),
3564 " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3566 symp = symbolP2;
3567 while (symp != symbolP)
3569 char *old_loop = loop;
3570 symp = symbol_get_value_expression (symp)->X_add_symbol;
3571 loop = concat (loop, " => ", S_GET_NAME (symp),
3572 (const char *) NULL);
3573 free (old_loop);
3576 as_bad (_("%s: would close weakref loop: %s"),
3577 S_GET_NAME (symbolP), loop);
3579 free (loop);
3581 *end_name = delim;
3582 ignore_rest_of_line ();
3583 return;
3586 /* Short-circuiting instead of just checking here might speed
3587 things up a tiny little bit, but loop error messages would
3588 miss intermediate links. */
3589 /* symbolP2 = symp; */
3592 *end_name = delim;
3594 memset (&exp, 0, sizeof (exp));
3595 exp.X_op = O_symbol;
3596 exp.X_add_symbol = symbolP2;
3598 S_SET_SEGMENT (symbolP, undefined_section);
3599 symbol_set_value_expression (symbolP, &exp);
3600 symbol_set_frag (symbolP, &zero_address_frag);
3601 S_SET_WEAKREFR (symbolP);
3603 demand_empty_rest_of_line ();
3607 /* Verify that we are at the end of a line. If not, issue an error and
3608 skip to EOL. */
3610 void
3611 demand_empty_rest_of_line (void)
3613 SKIP_WHITESPACE ();
3614 if (is_end_of_line[(unsigned char) *input_line_pointer])
3615 input_line_pointer++;
3616 else
3618 if (ISPRINT (*input_line_pointer))
3619 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3620 *input_line_pointer);
3621 else
3622 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3623 *input_line_pointer);
3624 ignore_rest_of_line ();
3627 /* Return pointing just after end-of-line. */
3628 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3631 /* Silently advance to the end of line. Use this after already having
3632 issued an error about something bad. */
3634 void
3635 ignore_rest_of_line (void)
3637 while (input_line_pointer < buffer_limit
3638 && !is_end_of_line[(unsigned char) *input_line_pointer])
3639 input_line_pointer++;
3641 input_line_pointer++;
3643 /* Return pointing just after end-of-line. */
3644 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3647 /* Sets frag for given symbol to zero_address_frag, except when the
3648 symbol frag is already set to a dummy listing frag. */
3650 static void
3651 set_zero_frag (symbolS *symbolP)
3653 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3654 symbol_set_frag (symbolP, &zero_address_frag);
3657 /* In: Pointer to a symbol.
3658 Input_line_pointer->expression.
3660 Out: Input_line_pointer->just after any whitespace after expression.
3661 Tried to set symbol to value of expression.
3662 Will change symbols type, value, and frag; */
3664 void
3665 pseudo_set (symbolS *symbolP)
3667 expressionS exp;
3668 segT seg;
3670 know (symbolP); /* NULL pointer is logic error. */
3672 if (!S_IS_FORWARD_REF (symbolP))
3673 (void) expression (&exp);
3674 else
3675 (void) deferred_expression (&exp);
3677 if (exp.X_op == O_illegal)
3678 as_bad (_("illegal expression"));
3679 else if (exp.X_op == O_absent)
3680 as_bad (_("missing expression"));
3681 else if (exp.X_op == O_big)
3683 if (exp.X_add_number > 0)
3684 as_bad (_("bignum invalid"));
3685 else
3686 as_bad (_("floating point number invalid"));
3688 else if (exp.X_op == O_subtract
3689 && !S_IS_FORWARD_REF (symbolP)
3690 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3691 && (symbol_get_frag (exp.X_add_symbol)
3692 == symbol_get_frag (exp.X_op_symbol)))
3694 exp.X_op = O_constant;
3695 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3696 - S_GET_VALUE (exp.X_op_symbol));
3699 if (symbol_section_p (symbolP))
3701 as_bad ("attempt to set value of section symbol");
3702 return;
3705 switch (exp.X_op)
3707 case O_illegal:
3708 case O_absent:
3709 case O_big:
3710 exp.X_add_number = 0;
3711 /* Fall through. */
3712 case O_constant:
3713 S_SET_SEGMENT (symbolP, absolute_section);
3714 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3715 set_zero_frag (symbolP);
3716 break;
3718 case O_register:
3719 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3720 if (S_IS_EXTERNAL (symbolP))
3722 as_bad ("can't equate global symbol `%s' with register name",
3723 S_GET_NAME (symbolP));
3724 return;
3726 #endif
3727 S_SET_SEGMENT (symbolP, reg_section);
3728 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3729 set_zero_frag (symbolP);
3730 symbol_get_value_expression (symbolP)->X_op = O_register;
3731 break;
3733 case O_symbol:
3734 seg = S_GET_SEGMENT (exp.X_add_symbol);
3735 /* For x=undef+const, create an expression symbol.
3736 For x=x+const, just update x except when x is an undefined symbol
3737 For x=defined+const, evaluate x. */
3738 if (symbolP == exp.X_add_symbol
3739 && (seg != undefined_section
3740 || !symbol_constant_p (symbolP)))
3742 *symbol_X_add_number (symbolP) += exp.X_add_number;
3743 break;
3745 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3747 symbolS *s = exp.X_add_symbol;
3749 if (S_IS_COMMON (s))
3750 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3751 S_GET_NAME (symbolP), S_GET_NAME (s));
3753 S_SET_SEGMENT (symbolP, seg);
3754 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3755 symbol_set_frag (symbolP, symbol_get_frag (s));
3756 copy_symbol_attributes (symbolP, s);
3757 break;
3759 S_SET_SEGMENT (symbolP, undefined_section);
3760 symbol_set_value_expression (symbolP, &exp);
3761 copy_symbol_attributes (symbolP, exp.X_add_symbol);
3762 set_zero_frag (symbolP);
3763 break;
3765 default:
3766 /* The value is some complex expression. */
3767 S_SET_SEGMENT (symbolP, expr_section);
3768 symbol_set_value_expression (symbolP, &exp);
3769 set_zero_frag (symbolP);
3770 break;
3774 /* cons()
3776 CONStruct more frag of .bytes, or .words etc.
3777 Should need_pass_2 be 1 then emit no frag(s).
3778 This understands EXPRESSIONS.
3780 Bug (?)
3782 This has a split personality. We use expression() to read the
3783 value. We can detect if the value won't fit in a byte or word.
3784 But we can't detect if expression() discarded significant digits
3785 in the case of a long. Not worth the crocks required to fix it. */
3787 /* Select a parser for cons expressions. */
3789 /* Some targets need to parse the expression in various fancy ways.
3790 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3791 (for example, the HPPA does this). Otherwise, you can define
3792 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3793 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3794 are defined, which is the normal case, then only simple expressions
3795 are permitted. */
3797 #ifdef TC_M68K
3798 static void
3799 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3800 #endif
3802 #ifndef TC_PARSE_CONS_EXPRESSION
3803 #ifdef BITFIELD_CONS_EXPRESSIONS
3804 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3805 static void
3806 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3807 #endif
3808 #ifdef REPEAT_CONS_EXPRESSIONS
3809 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3810 static void
3811 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3812 #endif
3814 /* If we haven't gotten one yet, just call expression. */
3815 #ifndef TC_PARSE_CONS_EXPRESSION
3816 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3817 #endif
3818 #endif
3820 void
3821 do_parse_cons_expression (expressionS *exp,
3822 int nbytes ATTRIBUTE_UNUSED)
3824 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3828 /* Worker to do .byte etc statements.
3829 Clobbers input_line_pointer and checks end-of-line. */
3831 static void
3832 cons_worker (int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3833 int rva)
3835 int c;
3836 expressionS exp;
3837 char *stop = NULL;
3838 char stopc = 0;
3840 #ifdef md_flush_pending_output
3841 md_flush_pending_output ();
3842 #endif
3844 if (flag_mri)
3845 stop = mri_comment_field (&stopc);
3847 if (is_it_end_of_statement ())
3849 demand_empty_rest_of_line ();
3850 if (flag_mri)
3851 mri_comment_end (stop, stopc);
3852 return;
3855 #ifdef TC_ADDRESS_BYTES
3856 if (nbytes == 0)
3857 nbytes = TC_ADDRESS_BYTES ();
3858 #endif
3860 #ifdef md_cons_align
3861 md_cons_align (nbytes);
3862 #endif
3864 c = 0;
3867 #ifdef TC_M68K
3868 if (flag_m68k_mri)
3869 parse_mri_cons (&exp, (unsigned int) nbytes);
3870 else
3871 #endif
3873 if (*input_line_pointer == '"')
3875 as_bad (_("unexpected `\"' in expression"));
3876 ignore_rest_of_line ();
3877 return;
3879 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3882 if (rva)
3884 if (exp.X_op == O_symbol)
3885 exp.X_op = O_symbol_rva;
3886 else
3887 as_fatal (_("rva without symbol"));
3889 emit_expr (&exp, (unsigned int) nbytes);
3890 ++c;
3892 while (*input_line_pointer++ == ',');
3894 /* In MRI mode, after an odd number of bytes, we must align to an
3895 even word boundary, unless the next instruction is a dc.b, ds.b
3896 or dcb.b. */
3897 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3898 mri_pending_align = 1;
3900 input_line_pointer--; /* Put terminator back into stream. */
3902 demand_empty_rest_of_line ();
3904 if (flag_mri)
3905 mri_comment_end (stop, stopc);
3908 void
3909 cons (int size)
3911 cons_worker (size, 0);
3914 void
3915 s_rva (int size)
3917 cons_worker (size, 1);
3920 /* .reloc offset, reloc_name, symbol+addend. */
3922 void
3923 s_reloc (int ignore ATTRIBUTE_UNUSED)
3925 char *stop = NULL;
3926 char stopc = 0;
3927 expressionS exp;
3928 char *r_name;
3929 int c;
3930 struct reloc_list *reloc;
3932 reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
3934 if (flag_mri)
3935 stop = mri_comment_field (&stopc);
3937 expression (&exp);
3938 switch (exp.X_op)
3940 case O_illegal:
3941 case O_absent:
3942 case O_big:
3943 case O_register:
3944 as_bad (_("missing or bad offset expression"));
3945 goto err_out;
3946 case O_constant:
3947 exp.X_add_symbol = section_symbol (now_seg);
3948 exp.X_op = O_symbol;
3949 /* Fall thru */
3950 case O_symbol:
3951 if (exp.X_add_number == 0)
3953 reloc->u.a.offset_sym = exp.X_add_symbol;
3954 break;
3956 /* Fall thru */
3957 default:
3958 reloc->u.a.offset_sym = make_expr_symbol (&exp);
3959 break;
3962 SKIP_WHITESPACE ();
3963 if (*input_line_pointer != ',')
3965 as_bad (_("missing reloc type"));
3966 goto err_out;
3969 ++input_line_pointer;
3970 SKIP_WHITESPACE ();
3971 r_name = input_line_pointer;
3972 c = get_symbol_end ();
3973 reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3974 *input_line_pointer = c;
3975 if (reloc->u.a.howto == NULL)
3977 as_bad (_("unrecognized reloc type"));
3978 goto err_out;
3981 exp.X_op = O_absent;
3982 SKIP_WHITESPACE ();
3983 if (*input_line_pointer == ',')
3985 ++input_line_pointer;
3986 expression (&exp);
3988 switch (exp.X_op)
3990 case O_illegal:
3991 case O_big:
3992 case O_register:
3993 as_bad (_("bad reloc expression"));
3994 err_out:
3995 ignore_rest_of_line ();
3996 free (reloc);
3997 if (flag_mri)
3998 mri_comment_end (stop, stopc);
3999 return;
4000 case O_absent:
4001 reloc->u.a.sym = NULL;
4002 reloc->u.a.addend = 0;
4003 break;
4004 case O_constant:
4005 reloc->u.a.sym = NULL;
4006 reloc->u.a.addend = exp.X_add_number;
4007 break;
4008 case O_symbol:
4009 reloc->u.a.sym = exp.X_add_symbol;
4010 reloc->u.a.addend = exp.X_add_number;
4011 break;
4012 default:
4013 reloc->u.a.sym = make_expr_symbol (&exp);
4014 reloc->u.a.addend = 0;
4015 break;
4018 as_where (&reloc->file, &reloc->line);
4019 reloc->next = reloc_list;
4020 reloc_list = reloc;
4022 demand_empty_rest_of_line ();
4023 if (flag_mri)
4024 mri_comment_end (stop, stopc);
4027 /* Put the contents of expression EXP into the object file using
4028 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4030 void
4031 emit_expr (expressionS *exp, unsigned int nbytes)
4033 operatorT op;
4034 char *p;
4035 valueT extra_digit = 0;
4037 /* Don't do anything if we are going to make another pass. */
4038 if (need_pass_2)
4039 return;
4041 /* Grow the current frag now so that dot_value does not get invalidated
4042 if the frag were to fill up in the frag_more() call below. */
4043 frag_grow (nbytes);
4044 dot_value = frag_now_fix ();
4046 #ifndef NO_LISTING
4047 #ifdef OBJ_ELF
4048 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4049 appear as a four byte positive constant in the .line section,
4050 followed by a 2 byte 0xffff. Look for that case here. */
4052 static int dwarf_line = -1;
4054 if (strcmp (segment_name (now_seg), ".line") != 0)
4055 dwarf_line = -1;
4056 else if (dwarf_line >= 0
4057 && nbytes == 2
4058 && exp->X_op == O_constant
4059 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4060 listing_source_line ((unsigned int) dwarf_line);
4061 else if (nbytes == 4
4062 && exp->X_op == O_constant
4063 && exp->X_add_number >= 0)
4064 dwarf_line = exp->X_add_number;
4065 else
4066 dwarf_line = -1;
4069 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4070 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4071 AT_sibling (0x12) followed by a four byte address of the sibling
4072 followed by a 2 byte AT_name (0x38) followed by the name of the
4073 file. We look for that case here. */
4075 static int dwarf_file = 0;
4077 if (strcmp (segment_name (now_seg), ".debug") != 0)
4078 dwarf_file = 0;
4079 else if (dwarf_file == 0
4080 && nbytes == 2
4081 && exp->X_op == O_constant
4082 && exp->X_add_number == 0x11)
4083 dwarf_file = 1;
4084 else if (dwarf_file == 1
4085 && nbytes == 2
4086 && exp->X_op == O_constant
4087 && exp->X_add_number == 0x12)
4088 dwarf_file = 2;
4089 else if (dwarf_file == 2
4090 && nbytes == 4)
4091 dwarf_file = 3;
4092 else if (dwarf_file == 3
4093 && nbytes == 2
4094 && exp->X_op == O_constant
4095 && exp->X_add_number == 0x38)
4096 dwarf_file = 4;
4097 else
4098 dwarf_file = 0;
4100 /* The variable dwarf_file_string tells stringer that the string
4101 may be the name of the source file. */
4102 if (dwarf_file == 4)
4103 dwarf_file_string = 1;
4104 else
4105 dwarf_file_string = 0;
4107 #endif
4108 #endif
4110 if (check_eh_frame (exp, &nbytes))
4111 return;
4113 op = exp->X_op;
4115 /* Allow `.word 0' in the absolute section. */
4116 if (now_seg == absolute_section)
4118 if (op != O_constant || exp->X_add_number != 0)
4119 as_bad (_("attempt to store value in absolute section"));
4120 abs_section_offset += nbytes;
4121 return;
4124 /* Handle a negative bignum. */
4125 if (op == O_uminus
4126 && exp->X_add_number == 0
4127 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4128 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4130 int i;
4131 unsigned long carry;
4133 exp = symbol_get_value_expression (exp->X_add_symbol);
4135 /* Negate the bignum: one's complement each digit and add 1. */
4136 carry = 1;
4137 for (i = 0; i < exp->X_add_number; i++)
4139 unsigned long next;
4141 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4142 & LITTLENUM_MASK)
4143 + carry);
4144 generic_bignum[i] = next & LITTLENUM_MASK;
4145 carry = next >> LITTLENUM_NUMBER_OF_BITS;
4148 /* We can ignore any carry out, because it will be handled by
4149 extra_digit if it is needed. */
4151 extra_digit = (valueT) -1;
4152 op = O_big;
4155 if (op == O_absent || op == O_illegal)
4157 as_warn (_("zero assumed for missing expression"));
4158 exp->X_add_number = 0;
4159 op = O_constant;
4161 else if (op == O_big && exp->X_add_number <= 0)
4163 as_bad (_("floating point number invalid"));
4164 exp->X_add_number = 0;
4165 op = O_constant;
4167 else if (op == O_register)
4169 as_warn (_("register value used as expression"));
4170 op = O_constant;
4173 p = frag_more ((int) nbytes);
4175 #ifndef WORKING_DOT_WORD
4176 /* If we have the difference of two symbols in a word, save it on
4177 the broken_words list. See the code in write.c. */
4178 if (op == O_subtract && nbytes == 2)
4180 struct broken_word *x;
4182 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4183 x->next_broken_word = broken_words;
4184 broken_words = x;
4185 x->seg = now_seg;
4186 x->subseg = now_subseg;
4187 x->frag = frag_now;
4188 x->word_goes_here = p;
4189 x->dispfrag = 0;
4190 x->add = exp->X_add_symbol;
4191 x->sub = exp->X_op_symbol;
4192 x->addnum = exp->X_add_number;
4193 x->added = 0;
4194 x->use_jump = 0;
4195 new_broken_words++;
4196 return;
4198 #endif
4200 /* If we have an integer, but the number of bytes is too large to
4201 pass to md_number_to_chars, handle it as a bignum. */
4202 if (op == O_constant && nbytes > sizeof (valueT))
4204 extra_digit = exp->X_unsigned ? 0 : -1;
4205 convert_to_bignum (exp);
4206 op = O_big;
4209 if (op == O_constant)
4211 valueT get;
4212 valueT use;
4213 valueT mask;
4214 valueT hibit;
4215 valueT unmask;
4217 /* JF << of >= number of bits in the object is undefined. In
4218 particular SPARC (Sun 4) has problems. */
4219 if (nbytes >= sizeof (valueT))
4221 mask = 0;
4222 if (nbytes > sizeof (valueT))
4223 hibit = 0;
4224 else
4225 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4227 else
4229 /* Don't store these bits. */
4230 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4231 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4234 unmask = ~mask; /* Do store these bits. */
4236 #ifdef NEVER
4237 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4238 mask = ~(unmask >> 1); /* Includes sign bit now. */
4239 #endif
4241 get = exp->X_add_number;
4242 use = get & unmask;
4243 if ((get & mask) != 0
4244 && ((get & mask) != mask
4245 || (get & hibit) == 0))
4246 { /* Leading bits contain both 0s & 1s. */
4247 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4248 #ifndef __MSVCRT__
4249 as_warn (_("value 0x%llx truncated to 0x%llx"),
4250 (unsigned long long) get, (unsigned long long) use);
4251 #else
4252 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4253 (unsigned long long) get, (unsigned long long) use);
4254 #endif
4255 #else
4256 as_warn (_("value 0x%lx truncated to 0x%lx"),
4257 (unsigned long) get, (unsigned long) use);
4258 #endif
4260 /* Put bytes in right order. */
4261 md_number_to_chars (p, use, (int) nbytes);
4263 else if (op == O_big)
4265 unsigned int size;
4266 LITTLENUM_TYPE *nums;
4268 size = exp->X_add_number * CHARS_PER_LITTLENUM;
4269 if (nbytes < size)
4271 int i = nbytes / CHARS_PER_LITTLENUM;
4272 if (i != 0)
4274 LITTLENUM_TYPE sign = 0;
4275 if ((generic_bignum[--i]
4276 & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
4277 sign = ~(LITTLENUM_TYPE) 0;
4278 while (++i < exp->X_add_number)
4279 if (generic_bignum[i] != sign)
4280 break;
4282 if (i < exp->X_add_number)
4283 as_warn (_("bignum truncated to %d bytes"), nbytes);
4284 size = nbytes;
4287 if (nbytes == 1)
4289 md_number_to_chars (p, (valueT) generic_bignum[0], 1);
4290 return;
4292 know (nbytes % CHARS_PER_LITTLENUM == 0);
4294 if (target_big_endian)
4296 while (nbytes > size)
4298 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4299 nbytes -= CHARS_PER_LITTLENUM;
4300 p += CHARS_PER_LITTLENUM;
4303 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4304 while (size >= CHARS_PER_LITTLENUM)
4306 --nums;
4307 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4308 size -= CHARS_PER_LITTLENUM;
4309 p += CHARS_PER_LITTLENUM;
4312 else
4314 nums = generic_bignum;
4315 while (size >= CHARS_PER_LITTLENUM)
4317 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4318 ++nums;
4319 size -= CHARS_PER_LITTLENUM;
4320 p += CHARS_PER_LITTLENUM;
4321 nbytes -= CHARS_PER_LITTLENUM;
4324 while (nbytes >= CHARS_PER_LITTLENUM)
4326 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4327 nbytes -= CHARS_PER_LITTLENUM;
4328 p += CHARS_PER_LITTLENUM;
4332 else
4333 emit_expr_fix (exp, nbytes, frag_now, p);
4336 void
4337 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4339 memset (p, 0, nbytes);
4341 /* Generate a fixS to record the symbol value. */
4343 #ifdef TC_CONS_FIX_NEW
4344 TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4345 #else
4347 bfd_reloc_code_real_type r;
4349 switch (nbytes)
4351 case 1:
4352 r = BFD_RELOC_8;
4353 break;
4354 case 2:
4355 r = BFD_RELOC_16;
4356 break;
4357 case 3:
4358 r = BFD_RELOC_24;
4359 break;
4360 case 4:
4361 r = BFD_RELOC_32;
4362 break;
4363 case 8:
4364 r = BFD_RELOC_64;
4365 break;
4366 default:
4367 as_bad (_("unsupported BFD relocation size %u"), nbytes);
4368 r = BFD_RELOC_32;
4369 break;
4371 fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4372 0, r);
4374 #endif
4377 #ifdef BITFIELD_CONS_EXPRESSIONS
4379 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4380 w:x,y:z, where w and y are bitwidths and x and y are values. They
4381 then pack them all together. We do a little better in that we allow
4382 them in words, longs, etc. and we'll pack them in target byte order
4383 for you.
4385 The rules are: pack least significant bit first, if a field doesn't
4386 entirely fit, put it in the next unit. Overflowing the bitfield is
4387 explicitly *not* even a warning. The bitwidth should be considered
4388 a "mask".
4390 To use this function the tc-XXX.h file should define
4391 BITFIELD_CONS_EXPRESSIONS. */
4393 static void
4394 parse_bitfield_cons (exp, nbytes)
4395 expressionS *exp;
4396 unsigned int nbytes;
4398 unsigned int bits_available = BITS_PER_CHAR * nbytes;
4399 char *hold = input_line_pointer;
4401 (void) expression (exp);
4403 if (*input_line_pointer == ':')
4405 /* Bitfields. */
4406 long value = 0;
4408 for (;;)
4410 unsigned long width;
4412 if (*input_line_pointer != ':')
4414 input_line_pointer = hold;
4415 break;
4416 } /* Next piece is not a bitfield. */
4418 /* In the general case, we can't allow
4419 full expressions with symbol
4420 differences and such. The relocation
4421 entries for symbols not defined in this
4422 assembly would require arbitrary field
4423 widths, positions, and masks which most
4424 of our current object formats don't
4425 support.
4427 In the specific case where a symbol
4428 *is* defined in this assembly, we
4429 *could* build fixups and track it, but
4430 this could lead to confusion for the
4431 backends. I'm lazy. I'll take any
4432 SEG_ABSOLUTE. I think that means that
4433 you can use a previous .set or
4434 .equ type symbol. xoxorich. */
4436 if (exp->X_op == O_absent)
4438 as_warn (_("using a bit field width of zero"));
4439 exp->X_add_number = 0;
4440 exp->X_op = O_constant;
4441 } /* Implied zero width bitfield. */
4443 if (exp->X_op != O_constant)
4445 *input_line_pointer = '\0';
4446 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4447 *input_line_pointer = ':';
4448 demand_empty_rest_of_line ();
4449 return;
4450 } /* Too complex. */
4452 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4454 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4455 width, nbytes, (BITS_PER_CHAR * nbytes));
4456 width = BITS_PER_CHAR * nbytes;
4457 } /* Too big. */
4459 if (width > bits_available)
4461 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4462 input_line_pointer = hold;
4463 exp->X_add_number = value;
4464 break;
4465 } /* Won't fit. */
4467 /* Skip ':'. */
4468 hold = ++input_line_pointer;
4470 (void) expression (exp);
4471 if (exp->X_op != O_constant)
4473 char cache = *input_line_pointer;
4475 *input_line_pointer = '\0';
4476 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4477 *input_line_pointer = cache;
4478 demand_empty_rest_of_line ();
4479 return;
4480 } /* Too complex. */
4482 value |= ((~(-1 << width) & exp->X_add_number)
4483 << ((BITS_PER_CHAR * nbytes) - bits_available));
4485 if ((bits_available -= width) == 0
4486 || is_it_end_of_statement ()
4487 || *input_line_pointer != ',')
4489 break;
4490 } /* All the bitfields we're gonna get. */
4492 hold = ++input_line_pointer;
4493 (void) expression (exp);
4496 exp->X_add_number = value;
4497 exp->X_op = O_constant;
4498 exp->X_unsigned = 1;
4502 #endif /* BITFIELD_CONS_EXPRESSIONS */
4504 /* Handle an MRI style string expression. */
4506 #ifdef TC_M68K
4507 static void
4508 parse_mri_cons (exp, nbytes)
4509 expressionS *exp;
4510 unsigned int nbytes;
4512 if (*input_line_pointer != '\''
4513 && (input_line_pointer[1] != '\''
4514 || (*input_line_pointer != 'A'
4515 && *input_line_pointer != 'E')))
4516 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4517 else
4519 unsigned int scan;
4520 unsigned int result = 0;
4522 /* An MRI style string. Cut into as many bytes as will fit into
4523 a nbyte chunk, left justify if necessary, and separate with
4524 commas so we can try again later. */
4525 if (*input_line_pointer == 'A')
4526 ++input_line_pointer;
4527 else if (*input_line_pointer == 'E')
4529 as_bad (_("EBCDIC constants are not supported"));
4530 ++input_line_pointer;
4533 input_line_pointer++;
4534 for (scan = 0; scan < nbytes; scan++)
4536 if (*input_line_pointer == '\'')
4538 if (input_line_pointer[1] == '\'')
4540 input_line_pointer++;
4542 else
4543 break;
4545 result = (result << 8) | (*input_line_pointer++);
4548 /* Left justify. */
4549 while (scan < nbytes)
4551 result <<= 8;
4552 scan++;
4555 /* Create correct expression. */
4556 exp->X_op = O_constant;
4557 exp->X_add_number = result;
4559 /* Fake it so that we can read the next char too. */
4560 if (input_line_pointer[0] != '\'' ||
4561 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4563 input_line_pointer -= 2;
4564 input_line_pointer[0] = ',';
4565 input_line_pointer[1] = '\'';
4567 else
4568 input_line_pointer++;
4571 #endif /* TC_M68K */
4573 #ifdef REPEAT_CONS_EXPRESSIONS
4575 /* Parse a repeat expression for cons. This is used by the MIPS
4576 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4577 object file COUNT times.
4579 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4581 static void
4582 parse_repeat_cons (exp, nbytes)
4583 expressionS *exp;
4584 unsigned int nbytes;
4586 expressionS count;
4587 int i;
4589 expression (exp);
4591 if (*input_line_pointer != ':')
4593 /* No repeat count. */
4594 return;
4597 ++input_line_pointer;
4598 expression (&count);
4599 if (count.X_op != O_constant
4600 || count.X_add_number <= 0)
4602 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4603 return;
4606 /* The cons function is going to output this expression once. So we
4607 output it count - 1 times. */
4608 for (i = count.X_add_number - 1; i > 0; i--)
4609 emit_expr (exp, nbytes);
4612 #endif /* REPEAT_CONS_EXPRESSIONS */
4614 /* Parse a floating point number represented as a hex constant. This
4615 permits users to specify the exact bits they want in the floating
4616 point number. */
4618 static int
4619 hex_float (int float_type, char *bytes)
4621 int length;
4622 int i;
4624 switch (float_type)
4626 case 'f':
4627 case 'F':
4628 case 's':
4629 case 'S':
4630 length = 4;
4631 break;
4633 case 'd':
4634 case 'D':
4635 case 'r':
4636 case 'R':
4637 length = 8;
4638 break;
4640 case 'x':
4641 case 'X':
4642 length = 12;
4643 break;
4645 case 'p':
4646 case 'P':
4647 length = 12;
4648 break;
4650 default:
4651 as_bad (_("unknown floating type type '%c'"), float_type);
4652 return -1;
4655 /* It would be nice if we could go through expression to parse the
4656 hex constant, but if we get a bignum it's a pain to sort it into
4657 the buffer correctly. */
4658 i = 0;
4659 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4661 int d;
4663 /* The MRI assembler accepts arbitrary underscores strewn about
4664 through the hex constant, so we ignore them as well. */
4665 if (*input_line_pointer == '_')
4667 ++input_line_pointer;
4668 continue;
4671 if (i >= length)
4673 as_warn (_("floating point constant too large"));
4674 return -1;
4676 d = hex_value (*input_line_pointer) << 4;
4677 ++input_line_pointer;
4678 while (*input_line_pointer == '_')
4679 ++input_line_pointer;
4680 if (hex_p (*input_line_pointer))
4682 d += hex_value (*input_line_pointer);
4683 ++input_line_pointer;
4685 if (target_big_endian)
4686 bytes[i] = d;
4687 else
4688 bytes[length - i - 1] = d;
4689 ++i;
4692 if (i < length)
4694 if (target_big_endian)
4695 memset (bytes + i, 0, length - i);
4696 else
4697 memset (bytes, 0, length - i);
4700 return length;
4703 /* float_cons()
4705 CONStruct some more frag chars of .floats .ffloats etc.
4706 Makes 0 or more new frags.
4707 If need_pass_2 == 1, no frags are emitted.
4708 This understands only floating literals, not expressions. Sorry.
4710 A floating constant is defined by atof_generic(), except it is preceded
4711 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4712 reading, I decided to be incompatible. This always tries to give you
4713 rounded bits to the precision of the pseudo-op. Former AS did premature
4714 truncation, restored noisy bits instead of trailing 0s AND gave you
4715 a choice of 2 flavours of noise according to which of 2 floating-point
4716 scanners you directed AS to use.
4718 In: input_line_pointer->whitespace before, or '0' of flonum. */
4720 void
4721 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4722 int float_type /* 'f':.ffloat ... 'F':.float ... */)
4724 char *p;
4725 int length; /* Number of chars in an object. */
4726 char *err; /* Error from scanning floating literal. */
4727 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4729 if (is_it_end_of_statement ())
4731 demand_empty_rest_of_line ();
4732 return;
4735 #ifdef md_flush_pending_output
4736 md_flush_pending_output ();
4737 #endif
4739 #ifdef md_cons_align
4740 md_cons_align (1);
4741 #endif
4745 /* input_line_pointer->1st char of a flonum (we hope!). */
4746 SKIP_WHITESPACE ();
4748 /* Skip any 0{letter} that may be present. Don't even check if the
4749 letter is legal. Someone may invent a "z" format and this routine
4750 has no use for such information. Lusers beware: you get
4751 diagnostics if your input is ill-conditioned. */
4752 if (input_line_pointer[0] == '0'
4753 && ISALPHA (input_line_pointer[1]))
4754 input_line_pointer += 2;
4756 /* Accept :xxxx, where the x's are hex digits, for a floating
4757 point with the exact digits specified. */
4758 if (input_line_pointer[0] == ':')
4760 ++input_line_pointer;
4761 length = hex_float (float_type, temp);
4762 if (length < 0)
4764 ignore_rest_of_line ();
4765 return;
4768 else
4770 err = md_atof (float_type, temp, &length);
4771 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4772 know (err != NULL || length > 0);
4773 if (err)
4775 as_bad (_("bad floating literal: %s"), err);
4776 ignore_rest_of_line ();
4777 return;
4781 if (!need_pass_2)
4783 int count;
4785 count = 1;
4787 #ifdef REPEAT_CONS_EXPRESSIONS
4788 if (*input_line_pointer == ':')
4790 expressionS count_exp;
4792 ++input_line_pointer;
4793 expression (&count_exp);
4795 if (count_exp.X_op != O_constant
4796 || count_exp.X_add_number <= 0)
4797 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4798 else
4799 count = count_exp.X_add_number;
4801 #endif
4803 while (--count >= 0)
4805 p = frag_more (length);
4806 memcpy (p, temp, (unsigned int) length);
4809 SKIP_WHITESPACE ();
4811 while (*input_line_pointer++ == ',');
4813 /* Put terminator back into stream. */
4814 --input_line_pointer;
4815 demand_empty_rest_of_line ();
4818 /* Return the size of a LEB128 value. */
4820 static inline int
4821 sizeof_sleb128 (offsetT value)
4823 int size = 0;
4824 unsigned byte;
4828 byte = (value & 0x7f);
4829 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4830 Fortunately, we can structure things so that the extra work reduces
4831 to a noop on systems that do things "properly". */
4832 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4833 size += 1;
4835 while (!(((value == 0) && ((byte & 0x40) == 0))
4836 || ((value == -1) && ((byte & 0x40) != 0))));
4838 return size;
4841 static inline int
4842 sizeof_uleb128 (valueT value)
4844 int size = 0;
4848 value >>= 7;
4849 size += 1;
4851 while (value != 0);
4853 return size;
4857 sizeof_leb128 (valueT value, int sign)
4859 if (sign)
4860 return sizeof_sleb128 ((offsetT) value);
4861 else
4862 return sizeof_uleb128 (value);
4865 /* Output a LEB128 value. */
4867 static inline int
4868 output_sleb128 (char *p, offsetT value)
4870 char *orig = p;
4871 int more;
4875 unsigned byte = (value & 0x7f);
4877 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4878 Fortunately, we can structure things so that the extra work reduces
4879 to a noop on systems that do things "properly". */
4880 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4882 more = !((((value == 0) && ((byte & 0x40) == 0))
4883 || ((value == -1) && ((byte & 0x40) != 0))));
4884 if (more)
4885 byte |= 0x80;
4887 *p++ = byte;
4889 while (more);
4891 return p - orig;
4894 static inline int
4895 output_uleb128 (char *p, valueT value)
4897 char *orig = p;
4901 unsigned byte = (value & 0x7f);
4902 value >>= 7;
4903 if (value != 0)
4904 /* More bytes to follow. */
4905 byte |= 0x80;
4907 *p++ = byte;
4909 while (value != 0);
4911 return p - orig;
4915 output_leb128 (char *p, valueT value, int sign)
4917 if (sign)
4918 return output_sleb128 (p, (offsetT) value);
4919 else
4920 return output_uleb128 (p, value);
4923 /* Do the same for bignums. We combine sizeof with output here in that
4924 we don't output for NULL values of P. It isn't really as critical as
4925 for "normal" values that this be streamlined. */
4927 static inline int
4928 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4930 char *orig = p;
4931 valueT val = 0;
4932 int loaded = 0;
4933 unsigned byte;
4935 /* Strip leading sign extensions off the bignum. */
4936 while (size > 1
4937 && bignum[size - 1] == LITTLENUM_MASK
4938 && bignum[size - 2] > LITTLENUM_MASK / 2)
4939 size--;
4943 /* OR in the next part of the littlenum. */
4944 val |= (*bignum << loaded);
4945 loaded += LITTLENUM_NUMBER_OF_BITS;
4946 size--;
4947 bignum++;
4949 /* Add bytes until there are less than 7 bits left in VAL
4950 or until every non-sign bit has been written. */
4953 byte = val & 0x7f;
4954 loaded -= 7;
4955 val >>= 7;
4956 if (size > 0
4957 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4958 byte |= 0x80;
4960 if (orig)
4961 *p = byte;
4962 p++;
4964 while ((byte & 0x80) != 0 && loaded >= 7);
4966 while (size > 0);
4968 /* Mop up any left-over bits (of which there will be less than 7). */
4969 if ((byte & 0x80) != 0)
4971 /* Sign-extend VAL. */
4972 if (val & (1 << (loaded - 1)))
4973 val |= ~0 << loaded;
4974 if (orig)
4975 *p = val & 0x7f;
4976 p++;
4979 return p - orig;
4982 static inline int
4983 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4985 char *orig = p;
4986 valueT val = 0;
4987 int loaded = 0;
4988 unsigned byte;
4990 /* Strip leading zeros off the bignum. */
4991 /* XXX: Is this needed? */
4992 while (size > 0 && bignum[size - 1] == 0)
4993 size--;
4997 if (loaded < 7 && size > 0)
4999 val |= (*bignum << loaded);
5000 loaded += 8 * CHARS_PER_LITTLENUM;
5001 size--;
5002 bignum++;
5005 byte = val & 0x7f;
5006 loaded -= 7;
5007 val >>= 7;
5009 if (size > 0 || val)
5010 byte |= 0x80;
5012 if (orig)
5013 *p = byte;
5014 p++;
5016 while (byte & 0x80);
5018 return p - orig;
5021 static int
5022 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
5024 if (sign)
5025 return output_big_sleb128 (p, bignum, size);
5026 else
5027 return output_big_uleb128 (p, bignum, size);
5030 /* Generate the appropriate fragments for a given expression to emit a
5031 leb128 value. */
5033 static void
5034 emit_leb128_expr (expressionS *exp, int sign)
5036 operatorT op = exp->X_op;
5037 unsigned int nbytes;
5039 if (op == O_absent || op == O_illegal)
5041 as_warn (_("zero assumed for missing expression"));
5042 exp->X_add_number = 0;
5043 op = O_constant;
5045 else if (op == O_big && exp->X_add_number <= 0)
5047 as_bad (_("floating point number invalid"));
5048 exp->X_add_number = 0;
5049 op = O_constant;
5051 else if (op == O_register)
5053 as_warn (_("register value used as expression"));
5054 op = O_constant;
5056 else if (op == O_constant
5057 && sign
5058 && (exp->X_add_number < 0) != !exp->X_unsigned)
5060 /* We're outputting a signed leb128 and the sign of X_add_number
5061 doesn't reflect the sign of the original value. Convert EXP
5062 to a correctly-extended bignum instead. */
5063 convert_to_bignum (exp);
5064 op = O_big;
5067 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5068 a signal that this is leb128 data. It shouldn't optimize this away. */
5069 nbytes = (unsigned int) -1;
5070 if (check_eh_frame (exp, &nbytes))
5071 abort ();
5073 /* Let the backend know that subsequent data may be byte aligned. */
5074 #ifdef md_cons_align
5075 md_cons_align (1);
5076 #endif
5078 if (op == O_constant)
5080 /* If we've got a constant, emit the thing directly right now. */
5082 valueT value = exp->X_add_number;
5083 int size;
5084 char *p;
5086 size = sizeof_leb128 (value, sign);
5087 p = frag_more (size);
5088 output_leb128 (p, value, sign);
5090 else if (op == O_big)
5092 /* O_big is a different sort of constant. */
5094 int size;
5095 char *p;
5097 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5098 p = frag_more (size);
5099 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5101 else
5103 /* Otherwise, we have to create a variable sized fragment and
5104 resolve things later. */
5106 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5107 make_expr_symbol (exp), 0, (char *) NULL);
5111 /* Parse the .sleb128 and .uleb128 pseudos. */
5113 void
5114 s_leb128 (int sign)
5116 expressionS exp;
5118 #ifdef md_flush_pending_output
5119 md_flush_pending_output ();
5120 #endif
5124 expression (&exp);
5125 emit_leb128_expr (&exp, sign);
5127 while (*input_line_pointer++ == ',');
5129 input_line_pointer--;
5130 demand_empty_rest_of_line ();
5133 static void
5134 stringer_append_char (int c, int bitsize)
5136 if (!target_big_endian)
5137 FRAG_APPEND_1_CHAR (c);
5139 switch (bitsize)
5141 case 64:
5142 FRAG_APPEND_1_CHAR (0);
5143 FRAG_APPEND_1_CHAR (0);
5144 FRAG_APPEND_1_CHAR (0);
5145 FRAG_APPEND_1_CHAR (0);
5146 /* Fall through. */
5147 case 32:
5148 FRAG_APPEND_1_CHAR (0);
5149 FRAG_APPEND_1_CHAR (0);
5150 /* Fall through. */
5151 case 16:
5152 FRAG_APPEND_1_CHAR (0);
5153 /* Fall through. */
5154 case 8:
5155 break;
5156 default:
5157 /* Called with invalid bitsize argument. */
5158 abort ();
5159 break;
5161 if (target_big_endian)
5162 FRAG_APPEND_1_CHAR (c);
5165 /* Worker to do .ascii etc statements.
5166 Reads 0 or more ',' separated, double-quoted strings.
5167 Caller should have checked need_pass_2 is FALSE because we don't
5168 check it.
5169 Checks for end-of-line.
5170 BITS_APPENDZERO says how many bits are in a target char.
5171 The bottom bit is set if a NUL char should be appended to the strings. */
5173 void
5174 stringer (int bits_appendzero)
5176 const int bitsize = bits_appendzero & ~7;
5177 const int append_zero = bits_appendzero & 1;
5178 unsigned int c;
5179 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5180 char *start;
5181 #endif
5183 #ifdef md_flush_pending_output
5184 md_flush_pending_output ();
5185 #endif
5187 #ifdef md_cons_align
5188 md_cons_align (1);
5189 #endif
5191 /* The following awkward logic is to parse ZERO or more strings,
5192 comma separated. Recall a string expression includes spaces
5193 before the opening '\"' and spaces after the closing '\"'.
5194 We fake a leading ',' if there is (supposed to be)
5195 a 1st, expression. We keep demanding expressions for each ','. */
5196 if (is_it_end_of_statement ())
5198 c = 0; /* Skip loop. */
5199 ++input_line_pointer; /* Compensate for end of loop. */
5201 else
5203 c = ','; /* Do loop. */
5205 /* If we have been switched into the abs_section then we
5206 will not have an obstack onto which we can hang strings. */
5207 if (now_seg == absolute_section)
5209 as_bad (_("strings must be placed into a section"));
5210 c = 0;
5211 ignore_rest_of_line ();
5214 while (c == ',' || c == '<' || c == '"')
5216 SKIP_WHITESPACE ();
5217 switch (*input_line_pointer)
5219 case '\"':
5220 ++input_line_pointer; /*->1st char of string. */
5221 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5222 start = input_line_pointer;
5223 #endif
5225 while (is_a_char (c = next_char_of_string ()))
5226 stringer_append_char (c, bitsize);
5228 if (append_zero)
5229 stringer_append_char (0, bitsize);
5231 know (input_line_pointer[-1] == '\"');
5233 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5234 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5235 will emit .string with a filename in the .debug section
5236 after a sequence of constants. See the comment in
5237 emit_expr for the sequence. emit_expr will set
5238 dwarf_file_string to non-zero if this string might be a
5239 source file name. */
5240 if (strcmp (segment_name (now_seg), ".debug") != 0)
5241 dwarf_file_string = 0;
5242 else if (dwarf_file_string)
5244 c = input_line_pointer[-1];
5245 input_line_pointer[-1] = '\0';
5246 listing_source_file (start);
5247 input_line_pointer[-1] = c;
5249 #endif
5251 break;
5252 case '<':
5253 input_line_pointer++;
5254 c = get_single_number ();
5255 stringer_append_char (c, bitsize);
5256 if (*input_line_pointer != '>')
5257 as_bad (_("expected <nn>"));
5259 input_line_pointer++;
5260 break;
5261 case ',':
5262 input_line_pointer++;
5263 break;
5265 SKIP_WHITESPACE ();
5266 c = *input_line_pointer;
5269 demand_empty_rest_of_line ();
5272 /* FIXME-SOMEDAY: I had trouble here on characters with the
5273 high bits set. We'll probably also have trouble with
5274 multibyte chars, wide chars, etc. Also be careful about
5275 returning values bigger than 1 byte. xoxorich. */
5277 unsigned int
5278 next_char_of_string (void)
5280 unsigned int c;
5282 c = *input_line_pointer++ & CHAR_MASK;
5283 switch (c)
5285 case '\"':
5286 c = NOT_A_CHAR;
5287 break;
5289 case '\n':
5290 as_warn (_("unterminated string; newline inserted"));
5291 bump_line_counters ();
5292 break;
5294 #ifndef NO_STRING_ESCAPES
5295 case '\\':
5296 switch (c = *input_line_pointer++)
5298 case 'b':
5299 c = '\b';
5300 break;
5302 case 'f':
5303 c = '\f';
5304 break;
5306 case 'n':
5307 c = '\n';
5308 break;
5310 case 'r':
5311 c = '\r';
5312 break;
5314 case 't':
5315 c = '\t';
5316 break;
5318 case 'v':
5319 c = '\013';
5320 break;
5322 case '\\':
5323 case '"':
5324 break; /* As itself. */
5326 case '0':
5327 case '1':
5328 case '2':
5329 case '3':
5330 case '4':
5331 case '5':
5332 case '6':
5333 case '7':
5334 case '8':
5335 case '9':
5337 long number;
5338 int i;
5340 for (i = 0, number = 0;
5341 ISDIGIT (c) && i < 3;
5342 c = *input_line_pointer++, i++)
5344 number = number * 8 + c - '0';
5347 c = number & 0xff;
5349 --input_line_pointer;
5350 break;
5352 case 'x':
5353 case 'X':
5355 long number;
5357 number = 0;
5358 c = *input_line_pointer++;
5359 while (ISXDIGIT (c))
5361 if (ISDIGIT (c))
5362 number = number * 16 + c - '0';
5363 else if (ISUPPER (c))
5364 number = number * 16 + c - 'A' + 10;
5365 else
5366 number = number * 16 + c - 'a' + 10;
5367 c = *input_line_pointer++;
5369 c = number & 0xff;
5370 --input_line_pointer;
5372 break;
5374 case '\n':
5375 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5376 as_warn (_("unterminated string; newline inserted"));
5377 c = '\n';
5378 bump_line_counters ();
5379 break;
5381 default:
5383 #ifdef ONLY_STANDARD_ESCAPES
5384 as_bad (_("bad escaped character in string"));
5385 c = '?';
5386 #endif /* ONLY_STANDARD_ESCAPES */
5388 break;
5390 break;
5391 #endif /* ! defined (NO_STRING_ESCAPES) */
5393 default:
5394 break;
5396 return (c);
5399 static segT
5400 get_segmented_expression (expressionS *expP)
5402 segT retval;
5404 retval = expression (expP);
5405 if (expP->X_op == O_illegal
5406 || expP->X_op == O_absent
5407 || expP->X_op == O_big)
5409 as_bad (_("expected address expression"));
5410 expP->X_op = O_constant;
5411 expP->X_add_number = 0;
5412 retval = absolute_section;
5414 return retval;
5417 static segT
5418 get_known_segmented_expression (expressionS *expP)
5420 segT retval;
5422 if ((retval = get_segmented_expression (expP)) == undefined_section)
5424 /* There is no easy way to extract the undefined symbol from the
5425 expression. */
5426 if (expP->X_add_symbol != NULL
5427 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5428 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5429 S_GET_NAME (expP->X_add_symbol));
5430 else
5431 as_warn (_("some symbol undefined; zero assumed"));
5432 retval = absolute_section;
5433 expP->X_op = O_constant;
5434 expP->X_add_number = 0;
5436 know (retval == absolute_section || SEG_NORMAL (retval));
5437 return (retval);
5440 char /* Return terminator. */
5441 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
5443 /* FIXME: val_pointer should probably be offsetT *. */
5444 *val_pointer = (long) get_absolute_expression ();
5445 return (*input_line_pointer++);
5448 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5449 Give a warning if that happens. */
5451 char *
5452 demand_copy_C_string (int *len_pointer)
5454 char *s;
5456 if ((s = demand_copy_string (len_pointer)) != 0)
5458 int len;
5460 for (len = *len_pointer; len > 0; len--)
5462 if (*s == 0)
5464 s = 0;
5465 len = 1;
5466 *len_pointer = 0;
5467 as_bad (_("this string may not contain \'\\0\'"));
5472 return s;
5475 /* Demand string, but return a safe (=private) copy of the string.
5476 Return NULL if we can't read a string here. */
5478 char *
5479 demand_copy_string (int *lenP)
5481 unsigned int c;
5482 int len;
5483 char *retval;
5485 len = 0;
5486 SKIP_WHITESPACE ();
5487 if (*input_line_pointer == '\"')
5489 input_line_pointer++; /* Skip opening quote. */
5491 while (is_a_char (c = next_char_of_string ()))
5493 obstack_1grow (&notes, c);
5494 len++;
5496 /* JF this next line is so demand_copy_C_string will return a
5497 null terminated string. */
5498 obstack_1grow (&notes, '\0');
5499 retval = (char *) obstack_finish (&notes);
5501 else
5503 as_bad (_("missing string"));
5504 retval = NULL;
5505 ignore_rest_of_line ();
5507 *lenP = len;
5508 return (retval);
5511 /* In: Input_line_pointer->next character.
5513 Do: Skip input_line_pointer over all whitespace.
5515 Out: 1 if input_line_pointer->end-of-line. */
5518 is_it_end_of_statement (void)
5520 SKIP_WHITESPACE ();
5521 return (is_end_of_line[(unsigned char) *input_line_pointer]);
5524 void
5525 equals (char *sym_name, int reassign)
5527 char *stop = NULL;
5528 char stopc = 0;
5530 input_line_pointer++;
5531 if (*input_line_pointer == '=')
5532 input_line_pointer++;
5533 if (reassign < 0 && *input_line_pointer == '=')
5534 input_line_pointer++;
5536 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5537 input_line_pointer++;
5539 if (flag_mri)
5540 stop = mri_comment_field (&stopc);
5542 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5544 if (flag_mri)
5546 demand_empty_rest_of_line ();
5547 mri_comment_end (stop, stopc);
5551 /* .incbin -- include a file verbatim at the current location. */
5553 void
5554 s_incbin (int x ATTRIBUTE_UNUSED)
5556 FILE * binfile;
5557 char * path;
5558 char * filename;
5559 char * binfrag;
5560 long skip = 0;
5561 long count = 0;
5562 long bytes;
5563 int len;
5565 #ifdef md_flush_pending_output
5566 md_flush_pending_output ();
5567 #endif
5569 #ifdef md_cons_align
5570 md_cons_align (1);
5571 #endif
5573 SKIP_WHITESPACE ();
5574 filename = demand_copy_string (& len);
5575 if (filename == NULL)
5576 return;
5578 SKIP_WHITESPACE ();
5580 /* Look for optional skip and count. */
5581 if (* input_line_pointer == ',')
5583 ++ input_line_pointer;
5584 skip = get_absolute_expression ();
5586 SKIP_WHITESPACE ();
5588 if (* input_line_pointer == ',')
5590 ++ input_line_pointer;
5592 count = get_absolute_expression ();
5593 if (count == 0)
5594 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5596 SKIP_WHITESPACE ();
5600 demand_empty_rest_of_line ();
5602 /* Try opening absolute path first, then try include dirs. */
5603 binfile = fopen (filename, FOPEN_RB);
5604 if (binfile == NULL)
5606 int i;
5608 path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5610 for (i = 0; i < include_dir_count; i++)
5612 sprintf (path, "%s/%s", include_dirs[i], filename);
5614 binfile = fopen (path, FOPEN_RB);
5615 if (binfile != NULL)
5616 break;
5619 if (binfile == NULL)
5620 as_bad (_("file not found: %s"), filename);
5622 else
5623 path = xstrdup (filename);
5625 if (binfile)
5627 long file_len;
5629 register_dependency (path);
5631 /* Compute the length of the file. */
5632 if (fseek (binfile, 0, SEEK_END) != 0)
5634 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5635 goto done;
5637 file_len = ftell (binfile);
5639 /* If a count was not specified use the remainder of the file. */
5640 if (count == 0)
5641 count = file_len - skip;
5643 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5645 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5646 skip, count, file_len);
5647 goto done;
5650 if (fseek (binfile, skip, SEEK_SET) != 0)
5652 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5653 goto done;
5656 /* Allocate frag space and store file contents in it. */
5657 binfrag = frag_more (count);
5659 bytes = fread (binfrag, 1, count, binfile);
5660 if (bytes < count)
5661 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5662 path, bytes, count);
5664 done:
5665 if (binfile != NULL)
5666 fclose (binfile);
5667 if (path)
5668 free (path);
5671 /* .include -- include a file at this point. */
5673 void
5674 s_include (int arg ATTRIBUTE_UNUSED)
5676 char *filename;
5677 int i;
5678 FILE *try_file;
5679 char *path;
5681 if (!flag_m68k_mri)
5683 filename = demand_copy_string (&i);
5684 if (filename == NULL)
5686 /* demand_copy_string has already printed an error and
5687 called ignore_rest_of_line. */
5688 return;
5691 else
5693 SKIP_WHITESPACE ();
5694 i = 0;
5695 while (!is_end_of_line[(unsigned char) *input_line_pointer]
5696 && *input_line_pointer != ' '
5697 && *input_line_pointer != '\t')
5699 obstack_1grow (&notes, *input_line_pointer);
5700 ++input_line_pointer;
5701 ++i;
5704 obstack_1grow (&notes, '\0');
5705 filename = (char *) obstack_finish (&notes);
5706 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5707 ++input_line_pointer;
5710 demand_empty_rest_of_line ();
5711 path = (char *) xmalloc ((unsigned long) i
5712 + include_dir_maxlen + 5 /* slop */ );
5714 for (i = 0; i < include_dir_count; i++)
5716 strcpy (path, include_dirs[i]);
5717 strcat (path, "/");
5718 strcat (path, filename);
5719 if (0 != (try_file = fopen (path, FOPEN_RT)))
5721 fclose (try_file);
5722 goto gotit;
5726 free (path);
5727 path = filename;
5728 gotit:
5729 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
5730 register_dependency (path);
5731 input_scrub_insert_file (path);
5734 void
5735 add_include_dir (char *path)
5737 int i;
5739 if (include_dir_count == 0)
5741 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5742 include_dirs[0] = "."; /* Current dir. */
5743 include_dir_count = 2;
5745 else
5747 include_dir_count++;
5748 include_dirs =
5749 (char **) realloc (include_dirs,
5750 include_dir_count * sizeof (*include_dirs));
5753 include_dirs[include_dir_count - 1] = path; /* New one. */
5755 i = strlen (path);
5756 if (i > include_dir_maxlen)
5757 include_dir_maxlen = i;
5760 /* Output debugging information to denote the source file. */
5762 static void
5763 generate_file_debug (void)
5765 if (debug_type == DEBUG_STABS)
5766 stabs_generate_asm_file ();
5769 /* Output line number debugging information for the current source line. */
5771 void
5772 generate_lineno_debug (void)
5774 switch (debug_type)
5776 case DEBUG_UNSPECIFIED:
5777 case DEBUG_NONE:
5778 case DEBUG_DWARF:
5779 break;
5780 case DEBUG_STABS:
5781 stabs_generate_asm_lineno ();
5782 break;
5783 case DEBUG_ECOFF:
5784 ecoff_generate_asm_lineno ();
5785 break;
5786 case DEBUG_DWARF2:
5787 /* ??? We could here indicate to dwarf2dbg.c that something
5788 has changed. However, since there is additional backend
5789 support that is required (calling dwarf2_emit_insn), we
5790 let dwarf2dbg.c call as_where on its own. */
5791 break;
5795 /* Output debugging information to mark a function entry point or end point.
5796 END_P is zero for .func, and non-zero for .endfunc. */
5798 void
5799 s_func (int end_p)
5801 do_s_func (end_p, NULL);
5804 /* Subroutine of s_func so targets can choose a different default prefix.
5805 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5807 static void
5808 do_s_func (int end_p, const char *default_prefix)
5810 /* Record the current function so that we can issue an error message for
5811 misplaced .func,.endfunc, and also so that .endfunc needs no
5812 arguments. */
5813 static char *current_name;
5814 static char *current_label;
5816 if (end_p)
5818 if (current_name == NULL)
5820 as_bad (_("missing .func"));
5821 ignore_rest_of_line ();
5822 return;
5825 if (debug_type == DEBUG_STABS)
5826 stabs_generate_asm_endfunc (current_name, current_label);
5828 current_name = current_label = NULL;
5830 else /* ! end_p */
5832 char *name, *label;
5833 char delim1, delim2;
5835 if (current_name != NULL)
5837 as_bad (_(".endfunc missing for previous .func"));
5838 ignore_rest_of_line ();
5839 return;
5842 name = input_line_pointer;
5843 delim1 = get_symbol_end ();
5844 name = xstrdup (name);
5845 *input_line_pointer = delim1;
5846 SKIP_WHITESPACE ();
5847 if (*input_line_pointer != ',')
5849 if (default_prefix)
5851 if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5852 as_fatal ("%s", xstrerror (errno));
5854 else
5856 char leading_char = bfd_get_symbol_leading_char (stdoutput);
5857 /* Missing entry point, use function's name with the leading
5858 char prepended. */
5859 if (leading_char)
5861 if (asprintf (&label, "%c%s", leading_char, name) == -1)
5862 as_fatal ("%s", xstrerror (errno));
5864 else
5865 label = name;
5868 else
5870 ++input_line_pointer;
5871 SKIP_WHITESPACE ();
5872 label = input_line_pointer;
5873 delim2 = get_symbol_end ();
5874 label = xstrdup (label);
5875 *input_line_pointer = delim2;
5878 if (debug_type == DEBUG_STABS)
5879 stabs_generate_asm_func (name, label);
5881 current_name = name;
5882 current_label = label;
5885 demand_empty_rest_of_line ();
5888 void
5889 s_ignore (int arg ATTRIBUTE_UNUSED)
5891 ignore_rest_of_line ();
5894 void
5895 read_print_statistics (FILE *file)
5897 hash_print_statistics (file, "pseudo-op table", po_hash);
5900 /* Inserts the given line into the input stream.
5902 This call avoids macro/conditionals nesting checking, since the contents of
5903 the line are assumed to replace the contents of a line already scanned.
5905 An appropriate use of this function would be substitution of input lines when
5906 called by md_start_line_hook(). The given line is assumed to already be
5907 properly scrubbed. */
5909 void
5910 input_scrub_insert_line (const char *line)
5912 sb newline;
5913 sb_new (&newline);
5914 sb_add_string (&newline, line);
5915 input_scrub_include_sb (&newline, input_line_pointer, 0);
5916 sb_kill (&newline);
5917 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5920 /* Insert a file into the input stream; the path must resolve to an actual
5921 file; no include path searching or dependency registering is performed. */
5923 void
5924 input_scrub_insert_file (char *path)
5926 input_scrub_include_file (path, input_line_pointer);
5927 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5930 /* Find the end of a line, considering quotation and escaping of quotes. */
5932 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5933 # define TC_SINGLE_QUOTE_STRINGS 1
5934 #endif
5936 static char *
5937 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5938 int in_macro)
5940 char inquote = '\0';
5941 int inescape = 0;
5943 while (!is_end_of_line[(unsigned char) *s]
5944 || (inquote && !ISCNTRL (*s))
5945 || (inquote == '\'' && flag_mri)
5946 #ifdef TC_EOL_IN_INSN
5947 || (insn && TC_EOL_IN_INSN (s))
5948 #endif
5949 /* PR 6926: When we are parsing the body of a macro the sequence
5950 \@ is special - it refers to the invocation count. If the @
5951 character happens to be registered as a line-separator character
5952 by the target, then the is_end_of_line[] test above will have
5953 returned true, but we need to ignore the line separating
5954 semantics in this particular case. */
5955 || (in_macro && inescape && *s == '@')
5958 if (mri_string && *s == '\'')
5959 inquote ^= *s;
5960 else if (inescape)
5961 inescape = 0;
5962 else if (*s == '\\')
5963 inescape = 1;
5964 else if (!inquote
5965 ? *s == '"'
5966 #ifdef TC_SINGLE_QUOTE_STRINGS
5967 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5968 #endif
5969 : *s == inquote)
5970 inquote ^= *s;
5971 ++s;
5973 if (inquote)
5974 as_warn (_("missing closing `%c'"), inquote);
5975 if (inescape)
5976 as_warn (_("stray `\\'"));
5977 return s;
5980 char *
5981 find_end_of_line (char *s, int mri_string)
5983 return _find_end_of_line (s, mri_string, 0, 0);