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