projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[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),
1bf57e9f 3452 " => ", S_GET_NAME (symbolP2), (const char *) NULL);
06e77878
AO		 3453
3454 symp = symbolP2;
3455 while (symp != symbolP)
3456 {
3457 char *old_loop = loop;
3458 symp = symbol_get_value_expression (symp)->X_add_symbol;
1bf57e9f
AM		 3459 loop = concat (loop, " => ", S_GET_NAME (symp),
3460 (const char *) NULL);
06e77878
AO		 3461 free (old_loop);
3462 }
3463
3464 as_bad (_("%s: would close weakref loop: %s"),
3465 S_GET_NAME (symbolP), loop);
3466
3467 free (loop);
3468
3469 *end_name = delim;
3470 ignore_rest_of_line ();
3471 return;
3472 }
3473
3474 /* Short-circuiting instead of just checking here might speed
3475 things up a tiny little bit, but loop error messages would
3476 miss intermediate links. */
3477 /* symbolP2 = symp; */
3478 }
3479
3480 *end_name = delim;
3481
3482 memset (&exp, 0, sizeof (exp));
3483 exp.X_op = O_symbol;
3484 exp.X_add_symbol = symbolP2;
3485
3486 S_SET_SEGMENT (symbolP, undefined_section);
3487 symbol_set_value_expression (symbolP, &exp);
3488 symbol_set_frag (symbolP, &zero_address_frag);
3489 S_SET_WEAKREFR (symbolP);
3490
3491 demand_empty_rest_of_line ();
3492}
252b5132 3493\f
c95b35a9
NS		 3494
3495/* Verify that we are at the end of a line. If not, issue an error and
3496 skip to EOL. */
3497
041ff4dd 3498void
39e6acbd 3499demand_empty_rest_of_line (void)
252b5132
RH		 3500{
3501 SKIP_WHITESPACE ();
3502 if (is_end_of_line[(unsigned char) *input_line_pointer])
041ff4dd 3503 input_line_pointer++;
252b5132 3504 else
252b5132 3505 {
3882b010 3506 if (ISPRINT (*input_line_pointer))
c95b35a9 3507 as_bad (_("junk at end of line, first unrecognized character is `%c'"),
0e389e77 3508 *input_line_pointer);
252b5132 3509 else
c95b35a9 3510 as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
0e389e77 3511 *input_line_pointer);
c95b35a9 3512 ignore_rest_of_line ();
252b5132 3513 }
c95b35a9
NS		 3514
3515 /* Return pointing just after end-of-line. */
3516 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3517}
3518
3519/* Silently advance to the end of line. Use this after already having
3520 issued an error about something bad. */
3521
3522void
3523ignore_rest_of_line (void)
3524{
3525 while (input_line_pointer < buffer_limit
3526 && !is_end_of_line[(unsigned char) *input_line_pointer])
3527 input_line_pointer++;
f0e652b4 3528
041ff4dd
NC		 3529 input_line_pointer++;
3530
3531 /* Return pointing just after end-of-line. */
252b5132
RH		 3532 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
3533}
3534
be95a9c1
AM		 3535/* Sets frag for given symbol to zero_address_frag, except when the
3536 symbol frag is already set to a dummy listing frag. */
3537
3538static void
3539set_zero_frag (symbolS *symbolP)
3540{
3541 if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
3542 symbol_set_frag (symbolP, &zero_address_frag);
3543}
3544
041ff4dd 3545/* In: Pointer to a symbol.
d6415f6c 3546 Input_line_pointer->expression.
f0e652b4 3547
041ff4dd 3548 Out: Input_line_pointer->just after any whitespace after expression.
d6415f6c
AM		 3549 Tried to set symbol to value of expression.
3550 Will change symbols type, value, and frag; */
041ff4dd 3551
252b5132 3552void
39e6acbd 3553pseudo_set (symbolS *symbolP)
252b5132
RH		 3554{
3555 expressionS exp;
be95a9c1 3556 segT seg;
252b5132 3557
041ff4dd 3558 know (symbolP); /* NULL pointer is logic error. */
252b5132 3559
9497f5ac
NC		 3560 if (!S_IS_FORWARD_REF (symbolP))
3561 (void) expression (&exp);
3562 else
3563 (void) deferred_expression (&exp);
252b5132
RH		 3564
3565 if (exp.X_op == O_illegal)
0e389e77 3566 as_bad (_("illegal expression"));
252b5132 3567 else if (exp.X_op == O_absent)
0e389e77 3568 as_bad (_("missing expression"));
252b5132
RH		 3569 else if (exp.X_op == O_big)
3570 {
3571 if (exp.X_add_number > 0)
0e389e77 3572 as_bad (_("bignum invalid"));
252b5132 3573 else
0e389e77 3574 as_bad (_("floating point number invalid"));
252b5132
RH		 3575 }
3576 else if (exp.X_op == O_subtract
9497f5ac 3577 && !S_IS_FORWARD_REF (symbolP)
252b5132 3578 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
2b47531b
ILT		 3579 && (symbol_get_frag (exp.X_add_symbol)
3580 == symbol_get_frag (exp.X_op_symbol)))
252b5132
RH		 3581 {
3582 exp.X_op = O_constant;
3583 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3584 - S_GET_VALUE (exp.X_op_symbol));
3585 }
3586
be95a9c1
AM		 3587 if (symbol_section_p (symbolP))
3588 {
3589 as_bad ("attempt to set value of section symbol");
3590 return;
3591 }
be95a9c1 3592
252b5132
RH		 3593 switch (exp.X_op)
3594 {
3595 case O_illegal:
3596 case O_absent:
3597 case O_big:
3598 exp.X_add_number = 0;
3599 /* Fall through. */
3600 case O_constant:
3601 S_SET_SEGMENT (symbolP, absolute_section);
252b5132 3602 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
be95a9c1 3603 set_zero_frag (symbolP);
252b5132
RH		 3604 break;
3605
3606 case O_register:
d0548f34
L		 3607 if (S_IS_EXTERNAL (symbolP))
3608 {
3609 as_bad ("can't equate global symbol `%s' with register name",
3610 S_GET_NAME (symbolP));
3611 return;
3612 }
252b5132
RH		 3613 S_SET_SEGMENT (symbolP, reg_section);
3614 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
be95a9c1 3615 set_zero_frag (symbolP);
db557034 3616 symbol_get_value_expression (symbolP)->X_op = O_register;
252b5132
RH		 3617 break;
3618
3619 case O_symbol:
be95a9c1
AM		 3620 seg = S_GET_SEGMENT (exp.X_add_symbol);
3621 /* For x=undef+const, create an expression symbol.
3622 For x=x+const, just update x except when x is an undefined symbol
3623 For x=defined+const, evaluate x. */
3624 if (symbolP == exp.X_add_symbol
3625 && (seg != undefined_section
3626 || !symbol_constant_p (symbolP)))
3627 {
3628 *symbol_X_add_number (symbolP) += exp.X_add_number;
3629 break;
3630 }
9497f5ac 3631 else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
252b5132
RH		 3632 {
3633 symbolS *s = exp.X_add_symbol;
3634
60938e80
L		 3635 if (S_IS_COMMON (s))
3636 as_bad (_("`%s' can't be equated to common symbol '%s'"),
3637 S_GET_NAME (symbolP), S_GET_NAME (s));
3638
be95a9c1
AM		 3639 S_SET_SEGMENT (symbolP, seg);
3640 S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
2b47531b 3641 symbol_set_frag (symbolP, symbol_get_frag (s));
252b5132 3642 copy_symbol_attributes (symbolP, s);
be95a9c1 3643 break;
252b5132 3644 }
66bd02d3
AM		 3645 S_SET_SEGMENT (symbolP, undefined_section);
3646 symbol_set_value_expression (symbolP, &exp);
3647 set_zero_frag (symbolP);
3648 break;
252b5132
RH		 3649
3650 default:
aba4aa7d
AM		 3651 /* The value is some complex expression. */
3652 S_SET_SEGMENT (symbolP, expr_section);
2b47531b 3653 symbol_set_value_expression (symbolP, &exp);
be95a9c1 3654 set_zero_frag (symbolP);
252b5132
RH		 3655 break;
3656 }
3657}
3658\f
d6415f6c 3659/* cons()
f0e652b4 3660
041ff4dd
NC		 3661 CONStruct more frag of .bytes, or .words etc.
3662 Should need_pass_2 be 1 then emit no frag(s).
3663 This understands EXPRESSIONS.
f0e652b4 3664
041ff4dd 3665 Bug (?)
f0e652b4 3666
041ff4dd
NC		 3667 This has a split personality. We use expression() to read the
3668 value. We can detect if the value won't fit in a byte or word.
3669 But we can't detect if expression() discarded significant digits
3670 in the case of a long. Not worth the crocks required to fix it. */
252b5132
RH		 3671
3672/* Select a parser for cons expressions. */
3673
3674/* Some targets need to parse the expression in various fancy ways.
3675 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3676 (for example, the HPPA does this). Otherwise, you can define
3677 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3678 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3679 are defined, which is the normal case, then only simple expressions
3680 are permitted. */
3681
abd63a32 3682#ifdef TC_M68K
252b5132 3683static void
39e6acbd 3684parse_mri_cons (expressionS *exp, unsigned int nbytes);
abd63a32 3685#endif
252b5132
RH		 3686
3687#ifndef TC_PARSE_CONS_EXPRESSION
3688#ifdef BITFIELD_CONS_EXPRESSIONS
3689#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
041ff4dd 3690static void
39e6acbd 3691parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
252b5132
RH		 3692#endif
3693#ifdef REPEAT_CONS_EXPRESSIONS
3694#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3695static void
39e6acbd 3696parse_repeat_cons (expressionS *exp, unsigned int nbytes);
252b5132
RH		 3697#endif
3698
3699/* If we haven't gotten one yet, just call expression. */
3700#ifndef TC_PARSE_CONS_EXPRESSION
3701#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3702#endif
3703#endif
3704
cdfbf930 3705void
b41b1f95
L		 3706do_parse_cons_expression (expressionS *exp,
3707 int nbytes ATTRIBUTE_UNUSED)
cdfbf930
RH		 3708{
3709 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3710}
3711
3712
041ff4dd
NC		 3713/* Worker to do .byte etc statements.
3714 Clobbers input_line_pointer and checks end-of-line. */
3715
3716static void
39e6acbd
KH		 3717cons_worker (register int nbytes, /* 1=.byte, 2=.word, 4=.long. */
3718 int rva)
252b5132
RH		 3719{
3720 int c;
3721 expressionS exp;
3722 char *stop = NULL;
fb25138b 3723 char stopc = 0;
252b5132
RH		 3724
3725#ifdef md_flush_pending_output
3726 md_flush_pending_output ();
3727#endif
3728
3729 if (flag_mri)
3730 stop = mri_comment_field (&stopc);
3731
3732 if (is_it_end_of_statement ())
3733 {
3734 demand_empty_rest_of_line ();
3735 if (flag_mri)
3736 mri_comment_end (stop, stopc);
3737 return;
3738 }
3739
cc1bc22a
AM		 3740#ifdef TC_ADDRESS_BYTES
3741 if (nbytes == 0)
3742 nbytes = TC_ADDRESS_BYTES ();
3743#endif
3744
252b5132
RH		 3745#ifdef md_cons_align
3746 md_cons_align (nbytes);
3747#endif
3748
3749 c = 0;
3750 do
3751 {
abd63a32 3752#ifdef TC_M68K
252b5132
RH		 3753 if (flag_m68k_mri)
3754 parse_mri_cons (&exp, (unsigned int) nbytes);
3755 else
abd63a32 3756#endif
252b5132
RH		 3757 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3758
3759 if (rva)
3760 {
3761 if (exp.X_op == O_symbol)
3762 exp.X_op = O_symbol_rva;
3763 else
3764 as_fatal (_("rva without symbol"));
3765 }
3766 emit_expr (&exp, (unsigned int) nbytes);
3767 ++c;
3768 }
3769 while (*input_line_pointer++ == ',');
3770
3771 /* In MRI mode, after an odd number of bytes, we must align to an
3772 even word boundary, unless the next instruction is a dc.b, ds.b
3773 or dcb.b. */
3774 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3775 mri_pending_align = 1;
3776
041ff4dd 3777 input_line_pointer--; /* Put terminator back into stream. */
252b5132
RH		 3778
3779 demand_empty_rest_of_line ();
3780
3781 if (flag_mri)
3782 mri_comment_end (stop, stopc);
3783}
3784
252b5132 3785void
39e6acbd 3786cons (int size)
252b5132
RH		 3787{
3788 cons_worker (size, 0);
3789}
3790
041ff4dd 3791void
39e6acbd 3792s_rva (int size)
252b5132
RH		 3793{
3794 cons_worker (size, 1);
3795}
3796
05e9452c
AM		 3797/* .reloc offset, reloc_name, symbol+addend. */
3798
3799void
3800s_reloc (int ignore ATTRIBUTE_UNUSED)
3801{
3802 char *stop = NULL;
3803 char stopc = 0;
3804 expressionS exp;
3805 char *r_name;
3806 int c;
3807 struct reloc_list *reloc;
3808
3809 reloc = xmalloc (sizeof (*reloc));
3810
3811 if (flag_mri)
3812 stop = mri_comment_field (&stopc);
3813
3814 expression (&exp);
3815 switch (exp.X_op)
3816 {
3817 case O_illegal:
3818 case O_absent:
3819 case O_big:
3820 case O_register:
3821 as_bad (_("missing or bad offset expression"));
3822 goto err_out;
3823 case O_constant:
3824 exp.X_add_symbol = section_symbol (now_seg);
3825 exp.X_op = O_symbol;
3826 /* Fall thru */
3827 case O_symbol:
3828 if (exp.X_add_number == 0)
3829 {
3830 reloc->u.a.offset_sym = exp.X_add_symbol;
3831 break;
3832 }
3833 /* Fall thru */
3834 default:
3835 reloc->u.a.offset_sym = make_expr_symbol (&exp);
3836 break;
3837 }
3838
3839 SKIP_WHITESPACE ();
3840 if (*input_line_pointer != ',')
3841 {
3842 as_bad (_("missing reloc type"));
3843 goto err_out;
3844 }
3845
3846 ++input_line_pointer;
3847 SKIP_WHITESPACE ();
3848 r_name = input_line_pointer;
3849 c = get_symbol_end ();
3850 reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
3851 *input_line_pointer = c;
3852 if (reloc->u.a.howto == NULL)
3853 {
3854 as_bad (_("unrecognized reloc type"));
3855 goto err_out;
3856 }
3857
3858 exp.X_op = O_absent;
3859 SKIP_WHITESPACE ();
3860 if (*input_line_pointer == ',')
3861 {
3862 ++input_line_pointer;
3863 expression_and_evaluate (&exp);
3864 }
3865 switch (exp.X_op)
3866 {
3867 case O_illegal:
3868 case O_big:
3869 case O_register:
3870 as_bad (_("bad reloc expression"));
3871 err_out:
3872 ignore_rest_of_line ();
3873 free (reloc);
3874 if (flag_mri)
3875 mri_comment_end (stop, stopc);
3876 return;
3877 case O_absent:
3878 reloc->u.a.sym = NULL;
3879 reloc->u.a.addend = 0;
3880 break;
3881 case O_constant:
3882 reloc->u.a.sym = NULL;
3883 reloc->u.a.addend = exp.X_add_number;
3884 break;
3885 case O_symbol:
3886 reloc->u.a.sym = exp.X_add_symbol;
3887 reloc->u.a.addend = exp.X_add_number;
3888 break;
3889 default:
3890 reloc->u.a.sym = make_expr_symbol (&exp);
3891 reloc->u.a.addend = 0;
3892 break;
3893 }
3894
3895 as_where (&reloc->file, &reloc->line);
3896 reloc->next = reloc_list;
3897 reloc_list = reloc;
3898
3899 demand_empty_rest_of_line ();
3900 if (flag_mri)
3901 mri_comment_end (stop, stopc);
3902}
3903
252b5132
RH		 3904/* Put the contents of expression EXP into the object file using
3905 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3906
3907void
39e6acbd 3908emit_expr (expressionS *exp, unsigned int nbytes)
252b5132
RH		 3909{
3910 operatorT op;
3911 register char *p;
3912 valueT extra_digit = 0;
3913
3914 /* Don't do anything if we are going to make another pass. */
3915 if (need_pass_2)
3916 return;
3917
ed7d5d1a
AM		 3918 dot_value = frag_now_fix ();
3919
252b5132
RH		 3920#ifndef NO_LISTING
3921#ifdef OBJ_ELF
3922 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3923 appear as a four byte positive constant in the .line section,
3924 followed by a 2 byte 0xffff. Look for that case here. */
3925 {
3926 static int dwarf_line = -1;
3927
3928 if (strcmp (segment_name (now_seg), ".line") != 0)
3929 dwarf_line = -1;
3930 else if (dwarf_line >= 0
3931 && nbytes == 2
3932 && exp->X_op == O_constant
3933 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3934 listing_source_line ((unsigned int) dwarf_line);
3935 else if (nbytes == 4
3936 && exp->X_op == O_constant
3937 && exp->X_add_number >= 0)
3938 dwarf_line = exp->X_add_number;
3939 else
3940 dwarf_line = -1;
3941 }
3942
3943 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3944 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3945 AT_sibling (0x12) followed by a four byte address of the sibling
3946 followed by a 2 byte AT_name (0x38) followed by the name of the
3947 file. We look for that case here. */
3948 {
3949 static int dwarf_file = 0;
3950
3951 if (strcmp (segment_name (now_seg), ".debug") != 0)
3952 dwarf_file = 0;
3953 else if (dwarf_file == 0
3954 && nbytes == 2
3955 && exp->X_op == O_constant
3956 && exp->X_add_number == 0x11)
3957 dwarf_file = 1;
3958 else if (dwarf_file == 1
3959 && nbytes == 2
3960 && exp->X_op == O_constant
3961 && exp->X_add_number == 0x12)
3962 dwarf_file = 2;
3963 else if (dwarf_file == 2
3964 && nbytes == 4)
3965 dwarf_file = 3;
3966 else if (dwarf_file == 3
3967 && nbytes == 2
3968 && exp->X_op == O_constant
3969 && exp->X_add_number == 0x38)
3970 dwarf_file = 4;
3971 else
3972 dwarf_file = 0;
3973
3974 /* The variable dwarf_file_string tells stringer that the string
3975 may be the name of the source file. */
3976 if (dwarf_file == 4)
3977 dwarf_file_string = 1;
3978 else
3979 dwarf_file_string = 0;
3980 }
3981#endif
3982#endif
3983
3984 if (check_eh_frame (exp, &nbytes))
3985 return;
3986
3987 op = exp->X_op;
3988
3989 /* Allow `.word 0' in the absolute section. */
3990 if (now_seg == absolute_section)
3991 {
3992 if (op != O_constant || exp->X_add_number != 0)
3993 as_bad (_("attempt to store value in absolute section"));
3994 abs_section_offset += nbytes;
3995 return;
3996 }
3997
3998 /* Handle a negative bignum. */
3999 if (op == O_uminus
4000 && exp->X_add_number == 0
2b47531b
ILT		 4001 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
4002 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
252b5132
RH		 4003 {
4004 int i;
4005 unsigned long carry;
4006
2b47531b 4007 exp = symbol_get_value_expression (exp->X_add_symbol);
252b5132
RH		 4008
4009 /* Negate the bignum: one's complement each digit and add 1. */
4010 carry = 1;
4011 for (i = 0; i < exp->X_add_number; i++)
4012 {
4013 unsigned long next;
4014
041ff4dd 4015 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
252b5132
RH		 4016 & LITTLENUM_MASK)
4017 + carry);
4018 generic_bignum[i] = next & LITTLENUM_MASK;
4019 carry = next >> LITTLENUM_NUMBER_OF_BITS;
4020 }
4021
4022 /* We can ignore any carry out, because it will be handled by
4023 extra_digit if it is needed. */
4024
4025 extra_digit = (valueT) -1;
4026 op = O_big;
4027 }
4028
4029 if (op == O_absent || op == O_illegal)
4030 {
4031 as_warn (_("zero assumed for missing expression"));
4032 exp->X_add_number = 0;
4033 op = O_constant;
4034 }
4035 else if (op == O_big && exp->X_add_number <= 0)
4036 {
0e389e77 4037 as_bad (_("floating point number invalid"));
252b5132
RH		 4038 exp->X_add_number = 0;
4039 op = O_constant;
4040 }
4041 else if (op == O_register)
4042 {
4043 as_warn (_("register value used as expression"));
4044 op = O_constant;
4045 }
4046
4047 p = frag_more ((int) nbytes);
4048
4049#ifndef WORKING_DOT_WORD
4050 /* If we have the difference of two symbols in a word, save it on
4051 the broken_words list. See the code in write.c. */
4052 if (op == O_subtract && nbytes == 2)
4053 {
4054 struct broken_word *x;
4055
4056 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
4057 x->next_broken_word = broken_words;
4058 broken_words = x;
4059 x->seg = now_seg;
4060 x->subseg = now_subseg;
4061 x->frag = frag_now;
4062 x->word_goes_here = p;
4063 x->dispfrag = 0;
4064 x->add = exp->X_add_symbol;
4065 x->sub = exp->X_op_symbol;
4066 x->addnum = exp->X_add_number;
4067 x->added = 0;
dc59a897 4068 x->use_jump = 0;
252b5132
RH		 4069 new_broken_words++;
4070 return;
4071 }
4072#endif
4073
4074 /* If we have an integer, but the number of bytes is too large to
4075 pass to md_number_to_chars, handle it as a bignum. */
4076 if (op == O_constant && nbytes > sizeof (valueT))
4077 {
e5604d79
RS		 4078 extra_digit = exp->X_unsigned ? 0 : -1;
4079 convert_to_bignum (exp);
4080 op = O_big;
252b5132
RH		 4081 }
4082
4083 if (op == O_constant)
4084 {
4085 register valueT get;
4086 register valueT use;
4087 register valueT mask;
4088 valueT hibit;
4089 register valueT unmask;
4090
4091 /* JF << of >= number of bits in the object is undefined. In
041ff4dd 4092 particular SPARC (Sun 4) has problems. */
252b5132
RH		 4093 if (nbytes >= sizeof (valueT))
4094 {
4095 mask = 0;
4096 if (nbytes > sizeof (valueT))
4097 hibit = 0;
4098 else
4099 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4100 }
4101 else
4102 {
041ff4dd 4103 /* Don't store these bits. */
252b5132
RH		 4104 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
4105 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
4106 }
4107
041ff4dd 4108 unmask = ~mask; /* Do store these bits. */
252b5132
RH		 4109
4110#ifdef NEVER
4111 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
041ff4dd 4112 mask = ~(unmask >> 1); /* Includes sign bit now. */
252b5132
RH		 4113#endif
4114
4115 get = exp->X_add_number;
4116 use = get & unmask;
4117 if ((get & mask) != 0
4118 && ((get & mask) != mask
4119 || (get & hibit) == 0))
041ff4dd 4120 { /* Leading bits contain both 0s & 1s. */
b6ac5419 4121#if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 4122#ifndef __MSVCRT__
5c612369
NC		 4123 as_warn (_("value 0x%llx truncated to 0x%llx"),
4124 (unsigned long long) get, (unsigned long long) use);
6e3d6dc1
NC		 4125#else
4126 as_warn (_("value 0x%I64x truncated to 0x%I64x"),
4127 (unsigned long long) get, (unsigned long long) use);
4128#endif
b6ac5419
AM		 4129#else
4130 as_warn (_("value 0x%lx truncated to 0x%lx"),
4131 (unsigned long) get, (unsigned long) use);
4132#endif
252b5132 4133 }
041ff4dd 4134 /* Put bytes in right order. */
252b5132
RH		 4135 md_number_to_chars (p, use, (int) nbytes);
4136 }
4137 else if (op == O_big)
4138 {
4139 unsigned int size;
4140 LITTLENUM_TYPE *nums;
4141
4142 know (nbytes % CHARS_PER_LITTLENUM == 0);
4143
4144 size = exp->X_add_number * CHARS_PER_LITTLENUM;
4145 if (nbytes < size)
4146 {
0e389e77 4147 as_warn (_("bignum truncated to %d bytes"), nbytes);
252b5132
RH		 4148 size = nbytes;
4149 }
4150
4151 if (target_big_endian)
4152 {
4153 while (nbytes > size)
4154 {
4155 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4156 nbytes -= CHARS_PER_LITTLENUM;
4157 p += CHARS_PER_LITTLENUM;
4158 }
4159
4160 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
ceac3f62 4161 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 4162 {
4163 --nums;
4164 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4165 size -= CHARS_PER_LITTLENUM;
4166 p += CHARS_PER_LITTLENUM;
4167 }
4168 }
4169 else
4170 {
4171 nums = generic_bignum;
ceac3f62 4172 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 4173 {
4174 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
4175 ++nums;
4176 size -= CHARS_PER_LITTLENUM;
4177 p += CHARS_PER_LITTLENUM;
4178 nbytes -= CHARS_PER_LITTLENUM;
4179 }
4180
ceac3f62 4181 while (nbytes >= CHARS_PER_LITTLENUM)
252b5132
RH		 4182 {
4183 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
4184 nbytes -= CHARS_PER_LITTLENUM;
4185 p += CHARS_PER_LITTLENUM;
4186 }
4187 }
4188 }
4189 else
7ddd14de
BW		 4190 emit_expr_fix (exp, nbytes, frag_now, p);
4191}
4192
4193void
4194emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
4195{
4196 memset (p, 0, nbytes);
252b5132 4197
7ddd14de 4198 /* Generate a fixS to record the symbol value. */
252b5132 4199
252b5132 4200#ifdef TC_CONS_FIX_NEW
7ddd14de 4201 TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
252b5132 4202#else
7ddd14de
BW		 4203 {
4204 bfd_reloc_code_real_type r;
252b5132 4205
7ddd14de
BW		 4206 switch (nbytes)
4207 {
4208 case 1:
4209 r = BFD_RELOC_8;
4210 break;
4211 case 2:
4212 r = BFD_RELOC_16;
4213 break;
4214 case 4:
4215 r = BFD_RELOC_32;
4216 break;
4217 case 8:
4218 r = BFD_RELOC_64;
4219 break;
4220 default:
4221 as_bad (_("unsupported BFD relocation size %u"), nbytes);
4222 r = BFD_RELOC_32;
4223 break;
252b5132 4224 }
7ddd14de
BW		 4225 fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
4226 0, r);
4227 }
252b5132 4228#endif
252b5132
RH		 4229}
4230\f
4231#ifdef BITFIELD_CONS_EXPRESSIONS
4232
4233/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
4234 w:x,y:z, where w and y are bitwidths and x and y are values. They
4235 then pack them all together. We do a little better in that we allow
4236 them in words, longs, etc. and we'll pack them in target byte order
4237 for you.
4238
47eebc20 4239 The rules are: pack least significant bit first, if a field doesn't
252b5132
RH		 4240 entirely fit, put it in the next unit. Overflowing the bitfield is
4241 explicitly *not* even a warning. The bitwidth should be considered
4242 a "mask".
4243
4244 To use this function the tc-XXX.h file should define
4245 BITFIELD_CONS_EXPRESSIONS. */
4246
041ff4dd 4247static void
252b5132
RH		 4248parse_bitfield_cons (exp, nbytes)
4249 expressionS *exp;
4250 unsigned int nbytes;
4251{
4252 unsigned int bits_available = BITS_PER_CHAR * nbytes;
4253 char *hold = input_line_pointer;
4254
4255 (void) expression (exp);
4256
4257 if (*input_line_pointer == ':')
041ff4dd
NC		 4258 {
4259 /* Bitfields. */
252b5132
RH		 4260 long value = 0;
4261
4262 for (;;)
4263 {
4264 unsigned long width;
4265
4266 if (*input_line_pointer != ':')
4267 {
4268 input_line_pointer = hold;
4269 break;
041ff4dd 4270 } /* Next piece is not a bitfield. */
252b5132
RH		 4271
4272 /* In the general case, we can't allow
4273 full expressions with symbol
4274 differences and such. The relocation
4275 entries for symbols not defined in this
4276 assembly would require arbitrary field
4277 widths, positions, and masks which most
4278 of our current object formats don't
4279 support.
4280
4281 In the specific case where a symbol
4282 *is* defined in this assembly, we
4283 *could* build fixups and track it, but
4284 this could lead to confusion for the
4285 backends. I'm lazy. I'll take any
4286 SEG_ABSOLUTE. I think that means that
4287 you can use a previous .set or
041ff4dd 4288 .equ type symbol. xoxorich. */
252b5132
RH		 4289
4290 if (exp->X_op == O_absent)
4291 {
4292 as_warn (_("using a bit field width of zero"));
4293 exp->X_add_number = 0;
4294 exp->X_op = O_constant;
041ff4dd 4295 } /* Implied zero width bitfield. */
252b5132
RH		 4296
4297 if (exp->X_op != O_constant)
4298 {
4299 *input_line_pointer = '\0';
4300 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
4301 *input_line_pointer = ':';
4302 demand_empty_rest_of_line ();
4303 return;
041ff4dd 4304 } /* Too complex. */
252b5132
RH		 4305
4306 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
4307 {
4308 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
4309 width, nbytes, (BITS_PER_CHAR * nbytes));
4310 width = BITS_PER_CHAR * nbytes;
041ff4dd 4311 } /* Too big. */
252b5132
RH		 4312
4313 if (width > bits_available)
4314 {
4315 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
4316 input_line_pointer = hold;
4317 exp->X_add_number = value;
4318 break;
041ff4dd 4319 } /* Won't fit. */
252b5132 4320
ef99799a
KH		 4321 /* Skip ':'. */
4322 hold = ++input_line_pointer;
252b5132
RH		 4323
4324 (void) expression (exp);
4325 if (exp->X_op != O_constant)
4326 {
4327 char cache = *input_line_pointer;
4328
4329 *input_line_pointer = '\0';
4330 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
4331 *input_line_pointer = cache;
4332 demand_empty_rest_of_line ();
4333 return;
041ff4dd 4334 } /* Too complex. */
252b5132
RH		 4335
4336 value |= ((~(-1 << width) & exp->X_add_number)
4337 << ((BITS_PER_CHAR * nbytes) - bits_available));
4338
4339 if ((bits_available -= width) == 0
4340 || is_it_end_of_statement ()
4341 || *input_line_pointer != ',')
4342 {
4343 break;
041ff4dd 4344 } /* All the bitfields we're gonna get. */
252b5132
RH		 4345
4346 hold = ++input_line_pointer;
4347 (void) expression (exp);
041ff4dd 4348 }
252b5132
RH		 4349
4350 exp->X_add_number = value;
4351 exp->X_op = O_constant;
4352 exp->X_unsigned = 1;
041ff4dd
NC		 4353 }
4354}
252b5132
RH		 4355
4356#endif /* BITFIELD_CONS_EXPRESSIONS */
4357\f
4358/* Handle an MRI style string expression. */
4359
abd63a32 4360#ifdef TC_M68K
252b5132
RH		 4361static void
4362parse_mri_cons (exp, nbytes)
4363 expressionS *exp;
4364 unsigned int nbytes;
4365{
4366 if (*input_line_pointer != '\''
4367 && (input_line_pointer[1] != '\''
4368 || (*input_line_pointer != 'A'
4369 && *input_line_pointer != 'E')))
4370 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
4371 else
4372 {
4373 unsigned int scan;
4374 unsigned int result = 0;
4375
4376 /* An MRI style string. Cut into as many bytes as will fit into
4377 a nbyte chunk, left justify if necessary, and separate with
4378 commas so we can try again later. */
4379 if (*input_line_pointer == 'A')
4380 ++input_line_pointer;
4381 else if (*input_line_pointer == 'E')
4382 {
4383 as_bad (_("EBCDIC constants are not supported"));
4384 ++input_line_pointer;
4385 }
4386
4387 input_line_pointer++;
4388 for (scan = 0; scan < nbytes; scan++)
4389 {
4390 if (*input_line_pointer == '\'')
4391 {
4392 if (input_line_pointer[1] == '\'')
4393 {
4394 input_line_pointer++;
4395 }
4396 else
4397 break;
4398 }
4399 result = (result << 8) | (*input_line_pointer++);
4400 }
4401
041ff4dd 4402 /* Left justify. */
252b5132
RH		 4403 while (scan < nbytes)
4404 {
4405 result <<= 8;
4406 scan++;
4407 }
f0e652b4 4408
041ff4dd 4409 /* Create correct expression. */
252b5132
RH		 4410 exp->X_op = O_constant;
4411 exp->X_add_number = result;
f0e652b4 4412
041ff4dd 4413 /* Fake it so that we can read the next char too. */
252b5132
RH		 4414 if (input_line_pointer[0] != '\'' ||
4415 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
4416 {
4417 input_line_pointer -= 2;
4418 input_line_pointer[0] = ',';
4419 input_line_pointer[1] = '\'';
4420 }
4421 else
4422 input_line_pointer++;
4423 }
4424}
abd63a32 4425#endif /* TC_M68K */
252b5132
RH		 4426\f
4427#ifdef REPEAT_CONS_EXPRESSIONS
4428
4429/* Parse a repeat expression for cons. This is used by the MIPS
4430 assembler. The format is NUMBER:COUNT; NUMBER appears in the
4431 object file COUNT times.
4432
4433 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
4434
4435static void
4436parse_repeat_cons (exp, nbytes)
4437 expressionS *exp;
4438 unsigned int nbytes;
4439{
4440 expressionS count;
4441 register int i;
4442
4443 expression (exp);
4444
4445 if (*input_line_pointer != ':')
4446 {
4447 /* No repeat count. */
4448 return;
4449 }
4450
4451 ++input_line_pointer;
4452 expression (&count);
4453 if (count.X_op != O_constant
4454 || count.X_add_number <= 0)
4455 {
0e389e77 4456 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4457 return;
4458 }
4459
4460 /* The cons function is going to output this expression once. So we
4461 output it count - 1 times. */
4462 for (i = count.X_add_number - 1; i > 0; i--)
4463 emit_expr (exp, nbytes);
4464}
4465
4466#endif /* REPEAT_CONS_EXPRESSIONS */
4467\f
4468/* Parse a floating point number represented as a hex constant. This
4469 permits users to specify the exact bits they want in the floating
4470 point number. */
4471
4472static int
39e6acbd 4473hex_float (int float_type, char *bytes)
252b5132
RH		 4474{
4475 int length;
4476 int i;
4477
4478 switch (float_type)
4479 {
4480 case 'f':
4481 case 'F':
4482 case 's':
4483 case 'S':
4484 length = 4;
4485 break;
4486
4487 case 'd':
4488 case 'D':
4489 case 'r':
4490 case 'R':
4491 length = 8;
4492 break;
4493
4494 case 'x':
4495 case 'X':
4496 length = 12;
4497 break;
4498
4499 case 'p':
4500 case 'P':
4501 length = 12;
4502 break;
4503
4504 default:
0e389e77 4505 as_bad (_("unknown floating type type '%c'"), float_type);
252b5132
RH		 4506 return -1;
4507 }
4508
4509 /* It would be nice if we could go through expression to parse the
4510 hex constant, but if we get a bignum it's a pain to sort it into
4511 the buffer correctly. */
4512 i = 0;
4513 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4514 {
4515 int d;
4516
4517 /* The MRI assembler accepts arbitrary underscores strewn about
041ff4dd 4518 through the hex constant, so we ignore them as well. */
252b5132
RH		 4519 if (*input_line_pointer == '_')
4520 {
4521 ++input_line_pointer;
4522 continue;
4523 }
4524
4525 if (i >= length)
4526 {
0e389e77 4527 as_warn (_("floating point constant too large"));
252b5132
RH		 4528 return -1;
4529 }
4530 d = hex_value (*input_line_pointer) << 4;
4531 ++input_line_pointer;
4532 while (*input_line_pointer == '_')
4533 ++input_line_pointer;
4534 if (hex_p (*input_line_pointer))
4535 {
4536 d += hex_value (*input_line_pointer);
4537 ++input_line_pointer;
4538 }
4539 if (target_big_endian)
4540 bytes[i] = d;
4541 else
4542 bytes[length - i - 1] = d;
4543 ++i;
4544 }
4545
4546 if (i < length)
4547 {
4548 if (target_big_endian)
4549 memset (bytes + i, 0, length - i);
4550 else
4551 memset (bytes, 0, length - i);
4552 }
4553
4554 return length;
4555}
4556
d6415f6c 4557/* float_cons()
f0e652b4 4558
041ff4dd
NC		 4559 CONStruct some more frag chars of .floats .ffloats etc.
4560 Makes 0 or more new frags.
4561 If need_pass_2 == 1, no frags are emitted.
4562 This understands only floating literals, not expressions. Sorry.
f0e652b4 4563
041ff4dd
NC		 4564 A floating constant is defined by atof_generic(), except it is preceded
4565 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4566 reading, I decided to be incompatible. This always tries to give you
4567 rounded bits to the precision of the pseudo-op. Former AS did premature
47eebc20 4568 truncation, restored noisy bits instead of trailing 0s AND gave you
041ff4dd
NC		 4569 a choice of 2 flavours of noise according to which of 2 floating-point
4570 scanners you directed AS to use.
f0e652b4 4571
041ff4dd 4572 In: input_line_pointer->whitespace before, or '0' of flonum. */
252b5132
RH		 4573
4574void
39e6acbd
KH		 4575float_cons (/* Clobbers input_line-pointer, checks end-of-line. */
4576 register int float_type /* 'f':.ffloat ... 'F':.float ... */)
252b5132
RH		 4577{
4578 register char *p;
041ff4dd
NC		 4579 int length; /* Number of chars in an object. */
4580 register char *err; /* Error from scanning floating literal. */
252b5132
RH		 4581 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4582
4583 if (is_it_end_of_statement ())
4584 {
4585 demand_empty_rest_of_line ();
4586 return;
4587 }
4588
4589#ifdef md_flush_pending_output
4590 md_flush_pending_output ();
4591#endif
4592
4593 do
4594 {
041ff4dd 4595 /* input_line_pointer->1st char of a flonum (we hope!). */
252b5132
RH		 4596 SKIP_WHITESPACE ();
4597
4598 /* Skip any 0{letter} that may be present. Don't even check if the
d6415f6c
AM		 4599 letter is legal. Someone may invent a "z" format and this routine
4600 has no use for such information. Lusers beware: you get
4601 diagnostics if your input is ill-conditioned. */
252b5132 4602 if (input_line_pointer[0] == '0'
3882b010 4603 && ISALPHA (input_line_pointer[1]))
252b5132
RH		 4604 input_line_pointer += 2;
4605
4606 /* Accept :xxxx, where the x's are hex digits, for a floating
d6415f6c 4607 point with the exact digits specified. */
252b5132
RH		 4608 if (input_line_pointer[0] == ':')
4609 {
4610 ++input_line_pointer;
4611 length = hex_float (float_type, temp);
4612 if (length < 0)
4613 {
4614 ignore_rest_of_line ();
4615 return;
4616 }
4617 }
4618 else
4619 {
4620 err = md_atof (float_type, temp, &length);
4621 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
499ac353 4622 know (err != NULL || length > 0);
252b5132
RH		 4623 if (err)
4624 {
0e389e77 4625 as_bad (_("bad floating literal: %s"), err);
252b5132
RH		 4626 ignore_rest_of_line ();
4627 return;
4628 }
4629 }
4630
4631 if (!need_pass_2)
4632 {
4633 int count;
4634
4635 count = 1;
4636
4637#ifdef REPEAT_CONS_EXPRESSIONS
4638 if (*input_line_pointer == ':')
4639 {
4640 expressionS count_exp;
4641
4642 ++input_line_pointer;
4643 expression (&count_exp);
f0e652b4 4644
252b5132
RH		 4645 if (count_exp.X_op != O_constant
4646 || count_exp.X_add_number <= 0)
041ff4dd 4647 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4648 else
4649 count = count_exp.X_add_number;
4650 }
4651#endif
4652
4653 while (--count >= 0)
4654 {
4655 p = frag_more (length);
4656 memcpy (p, temp, (unsigned int) length);
4657 }
4658 }
4659 SKIP_WHITESPACE ();
4660 }
4661 while (*input_line_pointer++ == ',');
4662
041ff4dd
NC		 4663 /* Put terminator back into stream. */
4664 --input_line_pointer;
252b5132 4665 demand_empty_rest_of_line ();
041ff4dd 4666}
252b5132 4667\f
041ff4dd 4668/* Return the size of a LEB128 value. */
252b5132
RH		 4669
4670static inline int
39e6acbd 4671sizeof_sleb128 (offsetT value)
252b5132
RH		 4672{
4673 register int size = 0;
4674 register unsigned byte;
4675
4676 do
4677 {
4678 byte = (value & 0x7f);
4679 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4680 Fortunately, we can structure things so that the extra work reduces
4681 to a noop on systems that do things "properly". */
4682 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4683 size += 1;
4684 }
4685 while (!(((value == 0) && ((byte & 0x40) == 0))
4686 || ((value == -1) && ((byte & 0x40) != 0))));
4687
4688 return size;
4689}
4690
4691static inline int
39e6acbd 4692sizeof_uleb128 (valueT value)
252b5132
RH		 4693{
4694 register int size = 0;
4695 register unsigned byte;
4696
4697 do
4698 {
4699 byte = (value & 0x7f);
4700 value >>= 7;
4701 size += 1;
4702 }
4703 while (value != 0);
4704
4705 return size;
4706}
4707
4708int
39e6acbd 4709sizeof_leb128 (valueT value, int sign)
252b5132
RH		 4710{
4711 if (sign)
4712 return sizeof_sleb128 ((offsetT) value);
4713 else
4714 return sizeof_uleb128 (value);
4715}
4716
4717/* Output a LEB128 value. */
4718
4719static inline int
39e6acbd 4720output_sleb128 (char *p, offsetT value)
252b5132
RH		 4721{
4722 register char *orig = p;
4723 register int more;
4724
4725 do
4726 {
4727 unsigned byte = (value & 0x7f);
4728
4729 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4730 Fortunately, we can structure things so that the extra work reduces
4731 to a noop on systems that do things "properly". */
4732 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4733
4734 more = !((((value == 0) && ((byte & 0x40) == 0))
4735 || ((value == -1) && ((byte & 0x40) != 0))));
4736 if (more)
4737 byte |= 0x80;
4738
4739 *p++ = byte;
4740 }
4741 while (more);
4742
4743 return p - orig;
4744}
4745
4746static inline int
39e6acbd 4747output_uleb128 (char *p, valueT value)
252b5132
RH		 4748{
4749 char *orig = p;
4750
4751 do
4752 {
4753 unsigned byte = (value & 0x7f);
4754 value >>= 7;
4755 if (value != 0)
4756 /* More bytes to follow. */
4757 byte |= 0x80;
4758
4759 *p++ = byte;
4760 }
4761 while (value != 0);
4762
4763 return p - orig;
4764}
4765
4766int
39e6acbd 4767output_leb128 (char *p, valueT value, int sign)
252b5132
RH		 4768{
4769 if (sign)
4770 return output_sleb128 (p, (offsetT) value);
4771 else
4772 return output_uleb128 (p, value);
4773}
4774
4775/* Do the same for bignums. We combine sizeof with output here in that
4776 we don't output for NULL values of P. It isn't really as critical as
4777 for "normal" values that this be streamlined. */
4778
6d4d30bb 4779static inline int
39e6acbd 4780output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
252b5132
RH		 4781{
4782 char *orig = p;
4783 valueT val = 0;
4784 int loaded = 0;
4785 unsigned byte;
4786
4787 /* Strip leading sign extensions off the bignum. */
e5604d79
RS		 4788 while (size > 1
4789 && bignum[size - 1] == LITTLENUM_MASK
4790 && bignum[size - 2] > LITTLENUM_MASK / 2)
252b5132
RH		 4791 size--;
4792
4793 do
4794 {
e5604d79
RS		 4795 /* OR in the next part of the littlenum. */
4796 val |= (*bignum << loaded);
4797 loaded += LITTLENUM_NUMBER_OF_BITS;
4798 size--;
4799 bignum++;
4800
4801 /* Add bytes until there are less than 7 bits left in VAL
4802 or until every non-sign bit has been written. */
4803 do
252b5132 4804 {
e5604d79
RS		 4805 byte = val & 0x7f;
4806 loaded -= 7;
4807 val >>= 7;
4808 if (size > 0
4809 || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
252b5132 4810 byte |= 0x80;
e5604d79
RS		 4811
4812 if (orig)
4813 *p = byte;
4814 p++;
252b5132 4815 }
e5604d79
RS		 4816 while ((byte & 0x80) != 0 && loaded >= 7);
4817 }
4818 while (size > 0);
252b5132 4819
e5604d79
RS		 4820 /* Mop up any left-over bits (of which there will be less than 7). */
4821 if ((byte & 0x80) != 0)
4822 {
4823 /* Sign-extend VAL. */
4824 if (val & (1 << (loaded - 1)))
4825 val |= ~0 << loaded;
252b5132 4826 if (orig)
e5604d79 4827 *p = val & 0x7f;
252b5132
RH		 4828 p++;
4829 }
252b5132
RH		 4830
4831 return p - orig;
4832}
4833
6d4d30bb 4834static inline int
39e6acbd 4835output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
252b5132
RH		 4836{
4837 char *orig = p;
4838 valueT val = 0;
4839 int loaded = 0;
4840 unsigned byte;
4841
4842 /* Strip leading zeros off the bignum. */
4843 /* XXX: Is this needed? */
041ff4dd 4844 while (size > 0 && bignum[size - 1] == 0)
252b5132
RH		 4845 size--;
4846
4847 do
4848 {
4849 if (loaded < 7 && size > 0)
4850 {
4851 val |= (*bignum << loaded);
4852 loaded += 8 * CHARS_PER_LITTLENUM;
4853 size--;
4854 bignum++;
4855 }
4856
4857 byte = val & 0x7f;
4858 loaded -= 7;
4859 val >>= 7;
4860
4861 if (size > 0 || val)
4862 byte |= 0x80;
4863
4864 if (orig)
4865 *p = byte;
4866 p++;
4867 }
4868 while (byte & 0x80);
4869
4870 return p - orig;
4871}
4872
6d4d30bb 4873static int
39e6acbd 4874output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
252b5132
RH		 4875{
4876 if (sign)
4877 return output_big_sleb128 (p, bignum, size);
4878 else
4879 return output_big_uleb128 (p, bignum, size);
4880}
4881
4882/* Generate the appropriate fragments for a given expression to emit a
4883 leb128 value. */
4884
87c245cc 4885static void
39e6acbd 4886emit_leb128_expr (expressionS *exp, int sign)
252b5132
RH		 4887{
4888 operatorT op = exp->X_op;
b7712f8d 4889 unsigned int nbytes;
252b5132
RH		 4890
4891 if (op == O_absent || op == O_illegal)
4892 {
4893 as_warn (_("zero assumed for missing expression"));
4894 exp->X_add_number = 0;
4895 op = O_constant;
4896 }
4897 else if (op == O_big && exp->X_add_number <= 0)
4898 {
0e389e77 4899 as_bad (_("floating point number invalid"));
252b5132
RH		 4900 exp->X_add_number = 0;
4901 op = O_constant;
4902 }
4903 else if (op == O_register)
4904 {
4905 as_warn (_("register value used as expression"));
4906 op = O_constant;
4907 }
e5604d79
RS		 4908 else if (op == O_constant
4909 && sign
4910 && (exp->X_add_number < 0) != !exp->X_unsigned)
4911 {
4912 /* We're outputting a signed leb128 and the sign of X_add_number
4913 doesn't reflect the sign of the original value. Convert EXP
4914 to a correctly-extended bignum instead. */
4915 convert_to_bignum (exp);
4916 op = O_big;
4917 }
252b5132 4918
67a659f6
RH		 4919 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4920 a signal that this is leb128 data. It shouldn't optimize this away. */
b7712f8d 4921 nbytes = (unsigned int) -1;
67a659f6
RH		 4922 if (check_eh_frame (exp, &nbytes))
4923 abort ();
4924
371b7465
RH		 4925 /* Let the backend know that subsequent data may be byte aligned. */
4926#ifdef md_cons_align
4927 md_cons_align (1);
4928#endif
4929
252b5132
RH		 4930 if (op == O_constant)
4931 {
4932 /* If we've got a constant, emit the thing directly right now. */
4933
4934 valueT value = exp->X_add_number;
4935 int size;
4936 char *p;
4937
4938 size = sizeof_leb128 (value, sign);
4939 p = frag_more (size);
4940 output_leb128 (p, value, sign);
4941 }
4942 else if (op == O_big)
4943 {
4944 /* O_big is a different sort of constant. */
4945
4946 int size;
4947 char *p;
4948
4949 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4950 p = frag_more (size);
4951 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4952 }
4953 else
4954 {
041ff4dd 4955 /* Otherwise, we have to create a variable sized fragment and
252b5132
RH		 4956 resolve things later. */
4957
041ff4dd 4958 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
252b5132
RH		 4959 make_expr_symbol (exp), 0, (char *) NULL);
4960 }
4961}
4962
4963/* Parse the .sleb128 and .uleb128 pseudos. */
4964
4965void
39e6acbd 4966s_leb128 (int sign)
252b5132
RH		 4967{
4968 expressionS exp;
4969
00bbdfe7
BW		 4970#ifdef md_flush_pending_output
4971 md_flush_pending_output ();
4972#endif
4973
041ff4dd
NC		 4974 do
4975 {
4976 expression (&exp);
4977 emit_leb128_expr (&exp, sign);
4978 }
4979 while (*input_line_pointer++ == ',');
252b5132
RH		 4980
4981 input_line_pointer--;
4982 demand_empty_rest_of_line ();
4983}
4984\f
38a57ae7
NC		 4985static void
4986stringer_append_char (int c, int bitsize)
4987{
4988 if (!target_big_endian)
4989 FRAG_APPEND_1_CHAR (c);
4990
4991 switch (bitsize)
4992 {
4993 case 64:
4994 FRAG_APPEND_1_CHAR (0);
4995 FRAG_APPEND_1_CHAR (0);
4996 FRAG_APPEND_1_CHAR (0);
4997 FRAG_APPEND_1_CHAR (0);
4998 /* Fall through. */
4999 case 32:
5000 FRAG_APPEND_1_CHAR (0);
5001 FRAG_APPEND_1_CHAR (0);
5002 /* Fall through. */
5003 case 16:
5004 FRAG_APPEND_1_CHAR (0);
5005 /* Fall through. */
5006 case 8:
5007 break;
5008 default:
5009 /* Called with invalid bitsize argument. */
5010 abort ();
5011 break;
5012 }
5013 if (target_big_endian)
5014 FRAG_APPEND_1_CHAR (c);
5015}
5016
5017/* Worker to do .ascii etc statements.
5018 Reads 0 or more ',' separated, double-quoted strings.
041ff4dd 5019 Caller should have checked need_pass_2 is FALSE because we don't
38a57ae7
NC		 5020 check it.
5021 Checks for end-of-line.
5022 BITS_APPENDZERO says how many bits are in a target char.
5023 The bottom bit is set if a NUL char should be appended to the strings. */
041ff4dd
NC		 5024
5025void
38a57ae7 5026stringer (int bits_appendzero)
252b5132 5027{
38a57ae7
NC		 5028 const int bitsize = bits_appendzero & ~7;
5029 const int append_zero = bits_appendzero & 1;
5030 unsigned int c;
252b5132
RH		 5031 char *start;
5032
5033#ifdef md_flush_pending_output
5034 md_flush_pending_output ();
5035#endif
5036
041ff4dd
NC		 5037 /* The following awkward logic is to parse ZERO or more strings,
5038 comma separated. Recall a string expression includes spaces
5039 before the opening '\"' and spaces after the closing '\"'.
5040 We fake a leading ',' if there is (supposed to be)
5041 a 1st, expression. We keep demanding expressions for each ','. */
252b5132
RH		 5042 if (is_it_end_of_statement ())
5043 {
041ff4dd
NC		 5044 c = 0; /* Skip loop. */
5045 ++input_line_pointer; /* Compensate for end of loop. */
252b5132
RH		 5046 }
5047 else
5048 {
041ff4dd 5049 c = ','; /* Do loop. */
252b5132 5050 }
8ac9ba6c
NC		 5051 /* If we have been switched into the abs_section then we
5052 will not have an obstack onto which we can hang strings. */
5053 if (now_seg == absolute_section)
5054 {
5055 as_bad (_("strings must be placed into a section"));
5056 c = 0;
5057 ignore_rest_of_line ();
5058 }
d6415f6c 5059
252b5132
RH		 5060 while (c == ',' || c == '<' || c == '"')
5061 {
5062 SKIP_WHITESPACE ();
5063 switch (*input_line_pointer)
5064 {
5065 case '\"':
041ff4dd 5066 ++input_line_pointer; /*->1st char of string. */
252b5132 5067 start = input_line_pointer;
38a57ae7 5068
252b5132 5069 while (is_a_char (c = next_char_of_string ()))
38a57ae7
NC		 5070 stringer_append_char (c, bitsize);
5071
252b5132 5072 if (append_zero)
38a57ae7
NC		 5073 stringer_append_char (0, bitsize);
5074
252b5132
RH		 5075 know (input_line_pointer[-1] == '\"');
5076
5077#ifndef NO_LISTING
5078#ifdef OBJ_ELF
5079 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
d6415f6c
AM		 5080 will emit .string with a filename in the .debug section
5081 after a sequence of constants. See the comment in
5082 emit_expr for the sequence. emit_expr will set
5083 dwarf_file_string to non-zero if this string might be a
5084 source file name. */
252b5132
RH		 5085 if (strcmp (segment_name (now_seg), ".debug") != 0)
5086 dwarf_file_string = 0;
5087 else if (dwarf_file_string)
5088 {
5089 c = input_line_pointer[-1];
5090 input_line_pointer[-1] = '\0';
5091 listing_source_file (start);
5092 input_line_pointer[-1] = c;
5093 }
5094#endif
5095#endif
5096
5097 break;
5098 case '<':
5099 input_line_pointer++;
5100 c = get_single_number ();
38a57ae7 5101 stringer_append_char (c, bitsize);
252b5132 5102 if (*input_line_pointer != '>')
38a57ae7
NC		 5103 as_bad (_("expected <nn>"));
5104
252b5132
RH		 5105 input_line_pointer++;
5106 break;
5107 case ',':
5108 input_line_pointer++;
5109 break;
5110 }
5111 SKIP_WHITESPACE ();
5112 c = *input_line_pointer;
5113 }
5114
5115 demand_empty_rest_of_line ();
38a57ae7 5116}
252b5132
RH		 5117\f
5118/* FIXME-SOMEDAY: I had trouble here on characters with the
5119 high bits set. We'll probably also have trouble with
5120 multibyte chars, wide chars, etc. Also be careful about
041ff4dd 5121 returning values bigger than 1 byte. xoxorich. */
252b5132 5122
041ff4dd 5123unsigned int
39e6acbd 5124next_char_of_string (void)
252b5132
RH		 5125{
5126 register unsigned int c;
5127
5128 c = *input_line_pointer++ & CHAR_MASK;
5129 switch (c)
5130 {
5131 case '\"':
5132 c = NOT_A_CHAR;
5133 break;
5134
5135 case '\n':
0e389e77 5136 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 5137 bump_line_counters ();
5138 break;
5139
5140#ifndef NO_STRING_ESCAPES
5141 case '\\':
5142 switch (c = *input_line_pointer++)
5143 {
5144 case 'b':
5145 c = '\b';
5146 break;
5147
5148 case 'f':
5149 c = '\f';
5150 break;
5151
5152 case 'n':
5153 c = '\n';
5154 break;
5155
5156 case 'r':
5157 c = '\r';
5158 break;
5159
5160 case 't':
5161 c = '\t';
5162 break;
5163
5164 case 'v':
5165 c = '\013';
5166 break;
5167
5168 case '\\':
5169 case '"':
041ff4dd 5170 break; /* As itself. */
252b5132
RH		 5171
5172 case '0':
5173 case '1':
5174 case '2':
5175 case '3':
5176 case '4':
5177 case '5':
5178 case '6':
5179 case '7':
5180 case '8':
5181 case '9':
5182 {
5183 long number;
5184 int i;
5185
041ff4dd 5186 for (i = 0, number = 0;
3882b010 5187 ISDIGIT (c) && i < 3;
041ff4dd 5188 c = *input_line_pointer++, i++)
252b5132
RH		 5189 {
5190 number = number * 8 + c - '0';
5191 }
f0e652b4 5192
252b5132
RH		 5193 c = number & 0xff;
5194 }
5195 --input_line_pointer;
5196 break;
5197
5198 case 'x':
5199 case 'X':
5200 {
5201 long number;
5202
5203 number = 0;
5204 c = *input_line_pointer++;
3882b010 5205 while (ISXDIGIT (c))
252b5132 5206 {
3882b010 5207 if (ISDIGIT (c))
252b5132 5208 number = number * 16 + c - '0';
3882b010 5209 else if (ISUPPER (c))
252b5132
RH		 5210 number = number * 16 + c - 'A' + 10;
5211 else
5212 number = number * 16 + c - 'a' + 10;
5213 c = *input_line_pointer++;
5214 }
5215 c = number & 0xff;
5216 --input_line_pointer;
5217 }
5218 break;
5219
5220 case '\n':
041ff4dd 5221 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
0e389e77 5222 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 5223 c = '\n';
5224 bump_line_counters ();
5225 break;
5226
5227 default:
5228
5229#ifdef ONLY_STANDARD_ESCAPES
0e389e77 5230 as_bad (_("bad escaped character in string"));
252b5132
RH		 5231 c = '?';
5232#endif /* ONLY_STANDARD_ESCAPES */
5233
5234 break;
041ff4dd 5235 }
252b5132
RH		 5236 break;
5237#endif /* ! defined (NO_STRING_ESCAPES) */
5238
5239 default:
5240 break;
041ff4dd 5241 }
252b5132 5242 return (c);
041ff4dd 5243}
252b5132
RH		 5244\f
5245static segT
39e6acbd 5246get_segmented_expression (register expressionS *expP)
252b5132
RH		 5247{
5248 register segT retval;
5249
5250 retval = expression (expP);
5251 if (expP->X_op == O_illegal
5252 || expP->X_op == O_absent
5253 || expP->X_op == O_big)
5254 {
0e389e77 5255 as_bad (_("expected address expression"));
252b5132
RH		 5256 expP->X_op = O_constant;
5257 expP->X_add_number = 0;
5258 retval = absolute_section;
5259 }
5260 return retval;
5261}
5262
041ff4dd 5263static segT
39e6acbd 5264get_known_segmented_expression (register expressionS *expP)
252b5132
RH		 5265{
5266 register segT retval;
5267
5268 if ((retval = get_segmented_expression (expP)) == undefined_section)
5269 {
5270 /* There is no easy way to extract the undefined symbol from the
5271 expression. */
5272 if (expP->X_add_symbol != NULL
5273 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
5274 as_warn (_("symbol \"%s\" undefined; zero assumed"),
5275 S_GET_NAME (expP->X_add_symbol));
5276 else
5277 as_warn (_("some symbol undefined; zero assumed"));
5278 retval = absolute_section;
5279 expP->X_op = O_constant;
5280 expP->X_add_number = 0;
5281 }
5282 know (retval == absolute_section || SEG_NORMAL (retval));
5283 return (retval);
041ff4dd 5284}
252b5132 5285
041ff4dd 5286char /* Return terminator. */
39e6acbd 5287get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression. */)
252b5132
RH		 5288{
5289 /* FIXME: val_pointer should probably be offsetT *. */
5290 *val_pointer = (long) get_absolute_expression ();
5291 return (*input_line_pointer++);
5292}
5293\f
041ff4dd
NC		 5294/* Like demand_copy_string, but return NULL if the string contains any '\0's.
5295 Give a warning if that happens. */
5296
252b5132 5297char *
39e6acbd 5298demand_copy_C_string (int *len_pointer)
252b5132
RH		 5299{
5300 register char *s;
5301
5302 if ((s = demand_copy_string (len_pointer)) != 0)
5303 {
5304 register int len;
5305
5306 for (len = *len_pointer; len > 0; len--)
5307 {
5308 if (*s == 0)
5309 {
5310 s = 0;
5311 len = 1;
5312 *len_pointer = 0;
0e389e77 5313 as_bad (_("this string may not contain \'\\0\'"));
252b5132
RH		 5314 }
5315 }
5316 }
f0e652b4 5317
252b5132
RH		 5318 return s;
5319}
5320\f
041ff4dd
NC		 5321/* Demand string, but return a safe (=private) copy of the string.
5322 Return NULL if we can't read a string here. */
5323
252b5132 5324char *
39e6acbd 5325demand_copy_string (int *lenP)
252b5132
RH		 5326{
5327 register unsigned int c;
5328 register int len;
5329 char *retval;
5330
5331 len = 0;
5332 SKIP_WHITESPACE ();
5333 if (*input_line_pointer == '\"')
5334 {
041ff4dd 5335 input_line_pointer++; /* Skip opening quote. */
252b5132
RH		 5336
5337 while (is_a_char (c = next_char_of_string ()))
5338 {
5339 obstack_1grow (&notes, c);
5340 len++;
5341 }
5342 /* JF this next line is so demand_copy_C_string will return a
041ff4dd 5343 null terminated string. */
252b5132
RH		 5344 obstack_1grow (&notes, '\0');
5345 retval = obstack_finish (&notes);
5346 }
5347 else
5348 {
c95b35a9 5349 as_bad (_("missing string"));
252b5132
RH		 5350 retval = NULL;
5351 ignore_rest_of_line ();
5352 }
5353 *lenP = len;
5354 return (retval);
041ff4dd 5355}
252b5132 5356\f
041ff4dd 5357/* In: Input_line_pointer->next character.
f0e652b4 5358
041ff4dd 5359 Do: Skip input_line_pointer over all whitespace.
f0e652b4 5360
041ff4dd
NC		 5361 Out: 1 if input_line_pointer->end-of-line. */
5362
5363int
39e6acbd 5364is_it_end_of_statement (void)
252b5132
RH		 5365{
5366 SKIP_WHITESPACE ();
5367 return (is_end_of_line[(unsigned char) *input_line_pointer]);
041ff4dd 5368}
252b5132 5369
041ff4dd 5370void
39e6acbd 5371equals (char *sym_name, int reassign)
252b5132 5372{
252b5132 5373 char *stop = NULL;
fb25138b 5374 char stopc = 0;
252b5132
RH		 5375
5376 input_line_pointer++;
5377 if (*input_line_pointer == '=')
5378 input_line_pointer++;
9497f5ac
NC		 5379 if (reassign < 0 && *input_line_pointer == '=')
5380 input_line_pointer++;
252b5132
RH		 5381
5382 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
5383 input_line_pointer++;
5384
5385 if (flag_mri)
5386 stop = mri_comment_field (&stopc);
5387
9497f5ac 5388 assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
252b5132
RH		 5389
5390 if (flag_mri)
31d20a21
AM		 5391 {
5392 demand_empty_rest_of_line ();
5393 mri_comment_end (stop, stopc);
5394 }
041ff4dd 5395}
252b5132 5396
7e005732
NC		 5397/* .incbin -- include a file verbatim at the current location. */
5398
5399void
39e6acbd 5400s_incbin (int x ATTRIBUTE_UNUSED)
7e005732
NC		 5401{
5402 FILE * binfile;
5403 char * path;
5404 char * filename;
5405 char * binfrag;
5406 long skip = 0;
5407 long count = 0;
5408 long bytes;
5409 int len;
5410
5411#ifdef md_flush_pending_output
5412 md_flush_pending_output ();
5413#endif
5414
5415 SKIP_WHITESPACE ();
5416 filename = demand_copy_string (& len);
5417 if (filename == NULL)
5418 return;
5419
5420 SKIP_WHITESPACE ();
5421
5422 /* Look for optional skip and count. */
5423 if (* input_line_pointer == ',')
5424 {
5425 ++ input_line_pointer;
5426 skip = get_absolute_expression ();
5427
5428 SKIP_WHITESPACE ();
5429
5430 if (* input_line_pointer == ',')
5431 {
5432 ++ input_line_pointer;
5433
5434 count = get_absolute_expression ();
5435 if (count == 0)
5436 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5437
5438 SKIP_WHITESPACE ();
5439 }
5440 }
5441
5442 demand_empty_rest_of_line ();
5443
5444 /* Try opening absolute path first, then try include dirs. */
f740e790 5445 binfile = fopen (filename, FOPEN_RB);
7e005732
NC		 5446 if (binfile == NULL)
5447 {
5448 int i;
5449
5450 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5451
5452 for (i = 0; i < include_dir_count; i++)
5453 {
5454 sprintf (path, "%s/%s", include_dirs[i], filename);
5455
f740e790 5456 binfile = fopen (path, FOPEN_RB);
7e005732
NC		 5457 if (binfile != NULL)
5458 break;
5459 }
5460
5461 if (binfile == NULL)
5462 as_bad (_("file not found: %s"), filename);
5463 }
5464 else
5465 path = xstrdup (filename);
5466
5467 if (binfile)
5468 {
f740e790
NC		 5469 long file_len;
5470
7e005732
NC		 5471 register_dependency (path);
5472
5473 /* Compute the length of the file. */
5474 if (fseek (binfile, 0, SEEK_END) != 0)
5475 {
5476 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5477 goto done;
5478 }
f740e790 5479 file_len = ftell (binfile);
7e005732 5480
c556cc9c 5481 /* If a count was not specified use the remainder of the file. */
7e005732 5482 if (count == 0)
c556cc9c 5483 count = file_len - skip;
7e005732 5484
c556cc9c 5485 if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
7e005732 5486 {
c556cc9c 5487 as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
f740e790 5488 skip, count, file_len);
7e005732
NC		 5489 goto done;
5490 }
5491
5492 if (fseek (binfile, skip, SEEK_SET) != 0)
5493 {
5494 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5495 goto done;
5496 }
5497
5498 /* Allocate frag space and store file contents in it. */
5499 binfrag = frag_more (count);
5500
5501 bytes = fread (binfrag, 1, count, binfile);
5502 if (bytes < count)
5503 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5504 path, bytes, count);
5505 }
5506done:
5507 if (binfile != NULL)
5508 fclose (binfile);
5509 if (path)
5510 free (path);
5511}
5512
041ff4dd 5513/* .include -- include a file at this point. */
252b5132 5514
041ff4dd 5515void
39e6acbd 5516s_include (int arg ATTRIBUTE_UNUSED)
252b5132 5517{
252b5132
RH		 5518 char *filename;
5519 int i;
5520 FILE *try;
5521 char *path;
5522
041ff4dd 5523 if (!flag_m68k_mri)
252b5132
RH		 5524 {
5525 filename = demand_copy_string (&i);
5526 if (filename == NULL)
5527 {
5528 /* demand_copy_string has already printed an error and
d6415f6c 5529 called ignore_rest_of_line. */
252b5132
RH		 5530 return;
5531 }
5532 }
5533 else
5534 {
5535 SKIP_WHITESPACE ();
5536 i = 0;
041ff4dd 5537 while (!is_end_of_line[(unsigned char) *input_line_pointer]
252b5132
RH		 5538 && *input_line_pointer != ' '
5539 && *input_line_pointer != '\t')
5540 {
5541 obstack_1grow (&notes, *input_line_pointer);
5542 ++input_line_pointer;
5543 ++i;
5544 }
f0e652b4 5545
252b5132
RH		 5546 obstack_1grow (&notes, '\0');
5547 filename = obstack_finish (&notes);
041ff4dd 5548 while (!is_end_of_line[(unsigned char) *input_line_pointer])
252b5132
RH		 5549 ++input_line_pointer;
5550 }
f0e652b4 5551
252b5132
RH		 5552 demand_empty_rest_of_line ();
5553 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
f0e652b4 5554
252b5132
RH		 5555 for (i = 0; i < include_dir_count; i++)
5556 {
5557 strcpy (path, include_dirs[i]);
5558 strcat (path, "/");
5559 strcat (path, filename);
f740e790 5560 if (0 != (try = fopen (path, FOPEN_RT)))
252b5132
RH		 5561 {
5562 fclose (try);
5563 goto gotit;
5564 }
5565 }
f0e652b4 5566
252b5132
RH		 5567 free (path);
5568 path = filename;
5569gotit:
041ff4dd 5570 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
252b5132 5571 register_dependency (path);
9f10757c 5572 input_scrub_insert_file (path);
041ff4dd 5573}
252b5132 5574
041ff4dd 5575void
39e6acbd 5576add_include_dir (char *path)
252b5132
RH		 5577{
5578 int i;
5579
5580 if (include_dir_count == 0)
5581 {
5582 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
041ff4dd 5583 include_dirs[0] = "."; /* Current dir. */
252b5132
RH		 5584 include_dir_count = 2;
5585 }
5586 else
5587 {
5588 include_dir_count++;
041ff4dd
NC		 5589 include_dirs =
5590 (char **) realloc (include_dirs,
5591 include_dir_count * sizeof (*include_dirs));
252b5132
RH		 5592 }
5593
041ff4dd 5594 include_dirs[include_dir_count - 1] = path; /* New one. */
252b5132
RH		 5595
5596 i = strlen (path);
5597 if (i > include_dir_maxlen)
5598 include_dir_maxlen = i;
041ff4dd 5599}
252b5132
RH		 5600\f
5601/* Output debugging information to denote the source file. */
5602
5603static void
39e6acbd 5604generate_file_debug (void)
252b5132
RH		 5605{
5606 if (debug_type == DEBUG_STABS)
5607 stabs_generate_asm_file ();
5608}
5609
5610/* Output line number debugging information for the current source line. */
5611
5612void
39e6acbd 5613generate_lineno_debug (void)
252b5132 5614{
252b5132
RH		 5615 switch (debug_type)
5616 {
5617 case DEBUG_UNSPECIFIED:
5618 case DEBUG_NONE:
4dc7ead9 5619 case DEBUG_DWARF:
252b5132
RH		 5620 break;
5621 case DEBUG_STABS:
5622 stabs_generate_asm_lineno ();
5623 break;
5624 case DEBUG_ECOFF:
5625 ecoff_generate_asm_lineno ();
5626 break;
252b5132 5627 case DEBUG_DWARF2:
4dc7ead9
RH		 5628 /* ??? We could here indicate to dwarf2dbg.c that something
5629 has changed. However, since there is additional backend
5630 support that is required (calling dwarf2_emit_insn), we
5631 let dwarf2dbg.c call as_where on its own. */
252b5132
RH		 5632 break;
5633 }
5634}
5635
5636/* Output debugging information to mark a function entry point or end point.
5637 END_P is zero for .func, and non-zero for .endfunc. */
5638
5639void
39e6acbd 5640s_func (int end_p)
252b5132
RH		 5641{
5642 do_s_func (end_p, NULL);
5643}
5644
5645/* Subroutine of s_func so targets can choose a different default prefix.
5646 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5647
87c245cc 5648static void
39e6acbd 5649do_s_func (int end_p, const char *default_prefix)
252b5132
RH		 5650{
5651 /* Record the current function so that we can issue an error message for
5652 misplaced .func,.endfunc, and also so that .endfunc needs no
5653 arguments. */
5654 static char *current_name;
5655 static char *current_label;
5656
5657 if (end_p)
5658 {
5659 if (current_name == NULL)
5660 {
5661 as_bad (_("missing .func"));
5662 ignore_rest_of_line ();
5663 return;
5664 }
5665
5666 if (debug_type == DEBUG_STABS)
5667 stabs_generate_asm_endfunc (current_name, current_label);
5668
5669 current_name = current_label = NULL;
5670 }
5671 else /* ! end_p */
5672 {
041ff4dd
NC		 5673 char *name, *label;
5674 char delim1, delim2;
252b5132
RH		 5675
5676 if (current_name != NULL)
5677 {
5678 as_bad (_(".endfunc missing for previous .func"));
5679 ignore_rest_of_line ();
5680 return;
5681 }
5682
5683 name = input_line_pointer;
5684 delim1 = get_symbol_end ();
5685 name = xstrdup (name);
5686 *input_line_pointer = delim1;
5687 SKIP_WHITESPACE ();
5688 if (*input_line_pointer != ',')
5689 {
5690 if (default_prefix)
05f4ab67
AM		 5691 {
5692 if (asprintf (&label, "%s%s", default_prefix, name) == -1)
5693 as_fatal ("%s", xstrerror (errno));
5694 }
252b5132
RH		 5695 else
5696 {
7be1c489 5697 char leading_char = bfd_get_symbol_leading_char (stdoutput);
252b5132
RH		 5698 /* Missing entry point, use function's name with the leading
5699 char prepended. */
5700 if (leading_char)
05f4ab67
AM		 5701 {
5702 if (asprintf (&label, "%c%s", leading_char, name) == -1)
5703 as_fatal ("%s", xstrerror (errno));
5704 }
252b5132
RH		 5705 else
5706 label = name;
5707 }
5708 }
5709 else
5710 {
5711 ++input_line_pointer;
5712 SKIP_WHITESPACE ();
5713 label = input_line_pointer;
5714 delim2 = get_symbol_end ();
5715 label = xstrdup (label);
5716 *input_line_pointer = delim2;
5717 }
5718
5719 if (debug_type == DEBUG_STABS)
5720 stabs_generate_asm_func (name, label);
5721
5722 current_name = name;
5723 current_label = label;
5724 }
5725
5726 demand_empty_rest_of_line ();
5727}
5728\f
041ff4dd 5729void
39e6acbd 5730s_ignore (int arg ATTRIBUTE_UNUSED)
252b5132 5731{
40a4d956 5732 ignore_rest_of_line ();
252b5132
RH		 5733}
5734
252b5132 5735void
39e6acbd 5736read_print_statistics (FILE *file)
252b5132
RH		 5737{
5738 hash_print_statistics (file, "pseudo-op table", po_hash);
5739}
5740
041ff4dd
NC		 5741/* Inserts the given line into the input stream.
5742
9f10757c
TW		 5743 This call avoids macro/conditionals nesting checking, since the contents of
5744 the line are assumed to replace the contents of a line already scanned.
5745
47eebc20 5746 An appropriate use of this function would be substitution of input lines when
9f10757c
TW		 5747 called by md_start_line_hook(). The given line is assumed to already be
5748 properly scrubbed. */
5749
5750void
39e6acbd 5751input_scrub_insert_line (const char *line)
9f10757c
TW		 5752{
5753 sb newline;
5754 sb_new (&newline);
5755 sb_add_string (&newline, line);
5756 input_scrub_include_sb (&newline, input_line_pointer, 0);
5757 sb_kill (&newline);
5758 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5759}
5760
5761/* Insert a file into the input stream; the path must resolve to an actual
041ff4dd 5762 file; no include path searching or dependency registering is performed. */
9f10757c
TW		 5763
5764void
39e6acbd 5765input_scrub_insert_file (char *path)
9f10757c
TW		 5766{
5767 input_scrub_include_file (path, input_line_pointer);
5768 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5769}
40a4d956
JB		 5770
5771/* Find the end of a line, considering quotation and escaping of quotes. */
5772
5773#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
5774# define TC_SINGLE_QUOTE_STRINGS 1
5775#endif
5776
5777static char *
5778_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
5779{
5780 char inquote = '\0';
5781 int inescape = 0;
5782
5783 while (!is_end_of_line[(unsigned char) *s]
5784 || (inquote && !ISCNTRL (*s))
5785 || (inquote == '\'' && flag_mri)
5786#ifdef TC_EOL_IN_INSN
5787 || (insn && TC_EOL_IN_INSN (s))
5788#endif
5789 )
5790 {
5791 if (mri_string && *s == '\'')
5792 inquote ^= *s;
5793 else if (inescape)
5794 inescape = 0;
5795 else if (*s == '\\')
5796 inescape = 1;
5797 else if (!inquote
5798 ? *s == '"'
5799#ifdef TC_SINGLE_QUOTE_STRINGS
5800 || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
5801#endif
5802 : *s == inquote)
5803 inquote ^= *s;
5804 ++s;
5805 }
5806 if (inquote)
5807 as_warn (_("missing closing `%c'"), inquote);
5808 if (inescape)
5809 as_warn (_("stray `\\'"));
5810 return s;
5811}
5812
5813char *
5814find_end_of_line (char *s, int mri_string)
5815{
5816 return _find_end_of_line (s, mri_string, 0);
5817}
GDB Binutils - Deliverables
This page took 0.736938 seconds and 4 git commands to generate.