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