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