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