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