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