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