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