PR 12569
[deliverable/binutils-gdb.git] / gas / read.c
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, 2011 Free Software Foundation, Inc.
5
6 This file is part of GAS, the GNU Assembler.
7
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.
12
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.
17
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. */
22
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)
27
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)
31
32 /* Routines that read assembler source text to build spaghetti in memory.
33 Another group of these functions is in the expr.c module. */
34
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"
43
44 #ifndef TC_START_LABEL
45 #define TC_START_LABEL(x,y,z) (x == ':')
46 #endif
47
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
64
65 char *input_line_pointer; /*->next char of source file to parse. */
66
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
72
73 #ifndef LEX_AT
74 #define LEX_AT 0
75 #endif
76
77 #ifndef LEX_BR
78 /* The RS/6000 assembler uses {,},[,] as parts of symbol names. */
79 #define LEX_BR 0
80 #endif
81
82 #ifndef LEX_PCT
83 /* The Delta 68k assembler permits % inside label names. */
84 #define LEX_PCT 0
85 #endif
86
87 #ifndef LEX_QM
88 /* The PowerPC Windows NT assemblers permits ? inside label names. */
89 #define LEX_QM 0
90 #endif
91
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
97
98 #ifndef LEX_DOLLAR
99 #define LEX_DOLLAR 3
100 #endif
101
102 #ifndef LEX_TILDE
103 /* The Delta 68k assembler permits ~ at start of label names. */
104 #define LEX_TILDE 0
105 #endif
106
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
125 };
126
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 /* */
151 };
152
153 #ifndef TC_CASE_SENSITIVE
154 char original_case_string[128];
155 #endif
156
157 /* Functions private to this file. */
158
159 static char *buffer; /* 1st char of each buffer of lines is here. */
160 static char *buffer_limit; /*->1 + last char in buffer. */
161
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;
166
167 /* Variables for handling include file directory table. */
168
169 /* Table of pointers to directories to search for .include's. */
170 char **include_dirs;
171
172 /* How many are in the table. */
173 int include_dir_count;
174
175 /* Length of longest in table. */
176 int include_dir_maxlen = 1;
177
178 #ifndef WORKING_DOT_WORD
179 struct broken_word *broken_words;
180 int new_broken_words;
181 #endif
182
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;
187
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;
191
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;
196
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;
202
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
211
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);
227 \f
228 void
229 read_begin (void)
230 {
231 const char *p;
232
233 pobegin ();
234 obj_read_begin_hook ();
235
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);
240
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. */
245
246 if (flag_mri)
247 lex_type['?'] = 3;
248 }
249 \f
250 #ifndef TC_ADDRESS_BYTES
251 #define TC_ADDRESS_BYTES address_bytes
252
253 static inline int
254 address_bytes (void)
255 {
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;
263 }
264 #endif
265
266 /* Set up pseudo-op tables. */
267
268 static struct hash_control *po_hash;
269
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},
428
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},
438
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. */
454 };
455
456 static offsetT
457 get_absolute_expr (expressionS *exp)
458 {
459 expression_and_evaluate (exp);
460 if (exp->X_op != O_constant)
461 {
462 if (exp->X_op != O_absent)
463 as_bad (_("bad or irreducible absolute expression"));
464 exp->X_add_number = 0;
465 }
466 return exp->X_add_number;
467 }
468
469 offsetT
470 get_absolute_expression (void)
471 {
472 expressionS exp;
473
474 return get_absolute_expr (&exp);
475 }
476
477 static int pop_override_ok = 0;
478 static const char *pop_table_name;
479
480 void
481 pop_insert (const pseudo_typeS *table)
482 {
483 const char *errtxt;
484 const pseudo_typeS *pop;
485 for (pop = table; pop->poc_name; pop++)
486 {
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);
491 }
492 }
493
494 #ifndef md_pop_insert
495 #define md_pop_insert() pop_insert(md_pseudo_table)
496 #endif
497
498 #ifndef obj_pop_insert
499 #define obj_pop_insert() pop_insert(obj_pseudo_table)
500 #endif
501
502 #ifndef cfi_pop_insert
503 #define cfi_pop_insert() pop_insert(cfi_pseudo_table)
504 #endif
505
506 static void
507 pobegin (void)
508 {
509 po_hash = hash_new ();
510
511 /* Do the target-specific pseudo ops. */
512 pop_table_name = "md";
513 md_pop_insert ();
514
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 ();
519
520 /* Now portable ones. Skip any that we've seen already. */
521 pop_table_name = "standard";
522 pop_insert (potable);
523
524 /* Now CFI ones. */
525 pop_table_name = "cfi";
526 pop_override_ok = 1;
527 cfi_pop_insert ();
528 }
529 \f
530 #define HANDLE_CONDITIONAL_ASSEMBLY() \
531 if (ignore_input ()) \
532 { \
533 char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
534 input_line_pointer = (input_line_pointer <= buffer_limit \
535 && eol >= buffer_limit) \
536 ? buffer_limit \
537 : eol + 1; \
538 continue; \
539 }
540
541 /* This function is used when scrubbing the characters between #APP
542 and #NO_APP. */
543
544 static char *scrub_string;
545 static char *scrub_string_end;
546
547 static int
548 scrub_from_string (char *buf, int buflen)
549 {
550 int copy;
551
552 copy = scrub_string_end - scrub_string;
553 if (copy > buflen)
554 copy = buflen;
555 memcpy (buf, scrub_string, copy);
556 scrub_string += copy;
557 return copy;
558 }
559
560 /* Helper function of read_a_source_file, which tries to expand a macro. */
561 static int
562 try_macro (char term, const char *line)
563 {
564 sb out;
565 const char *err;
566 macro_entry *macro;
567
568 if (check_macro (line, &out, &err, &macro))
569 {
570 if (err != NULL)
571 as_bad ("%s", err);
572 *input_line_pointer++ = term;
573 input_scrub_include_sb (&out,
574 input_line_pointer, 1);
575 sb_kill (&out);
576 buffer_limit =
577 input_scrub_next_buffer (&input_line_pointer);
578 #ifdef md_macro_info
579 md_macro_info (macro);
580 #endif
581 return 1;
582 }
583 return 0;
584 }
585
586 /* We read the file, putting things into a web that represents what we
587 have been reading. */
588 void
589 read_a_source_file (char *name)
590 {
591 char c;
592 char *s; /* String of symbol, '\0' appended. */
593 int temp;
594 pseudo_typeS *pop;
595
596 #ifdef WARN_COMMENTS
597 found_comment = 0;
598 #endif
599
600 buffer = input_scrub_new_file (name);
601
602 listing_file (name);
603 listing_newline (NULL);
604 register_dependency (name);
605
606 /* Generate debugging information before we've read anything in to denote
607 this file as the "main" source file and not a subordinate one
608 (e.g. N_SO vs N_SOL in stabs). */
609 generate_file_debug ();
610
611 while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
612 { /* We have another line to parse. */
613 #ifndef NO_LISTING
614 /* In order to avoid listing macro expansion lines with labels
615 multiple times, keep track of which line was last issued. */
616 static char *last_eol;
617
618 last_eol = NULL;
619 #endif
620 while (input_line_pointer < buffer_limit)
621 {
622 bfd_boolean was_new_line;
623 /* We have more of this buffer to parse. */
624
625 /* We now have input_line_pointer->1st char of next line.
626 If input_line_pointer [-1] == '\n' then we just
627 scanned another line: so bump line counters. */
628 was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
629 if (was_new_line)
630 {
631 symbol_set_value_now (&dot_symbol);
632 #ifdef md_start_line_hook
633 md_start_line_hook ();
634 #endif
635 if (input_line_pointer[-1] == '\n')
636 bump_line_counters ();
637 }
638
639 #ifndef NO_LISTING
640 /* If listing is on, and we are expanding a macro, then give
641 the listing code the contents of the expanded line. */
642 if (listing)
643 {
644 if ((listing & LISTING_MACEXP) && macro_nest > 0)
645 {
646 /* Find the end of the current expanded macro line. */
647 s = find_end_of_line (input_line_pointer, flag_m68k_mri);
648
649 if (s != last_eol)
650 {
651 char *copy;
652 int len;
653
654 last_eol = s;
655 /* Copy it for safe keeping. Also give an indication of
656 how much macro nesting is involved at this point. */
657 len = s - input_line_pointer;
658 copy = (char *) xmalloc (len + macro_nest + 2);
659 memset (copy, '>', macro_nest);
660 copy[macro_nest] = ' ';
661 memcpy (copy + macro_nest + 1, input_line_pointer, len);
662 copy[macro_nest + 1 + len] = '\0';
663
664 /* Install the line with the listing facility. */
665 listing_newline (copy);
666 }
667 }
668 else
669 listing_newline (NULL);
670 }
671 #endif
672 if (was_new_line)
673 {
674 line_label = NULL;
675
676 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
677 {
678 /* Text at the start of a line must be a label, we
679 run down and stick a colon in. */
680 if (is_name_beginner (*input_line_pointer))
681 {
682 char *line_start = input_line_pointer;
683 int mri_line_macro;
684
685 HANDLE_CONDITIONAL_ASSEMBLY ();
686
687 c = get_symbol_end ();
688
689 /* In MRI mode, the EQU and MACRO pseudoops must
690 be handled specially. */
691 mri_line_macro = 0;
692 if (flag_m68k_mri)
693 {
694 char *rest = input_line_pointer + 1;
695
696 if (*rest == ':')
697 ++rest;
698 if (*rest == ' ' || *rest == '\t')
699 ++rest;
700 if ((strncasecmp (rest, "EQU", 3) == 0
701 || strncasecmp (rest, "SET", 3) == 0)
702 && (rest[3] == ' ' || rest[3] == '\t'))
703 {
704 input_line_pointer = rest + 3;
705 equals (line_start,
706 strncasecmp (rest, "SET", 3) == 0);
707 continue;
708 }
709 if (strncasecmp (rest, "MACRO", 5) == 0
710 && (rest[5] == ' '
711 || rest[5] == '\t'
712 || is_end_of_line[(unsigned char) rest[5]]))
713 mri_line_macro = 1;
714 }
715
716 /* In MRI mode, we need to handle the MACRO
717 pseudo-op specially: we don't want to put the
718 symbol in the symbol table. */
719 if (!mri_line_macro
720 #ifdef TC_START_LABEL_WITHOUT_COLON
721 && TC_START_LABEL_WITHOUT_COLON(c,
722 input_line_pointer)
723 #endif
724 )
725 line_label = colon (line_start);
726 else
727 line_label = symbol_create (line_start,
728 absolute_section,
729 (valueT) 0,
730 &zero_address_frag);
731
732 *input_line_pointer = c;
733 if (c == ':')
734 input_line_pointer++;
735 }
736 }
737 }
738
739 /* We are at the beginning of a line, or similar place.
740 We expect a well-formed assembler statement.
741 A "symbol-name:" is a statement.
742
743 Depending on what compiler is used, the order of these tests
744 may vary to catch most common case 1st.
745 Each test is independent of all other tests at the (top)
746 level. */
747 do
748 c = *input_line_pointer++;
749 while (c == '\t' || c == ' ' || c == '\f');
750
751 /* C is the 1st significant character.
752 Input_line_pointer points after that character. */
753 if (is_name_beginner (c))
754 {
755 /* Want user-defined label or pseudo/opcode. */
756 HANDLE_CONDITIONAL_ASSEMBLY ();
757
758 s = --input_line_pointer;
759 c = get_symbol_end (); /* name's delimiter. */
760
761 /* C is character after symbol.
762 That character's place in the input line is now '\0'.
763 S points to the beginning of the symbol.
764 [In case of pseudo-op, s->'.'.]
765 Input_line_pointer->'\0' where c was. */
766 if (TC_START_LABEL (c, s, input_line_pointer))
767 {
768 if (flag_m68k_mri)
769 {
770 char *rest = input_line_pointer + 1;
771
772 /* In MRI mode, \tsym: set 0 is permitted. */
773 if (*rest == ':')
774 ++rest;
775
776 if (*rest == ' ' || *rest == '\t')
777 ++rest;
778
779 if ((strncasecmp (rest, "EQU", 3) == 0
780 || strncasecmp (rest, "SET", 3) == 0)
781 && (rest[3] == ' ' || rest[3] == '\t'))
782 {
783 input_line_pointer = rest + 3;
784 equals (s, 1);
785 continue;
786 }
787 }
788
789 line_label = colon (s); /* User-defined label. */
790 /* Put ':' back for error messages' sake. */
791 *input_line_pointer++ = ':';
792 #ifdef tc_check_label
793 tc_check_label (line_label);
794 #endif
795 /* Input_line_pointer->after ':'. */
796 SKIP_WHITESPACE ();
797 }
798 else if ((c == '=' && input_line_pointer[1] == '=')
799 || ((c == ' ' || c == '\t')
800 && input_line_pointer[1] == '='
801 && input_line_pointer[2] == '='))
802 {
803 equals (s, -1);
804 demand_empty_rest_of_line ();
805 }
806 else if ((c == '='
807 || ((c == ' ' || c == '\t')
808 && input_line_pointer[1] == '='))
809 #ifdef TC_EQUAL_IN_INSN
810 && !TC_EQUAL_IN_INSN (c, s)
811 #endif
812 )
813 {
814 equals (s, 1);
815 demand_empty_rest_of_line ();
816 }
817 else
818 {
819 /* Expect pseudo-op or machine instruction. */
820 pop = NULL;
821
822 #ifndef TC_CASE_SENSITIVE
823 {
824 char *s2 = s;
825
826 strncpy (original_case_string, s2, sizeof (original_case_string));
827 original_case_string[sizeof (original_case_string) - 1] = 0;
828
829 while (*s2)
830 {
831 *s2 = TOLOWER (*s2);
832 s2++;
833 }
834 }
835 #endif
836 if (NO_PSEUDO_DOT || flag_m68k_mri)
837 {
838 /* The MRI assembler uses pseudo-ops without
839 a period. */
840 pop = (pseudo_typeS *) hash_find (po_hash, s);
841 if (pop != NULL && pop->poc_handler == NULL)
842 pop = NULL;
843 }
844
845 if (pop != NULL
846 || (!flag_m68k_mri && *s == '.'))
847 {
848 /* PSEUDO - OP.
849
850 WARNING: c has next char, which may be end-of-line.
851 We lookup the pseudo-op table with s+1 because we
852 already know that the pseudo-op begins with a '.'. */
853
854 if (pop == NULL)
855 pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
856 if (pop && !pop->poc_handler)
857 pop = NULL;
858
859 /* In MRI mode, we may need to insert an
860 automatic alignment directive. What a hack
861 this is. */
862 if (mri_pending_align
863 && (pop == NULL
864 || !((pop->poc_handler == cons
865 && pop->poc_val == 1)
866 || (pop->poc_handler == s_space
867 && pop->poc_val == 1)
868 #ifdef tc_conditional_pseudoop
869 || tc_conditional_pseudoop (pop)
870 #endif
871 || pop->poc_handler == s_if
872 || pop->poc_handler == s_ifdef
873 || pop->poc_handler == s_ifc
874 || pop->poc_handler == s_ifeqs
875 || pop->poc_handler == s_else
876 || pop->poc_handler == s_endif
877 || pop->poc_handler == s_globl
878 || pop->poc_handler == s_ignore)))
879 {
880 do_align (1, (char *) NULL, 0, 0);
881 mri_pending_align = 0;
882
883 if (line_label != NULL)
884 {
885 symbol_set_frag (line_label, frag_now);
886 S_SET_VALUE (line_label, frag_now_fix ());
887 }
888 }
889
890 /* Print the error msg now, while we still can. */
891 if (pop == NULL)
892 {
893 char *end = input_line_pointer;
894
895 *input_line_pointer = c;
896 s_ignore (0);
897 c = *--input_line_pointer;
898 *input_line_pointer = '\0';
899 if (! macro_defined || ! try_macro (c, s))
900 {
901 *end = '\0';
902 as_bad (_("unknown pseudo-op: `%s'"), s);
903 *input_line_pointer++ = c;
904 }
905 continue;
906 }
907
908 /* Put it back for error messages etc. */
909 *input_line_pointer = c;
910 /* The following skip of whitespace is compulsory.
911 A well shaped space is sometimes all that separates
912 keyword from operands. */
913 if (c == ' ' || c == '\t')
914 input_line_pointer++;
915
916 /* Input_line is restored.
917 Input_line_pointer->1st non-blank char
918 after pseudo-operation. */
919 (*pop->poc_handler) (pop->poc_val);
920
921 /* If that was .end, just get out now. */
922 if (pop->poc_handler == s_end)
923 goto quit;
924 }
925 else
926 {
927 /* WARNING: c has char, which may be end-of-line. */
928 /* Also: input_line_pointer->`\0` where c was. */
929 *input_line_pointer = c;
930 input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
931 c = *input_line_pointer;
932 *input_line_pointer = '\0';
933
934 generate_lineno_debug ();
935
936 if (macro_defined && try_macro (c, s))
937 continue;
938
939 if (mri_pending_align)
940 {
941 do_align (1, (char *) NULL, 0, 0);
942 mri_pending_align = 0;
943 if (line_label != NULL)
944 {
945 symbol_set_frag (line_label, frag_now);
946 S_SET_VALUE (line_label, frag_now_fix ());
947 }
948 }
949
950 md_assemble (s); /* Assemble 1 instruction. */
951
952 *input_line_pointer++ = c;
953
954 /* We resume loop AFTER the end-of-line from
955 this instruction. */
956 }
957 }
958 continue;
959 }
960
961 /* Empty statement? */
962 if (is_end_of_line[(unsigned char) c])
963 continue;
964
965 if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
966 {
967 /* local label ("4:") */
968 char *backup = input_line_pointer;
969
970 HANDLE_CONDITIONAL_ASSEMBLY ();
971
972 temp = c - '0';
973
974 /* Read the whole number. */
975 while (ISDIGIT (*input_line_pointer))
976 {
977 temp = (temp * 10) + *input_line_pointer - '0';
978 ++input_line_pointer;
979 }
980
981 if (LOCAL_LABELS_DOLLAR
982 && *input_line_pointer == '$'
983 && *(input_line_pointer + 1) == ':')
984 {
985 input_line_pointer += 2;
986
987 if (dollar_label_defined (temp))
988 {
989 as_fatal (_("label \"%d$\" redefined"), temp);
990 }
991
992 define_dollar_label (temp);
993 colon (dollar_label_name (temp, 0));
994 continue;
995 }
996
997 if (LOCAL_LABELS_FB
998 && *input_line_pointer++ == ':')
999 {
1000 fb_label_instance_inc (temp);
1001 colon (fb_label_name (temp, 0));
1002 continue;
1003 }
1004
1005 input_line_pointer = backup;
1006 } /* local label ("4:") */
1007
1008 if (c && strchr (line_comment_chars, c))
1009 { /* Its a comment. Better say APP or NO_APP. */
1010 sb sbuf;
1011 char *ends;
1012 char *new_buf;
1013 char *new_tmp;
1014 unsigned int new_length;
1015 char *tmp_buf = 0;
1016
1017 s = input_line_pointer;
1018 if (strncmp (s, "APP\n", 4))
1019 {
1020 /* We ignore it. */
1021 ignore_rest_of_line ();
1022 continue;
1023 }
1024 bump_line_counters ();
1025 s += 4;
1026
1027 sb_new (&sbuf);
1028 ends = strstr (s, "#NO_APP\n");
1029
1030 if (!ends)
1031 {
1032 unsigned int tmp_len;
1033 unsigned int num;
1034
1035 /* The end of the #APP wasn't in this buffer. We
1036 keep reading in buffers until we find the #NO_APP
1037 that goes with this #APP There is one. The specs
1038 guarantee it... */
1039 tmp_len = buffer_limit - s;
1040 tmp_buf = (char *) xmalloc (tmp_len + 1);
1041 memcpy (tmp_buf, s, tmp_len);
1042 do
1043 {
1044 new_tmp = input_scrub_next_buffer (&buffer);
1045 if (!new_tmp)
1046 break;
1047 else
1048 buffer_limit = new_tmp;
1049 input_line_pointer = buffer;
1050 ends = strstr (buffer, "#NO_APP\n");
1051 if (ends)
1052 num = ends - buffer;
1053 else
1054 num = buffer_limit - buffer;
1055
1056 tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
1057 memcpy (tmp_buf + tmp_len, buffer, num);
1058 tmp_len += num;
1059 }
1060 while (!ends);
1061
1062 input_line_pointer = ends ? ends + 8 : NULL;
1063
1064 s = tmp_buf;
1065 ends = s + tmp_len;
1066
1067 }
1068 else
1069 {
1070 input_line_pointer = ends + 8;
1071 }
1072
1073 scrub_string = s;
1074 scrub_string_end = ends;
1075
1076 new_length = ends - s;
1077 new_buf = (char *) xmalloc (new_length);
1078 new_tmp = new_buf;
1079 for (;;)
1080 {
1081 int space;
1082 int size;
1083
1084 space = (new_buf + new_length) - new_tmp;
1085 size = do_scrub_chars (scrub_from_string, new_tmp, space);
1086
1087 if (size < space)
1088 {
1089 new_tmp[size] = 0;
1090 break;
1091 }
1092
1093 new_buf = (char *) xrealloc (new_buf, new_length + 100);
1094 new_tmp = new_buf + new_length;
1095 new_length += 100;
1096 }
1097
1098 if (tmp_buf)
1099 free (tmp_buf);
1100
1101 /* We've "scrubbed" input to the preferred format. In the
1102 process we may have consumed the whole of the remaining
1103 file (and included files). We handle this formatted
1104 input similar to that of macro expansion, letting
1105 actual macro expansion (possibly nested) and other
1106 input expansion work. Beware that in messages, line
1107 numbers and possibly file names will be incorrect. */
1108 sb_add_string (&sbuf, new_buf);
1109 input_scrub_include_sb (&sbuf, input_line_pointer, 0);
1110 sb_kill (&sbuf);
1111 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1112 free (new_buf);
1113 continue;
1114 }
1115
1116 HANDLE_CONDITIONAL_ASSEMBLY ();
1117
1118 #ifdef tc_unrecognized_line
1119 if (tc_unrecognized_line (c))
1120 continue;
1121 #endif
1122 input_line_pointer--;
1123 /* Report unknown char as error. */
1124 demand_empty_rest_of_line ();
1125 }
1126
1127 #ifdef md_after_pass_hook
1128 md_after_pass_hook ();
1129 #endif
1130 }
1131 symbol_set_value_now (&dot_symbol);
1132
1133 quit:
1134
1135 #ifdef md_cleanup
1136 md_cleanup ();
1137 #endif
1138 /* Close the input file. */
1139 input_scrub_close ();
1140 #ifdef WARN_COMMENTS
1141 {
1142 if (warn_comment && found_comment)
1143 as_warn_where (found_comment_file, found_comment,
1144 "first comment found here");
1145 }
1146 #endif
1147 }
1148
1149 /* Convert O_constant expression EXP into the equivalent O_big representation.
1150 Take the sign of the number from X_unsigned rather than X_add_number. */
1151
1152 static void
1153 convert_to_bignum (expressionS *exp)
1154 {
1155 valueT value;
1156 unsigned int i;
1157
1158 value = exp->X_add_number;
1159 for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
1160 {
1161 generic_bignum[i] = value & LITTLENUM_MASK;
1162 value >>= LITTLENUM_NUMBER_OF_BITS;
1163 }
1164 /* Add a sequence of sign bits if the top bit of X_add_number is not
1165 the sign of the original value. */
1166 if ((exp->X_add_number < 0) != !exp->X_unsigned)
1167 generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
1168 exp->X_op = O_big;
1169 exp->X_add_number = i;
1170 }
1171
1172 /* For most MRI pseudo-ops, the line actually ends at the first
1173 nonquoted space. This function looks for that point, stuffs a null
1174 in, and sets *STOPCP to the character that used to be there, and
1175 returns the location.
1176
1177 Until I hear otherwise, I am going to assume that this is only true
1178 for the m68k MRI assembler. */
1179
1180 char *
1181 mri_comment_field (char *stopcp)
1182 {
1183 char *s;
1184 #ifdef TC_M68K
1185 int inquote = 0;
1186
1187 know (flag_m68k_mri);
1188
1189 for (s = input_line_pointer;
1190 ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1191 || inquote);
1192 s++)
1193 {
1194 if (*s == '\'')
1195 inquote = !inquote;
1196 }
1197 #else
1198 for (s = input_line_pointer;
1199 !is_end_of_line[(unsigned char) *s];
1200 s++)
1201 ;
1202 #endif
1203 *stopcp = *s;
1204 *s = '\0';
1205
1206 return s;
1207 }
1208
1209 /* Skip to the end of an MRI comment field. */
1210
1211 void
1212 mri_comment_end (char *stop, int stopc)
1213 {
1214 know (flag_mri);
1215
1216 input_line_pointer = stop;
1217 *stop = stopc;
1218 while (!is_end_of_line[(unsigned char) *input_line_pointer])
1219 ++input_line_pointer;
1220 }
1221
1222 void
1223 s_abort (int ignore ATTRIBUTE_UNUSED)
1224 {
1225 as_fatal (_(".abort detected. Abandoning ship."));
1226 }
1227
1228 /* Guts of .align directive. N is the power of two to which to align.
1229 FILL may be NULL, or it may point to the bytes of the fill pattern.
1230 LEN is the length of whatever FILL points to, if anything. MAX is
1231 the maximum number of characters to skip when doing the alignment,
1232 or 0 if there is no maximum. */
1233
1234 static void
1235 do_align (int n, char *fill, int len, int max)
1236 {
1237 if (now_seg == absolute_section)
1238 {
1239 if (fill != NULL)
1240 while (len-- > 0)
1241 if (*fill++ != '\0')
1242 {
1243 as_warn (_("ignoring fill value in absolute section"));
1244 break;
1245 }
1246 fill = NULL;
1247 len = 0;
1248 }
1249
1250 #ifdef md_flush_pending_output
1251 md_flush_pending_output ();
1252 #endif
1253 #ifdef md_do_align
1254 md_do_align (n, fill, len, max, just_record_alignment);
1255 #endif
1256
1257 /* Only make a frag if we HAVE to... */
1258 if (n != 0 && !need_pass_2)
1259 {
1260 if (fill == NULL)
1261 {
1262 if (subseg_text_p (now_seg))
1263 frag_align_code (n, max);
1264 else
1265 frag_align (n, 0, max);
1266 }
1267 else if (len <= 1)
1268 frag_align (n, *fill, max);
1269 else
1270 frag_align_pattern (n, fill, len, max);
1271 }
1272
1273 #ifdef md_do_align
1274 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
1275 #endif
1276
1277 record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
1278 }
1279
1280 /* Handle the .align pseudo-op. A positive ARG is a default alignment
1281 (in bytes). A negative ARG is the negative of the length of the
1282 fill pattern. BYTES_P is non-zero if the alignment value should be
1283 interpreted as the byte boundary, rather than the power of 2. */
1284 #ifndef TC_ALIGN_LIMIT
1285 #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
1286 #endif
1287
1288 static void
1289 s_align (int arg, int bytes_p)
1290 {
1291 unsigned int align_limit = TC_ALIGN_LIMIT;
1292 unsigned int align;
1293 char *stop = NULL;
1294 char stopc = 0;
1295 offsetT fill = 0;
1296 int max;
1297 int fill_p;
1298
1299 if (flag_mri)
1300 stop = mri_comment_field (&stopc);
1301
1302 if (is_end_of_line[(unsigned char) *input_line_pointer])
1303 {
1304 if (arg < 0)
1305 align = 0;
1306 else
1307 align = arg; /* Default value from pseudo-op table. */
1308 }
1309 else
1310 {
1311 align = get_absolute_expression ();
1312 SKIP_WHITESPACE ();
1313 }
1314
1315 if (bytes_p)
1316 {
1317 /* Convert to a power of 2. */
1318 if (align != 0)
1319 {
1320 unsigned int i;
1321
1322 for (i = 0; (align & 1) == 0; align >>= 1, ++i)
1323 ;
1324 if (align != 1)
1325 as_bad (_("alignment not a power of 2"));
1326
1327 align = i;
1328 }
1329 }
1330
1331 if (align > align_limit)
1332 {
1333 align = align_limit;
1334 as_warn (_("alignment too large: %u assumed"), align);
1335 }
1336
1337 if (*input_line_pointer != ',')
1338 {
1339 fill_p = 0;
1340 max = 0;
1341 }
1342 else
1343 {
1344 ++input_line_pointer;
1345 if (*input_line_pointer == ',')
1346 fill_p = 0;
1347 else
1348 {
1349 fill = get_absolute_expression ();
1350 SKIP_WHITESPACE ();
1351 fill_p = 1;
1352 }
1353
1354 if (*input_line_pointer != ',')
1355 max = 0;
1356 else
1357 {
1358 ++input_line_pointer;
1359 max = get_absolute_expression ();
1360 }
1361 }
1362
1363 if (!fill_p)
1364 {
1365 if (arg < 0)
1366 as_warn (_("expected fill pattern missing"));
1367 do_align (align, (char *) NULL, 0, max);
1368 }
1369 else
1370 {
1371 int fill_len;
1372
1373 if (arg >= 0)
1374 fill_len = 1;
1375 else
1376 fill_len = -arg;
1377 if (fill_len <= 1)
1378 {
1379 char fill_char;
1380
1381 fill_char = fill;
1382 do_align (align, &fill_char, fill_len, max);
1383 }
1384 else
1385 {
1386 char ab[16];
1387
1388 if ((size_t) fill_len > sizeof ab)
1389 abort ();
1390 md_number_to_chars (ab, fill, fill_len);
1391 do_align (align, ab, fill_len, max);
1392 }
1393 }
1394
1395 demand_empty_rest_of_line ();
1396
1397 if (flag_mri)
1398 mri_comment_end (stop, stopc);
1399 }
1400
1401 /* Handle the .align pseudo-op on machines where ".align 4" means
1402 align to a 4 byte boundary. */
1403
1404 void
1405 s_align_bytes (int arg)
1406 {
1407 s_align (arg, 1);
1408 }
1409
1410 /* Handle the .align pseudo-op on machines where ".align 4" means align
1411 to a 2**4 boundary. */
1412
1413 void
1414 s_align_ptwo (int arg)
1415 {
1416 s_align (arg, 0);
1417 }
1418
1419 /* Switch in and out of alternate macro mode. */
1420
1421 void
1422 s_altmacro (int on)
1423 {
1424 demand_empty_rest_of_line ();
1425 macro_set_alternate (on);
1426 }
1427
1428 symbolS *
1429 s_comm_internal (int param,
1430 symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
1431 {
1432 char *name;
1433 char c;
1434 char *p;
1435 offsetT temp, size;
1436 symbolS *symbolP = NULL;
1437 char *stop = NULL;
1438 char stopc = 0;
1439 expressionS exp;
1440
1441 if (flag_mri)
1442 stop = mri_comment_field (&stopc);
1443
1444 name = input_line_pointer;
1445 c = get_symbol_end ();
1446 /* Just after name is now '\0'. */
1447 p = input_line_pointer;
1448 *p = c;
1449
1450 if (name == p)
1451 {
1452 as_bad (_("expected symbol name"));
1453 ignore_rest_of_line ();
1454 goto out;
1455 }
1456
1457 SKIP_WHITESPACE ();
1458
1459 /* Accept an optional comma after the name. The comma used to be
1460 required, but Irix 5 cc does not generate it for .lcomm. */
1461 if (*input_line_pointer == ',')
1462 input_line_pointer++;
1463
1464 temp = get_absolute_expr (&exp);
1465 size = temp;
1466 size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
1467 if (exp.X_op == O_absent)
1468 {
1469 as_bad (_("missing size expression"));
1470 ignore_rest_of_line ();
1471 goto out;
1472 }
1473 else if (temp != size || !exp.X_unsigned)
1474 {
1475 as_warn (_("size (%ld) out of range, ignored"), (long) temp);
1476 ignore_rest_of_line ();
1477 goto out;
1478 }
1479
1480 *p = 0;
1481 symbolP = symbol_find_or_make (name);
1482 if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
1483 && !S_IS_COMMON (symbolP))
1484 {
1485 if (!S_IS_VOLATILE (symbolP))
1486 {
1487 symbolP = NULL;
1488 as_bad (_("symbol `%s' is already defined"), name);
1489 *p = c;
1490 ignore_rest_of_line ();
1491 goto out;
1492 }
1493 symbolP = symbol_clone (symbolP, 1);
1494 S_SET_SEGMENT (symbolP, undefined_section);
1495 S_SET_VALUE (symbolP, 0);
1496 symbol_set_frag (symbolP, &zero_address_frag);
1497 S_CLEAR_VOLATILE (symbolP);
1498 }
1499
1500 size = S_GET_VALUE (symbolP);
1501 if (size == 0)
1502 size = temp;
1503 else if (size != temp)
1504 as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
1505 name, (long) size, (long) temp);
1506
1507 *p = c;
1508 if (comm_parse_extra != NULL)
1509 symbolP = (*comm_parse_extra) (param, symbolP, size);
1510 else
1511 {
1512 S_SET_VALUE (symbolP, (valueT) size);
1513 S_SET_EXTERNAL (symbolP);
1514 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
1515 #ifdef OBJ_VMS
1516 {
1517 extern int flag_one;
1518 if (size == 0 || !flag_one)
1519 S_GET_OTHER (symbolP) = const_flag;
1520 }
1521 #endif
1522 }
1523
1524 demand_empty_rest_of_line ();
1525 out:
1526 if (flag_mri)
1527 mri_comment_end (stop, stopc);
1528 return symbolP;
1529 }
1530
1531 void
1532 s_comm (int ignore)
1533 {
1534 s_comm_internal (ignore, NULL);
1535 }
1536
1537 /* The MRI COMMON pseudo-op. We handle this by creating a common
1538 symbol with the appropriate name. We make s_space do the right
1539 thing by increasing the size. */
1540
1541 void
1542 s_mri_common (int small ATTRIBUTE_UNUSED)
1543 {
1544 char *name;
1545 char c;
1546 char *alc = NULL;
1547 symbolS *sym;
1548 offsetT align;
1549 char *stop = NULL;
1550 char stopc = 0;
1551
1552 if (!flag_mri)
1553 {
1554 s_comm (0);
1555 return;
1556 }
1557
1558 stop = mri_comment_field (&stopc);
1559
1560 SKIP_WHITESPACE ();
1561
1562 name = input_line_pointer;
1563 if (!ISDIGIT (*name))
1564 c = get_symbol_end ();
1565 else
1566 {
1567 do
1568 {
1569 ++input_line_pointer;
1570 }
1571 while (ISDIGIT (*input_line_pointer));
1572
1573 c = *input_line_pointer;
1574 *input_line_pointer = '\0';
1575
1576 if (line_label != NULL)
1577 {
1578 alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1579 + (input_line_pointer - name)
1580 + 1);
1581 sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1582 name = alc;
1583 }
1584 }
1585
1586 sym = symbol_find_or_make (name);
1587 *input_line_pointer = c;
1588 if (alc != NULL)
1589 free (alc);
1590
1591 if (*input_line_pointer != ',')
1592 align = 0;
1593 else
1594 {
1595 ++input_line_pointer;
1596 align = get_absolute_expression ();
1597 }
1598
1599 if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
1600 {
1601 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
1602 ignore_rest_of_line ();
1603 mri_comment_end (stop, stopc);
1604 return;
1605 }
1606
1607 S_SET_EXTERNAL (sym);
1608 S_SET_SEGMENT (sym, bfd_com_section_ptr);
1609 mri_common_symbol = sym;
1610
1611 #ifdef S_SET_ALIGN
1612 if (align != 0)
1613 S_SET_ALIGN (sym, align);
1614 #else
1615 (void) align;
1616 #endif
1617
1618 if (line_label != NULL)
1619 {
1620 expressionS exp;
1621 exp.X_op = O_symbol;
1622 exp.X_add_symbol = sym;
1623 exp.X_add_number = 0;
1624 symbol_set_value_expression (line_label, &exp);
1625 symbol_set_frag (line_label, &zero_address_frag);
1626 S_SET_SEGMENT (line_label, expr_section);
1627 }
1628
1629 /* FIXME: We just ignore the small argument, which distinguishes
1630 COMMON and COMMON.S. I don't know what we can do about it. */
1631
1632 /* Ignore the type and hptype. */
1633 if (*input_line_pointer == ',')
1634 input_line_pointer += 2;
1635 if (*input_line_pointer == ',')
1636 input_line_pointer += 2;
1637
1638 demand_empty_rest_of_line ();
1639
1640 mri_comment_end (stop, stopc);
1641 }
1642
1643 void
1644 s_data (int ignore ATTRIBUTE_UNUSED)
1645 {
1646 segT section;
1647 int temp;
1648
1649 temp = get_absolute_expression ();
1650 if (flag_readonly_data_in_text)
1651 {
1652 section = text_section;
1653 temp += 1000;
1654 }
1655 else
1656 section = data_section;
1657
1658 subseg_set (section, (subsegT) temp);
1659
1660 #ifdef OBJ_VMS
1661 const_flag = 0;
1662 #endif
1663 demand_empty_rest_of_line ();
1664 }
1665
1666 /* Handle the .appfile pseudo-op. This is automatically generated by
1667 do_scrub_chars when a preprocessor # line comment is seen with a
1668 file name. This default definition may be overridden by the object
1669 or CPU specific pseudo-ops. This function is also the default
1670 definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1671 .file. */
1672
1673 void
1674 s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
1675 {
1676 #ifdef LISTING
1677 if (listing)
1678 listing_source_file (file);
1679 #endif
1680 register_dependency (file);
1681 #ifdef obj_app_file
1682 obj_app_file (file, appfile);
1683 #endif
1684 }
1685
1686 void
1687 s_app_file (int appfile)
1688 {
1689 char *s;
1690 int length;
1691
1692 /* Some assemblers tolerate immediately following '"'. */
1693 if ((s = demand_copy_string (&length)) != 0)
1694 {
1695 int may_omit
1696 = (!new_logical_line_flags (s, -1, 1) && appfile);
1697
1698 /* In MRI mode, the preprocessor may have inserted an extraneous
1699 backquote. */
1700 if (flag_m68k_mri
1701 && *input_line_pointer == '\''
1702 && is_end_of_line[(unsigned char) input_line_pointer[1]])
1703 ++input_line_pointer;
1704
1705 demand_empty_rest_of_line ();
1706 if (!may_omit)
1707 s_app_file_string (s, appfile);
1708 }
1709 }
1710
1711 static int
1712 get_linefile_number (int *flag)
1713 {
1714 SKIP_WHITESPACE ();
1715
1716 if (*input_line_pointer < '0' || *input_line_pointer > '9')
1717 return 0;
1718
1719 *flag = get_absolute_expression ();
1720
1721 return 1;
1722 }
1723
1724 /* Handle the .appline pseudo-op. This is automatically generated by
1725 do_scrub_chars when a preprocessor # line comment is seen. This
1726 default definition may be overridden by the object or CPU specific
1727 pseudo-ops. */
1728
1729 void
1730 s_app_line (int appline)
1731 {
1732 char *file = NULL;
1733 int l;
1734
1735 /* The given number is that of the next line. */
1736 if (appline)
1737 l = get_absolute_expression ();
1738 else if (!get_linefile_number (&l))
1739 {
1740 ignore_rest_of_line ();
1741 return;
1742 }
1743
1744 l--;
1745
1746 if (l < -1)
1747 /* Some of the back ends can't deal with non-positive line numbers.
1748 Besides, it's silly. GCC however will generate a line number of
1749 zero when it is pre-processing builtins for assembler-with-cpp files:
1750
1751 # 0 "<built-in>"
1752
1753 We do not want to barf on this, especially since such files are used
1754 in the GCC and GDB testsuites. So we check for negative line numbers
1755 rather than non-positive line numbers. */
1756 as_warn (_("line numbers must be positive; line number %d rejected"),
1757 l + 1);
1758 else
1759 {
1760 int flags = 0;
1761 int length = 0;
1762
1763 if (!appline)
1764 {
1765 SKIP_WHITESPACE ();
1766
1767 if (*input_line_pointer == '"')
1768 file = demand_copy_string (&length);
1769
1770 if (file)
1771 {
1772 int this_flag;
1773
1774 while (get_linefile_number (&this_flag))
1775 switch (this_flag)
1776 {
1777 /* From GCC's cpp documentation:
1778 1: start of a new file.
1779 2: returning to a file after having included
1780 another file.
1781 3: following text comes from a system header file.
1782 4: following text should be treated as extern "C".
1783
1784 4 is nonsensical for the assembler; 3, we don't
1785 care about, so we ignore it just in case a
1786 system header file is included while
1787 preprocessing assembly. So 1 and 2 are all we
1788 care about, and they are mutually incompatible.
1789 new_logical_line_flags() demands this. */
1790 case 1:
1791 case 2:
1792 if (flags && flags != (1 << this_flag))
1793 as_warn (_("incompatible flag %i in line directive"),
1794 this_flag);
1795 else
1796 flags |= 1 << this_flag;
1797 break;
1798
1799 case 3:
1800 case 4:
1801 /* We ignore these. */
1802 break;
1803
1804 default:
1805 as_warn (_("unsupported flag %i in line directive"),
1806 this_flag);
1807 break;
1808 }
1809
1810 if (!is_end_of_line[(unsigned char)*input_line_pointer])
1811 file = 0;
1812 }
1813 }
1814
1815 if (appline || file)
1816 {
1817 new_logical_line_flags (file, l, flags);
1818 #ifdef LISTING
1819 if (listing)
1820 listing_source_line (l);
1821 #endif
1822 }
1823 }
1824 if (appline || file)
1825 demand_empty_rest_of_line ();
1826 else
1827 ignore_rest_of_line ();
1828 }
1829
1830 /* Handle the .end pseudo-op. Actually, the real work is done in
1831 read_a_source_file. */
1832
1833 void
1834 s_end (int ignore ATTRIBUTE_UNUSED)
1835 {
1836 if (flag_mri)
1837 {
1838 /* The MRI assembler permits the start symbol to follow .end,
1839 but we don't support that. */
1840 SKIP_WHITESPACE ();
1841 if (!is_end_of_line[(unsigned char) *input_line_pointer]
1842 && *input_line_pointer != '*'
1843 && *input_line_pointer != '!')
1844 as_warn (_("start address not supported"));
1845 }
1846 }
1847
1848 /* Handle the .err pseudo-op. */
1849
1850 void
1851 s_err (int ignore ATTRIBUTE_UNUSED)
1852 {
1853 as_bad (_(".err encountered"));
1854 demand_empty_rest_of_line ();
1855 }
1856
1857 /* Handle the .error and .warning pseudo-ops. */
1858
1859 void
1860 s_errwarn (int err)
1861 {
1862 int len;
1863 /* The purpose for the conditional assignment is not to
1864 internationalize the directive itself, but that we need a
1865 self-contained message, one that can be passed like the
1866 demand_copy_C_string return value, and with no assumption on the
1867 location of the name of the directive within the message. */
1868 char *msg
1869 = (err ? _(".error directive invoked in source file")
1870 : _(".warning directive invoked in source file"));
1871
1872 if (!is_it_end_of_statement ())
1873 {
1874 if (*input_line_pointer != '\"')
1875 {
1876 as_bad (_("%s argument must be a string"),
1877 err ? ".error" : ".warning");
1878 ignore_rest_of_line ();
1879 return;
1880 }
1881
1882 msg = demand_copy_C_string (&len);
1883 if (msg == NULL)
1884 return;
1885 }
1886
1887 if (err)
1888 as_bad ("%s", msg);
1889 else
1890 as_warn ("%s", msg);
1891 demand_empty_rest_of_line ();
1892 }
1893
1894 /* Handle the MRI fail pseudo-op. */
1895
1896 void
1897 s_fail (int ignore ATTRIBUTE_UNUSED)
1898 {
1899 offsetT temp;
1900 char *stop = NULL;
1901 char stopc = 0;
1902
1903 if (flag_mri)
1904 stop = mri_comment_field (&stopc);
1905
1906 temp = get_absolute_expression ();
1907 if (temp >= 500)
1908 as_warn (_(".fail %ld encountered"), (long) temp);
1909 else
1910 as_bad (_(".fail %ld encountered"), (long) temp);
1911
1912 demand_empty_rest_of_line ();
1913
1914 if (flag_mri)
1915 mri_comment_end (stop, stopc);
1916 }
1917
1918 void
1919 s_fill (int ignore ATTRIBUTE_UNUSED)
1920 {
1921 expressionS rep_exp;
1922 long size = 1;
1923 long fill = 0;
1924 char *p;
1925
1926 #ifdef md_flush_pending_output
1927 md_flush_pending_output ();
1928 #endif
1929
1930 #ifdef md_cons_align
1931 md_cons_align (1);
1932 #endif
1933
1934 get_known_segmented_expression (&rep_exp);
1935 if (*input_line_pointer == ',')
1936 {
1937 input_line_pointer++;
1938 size = get_absolute_expression ();
1939 if (*input_line_pointer == ',')
1940 {
1941 input_line_pointer++;
1942 fill = get_absolute_expression ();
1943 }
1944 }
1945
1946 /* This is to be compatible with BSD 4.2 AS, not for any rational reason. */
1947 #define BSD_FILL_SIZE_CROCK_8 (8)
1948 if (size > BSD_FILL_SIZE_CROCK_8)
1949 {
1950 as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
1951 size = BSD_FILL_SIZE_CROCK_8;
1952 }
1953 if (size < 0)
1954 {
1955 as_warn (_("size negative; .fill ignored"));
1956 size = 0;
1957 }
1958 else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
1959 {
1960 if (rep_exp.X_add_number < 0)
1961 as_warn (_("repeat < 0; .fill ignored"));
1962 size = 0;
1963 }
1964
1965 if (size && !need_pass_2)
1966 {
1967 if (rep_exp.X_op == O_constant)
1968 {
1969 p = frag_var (rs_fill, (int) size, (int) size,
1970 (relax_substateT) 0, (symbolS *) 0,
1971 (offsetT) rep_exp.X_add_number,
1972 (char *) 0);
1973 }
1974 else
1975 {
1976 /* We don't have a constant repeat count, so we can't use
1977 rs_fill. We can get the same results out of rs_space,
1978 but its argument is in bytes, so we must multiply the
1979 repeat count by size. */
1980
1981 symbolS *rep_sym;
1982 rep_sym = make_expr_symbol (&rep_exp);
1983 if (size != 1)
1984 {
1985 expressionS size_exp;
1986 size_exp.X_op = O_constant;
1987 size_exp.X_add_number = size;
1988
1989 rep_exp.X_op = O_multiply;
1990 rep_exp.X_add_symbol = rep_sym;
1991 rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
1992 rep_exp.X_add_number = 0;
1993 rep_sym = make_expr_symbol (&rep_exp);
1994 }
1995
1996 p = frag_var (rs_space, (int) size, (int) size,
1997 (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
1998 }
1999
2000 memset (p, 0, (unsigned int) size);
2001
2002 /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
2003 flavoured AS. The following bizarre behaviour is to be
2004 compatible with above. I guess they tried to take up to 8
2005 bytes from a 4-byte expression and they forgot to sign
2006 extend. */
2007 #define BSD_FILL_SIZE_CROCK_4 (4)
2008 md_number_to_chars (p, (valueT) fill,
2009 (size > BSD_FILL_SIZE_CROCK_4
2010 ? BSD_FILL_SIZE_CROCK_4
2011 : (int) size));
2012 /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
2013 but emits no error message because it seems a legal thing to do.
2014 It is a degenerate case of .fill but could be emitted by a
2015 compiler. */
2016 }
2017 demand_empty_rest_of_line ();
2018 }
2019
2020 void
2021 s_globl (int ignore ATTRIBUTE_UNUSED)
2022 {
2023 char *name;
2024 int c;
2025 symbolS *symbolP;
2026 char *stop = NULL;
2027 char stopc = 0;
2028
2029 if (flag_mri)
2030 stop = mri_comment_field (&stopc);
2031
2032 do
2033 {
2034 name = input_line_pointer;
2035 c = get_symbol_end ();
2036 symbolP = symbol_find_or_make (name);
2037 S_SET_EXTERNAL (symbolP);
2038
2039 *input_line_pointer = c;
2040 SKIP_WHITESPACE ();
2041 c = *input_line_pointer;
2042 if (c == ',')
2043 {
2044 input_line_pointer++;
2045 SKIP_WHITESPACE ();
2046 if (is_end_of_line[(unsigned char) *input_line_pointer])
2047 c = '\n';
2048 }
2049 }
2050 while (c == ',');
2051
2052 demand_empty_rest_of_line ();
2053
2054 if (flag_mri)
2055 mri_comment_end (stop, stopc);
2056 }
2057
2058 #ifdef OBJ_ELF
2059 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
2060
2061 static inline int
2062 skip_past_char (char ** str, char c)
2063 {
2064 if (**str == c)
2065 {
2066 (*str)++;
2067 return 0;
2068 }
2069 else
2070 return -1;
2071 }
2072 #define skip_past_comma(str) skip_past_char (str, ',')
2073
2074 /* Parse an attribute directive for VENDOR.
2075 Returns the attribute number read, or zero on error. */
2076 int
2077 s_vendor_attribute (int vendor)
2078 {
2079 expressionS exp;
2080 int type;
2081 int tag;
2082 unsigned int i = 0;
2083 char *s = NULL;
2084
2085 /* Read the first number or name. */
2086 skip_whitespace (input_line_pointer);
2087 s = input_line_pointer;
2088 if (ISDIGIT (*input_line_pointer))
2089 {
2090 expression (& exp);
2091 if (exp.X_op != O_constant)
2092 goto bad;
2093 tag = exp.X_add_number;
2094 }
2095 else
2096 {
2097 char *name;
2098
2099 /* A name may contain '_', but no other punctuation. */
2100 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
2101 ++input_line_pointer)
2102 i++;
2103 if (i == 0)
2104 goto bad;
2105
2106 name = (char *) alloca (i + 1);
2107 memcpy (name, s, i);
2108 name[i] = '\0';
2109
2110 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE
2111 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
2112 #endif
2113
2114 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
2115 if (tag == -1)
2116 {
2117 as_bad (_("Attribute name not recognised: %s"), name);
2118 ignore_rest_of_line ();
2119 return 0;
2120 }
2121 }
2122
2123 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
2124
2125 if (skip_past_comma (&input_line_pointer) == -1)
2126 goto bad;
2127 if (type & 1)
2128 {
2129 expression (& exp);
2130 if (exp.X_op != O_constant)
2131 {
2132 as_bad (_("expected numeric constant"));
2133 ignore_rest_of_line ();
2134 return 0;
2135 }
2136 i = exp.X_add_number;
2137 }
2138 if ((type & 3) == 3
2139 && skip_past_comma (&input_line_pointer) == -1)
2140 {
2141 as_bad (_("expected comma"));
2142 ignore_rest_of_line ();
2143 return 0;
2144 }
2145 if (type & 2)
2146 {
2147 int len;
2148
2149 skip_whitespace (input_line_pointer);
2150 if (*input_line_pointer != '"')
2151 goto bad_string;
2152 s = demand_copy_C_string (&len);
2153 }
2154
2155 switch (type & 3)
2156 {
2157 case 3:
2158 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
2159 break;
2160 case 2:
2161 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
2162 break;
2163 case 1:
2164 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
2165 break;
2166 default:
2167 abort ();
2168 }
2169
2170 demand_empty_rest_of_line ();
2171 return tag;
2172 bad_string:
2173 as_bad (_("bad string constant"));
2174 ignore_rest_of_line ();
2175 return 0;
2176 bad:
2177 as_bad (_("expected <tag> , <value>"));
2178 ignore_rest_of_line ();
2179 return 0;
2180 }
2181
2182 /* Parse a .gnu_attribute directive. */
2183
2184 static void
2185 s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
2186 {
2187 s_vendor_attribute (OBJ_ATTR_GNU);
2188 }
2189 #endif /* OBJ_ELF */
2190
2191 /* Handle the MRI IRP and IRPC pseudo-ops. */
2192
2193 void
2194 s_irp (int irpc)
2195 {
2196 char *file, *eol;
2197 unsigned int line;
2198 sb s;
2199 const char *err;
2200 sb out;
2201
2202 as_where (&file, &line);
2203
2204 sb_new (&s);
2205 eol = find_end_of_line (input_line_pointer, 0);
2206 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2207 input_line_pointer = eol;
2208
2209 sb_new (&out);
2210
2211 err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
2212 if (err != NULL)
2213 as_bad_where (file, line, "%s", err);
2214
2215 sb_kill (&s);
2216
2217 input_scrub_include_sb (&out, input_line_pointer, 1);
2218 sb_kill (&out);
2219 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2220 }
2221
2222 /* Handle the .linkonce pseudo-op. This tells the assembler to mark
2223 the section to only be linked once. However, this is not supported
2224 by most object file formats. This takes an optional argument,
2225 which is what to do about duplicates. */
2226
2227 void
2228 s_linkonce (int ignore ATTRIBUTE_UNUSED)
2229 {
2230 enum linkonce_type type;
2231
2232 SKIP_WHITESPACE ();
2233
2234 type = LINKONCE_DISCARD;
2235
2236 if (!is_end_of_line[(unsigned char) *input_line_pointer])
2237 {
2238 char *s;
2239 char c;
2240
2241 s = input_line_pointer;
2242 c = get_symbol_end ();
2243 if (strcasecmp (s, "discard") == 0)
2244 type = LINKONCE_DISCARD;
2245 else if (strcasecmp (s, "one_only") == 0)
2246 type = LINKONCE_ONE_ONLY;
2247 else if (strcasecmp (s, "same_size") == 0)
2248 type = LINKONCE_SAME_SIZE;
2249 else if (strcasecmp (s, "same_contents") == 0)
2250 type = LINKONCE_SAME_CONTENTS;
2251 else
2252 as_warn (_("unrecognized .linkonce type `%s'"), s);
2253
2254 *input_line_pointer = c;
2255 }
2256
2257 #ifdef obj_handle_link_once
2258 obj_handle_link_once (type);
2259 #else /* ! defined (obj_handle_link_once) */
2260 {
2261 flagword flags;
2262
2263 if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
2264 as_warn (_(".linkonce is not supported for this object file format"));
2265
2266 flags = bfd_get_section_flags (stdoutput, now_seg);
2267 flags |= SEC_LINK_ONCE;
2268 switch (type)
2269 {
2270 default:
2271 abort ();
2272 case LINKONCE_DISCARD:
2273 flags |= SEC_LINK_DUPLICATES_DISCARD;
2274 break;
2275 case LINKONCE_ONE_ONLY:
2276 flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
2277 break;
2278 case LINKONCE_SAME_SIZE:
2279 flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
2280 break;
2281 case LINKONCE_SAME_CONTENTS:
2282 flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
2283 break;
2284 }
2285 if (!bfd_set_section_flags (stdoutput, now_seg, flags))
2286 as_bad (_("bfd_set_section_flags: %s"),
2287 bfd_errmsg (bfd_get_error ()));
2288 }
2289 #endif /* ! defined (obj_handle_link_once) */
2290
2291 demand_empty_rest_of_line ();
2292 }
2293
2294 void
2295 bss_alloc (symbolS *symbolP, addressT size, int align)
2296 {
2297 char *pfrag;
2298 segT current_seg = now_seg;
2299 subsegT current_subseg = now_subseg;
2300 segT bss_seg = bss_section;
2301
2302 #if defined (TC_MIPS) || defined (TC_ALPHA)
2303 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
2304 || OUTPUT_FLAVOR == bfd_target_elf_flavour)
2305 {
2306 /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss. */
2307 if (size <= bfd_get_gp_size (stdoutput))
2308 {
2309 bss_seg = subseg_new (".sbss", 1);
2310 seg_info (bss_seg)->bss = 1;
2311 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
2312 as_warn (_("error setting flags for \".sbss\": %s"),
2313 bfd_errmsg (bfd_get_error ()));
2314 }
2315 }
2316 #endif
2317 subseg_set (bss_seg, 1);
2318
2319 if (align)
2320 {
2321 record_alignment (bss_seg, align);
2322 frag_align (align, 0, 0);
2323 }
2324
2325 /* Detach from old frag. */
2326 if (S_GET_SEGMENT (symbolP) == bss_seg)
2327 symbol_get_frag (symbolP)->fr_symbol = NULL;
2328
2329 symbol_set_frag (symbolP, frag_now);
2330 pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
2331 *pfrag = 0;
2332
2333 #ifdef S_SET_SIZE
2334 S_SET_SIZE (symbolP, size);
2335 #endif
2336 S_SET_SEGMENT (symbolP, bss_seg);
2337
2338 #ifdef OBJ_COFF
2339 /* The symbol may already have been created with a preceding
2340 ".globl" directive -- be careful not to step on storage class
2341 in that case. Otherwise, set it to static. */
2342 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
2343 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2344 #endif /* OBJ_COFF */
2345
2346 subseg_set (current_seg, current_subseg);
2347 }
2348
2349 offsetT
2350 parse_align (int align_bytes)
2351 {
2352 expressionS exp;
2353 addressT align;
2354
2355 SKIP_WHITESPACE ();
2356 if (*input_line_pointer != ',')
2357 {
2358 no_align:
2359 as_bad (_("expected alignment after size"));
2360 ignore_rest_of_line ();
2361 return -1;
2362 }
2363
2364 input_line_pointer++;
2365 SKIP_WHITESPACE ();
2366
2367 align = get_absolute_expr (&exp);
2368 if (exp.X_op == O_absent)
2369 goto no_align;
2370
2371 if (!exp.X_unsigned)
2372 {
2373 as_warn (_("alignment negative; 0 assumed"));
2374 align = 0;
2375 }
2376
2377 if (align_bytes && align != 0)
2378 {
2379 /* convert to a power of 2 alignment */
2380 unsigned int alignp2 = 0;
2381 while ((align & 1) == 0)
2382 align >>= 1, ++alignp2;
2383 if (align != 1)
2384 {
2385 as_bad (_("alignment not a power of 2"));
2386 ignore_rest_of_line ();
2387 return -1;
2388 }
2389 align = alignp2;
2390 }
2391 return align;
2392 }
2393
2394 /* Called from s_comm_internal after symbol name and size have been
2395 parsed. NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
2396 1 if this was a ".bss" directive which has a 3rd argument
2397 (alignment as a power of 2), or 2 if this was a ".bss" directive
2398 with alignment in bytes. */
2399
2400 symbolS *
2401 s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
2402 {
2403 addressT align = 0;
2404
2405 if (needs_align)
2406 {
2407 align = parse_align (needs_align - 1);
2408 if (align == (addressT) -1)
2409 return NULL;
2410 }
2411 else
2412 /* Assume some objects may require alignment on some systems. */
2413 TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
2414
2415 bss_alloc (symbolP, size, align);
2416 return symbolP;
2417 }
2418
2419 void
2420 s_lcomm (int needs_align)
2421 {
2422 s_comm_internal (needs_align, s_lcomm_internal);
2423 }
2424
2425 void
2426 s_lcomm_bytes (int needs_align)
2427 {
2428 s_comm_internal (needs_align * 2, s_lcomm_internal);
2429 }
2430
2431 void
2432 s_lsym (int ignore ATTRIBUTE_UNUSED)
2433 {
2434 char *name;
2435 char c;
2436 char *p;
2437 expressionS exp;
2438 symbolS *symbolP;
2439
2440 /* We permit ANY defined expression: BSD4.2 demands constants. */
2441 name = input_line_pointer;
2442 c = get_symbol_end ();
2443 p = input_line_pointer;
2444 *p = c;
2445
2446 if (name == p)
2447 {
2448 as_bad (_("expected symbol name"));
2449 ignore_rest_of_line ();
2450 return;
2451 }
2452
2453 SKIP_WHITESPACE ();
2454
2455 if (*input_line_pointer != ',')
2456 {
2457 *p = 0;
2458 as_bad (_("expected comma after \"%s\""), name);
2459 *p = c;
2460 ignore_rest_of_line ();
2461 return;
2462 }
2463
2464 input_line_pointer++;
2465 expression_and_evaluate (&exp);
2466
2467 if (exp.X_op != O_constant
2468 && exp.X_op != O_register)
2469 {
2470 as_bad (_("bad expression"));
2471 ignore_rest_of_line ();
2472 return;
2473 }
2474
2475 *p = 0;
2476 symbolP = symbol_find_or_make (name);
2477
2478 if (S_GET_SEGMENT (symbolP) == undefined_section)
2479 {
2480 /* The name might be an undefined .global symbol; be sure to
2481 keep the "external" bit. */
2482 S_SET_SEGMENT (symbolP,
2483 (exp.X_op == O_constant
2484 ? absolute_section
2485 : reg_section));
2486 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2487 }
2488 else
2489 {
2490 as_bad (_("symbol `%s' is already defined"), name);
2491 }
2492
2493 *p = c;
2494 demand_empty_rest_of_line ();
2495 }
2496
2497 /* Read a line into an sb. Returns the character that ended the line
2498 or zero if there are no more lines. */
2499
2500 static int
2501 get_line_sb (sb *line, int in_macro)
2502 {
2503 char *eol;
2504
2505 if (input_line_pointer[-1] == '\n')
2506 bump_line_counters ();
2507
2508 if (input_line_pointer >= buffer_limit)
2509 {
2510 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2511 if (buffer_limit == 0)
2512 return 0;
2513 }
2514
2515 eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
2516 sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
2517 input_line_pointer = eol;
2518
2519 /* Don't skip multiple end-of-line characters, because that breaks support
2520 for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
2521 characters but isn't. Instead just skip one end of line character and
2522 return the character skipped so that the caller can re-insert it if
2523 necessary. */
2524 return *input_line_pointer++;
2525 }
2526
2527 static int
2528 get_non_macro_line_sb (sb *line)
2529 {
2530 return get_line_sb (line, 0);
2531 }
2532
2533 static int
2534 get_macro_line_sb (sb *line)
2535 {
2536 return get_line_sb (line, 1);
2537 }
2538
2539 /* Define a macro. This is an interface to macro.c. */
2540
2541 void
2542 s_macro (int ignore ATTRIBUTE_UNUSED)
2543 {
2544 char *file, *eol;
2545 unsigned int line;
2546 sb s;
2547 const char *err;
2548 const char *name;
2549
2550 as_where (&file, &line);
2551
2552 sb_new (&s);
2553 eol = find_end_of_line (input_line_pointer, 0);
2554 sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
2555 input_line_pointer = eol;
2556
2557 if (line_label != NULL)
2558 {
2559 sb label;
2560
2561 sb_new (&label);
2562 sb_add_string (&label, S_GET_NAME (line_label));
2563 err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
2564 sb_kill (&label);
2565 }
2566 else
2567 err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
2568 if (err != NULL)
2569 as_bad_where (file, line, err, name);
2570 else
2571 {
2572 if (line_label != NULL)
2573 {
2574 S_SET_SEGMENT (line_label, absolute_section);
2575 S_SET_VALUE (line_label, 0);
2576 symbol_set_frag (line_label, &zero_address_frag);
2577 }
2578
2579 if (((NO_PSEUDO_DOT || flag_m68k_mri)
2580 && hash_find (po_hash, name) != NULL)
2581 || (!flag_m68k_mri
2582 && *name == '.'
2583 && hash_find (po_hash, name + 1) != NULL))
2584 as_warn_where (file,
2585 line,
2586 _("attempt to redefine pseudo-op `%s' ignored"),
2587 name);
2588 }
2589
2590 sb_kill (&s);
2591 }
2592
2593 /* Handle the .mexit pseudo-op, which immediately exits a macro
2594 expansion. */
2595
2596 void
2597 s_mexit (int ignore ATTRIBUTE_UNUSED)
2598 {
2599 if (macro_nest)
2600 {
2601 cond_exit_macro (macro_nest);
2602 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2603 }
2604 else
2605 as_warn (_("ignoring macro exit outside a macro definition."));
2606 }
2607
2608 /* Switch in and out of MRI mode. */
2609
2610 void
2611 s_mri (int ignore ATTRIBUTE_UNUSED)
2612 {
2613 int on;
2614 #ifdef MRI_MODE_CHANGE
2615 int old_flag;
2616 #endif
2617
2618 on = get_absolute_expression ();
2619 #ifdef MRI_MODE_CHANGE
2620 old_flag = flag_mri;
2621 #endif
2622 if (on != 0)
2623 {
2624 flag_mri = 1;
2625 #ifdef TC_M68K
2626 flag_m68k_mri = 1;
2627 #endif
2628 macro_mri_mode (1);
2629 }
2630 else
2631 {
2632 flag_mri = 0;
2633 #ifdef TC_M68K
2634 flag_m68k_mri = 0;
2635 #endif
2636 macro_mri_mode (0);
2637 }
2638
2639 /* Operator precedence changes in m68k MRI mode, so we need to
2640 update the operator rankings. */
2641 expr_set_precedence ();
2642
2643 #ifdef MRI_MODE_CHANGE
2644 if (on != old_flag)
2645 MRI_MODE_CHANGE (on);
2646 #endif
2647
2648 demand_empty_rest_of_line ();
2649 }
2650
2651 /* Handle changing the location counter. */
2652
2653 static void
2654 do_org (segT segment, expressionS *exp, int fill)
2655 {
2656 if (segment != now_seg
2657 && segment != absolute_section
2658 && segment != expr_section)
2659 as_bad (_("invalid segment \"%s\""), segment_name (segment));
2660
2661 if (now_seg == absolute_section)
2662 {
2663 if (fill != 0)
2664 as_warn (_("ignoring fill value in absolute section"));
2665 if (exp->X_op != O_constant)
2666 {
2667 as_bad (_("only constant offsets supported in absolute section"));
2668 exp->X_add_number = 0;
2669 }
2670 abs_section_offset = exp->X_add_number;
2671 }
2672 else
2673 {
2674 char *p;
2675 symbolS *sym = exp->X_add_symbol;
2676 offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
2677
2678 if (exp->X_op != O_constant && exp->X_op != O_symbol)
2679 {
2680 /* Handle complex expressions. */
2681 sym = make_expr_symbol (exp);
2682 off = 0;
2683 }
2684
2685 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
2686 *p = fill;
2687 }
2688 }
2689
2690 void
2691 s_org (int ignore ATTRIBUTE_UNUSED)
2692 {
2693 segT segment;
2694 expressionS exp;
2695 long temp_fill;
2696
2697 #ifdef md_flush_pending_output
2698 md_flush_pending_output ();
2699 #endif
2700
2701 /* The m68k MRI assembler has a different meaning for .org. It
2702 means to create an absolute section at a given address. We can't
2703 support that--use a linker script instead. */
2704 if (flag_m68k_mri)
2705 {
2706 as_bad (_("MRI style ORG pseudo-op not supported"));
2707 ignore_rest_of_line ();
2708 return;
2709 }
2710
2711 /* Don't believe the documentation of BSD 4.2 AS. There is no such
2712 thing as a sub-segment-relative origin. Any absolute origin is
2713 given a warning, then assumed to be segment-relative. Any
2714 segmented origin expression ("foo+42") had better be in the right
2715 segment or the .org is ignored.
2716
2717 BSD 4.2 AS warns if you try to .org backwards. We cannot because
2718 we never know sub-segment sizes when we are reading code. BSD
2719 will crash trying to emit negative numbers of filler bytes in
2720 certain .orgs. We don't crash, but see as-write for that code.
2721
2722 Don't make frag if need_pass_2==1. */
2723 segment = get_known_segmented_expression (&exp);
2724 if (*input_line_pointer == ',')
2725 {
2726 input_line_pointer++;
2727 temp_fill = get_absolute_expression ();
2728 }
2729 else
2730 temp_fill = 0;
2731
2732 if (!need_pass_2)
2733 do_org (segment, &exp, temp_fill);
2734
2735 demand_empty_rest_of_line ();
2736 }
2737
2738 /* Handle parsing for the MRI SECT/SECTION pseudo-op. This should be
2739 called by the obj-format routine which handles section changing
2740 when in MRI mode. It will create a new section, and return it. It
2741 will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2742 'M' (mixed), or 'R' (romable). The flags will be set in the section. */
2743
2744 void
2745 s_mri_sect (char *type ATTRIBUTE_UNUSED)
2746 {
2747 #ifdef TC_M68K
2748
2749 char *name;
2750 char c;
2751 segT seg;
2752
2753 SKIP_WHITESPACE ();
2754
2755 name = input_line_pointer;
2756 if (!ISDIGIT (*name))
2757 c = get_symbol_end ();
2758 else
2759 {
2760 do
2761 {
2762 ++input_line_pointer;
2763 }
2764 while (ISDIGIT (*input_line_pointer));
2765
2766 c = *input_line_pointer;
2767 *input_line_pointer = '\0';
2768 }
2769
2770 name = xstrdup (name);
2771
2772 *input_line_pointer = c;
2773
2774 seg = subseg_new (name, 0);
2775
2776 if (*input_line_pointer == ',')
2777 {
2778 int align;
2779
2780 ++input_line_pointer;
2781 align = get_absolute_expression ();
2782 record_alignment (seg, align);
2783 }
2784
2785 *type = 'C';
2786 if (*input_line_pointer == ',')
2787 {
2788 c = *++input_line_pointer;
2789 c = TOUPPER (c);
2790 if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2791 *type = c;
2792 else
2793 as_bad (_("unrecognized section type"));
2794 ++input_line_pointer;
2795
2796 {
2797 flagword flags;
2798
2799 flags = SEC_NO_FLAGS;
2800 if (*type == 'C')
2801 flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2802 else if (*type == 'D' || *type == 'M')
2803 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2804 else if (*type == 'R')
2805 flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2806 if (flags != SEC_NO_FLAGS)
2807 {
2808 if (!bfd_set_section_flags (stdoutput, seg, flags))
2809 as_warn (_("error setting flags for \"%s\": %s"),
2810 bfd_section_name (stdoutput, seg),
2811 bfd_errmsg (bfd_get_error ()));
2812 }
2813 }
2814 }
2815
2816 /* Ignore the HP type. */
2817 if (*input_line_pointer == ',')
2818 input_line_pointer += 2;
2819
2820 demand_empty_rest_of_line ();
2821
2822 #else /* ! TC_M68K */
2823 #ifdef TC_I960
2824
2825 char *name;
2826 char c;
2827 segT seg;
2828
2829 SKIP_WHITESPACE ();
2830
2831 name = input_line_pointer;
2832 c = get_symbol_end ();
2833
2834 name = xstrdup (name);
2835
2836 *input_line_pointer = c;
2837
2838 seg = subseg_new (name, 0);
2839
2840 if (*input_line_pointer != ',')
2841 *type = 'C';
2842 else
2843 {
2844 char *sectype;
2845
2846 ++input_line_pointer;
2847 SKIP_WHITESPACE ();
2848 sectype = input_line_pointer;
2849 c = get_symbol_end ();
2850 if (*sectype == '\0')
2851 *type = 'C';
2852 else if (strcasecmp (sectype, "text") == 0)
2853 *type = 'C';
2854 else if (strcasecmp (sectype, "data") == 0)
2855 *type = 'D';
2856 else if (strcasecmp (sectype, "romdata") == 0)
2857 *type = 'R';
2858 else
2859 as_warn (_("unrecognized section type `%s'"), sectype);
2860 *input_line_pointer = c;
2861 }
2862
2863 if (*input_line_pointer == ',')
2864 {
2865 char *seccmd;
2866
2867 ++input_line_pointer;
2868 SKIP_WHITESPACE ();
2869 seccmd = input_line_pointer;
2870 c = get_symbol_end ();
2871 if (strcasecmp (seccmd, "absolute") == 0)
2872 {
2873 as_bad (_("absolute sections are not supported"));
2874 *input_line_pointer = c;
2875 ignore_rest_of_line ();
2876 return;
2877 }
2878 else if (strcasecmp (seccmd, "align") == 0)
2879 {
2880 int align;
2881
2882 *input_line_pointer = c;
2883 align = get_absolute_expression ();
2884 record_alignment (seg, align);
2885 }
2886 else
2887 {
2888 as_warn (_("unrecognized section command `%s'"), seccmd);
2889 *input_line_pointer = c;
2890 }
2891 }
2892
2893 demand_empty_rest_of_line ();
2894
2895 #else /* ! TC_I960 */
2896 /* The MRI assembler seems to use different forms of .sect for
2897 different targets. */
2898 as_bad ("MRI mode not supported for this target");
2899 ignore_rest_of_line ();
2900 #endif /* ! TC_I960 */
2901 #endif /* ! TC_M68K */
2902 }
2903
2904 /* Handle the .print pseudo-op. */
2905
2906 void
2907 s_print (int ignore ATTRIBUTE_UNUSED)
2908 {
2909 char *s;
2910 int len;
2911
2912 s = demand_copy_C_string (&len);
2913 if (s != NULL)
2914 printf ("%s\n", s);
2915 demand_empty_rest_of_line ();
2916 }
2917
2918 /* Handle the .purgem pseudo-op. */
2919
2920 void
2921 s_purgem (int ignore ATTRIBUTE_UNUSED)
2922 {
2923 if (is_it_end_of_statement ())
2924 {
2925 demand_empty_rest_of_line ();
2926 return;
2927 }
2928
2929 do
2930 {
2931 char *name;
2932 char c;
2933
2934 SKIP_WHITESPACE ();
2935 name = input_line_pointer;
2936 c = get_symbol_end ();
2937 delete_macro (name);
2938 *input_line_pointer = c;
2939 SKIP_WHITESPACE ();
2940 }
2941 while (*input_line_pointer++ == ',');
2942
2943 --input_line_pointer;
2944 demand_empty_rest_of_line ();
2945 }
2946
2947 /* Handle the .endm/.endr pseudo-ops. */
2948
2949 static void
2950 s_bad_end (int endr)
2951 {
2952 as_warn (_(".end%c encountered without preceeding %s"),
2953 endr ? 'r' : 'm',
2954 endr ? ".rept, .irp, or .irpc" : ".macro");
2955 demand_empty_rest_of_line ();
2956 }
2957
2958 /* Handle the .rept pseudo-op. */
2959
2960 void
2961 s_rept (int ignore ATTRIBUTE_UNUSED)
2962 {
2963 int count;
2964
2965 count = get_absolute_expression ();
2966
2967 do_repeat (count, "REPT", "ENDR");
2968 }
2969
2970 /* This function provides a generic repeat block implementation. It allows
2971 different directives to be used as the start/end keys. */
2972
2973 void
2974 do_repeat (int count, const char *start, const char *end)
2975 {
2976 sb one;
2977 sb many;
2978
2979 sb_new (&one);
2980 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
2981 {
2982 as_bad (_("%s without %s"), start, end);
2983 return;
2984 }
2985
2986 sb_new (&many);
2987 while (count-- > 0)
2988 sb_add_sb (&many, &one);
2989
2990 sb_kill (&one);
2991
2992 input_scrub_include_sb (&many, input_line_pointer, 1);
2993 sb_kill (&many);
2994 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2995 }
2996
2997 /* Like do_repeat except that any text matching EXPANDER in the
2998 block is replaced by the itteration count. */
2999
3000 void
3001 do_repeat_with_expander (int count,
3002 const char * start,
3003 const char * end,
3004 const char * expander)
3005 {
3006 sb one;
3007 sb many;
3008
3009 sb_new (&one);
3010 if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
3011 {
3012 as_bad (_("%s without %s"), start, end);
3013 return;
3014 }
3015
3016 sb_new (&many);
3017
3018 if (expander != NULL && strstr (one.ptr, expander) != NULL)
3019 {
3020 while (count -- > 0)
3021 {
3022 int len;
3023 char * sub;
3024 sb processed;
3025
3026 sb_new (& processed);
3027 sb_add_sb (& processed, & one);
3028 sub = strstr (processed.ptr, expander);
3029 len = sprintf (sub, "%d", count);
3030 gas_assert (len < 8);
3031 strcpy (sub + len, sub + 8);
3032 processed.len -= (8 - len);
3033 sb_add_sb (& many, & processed);
3034 sb_kill (& processed);
3035 }
3036 }
3037 else
3038 while (count-- > 0)
3039 sb_add_sb (&many, &one);
3040
3041 sb_kill (&one);
3042
3043 input_scrub_include_sb (&many, input_line_pointer, 1);
3044 sb_kill (&many);
3045 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3046 }
3047
3048 /* Skip to end of current repeat loop; EXTRA indicates how many additional
3049 input buffers to skip. Assumes that conditionals preceding the loop end
3050 are properly nested.
3051
3052 This function makes it easier to implement a premature "break" out of the
3053 loop. The EXTRA arg accounts for other buffers we might have inserted,
3054 such as line substitutions. */
3055
3056 void
3057 end_repeat (int extra)
3058 {
3059 cond_exit_macro (macro_nest);
3060 while (extra-- >= 0)
3061 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
3062 }
3063
3064 static void
3065 assign_symbol (char *name, int mode)
3066 {
3067 symbolS *symbolP;
3068
3069 if (name[0] == '.' && name[1] == '\0')
3070 {
3071 /* Turn '. = mumble' into a .org mumble. */
3072 segT segment;
3073 expressionS exp;
3074
3075 segment = get_known_segmented_expression (&exp);
3076
3077 if (!need_pass_2)
3078 do_org (segment, &exp, 0);
3079
3080 return;
3081 }
3082
3083 if ((symbolP = symbol_find (name)) == NULL
3084 && (symbolP = md_undefined_symbol (name)) == NULL)
3085 {
3086 symbolP = symbol_find_or_make (name);
3087 #ifndef NO_LISTING
3088 /* When doing symbol listings, play games with dummy fragments living
3089 outside the normal fragment chain to record the file and line info
3090 for this symbol. */
3091 if (listing & LISTING_SYMBOLS)
3092 {
3093 extern struct list_info_struct *listing_tail;
3094 fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
3095 dummy_frag->line = listing_tail;
3096 dummy_frag->fr_symbol = symbolP;
3097 symbol_set_frag (symbolP, dummy_frag);
3098 }
3099 #endif
3100 #ifdef OBJ_COFF
3101 /* "set" symbols are local unless otherwise specified. */
3102 SF_SET_LOCAL (symbolP);
3103 #endif
3104 }
3105
3106 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3107 {
3108 /* Permit register names to be redefined. */
3109 if ((mode != 0 || !S_IS_VOLATILE (symbolP))
3110 && S_GET_SEGMENT (symbolP) != reg_section)
3111 {
3112 as_bad (_("symbol `%s' is already defined"), name);
3113 symbolP = symbol_clone (symbolP, 0);
3114 }
3115 /* If the symbol is volatile, copy the symbol and replace the
3116 original with the copy, so that previous uses of the symbol will
3117 retain the value of the symbol at the point of use. */
3118 else if (S_IS_VOLATILE (symbolP))
3119 symbolP = symbol_clone (symbolP, 1);
3120 }
3121
3122 if (mode == 0)
3123 S_SET_VOLATILE (symbolP);
3124 else if (mode < 0)
3125 S_SET_FORWARD_REF (symbolP);
3126
3127 pseudo_set (symbolP);
3128 }
3129
3130 /* Handle the .equ, .equiv, .eqv, and .set directives. If EQUIV is 1,
3131 then this is .equiv, and it is an error if the symbol is already
3132 defined. If EQUIV is -1, the symbol additionally is a forward
3133 reference. */
3134
3135 void
3136 s_set (int equiv)
3137 {
3138 char *name;
3139 char delim;
3140 char *end_name;
3141
3142 /* Especial apologies for the random logic:
3143 this just grew, and could be parsed much more simply!
3144 Dean in haste. */
3145 name = input_line_pointer;
3146 delim = get_symbol_end ();
3147 end_name = input_line_pointer;
3148 *end_name = delim;
3149
3150 if (name == end_name)
3151 {
3152 as_bad (_("expected symbol name"));
3153 ignore_rest_of_line ();
3154 return;
3155 }
3156
3157 SKIP_WHITESPACE ();
3158
3159 if (*input_line_pointer != ',')
3160 {
3161 *end_name = 0;
3162 as_bad (_("expected comma after \"%s\""), name);
3163 *end_name = delim;
3164 ignore_rest_of_line ();
3165 return;
3166 }
3167
3168 input_line_pointer++;
3169 *end_name = 0;
3170
3171 assign_symbol (name, equiv);
3172 *end_name = delim;
3173
3174 demand_empty_rest_of_line ();
3175 }
3176
3177 void
3178 s_space (int mult)
3179 {
3180 expressionS exp;
3181 expressionS val;
3182 char *p = 0;
3183 char *stop = NULL;
3184 char stopc = 0;
3185 int bytes;
3186
3187 #ifdef md_flush_pending_output
3188 md_flush_pending_output ();
3189 #endif
3190
3191 #ifdef md_cons_align
3192 md_cons_align (1);
3193 #endif
3194
3195 if (flag_mri)
3196 stop = mri_comment_field (&stopc);
3197
3198 /* In m68k MRI mode, we need to align to a word boundary, unless
3199 this is ds.b. */
3200 if (flag_m68k_mri && mult > 1)
3201 {
3202 if (now_seg == absolute_section)
3203 {
3204 abs_section_offset += abs_section_offset & 1;
3205 if (line_label != NULL)
3206 S_SET_VALUE (line_label, abs_section_offset);
3207 }
3208 else if (mri_common_symbol != NULL)
3209 {
3210 valueT mri_val;
3211
3212 mri_val = S_GET_VALUE (mri_common_symbol);
3213 if ((mri_val & 1) != 0)
3214 {
3215 S_SET_VALUE (mri_common_symbol, mri_val + 1);
3216 if (line_label != NULL)
3217 {
3218 expressionS *symexp;
3219
3220 symexp = symbol_get_value_expression (line_label);
3221 know (symexp->X_op == O_symbol);
3222 know (symexp->X_add_symbol == mri_common_symbol);
3223 symexp->X_add_number += 1;
3224 }
3225 }
3226 }
3227 else
3228 {
3229 do_align (1, (char *) NULL, 0, 0);
3230 if (line_label != NULL)
3231 {
3232 symbol_set_frag (line_label, frag_now);
3233 S_SET_VALUE (line_label, frag_now_fix ());
3234 }
3235 }
3236 }
3237
3238 bytes = mult;
3239
3240 expression (&exp);
3241
3242 SKIP_WHITESPACE ();
3243 if (*input_line_pointer == ',')
3244 {
3245 ++input_line_pointer;
3246 expression (&val);
3247 }
3248 else
3249 {
3250 val.X_op = O_constant;
3251 val.X_add_number = 0;
3252 }
3253
3254 if (val.X_op != O_constant
3255 || val.X_add_number < - 0x80
3256 || val.X_add_number > 0xff
3257 || (mult != 0 && mult != 1 && val.X_add_number != 0))
3258 {
3259 resolve_expression (&exp);
3260 if (exp.X_op != O_constant)
3261 as_bad (_("unsupported variable size or fill value"));
3262 else
3263 {
3264 offsetT i;
3265
3266 if (mult == 0)
3267 mult = 1;
3268 bytes = mult * exp.X_add_number;
3269 for (i = 0; i < exp.X_add_number; i++)
3270 emit_expr (&val, mult);
3271 }
3272 }
3273 else
3274 {
3275 if (now_seg == absolute_section || mri_common_symbol != NULL)
3276 resolve_expression (&exp);
3277
3278 if (exp.X_op == O_constant)
3279 {
3280 offsetT repeat;
3281
3282 repeat = exp.X_add_number;
3283 if (mult)
3284 repeat *= mult;
3285 bytes = repeat;
3286 if (repeat <= 0)
3287 {
3288 if (!flag_mri)
3289 as_warn (_(".space repeat count is zero, ignored"));
3290 else if (repeat < 0)
3291 as_warn (_(".space repeat count is negative, ignored"));
3292 goto getout;
3293 }
3294
3295 /* If we are in the absolute section, just bump the offset. */
3296 if (now_seg == absolute_section)
3297 {
3298 abs_section_offset += repeat;
3299 goto getout;
3300 }
3301
3302 /* If we are secretly in an MRI common section, then
3303 creating space just increases the size of the common
3304 symbol. */
3305 if (mri_common_symbol != NULL)
3306 {
3307 S_SET_VALUE (mri_common_symbol,
3308 S_GET_VALUE (mri_common_symbol) + repeat);
3309 goto getout;
3310 }
3311
3312 if (!need_pass_2)
3313 p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
3314 (offsetT) repeat, (char *) 0);
3315 }
3316 else
3317 {
3318 if (now_seg == absolute_section)
3319 {
3320 as_bad (_("space allocation too complex in absolute section"));
3321 subseg_set (text_section, 0);
3322 }
3323
3324 if (mri_common_symbol != NULL)
3325 {
3326 as_bad (_("space allocation too complex in common section"));
3327 mri_common_symbol = NULL;
3328 }
3329
3330 if (!need_pass_2)
3331 p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
3332 make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
3333 }
3334
3335 if (p)
3336 *p = val.X_add_number;
3337 }
3338
3339 getout:
3340
3341 /* In MRI mode, after an odd number of bytes, we must align to an
3342 even word boundary, unless the next instruction is a dc.b, ds.b
3343 or dcb.b. */
3344 if (flag_mri && (bytes & 1) != 0)
3345 mri_pending_align = 1;
3346
3347 demand_empty_rest_of_line ();
3348
3349 if (flag_mri)
3350 mri_comment_end (stop, stopc);
3351 }
3352
3353 /* This is like s_space, but the value is a floating point number with
3354 the given precision. This is for the MRI dcb.s pseudo-op and
3355 friends. */
3356
3357 void
3358 s_float_space (int float_type)
3359 {
3360 offsetT count;
3361 int flen;
3362 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3363 char *stop = NULL;
3364 char stopc = 0;
3365
3366 #ifdef md_cons_align
3367 md_cons_align (1);
3368 #endif
3369
3370 if (flag_mri)
3371 stop = mri_comment_field (&stopc);
3372
3373 count = get_absolute_expression ();
3374
3375 SKIP_WHITESPACE ();
3376 if (*input_line_pointer != ',')
3377 {
3378 as_bad (_("missing value"));
3379 ignore_rest_of_line ();
3380 if (flag_mri)
3381 mri_comment_end (stop, stopc);
3382 return;
3383 }
3384
3385 ++input_line_pointer;
3386
3387 SKIP_WHITESPACE ();
3388
3389 /* Skip any 0{letter} that may be present. Don't even check if the
3390 * letter is legal. */
3391 if (input_line_pointer[0] == '0'
3392 && ISALPHA (input_line_pointer[1]))
3393 input_line_pointer += 2;
3394
3395 /* Accept :xxxx, where the x's are hex digits, for a floating point
3396 with the exact digits specified. */
3397 if (input_line_pointer[0] == ':')
3398 {
3399 flen = hex_float (float_type, temp);
3400 if (flen < 0)
3401 {
3402 ignore_rest_of_line ();
3403 if (flag_mri)
3404 mri_comment_end (stop, stopc);
3405 return;
3406 }
3407 }
3408 else
3409 {
3410 char *err;
3411
3412 err = md_atof (float_type, temp, &flen);
3413 know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3414 know (err != NULL || flen > 0);
3415 if (err)
3416 {
3417 as_bad (_("bad floating literal: %s"), err);
3418 ignore_rest_of_line ();
3419 if (flag_mri)
3420 mri_comment_end (stop, stopc);
3421 return;
3422 }
3423 }
3424
3425 while (--count >= 0)
3426 {
3427 char *p;
3428
3429 p = frag_more (flen);
3430 memcpy (p, temp, (unsigned int) flen);
3431 }
3432
3433 demand_empty_rest_of_line ();
3434
3435 if (flag_mri)
3436 mri_comment_end (stop, stopc);
3437 }
3438
3439 /* Handle the .struct pseudo-op, as found in MIPS assemblers. */
3440
3441 void
3442 s_struct (int ignore ATTRIBUTE_UNUSED)
3443 {
3444 char *stop = NULL;
3445 char stopc = 0;
3446
3447 if (flag_mri)
3448 stop = mri_comment_field (&stopc);
3449 abs_section_offset = get_absolute_expression ();
3450 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3451 /* The ELF backend needs to know that we are changing sections, so
3452 that .previous works correctly. */
3453 if (IS_ELF)
3454 obj_elf_section_change_hook ();
3455 #endif
3456 subseg_set (absolute_section, 0);
3457 demand_empty_rest_of_line ();
3458 if (flag_mri)
3459 mri_comment_end (stop, stopc);
3460 }
3461
3462 void
3463 s_text (int ignore ATTRIBUTE_UNUSED)
3464 {
3465 int temp;
3466
3467 temp = get_absolute_expression ();
3468 subseg_set (text_section, (subsegT) temp);
3469 demand_empty_rest_of_line ();
3470 #ifdef OBJ_VMS
3471 const_flag &= ~IN_DEFAULT_SECTION;
3472 #endif
3473 }
3474
3475 /* .weakref x, y sets x as an alias to y that, as long as y is not
3476 referenced directly, will cause y to become a weak symbol. */
3477 void
3478 s_weakref (int ignore ATTRIBUTE_UNUSED)
3479 {
3480 char *name;
3481 char delim;
3482 char *end_name;
3483 symbolS *symbolP;
3484 symbolS *symbolP2;
3485 expressionS exp;
3486
3487 name = input_line_pointer;
3488 delim = get_symbol_end ();
3489 end_name = input_line_pointer;
3490
3491 if (name == end_name)
3492 {
3493 as_bad (_("expected symbol name"));
3494 *end_name = delim;
3495 ignore_rest_of_line ();
3496 return;
3497 }
3498
3499 symbolP = symbol_find_or_make (name);
3500
3501 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3502 {
3503 if (!S_IS_VOLATILE (symbolP))
3504 {
3505 as_bad (_("symbol `%s' is already defined"), name);
3506 *end_name = delim;
3507 ignore_rest_of_line ();
3508 return;
3509 }
3510 symbolP = symbol_clone (symbolP, 1);
3511 S_CLEAR_VOLATILE (symbolP);
3512 }
3513
3514 *end_name = delim;
3515
3516 SKIP_WHITESPACE ();
3517
3518 if (*input_line_pointer != ',')
3519 {
3520 *end_name = 0;
3521 as_bad (_("expected comma after \"%s\""), name);
3522 *end_name = delim;
3523 ignore_rest_of_line ();
3524 return;
3525 }
3526
3527 input_line_pointer++;
3528
3529 SKIP_WHITESPACE ();
3530
3531 name = input_line_pointer;
3532 delim = get_symbol_end ();
3533 end_name = input_line_pointer;
3534
3535 if (name == end_name)
3536 {
3537 as_bad (_("expected symbol name"));
3538 ignore_rest_of_line ();
3539 return;
3540 }
3541
3542 if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3543 && (symbolP2 = md_undefined_symbol (name)) == NULL)
3544 {
3545 symbolP2 = symbol_find_or_make (name);
3546 S_SET_WEAKREFD (symbolP2);
3547 }
3548 else
3549 {
3550 symbolS *symp = symbolP2;
3551
3552 while (S_IS_WEAKREFR (symp) && symp != symbolP)
3553 {
3554 expressionS *expP = symbol_get_value_expression (symp);
3555
3556 gas_assert (expP->X_op == O_symbol
3557 && expP->X_add_number == 0);
3558 symp = expP->X_add_symbol;
3559 }
3560 if (symp == symbolP)
3561 {
3562 char *loop;
3563
3564 loop = concat (S_GET_NAME (symbolP),
3565 " => ", S_GET_NAME (symbolP2), (const char *) NULL);
3566
3567 symp = symbolP2;
3568 while (symp != symbolP)
3569 {
3570 char *old_loop = loop;
3571 symp = symbol_get_value_expression (symp)->X_add_symbol;
3572 loop = concat (loop, " => ", S_GET_NAME (symp),
3573 (const char *) NULL);
3574 free (old_loop);
3575 }
3576
3577 as_bad (_("%s: would close weakref loop: %s"),
3578 S_GET_NAME (symbolP), loop);
3579
3580 free (loop);
3581
3582 *end_name = delim;
3583 ignore_rest_of_line ();
3584 return;
3585 }
3586
3587 /* Short-circuiting instead of just checking here might speed
3588 things up a tiny little bit, but loop error messages would
3589 miss intermediate links. */
3590 /* symbolP2 = symp; */
3591 }
3592
3593 *end_name = delim;
3594
3595 memset (&exp, 0, sizeof (exp));
3596 exp.X_op = O_symbol;
3597 exp.X_add_symbol = symbolP2;
3598
3599 S_SET_SEGMENT (symbolP, undefined_section);
3600 symbol_set_value_expression (symbolP, &exp);
3601 symbol_set_frag (symbolP, &zero_address_frag);
3602 S_SET_WEAKREFR (symbolP);
3603
3604 demand_empty_rest_of_line ();
3605 }
3606 \f
3607
3608 /* Verify that we are at the end of a line. If not, issue an error and
3609 skip to EOL. */
3610
3611 void
3612 demand_empty_rest_of_line (void)
3613 {
3614 SKIP_WHITESPACE ();
3615 if (is_end_of_line[(unsigned char) *input_line_pointer])
3616 input_line_pointer++;
3617 else
3618 {
3619 if (ISPRINT (*input_line_pointer))
3620 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
3621 *input_line_pointer);
3622 else
3623 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
3624 *input_line_pointer);
3625 ignore_rest_of_line ();
3626 }
3627
3628 /* Return pointing just after end-of-line. */
3629 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3630 }
3631
3632 /* Silently advance to the end of line. Use this after already having
3633 issued an error about something bad. */
3634
3635 void
3636 ignore_rest_of_line (void)
3637 {
3638 while (input_line_pointer < buffer_limit
3639 && !is_end_of_line[(unsigned char) *input_line_pointer])
3640 input_line_pointer++;
3641
3642 input_line_pointer++;
3643
3644 /* Return pointing just after end-of-line. */
3645 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3646 }
3647
3648 /* Sets frag for given symbol to zero_address_frag, except when the
3649 symbol frag is already set to a dummy listing frag. */
3650
3651 static void
3652 set_zero_frag (symbolS *symbolP)
3653 {
3654 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3655 symbol_set_frag (symbolP, &zero_address_frag);
3656 }
3657
3658 /* In: Pointer to a symbol.
3659 Input_line_pointer->expression.
3660
3661 Out: Input_line_pointer->just after any whitespace after expression.
3662 Tried to set symbol to value of expression.
3663 Will change symbols type, value, and frag; */
3664
3665 void
3666 pseudo_set (symbolS *symbolP)
3667 {
3668 expressionS exp;
3669 segT seg;
3670
3671 know (symbolP); /* NULL pointer is logic error. */
3672
3673 if (!S_IS_FORWARD_REF (symbolP))
3674 (void) expression (&exp);
3675 else
3676 (void) deferred_expression (&exp);
3677
3678 if (exp.X_op == O_illegal)
3679 as_bad (_("illegal expression"));
3680 else if (exp.X_op == O_absent)
3681 as_bad (_("missing expression"));
3682 else if (exp.X_op == O_big)
3683 {
3684 if (exp.X_add_number > 0)
3685 as_bad (_("bignum invalid"));
3686 else
3687 as_bad (_("floating point number invalid"));
3688 }
3689 else if (exp.X_op == O_subtract
3690 && !S_IS_FORWARD_REF (symbolP)
3691 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
3692 && (symbol_get_frag (exp.X_add_symbol)
3693 == symbol_get_frag (exp.X_op_symbol)))
3694 {
3695 exp.X_op = O_constant;
3696 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3697 - S_GET_VALUE (exp.X_op_symbol));
3698 }
3699
3700 if (symbol_section_p (symbolP))
3701 {
3702 as_bad ("attempt to set value of section symbol");
3703 return;
3704 }
3705
3706 switch (exp.X_op)
3707 {
3708 case O_illegal:
3709 case O_absent:
3710 case O_big:
3711 exp.X_add_number = 0;
3712 /* Fall through. */
3713 case O_constant:
3714 S_SET_SEGMENT (symbolP, absolute_section);
3715 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3716 set_zero_frag (symbolP);
3717 break;
3718
3719 case O_register:
3720 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
3721 if (S_IS_EXTERNAL (symbolP))
3722 {
3723 as_bad ("can't equate global symbol `%s' with register name",
3724 S_GET_NAME (symbolP));
3725 return;
3726 }
3727 #endif
3728 S_SET_SEGMENT (symbolP, reg_section);
3729 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3730 set_zero_frag (symbolP);
3731 symbol_get_value_expression (symbolP)->X_op = O_register;
3732 break;
3733
3734 case O_symbol:
3735 seg = S_GET_SEGMENT (exp.X_add_symbol);
3736 /* For x=undef+const, create an expression symbol.
3737 For x=x+const, just update x except when x is an undefined symbol
3738 For x=defined+const, evaluate x. */
3739 if (symbolP == exp.X_add_symbol
3740 && (seg != undefined_section
3741 || !symbol_constant_p (symbolP)))
3742 {
3743 *symbol_X_add_number (symbolP) += exp.X_add_number;
3744 break;
3745 }
3746 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
3747 {
3748 symbolS *s = exp.X_add_symbol;
3749
3750 if (S_IS_COMMON (s))
3751 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3752 S_GET_NAME (symbolP), S_GET_NAME (s));
3753
3754 S_SET_SEGMENT (symbolP, seg);
3755 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
3756 symbol_set_frag (symbolP, symbol_get_frag (s));
3757 copy_symbol_attributes (symbolP, s);
3758 break;
3759 }
3760 S_SET_SEGMENT (symbolP, undefined_section);
3761 symbol_set_value_expression (symbolP, &exp);
3762 copy_symbol_attributes (symbolP, exp.X_add_symbol);
3763 set_zero_frag (symbolP);
3764 break;
3765
3766 default:
3767 /* The value is some complex expression. */
3768 S_SET_SEGMENT (symbolP, expr_section);
3769 symbol_set_value_expression (symbolP, &exp);
3770 set_zero_frag (symbolP);
3771 break;
3772 }
3773 }
3774 \f
3775 /* cons()
3776
3777 CONStruct more frag of .bytes, or .words etc.
3778 Should need_pass_2 be 1 then emit no frag(s).
3779 This understands EXPRESSIONS.
3780
3781 Bug (?)
3782
3783 This has a split personality. We use expression() to read the
3784 value. We can detect if the value won't fit in a byte or word.
3785 But we can't detect if expression() discarded significant digits
3786 in the case of a long. Not worth the crocks required to fix it. */
3787
3788 /* Select a parser for cons expressions. */
3789
3790 /* Some targets need to parse the expression in various fancy ways.
3791 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3792 (for example, the HPPA does this). Otherwise, you can define
3793 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3794 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3795 are defined, which is the normal case, then only simple expressions
3796 are permitted. */
3797
3798 #ifdef TC_M68K
3799 static void
3800 parse_mri_cons (expressionS *exp, unsigned int nbytes);
3801 #endif
3802
3803 #ifndef TC_PARSE_CONS_EXPRESSION
3804 #ifdef BITFIELD_CONS_EXPRESSIONS
3805 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
3806 static void
3807 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
3808 #endif
3809 #ifdef REPEAT_CONS_EXPRESSIONS
3810 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3811 static void
3812 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
3813 #endif
3814
3815 /* If we haven't gotten one yet, just call expression. */
3816 #ifndef TC_PARSE_CONS_EXPRESSION
3817 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3818 #endif
3819 #endif
3820
3821 void
3822 do_parse_cons_expression (expressionS *exp,
3823 int nbytes ATTRIBUTE_UNUSED)
3824 {
3825 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3826 }
3827
3828
3829 /* Worker to do .byte etc statements.
3830 Clobbers input_line_pointer and checks end-of-line. */
3831
3832 static void
3833 cons_worker (int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3834 int rva)
3835 {
3836 int c;
3837 expressionS exp;
3838 char *stop = NULL;
3839 char stopc = 0;
3840
3841 #ifdef md_flush_pending_output
3842 md_flush_pending_output ();
3843 #endif
3844
3845 if (flag_mri)
3846 stop = mri_comment_field (&stopc);
3847
3848 if (is_it_end_of_statement ())
3849 {
3850 demand_empty_rest_of_line ();
3851 if (flag_mri)
3852 mri_comment_end (stop, stopc);
3853 return;
3854 }
3855
3856 #ifdef TC_ADDRESS_BYTES
3857 if (nbytes == 0)
3858 nbytes = TC_ADDRESS_BYTES ();
3859 #endif
3860
3861 #ifdef md_cons_align
3862 md_cons_align (nbytes);
3863 #endif
3864
3865 c = 0;
3866 do
3867 {
3868 #ifdef TC_M68K
3869 if (flag_m68k_mri)
3870 parse_mri_cons (&exp, (unsigned int) nbytes);
3871 else
3872 #endif
3873 {
3874 if (*input_line_pointer == '"')
3875 {
3876 as_bad (_("unexpected `\"' in expression"));
3877 ignore_rest_of_line ();
3878 return;
3879 }
3880 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3881 }
3882
3883 if (rva)
3884 {
3885 if (exp.X_op == O_symbol)
3886 exp.X_op = O_symbol_rva;
3887 else
3888 as_fatal (_("rva without symbol"));
3889 }
3890 emit_expr (&exp, (unsigned int) nbytes);
3891 ++c;
3892 }
3893 while (*input_line_pointer++ == ',');
3894
3895 /* In MRI mode, after an odd number of bytes, we must align to an
3896 even word boundary, unless the next instruction is a dc.b, ds.b
3897 or dcb.b. */
3898 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3899 mri_pending_align = 1;
3900
3901 input_line_pointer--; /* Put terminator back into stream. */
3902
3903 demand_empty_rest_of_line ();
3904
3905 if (flag_mri)
3906 mri_comment_end (stop, stopc);
3907 }
3908
3909 void
3910 cons (int size)
3911 {
3912 cons_worker (size, 0);
3913 }
3914
3915 void
3916 s_rva (int size)
3917 {
3918 cons_worker (size, 1);
3919 }
3920
3921 /* .reloc offset, reloc_name, symbol+addend. */
3922
3923 void
3924 s_reloc (int ignore ATTRIBUTE_UNUSED)
3925 {
3926 char *stop = NULL;
3927 char stopc = 0;
3928 expressionS exp;
3929 char *r_name;
3930 int c;
3931 struct reloc_list *reloc;
3932
3933 reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
3934
3935 if (flag_mri)
3936 stop = mri_comment_field (&stopc);
3937
3938 expression (&exp);
3939 switch (exp.X_op)
3940 {
3941 case O_illegal:
3942 case O_absent:
3943 case O_big:
3944 case O_register:
3945 as_bad (_("missing or bad offset expression"));
3946 goto err_out;
3947 case O_constant:
3948 exp.X_add_symbol = section_symbol (now_seg);
3949 exp.X_op = O_symbol;
3950 /* Fall thru */
3951 case O_symbol:
3952 if (exp.X_add_number == 0)
3953 {
3954 reloc->u.a.offset_sym = exp.X_add_symbol;
3955 break;
3956 }
3957 /* Fall thru */
3958 default:
3959 reloc->u.a.offset_sym = make_expr_symbol (&exp);
3960 break;
3961 }
3962
3963 SKIP_WHITESPACE ();
3964 if (*input_line_pointer != ',')
3965 {
3966 as_bad (_("missing reloc type"));
3967 goto err_out;
3968 }
3969
3970 ++input_line_pointer;
3971 SKIP_WHITESPACE ();
3972 r_name = input_line_pointer;
3973 c = get_symbol_end ();
3974 reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3975 *input_line_pointer = c;
3976 if (reloc->u.a.howto == NULL)
3977 {
3978 as_bad (_("unrecognized reloc type"));
3979 goto err_out;
3980 }
3981
3982 exp.X_op = O_absent;
3983 SKIP_WHITESPACE ();
3984 if (*input_line_pointer == ',')
3985 {
3986 ++input_line_pointer;
3987 expression (&exp);
3988 }
3989 switch (exp.X_op)
3990 {
3991 case O_illegal:
3992 case O_big:
3993 case O_register:
3994 as_bad (_("bad reloc expression"));
3995 err_out:
3996 ignore_rest_of_line ();
3997 free (reloc);
3998 if (flag_mri)
3999 mri_comment_end (stop, stopc);
4000 return;
4001 case O_absent:
4002 reloc->u.a.sym = NULL;
4003 reloc->u.a.addend = 0;
4004 break;
4005 case O_constant:
4006 reloc->u.a.sym = NULL;
4007 reloc->u.a.addend = exp.X_add_number;
4008 break;
4009 case O_symbol:
4010 reloc->u.a.sym = exp.X_add_symbol;
4011 reloc->u.a.addend = exp.X_add_number;
4012 break;
4013 default:
4014 reloc->u.a.sym = make_expr_symbol (&exp);
4015 reloc->u.a.addend = 0;
4016 break;
4017 }
4018
4019 as_where (&reloc->file, &reloc->line);
4020 reloc->next = reloc_list;
4021 reloc_list = reloc;
4022
4023 demand_empty_rest_of_line ();
4024 if (flag_mri)
4025 mri_comment_end (stop, stopc);
4026 }
4027
4028 /* Put the contents of expression EXP into the object file using
4029 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
4030
4031 void
4032 emit_expr (expressionS *exp, unsigned int nbytes)
4033 {
4034 operatorT op;
4035 char *p;
4036 valueT extra_digit = 0;
4037
4038 /* Don't do anything if we are going to make another pass. */
4039 if (need_pass_2)
4040 return;
4041
4042 /* Grow the current frag now so that dot_value does not get invalidated
4043 if the frag were to fill up in the frag_more() call below. */
4044 frag_grow (nbytes);
4045 dot_value = frag_now_fix ();
4046
4047 #ifndef NO_LISTING
4048 #ifdef OBJ_ELF
4049 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
4050 appear as a four byte positive constant in the .line section,
4051 followed by a 2 byte 0xffff. Look for that case here. */
4052 {
4053 static int dwarf_line = -1;
4054
4055 if (strcmp (segment_name (now_seg), ".line") != 0)
4056 dwarf_line = -1;
4057 else if (dwarf_line >= 0
4058 && nbytes == 2
4059 && exp->X_op == O_constant
4060 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
4061 listing_source_line ((unsigned int) dwarf_line);
4062 else if (nbytes == 4
4063 && exp->X_op == O_constant
4064 && exp->X_add_number >= 0)
4065 dwarf_line = exp->X_add_number;
4066 else
4067 dwarf_line = -1;
4068 }
4069
4070 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
4071 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
4072 AT_sibling (0x12) followed by a four byte address of the sibling
4073 followed by a 2 byte AT_name (0x38) followed by the name of the
4074 file. We look for that case here. */
4075 {
4076 static int dwarf_file = 0;
4077
4078 if (strcmp (segment_name (now_seg), ".debug") != 0)
4079 dwarf_file = 0;
4080 else if (dwarf_file == 0
4081 && nbytes == 2
4082 && exp->X_op == O_constant
4083 && exp->X_add_number == 0x11)
4084 dwarf_file = 1;
4085 else if (dwarf_file == 1
4086 && nbytes == 2
4087 && exp->X_op == O_constant
4088 && exp->X_add_number == 0x12)
4089 dwarf_file = 2;
4090 else if (dwarf_file == 2
4091 && nbytes == 4)
4092 dwarf_file = 3;
4093 else if (dwarf_file == 3
4094 && nbytes == 2
4095 && exp->X_op == O_constant
4096 && exp->X_add_number == 0x38)
4097 dwarf_file = 4;
4098 else
4099 dwarf_file = 0;
4100
4101 /* The variable dwarf_file_string tells stringer that the string
4102 may be the name of the source file. */
4103 if (dwarf_file == 4)
4104 dwarf_file_string = 1;
4105 else
4106 dwarf_file_string = 0;
4107 }
4108 #endif
4109 #endif
4110
4111 if (check_eh_frame (exp, &nbytes))
4112 return;
4113
4114 op = exp->X_op;
4115
4116 /* Allow `.word 0' in the absolute section. */
4117 if (now_seg == absolute_section)
4118 {
4119 if (op != O_constant || exp->X_add_number != 0)
4120 as_bad (_("attempt to store value in absolute section"));
4121 abs_section_offset += nbytes;
4122 return;
4123 }
4124
4125 /* Handle a negative bignum. */
4126 if (op == O_uminus
4127 && exp->X_add_number == 0
4128 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4129 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
4130 {
4131 int i;
4132 unsigned long carry;
4133
4134 exp = symbol_get_value_expression (exp->X_add_symbol);
4135
4136 /* Negate the bignum: one's complement each digit and add 1. */
4137 carry = 1;
4138 for (i = 0; i < exp->X_add_number; i++)
4139 {
4140 unsigned long next;
4141
4142 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
4143 & LITTLENUM_MASK)
4144 + carry);
4145 generic_bignum[i] = next & LITTLENUM_MASK;
4146 carry = next >> LITTLENUM_NUMBER_OF_BITS;
4147 }
4148
4149 /* We can ignore any carry out, because it will be handled by
4150 extra_digit if it is needed. */
4151
4152 extra_digit = (valueT) -1;
4153 op = O_big;
4154 }
4155
4156 if (op == O_absent || op == O_illegal)
4157 {
4158 as_warn (_("zero assumed for missing expression"));
4159 exp->X_add_number = 0;
4160 op = O_constant;
4161 }
4162 else if (op == O_big && exp->X_add_number <= 0)
4163 {
4164 as_bad (_("floating point number invalid"));
4165 exp->X_add_number = 0;
4166 op = O_constant;
4167 }
4168 else if (op == O_register)
4169 {
4170 as_warn (_("register value used as expression"));
4171 op = O_constant;
4172 }
4173
4174 p = frag_more ((int) nbytes);
4175
4176 #ifndef WORKING_DOT_WORD
4177 /* If we have the difference of two symbols in a word, save it on
4178 the broken_words list. See the code in write.c. */
4179 if (op == O_subtract && nbytes == 2)
4180 {
4181 struct broken_word *x;
4182
4183 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4184 x->next_broken_word = broken_words;
4185 broken_words = x;
4186 x->seg = now_seg;
4187 x->subseg = now_subseg;
4188 x->frag = frag_now;
4189 x->word_goes_here = p;
4190 x->dispfrag = 0;
4191 x->add = exp->X_add_symbol;
4192 x->sub = exp->X_op_symbol;
4193 x->addnum = exp->X_add_number;
4194 x->added = 0;
4195 x->use_jump = 0;
4196 new_broken_words++;
4197 return;
4198 }
4199 #endif
4200
4201 /* If we have an integer, but the number of bytes is too large to
4202 pass to md_number_to_chars, handle it as a bignum. */
4203 if (op == O_constant && nbytes > sizeof (valueT))
4204 {
4205 extra_digit = exp->X_unsigned ? 0 : -1;
4206 convert_to_bignum (exp);
4207 op = O_big;
4208 }
4209
4210 if (op == O_constant)
4211 {
4212 valueT get;
4213 valueT use;
4214 valueT mask;
4215 valueT hibit;
4216 valueT unmask;
4217
4218 /* JF << of >= number of bits in the object is undefined. In
4219 particular SPARC (Sun 4) has problems. */
4220 if (nbytes >= sizeof (valueT))
4221 {
4222 mask = 0;
4223 if (nbytes > sizeof (valueT))
4224 hibit = 0;
4225 else
4226 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4227 }
4228 else
4229 {
4230 /* Don't store these bits. */
4231 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4232 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4233 }
4234
4235 unmask = ~mask; /* Do store these bits. */
4236
4237 #ifdef NEVER
4238 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
4239 mask = ~(unmask >> 1); /* Includes sign bit now. */
4240 #endif
4241
4242 get = exp->X_add_number;
4243 use = get & unmask;
4244 if ((get & mask) != 0
4245 && ((get & mask) != mask
4246 || (get & hibit) == 0))
4247 { /* Leading bits contain both 0s & 1s. */
4248 #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
4249 #ifndef __MSVCRT__
4250 as_warn (_("value 0x%llx truncated to 0x%llx"),
4251 (unsigned long long) get, (unsigned long long) use);
4252 #else
4253 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4254 (unsigned long long) get, (unsigned long long) use);
4255 #endif
4256 #else
4257 as_warn (_("value 0x%lx truncated to 0x%lx"),
4258 (unsigned long) get, (unsigned long) use);
4259 #endif
4260 }
4261 /* Put bytes in right order. */
4262 md_number_to_chars (p, use, (int) nbytes);
4263 }
4264 else if (op == O_big)
4265 {
4266 unsigned int size;
4267 LITTLENUM_TYPE *nums;
4268
4269 size = exp->X_add_number * CHARS_PER_LITTLENUM;
4270 if (nbytes < size)
4271 {
4272 int i = nbytes / CHARS_PER_LITTLENUM;
4273 if (i != 0)
4274 {
4275 LITTLENUM_TYPE sign = 0;
4276 if ((generic_bignum[--i]
4277 & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
4278 sign = ~(LITTLENUM_TYPE) 0;
4279 while (++i < exp->X_add_number)
4280 if (generic_bignum[i] != sign)
4281 break;
4282 }
4283 if (i < exp->X_add_number)
4284 as_warn (_("bignum truncated to %d bytes"), nbytes);
4285 size = nbytes;
4286 }
4287
4288 if (nbytes == 1)
4289 {
4290 md_number_to_chars (p, (valueT) generic_bignum[0], 1);
4291 return;
4292 }
4293 know (nbytes % CHARS_PER_LITTLENUM == 0);
4294
4295 if (target_big_endian)
4296 {
4297 while (nbytes > size)
4298 {
4299 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4300 nbytes -= CHARS_PER_LITTLENUM;
4301 p += CHARS_PER_LITTLENUM;
4302 }
4303
4304 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
4305 while (size >= CHARS_PER_LITTLENUM)
4306 {
4307 --nums;
4308 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4309 size -= CHARS_PER_LITTLENUM;
4310 p += CHARS_PER_LITTLENUM;
4311 }
4312 }
4313 else
4314 {
4315 nums = generic_bignum;
4316 while (size >= CHARS_PER_LITTLENUM)
4317 {
4318 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4319 ++nums;
4320 size -= CHARS_PER_LITTLENUM;
4321 p += CHARS_PER_LITTLENUM;
4322 nbytes -= CHARS_PER_LITTLENUM;
4323 }
4324
4325 while (nbytes >= CHARS_PER_LITTLENUM)
4326 {
4327 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4328 nbytes -= CHARS_PER_LITTLENUM;
4329 p += CHARS_PER_LITTLENUM;
4330 }
4331 }
4332 }
4333 else
4334 emit_expr_fix (exp, nbytes, frag_now, p);
4335 }
4336
4337 void
4338 emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4339 {
4340 memset (p, 0, nbytes);
4341
4342 /* Generate a fixS to record the symbol value. */
4343
4344 #ifdef TC_CONS_FIX_NEW
4345 TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
4346 #else
4347 {
4348 bfd_reloc_code_real_type r;
4349
4350 switch (nbytes)
4351 {
4352 case 1:
4353 r = BFD_RELOC_8;
4354 break;
4355 case 2:
4356 r = BFD_RELOC_16;
4357 break;
4358 case 3:
4359 r = BFD_RELOC_24;
4360 break;
4361 case 4:
4362 r = BFD_RELOC_32;
4363 break;
4364 case 8:
4365 r = BFD_RELOC_64;
4366 break;
4367 default:
4368 as_bad (_("unsupported BFD relocation size %u"), nbytes);
4369 r = BFD_RELOC_32;
4370 break;
4371 }
4372 fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4373 0, r);
4374 }
4375 #endif
4376 }
4377 \f
4378 #ifdef BITFIELD_CONS_EXPRESSIONS
4379
4380 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4381 w:x,y:z, where w and y are bitwidths and x and y are values. They
4382 then pack them all together. We do a little better in that we allow
4383 them in words, longs, etc. and we'll pack them in target byte order
4384 for you.
4385
4386 The rules are: pack least significant bit first, if a field doesn't
4387 entirely fit, put it in the next unit. Overflowing the bitfield is
4388 explicitly *not* even a warning. The bitwidth should be considered
4389 a "mask".
4390
4391 To use this function the tc-XXX.h file should define
4392 BITFIELD_CONS_EXPRESSIONS. */
4393
4394 static void
4395 parse_bitfield_cons (exp, nbytes)
4396 expressionS *exp;
4397 unsigned int nbytes;
4398 {
4399 unsigned int bits_available = BITS_PER_CHAR * nbytes;
4400 char *hold = input_line_pointer;
4401
4402 (void) expression (exp);
4403
4404 if (*input_line_pointer == ':')
4405 {
4406 /* Bitfields. */
4407 long value = 0;
4408
4409 for (;;)
4410 {
4411 unsigned long width;
4412
4413 if (*input_line_pointer != ':')
4414 {
4415 input_line_pointer = hold;
4416 break;
4417 } /* Next piece is not a bitfield. */
4418
4419 /* In the general case, we can't allow
4420 full expressions with symbol
4421 differences and such. The relocation
4422 entries for symbols not defined in this
4423 assembly would require arbitrary field
4424 widths, positions, and masks which most
4425 of our current object formats don't
4426 support.
4427
4428 In the specific case where a symbol
4429 *is* defined in this assembly, we
4430 *could* build fixups and track it, but
4431 this could lead to confusion for the
4432 backends. I'm lazy. I'll take any
4433 SEG_ABSOLUTE. I think that means that
4434 you can use a previous .set or
4435 .equ type symbol. xoxorich. */
4436
4437 if (exp->X_op == O_absent)
4438 {
4439 as_warn (_("using a bit field width of zero"));
4440 exp->X_add_number = 0;
4441 exp->X_op = O_constant;
4442 } /* Implied zero width bitfield. */
4443
4444 if (exp->X_op != O_constant)
4445 {
4446 *input_line_pointer = '\0';
4447 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4448 *input_line_pointer = ':';
4449 demand_empty_rest_of_line ();
4450 return;
4451 } /* Too complex. */
4452
4453 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4454 {
4455 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4456 width, nbytes, (BITS_PER_CHAR * nbytes));
4457 width = BITS_PER_CHAR * nbytes;
4458 } /* Too big. */
4459
4460 if (width > bits_available)
4461 {
4462 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4463 input_line_pointer = hold;
4464 exp->X_add_number = value;
4465 break;
4466 } /* Won't fit. */
4467
4468 /* Skip ':'. */
4469 hold = ++input_line_pointer;
4470
4471 (void) expression (exp);
4472 if (exp->X_op != O_constant)
4473 {
4474 char cache = *input_line_pointer;
4475
4476 *input_line_pointer = '\0';
4477 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4478 *input_line_pointer = cache;
4479 demand_empty_rest_of_line ();
4480 return;
4481 } /* Too complex. */
4482
4483 value |= ((~(-1 << width) & exp->X_add_number)
4484 << ((BITS_PER_CHAR * nbytes) - bits_available));
4485
4486 if ((bits_available -= width) == 0
4487 || is_it_end_of_statement ()
4488 || *input_line_pointer != ',')
4489 {
4490 break;
4491 } /* All the bitfields we're gonna get. */
4492
4493 hold = ++input_line_pointer;
4494 (void) expression (exp);
4495 }
4496
4497 exp->X_add_number = value;
4498 exp->X_op = O_constant;
4499 exp->X_unsigned = 1;
4500 }
4501 }
4502
4503 #endif /* BITFIELD_CONS_EXPRESSIONS */
4504 \f
4505 /* Handle an MRI style string expression. */
4506
4507 #ifdef TC_M68K
4508 static void
4509 parse_mri_cons (exp, nbytes)
4510 expressionS *exp;
4511 unsigned int nbytes;
4512 {
4513 if (*input_line_pointer != '\''
4514 && (input_line_pointer[1] != '\''
4515 || (*input_line_pointer != 'A'
4516 && *input_line_pointer != 'E')))
4517 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4518 else
4519 {
4520 unsigned int scan;
4521 unsigned int result = 0;
4522
4523 /* An MRI style string. Cut into as many bytes as will fit into
4524 a nbyte chunk, left justify if necessary, and separate with
4525 commas so we can try again later. */
4526 if (*input_line_pointer == 'A')
4527 ++input_line_pointer;
4528 else if (*input_line_pointer == 'E')
4529 {
4530 as_bad (_("EBCDIC constants are not supported"));
4531 ++input_line_pointer;
4532 }
4533
4534 input_line_pointer++;
4535 for (scan = 0; scan < nbytes; scan++)
4536 {
4537 if (*input_line_pointer == '\'')
4538 {
4539 if (input_line_pointer[1] == '\'')
4540 {
4541 input_line_pointer++;
4542 }
4543 else
4544 break;
4545 }
4546 result = (result << 8) | (*input_line_pointer++);
4547 }
4548
4549 /* Left justify. */
4550 while (scan < nbytes)
4551 {
4552 result <<= 8;
4553 scan++;
4554 }
4555
4556 /* Create correct expression. */
4557 exp->X_op = O_constant;
4558 exp->X_add_number = result;
4559
4560 /* Fake it so that we can read the next char too. */
4561 if (input_line_pointer[0] != '\'' ||
4562 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4563 {
4564 input_line_pointer -= 2;
4565 input_line_pointer[0] = ',';
4566 input_line_pointer[1] = '\'';
4567 }
4568 else
4569 input_line_pointer++;
4570 }
4571 }
4572 #endif /* TC_M68K */
4573 \f
4574 #ifdef REPEAT_CONS_EXPRESSIONS
4575
4576 /* Parse a repeat expression for cons. This is used by the MIPS
4577 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4578 object file COUNT times.
4579
4580 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4581
4582 static void
4583 parse_repeat_cons (exp, nbytes)
4584 expressionS *exp;
4585 unsigned int nbytes;
4586 {
4587 expressionS count;
4588 int i;
4589
4590 expression (exp);
4591
4592 if (*input_line_pointer != ':')
4593 {
4594 /* No repeat count. */
4595 return;
4596 }
4597
4598 ++input_line_pointer;
4599 expression (&count);
4600 if (count.X_op != O_constant
4601 || count.X_add_number <= 0)
4602 {
4603 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4604 return;
4605 }
4606
4607 /* The cons function is going to output this expression once. So we
4608 output it count - 1 times. */
4609 for (i = count.X_add_number - 1; i > 0; i--)
4610 emit_expr (exp, nbytes);
4611 }
4612
4613 #endif /* REPEAT_CONS_EXPRESSIONS */
4614 \f
4615 /* Parse a floating point number represented as a hex constant. This
4616 permits users to specify the exact bits they want in the floating
4617 point number. */
4618
4619 static int
4620 hex_float (int float_type, char *bytes)
4621 {
4622 int length;
4623 int i;
4624
4625 switch (float_type)
4626 {
4627 case 'f':
4628 case 'F':
4629 case 's':
4630 case 'S':
4631 length = 4;
4632 break;
4633
4634 case 'd':
4635 case 'D':
4636 case 'r':
4637 case 'R':
4638 length = 8;
4639 break;
4640
4641 case 'x':
4642 case 'X':
4643 length = 12;
4644 break;
4645
4646 case 'p':
4647 case 'P':
4648 length = 12;
4649 break;
4650
4651 default:
4652 as_bad (_("unknown floating type type '%c'"), float_type);
4653 return -1;
4654 }
4655
4656 /* It would be nice if we could go through expression to parse the
4657 hex constant, but if we get a bignum it's a pain to sort it into
4658 the buffer correctly. */
4659 i = 0;
4660 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4661 {
4662 int d;
4663
4664 /* The MRI assembler accepts arbitrary underscores strewn about
4665 through the hex constant, so we ignore them as well. */
4666 if (*input_line_pointer == '_')
4667 {
4668 ++input_line_pointer;
4669 continue;
4670 }
4671
4672 if (i >= length)
4673 {
4674 as_warn (_("floating point constant too large"));
4675 return -1;
4676 }
4677 d = hex_value (*input_line_pointer) << 4;
4678 ++input_line_pointer;
4679 while (*input_line_pointer == '_')
4680 ++input_line_pointer;
4681 if (hex_p (*input_line_pointer))
4682 {
4683 d += hex_value (*input_line_pointer);
4684 ++input_line_pointer;
4685 }
4686 if (target_big_endian)
4687 bytes[i] = d;
4688 else
4689 bytes[length - i - 1] = d;
4690 ++i;
4691 }
4692
4693 if (i < length)
4694 {
4695 if (target_big_endian)
4696 memset (bytes + i, 0, length - i);
4697 else
4698 memset (bytes, 0, length - i);
4699 }
4700
4701 return length;
4702 }
4703
4704 /* float_cons()
4705
4706 CONStruct some more frag chars of .floats .ffloats etc.
4707 Makes 0 or more new frags.
4708 If need_pass_2 == 1, no frags are emitted.
4709 This understands only floating literals, not expressions. Sorry.
4710
4711 A floating constant is defined by atof_generic(), except it is preceded
4712 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4713 reading, I decided to be incompatible. This always tries to give you
4714 rounded bits to the precision of the pseudo-op. Former AS did premature
4715 truncation, restored noisy bits instead of trailing 0s AND gave you
4716 a choice of 2 flavours of noise according to which of 2 floating-point
4717 scanners you directed AS to use.
4718
4719 In: input_line_pointer->whitespace before, or '0' of flonum. */
4720
4721 void
4722 float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4723 int float_type /* 'f':.ffloat ... 'F':.float ... */)
4724 {
4725 char *p;
4726 int length; /* Number of chars in an object. */
4727 char *err; /* Error from scanning floating literal. */
4728 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4729
4730 if (is_it_end_of_statement ())
4731 {
4732 demand_empty_rest_of_line ();
4733 return;
4734 }
4735
4736 #ifdef md_flush_pending_output
4737 md_flush_pending_output ();
4738 #endif
4739
4740 #ifdef md_cons_align
4741 md_cons_align (1);
4742 #endif
4743
4744 do
4745 {
4746 /* input_line_pointer->1st char of a flonum (we hope!). */
4747 SKIP_WHITESPACE ();
4748
4749 /* Skip any 0{letter} that may be present. Don't even check if the
4750 letter is legal. Someone may invent a "z" format and this routine
4751 has no use for such information. Lusers beware: you get
4752 diagnostics if your input is ill-conditioned. */
4753 if (input_line_pointer[0] == '0'
4754 && ISALPHA (input_line_pointer[1]))
4755 input_line_pointer += 2;
4756
4757 /* Accept :xxxx, where the x's are hex digits, for a floating
4758 point with the exact digits specified. */
4759 if (input_line_pointer[0] == ':')
4760 {
4761 ++input_line_pointer;
4762 length = hex_float (float_type, temp);
4763 if (length < 0)
4764 {
4765 ignore_rest_of_line ();
4766 return;
4767 }
4768 }
4769 else
4770 {
4771 err = md_atof (float_type, temp, &length);
4772 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4773 know (err != NULL || length > 0);
4774 if (err)
4775 {
4776 as_bad (_("bad floating literal: %s"), err);
4777 ignore_rest_of_line ();
4778 return;
4779 }
4780 }
4781
4782 if (!need_pass_2)
4783 {
4784 int count;
4785
4786 count = 1;
4787
4788 #ifdef REPEAT_CONS_EXPRESSIONS
4789 if (*input_line_pointer == ':')
4790 {
4791 expressionS count_exp;
4792
4793 ++input_line_pointer;
4794 expression (&count_exp);
4795
4796 if (count_exp.X_op != O_constant
4797 || count_exp.X_add_number <= 0)
4798 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
4799 else
4800 count = count_exp.X_add_number;
4801 }
4802 #endif
4803
4804 while (--count >= 0)
4805 {
4806 p = frag_more (length);
4807 memcpy (p, temp, (unsigned int) length);
4808 }
4809 }
4810 SKIP_WHITESPACE ();
4811 }
4812 while (*input_line_pointer++ == ',');
4813
4814 /* Put terminator back into stream. */
4815 --input_line_pointer;
4816 demand_empty_rest_of_line ();
4817 }
4818 \f
4819 /* Return the size of a LEB128 value. */
4820
4821 static inline int
4822 sizeof_sleb128 (offsetT value)
4823 {
4824 int size = 0;
4825 unsigned byte;
4826
4827 do
4828 {
4829 byte = (value & 0x7f);
4830 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4831 Fortunately, we can structure things so that the extra work reduces
4832 to a noop on systems that do things "properly". */
4833 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4834 size += 1;
4835 }
4836 while (!(((value == 0) && ((byte & 0x40) == 0))
4837 || ((value == -1) && ((byte & 0x40) != 0))));
4838
4839 return size;
4840 }
4841
4842 static inline int
4843 sizeof_uleb128 (valueT value)
4844 {
4845 int size = 0;
4846
4847 do
4848 {
4849 value >>= 7;
4850 size += 1;
4851 }
4852 while (value != 0);
4853
4854 return size;
4855 }
4856
4857 int
4858 sizeof_leb128 (valueT value, int sign)
4859 {
4860 if (sign)
4861 return sizeof_sleb128 ((offsetT) value);
4862 else
4863 return sizeof_uleb128 (value);
4864 }
4865
4866 /* Output a LEB128 value. */
4867
4868 static inline int
4869 output_sleb128 (char *p, offsetT value)
4870 {
4871 char *orig = p;
4872 int more;
4873
4874 do
4875 {
4876 unsigned byte = (value & 0x7f);
4877
4878 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4879 Fortunately, we can structure things so that the extra work reduces
4880 to a noop on systems that do things "properly". */
4881 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4882
4883 more = !((((value == 0) && ((byte & 0x40) == 0))
4884 || ((value == -1) && ((byte & 0x40) != 0))));
4885 if (more)
4886 byte |= 0x80;
4887
4888 *p++ = byte;
4889 }
4890 while (more);
4891
4892 return p - orig;
4893 }
4894
4895 static inline int
4896 output_uleb128 (char *p, valueT value)
4897 {
4898 char *orig = p;
4899
4900 do
4901 {
4902 unsigned byte = (value & 0x7f);
4903 value >>= 7;
4904 if (value != 0)
4905 /* More bytes to follow. */
4906 byte |= 0x80;
4907
4908 *p++ = byte;
4909 }
4910 while (value != 0);
4911
4912 return p - orig;
4913 }
4914
4915 int
4916 output_leb128 (char *p, valueT value, int sign)
4917 {
4918 if (sign)
4919 return output_sleb128 (p, (offsetT) value);
4920 else
4921 return output_uleb128 (p, value);
4922 }
4923
4924 /* Do the same for bignums. We combine sizeof with output here in that
4925 we don't output for NULL values of P. It isn't really as critical as
4926 for "normal" values that this be streamlined. */
4927
4928 static inline int
4929 output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4930 {
4931 char *orig = p;
4932 valueT val = 0;
4933 int loaded = 0;
4934 unsigned byte;
4935
4936 /* Strip leading sign extensions off the bignum. */
4937 while (size > 1
4938 && bignum[size - 1] == LITTLENUM_MASK
4939 && bignum[size - 2] > LITTLENUM_MASK / 2)
4940 size--;
4941
4942 do
4943 {
4944 /* OR in the next part of the littlenum. */
4945 val |= (*bignum << loaded);
4946 loaded += LITTLENUM_NUMBER_OF_BITS;
4947 size--;
4948 bignum++;
4949
4950 /* Add bytes until there are less than 7 bits left in VAL
4951 or until every non-sign bit has been written. */
4952 do
4953 {
4954 byte = val & 0x7f;
4955 loaded -= 7;
4956 val >>= 7;
4957 if (size > 0
4958 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
4959 byte |= 0x80;
4960
4961 if (orig)
4962 *p = byte;
4963 p++;
4964 }
4965 while ((byte & 0x80) != 0 && loaded >= 7);
4966 }
4967 while (size > 0);
4968
4969 /* Mop up any left-over bits (of which there will be less than 7). */
4970 if ((byte & 0x80) != 0)
4971 {
4972 /* Sign-extend VAL. */
4973 if (val & (1 << (loaded - 1)))
4974 val |= ~0 << loaded;
4975 if (orig)
4976 *p = val & 0x7f;
4977 p++;
4978 }
4979
4980 return p - orig;
4981 }
4982
4983 static inline int
4984 output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
4985 {
4986 char *orig = p;
4987 valueT val = 0;
4988 int loaded = 0;
4989 unsigned byte;
4990
4991 /* Strip leading zeros off the bignum. */
4992 /* XXX: Is this needed? */
4993 while (size > 0 && bignum[size - 1] == 0)
4994 size--;
4995
4996 do
4997 {
4998 if (loaded < 7 && size > 0)
4999 {
5000 val |= (*bignum << loaded);
5001 loaded += 8 * CHARS_PER_LITTLENUM;
5002 size--;
5003 bignum++;
5004 }
5005
5006 byte = val & 0x7f;
5007 loaded -= 7;
5008 val >>= 7;
5009
5010 if (size > 0 || val)
5011 byte |= 0x80;
5012
5013 if (orig)
5014 *p = byte;
5015 p++;
5016 }
5017 while (byte & 0x80);
5018
5019 return p - orig;
5020 }
5021
5022 static int
5023 output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
5024 {
5025 if (sign)
5026 return output_big_sleb128 (p, bignum, size);
5027 else
5028 return output_big_uleb128 (p, bignum, size);
5029 }
5030
5031 /* Generate the appropriate fragments for a given expression to emit a
5032 leb128 value. */
5033
5034 static void
5035 emit_leb128_expr (expressionS *exp, int sign)
5036 {
5037 operatorT op = exp->X_op;
5038 unsigned int nbytes;
5039
5040 if (op == O_absent || op == O_illegal)
5041 {
5042 as_warn (_("zero assumed for missing expression"));
5043 exp->X_add_number = 0;
5044 op = O_constant;
5045 }
5046 else if (op == O_big && exp->X_add_number <= 0)
5047 {
5048 as_bad (_("floating point number invalid"));
5049 exp->X_add_number = 0;
5050 op = O_constant;
5051 }
5052 else if (op == O_register)
5053 {
5054 as_warn (_("register value used as expression"));
5055 op = O_constant;
5056 }
5057 else if (op == O_constant
5058 && sign
5059 && (exp->X_add_number < 0) != !exp->X_unsigned)
5060 {
5061 /* We're outputting a signed leb128 and the sign of X_add_number
5062 doesn't reflect the sign of the original value. Convert EXP
5063 to a correctly-extended bignum instead. */
5064 convert_to_bignum (exp);
5065 op = O_big;
5066 }
5067
5068 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
5069 a signal that this is leb128 data. It shouldn't optimize this away. */
5070 nbytes = (unsigned int) -1;
5071 if (check_eh_frame (exp, &nbytes))
5072 abort ();
5073
5074 /* Let the backend know that subsequent data may be byte aligned. */
5075 #ifdef md_cons_align
5076 md_cons_align (1);
5077 #endif
5078
5079 if (op == O_constant)
5080 {
5081 /* If we've got a constant, emit the thing directly right now. */
5082
5083 valueT value = exp->X_add_number;
5084 int size;
5085 char *p;
5086
5087 size = sizeof_leb128 (value, sign);
5088 p = frag_more (size);
5089 output_leb128 (p, value, sign);
5090 }
5091 else if (op == O_big)
5092 {
5093 /* O_big is a different sort of constant. */
5094
5095 int size;
5096 char *p;
5097
5098 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
5099 p = frag_more (size);
5100 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
5101 }
5102 else
5103 {
5104 /* Otherwise, we have to create a variable sized fragment and
5105 resolve things later. */
5106
5107 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
5108 make_expr_symbol (exp), 0, (char *) NULL);
5109 }
5110 }
5111
5112 /* Parse the .sleb128 and .uleb128 pseudos. */
5113
5114 void
5115 s_leb128 (int sign)
5116 {
5117 expressionS exp;
5118
5119 #ifdef md_flush_pending_output
5120 md_flush_pending_output ();
5121 #endif
5122
5123 do
5124 {
5125 expression (&exp);
5126 emit_leb128_expr (&exp, sign);
5127 }
5128 while (*input_line_pointer++ == ',');
5129
5130 input_line_pointer--;
5131 demand_empty_rest_of_line ();
5132 }
5133 \f
5134 static void
5135 stringer_append_char (int c, int bitsize)
5136 {
5137 if (!target_big_endian)
5138 FRAG_APPEND_1_CHAR (c);
5139
5140 switch (bitsize)
5141 {
5142 case 64:
5143 FRAG_APPEND_1_CHAR (0);
5144 FRAG_APPEND_1_CHAR (0);
5145 FRAG_APPEND_1_CHAR (0);
5146 FRAG_APPEND_1_CHAR (0);
5147 /* Fall through. */
5148 case 32:
5149 FRAG_APPEND_1_CHAR (0);
5150 FRAG_APPEND_1_CHAR (0);
5151 /* Fall through. */
5152 case 16:
5153 FRAG_APPEND_1_CHAR (0);
5154 /* Fall through. */
5155 case 8:
5156 break;
5157 default:
5158 /* Called with invalid bitsize argument. */
5159 abort ();
5160 break;
5161 }
5162 if (target_big_endian)
5163 FRAG_APPEND_1_CHAR (c);
5164 }
5165
5166 /* Worker to do .ascii etc statements.
5167 Reads 0 or more ',' separated, double-quoted strings.
5168 Caller should have checked need_pass_2 is FALSE because we don't
5169 check it.
5170 Checks for end-of-line.
5171 BITS_APPENDZERO says how many bits are in a target char.
5172 The bottom bit is set if a NUL char should be appended to the strings. */
5173
5174 void
5175 stringer (int bits_appendzero)
5176 {
5177 const int bitsize = bits_appendzero & ~7;
5178 const int append_zero = bits_appendzero & 1;
5179 unsigned int c;
5180 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5181 char *start;
5182 #endif
5183
5184 #ifdef md_flush_pending_output
5185 md_flush_pending_output ();
5186 #endif
5187
5188 #ifdef md_cons_align
5189 md_cons_align (1);
5190 #endif
5191
5192 /* The following awkward logic is to parse ZERO or more strings,
5193 comma separated. Recall a string expression includes spaces
5194 before the opening '\"' and spaces after the closing '\"'.
5195 We fake a leading ',' if there is (supposed to be)
5196 a 1st, expression. We keep demanding expressions for each ','. */
5197 if (is_it_end_of_statement ())
5198 {
5199 c = 0; /* Skip loop. */
5200 ++input_line_pointer; /* Compensate for end of loop. */
5201 }
5202 else
5203 {
5204 c = ','; /* Do loop. */
5205 }
5206 /* If we have been switched into the abs_section then we
5207 will not have an obstack onto which we can hang strings. */
5208 if (now_seg == absolute_section)
5209 {
5210 as_bad (_("strings must be placed into a section"));
5211 c = 0;
5212 ignore_rest_of_line ();
5213 }
5214
5215 while (c == ',' || c == '<' || c == '"')
5216 {
5217 SKIP_WHITESPACE ();
5218 switch (*input_line_pointer)
5219 {
5220 case '\"':
5221 ++input_line_pointer; /*->1st char of string. */
5222 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5223 start = input_line_pointer;
5224 #endif
5225
5226 while (is_a_char (c = next_char_of_string ()))
5227 stringer_append_char (c, bitsize);
5228
5229 if (append_zero)
5230 stringer_append_char (0, bitsize);
5231
5232 know (input_line_pointer[-1] == '\"');
5233
5234 #if !defined(NO_LISTING) && defined (OBJ_ELF)
5235 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
5236 will emit .string with a filename in the .debug section
5237 after a sequence of constants. See the comment in
5238 emit_expr for the sequence. emit_expr will set
5239 dwarf_file_string to non-zero if this string might be a
5240 source file name. */
5241 if (strcmp (segment_name (now_seg), ".debug") != 0)
5242 dwarf_file_string = 0;
5243 else if (dwarf_file_string)
5244 {
5245 c = input_line_pointer[-1];
5246 input_line_pointer[-1] = '\0';
5247 listing_source_file (start);
5248 input_line_pointer[-1] = c;
5249 }
5250 #endif
5251
5252 break;
5253 case '<':
5254 input_line_pointer++;
5255 c = get_single_number ();
5256 stringer_append_char (c, bitsize);
5257 if (*input_line_pointer != '>')
5258 as_bad (_("expected <nn>"));
5259
5260 input_line_pointer++;
5261 break;
5262 case ',':
5263 input_line_pointer++;
5264 break;
5265 }
5266 SKIP_WHITESPACE ();
5267 c = *input_line_pointer;
5268 }
5269
5270 demand_empty_rest_of_line ();
5271 }
5272 \f
5273 /* FIXME-SOMEDAY: I had trouble here on characters with the
5274 high bits set. We'll probably also have trouble with
5275 multibyte chars, wide chars, etc. Also be careful about
5276 returning values bigger than 1 byte. xoxorich. */
5277
5278 unsigned int
5279 next_char_of_string (void)
5280 {
5281 unsigned int c;
5282
5283 c = *input_line_pointer++ & CHAR_MASK;
5284 switch (c)
5285 {
5286 case '\"':
5287 c = NOT_A_CHAR;
5288 break;
5289
5290 case '\n':
5291 as_warn (_("unterminated string; newline inserted"));
5292 bump_line_counters ();
5293 break;
5294
5295 #ifndef NO_STRING_ESCAPES
5296 case '\\':
5297 switch (c = *input_line_pointer++)
5298 {
5299 case 'b':
5300 c = '\b';
5301 break;
5302
5303 case 'f':
5304 c = '\f';
5305 break;
5306
5307 case 'n':
5308 c = '\n';
5309 break;
5310
5311 case 'r':
5312 c = '\r';
5313 break;
5314
5315 case 't':
5316 c = '\t';
5317 break;
5318
5319 case 'v':
5320 c = '\013';
5321 break;
5322
5323 case '\\':
5324 case '"':
5325 break; /* As itself. */
5326
5327 case '0':
5328 case '1':
5329 case '2':
5330 case '3':
5331 case '4':
5332 case '5':
5333 case '6':
5334 case '7':
5335 case '8':
5336 case '9':
5337 {
5338 long number;
5339 int i;
5340
5341 for (i = 0, number = 0;
5342 ISDIGIT (c) && i < 3;
5343 c = *input_line_pointer++, i++)
5344 {
5345 number = number * 8 + c - '0';
5346 }
5347
5348 c = number & 0xff;
5349 }
5350 --input_line_pointer;
5351 break;
5352
5353 case 'x':
5354 case 'X':
5355 {
5356 long number;
5357
5358 number = 0;
5359 c = *input_line_pointer++;
5360 while (ISXDIGIT (c))
5361 {
5362 if (ISDIGIT (c))
5363 number = number * 16 + c - '0';
5364 else if (ISUPPER (c))
5365 number = number * 16 + c - 'A' + 10;
5366 else
5367 number = number * 16 + c - 'a' + 10;
5368 c = *input_line_pointer++;
5369 }
5370 c = number & 0xff;
5371 --input_line_pointer;
5372 }
5373 break;
5374
5375 case '\n':
5376 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
5377 as_warn (_("unterminated string; newline inserted"));
5378 c = '\n';
5379 bump_line_counters ();
5380 break;
5381
5382 default:
5383
5384 #ifdef ONLY_STANDARD_ESCAPES
5385 as_bad (_("bad escaped character in string"));
5386 c = '?';
5387 #endif /* ONLY_STANDARD_ESCAPES */
5388
5389 break;
5390 }
5391 break;
5392 #endif /* ! defined (NO_STRING_ESCAPES) */
5393
5394 default:
5395 break;
5396 }
5397 return (c);
5398 }
5399 \f
5400 static segT
5401 get_segmented_expression (expressionS *expP)
5402 {
5403 segT retval;
5404
5405 retval = expression (expP);
5406 if (expP->X_op == O_illegal
5407 || expP->X_op == O_absent
5408 || expP->X_op == O_big)
5409 {
5410 as_bad (_("expected address expression"));
5411 expP->X_op = O_constant;
5412 expP->X_add_number = 0;
5413 retval = absolute_section;
5414 }
5415 return retval;
5416 }
5417
5418 static segT
5419 get_known_segmented_expression (expressionS *expP)
5420 {
5421 segT retval = get_segmented_expression (expP);
5422
5423 if (retval == undefined_section)
5424 {
5425 /* There is no easy way to extract the undefined symbol from the
5426 expression. */
5427 if (expP->X_add_symbol != NULL
5428 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5429 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5430 S_GET_NAME (expP->X_add_symbol));
5431 else
5432 as_warn (_("some symbol undefined; zero assumed"));
5433 retval = absolute_section;
5434 expP->X_op = O_constant;
5435 expP->X_add_number = 0;
5436 }
5437 return retval;
5438 }
5439
5440 char /* Return terminator. */
5441 get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
5442 {
5443 /* FIXME: val_pointer should probably be offsetT *. */
5444 *val_pointer = (long) get_absolute_expression ();
5445 return (*input_line_pointer++);
5446 }
5447 \f
5448 /* Like demand_copy_string, but return NULL if the string contains any '\0's.
5449 Give a warning if that happens. */
5450
5451 char *
5452 demand_copy_C_string (int *len_pointer)
5453 {
5454 char *s;
5455
5456 if ((s = demand_copy_string (len_pointer)) != 0)
5457 {
5458 int len;
5459
5460 for (len = *len_pointer; len > 0; len--)
5461 {
5462 if (*s == 0)
5463 {
5464 s = 0;
5465 len = 1;
5466 *len_pointer = 0;
5467 as_bad (_("this string may not contain \'\\0\'"));
5468 }
5469 }
5470 }
5471
5472 return s;
5473 }
5474 \f
5475 /* Demand string, but return a safe (=private) copy of the string.
5476 Return NULL if we can't read a string here. */
5477
5478 char *
5479 demand_copy_string (int *lenP)
5480 {
5481 unsigned int c;
5482 int len;
5483 char *retval;
5484
5485 len = 0;
5486 SKIP_WHITESPACE ();
5487 if (*input_line_pointer == '\"')
5488 {
5489 input_line_pointer++; /* Skip opening quote. */
5490
5491 while (is_a_char (c = next_char_of_string ()))
5492 {
5493 obstack_1grow (&notes, c);
5494 len++;
5495 }
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);
5500 }
5501 else
5502 {
5503 as_bad (_("missing string"));
5504 retval = NULL;
5505 ignore_rest_of_line ();
5506 }
5507 *lenP = len;
5508 return (retval);
5509 }
5510 \f
5511 /* In: Input_line_pointer->next character.
5512
5513 Do: Skip input_line_pointer over all whitespace.
5514
5515 Out: 1 if input_line_pointer->end-of-line. */
5516
5517 int
5518 is_it_end_of_statement (void)
5519 {
5520 SKIP_WHITESPACE ();
5521 return (is_end_of_line[(unsigned char) *input_line_pointer]);
5522 }
5523
5524 void
5525 equals (char *sym_name, int reassign)
5526 {
5527 char *stop = NULL;
5528 char stopc = 0;
5529
5530 input_line_pointer++;
5531 if (*input_line_pointer == '=')
5532 input_line_pointer++;
5533 if (reassign < 0 && *input_line_pointer == '=')
5534 input_line_pointer++;
5535
5536 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5537 input_line_pointer++;
5538
5539 if (flag_mri)
5540 stop = mri_comment_field (&stopc);
5541
5542 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
5543
5544 if (flag_mri)
5545 {
5546 demand_empty_rest_of_line ();
5547 mri_comment_end (stop, stopc);
5548 }
5549 }
5550
5551 /* .incbin -- include a file verbatim at the current location. */
5552
5553 void
5554 s_incbin (int x ATTRIBUTE_UNUSED)
5555 {
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;
5564
5565 #ifdef md_flush_pending_output
5566 md_flush_pending_output ();
5567 #endif
5568
5569 #ifdef md_cons_align
5570 md_cons_align (1);
5571 #endif
5572
5573 SKIP_WHITESPACE ();
5574 filename = demand_copy_string (& len);
5575 if (filename == NULL)
5576 return;
5577
5578 SKIP_WHITESPACE ();
5579
5580 /* Look for optional skip and count. */
5581 if (* input_line_pointer == ',')
5582 {
5583 ++ input_line_pointer;
5584 skip = get_absolute_expression ();
5585
5586 SKIP_WHITESPACE ();
5587
5588 if (* input_line_pointer == ',')
5589 {
5590 ++ input_line_pointer;
5591
5592 count = get_absolute_expression ();
5593 if (count == 0)
5594 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5595
5596 SKIP_WHITESPACE ();
5597 }
5598 }
5599
5600 demand_empty_rest_of_line ();
5601
5602 /* Try opening absolute path first, then try include dirs. */
5603 binfile = fopen (filename, FOPEN_RB);
5604 if (binfile == NULL)
5605 {
5606 int i;
5607
5608 path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5609
5610 for (i = 0; i < include_dir_count; i++)
5611 {
5612 sprintf (path, "%s/%s", include_dirs[i], filename);
5613
5614 binfile = fopen (path, FOPEN_RB);
5615 if (binfile != NULL)
5616 break;
5617 }
5618
5619 if (binfile == NULL)
5620 as_bad (_("file not found: %s"), filename);
5621 }
5622 else
5623 path = xstrdup (filename);
5624
5625 if (binfile)
5626 {
5627 long file_len;
5628
5629 register_dependency (path);
5630
5631 /* Compute the length of the file. */
5632 if (fseek (binfile, 0, SEEK_END) != 0)
5633 {
5634 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5635 goto done;
5636 }
5637 file_len = ftell (binfile);
5638
5639 /* If a count was not specified use the remainder of the file. */
5640 if (count == 0)
5641 count = file_len - skip;
5642
5643 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
5644 {
5645 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
5646 skip, count, file_len);
5647 goto done;
5648 }
5649
5650 if (fseek (binfile, skip, SEEK_SET) != 0)
5651 {
5652 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5653 goto done;
5654 }
5655
5656 /* Allocate frag space and store file contents in it. */
5657 binfrag = frag_more (count);
5658
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);
5663 }
5664 done:
5665 if (binfile != NULL)
5666 fclose (binfile);
5667 if (path)
5668 free (path);
5669 }
5670
5671 /* .include -- include a file at this point. */
5672
5673 void
5674 s_include (int arg ATTRIBUTE_UNUSED)
5675 {
5676 char *filename;
5677 int i;
5678 FILE *try_file;
5679 char *path;
5680
5681 if (!flag_m68k_mri)
5682 {
5683 filename = demand_copy_string (&i);
5684 if (filename == NULL)
5685 {
5686 /* demand_copy_string has already printed an error and
5687 called ignore_rest_of_line. */
5688 return;
5689 }
5690 }
5691 else
5692 {
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')
5698 {
5699 obstack_1grow (&notes, *input_line_pointer);
5700 ++input_line_pointer;
5701 ++i;
5702 }
5703
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;
5708 }
5709
5710 demand_empty_rest_of_line ();
5711 path = (char *) xmalloc ((unsigned long) i
5712 + include_dir_maxlen + 5 /* slop */ );
5713
5714 for (i = 0; i < include_dir_count; i++)
5715 {
5716 strcpy (path, include_dirs[i]);
5717 strcat (path, "/");
5718 strcat (path, filename);
5719 if (0 != (try_file = fopen (path, FOPEN_RT)))
5720 {
5721 fclose (try_file);
5722 goto gotit;
5723 }
5724 }
5725
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);
5732 }
5733
5734 void
5735 add_include_dir (char *path)
5736 {
5737 int i;
5738
5739 if (include_dir_count == 0)
5740 {
5741 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
5742 include_dirs[0] = "."; /* Current dir. */
5743 include_dir_count = 2;
5744 }
5745 else
5746 {
5747 include_dir_count++;
5748 include_dirs =
5749 (char **) realloc (include_dirs,
5750 include_dir_count * sizeof (*include_dirs));
5751 }
5752
5753 include_dirs[include_dir_count - 1] = path; /* New one. */
5754
5755 i = strlen (path);
5756 if (i > include_dir_maxlen)
5757 include_dir_maxlen = i;
5758 }
5759 \f
5760 /* Output debugging information to denote the source file. */
5761
5762 static void
5763 generate_file_debug (void)
5764 {
5765 if (debug_type == DEBUG_STABS)
5766 stabs_generate_asm_file ();
5767 }
5768
5769 /* Output line number debugging information for the current source line. */
5770
5771 void
5772 generate_lineno_debug (void)
5773 {
5774 switch (debug_type)
5775 {
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;
5792 }
5793 }
5794
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. */
5797
5798 void
5799 s_func (int end_p)
5800 {
5801 do_s_func (end_p, NULL);
5802 }
5803
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". */
5806
5807 static void
5808 do_s_func (int end_p, const char *default_prefix)
5809 {
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;
5815
5816 if (end_p)
5817 {
5818 if (current_name == NULL)
5819 {
5820 as_bad (_("missing .func"));
5821 ignore_rest_of_line ();
5822 return;
5823 }
5824
5825 if (debug_type == DEBUG_STABS)
5826 stabs_generate_asm_endfunc (current_name, current_label);
5827
5828 current_name = current_label = NULL;
5829 }
5830 else /* ! end_p */
5831 {
5832 char *name, *label;
5833 char delim1, delim2;
5834
5835 if (current_name != NULL)
5836 {
5837 as_bad (_(".endfunc missing for previous .func"));
5838 ignore_rest_of_line ();
5839 return;
5840 }
5841
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 != ',')
5848 {
5849 if (default_prefix)
5850 {
5851 if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5852 as_fatal ("%s", xstrerror (errno));
5853 }
5854 else
5855 {
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)
5860 {
5861 if (asprintf (&label, "%c%s", leading_char, name) == -1)
5862 as_fatal ("%s", xstrerror (errno));
5863 }
5864 else
5865 label = name;
5866 }
5867 }
5868 else
5869 {
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;
5876 }
5877
5878 if (debug_type == DEBUG_STABS)
5879 stabs_generate_asm_func (name, label);
5880
5881 current_name = name;
5882 current_label = label;
5883 }
5884
5885 demand_empty_rest_of_line ();
5886 }
5887 \f
5888 void
5889 s_ignore (int arg ATTRIBUTE_UNUSED)
5890 {
5891 ignore_rest_of_line ();
5892 }
5893
5894 void
5895 read_print_statistics (FILE *file)
5896 {
5897 hash_print_statistics (file, "pseudo-op table", po_hash);
5898 }
5899
5900 /* Inserts the given line into the input stream.
5901
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.
5904
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. */
5908
5909 void
5910 input_scrub_insert_line (const char *line)
5911 {
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);
5918 }
5919
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. */
5922
5923 void
5924 input_scrub_insert_file (char *path)
5925 {
5926 input_scrub_include_file (path, input_line_pointer);
5927 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5928 }
5929
5930 /* Find the end of a line, considering quotation and escaping of quotes. */
5931
5932 #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5933 # define TC_SINGLE_QUOTE_STRINGS 1
5934 #endif
5935
5936 static char *
5937 _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
5938 int in_macro)
5939 {
5940 char inquote = '\0';
5941 int inescape = 0;
5942
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 == '@')
5956 )
5957 {
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;
5972 }
5973 if (inquote)
5974 as_warn (_("missing closing `%c'"), inquote);
5975 if (inescape)
5976 as_warn (_("stray `\\'"));
5977 return s;
5978 }
5979
5980 char *
5981 find_end_of_line (char *s, int mri_string)
5982 {
5983 return _find_end_of_line (s, mri_string, 0, 0);
5984 }
This page took 0.146736 seconds and 5 git commands to generate.