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