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