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