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