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