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