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