projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2006-06-19 Vladimir Prus <vladimir@codesourcery.com>
[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 ();
3135 subseg_set (absolute_section, 0);
3136 demand_empty_rest_of_line ();
3137 if (flag_mri)
3138 mri_comment_end (stop, stopc);
3139}
3140
3141void
39e6acbd 3142s_text (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 3143{
3144 register int temp;
3145
3146 temp = get_absolute_expression ();
3147 subseg_set (text_section, (subsegT) temp);
3148 demand_empty_rest_of_line ();
3149#ifdef OBJ_VMS
3150 const_flag &= ~IN_DEFAULT_SECTION;
3151#endif
041ff4dd 3152}
06e77878
AO		 3153
3154/* .weakref x, y sets x as an alias to y that, as long as y is not
3155 referenced directly, will cause y to become a weak symbol. */
3156void
3157s_weakref (int ignore ATTRIBUTE_UNUSED)
3158{
3159 char *name;
3160 char delim;
3161 char *end_name;
3162 symbolS *symbolP;
3163 symbolS *symbolP2;
3164 expressionS exp;
3165
3166 name = input_line_pointer;
3167 delim = get_symbol_end ();
3168 end_name = input_line_pointer;
3169
3170 if (name == end_name)
3171 {
3172 as_bad (_("expected symbol name"));
3173 *end_name = delim;
3174 ignore_rest_of_line ();
3175 return;
3176 }
3177
3178 symbolP = symbol_find_or_make (name);
3179
b54788f8
AO		 3180 if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
3181 {
89cdfe57 3182 if (!S_IS_VOLATILE (symbolP))
92757bc9
JB		 3183 {
3184 as_bad (_("symbol `%s' is already defined"), name);
3185 *end_name = delim;
3186 ignore_rest_of_line ();
3187 return;
3188 }
89cdfe57 3189 symbolP = symbol_clone (symbolP, 1);
92757bc9 3190 S_CLEAR_VOLATILE (symbolP);
b54788f8
AO		 3191 }
3192
06e77878
AO		 3193 *end_name = delim;
3194
3195 SKIP_WHITESPACE ();
3196
3197 if (*input_line_pointer != ',')
3198 {
3199 *end_name = 0;
3200 as_bad (_("expected comma after \"%s\""), name);
3201 *end_name = delim;
3202 ignore_rest_of_line ();
3203 return;
3204 }
3205
3206 input_line_pointer++;
3207
3208 SKIP_WHITESPACE ();
3209
3210 name = input_line_pointer;
3211 delim = get_symbol_end ();
3212 end_name = input_line_pointer;
3213
3214 if (name == end_name)
3215 {
3216 as_bad (_("expected symbol name"));
3217 ignore_rest_of_line ();
3218 return;
3219 }
3220
3221 if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
3222 && (symbolP2 = md_undefined_symbol (name)) == NULL)
3223 {
3224 symbolP2 = symbol_find_or_make (name);
3225 S_SET_WEAKREFD (symbolP2);
3226 }
3227 else
3228 {
3229 symbolS *symp = symbolP2;
3230
3231 while (S_IS_WEAKREFR (symp) && symp != symbolP)
3232 {
3233 expressionS *expP = symbol_get_value_expression (symp);
3234
3235 assert (expP->X_op == O_symbol
3236 && expP->X_add_number == 0);
3237 symp = expP->X_add_symbol;
3238 }
3239 if (symp == symbolP)
3240 {
3241 char *loop;
3242
3243 loop = concat (S_GET_NAME (symbolP),
3244 " => ", S_GET_NAME (symbolP2), NULL);
3245
3246 symp = symbolP2;
3247 while (symp != symbolP)
3248 {
3249 char *old_loop = loop;
3250 symp = symbol_get_value_expression (symp)->X_add_symbol;
3251 loop = concat (loop, " => ", S_GET_NAME (symp), NULL);
3252 free (old_loop);
3253 }
3254
3255 as_bad (_("%s: would close weakref loop: %s"),
3256 S_GET_NAME (symbolP), loop);
3257
3258 free (loop);
3259
3260 *end_name = delim;
3261 ignore_rest_of_line ();
3262 return;
3263 }
3264
3265 /* Short-circuiting instead of just checking here might speed
3266 things up a tiny little bit, but loop error messages would
3267 miss intermediate links. */
3268 /* symbolP2 = symp; */
3269 }
3270
3271 *end_name = delim;
3272
3273 memset (&exp, 0, sizeof (exp));
3274 exp.X_op = O_symbol;
3275 exp.X_add_symbol = symbolP2;
3276
3277 S_SET_SEGMENT (symbolP, undefined_section);
3278 symbol_set_value_expression (symbolP, &exp);
3279 symbol_set_frag (symbolP, &zero_address_frag);
3280 S_SET_WEAKREFR (symbolP);
3281
3282 demand_empty_rest_of_line ();
3283}
252b5132 3284\f
c95b35a9
NS		 3285
3286/* Verify that we are at the end of a line. If not, issue an error and
3287 skip to EOL. */
3288
041ff4dd 3289void
39e6acbd 3290demand_empty_rest_of_line (void)
252b5132
RH		 3291{
3292 SKIP_WHITESPACE ();
3293 if (is_end_of_line[(unsigned char) *input_line_pointer])
041ff4dd 3294 input_line_pointer++;
252b5132 3295 else
252b5132 3296 {
3882b010 3297 if (ISPRINT (*input_line_pointer))
c95b35a9 3298 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
0e389e77 3299 *input_line_pointer);
252b5132 3300 else
c95b35a9 3301 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
0e389e77 3302 *input_line_pointer);
c95b35a9 3303 ignore_rest_of_line ();
252b5132 3304 }
c95b35a9
NS		 3305
3306 /* Return pointing just after end-of-line. */
3307 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3308}
3309
3310/* Silently advance to the end of line. Use this after already having
3311 issued an error about something bad. */
3312
3313void
3314ignore_rest_of_line (void)
3315{
3316 while (input_line_pointer < buffer_limit
3317 && !is_end_of_line[(unsigned char) *input_line_pointer])
3318 input_line_pointer++;
f0e652b4 3319
041ff4dd
NC		 3320 input_line_pointer++;
3321
3322 /* Return pointing just after end-of-line. */
252b5132
RH		 3323 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3324}
3325
be95a9c1
AM		 3326/* Sets frag for given symbol to zero_address_frag, except when the
3327 symbol frag is already set to a dummy listing frag. */
3328
3329static void
3330set_zero_frag (symbolS *symbolP)
3331{
3332 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3333 symbol_set_frag (symbolP, &zero_address_frag);
3334}
3335
041ff4dd 3336/* In: Pointer to a symbol.
d6415f6c 3337 Input_line_pointer->expression.
f0e652b4 3338
041ff4dd 3339 Out: Input_line_pointer->just after any whitespace after expression.
d6415f6c
AM		 3340 Tried to set symbol to value of expression.
3341 Will change symbols type, value, and frag; */
041ff4dd 3342
252b5132 3343void
39e6acbd 3344pseudo_set (symbolS *symbolP)
252b5132
RH		 3345{
3346 expressionS exp;
be95a9c1 3347 segT seg;
252b5132 3348
041ff4dd 3349 know (symbolP); /* NULL pointer is logic error. */
252b5132 3350
9497f5ac
NC		 3351 if (!S_IS_FORWARD_REF (symbolP))
3352 (void) expression (&exp);
3353 else
3354 (void) deferred_expression (&exp);
252b5132
RH		 3355
3356 if (exp.X_op == O_illegal)
0e389e77 3357 as_bad (_("illegal expression"));
252b5132 3358 else if (exp.X_op == O_absent)
0e389e77 3359 as_bad (_("missing expression"));
252b5132
RH		 3360 else if (exp.X_op == O_big)
3361 {
3362 if (exp.X_add_number > 0)
0e389e77 3363 as_bad (_("bignum invalid"));
252b5132 3364 else
0e389e77 3365 as_bad (_("floating point number invalid"));
252b5132
RH		 3366 }
3367 else if (exp.X_op == O_subtract
9497f5ac 3368 && !S_IS_FORWARD_REF (symbolP)
252b5132 3369 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
2b47531b
ILT		 3370 && (symbol_get_frag (exp.X_add_symbol)
3371 == symbol_get_frag (exp.X_op_symbol)))
252b5132
RH		 3372 {
3373 exp.X_op = O_constant;
3374 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3375 - S_GET_VALUE (exp.X_op_symbol));
3376 }
3377
be95a9c1
AM		 3378 if (symbol_section_p (symbolP))
3379 {
3380 as_bad ("attempt to set value of section symbol");
3381 return;
3382 }
be95a9c1 3383
252b5132
RH		 3384 switch (exp.X_op)
3385 {
3386 case O_illegal:
3387 case O_absent:
3388 case O_big:
3389 exp.X_add_number = 0;
3390 /* Fall through. */
3391 case O_constant:
3392 S_SET_SEGMENT (symbolP, absolute_section);
252b5132 3393 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
be95a9c1 3394 set_zero_frag (symbolP);
252b5132
RH		 3395 break;
3396
3397 case O_register:
3398 S_SET_SEGMENT (symbolP, reg_section);
3399 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
be95a9c1 3400 set_zero_frag (symbolP);
252b5132
RH		 3401 break;
3402
3403 case O_symbol:
be95a9c1
AM		 3404 seg = S_GET_SEGMENT (exp.X_add_symbol);
3405 /* For x=undef+const, create an expression symbol.
3406 For x=x+const, just update x except when x is an undefined symbol
3407 For x=defined+const, evaluate x. */
3408 if (symbolP == exp.X_add_symbol
3409 && (seg != undefined_section
3410 || !symbol_constant_p (symbolP)))
3411 {
3412 *symbol_X_add_number (symbolP) += exp.X_add_number;
3413 break;
3414 }
9497f5ac 3415 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
252b5132
RH		 3416 {
3417 symbolS *s = exp.X_add_symbol;
3418
60938e80
L		 3419 if (S_IS_COMMON (s))
3420 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3421 S_GET_NAME (symbolP), S_GET_NAME (s));
3422
be95a9c1
AM		 3423 S_SET_SEGMENT (symbolP, seg);
3424 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
2b47531b 3425 symbol_set_frag (symbolP, symbol_get_frag (s));
252b5132 3426 copy_symbol_attributes (symbolP, s);
be95a9c1 3427 break;
252b5132 3428 }
66bd02d3
AM		 3429 S_SET_SEGMENT (symbolP, undefined_section);
3430 symbol_set_value_expression (symbolP, &exp);
3431 set_zero_frag (symbolP);
3432 break;
252b5132
RH		 3433
3434 default:
aba4aa7d
AM		 3435 /* The value is some complex expression. */
3436 S_SET_SEGMENT (symbolP, expr_section);
2b47531b 3437 symbol_set_value_expression (symbolP, &exp);
be95a9c1 3438 set_zero_frag (symbolP);
252b5132
RH		 3439 break;
3440 }
3441}
3442\f
d6415f6c 3443/* cons()
f0e652b4 3444
041ff4dd
NC		 3445 CONStruct more frag of .bytes, or .words etc.
3446 Should need_pass_2 be 1 then emit no frag(s).
3447 This understands EXPRESSIONS.
f0e652b4 3448
041ff4dd 3449 Bug (?)
f0e652b4 3450
041ff4dd
NC		 3451 This has a split personality. We use expression() to read the
3452 value. We can detect if the value won't fit in a byte or word.
3453 But we can't detect if expression() discarded significant digits
3454 in the case of a long. Not worth the crocks required to fix it. */
252b5132
RH		 3455
3456/* Select a parser for cons expressions. */
3457
3458/* Some targets need to parse the expression in various fancy ways.
3459 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3460 (for example, the HPPA does this). Otherwise, you can define
3461 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3462 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3463 are defined, which is the normal case, then only simple expressions
3464 are permitted. */
3465
abd63a32 3466#ifdef TC_M68K
252b5132 3467static void
39e6acbd 3468parse_mri_cons (expressionS *exp, unsigned int nbytes);
abd63a32 3469#endif
252b5132
RH		 3470
3471#ifndef TC_PARSE_CONS_EXPRESSION
3472#ifdef BITFIELD_CONS_EXPRESSIONS
3473#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
041ff4dd 3474static void
39e6acbd 3475parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
252b5132
RH		 3476#endif
3477#ifdef REPEAT_CONS_EXPRESSIONS
3478#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3479static void
39e6acbd 3480parse_repeat_cons (expressionS *exp, unsigned int nbytes);
252b5132
RH		 3481#endif
3482
3483/* If we haven't gotten one yet, just call expression. */
3484#ifndef TC_PARSE_CONS_EXPRESSION
3485#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3486#endif
3487#endif
3488
cdfbf930 3489void
b41b1f95
L		 3490do_parse_cons_expression (expressionS *exp,
3491 int nbytes ATTRIBUTE_UNUSED)
cdfbf930
RH		 3492{
3493 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3494}
3495
3496
041ff4dd
NC		 3497/* Worker to do .byte etc statements.
3498 Clobbers input_line_pointer and checks end-of-line. */
3499
3500static void
39e6acbd
KH		 3501cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3502 int rva)
252b5132
RH		 3503{
3504 int c;
3505 expressionS exp;
3506 char *stop = NULL;
3507 char stopc;
3508
3509#ifdef md_flush_pending_output
3510 md_flush_pending_output ();
3511#endif
3512
3513 if (flag_mri)
3514 stop = mri_comment_field (&stopc);
3515
3516 if (is_it_end_of_statement ())
3517 {
3518 demand_empty_rest_of_line ();
3519 if (flag_mri)
3520 mri_comment_end (stop, stopc);
3521 return;
3522 }
3523
cc1bc22a
AM		 3524#ifdef TC_ADDRESS_BYTES
3525 if (nbytes == 0)
3526 nbytes = TC_ADDRESS_BYTES ();
3527#endif
3528
252b5132
RH		 3529#ifdef md_cons_align
3530 md_cons_align (nbytes);
3531#endif
3532
3533 c = 0;
3534 do
3535 {
abd63a32 3536#ifdef TC_M68K
252b5132
RH		 3537 if (flag_m68k_mri)
3538 parse_mri_cons (&exp, (unsigned int) nbytes);
3539 else
abd63a32 3540#endif
252b5132
RH		 3541 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3542
3543 if (rva)
3544 {
3545 if (exp.X_op == O_symbol)
3546 exp.X_op = O_symbol_rva;
3547 else
3548 as_fatal (_("rva without symbol"));
3549 }
3550 emit_expr (&exp, (unsigned int) nbytes);
3551 ++c;
3552 }
3553 while (*input_line_pointer++ == ',');
3554
3555 /* In MRI mode, after an odd number of bytes, we must align to an
3556 even word boundary, unless the next instruction is a dc.b, ds.b
3557 or dcb.b. */
3558 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3559 mri_pending_align = 1;
3560
041ff4dd 3561 input_line_pointer--; /* Put terminator back into stream. */
252b5132
RH		 3562
3563 demand_empty_rest_of_line ();
3564
3565 if (flag_mri)
3566 mri_comment_end (stop, stopc);
3567}
3568
252b5132 3569void
39e6acbd 3570cons (int size)
252b5132
RH		 3571{
3572 cons_worker (size, 0);
3573}
3574
041ff4dd 3575void
39e6acbd 3576s_rva (int size)
252b5132
RH		 3577{
3578 cons_worker (size, 1);
3579}
3580
3581/* Put the contents of expression EXP into the object file using
3582 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3583
3584void
39e6acbd 3585emit_expr (expressionS *exp, unsigned int nbytes)
252b5132
RH		 3586{
3587 operatorT op;
3588 register char *p;
3589 valueT extra_digit = 0;
3590
3591 /* Don't do anything if we are going to make another pass. */
3592 if (need_pass_2)
3593 return;
3594
ed7d5d1a
AM		 3595 dot_value = frag_now_fix ();
3596
252b5132
RH		 3597#ifndef NO_LISTING
3598#ifdef OBJ_ELF
3599 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3600 appear as a four byte positive constant in the .line section,
3601 followed by a 2 byte 0xffff. Look for that case here. */
3602 {
3603 static int dwarf_line = -1;
3604
3605 if (strcmp (segment_name (now_seg), ".line") != 0)
3606 dwarf_line = -1;
3607 else if (dwarf_line >= 0
3608 && nbytes == 2
3609 && exp->X_op == O_constant
3610 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3611 listing_source_line ((unsigned int) dwarf_line);
3612 else if (nbytes == 4
3613 && exp->X_op == O_constant
3614 && exp->X_add_number >= 0)
3615 dwarf_line = exp->X_add_number;
3616 else
3617 dwarf_line = -1;
3618 }
3619
3620 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3621 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3622 AT_sibling (0x12) followed by a four byte address of the sibling
3623 followed by a 2 byte AT_name (0x38) followed by the name of the
3624 file. We look for that case here. */
3625 {
3626 static int dwarf_file = 0;
3627
3628 if (strcmp (segment_name (now_seg), ".debug") != 0)
3629 dwarf_file = 0;
3630 else if (dwarf_file == 0
3631 && nbytes == 2
3632 && exp->X_op == O_constant
3633 && exp->X_add_number == 0x11)
3634 dwarf_file = 1;
3635 else if (dwarf_file == 1
3636 && nbytes == 2
3637 && exp->X_op == O_constant
3638 && exp->X_add_number == 0x12)
3639 dwarf_file = 2;
3640 else if (dwarf_file == 2
3641 && nbytes == 4)
3642 dwarf_file = 3;
3643 else if (dwarf_file == 3
3644 && nbytes == 2
3645 && exp->X_op == O_constant
3646 && exp->X_add_number == 0x38)
3647 dwarf_file = 4;
3648 else
3649 dwarf_file = 0;
3650
3651 /* The variable dwarf_file_string tells stringer that the string
3652 may be the name of the source file. */
3653 if (dwarf_file == 4)
3654 dwarf_file_string = 1;
3655 else
3656 dwarf_file_string = 0;
3657 }
3658#endif
3659#endif
3660
3661 if (check_eh_frame (exp, &nbytes))
3662 return;
3663
3664 op = exp->X_op;
3665
3666 /* Allow `.word 0' in the absolute section. */
3667 if (now_seg == absolute_section)
3668 {
3669 if (op != O_constant || exp->X_add_number != 0)
3670 as_bad (_("attempt to store value in absolute section"));
3671 abs_section_offset += nbytes;
3672 return;
3673 }
3674
3675 /* Handle a negative bignum. */
3676 if (op == O_uminus
3677 && exp->X_add_number == 0
2b47531b
ILT		 3678 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3679 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
252b5132
RH		 3680 {
3681 int i;
3682 unsigned long carry;
3683
2b47531b 3684 exp = symbol_get_value_expression (exp->X_add_symbol);
252b5132
RH		 3685
3686 /* Negate the bignum: one's complement each digit and add 1. */
3687 carry = 1;
3688 for (i = 0; i < exp->X_add_number; i++)
3689 {
3690 unsigned long next;
3691
041ff4dd 3692 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
252b5132
RH		 3693 & LITTLENUM_MASK)
3694 + carry);
3695 generic_bignum[i] = next & LITTLENUM_MASK;
3696 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3697 }
3698
3699 /* We can ignore any carry out, because it will be handled by
3700 extra_digit if it is needed. */
3701
3702 extra_digit = (valueT) -1;
3703 op = O_big;
3704 }
3705
3706 if (op == O_absent || op == O_illegal)
3707 {
3708 as_warn (_("zero assumed for missing expression"));
3709 exp->X_add_number = 0;
3710 op = O_constant;
3711 }
3712 else if (op == O_big && exp->X_add_number <= 0)
3713 {
0e389e77 3714 as_bad (_("floating point number invalid"));
252b5132
RH		 3715 exp->X_add_number = 0;
3716 op = O_constant;
3717 }
3718 else if (op == O_register)
3719 {
3720 as_warn (_("register value used as expression"));
3721 op = O_constant;
3722 }
3723
3724 p = frag_more ((int) nbytes);
3725
3726#ifndef WORKING_DOT_WORD
3727 /* If we have the difference of two symbols in a word, save it on
3728 the broken_words list. See the code in write.c. */
3729 if (op == O_subtract && nbytes == 2)
3730 {
3731 struct broken_word *x;
3732
3733 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3734 x->next_broken_word = broken_words;
3735 broken_words = x;
3736 x->seg = now_seg;
3737 x->subseg = now_subseg;
3738 x->frag = frag_now;
3739 x->word_goes_here = p;
3740 x->dispfrag = 0;
3741 x->add = exp->X_add_symbol;
3742 x->sub = exp->X_op_symbol;
3743 x->addnum = exp->X_add_number;
3744 x->added = 0;
dc59a897 3745 x->use_jump = 0;
252b5132
RH		 3746 new_broken_words++;
3747 return;
3748 }
3749#endif
3750
3751 /* If we have an integer, but the number of bytes is too large to
3752 pass to md_number_to_chars, handle it as a bignum. */
3753 if (op == O_constant && nbytes > sizeof (valueT))
3754 {
e5604d79
RS		 3755 extra_digit = exp->X_unsigned ? 0 : -1;
3756 convert_to_bignum (exp);
3757 op = O_big;
252b5132
RH		 3758 }
3759
3760 if (op == O_constant)
3761 {
3762 register valueT get;
3763 register valueT use;
3764 register valueT mask;
3765 valueT hibit;
3766 register valueT unmask;
3767
3768 /* JF << of >= number of bits in the object is undefined. In
041ff4dd 3769 particular SPARC (Sun 4) has problems. */
252b5132
RH		 3770 if (nbytes >= sizeof (valueT))
3771 {
3772 mask = 0;
3773 if (nbytes > sizeof (valueT))
3774 hibit = 0;
3775 else
3776 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3777 }
3778 else
3779 {
041ff4dd 3780 /* Don't store these bits. */
252b5132
RH		 3781 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3782 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3783 }
3784
041ff4dd 3785 unmask = ~mask; /* Do store these bits. */
252b5132
RH		 3786
3787#ifdef NEVER
3788 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
041ff4dd 3789 mask = ~(unmask >> 1); /* Includes sign bit now. */
252b5132
RH		 3790#endif
3791
3792 get = exp->X_add_number;
3793 use = get & unmask;
3794 if ((get & mask) != 0
3795 && ((get & mask) != mask
3796 || (get & hibit) == 0))
041ff4dd 3797 { /* Leading bits contain both 0s & 1s. */
0e389e77 3798 as_warn (_("value 0x%lx truncated to 0x%lx"),
252b5132
RH		 3799 (unsigned long) get, (unsigned long) use);
3800 }
041ff4dd 3801 /* Put bytes in right order. */
252b5132
RH		 3802 md_number_to_chars (p, use, (int) nbytes);
3803 }
3804 else if (op == O_big)
3805 {
3806 unsigned int size;
3807 LITTLENUM_TYPE *nums;
3808
3809 know (nbytes % CHARS_PER_LITTLENUM == 0);
3810
3811 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3812 if (nbytes < size)
3813 {
0e389e77 3814 as_warn (_("bignum truncated to %d bytes"), nbytes);
252b5132
RH		 3815 size = nbytes;
3816 }
3817
3818 if (target_big_endian)
3819 {
3820 while (nbytes > size)
3821 {
3822 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3823 nbytes -= CHARS_PER_LITTLENUM;
3824 p += CHARS_PER_LITTLENUM;
3825 }
3826
3827 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
ceac3f62 3828 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 3829 {
3830 --nums;
3831 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3832 size -= CHARS_PER_LITTLENUM;
3833 p += CHARS_PER_LITTLENUM;
3834 }
3835 }
3836 else
3837 {
3838 nums = generic_bignum;
ceac3f62 3839 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 3840 {
3841 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3842 ++nums;
3843 size -= CHARS_PER_LITTLENUM;
3844 p += CHARS_PER_LITTLENUM;
3845 nbytes -= CHARS_PER_LITTLENUM;
3846 }
3847
ceac3f62 3848 while (nbytes >= CHARS_PER_LITTLENUM)
252b5132
RH		 3849 {
3850 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3851 nbytes -= CHARS_PER_LITTLENUM;
3852 p += CHARS_PER_LITTLENUM;
3853 }
3854 }
3855 }
3856 else
3857 {
3858 memset (p, 0, nbytes);
3859
7be1c489 3860 /* Now we need to generate a fixS to record the symbol value. */
252b5132 3861
252b5132
RH		 3862#ifdef TC_CONS_FIX_NEW
3863 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3864#else
3865 {
3866 bfd_reloc_code_real_type r;
3867
3868 switch (nbytes)
3869 {
3870 case 1:
3871 r = BFD_RELOC_8;
3872 break;
3873 case 2:
3874 r = BFD_RELOC_16;
3875 break;
3876 case 4:
3877 r = BFD_RELOC_32;
3878 break;
3879 case 8:
3880 r = BFD_RELOC_64;
3881 break;
3882 default:
3883 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3884 r = BFD_RELOC_32;
3885 break;
3886 }
3887 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3888 0, r);
3889 }
3890#endif
252b5132
RH		 3891 }
3892}
3893\f
3894#ifdef BITFIELD_CONS_EXPRESSIONS
3895
3896/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3897 w:x,y:z, where w and y are bitwidths and x and y are values. They
3898 then pack them all together. We do a little better in that we allow
3899 them in words, longs, etc. and we'll pack them in target byte order
3900 for you.
3901
47eebc20 3902 The rules are: pack least significant bit first, if a field doesn't
252b5132
RH		 3903 entirely fit, put it in the next unit. Overflowing the bitfield is
3904 explicitly *not* even a warning. The bitwidth should be considered
3905 a "mask".
3906
3907 To use this function the tc-XXX.h file should define
3908 BITFIELD_CONS_EXPRESSIONS. */
3909
041ff4dd 3910static void
252b5132
RH		 3911parse_bitfield_cons (exp, nbytes)
3912 expressionS *exp;
3913 unsigned int nbytes;
3914{
3915 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3916 char *hold = input_line_pointer;
3917
3918 (void) expression (exp);
3919
3920 if (*input_line_pointer == ':')
041ff4dd
NC		 3921 {
3922 /* Bitfields. */
252b5132
RH		 3923 long value = 0;
3924
3925 for (;;)
3926 {
3927 unsigned long width;
3928
3929 if (*input_line_pointer != ':')
3930 {
3931 input_line_pointer = hold;
3932 break;
041ff4dd 3933 } /* Next piece is not a bitfield. */
252b5132
RH		 3934
3935 /* In the general case, we can't allow
3936 full expressions with symbol
3937 differences and such. The relocation
3938 entries for symbols not defined in this
3939 assembly would require arbitrary field
3940 widths, positions, and masks which most
3941 of our current object formats don't
3942 support.
3943
3944 In the specific case where a symbol
3945 *is* defined in this assembly, we
3946 *could* build fixups and track it, but
3947 this could lead to confusion for the
3948 backends. I'm lazy. I'll take any
3949 SEG_ABSOLUTE. I think that means that
3950 you can use a previous .set or
041ff4dd 3951 .equ type symbol. xoxorich. */
252b5132
RH		 3952
3953 if (exp->X_op == O_absent)
3954 {
3955 as_warn (_("using a bit field width of zero"));
3956 exp->X_add_number = 0;
3957 exp->X_op = O_constant;
041ff4dd 3958 } /* Implied zero width bitfield. */
252b5132
RH		 3959
3960 if (exp->X_op != O_constant)
3961 {
3962 *input_line_pointer = '\0';
3963 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3964 *input_line_pointer = ':';
3965 demand_empty_rest_of_line ();
3966 return;
041ff4dd 3967 } /* Too complex. */
252b5132
RH		 3968
3969 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3970 {
3971 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3972 width, nbytes, (BITS_PER_CHAR * nbytes));
3973 width = BITS_PER_CHAR * nbytes;
041ff4dd 3974 } /* Too big. */
252b5132
RH		 3975
3976 if (width > bits_available)
3977 {
3978 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3979 input_line_pointer = hold;
3980 exp->X_add_number = value;
3981 break;
041ff4dd 3982 } /* Won't fit. */
252b5132 3983
ef99799a
KH		 3984 /* Skip ':'. */
3985 hold = ++input_line_pointer;
252b5132
RH		 3986
3987 (void) expression (exp);
3988 if (exp->X_op != O_constant)
3989 {
3990 char cache = *input_line_pointer;
3991
3992 *input_line_pointer = '\0';
3993 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3994 *input_line_pointer = cache;
3995 demand_empty_rest_of_line ();
3996 return;
041ff4dd 3997 } /* Too complex. */
252b5132
RH		 3998
3999 value |= ((~(-1 << width) & exp->X_add_number)
4000 << ((BITS_PER_CHAR * nbytes) - bits_available));
4001
4002 if ((bits_available -= width) == 0
4003 || is_it_end_of_statement ()
4004 || *input_line_pointer != ',')
4005 {
4006 break;
041ff4dd 4007 } /* All the bitfields we're gonna get. */
252b5132
RH		 4008
4009 hold = ++input_line_pointer;
4010 (void) expression (exp);
041ff4dd 4011 }
252b5132
RH		 4012
4013 exp->X_add_number = value;
4014 exp->X_op = O_constant;
4015 exp->X_unsigned = 1;
041ff4dd
NC		 4016 }
4017}
252b5132
RH		 4018
4019#endif /* BITFIELD_CONS_EXPRESSIONS */
4020\f
4021/* Handle an MRI style string expression. */
4022
abd63a32 4023#ifdef TC_M68K
252b5132
RH		 4024static void
4025parse_mri_cons (exp, nbytes)
4026 expressionS *exp;
4027 unsigned int nbytes;
4028{
4029 if (*input_line_pointer != '\''
4030 && (input_line_pointer[1] != '\''
4031 || (*input_line_pointer != 'A'
4032 && *input_line_pointer != 'E')))
4033 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4034 else
4035 {
4036 unsigned int scan;
4037 unsigned int result = 0;
4038
4039 /* An MRI style string. Cut into as many bytes as will fit into
4040 a nbyte chunk, left justify if necessary, and separate with
4041 commas so we can try again later. */
4042 if (*input_line_pointer == 'A')
4043 ++input_line_pointer;
4044 else if (*input_line_pointer == 'E')
4045 {
4046 as_bad (_("EBCDIC constants are not supported"));
4047 ++input_line_pointer;
4048 }
4049
4050 input_line_pointer++;
4051 for (scan = 0; scan < nbytes; scan++)
4052 {
4053 if (*input_line_pointer == '\'')
4054 {
4055 if (input_line_pointer[1] == '\'')
4056 {
4057 input_line_pointer++;
4058 }
4059 else
4060 break;
4061 }
4062 result = (result << 8) | (*input_line_pointer++);
4063 }
4064
041ff4dd 4065 /* Left justify. */
252b5132
RH		 4066 while (scan < nbytes)
4067 {
4068 result <<= 8;
4069 scan++;
4070 }
f0e652b4 4071
041ff4dd 4072 /* Create correct expression. */
252b5132
RH		 4073 exp->X_op = O_constant;
4074 exp->X_add_number = result;
f0e652b4 4075
041ff4dd 4076 /* Fake it so that we can read the next char too. */
252b5132
RH		 4077 if (input_line_pointer[0] != '\'' ||
4078 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4079 {
4080 input_line_pointer -= 2;
4081 input_line_pointer[0] = ',';
4082 input_line_pointer[1] = '\'';
4083 }
4084 else
4085 input_line_pointer++;
4086 }
4087}
abd63a32 4088#endif /* TC_M68K */
252b5132
RH		 4089\f
4090#ifdef REPEAT_CONS_EXPRESSIONS
4091
4092/* Parse a repeat expression for cons. This is used by the MIPS
4093 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4094 object file COUNT times.
4095
4096 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4097
4098static void
4099parse_repeat_cons (exp, nbytes)
4100 expressionS *exp;
4101 unsigned int nbytes;
4102{
4103 expressionS count;
4104 register int i;
4105
4106 expression (exp);
4107
4108 if (*input_line_pointer != ':')
4109 {
4110 /* No repeat count. */
4111 return;
4112 }
4113
4114 ++input_line_pointer;
4115 expression (&count);
4116 if (count.X_op != O_constant
4117 || count.X_add_number <= 0)
4118 {
0e389e77 4119 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4120 return;
4121 }
4122
4123 /* The cons function is going to output this expression once. So we
4124 output it count - 1 times. */
4125 for (i = count.X_add_number - 1; i > 0; i--)
4126 emit_expr (exp, nbytes);
4127}
4128
4129#endif /* REPEAT_CONS_EXPRESSIONS */
4130\f
4131/* Parse a floating point number represented as a hex constant. This
4132 permits users to specify the exact bits they want in the floating
4133 point number. */
4134
4135static int
39e6acbd 4136hex_float (int float_type, char *bytes)
252b5132
RH		 4137{
4138 int length;
4139 int i;
4140
4141 switch (float_type)
4142 {
4143 case 'f':
4144 case 'F':
4145 case 's':
4146 case 'S':
4147 length = 4;
4148 break;
4149
4150 case 'd':
4151 case 'D':
4152 case 'r':
4153 case 'R':
4154 length = 8;
4155 break;
4156
4157 case 'x':
4158 case 'X':
4159 length = 12;
4160 break;
4161
4162 case 'p':
4163 case 'P':
4164 length = 12;
4165 break;
4166
4167 default:
0e389e77 4168 as_bad (_("unknown floating type type '%c'"), float_type);
252b5132
RH		 4169 return -1;
4170 }
4171
4172 /* It would be nice if we could go through expression to parse the
4173 hex constant, but if we get a bignum it's a pain to sort it into
4174 the buffer correctly. */
4175 i = 0;
4176 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4177 {
4178 int d;
4179
4180 /* The MRI assembler accepts arbitrary underscores strewn about
041ff4dd 4181 through the hex constant, so we ignore them as well. */
252b5132
RH		 4182 if (*input_line_pointer == '_')
4183 {
4184 ++input_line_pointer;
4185 continue;
4186 }
4187
4188 if (i >= length)
4189 {
0e389e77 4190 as_warn (_("floating point constant too large"));
252b5132
RH		 4191 return -1;
4192 }
4193 d = hex_value (*input_line_pointer) << 4;
4194 ++input_line_pointer;
4195 while (*input_line_pointer == '_')
4196 ++input_line_pointer;
4197 if (hex_p (*input_line_pointer))
4198 {
4199 d += hex_value (*input_line_pointer);
4200 ++input_line_pointer;
4201 }
4202 if (target_big_endian)
4203 bytes[i] = d;
4204 else
4205 bytes[length - i - 1] = d;
4206 ++i;
4207 }
4208
4209 if (i < length)
4210 {
4211 if (target_big_endian)
4212 memset (bytes + i, 0, length - i);
4213 else
4214 memset (bytes, 0, length - i);
4215 }
4216
4217 return length;
4218}
4219
d6415f6c 4220/* float_cons()
f0e652b4 4221
041ff4dd
NC		 4222 CONStruct some more frag chars of .floats .ffloats etc.
4223 Makes 0 or more new frags.
4224 If need_pass_2 == 1, no frags are emitted.
4225 This understands only floating literals, not expressions. Sorry.
f0e652b4 4226
041ff4dd
NC		 4227 A floating constant is defined by atof_generic(), except it is preceded
4228 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4229 reading, I decided to be incompatible. This always tries to give you
4230 rounded bits to the precision of the pseudo-op. Former AS did premature
47eebc20 4231 truncation, restored noisy bits instead of trailing 0s AND gave you
041ff4dd
NC		 4232 a choice of 2 flavours of noise according to which of 2 floating-point
4233 scanners you directed AS to use.
f0e652b4 4234
041ff4dd 4235 In: input_line_pointer->whitespace before, or '0' of flonum. */
252b5132
RH		 4236
4237void
39e6acbd
KH		 4238float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4239 register int float_type /* 'f':.ffloat ... 'F':.float ... */)
252b5132
RH		 4240{
4241 register char *p;
041ff4dd
NC		 4242 int length; /* Number of chars in an object. */
4243 register char *err; /* Error from scanning floating literal. */
252b5132
RH		 4244 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4245
4246 if (is_it_end_of_statement ())
4247 {
4248 demand_empty_rest_of_line ();
4249 return;
4250 }
4251
4252#ifdef md_flush_pending_output
4253 md_flush_pending_output ();
4254#endif
4255
4256 do
4257 {
041ff4dd 4258 /* input_line_pointer->1st char of a flonum (we hope!). */
252b5132
RH		 4259 SKIP_WHITESPACE ();
4260
4261 /* Skip any 0{letter} that may be present. Don't even check if the
d6415f6c
AM		 4262 letter is legal. Someone may invent a "z" format and this routine
4263 has no use for such information. Lusers beware: you get
4264 diagnostics if your input is ill-conditioned. */
252b5132 4265 if (input_line_pointer[0] == '0'
3882b010 4266 && ISALPHA (input_line_pointer[1]))
252b5132
RH		 4267 input_line_pointer += 2;
4268
4269 /* Accept :xxxx, where the x's are hex digits, for a floating
d6415f6c 4270 point with the exact digits specified. */
252b5132
RH		 4271 if (input_line_pointer[0] == ':')
4272 {
4273 ++input_line_pointer;
4274 length = hex_float (float_type, temp);
4275 if (length < 0)
4276 {
4277 ignore_rest_of_line ();
4278 return;
4279 }
4280 }
4281 else
4282 {
4283 err = md_atof (float_type, temp, &length);
4284 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4285 know (length > 0);
4286 if (err)
4287 {
0e389e77 4288 as_bad (_("bad floating literal: %s"), err);
252b5132
RH		 4289 ignore_rest_of_line ();
4290 return;
4291 }
4292 }
4293
4294 if (!need_pass_2)
4295 {
4296 int count;
4297
4298 count = 1;
4299
4300#ifdef REPEAT_CONS_EXPRESSIONS
4301 if (*input_line_pointer == ':')
4302 {
4303 expressionS count_exp;
4304
4305 ++input_line_pointer;
4306 expression (&count_exp);
f0e652b4 4307
252b5132
RH		 4308 if (count_exp.X_op != O_constant
4309 || count_exp.X_add_number <= 0)
041ff4dd 4310 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4311 else
4312 count = count_exp.X_add_number;
4313 }
4314#endif
4315
4316 while (--count >= 0)
4317 {
4318 p = frag_more (length);
4319 memcpy (p, temp, (unsigned int) length);
4320 }
4321 }
4322 SKIP_WHITESPACE ();
4323 }
4324 while (*input_line_pointer++ == ',');
4325
041ff4dd
NC		 4326 /* Put terminator back into stream. */
4327 --input_line_pointer;
252b5132 4328 demand_empty_rest_of_line ();
041ff4dd 4329}
252b5132 4330\f
041ff4dd 4331/* Return the size of a LEB128 value. */
252b5132
RH		 4332
4333static inline int
39e6acbd 4334sizeof_sleb128 (offsetT value)
252b5132
RH		 4335{
4336 register int size = 0;
4337 register unsigned byte;
4338
4339 do
4340 {
4341 byte = (value & 0x7f);
4342 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4343 Fortunately, we can structure things so that the extra work reduces
4344 to a noop on systems that do things "properly". */
4345 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4346 size += 1;
4347 }
4348 while (!(((value == 0) && ((byte & 0x40) == 0))
4349 || ((value == -1) && ((byte & 0x40) != 0))));
4350
4351 return size;
4352}
4353
4354static inline int
39e6acbd 4355sizeof_uleb128 (valueT value)
252b5132
RH		 4356{
4357 register int size = 0;
4358 register unsigned byte;
4359
4360 do
4361 {
4362 byte = (value & 0x7f);
4363 value >>= 7;
4364 size += 1;
4365 }
4366 while (value != 0);
4367
4368 return size;
4369}
4370
4371int
39e6acbd 4372sizeof_leb128 (valueT value, int sign)
252b5132
RH		 4373{
4374 if (sign)
4375 return sizeof_sleb128 ((offsetT) value);
4376 else
4377 return sizeof_uleb128 (value);
4378}
4379
4380/* Output a LEB128 value. */
4381
4382static inline int
39e6acbd 4383output_sleb128 (char *p, offsetT value)
252b5132
RH		 4384{
4385 register char *orig = p;
4386 register int more;
4387
4388 do
4389 {
4390 unsigned byte = (value & 0x7f);
4391
4392 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4393 Fortunately, we can structure things so that the extra work reduces
4394 to a noop on systems that do things "properly". */
4395 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4396
4397 more = !((((value == 0) && ((byte & 0x40) == 0))
4398 || ((value == -1) && ((byte & 0x40) != 0))));
4399 if (more)
4400 byte |= 0x80;
4401
4402 *p++ = byte;
4403 }
4404 while (more);
4405
4406 return p - orig;
4407}
4408
4409static inline int
39e6acbd 4410output_uleb128 (char *p, valueT value)
252b5132
RH		 4411{
4412 char *orig = p;
4413
4414 do
4415 {
4416 unsigned byte = (value & 0x7f);
4417 value >>= 7;
4418 if (value != 0)
4419 /* More bytes to follow. */
4420 byte |= 0x80;
4421
4422 *p++ = byte;
4423 }
4424 while (value != 0);
4425
4426 return p - orig;
4427}
4428
4429int
39e6acbd 4430output_leb128 (char *p, valueT value, int sign)
252b5132
RH		 4431{
4432 if (sign)
4433 return output_sleb128 (p, (offsetT) value);
4434 else
4435 return output_uleb128 (p, value);
4436}
4437
4438/* Do the same for bignums. We combine sizeof with output here in that
4439 we don't output for NULL values of P. It isn't really as critical as
4440 for "normal" values that this be streamlined. */
4441
6d4d30bb 4442static inline int
39e6acbd 4443output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
252b5132
RH		 4444{
4445 char *orig = p;
4446 valueT val = 0;
4447 int loaded = 0;
4448 unsigned byte;
4449
4450 /* Strip leading sign extensions off the bignum. */
e5604d79
RS		 4451 while (size > 1
4452 && bignum[size - 1] == LITTLENUM_MASK
4453 && bignum[size - 2] > LITTLENUM_MASK / 2)
252b5132
RH		 4454 size--;
4455
4456 do
4457 {
e5604d79
RS		 4458 /* OR in the next part of the littlenum. */
4459 val |= (*bignum << loaded);
4460 loaded += LITTLENUM_NUMBER_OF_BITS;
4461 size--;
4462 bignum++;
4463
4464 /* Add bytes until there are less than 7 bits left in VAL
4465 or until every non-sign bit has been written. */
4466 do
252b5132 4467 {
e5604d79
RS		 4468 byte = val & 0x7f;
4469 loaded -= 7;
4470 val >>= 7;
4471 if (size > 0
4472 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
252b5132 4473 byte |= 0x80;
e5604d79
RS		 4474
4475 if (orig)
4476 *p = byte;
4477 p++;
252b5132 4478 }
e5604d79
RS		 4479 while ((byte & 0x80) != 0 && loaded >= 7);
4480 }
4481 while (size > 0);
252b5132 4482
e5604d79
RS		 4483 /* Mop up any left-over bits (of which there will be less than 7). */
4484 if ((byte & 0x80) != 0)
4485 {
4486 /* Sign-extend VAL. */
4487 if (val & (1 << (loaded - 1)))
4488 val |= ~0 << loaded;
252b5132 4489 if (orig)
e5604d79 4490 *p = val & 0x7f;
252b5132
RH		 4491 p++;
4492 }
252b5132
RH		 4493
4494 return p - orig;
4495}
4496
6d4d30bb 4497static inline int
39e6acbd 4498output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
252b5132
RH		 4499{
4500 char *orig = p;
4501 valueT val = 0;
4502 int loaded = 0;
4503 unsigned byte;
4504
4505 /* Strip leading zeros off the bignum. */
4506 /* XXX: Is this needed? */
041ff4dd 4507 while (size > 0 && bignum[size - 1] == 0)
252b5132
RH		 4508 size--;
4509
4510 do
4511 {
4512 if (loaded < 7 && size > 0)
4513 {
4514 val |= (*bignum << loaded);
4515 loaded += 8 * CHARS_PER_LITTLENUM;
4516 size--;
4517 bignum++;
4518 }
4519
4520 byte = val & 0x7f;
4521 loaded -= 7;
4522 val >>= 7;
4523
4524 if (size > 0 || val)
4525 byte |= 0x80;
4526
4527 if (orig)
4528 *p = byte;
4529 p++;
4530 }
4531 while (byte & 0x80);
4532
4533 return p - orig;
4534}
4535
6d4d30bb 4536static int
39e6acbd 4537output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
252b5132
RH		 4538{
4539 if (sign)
4540 return output_big_sleb128 (p, bignum, size);
4541 else
4542 return output_big_uleb128 (p, bignum, size);
4543}
4544
4545/* Generate the appropriate fragments for a given expression to emit a
4546 leb128 value. */
4547
87c245cc 4548static void
39e6acbd 4549emit_leb128_expr (expressionS *exp, int sign)
252b5132
RH		 4550{
4551 operatorT op = exp->X_op;
b7712f8d 4552 unsigned int nbytes;
252b5132
RH		 4553
4554 if (op == O_absent || op == O_illegal)
4555 {
4556 as_warn (_("zero assumed for missing expression"));
4557 exp->X_add_number = 0;
4558 op = O_constant;
4559 }
4560 else if (op == O_big && exp->X_add_number <= 0)
4561 {
0e389e77 4562 as_bad (_("floating point number invalid"));
252b5132
RH		 4563 exp->X_add_number = 0;
4564 op = O_constant;
4565 }
4566 else if (op == O_register)
4567 {
4568 as_warn (_("register value used as expression"));
4569 op = O_constant;
4570 }
e5604d79
RS		 4571 else if (op == O_constant
4572 && sign
4573 && (exp->X_add_number < 0) != !exp->X_unsigned)
4574 {
4575 /* We're outputting a signed leb128 and the sign of X_add_number
4576 doesn't reflect the sign of the original value. Convert EXP
4577 to a correctly-extended bignum instead. */
4578 convert_to_bignum (exp);
4579 op = O_big;
4580 }
252b5132 4581
67a659f6
RH		 4582 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4583 a signal that this is leb128 data. It shouldn't optimize this away. */
b7712f8d 4584 nbytes = (unsigned int) -1;
67a659f6
RH		 4585 if (check_eh_frame (exp, &nbytes))
4586 abort ();
4587
371b7465
RH		 4588 /* Let the backend know that subsequent data may be byte aligned. */
4589#ifdef md_cons_align
4590 md_cons_align (1);
4591#endif
4592
252b5132
RH		 4593 if (op == O_constant)
4594 {
4595 /* If we've got a constant, emit the thing directly right now. */
4596
4597 valueT value = exp->X_add_number;
4598 int size;
4599 char *p;
4600
4601 size = sizeof_leb128 (value, sign);
4602 p = frag_more (size);
4603 output_leb128 (p, value, sign);
4604 }
4605 else if (op == O_big)
4606 {
4607 /* O_big is a different sort of constant. */
4608
4609 int size;
4610 char *p;
4611
4612 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4613 p = frag_more (size);
4614 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4615 }
4616 else
4617 {
041ff4dd 4618 /* Otherwise, we have to create a variable sized fragment and
252b5132
RH		 4619 resolve things later. */
4620
041ff4dd 4621 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
252b5132
RH		 4622 make_expr_symbol (exp), 0, (char *) NULL);
4623 }
4624}
4625
4626/* Parse the .sleb128 and .uleb128 pseudos. */
4627
4628void
39e6acbd 4629s_leb128 (int sign)
252b5132
RH		 4630{
4631 expressionS exp;
4632
00bbdfe7
BW		 4633#ifdef md_flush_pending_output
4634 md_flush_pending_output ();
4635#endif
4636
041ff4dd
NC		 4637 do
4638 {
4639 expression (&exp);
4640 emit_leb128_expr (&exp, sign);
4641 }
4642 while (*input_line_pointer++ == ',');
252b5132
RH		 4643
4644 input_line_pointer--;
4645 demand_empty_rest_of_line ();
4646}
4647\f
041ff4dd
NC		 4648/* We read 0 or more ',' separated, double-quoted strings.
4649 Caller should have checked need_pass_2 is FALSE because we don't
4650 check it. */
4651
4652void
39e6acbd
KH		 4653stringer (/* Worker to do .ascii etc statements. */
4654 /* Checks end-of-line. */
4655 register int append_zero /* 0: don't append '\0', else 1. */)
252b5132
RH		 4656{
4657 register unsigned int c;
4658 char *start;
4659
4660#ifdef md_flush_pending_output
4661 md_flush_pending_output ();
4662#endif
4663
041ff4dd
NC		 4664 /* The following awkward logic is to parse ZERO or more strings,
4665 comma separated. Recall a string expression includes spaces
4666 before the opening '\"' and spaces after the closing '\"'.
4667 We fake a leading ',' if there is (supposed to be)
4668 a 1st, expression. We keep demanding expressions for each ','. */
252b5132
RH		 4669 if (is_it_end_of_statement ())
4670 {
041ff4dd
NC		 4671 c = 0; /* Skip loop. */
4672 ++input_line_pointer; /* Compensate for end of loop. */
252b5132
RH		 4673 }
4674 else
4675 {
041ff4dd 4676 c = ','; /* Do loop. */
252b5132 4677 }
8ac9ba6c
NC		 4678 /* If we have been switched into the abs_section then we
4679 will not have an obstack onto which we can hang strings. */
4680 if (now_seg == absolute_section)
4681 {
4682 as_bad (_("strings must be placed into a section"));
4683 c = 0;
4684 ignore_rest_of_line ();
4685 }
d6415f6c 4686
252b5132
RH		 4687 while (c == ',' || c == '<' || c == '"')
4688 {
4689 SKIP_WHITESPACE ();
4690 switch (*input_line_pointer)
4691 {
4692 case '\"':
041ff4dd 4693 ++input_line_pointer; /*->1st char of string. */
252b5132
RH		 4694 start = input_line_pointer;
4695 while (is_a_char (c = next_char_of_string ()))
4696 {
4697 FRAG_APPEND_1_CHAR (c);
4698 }
4699 if (append_zero)
4700 {
4701 FRAG_APPEND_1_CHAR (0);
4702 }
4703 know (input_line_pointer[-1] == '\"');
4704
4705#ifndef NO_LISTING
4706#ifdef OBJ_ELF
4707 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
d6415f6c
AM		 4708 will emit .string with a filename in the .debug section
4709 after a sequence of constants. See the comment in
4710 emit_expr for the sequence. emit_expr will set
4711 dwarf_file_string to non-zero if this string might be a
4712 source file name. */
252b5132
RH		 4713 if (strcmp (segment_name (now_seg), ".debug") != 0)
4714 dwarf_file_string = 0;
4715 else if (dwarf_file_string)
4716 {
4717 c = input_line_pointer[-1];
4718 input_line_pointer[-1] = '\0';
4719 listing_source_file (start);
4720 input_line_pointer[-1] = c;
4721 }
4722#endif
4723#endif
4724
4725 break;
4726 case '<':
4727 input_line_pointer++;
4728 c = get_single_number ();
4729 FRAG_APPEND_1_CHAR (c);
4730 if (*input_line_pointer != '>')
4731 {
0e389e77 4732 as_bad (_("expected <nn>"));
252b5132
RH		 4733 }
4734 input_line_pointer++;
4735 break;
4736 case ',':
4737 input_line_pointer++;
4738 break;
4739 }
4740 SKIP_WHITESPACE ();
4741 c = *input_line_pointer;
4742 }
4743
4744 demand_empty_rest_of_line ();
4745} /* stringer() */
4746\f
4747/* FIXME-SOMEDAY: I had trouble here on characters with the
4748 high bits set. We'll probably also have trouble with
4749 multibyte chars, wide chars, etc. Also be careful about
041ff4dd 4750 returning values bigger than 1 byte. xoxorich. */
252b5132 4751
041ff4dd 4752unsigned int
39e6acbd 4753next_char_of_string (void)
252b5132
RH		 4754{
4755 register unsigned int c;
4756
4757 c = *input_line_pointer++ & CHAR_MASK;
4758 switch (c)
4759 {
4760 case '\"':
4761 c = NOT_A_CHAR;
4762 break;
4763
4764 case '\n':
0e389e77 4765 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 4766 bump_line_counters ();
4767 break;
4768
4769#ifndef NO_STRING_ESCAPES
4770 case '\\':
4771 switch (c = *input_line_pointer++)
4772 {
4773 case 'b':
4774 c = '\b';
4775 break;
4776
4777 case 'f':
4778 c = '\f';
4779 break;
4780
4781 case 'n':
4782 c = '\n';
4783 break;
4784
4785 case 'r':
4786 c = '\r';
4787 break;
4788
4789 case 't':
4790 c = '\t';
4791 break;
4792
4793 case 'v':
4794 c = '\013';
4795 break;
4796
4797 case '\\':
4798 case '"':
041ff4dd 4799 break; /* As itself. */
252b5132
RH		 4800
4801 case '0':
4802 case '1':
4803 case '2':
4804 case '3':
4805 case '4':
4806 case '5':
4807 case '6':
4808 case '7':
4809 case '8':
4810 case '9':
4811 {
4812 long number;
4813 int i;
4814
041ff4dd 4815 for (i = 0, number = 0;
3882b010 4816 ISDIGIT (c) && i < 3;
041ff4dd 4817 c = *input_line_pointer++, i++)
252b5132
RH		 4818 {
4819 number = number * 8 + c - '0';
4820 }
f0e652b4 4821
252b5132
RH		 4822 c = number & 0xff;
4823 }
4824 --input_line_pointer;
4825 break;
4826
4827 case 'x':
4828 case 'X':
4829 {
4830 long number;
4831
4832 number = 0;
4833 c = *input_line_pointer++;
3882b010 4834 while (ISXDIGIT (c))
252b5132 4835 {
3882b010 4836 if (ISDIGIT (c))
252b5132 4837 number = number * 16 + c - '0';
3882b010 4838 else if (ISUPPER (c))
252b5132
RH		 4839 number = number * 16 + c - 'A' + 10;
4840 else
4841 number = number * 16 + c - 'a' + 10;
4842 c = *input_line_pointer++;
4843 }
4844 c = number & 0xff;
4845 --input_line_pointer;
4846 }
4847 break;
4848
4849 case '\n':
041ff4dd 4850 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
0e389e77 4851 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 4852 c = '\n';
4853 bump_line_counters ();
4854 break;
4855
4856 default:
4857
4858#ifdef ONLY_STANDARD_ESCAPES
0e389e77 4859 as_bad (_("bad escaped character in string"));
252b5132
RH		 4860 c = '?';
4861#endif /* ONLY_STANDARD_ESCAPES */
4862
4863 break;
041ff4dd 4864 }
252b5132
RH		 4865 break;
4866#endif /* ! defined (NO_STRING_ESCAPES) */
4867
4868 default:
4869 break;
041ff4dd 4870 }
252b5132 4871 return (c);
041ff4dd 4872}
252b5132
RH		 4873\f
4874static segT
39e6acbd 4875get_segmented_expression (register expressionS *expP)
252b5132
RH		 4876{
4877 register segT retval;
4878
4879 retval = expression (expP);
4880 if (expP->X_op == O_illegal
4881 || expP->X_op == O_absent
4882 || expP->X_op == O_big)
4883 {
0e389e77 4884 as_bad (_("expected address expression"));
252b5132
RH		 4885 expP->X_op = O_constant;
4886 expP->X_add_number = 0;
4887 retval = absolute_section;
4888 }
4889 return retval;
4890}
4891
041ff4dd 4892static segT
39e6acbd 4893get_known_segmented_expression (register expressionS *expP)
252b5132
RH		 4894{
4895 register segT retval;
4896
4897 if ((retval = get_segmented_expression (expP)) == undefined_section)
4898 {
4899 /* There is no easy way to extract the undefined symbol from the
4900 expression. */
4901 if (expP->X_add_symbol != NULL
4902 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4903 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4904 S_GET_NAME (expP->X_add_symbol));
4905 else
4906 as_warn (_("some symbol undefined; zero assumed"));
4907 retval = absolute_section;
4908 expP->X_op = O_constant;
4909 expP->X_add_number = 0;
4910 }
4911 know (retval == absolute_section || SEG_NORMAL (retval));
4912 return (retval);
041ff4dd 4913}
252b5132 4914
041ff4dd 4915char /* Return terminator. */
39e6acbd 4916get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
252b5132
RH		 4917{
4918 /* FIXME: val_pointer should probably be offsetT *. */
4919 *val_pointer = (long) get_absolute_expression ();
4920 return (*input_line_pointer++);
4921}
4922\f
041ff4dd
NC		 4923/* Like demand_copy_string, but return NULL if the string contains any '\0's.
4924 Give a warning if that happens. */
4925
252b5132 4926char *
39e6acbd 4927demand_copy_C_string (int *len_pointer)
252b5132
RH		 4928{
4929 register char *s;
4930
4931 if ((s = demand_copy_string (len_pointer)) != 0)
4932 {
4933 register int len;
4934
4935 for (len = *len_pointer; len > 0; len--)
4936 {
4937 if (*s == 0)
4938 {
4939 s = 0;
4940 len = 1;
4941 *len_pointer = 0;
0e389e77 4942 as_bad (_("this string may not contain \'\\0\'"));
252b5132
RH		 4943 }
4944 }
4945 }
f0e652b4 4946
252b5132
RH		 4947 return s;
4948}
4949\f
041ff4dd
NC		 4950/* Demand string, but return a safe (=private) copy of the string.
4951 Return NULL if we can't read a string here. */
4952
252b5132 4953char *
39e6acbd 4954demand_copy_string (int *lenP)
252b5132
RH		 4955{
4956 register unsigned int c;
4957 register int len;
4958 char *retval;
4959
4960 len = 0;
4961 SKIP_WHITESPACE ();
4962 if (*input_line_pointer == '\"')
4963 {
041ff4dd 4964 input_line_pointer++; /* Skip opening quote. */
252b5132
RH		 4965
4966 while (is_a_char (c = next_char_of_string ()))
4967 {
4968 obstack_1grow (&notes, c);
4969 len++;
4970 }
4971 /* JF this next line is so demand_copy_C_string will return a
041ff4dd 4972 null terminated string. */
252b5132
RH		 4973 obstack_1grow (&notes, '\0');
4974 retval = obstack_finish (&notes);
4975 }
4976 else
4977 {
c95b35a9 4978 as_bad (_("missing string"));
252b5132
RH		 4979 retval = NULL;
4980 ignore_rest_of_line ();
4981 }
4982 *lenP = len;
4983 return (retval);
041ff4dd 4984}
252b5132 4985\f
041ff4dd 4986/* In: Input_line_pointer->next character.
f0e652b4 4987
041ff4dd 4988 Do: Skip input_line_pointer over all whitespace.
f0e652b4 4989
041ff4dd
NC		 4990 Out: 1 if input_line_pointer->end-of-line. */
4991
4992int
39e6acbd 4993is_it_end_of_statement (void)
252b5132
RH		 4994{
4995 SKIP_WHITESPACE ();
4996 return (is_end_of_line[(unsigned char) *input_line_pointer]);
041ff4dd 4997}
252b5132 4998
041ff4dd 4999void
39e6acbd 5000equals (char *sym_name, int reassign)
252b5132 5001{
252b5132
RH		 5002 char *stop = NULL;
5003 char stopc;
5004
5005 input_line_pointer++;
5006 if (*input_line_pointer == '=')
5007 input_line_pointer++;
9497f5ac
NC		 5008 if (reassign < 0 && *input_line_pointer == '=')
5009 input_line_pointer++;
252b5132
RH		 5010
5011 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5012 input_line_pointer++;
5013
5014 if (flag_mri)
5015 stop = mri_comment_field (&stopc);
5016
9497f5ac 5017 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
252b5132
RH		 5018
5019 if (flag_mri)
31d20a21
AM		 5020 {
5021 demand_empty_rest_of_line ();
5022 mri_comment_end (stop, stopc);
5023 }
041ff4dd 5024}
252b5132 5025
7e005732
NC		 5026/* .incbin -- include a file verbatim at the current location. */
5027
5028void
39e6acbd 5029s_incbin (int x ATTRIBUTE_UNUSED)
7e005732
NC		 5030{
5031 FILE * binfile;
5032 char * path;
5033 char * filename;
5034 char * binfrag;
5035 long skip = 0;
5036 long count = 0;
5037 long bytes;
5038 int len;
5039
5040#ifdef md_flush_pending_output
5041 md_flush_pending_output ();
5042#endif
5043
5044 SKIP_WHITESPACE ();
5045 filename = demand_copy_string (& len);
5046 if (filename == NULL)
5047 return;
5048
5049 SKIP_WHITESPACE ();
5050
5051 /* Look for optional skip and count. */
5052 if (* input_line_pointer == ',')
5053 {
5054 ++ input_line_pointer;
5055 skip = get_absolute_expression ();
5056
5057 SKIP_WHITESPACE ();
5058
5059 if (* input_line_pointer == ',')
5060 {
5061 ++ input_line_pointer;
5062
5063 count = get_absolute_expression ();
5064 if (count == 0)
5065 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5066
5067 SKIP_WHITESPACE ();
5068 }
5069 }
5070
5071 demand_empty_rest_of_line ();
5072
5073 /* Try opening absolute path first, then try include dirs. */
f740e790 5074 binfile = fopen (filename, FOPEN_RB);
7e005732
NC		 5075 if (binfile == NULL)
5076 {
5077 int i;
5078
5079 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5080
5081 for (i = 0; i < include_dir_count; i++)
5082 {
5083 sprintf (path, "%s/%s", include_dirs[i], filename);
5084
f740e790 5085 binfile = fopen (path, FOPEN_RB);
7e005732
NC		 5086 if (binfile != NULL)
5087 break;
5088 }
5089
5090 if (binfile == NULL)
5091 as_bad (_("file not found: %s"), filename);
5092 }
5093 else
5094 path = xstrdup (filename);
5095
5096 if (binfile)
5097 {
f740e790
NC		 5098 long file_len;
5099
7e005732
NC		 5100 register_dependency (path);
5101
5102 /* Compute the length of the file. */
5103 if (fseek (binfile, 0, SEEK_END) != 0)
5104 {
5105 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5106 goto done;
5107 }
f740e790 5108 file_len = ftell (binfile);
7e005732 5109
c556cc9c 5110 /* If a count was not specified use the remainder of the file. */
7e005732 5111 if (count == 0)
c556cc9c 5112 count = file_len - skip;
7e005732 5113
c556cc9c 5114 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
7e005732 5115 {
c556cc9c 5116 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
f740e790 5117 skip, count, file_len);
7e005732
NC		 5118 goto done;
5119 }
5120
5121 if (fseek (binfile, skip, SEEK_SET) != 0)
5122 {
5123 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5124 goto done;
5125 }
5126
5127 /* Allocate frag space and store file contents in it. */
5128 binfrag = frag_more (count);
5129
5130 bytes = fread (binfrag, 1, count, binfile);
5131 if (bytes < count)
5132 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5133 path, bytes, count);
5134 }
5135done:
5136 if (binfile != NULL)
5137 fclose (binfile);
5138 if (path)
5139 free (path);
5140}
5141
041ff4dd 5142/* .include -- include a file at this point. */
252b5132 5143
041ff4dd 5144void
39e6acbd 5145s_include (int arg ATTRIBUTE_UNUSED)
252b5132 5146{
252b5132
RH		 5147 char *filename;
5148 int i;
5149 FILE *try;
5150 char *path;
5151
041ff4dd 5152 if (!flag_m68k_mri)
252b5132
RH		 5153 {
5154 filename = demand_copy_string (&i);
5155 if (filename == NULL)
5156 {
5157 /* demand_copy_string has already printed an error and
d6415f6c 5158 called ignore_rest_of_line. */
252b5132
RH		 5159 return;
5160 }
5161 }
5162 else
5163 {
5164 SKIP_WHITESPACE ();
5165 i = 0;
041ff4dd 5166 while (!is_end_of_line[(unsigned char) *input_line_pointer]
252b5132
RH		 5167 && *input_line_pointer != ' '
5168 && *input_line_pointer != '\t')
5169 {
5170 obstack_1grow (&notes, *input_line_pointer);
5171 ++input_line_pointer;
5172 ++i;
5173 }
f0e652b4 5174
252b5132
RH		 5175 obstack_1grow (&notes, '\0');
5176 filename = obstack_finish (&notes);
041ff4dd 5177 while (!is_end_of_line[(unsigned char) *input_line_pointer])
252b5132
RH		 5178 ++input_line_pointer;
5179 }
f0e652b4 5180
252b5132
RH		 5181 demand_empty_rest_of_line ();
5182 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
f0e652b4 5183
252b5132
RH		 5184 for (i = 0; i < include_dir_count; i++)
5185 {
5186 strcpy (path, include_dirs[i]);
5187 strcat (path, "/");
5188 strcat (path, filename);
f740e790 5189 if (0 != (try = fopen (path, FOPEN_RT)))
252b5132
RH		 5190 {
5191 fclose (try);
5192 goto gotit;
5193 }
5194 }
f0e652b4 5195
252b5132
RH		 5196 free (path);
5197 path = filename;
5198gotit:
041ff4dd 5199 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
252b5132 5200 register_dependency (path);
9f10757c 5201 input_scrub_insert_file (path);
041ff4dd 5202}
252b5132 5203
041ff4dd 5204void
39e6acbd 5205add_include_dir (char *path)
252b5132
RH		 5206{
5207 int i;
5208
5209 if (include_dir_count == 0)
5210 {
5211 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
041ff4dd 5212 include_dirs[0] = "."; /* Current dir. */
252b5132
RH		 5213 include_dir_count = 2;
5214 }
5215 else
5216 {
5217 include_dir_count++;
041ff4dd
NC		 5218 include_dirs =
5219 (char **) realloc (include_dirs,
5220 include_dir_count * sizeof (*include_dirs));
252b5132
RH		 5221 }
5222
041ff4dd 5223 include_dirs[include_dir_count - 1] = path; /* New one. */
252b5132
RH		 5224
5225 i = strlen (path);
5226 if (i > include_dir_maxlen)
5227 include_dir_maxlen = i;
041ff4dd 5228}
252b5132
RH		 5229\f
5230/* Output debugging information to denote the source file. */
5231
5232static void
39e6acbd 5233generate_file_debug (void)
252b5132
RH		 5234{
5235 if (debug_type == DEBUG_STABS)
5236 stabs_generate_asm_file ();
5237}
5238
5239/* Output line number debugging information for the current source line. */
5240
5241void
39e6acbd 5242generate_lineno_debug (void)
252b5132 5243{
252b5132
RH		 5244 switch (debug_type)
5245 {
5246 case DEBUG_UNSPECIFIED:
5247 case DEBUG_NONE:
4dc7ead9 5248 case DEBUG_DWARF:
252b5132
RH		 5249 break;
5250 case DEBUG_STABS:
5251 stabs_generate_asm_lineno ();
5252 break;
5253 case DEBUG_ECOFF:
5254 ecoff_generate_asm_lineno ();
5255 break;
252b5132 5256 case DEBUG_DWARF2:
4dc7ead9
RH		 5257 /* ??? We could here indicate to dwarf2dbg.c that something
5258 has changed. However, since there is additional backend
5259 support that is required (calling dwarf2_emit_insn), we
5260 let dwarf2dbg.c call as_where on its own. */
252b5132
RH		 5261 break;
5262 }
5263}
5264
5265/* Output debugging information to mark a function entry point or end point.
5266 END_P is zero for .func, and non-zero for .endfunc. */
5267
5268void
39e6acbd 5269s_func (int end_p)
252b5132
RH		 5270{
5271 do_s_func (end_p, NULL);
5272}
5273
5274/* Subroutine of s_func so targets can choose a different default prefix.
5275 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5276
87c245cc 5277static void
39e6acbd 5278do_s_func (int end_p, const char *default_prefix)
252b5132
RH		 5279{
5280 /* Record the current function so that we can issue an error message for
5281 misplaced .func,.endfunc, and also so that .endfunc needs no
5282 arguments. */
5283 static char *current_name;
5284 static char *current_label;
5285
5286 if (end_p)
5287 {
5288 if (current_name == NULL)
5289 {
5290 as_bad (_("missing .func"));
5291 ignore_rest_of_line ();
5292 return;
5293 }
5294
5295 if (debug_type == DEBUG_STABS)
5296 stabs_generate_asm_endfunc (current_name, current_label);
5297
5298 current_name = current_label = NULL;
5299 }
5300 else /* ! end_p */
5301 {
041ff4dd
NC		 5302 char *name, *label;
5303 char delim1, delim2;
252b5132
RH		 5304
5305 if (current_name != NULL)
5306 {
5307 as_bad (_(".endfunc missing for previous .func"));
5308 ignore_rest_of_line ();
5309 return;
5310 }
5311
5312 name = input_line_pointer;
5313 delim1 = get_symbol_end ();
5314 name = xstrdup (name);
5315 *input_line_pointer = delim1;
5316 SKIP_WHITESPACE ();
5317 if (*input_line_pointer != ',')
5318 {
5319 if (default_prefix)
5320 asprintf (&label, "%s%s", default_prefix, name);
5321 else
5322 {
7be1c489 5323 char leading_char = bfd_get_symbol_leading_char (stdoutput);
252b5132
RH		 5324 /* Missing entry point, use function's name with the leading
5325 char prepended. */
5326 if (leading_char)
5327 asprintf (&label, "%c%s", leading_char, name);
5328 else
5329 label = name;
5330 }
5331 }
5332 else
5333 {
5334 ++input_line_pointer;
5335 SKIP_WHITESPACE ();
5336 label = input_line_pointer;
5337 delim2 = get_symbol_end ();
5338 label = xstrdup (label);
5339 *input_line_pointer = delim2;
5340 }
5341
5342 if (debug_type == DEBUG_STABS)
5343 stabs_generate_asm_func (name, label);
5344
5345 current_name = name;
5346 current_label = label;
5347 }
5348
5349 demand_empty_rest_of_line ();
5350}
5351\f
041ff4dd 5352void
39e6acbd 5353s_ignore (int arg ATTRIBUTE_UNUSED)
252b5132 5354{
40a4d956 5355 ignore_rest_of_line ();
252b5132
RH		 5356}
5357
252b5132 5358void
39e6acbd 5359read_print_statistics (FILE *file)
252b5132
RH		 5360{
5361 hash_print_statistics (file, "pseudo-op table", po_hash);
5362}
5363
041ff4dd
NC		 5364/* Inserts the given line into the input stream.
5365
9f10757c
TW		 5366 This call avoids macro/conditionals nesting checking, since the contents of
5367 the line are assumed to replace the contents of a line already scanned.
5368
47eebc20 5369 An appropriate use of this function would be substitution of input lines when
9f10757c
TW		 5370 called by md_start_line_hook(). The given line is assumed to already be
5371 properly scrubbed. */
5372
5373void
39e6acbd 5374input_scrub_insert_line (const char *line)
9f10757c
TW		 5375{
5376 sb newline;
5377 sb_new (&newline);
5378 sb_add_string (&newline, line);
5379 input_scrub_include_sb (&newline, input_line_pointer, 0);
5380 sb_kill (&newline);
5381 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5382}
5383
5384/* Insert a file into the input stream; the path must resolve to an actual
041ff4dd 5385 file; no include path searching or dependency registering is performed. */
9f10757c
TW		 5386
5387void
39e6acbd 5388input_scrub_insert_file (char *path)
9f10757c
TW		 5389{
5390 input_scrub_include_file (path, input_line_pointer);
5391 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5392}
40a4d956
JB		 5393
5394/* Find the end of a line, considering quotation and escaping of quotes. */
5395
5396#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5397# define TC_SINGLE_QUOTE_STRINGS 1
5398#endif
5399
5400static char *
5401_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
5402{
5403 char inquote = '\0';
5404 int inescape = 0;
5405
5406 while (!is_end_of_line[(unsigned char) *s]
5407 || (inquote && !ISCNTRL (*s))
5408 || (inquote == '\'' && flag_mri)
5409#ifdef TC_EOL_IN_INSN
5410 || (insn && TC_EOL_IN_INSN (s))
5411#endif
5412 )
5413 {
5414 if (mri_string && *s == '\'')
5415 inquote ^= *s;
5416 else if (inescape)
5417 inescape = 0;
5418 else if (*s == '\\')
5419 inescape = 1;
5420 else if (!inquote
5421 ? *s == '"'
5422#ifdef TC_SINGLE_QUOTE_STRINGS
5423 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5424#endif
5425 : *s == inquote)
5426 inquote ^= *s;
5427 ++s;
5428 }
5429 if (inquote)
5430 as_warn (_("missing closing `%c'"), inquote);
5431 if (inescape)
5432 as_warn (_("stray `\\'"));
5433 return s;
5434}
5435
5436char *
5437find_end_of_line (char *s, int mri_string)
5438{
5439 return _find_end_of_line (s, mri_string, 0);
5440}
GDB Binutils - Deliverables
This page took 0.578824 seconds and 4 git commands to generate.