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