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