projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/tc-cris.c (SIMPLE_EXPR): New macro.
[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,
70658493 3 1998, 1999, 2000, 2001, 2002 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
a6bd2a4f 1200 just_record_alignment: ATTRIBUTE_UNUSED_LABEL
252b5132
RH		 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
252b5132 3235 && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
2b47531b
ILT		 3236 && (symbol_get_frag (exp.X_add_symbol)
3237 == symbol_get_frag (exp.X_op_symbol)))
252b5132
RH		 3238 {
3239 exp.X_op = O_constant;
3240 exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
3241 - S_GET_VALUE (exp.X_op_symbol));
3242 }
3243
3244 switch (exp.X_op)
3245 {
3246 case O_illegal:
3247 case O_absent:
3248 case O_big:
3249 exp.X_add_number = 0;
3250 /* Fall through. */
3251 case O_constant:
3252 S_SET_SEGMENT (symbolP, absolute_section);
3253#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3254 if (ext)
3255 S_SET_EXTERNAL (symbolP);
3256 else
3257 S_CLEAR_EXTERNAL (symbolP);
3258#endif /* OBJ_AOUT or OBJ_BOUT */
3259 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
3260 if (exp.X_op != O_constant)
041ff4dd 3261 symbol_set_frag (symbolP, &zero_address_frag);
252b5132
RH		 3262 break;
3263
3264 case O_register:
3265 S_SET_SEGMENT (symbolP, reg_section);
3266 S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2b47531b 3267 symbol_set_frag (symbolP, &zero_address_frag);
252b5132
RH		 3268 break;
3269
3270 case O_symbol:
3271 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
3272 || exp.X_add_number != 0)
2b47531b 3273 symbol_set_value_expression (symbolP, &exp);
53b0d397 3274 else if (symbol_section_p (symbolP))
0e389e77 3275 as_bad ("attempt to set value of section symbol");
252b5132
RH		 3276 else
3277 {
3278 symbolS *s = exp.X_add_symbol;
3279
3280 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
3281#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
3282 if (ext)
3283 S_SET_EXTERNAL (symbolP);
3284 else
3285 S_CLEAR_EXTERNAL (symbolP);
3286#endif /* OBJ_AOUT or OBJ_BOUT */
3287 S_SET_VALUE (symbolP,
3288 exp.X_add_number + S_GET_VALUE (s));
2b47531b 3289 symbol_set_frag (symbolP, symbol_get_frag (s));
252b5132
RH		 3290 copy_symbol_attributes (symbolP, s);
3291 }
3292 break;
3293
3294 default:
ce34c373
AM		 3295 /* The value is some complex expression.
3296 FIXME: Should we set the segment to anything? */
2b47531b 3297 symbol_set_value_expression (symbolP, &exp);
252b5132
RH		 3298 break;
3299 }
3300}
3301\f
041ff4dd 3302/* cons()
f0e652b4 3303
041ff4dd
NC		 3304 CONStruct more frag of .bytes, or .words etc.
3305 Should need_pass_2 be 1 then emit no frag(s).
3306 This understands EXPRESSIONS.
f0e652b4 3307
041ff4dd 3308 Bug (?)
f0e652b4 3309
041ff4dd
NC		 3310 This has a split personality. We use expression() to read the
3311 value. We can detect if the value won't fit in a byte or word.
3312 But we can't detect if expression() discarded significant digits
3313 in the case of a long. Not worth the crocks required to fix it. */
252b5132
RH		 3314
3315/* Select a parser for cons expressions. */
3316
3317/* Some targets need to parse the expression in various fancy ways.
3318 You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
3319 (for example, the HPPA does this). Otherwise, you can define
3320 BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
3321 REPEAT_CONS_EXPRESSIONS to permit repeat counts. If none of these
3322 are defined, which is the normal case, then only simple expressions
3323 are permitted. */
3324
abd63a32 3325#ifdef TC_M68K
252b5132
RH		 3326static void
3327parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
abd63a32 3328#endif
252b5132
RH		 3329
3330#ifndef TC_PARSE_CONS_EXPRESSION
3331#ifdef BITFIELD_CONS_EXPRESSIONS
3332#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
041ff4dd 3333static void
252b5132
RH		 3334parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3335#endif
3336#ifdef REPEAT_CONS_EXPRESSIONS
3337#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
3338static void
3339parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
3340#endif
3341
3342/* If we haven't gotten one yet, just call expression. */
3343#ifndef TC_PARSE_CONS_EXPRESSION
3344#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
3345#endif
3346#endif
3347
041ff4dd
NC		 3348/* Worker to do .byte etc statements.
3349 Clobbers input_line_pointer and checks end-of-line. */
3350
3351static void
252b5132 3352cons_worker (nbytes, rva)
041ff4dd 3353 register int nbytes; /* 1=.byte, 2=.word, 4=.long. */
252b5132
RH		 3354 int rva;
3355{
3356 int c;
3357 expressionS exp;
3358 char *stop = NULL;
3359 char stopc;
3360
3361#ifdef md_flush_pending_output
3362 md_flush_pending_output ();
3363#endif
3364
3365 if (flag_mri)
3366 stop = mri_comment_field (&stopc);
3367
3368 if (is_it_end_of_statement ())
3369 {
3370 demand_empty_rest_of_line ();
3371 if (flag_mri)
3372 mri_comment_end (stop, stopc);
3373 return;
3374 }
3375
3376#ifdef md_cons_align
3377 md_cons_align (nbytes);
3378#endif
3379
3380 c = 0;
3381 do
3382 {
abd63a32 3383#ifdef TC_M68K
252b5132
RH		 3384 if (flag_m68k_mri)
3385 parse_mri_cons (&exp, (unsigned int) nbytes);
3386 else
abd63a32 3387#endif
252b5132
RH		 3388 TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
3389
3390 if (rva)
3391 {
3392 if (exp.X_op == O_symbol)
3393 exp.X_op = O_symbol_rva;
3394 else
3395 as_fatal (_("rva without symbol"));
3396 }
3397 emit_expr (&exp, (unsigned int) nbytes);
3398 ++c;
3399 }
3400 while (*input_line_pointer++ == ',');
3401
3402 /* In MRI mode, after an odd number of bytes, we must align to an
3403 even word boundary, unless the next instruction is a dc.b, ds.b
3404 or dcb.b. */
3405 if (flag_mri && nbytes == 1 && (c & 1) != 0)
3406 mri_pending_align = 1;
3407
041ff4dd 3408 input_line_pointer--; /* Put terminator back into stream. */
252b5132
RH		 3409
3410 demand_empty_rest_of_line ();
3411
3412 if (flag_mri)
3413 mri_comment_end (stop, stopc);
3414}
3415
252b5132
RH		 3416void
3417cons (size)
3418 int size;
3419{
3420 cons_worker (size, 0);
3421}
3422
041ff4dd 3423void
252b5132
RH		 3424s_rva (size)
3425 int size;
3426{
3427 cons_worker (size, 1);
3428}
3429
3430/* Put the contents of expression EXP into the object file using
3431 NBYTES bytes. If need_pass_2 is 1, this does nothing. */
3432
3433void
3434emit_expr (exp, nbytes)
3435 expressionS *exp;
3436 unsigned int nbytes;
3437{
3438 operatorT op;
3439 register char *p;
3440 valueT extra_digit = 0;
3441
3442 /* Don't do anything if we are going to make another pass. */
3443 if (need_pass_2)
3444 return;
3445
3446#ifndef NO_LISTING
3447#ifdef OBJ_ELF
3448 /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
3449 appear as a four byte positive constant in the .line section,
3450 followed by a 2 byte 0xffff. Look for that case here. */
3451 {
3452 static int dwarf_line = -1;
3453
3454 if (strcmp (segment_name (now_seg), ".line") != 0)
3455 dwarf_line = -1;
3456 else if (dwarf_line >= 0
3457 && nbytes == 2
3458 && exp->X_op == O_constant
3459 && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
3460 listing_source_line ((unsigned int) dwarf_line);
3461 else if (nbytes == 4
3462 && exp->X_op == O_constant
3463 && exp->X_add_number >= 0)
3464 dwarf_line = exp->X_add_number;
3465 else
3466 dwarf_line = -1;
3467 }
3468
3469 /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
3470 appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
3471 AT_sibling (0x12) followed by a four byte address of the sibling
3472 followed by a 2 byte AT_name (0x38) followed by the name of the
3473 file. We look for that case here. */
3474 {
3475 static int dwarf_file = 0;
3476
3477 if (strcmp (segment_name (now_seg), ".debug") != 0)
3478 dwarf_file = 0;
3479 else if (dwarf_file == 0
3480 && nbytes == 2
3481 && exp->X_op == O_constant
3482 && exp->X_add_number == 0x11)
3483 dwarf_file = 1;
3484 else if (dwarf_file == 1
3485 && nbytes == 2
3486 && exp->X_op == O_constant
3487 && exp->X_add_number == 0x12)
3488 dwarf_file = 2;
3489 else if (dwarf_file == 2
3490 && nbytes == 4)
3491 dwarf_file = 3;
3492 else if (dwarf_file == 3
3493 && nbytes == 2
3494 && exp->X_op == O_constant
3495 && exp->X_add_number == 0x38)
3496 dwarf_file = 4;
3497 else
3498 dwarf_file = 0;
3499
3500 /* The variable dwarf_file_string tells stringer that the string
3501 may be the name of the source file. */
3502 if (dwarf_file == 4)
3503 dwarf_file_string = 1;
3504 else
3505 dwarf_file_string = 0;
3506 }
3507#endif
3508#endif
3509
3510 if (check_eh_frame (exp, &nbytes))
3511 return;
3512
3513 op = exp->X_op;
3514
3515 /* Allow `.word 0' in the absolute section. */
3516 if (now_seg == absolute_section)
3517 {
3518 if (op != O_constant || exp->X_add_number != 0)
3519 as_bad (_("attempt to store value in absolute section"));
3520 abs_section_offset += nbytes;
3521 return;
3522 }
3523
3524 /* Handle a negative bignum. */
3525 if (op == O_uminus
3526 && exp->X_add_number == 0
2b47531b
ILT		 3527 && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
3528 && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
252b5132
RH		 3529 {
3530 int i;
3531 unsigned long carry;
3532
2b47531b 3533 exp = symbol_get_value_expression (exp->X_add_symbol);
252b5132
RH		 3534
3535 /* Negate the bignum: one's complement each digit and add 1. */
3536 carry = 1;
3537 for (i = 0; i < exp->X_add_number; i++)
3538 {
3539 unsigned long next;
3540
041ff4dd 3541 next = (((~(generic_bignum[i] & LITTLENUM_MASK))
252b5132
RH		 3542 & LITTLENUM_MASK)
3543 + carry);
3544 generic_bignum[i] = next & LITTLENUM_MASK;
3545 carry = next >> LITTLENUM_NUMBER_OF_BITS;
3546 }
3547
3548 /* We can ignore any carry out, because it will be handled by
3549 extra_digit if it is needed. */
3550
3551 extra_digit = (valueT) -1;
3552 op = O_big;
3553 }
3554
3555 if (op == O_absent || op == O_illegal)
3556 {
3557 as_warn (_("zero assumed for missing expression"));
3558 exp->X_add_number = 0;
3559 op = O_constant;
3560 }
3561 else if (op == O_big && exp->X_add_number <= 0)
3562 {
0e389e77 3563 as_bad (_("floating point number invalid"));
252b5132
RH		 3564 exp->X_add_number = 0;
3565 op = O_constant;
3566 }
3567 else if (op == O_register)
3568 {
3569 as_warn (_("register value used as expression"));
3570 op = O_constant;
3571 }
3572
3573 p = frag_more ((int) nbytes);
3574
3575#ifndef WORKING_DOT_WORD
3576 /* If we have the difference of two symbols in a word, save it on
3577 the broken_words list. See the code in write.c. */
3578 if (op == O_subtract && nbytes == 2)
3579 {
3580 struct broken_word *x;
3581
3582 x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3583 x->next_broken_word = broken_words;
3584 broken_words = x;
3585 x->seg = now_seg;
3586 x->subseg = now_subseg;
3587 x->frag = frag_now;
3588 x->word_goes_here = p;
3589 x->dispfrag = 0;
3590 x->add = exp->X_add_symbol;
3591 x->sub = exp->X_op_symbol;
3592 x->addnum = exp->X_add_number;
3593 x->added = 0;
3594 new_broken_words++;
3595 return;
3596 }
3597#endif
3598
3599 /* If we have an integer, but the number of bytes is too large to
3600 pass to md_number_to_chars, handle it as a bignum. */
3601 if (op == O_constant && nbytes > sizeof (valueT))
3602 {
3603 valueT val;
3604 int gencnt;
3605
041ff4dd 3606 if (!exp->X_unsigned && exp->X_add_number < 0)
252b5132
RH		 3607 extra_digit = (valueT) -1;
3608 val = (valueT) exp->X_add_number;
3609 gencnt = 0;
3610 do
3611 {
3612 generic_bignum[gencnt] = val & LITTLENUM_MASK;
3613 val >>= LITTLENUM_NUMBER_OF_BITS;
3614 ++gencnt;
3615 }
3616 while (val != 0);
3617 op = exp->X_op = O_big;
3618 exp->X_add_number = gencnt;
3619 }
3620
3621 if (op == O_constant)
3622 {
3623 register valueT get;
3624 register valueT use;
3625 register valueT mask;
3626 valueT hibit;
3627 register valueT unmask;
3628
3629 /* JF << of >= number of bits in the object is undefined. In
041ff4dd 3630 particular SPARC (Sun 4) has problems. */
252b5132
RH		 3631 if (nbytes >= sizeof (valueT))
3632 {
3633 mask = 0;
3634 if (nbytes > sizeof (valueT))
3635 hibit = 0;
3636 else
3637 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3638 }
3639 else
3640 {
041ff4dd 3641 /* Don't store these bits. */
252b5132
RH		 3642 mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
3643 hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
3644 }
3645
041ff4dd 3646 unmask = ~mask; /* Do store these bits. */
252b5132
RH		 3647
3648#ifdef NEVER
3649 "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
041ff4dd 3650 mask = ~(unmask >> 1); /* Includes sign bit now. */
252b5132
RH		 3651#endif
3652
3653 get = exp->X_add_number;
3654 use = get & unmask;
3655 if ((get & mask) != 0
3656 && ((get & mask) != mask
3657 || (get & hibit) == 0))
041ff4dd 3658 { /* Leading bits contain both 0s & 1s. */
0e389e77 3659 as_warn (_("value 0x%lx truncated to 0x%lx"),
252b5132
RH		 3660 (unsigned long) get, (unsigned long) use);
3661 }
041ff4dd 3662 /* Put bytes in right order. */
252b5132
RH		 3663 md_number_to_chars (p, use, (int) nbytes);
3664 }
3665 else if (op == O_big)
3666 {
3667 unsigned int size;
3668 LITTLENUM_TYPE *nums;
3669
3670 know (nbytes % CHARS_PER_LITTLENUM == 0);
3671
3672 size = exp->X_add_number * CHARS_PER_LITTLENUM;
3673 if (nbytes < size)
3674 {
0e389e77 3675 as_warn (_("bignum truncated to %d bytes"), nbytes);
252b5132
RH		 3676 size = nbytes;
3677 }
3678
3679 if (target_big_endian)
3680 {
3681 while (nbytes > size)
3682 {
3683 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3684 nbytes -= CHARS_PER_LITTLENUM;
3685 p += CHARS_PER_LITTLENUM;
3686 }
3687
3688 nums = generic_bignum + size / CHARS_PER_LITTLENUM;
ceac3f62 3689 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 3690 {
3691 --nums;
3692 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3693 size -= CHARS_PER_LITTLENUM;
3694 p += CHARS_PER_LITTLENUM;
3695 }
3696 }
3697 else
3698 {
3699 nums = generic_bignum;
ceac3f62 3700 while (size >= CHARS_PER_LITTLENUM)
252b5132
RH		 3701 {
3702 md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3703 ++nums;
3704 size -= CHARS_PER_LITTLENUM;
3705 p += CHARS_PER_LITTLENUM;
3706 nbytes -= CHARS_PER_LITTLENUM;
3707 }
3708
ceac3f62 3709 while (nbytes >= CHARS_PER_LITTLENUM)
252b5132
RH		 3710 {
3711 md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3712 nbytes -= CHARS_PER_LITTLENUM;
3713 p += CHARS_PER_LITTLENUM;
3714 }
3715 }
3716 }
3717 else
3718 {
3719 memset (p, 0, nbytes);
3720
3721 /* Now we need to generate a fixS to record the symbol value.
3722 This is easy for BFD. For other targets it can be more
3723 complex. For very complex cases (currently, the HPPA and
3724 NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3725 want. For simpler cases, you can define TC_CONS_RELOC to be
3726 the name of the reloc code that should be stored in the fixS.
3727 If neither is defined, the code uses NO_RELOC if it is
3728 defined, and otherwise uses 0. */
3729
3730#ifdef BFD_ASSEMBLER
3731#ifdef TC_CONS_FIX_NEW
3732 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3733#else
3734 {
3735 bfd_reloc_code_real_type r;
3736
3737 switch (nbytes)
3738 {
3739 case 1:
3740 r = BFD_RELOC_8;
3741 break;
3742 case 2:
3743 r = BFD_RELOC_16;
3744 break;
3745 case 4:
3746 r = BFD_RELOC_32;
3747 break;
3748 case 8:
3749 r = BFD_RELOC_64;
3750 break;
3751 default:
3752 as_bad (_("unsupported BFD relocation size %u"), nbytes);
3753 r = BFD_RELOC_32;
3754 break;
3755 }
3756 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
3757 0, r);
3758 }
3759#endif
3760#else
3761#ifdef TC_CONS_FIX_NEW
3762 TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3763#else
3764 /* Figure out which reloc number to use. Use TC_CONS_RELOC if
3765 it is defined, otherwise use NO_RELOC if it is defined,
3766 otherwise use 0. */
3767#ifndef TC_CONS_RELOC
3768#ifdef NO_RELOC
3769#define TC_CONS_RELOC NO_RELOC
3770#else
3771#define TC_CONS_RELOC 0
3772#endif
3773#endif
3774 fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3775 TC_CONS_RELOC);
3776#endif /* TC_CONS_FIX_NEW */
3777#endif /* BFD_ASSEMBLER */
3778 }
3779}
3780\f
3781#ifdef BITFIELD_CONS_EXPRESSIONS
3782
3783/* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3784 w:x,y:z, where w and y are bitwidths and x and y are values. They
3785 then pack them all together. We do a little better in that we allow
3786 them in words, longs, etc. and we'll pack them in target byte order
3787 for you.
3788
3789 The rules are: pack least significat bit first, if a field doesn't
3790 entirely fit, put it in the next unit. Overflowing the bitfield is
3791 explicitly *not* even a warning. The bitwidth should be considered
3792 a "mask".
3793
3794 To use this function the tc-XXX.h file should define
3795 BITFIELD_CONS_EXPRESSIONS. */
3796
041ff4dd 3797static void
252b5132
RH		 3798parse_bitfield_cons (exp, nbytes)
3799 expressionS *exp;
3800 unsigned int nbytes;
3801{
3802 unsigned int bits_available = BITS_PER_CHAR * nbytes;
3803 char *hold = input_line_pointer;
3804
3805 (void) expression (exp);
3806
3807 if (*input_line_pointer == ':')
041ff4dd
NC		 3808 {
3809 /* Bitfields. */
252b5132
RH		 3810 long value = 0;
3811
3812 for (;;)
3813 {
3814 unsigned long width;
3815
3816 if (*input_line_pointer != ':')
3817 {
3818 input_line_pointer = hold;
3819 break;
041ff4dd 3820 } /* Next piece is not a bitfield. */
252b5132
RH		 3821
3822 /* In the general case, we can't allow
3823 full expressions with symbol
3824 differences and such. The relocation
3825 entries for symbols not defined in this
3826 assembly would require arbitrary field
3827 widths, positions, and masks which most
3828 of our current object formats don't
3829 support.
3830
3831 In the specific case where a symbol
3832 *is* defined in this assembly, we
3833 *could* build fixups and track it, but
3834 this could lead to confusion for the
3835 backends. I'm lazy. I'll take any
3836 SEG_ABSOLUTE. I think that means that
3837 you can use a previous .set or
041ff4dd 3838 .equ type symbol. xoxorich. */
252b5132
RH		 3839
3840 if (exp->X_op == O_absent)
3841 {
3842 as_warn (_("using a bit field width of zero"));
3843 exp->X_add_number = 0;
3844 exp->X_op = O_constant;
041ff4dd 3845 } /* Implied zero width bitfield. */
252b5132
RH		 3846
3847 if (exp->X_op != O_constant)
3848 {
3849 *input_line_pointer = '\0';
3850 as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
3851 *input_line_pointer = ':';
3852 demand_empty_rest_of_line ();
3853 return;
041ff4dd 3854 } /* Too complex. */
252b5132
RH		 3855
3856 if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3857 {
3858 as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
3859 width, nbytes, (BITS_PER_CHAR * nbytes));
3860 width = BITS_PER_CHAR * nbytes;
041ff4dd 3861 } /* Too big. */
252b5132
RH		 3862
3863 if (width > bits_available)
3864 {
3865 /* FIXME-SOMEDAY: backing up and reparsing is wasteful. */
3866 input_line_pointer = hold;
3867 exp->X_add_number = value;
3868 break;
041ff4dd 3869 } /* Won't fit. */
252b5132 3870
ef99799a
KH		 3871 /* Skip ':'. */
3872 hold = ++input_line_pointer;
252b5132
RH		 3873
3874 (void) expression (exp);
3875 if (exp->X_op != O_constant)
3876 {
3877 char cache = *input_line_pointer;
3878
3879 *input_line_pointer = '\0';
3880 as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
3881 *input_line_pointer = cache;
3882 demand_empty_rest_of_line ();
3883 return;
041ff4dd 3884 } /* Too complex. */
252b5132
RH		 3885
3886 value |= ((~(-1 << width) & exp->X_add_number)
3887 << ((BITS_PER_CHAR * nbytes) - bits_available));
3888
3889 if ((bits_available -= width) == 0
3890 || is_it_end_of_statement ()
3891 || *input_line_pointer != ',')
3892 {
3893 break;
041ff4dd 3894 } /* All the bitfields we're gonna get. */
252b5132
RH		 3895
3896 hold = ++input_line_pointer;
3897 (void) expression (exp);
041ff4dd 3898 }
252b5132
RH		 3899
3900 exp->X_add_number = value;
3901 exp->X_op = O_constant;
3902 exp->X_unsigned = 1;
041ff4dd
NC		 3903 }
3904}
252b5132
RH		 3905
3906#endif /* BITFIELD_CONS_EXPRESSIONS */
3907\f
3908/* Handle an MRI style string expression. */
3909
abd63a32 3910#ifdef TC_M68K
252b5132
RH		 3911static void
3912parse_mri_cons (exp, nbytes)
3913 expressionS *exp;
3914 unsigned int nbytes;
3915{
3916 if (*input_line_pointer != '\''
3917 && (input_line_pointer[1] != '\''
3918 || (*input_line_pointer != 'A'
3919 && *input_line_pointer != 'E')))
3920 TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3921 else
3922 {
3923 unsigned int scan;
3924 unsigned int result = 0;
3925
3926 /* An MRI style string. Cut into as many bytes as will fit into
3927 a nbyte chunk, left justify if necessary, and separate with
3928 commas so we can try again later. */
3929 if (*input_line_pointer == 'A')
3930 ++input_line_pointer;
3931 else if (*input_line_pointer == 'E')
3932 {
3933 as_bad (_("EBCDIC constants are not supported"));
3934 ++input_line_pointer;
3935 }
3936
3937 input_line_pointer++;
3938 for (scan = 0; scan < nbytes; scan++)
3939 {
3940 if (*input_line_pointer == '\'')
3941 {
3942 if (input_line_pointer[1] == '\'')
3943 {
3944 input_line_pointer++;
3945 }
3946 else
3947 break;
3948 }
3949 result = (result << 8) | (*input_line_pointer++);
3950 }
3951
041ff4dd 3952 /* Left justify. */
252b5132
RH		 3953 while (scan < nbytes)
3954 {
3955 result <<= 8;
3956 scan++;
3957 }
f0e652b4 3958
041ff4dd 3959 /* Create correct expression. */
252b5132
RH		 3960 exp->X_op = O_constant;
3961 exp->X_add_number = result;
f0e652b4 3962
041ff4dd 3963 /* Fake it so that we can read the next char too. */
252b5132
RH		 3964 if (input_line_pointer[0] != '\'' ||
3965 (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3966 {
3967 input_line_pointer -= 2;
3968 input_line_pointer[0] = ',';
3969 input_line_pointer[1] = '\'';
3970 }
3971 else
3972 input_line_pointer++;
3973 }
3974}
abd63a32 3975#endif /* TC_M68K */
252b5132
RH		 3976\f
3977#ifdef REPEAT_CONS_EXPRESSIONS
3978
3979/* Parse a repeat expression for cons. This is used by the MIPS
3980 assembler. The format is NUMBER:COUNT; NUMBER appears in the
3981 object file COUNT times.
3982
3983 To use this for a target, define REPEAT_CONS_EXPRESSIONS. */
3984
3985static void
3986parse_repeat_cons (exp, nbytes)
3987 expressionS *exp;
3988 unsigned int nbytes;
3989{
3990 expressionS count;
3991 register int i;
3992
3993 expression (exp);
3994
3995 if (*input_line_pointer != ':')
3996 {
3997 /* No repeat count. */
3998 return;
3999 }
4000
4001 ++input_line_pointer;
4002 expression (&count);
4003 if (count.X_op != O_constant
4004 || count.X_add_number <= 0)
4005 {
0e389e77 4006 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4007 return;
4008 }
4009
4010 /* The cons function is going to output this expression once. So we
4011 output it count - 1 times. */
4012 for (i = count.X_add_number - 1; i > 0; i--)
4013 emit_expr (exp, nbytes);
4014}
4015
4016#endif /* REPEAT_CONS_EXPRESSIONS */
4017\f
4018/* Parse a floating point number represented as a hex constant. This
4019 permits users to specify the exact bits they want in the floating
4020 point number. */
4021
4022static int
4023hex_float (float_type, bytes)
4024 int float_type;
4025 char *bytes;
4026{
4027 int length;
4028 int i;
4029
4030 switch (float_type)
4031 {
4032 case 'f':
4033 case 'F':
4034 case 's':
4035 case 'S':
4036 length = 4;
4037 break;
4038
4039 case 'd':
4040 case 'D':
4041 case 'r':
4042 case 'R':
4043 length = 8;
4044 break;
4045
4046 case 'x':
4047 case 'X':
4048 length = 12;
4049 break;
4050
4051 case 'p':
4052 case 'P':
4053 length = 12;
4054 break;
4055
4056 default:
0e389e77 4057 as_bad (_("unknown floating type type '%c'"), float_type);
252b5132
RH		 4058 return -1;
4059 }
4060
4061 /* It would be nice if we could go through expression to parse the
4062 hex constant, but if we get a bignum it's a pain to sort it into
4063 the buffer correctly. */
4064 i = 0;
4065 while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
4066 {
4067 int d;
4068
4069 /* The MRI assembler accepts arbitrary underscores strewn about
041ff4dd 4070 through the hex constant, so we ignore them as well. */
252b5132
RH		 4071 if (*input_line_pointer == '_')
4072 {
4073 ++input_line_pointer;
4074 continue;
4075 }
4076
4077 if (i >= length)
4078 {
0e389e77 4079 as_warn (_("floating point constant too large"));
252b5132
RH		 4080 return -1;
4081 }
4082 d = hex_value (*input_line_pointer) << 4;
4083 ++input_line_pointer;
4084 while (*input_line_pointer == '_')
4085 ++input_line_pointer;
4086 if (hex_p (*input_line_pointer))
4087 {
4088 d += hex_value (*input_line_pointer);
4089 ++input_line_pointer;
4090 }
4091 if (target_big_endian)
4092 bytes[i] = d;
4093 else
4094 bytes[length - i - 1] = d;
4095 ++i;
4096 }
4097
4098 if (i < length)
4099 {
4100 if (target_big_endian)
4101 memset (bytes + i, 0, length - i);
4102 else
4103 memset (bytes, 0, length - i);
4104 }
4105
4106 return length;
4107}
4108
041ff4dd 4109/* float_cons()
f0e652b4 4110
041ff4dd
NC		 4111 CONStruct some more frag chars of .floats .ffloats etc.
4112 Makes 0 or more new frags.
4113 If need_pass_2 == 1, no frags are emitted.
4114 This understands only floating literals, not expressions. Sorry.
f0e652b4 4115
041ff4dd
NC		 4116 A floating constant is defined by atof_generic(), except it is preceded
4117 by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
4118 reading, I decided to be incompatible. This always tries to give you
4119 rounded bits to the precision of the pseudo-op. Former AS did premature
4120 truncatation, restored noisy bits instead of trailing 0s AND gave you
4121 a choice of 2 flavours of noise according to which of 2 floating-point
4122 scanners you directed AS to use.
f0e652b4 4123
041ff4dd 4124 In: input_line_pointer->whitespace before, or '0' of flonum. */
252b5132
RH		 4125
4126void
4127float_cons (float_type)
041ff4dd
NC		 4128 /* Clobbers input_line-pointer, checks end-of-line. */
4129 register int float_type; /* 'f':.ffloat ... 'F':.float ... */
252b5132
RH		 4130{
4131 register char *p;
041ff4dd
NC		 4132 int length; /* Number of chars in an object. */
4133 register char *err; /* Error from scanning floating literal. */
252b5132
RH		 4134 char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
4135
4136 if (is_it_end_of_statement ())
4137 {
4138 demand_empty_rest_of_line ();
4139 return;
4140 }
4141
4142#ifdef md_flush_pending_output
4143 md_flush_pending_output ();
4144#endif
4145
4146 do
4147 {
041ff4dd 4148 /* input_line_pointer->1st char of a flonum (we hope!). */
252b5132
RH		 4149 SKIP_WHITESPACE ();
4150
4151 /* Skip any 0{letter} that may be present. Don't even check if the
041ff4dd
NC		 4152 letter is legal. Someone may invent a "z" format and this routine
4153 has no use for such information. Lusers beware: you get
4154 diagnostics if your input is ill-conditioned. */
252b5132 4155 if (input_line_pointer[0] == '0'
3882b010 4156 && ISALPHA (input_line_pointer[1]))
252b5132
RH		 4157 input_line_pointer += 2;
4158
4159 /* Accept :xxxx, where the x's are hex digits, for a floating
4160 point with the exact digits specified. */
4161 if (input_line_pointer[0] == ':')
4162 {
4163 ++input_line_pointer;
4164 length = hex_float (float_type, temp);
4165 if (length < 0)
4166 {
4167 ignore_rest_of_line ();
4168 return;
4169 }
4170 }
4171 else
4172 {
4173 err = md_atof (float_type, temp, &length);
4174 know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
4175 know (length > 0);
4176 if (err)
4177 {
0e389e77 4178 as_bad (_("bad floating literal: %s"), err);
252b5132
RH		 4179 ignore_rest_of_line ();
4180 return;
4181 }
4182 }
4183
4184 if (!need_pass_2)
4185 {
4186 int count;
4187
4188 count = 1;
4189
4190#ifdef REPEAT_CONS_EXPRESSIONS
4191 if (*input_line_pointer == ':')
4192 {
4193 expressionS count_exp;
4194
4195 ++input_line_pointer;
4196 expression (&count_exp);
f0e652b4 4197
252b5132
RH		 4198 if (count_exp.X_op != O_constant
4199 || count_exp.X_add_number <= 0)
041ff4dd 4200 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
252b5132
RH		 4201 else
4202 count = count_exp.X_add_number;
4203 }
4204#endif
4205
4206 while (--count >= 0)
4207 {
4208 p = frag_more (length);
4209 memcpy (p, temp, (unsigned int) length);
4210 }
4211 }
4212 SKIP_WHITESPACE ();
4213 }
4214 while (*input_line_pointer++ == ',');
4215
041ff4dd
NC		 4216 /* Put terminator back into stream. */
4217 --input_line_pointer;
252b5132 4218 demand_empty_rest_of_line ();
041ff4dd 4219}
252b5132 4220\f
041ff4dd 4221/* Return the size of a LEB128 value. */
252b5132
RH		 4222
4223static inline int
4224sizeof_sleb128 (value)
4225 offsetT value;
4226{
4227 register int size = 0;
4228 register unsigned byte;
4229
4230 do
4231 {
4232 byte = (value & 0x7f);
4233 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4234 Fortunately, we can structure things so that the extra work reduces
4235 to a noop on systems that do things "properly". */
4236 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4237 size += 1;
4238 }
4239 while (!(((value == 0) && ((byte & 0x40) == 0))
4240 || ((value == -1) && ((byte & 0x40) != 0))));
4241
4242 return size;
4243}
4244
4245static inline int
4246sizeof_uleb128 (value)
4247 valueT value;
4248{
4249 register int size = 0;
4250 register unsigned byte;
4251
4252 do
4253 {
4254 byte = (value & 0x7f);
4255 value >>= 7;
4256 size += 1;
4257 }
4258 while (value != 0);
4259
4260 return size;
4261}
4262
4263int
4264sizeof_leb128 (value, sign)
4265 valueT value;
4266 int sign;
4267{
4268 if (sign)
4269 return sizeof_sleb128 ((offsetT) value);
4270 else
4271 return sizeof_uleb128 (value);
4272}
4273
4274/* Output a LEB128 value. */
4275
4276static inline int
4277output_sleb128 (p, value)
4278 char *p;
4279 offsetT value;
4280{
4281 register char *orig = p;
4282 register int more;
4283
4284 do
4285 {
4286 unsigned byte = (value & 0x7f);
4287
4288 /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
4289 Fortunately, we can structure things so that the extra work reduces
4290 to a noop on systems that do things "properly". */
4291 value = (value >> 7) | ~(-(offsetT)1 >> 7);
4292
4293 more = !((((value == 0) && ((byte & 0x40) == 0))
4294 || ((value == -1) && ((byte & 0x40) != 0))));
4295 if (more)
4296 byte |= 0x80;
4297
4298 *p++ = byte;
4299 }
4300 while (more);
4301
4302 return p - orig;
4303}
4304
4305static inline int
4306output_uleb128 (p, value)
4307 char *p;
4308 valueT value;
4309{
4310 char *orig = p;
4311
4312 do
4313 {
4314 unsigned byte = (value & 0x7f);
4315 value >>= 7;
4316 if (value != 0)
4317 /* More bytes to follow. */
4318 byte |= 0x80;
4319
4320 *p++ = byte;
4321 }
4322 while (value != 0);
4323
4324 return p - orig;
4325}
4326
4327int
4328output_leb128 (p, value, sign)
4329 char *p;
4330 valueT value;
4331 int sign;
4332{
4333 if (sign)
4334 return output_sleb128 (p, (offsetT) value);
4335 else
4336 return output_uleb128 (p, value);
4337}
4338
4339/* Do the same for bignums. We combine sizeof with output here in that
4340 we don't output for NULL values of P. It isn't really as critical as
4341 for "normal" values that this be streamlined. */
4342
6d4d30bb 4343static inline int
252b5132
RH		 4344output_big_sleb128 (p, bignum, size)
4345 char *p;
4346 LITTLENUM_TYPE *bignum;
4347 int size;
4348{
4349 char *orig = p;
4350 valueT val = 0;
4351 int loaded = 0;
4352 unsigned byte;
4353
4354 /* Strip leading sign extensions off the bignum. */
041ff4dd 4355 while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
252b5132
RH		 4356 size--;
4357
4358 do
4359 {
4360 if (loaded < 7 && size > 0)
4361 {
4362 val |= (*bignum << loaded);
4363 loaded += 8 * CHARS_PER_LITTLENUM;
4364 size--;
4365 bignum++;
4366 }
4367
4368 byte = val & 0x7f;
4369 loaded -= 7;
4370 val >>= 7;
4371
4372 if (size == 0)
4373 {
4374 if ((val == 0 && (byte & 0x40) == 0)
041ff4dd 4375 || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
252b5132
RH		 4376 && (byte & 0x40) != 0))
4377 byte |= 0x80;
4378 }
4379
4380 if (orig)
4381 *p = byte;
4382 p++;
4383 }
4384 while (byte & 0x80);
4385
4386 return p - orig;
4387}
4388
6d4d30bb 4389static inline int
252b5132
RH		 4390output_big_uleb128 (p, bignum, size)
4391 char *p;
4392 LITTLENUM_TYPE *bignum;
4393 int size;
4394{
4395 char *orig = p;
4396 valueT val = 0;
4397 int loaded = 0;
4398 unsigned byte;
4399
4400 /* Strip leading zeros off the bignum. */
4401 /* XXX: Is this needed? */
041ff4dd 4402 while (size > 0 && bignum[size - 1] == 0)
252b5132
RH		 4403 size--;
4404
4405 do
4406 {
4407 if (loaded < 7 && size > 0)
4408 {
4409 val |= (*bignum << loaded);
4410 loaded += 8 * CHARS_PER_LITTLENUM;
4411 size--;
4412 bignum++;
4413 }
4414
4415 byte = val & 0x7f;
4416 loaded -= 7;
4417 val >>= 7;
4418
4419 if (size > 0 || val)
4420 byte |= 0x80;
4421
4422 if (orig)
4423 *p = byte;
4424 p++;
4425 }
4426 while (byte & 0x80);
4427
4428 return p - orig;
4429}
4430
6d4d30bb 4431static int
252b5132
RH		 4432output_big_leb128 (p, bignum, size, sign)
4433 char *p;
4434 LITTLENUM_TYPE *bignum;
4435 int size, sign;
4436{
4437 if (sign)
4438 return output_big_sleb128 (p, bignum, size);
4439 else
4440 return output_big_uleb128 (p, bignum, size);
4441}
4442
4443/* Generate the appropriate fragments for a given expression to emit a
4444 leb128 value. */
4445
4446void
041ff4dd 4447emit_leb128_expr (exp, sign)
252b5132
RH		 4448 expressionS *exp;
4449 int sign;
4450{
4451 operatorT op = exp->X_op;
67a659f6 4452 int nbytes;
252b5132
RH		 4453
4454 if (op == O_absent || op == O_illegal)
4455 {
4456 as_warn (_("zero assumed for missing expression"));
4457 exp->X_add_number = 0;
4458 op = O_constant;
4459 }
4460 else if (op == O_big && exp->X_add_number <= 0)
4461 {
0e389e77 4462 as_bad (_("floating point number invalid"));
252b5132
RH		 4463 exp->X_add_number = 0;
4464 op = O_constant;
4465 }
4466 else if (op == O_register)
4467 {
4468 as_warn (_("register value used as expression"));
4469 op = O_constant;
4470 }
4471
67a659f6
RH		 4472 /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
4473 a signal that this is leb128 data. It shouldn't optimize this away. */
4474 nbytes = -1;
4475 if (check_eh_frame (exp, &nbytes))
4476 abort ();
4477
371b7465
RH		 4478 /* Let the backend know that subsequent data may be byte aligned. */
4479#ifdef md_cons_align
4480 md_cons_align (1);
4481#endif
4482
252b5132
RH		 4483 if (op == O_constant)
4484 {
4485 /* If we've got a constant, emit the thing directly right now. */
4486
4487 valueT value = exp->X_add_number;
4488 int size;
4489 char *p;
4490
4491 size = sizeof_leb128 (value, sign);
4492 p = frag_more (size);
4493 output_leb128 (p, value, sign);
4494 }
4495 else if (op == O_big)
4496 {
4497 /* O_big is a different sort of constant. */
4498
4499 int size;
4500 char *p;
4501
4502 size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
4503 p = frag_more (size);
4504 output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
4505 }
4506 else
4507 {
041ff4dd 4508 /* Otherwise, we have to create a variable sized fragment and
252b5132
RH		 4509 resolve things later. */
4510
041ff4dd 4511 frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
252b5132
RH		 4512 make_expr_symbol (exp), 0, (char *) NULL);
4513 }
4514}
4515
4516/* Parse the .sleb128 and .uleb128 pseudos. */
4517
4518void
4519s_leb128 (sign)
4520 int sign;
4521{
4522 expressionS exp;
4523
041ff4dd
NC		 4524 do
4525 {
4526 expression (&exp);
4527 emit_leb128_expr (&exp, sign);
4528 }
4529 while (*input_line_pointer++ == ',');
252b5132
RH		 4530
4531 input_line_pointer--;
4532 demand_empty_rest_of_line ();
4533}
4534\f
041ff4dd
NC		 4535/* We read 0 or more ',' separated, double-quoted strings.
4536 Caller should have checked need_pass_2 is FALSE because we don't
4537 check it. */
4538
4539void
4540stringer (append_zero) /* Worker to do .ascii etc statements. */
4541 /* Checks end-of-line. */
4542 register int append_zero; /* 0: don't append '\0', else 1. */
252b5132
RH		 4543{
4544 register unsigned int c;
4545 char *start;
4546
4547#ifdef md_flush_pending_output
4548 md_flush_pending_output ();
4549#endif
4550
041ff4dd
NC		 4551 /* The following awkward logic is to parse ZERO or more strings,
4552 comma separated. Recall a string expression includes spaces
4553 before the opening '\"' and spaces after the closing '\"'.
4554 We fake a leading ',' if there is (supposed to be)
4555 a 1st, expression. We keep demanding expressions for each ','. */
252b5132
RH		 4556 if (is_it_end_of_statement ())
4557 {
041ff4dd
NC		 4558 c = 0; /* Skip loop. */
4559 ++input_line_pointer; /* Compensate for end of loop. */
252b5132
RH		 4560 }
4561 else
4562 {
041ff4dd 4563 c = ','; /* Do loop. */
252b5132 4564 }
8ac9ba6c
NC		 4565 /* If we have been switched into the abs_section then we
4566 will not have an obstack onto which we can hang strings. */
4567 if (now_seg == absolute_section)
4568 {
4569 as_bad (_("strings must be placed into a section"));
4570 c = 0;
4571 ignore_rest_of_line ();
4572 }
4573
252b5132
RH		 4574 while (c == ',' || c == '<' || c == '"')
4575 {
4576 SKIP_WHITESPACE ();
4577 switch (*input_line_pointer)
4578 {
4579 case '\"':
041ff4dd 4580 ++input_line_pointer; /*->1st char of string. */
252b5132
RH		 4581 start = input_line_pointer;
4582 while (is_a_char (c = next_char_of_string ()))
4583 {
4584 FRAG_APPEND_1_CHAR (c);
4585 }
4586 if (append_zero)
4587 {
4588 FRAG_APPEND_1_CHAR (0);
4589 }
4590 know (input_line_pointer[-1] == '\"');
4591
4592#ifndef NO_LISTING
4593#ifdef OBJ_ELF
4594 /* In ELF, when gcc is emitting DWARF 1 debugging output, it
4595 will emit .string with a filename in the .debug section
4596 after a sequence of constants. See the comment in
4597 emit_expr for the sequence. emit_expr will set
4598 dwarf_file_string to non-zero if this string might be a
4599 source file name. */
4600 if (strcmp (segment_name (now_seg), ".debug") != 0)
4601 dwarf_file_string = 0;
4602 else if (dwarf_file_string)
4603 {
4604 c = input_line_pointer[-1];
4605 input_line_pointer[-1] = '\0';
4606 listing_source_file (start);
4607 input_line_pointer[-1] = c;
4608 }
4609#endif
4610#endif
4611
4612 break;
4613 case '<':
4614 input_line_pointer++;
4615 c = get_single_number ();
4616 FRAG_APPEND_1_CHAR (c);
4617 if (*input_line_pointer != '>')
4618 {
0e389e77 4619 as_bad (_("expected <nn>"));
252b5132
RH		 4620 }
4621 input_line_pointer++;
4622 break;
4623 case ',':
4624 input_line_pointer++;
4625 break;
4626 }
4627 SKIP_WHITESPACE ();
4628 c = *input_line_pointer;
4629 }
4630
4631 demand_empty_rest_of_line ();
4632} /* stringer() */
4633\f
4634/* FIXME-SOMEDAY: I had trouble here on characters with the
4635 high bits set. We'll probably also have trouble with
4636 multibyte chars, wide chars, etc. Also be careful about
041ff4dd 4637 returning values bigger than 1 byte. xoxorich. */
252b5132 4638
041ff4dd 4639unsigned int
252b5132
RH		 4640next_char_of_string ()
4641{
4642 register unsigned int c;
4643
4644 c = *input_line_pointer++ & CHAR_MASK;
4645 switch (c)
4646 {
4647 case '\"':
4648 c = NOT_A_CHAR;
4649 break;
4650
4651 case '\n':
0e389e77 4652 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 4653 bump_line_counters ();
4654 break;
4655
4656#ifndef NO_STRING_ESCAPES
4657 case '\\':
4658 switch (c = *input_line_pointer++)
4659 {
4660 case 'b':
4661 c = '\b';
4662 break;
4663
4664 case 'f':
4665 c = '\f';
4666 break;
4667
4668 case 'n':
4669 c = '\n';
4670 break;
4671
4672 case 'r':
4673 c = '\r';
4674 break;
4675
4676 case 't':
4677 c = '\t';
4678 break;
4679
4680 case 'v':
4681 c = '\013';
4682 break;
4683
4684 case '\\':
4685 case '"':
041ff4dd 4686 break; /* As itself. */
252b5132
RH		 4687
4688 case '0':
4689 case '1':
4690 case '2':
4691 case '3':
4692 case '4':
4693 case '5':
4694 case '6':
4695 case '7':
4696 case '8':
4697 case '9':
4698 {
4699 long number;
4700 int i;
4701
041ff4dd 4702 for (i = 0, number = 0;
3882b010 4703 ISDIGIT (c) && i < 3;
041ff4dd 4704 c = *input_line_pointer++, i++)
252b5132
RH		 4705 {
4706 number = number * 8 + c - '0';
4707 }
f0e652b4 4708
252b5132
RH		 4709 c = number & 0xff;
4710 }
4711 --input_line_pointer;
4712 break;
4713
4714 case 'x':
4715 case 'X':
4716 {
4717 long number;
4718
4719 number = 0;
4720 c = *input_line_pointer++;
3882b010 4721 while (ISXDIGIT (c))
252b5132 4722 {
3882b010 4723 if (ISDIGIT (c))
252b5132 4724 number = number * 16 + c - '0';
3882b010 4725 else if (ISUPPER (c))
252b5132
RH		 4726 number = number * 16 + c - 'A' + 10;
4727 else
4728 number = number * 16 + c - 'a' + 10;
4729 c = *input_line_pointer++;
4730 }
4731 c = number & 0xff;
4732 --input_line_pointer;
4733 }
4734 break;
4735
4736 case '\n':
041ff4dd 4737 /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
0e389e77 4738 as_warn (_("unterminated string; newline inserted"));
252b5132
RH		 4739 c = '\n';
4740 bump_line_counters ();
4741 break;
4742
4743 default:
4744
4745#ifdef ONLY_STANDARD_ESCAPES
0e389e77 4746 as_bad (_("bad escaped character in string"));
252b5132
RH		 4747 c = '?';
4748#endif /* ONLY_STANDARD_ESCAPES */
4749
4750 break;
041ff4dd 4751 }
252b5132
RH		 4752 break;
4753#endif /* ! defined (NO_STRING_ESCAPES) */
4754
4755 default:
4756 break;
041ff4dd 4757 }
252b5132 4758 return (c);
041ff4dd 4759}
252b5132
RH		 4760\f
4761static segT
4762get_segmented_expression (expP)
4763 register expressionS *expP;
4764{
4765 register segT retval;
4766
4767 retval = expression (expP);
4768 if (expP->X_op == O_illegal
4769 || expP->X_op == O_absent
4770 || expP->X_op == O_big)
4771 {
0e389e77 4772 as_bad (_("expected address expression"));
252b5132
RH		 4773 expP->X_op = O_constant;
4774 expP->X_add_number = 0;
4775 retval = absolute_section;
4776 }
4777 return retval;
4778}
4779
041ff4dd 4780static segT
252b5132
RH		 4781get_known_segmented_expression (expP)
4782 register expressionS *expP;
4783{
4784 register segT retval;
4785
4786 if ((retval = get_segmented_expression (expP)) == undefined_section)
4787 {
4788 /* There is no easy way to extract the undefined symbol from the
4789 expression. */
4790 if (expP->X_add_symbol != NULL
4791 && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
4792 as_warn (_("symbol \"%s\" undefined; zero assumed"),
4793 S_GET_NAME (expP->X_add_symbol));
4794 else
4795 as_warn (_("some symbol undefined; zero assumed"));
4796 retval = absolute_section;
4797 expP->X_op = O_constant;
4798 expP->X_add_number = 0;
4799 }
4800 know (retval == absolute_section || SEG_NORMAL (retval));
4801 return (retval);
041ff4dd 4802}
252b5132
RH		 4803
4804offsetT
4805get_absolute_expression ()
4806{
4807 expressionS exp;
4808
4809 expression (&exp);
4810 if (exp.X_op != O_constant)
4811 {
4812 if (exp.X_op != O_absent)
0e389e77 4813 as_bad (_("bad or irreducible absolute expression"));
252b5132
RH		 4814 exp.X_add_number = 0;
4815 }
4816 return exp.X_add_number;
4817}
4818
041ff4dd 4819char /* Return terminator. */
252b5132 4820get_absolute_expression_and_terminator (val_pointer)
041ff4dd 4821 long *val_pointer; /* Return value of expression. */
252b5132
RH		 4822{
4823 /* FIXME: val_pointer should probably be offsetT *. */
4824 *val_pointer = (long) get_absolute_expression ();
4825 return (*input_line_pointer++);
4826}
4827\f
041ff4dd
NC		 4828/* Like demand_copy_string, but return NULL if the string contains any '\0's.
4829 Give a warning if that happens. */
4830
252b5132
RH		 4831char *
4832demand_copy_C_string (len_pointer)
4833 int *len_pointer;
4834{
4835 register char *s;
4836
4837 if ((s = demand_copy_string (len_pointer)) != 0)
4838 {
4839 register int len;
4840
4841 for (len = *len_pointer; len > 0; len--)
4842 {
4843 if (*s == 0)
4844 {
4845 s = 0;
4846 len = 1;
4847 *len_pointer = 0;
0e389e77 4848 as_bad (_("this string may not contain \'\\0\'"));
252b5132
RH		 4849 }
4850 }
4851 }
f0e652b4 4852
252b5132
RH		 4853 return s;
4854}
4855\f
041ff4dd
NC		 4856/* Demand string, but return a safe (=private) copy of the string.
4857 Return NULL if we can't read a string here. */
4858
252b5132
RH		 4859char *
4860demand_copy_string (lenP)
4861 int *lenP;
4862{
4863 register unsigned int c;
4864 register int len;
4865 char *retval;
4866
4867 len = 0;
4868 SKIP_WHITESPACE ();
4869 if (*input_line_pointer == '\"')
4870 {
041ff4dd 4871 input_line_pointer++; /* Skip opening quote. */
252b5132
RH		 4872
4873 while (is_a_char (c = next_char_of_string ()))
4874 {
4875 obstack_1grow (&notes, c);
4876 len++;
4877 }
4878 /* JF this next line is so demand_copy_C_string will return a
041ff4dd 4879 null terminated string. */
252b5132
RH		 4880 obstack_1grow (&notes, '\0');
4881 retval = obstack_finish (&notes);
4882 }
4883 else
4884 {
0e389e77 4885 as_warn (_("missing string"));
252b5132
RH		 4886 retval = NULL;
4887 ignore_rest_of_line ();
4888 }
4889 *lenP = len;
4890 return (retval);
041ff4dd 4891}
252b5132 4892\f
041ff4dd 4893/* In: Input_line_pointer->next character.
f0e652b4 4894
041ff4dd 4895 Do: Skip input_line_pointer over all whitespace.
f0e652b4 4896
041ff4dd
NC		 4897 Out: 1 if input_line_pointer->end-of-line. */
4898
4899int
252b5132
RH		 4900is_it_end_of_statement ()
4901{
4902 SKIP_WHITESPACE ();
4903 return (is_end_of_line[(unsigned char) *input_line_pointer]);
041ff4dd 4904}
252b5132 4905
041ff4dd 4906void
252b5132
RH		 4907equals (sym_name, reassign)
4908 char *sym_name;
4909 int reassign;
4910{
041ff4dd 4911 register symbolS *symbolP; /* Symbol we are working with. */
252b5132
RH		 4912 char *stop = NULL;
4913 char stopc;
4914
4915 input_line_pointer++;
4916 if (*input_line_pointer == '=')
4917 input_line_pointer++;
4918
4919 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4920 input_line_pointer++;
4921
4922 if (flag_mri)
4923 stop = mri_comment_field (&stopc);
4924
4925 if (sym_name[0] == '.' && sym_name[1] == '\0')
4926 {
041ff4dd 4927 /* Turn '. = mumble' into a .org mumble. */
252b5132
RH		 4928 register segT segment;
4929 expressionS exp;
4930
4931 segment = get_known_segmented_expression (&exp);
4932 if (!need_pass_2)
4933 do_org (segment, &exp, 0);
4934 }
4935 else
4936 {
440ecb38
L		 4937#ifdef OBJ_COFF
4938 int local;
4939
4940 symbolP = symbol_find (sym_name);
4941 local = symbolP == NULL;
4942 if (local)
4943#endif /* OBJ_COFF */
252b5132
RH		 4944 symbolP = symbol_find_or_make (sym_name);
4945 /* Permit register names to be redefined. */
041ff4dd 4946 if (!reassign
252b5132
RH		 4947 && S_IS_DEFINED (symbolP)
4948 && S_GET_SEGMENT (symbolP) != reg_section)
0e389e77 4949 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
775cf891
NC		 4950
4951#ifdef OBJ_COFF
4952 /* "set" symbols are local unless otherwise specified. */
440ecb38
L		 4953 if (local)
4954 SF_SET_LOCAL (symbolP);
775cf891
NC		 4955#endif /* OBJ_COFF */
4956
252b5132
RH		 4957 pseudo_set (symbolP);
4958 }
4959
4960 if (flag_mri)
041ff4dd
NC		 4961 {
4962 /* Check garbage after the expression. */
4963 ignore_rest_of_line ();
4964 mri_comment_end (stop, stopc);
4965 }
4966}
252b5132 4967
7e005732
NC		 4968/* .incbin -- include a file verbatim at the current location. */
4969
4970void
4971s_incbin (x)
4972 int x ATTRIBUTE_UNUSED;
4973{
4974 FILE * binfile;
4975 char * path;
4976 char * filename;
4977 char * binfrag;
4978 long skip = 0;
4979 long count = 0;
4980 long bytes;
4981 int len;
4982
4983#ifdef md_flush_pending_output
4984 md_flush_pending_output ();
4985#endif
4986
4987 SKIP_WHITESPACE ();
4988 filename = demand_copy_string (& len);
4989 if (filename == NULL)
4990 return;
4991
4992 SKIP_WHITESPACE ();
4993
4994 /* Look for optional skip and count. */
4995 if (* input_line_pointer == ',')
4996 {
4997 ++ input_line_pointer;
4998 skip = get_absolute_expression ();
4999
5000 SKIP_WHITESPACE ();
5001
5002 if (* input_line_pointer == ',')
5003 {
5004 ++ input_line_pointer;
5005
5006 count = get_absolute_expression ();
5007 if (count == 0)
5008 as_warn (_(".incbin count zero, ignoring `%s'"), filename);
5009
5010 SKIP_WHITESPACE ();
5011 }
5012 }
5013
5014 demand_empty_rest_of_line ();
5015
5016 /* Try opening absolute path first, then try include dirs. */
f740e790 5017 binfile = fopen (filename, FOPEN_RB);
7e005732
NC		 5018 if (binfile == NULL)
5019 {
5020 int i;
5021
5022 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
5023
5024 for (i = 0; i < include_dir_count; i++)
5025 {
5026 sprintf (path, "%s/%s", include_dirs[i], filename);
5027
f740e790 5028 binfile = fopen (path, FOPEN_RB);
7e005732
NC		 5029 if (binfile != NULL)
5030 break;
5031 }
5032
5033 if (binfile == NULL)
5034 as_bad (_("file not found: %s"), filename);
5035 }
5036 else
5037 path = xstrdup (filename);
5038
5039 if (binfile)
5040 {
f740e790
NC		 5041 long file_len;
5042
7e005732
NC		 5043 register_dependency (path);
5044
5045 /* Compute the length of the file. */
5046 if (fseek (binfile, 0, SEEK_END) != 0)
5047 {
5048 as_bad (_("seek to end of .incbin file failed `%s'"), path);
5049 goto done;
5050 }
f740e790 5051 file_len = ftell (binfile);
7e005732
NC		 5052
5053 /* If a count was not specified use the size of the file. */
5054 if (count == 0)
f740e790 5055 count = file_len;
7e005732 5056
f740e790 5057 if (skip + count > file_len)
7e005732
NC		 5058 {
5059 as_bad (_("skip (%ld) + count (%ld) larger than file size (%ld)"),
f740e790 5060 skip, count, file_len);
7e005732
NC		 5061 goto done;
5062 }
5063
5064 if (fseek (binfile, skip, SEEK_SET) != 0)
5065 {
5066 as_bad (_("could not skip to %ld in file `%s'"), skip, path);
5067 goto done;
5068 }
5069
5070 /* Allocate frag space and store file contents in it. */
5071 binfrag = frag_more (count);
5072
5073 bytes = fread (binfrag, 1, count, binfile);
5074 if (bytes < count)
5075 as_warn (_("truncated file `%s', %ld of %ld bytes read"),
5076 path, bytes, count);
5077 }
5078done:
5079 if (binfile != NULL)
5080 fclose (binfile);
5081 if (path)
5082 free (path);
5083}
5084
041ff4dd 5085/* .include -- include a file at this point. */
252b5132 5086
041ff4dd 5087void
252b5132 5088s_include (arg)
ab9da554 5089 int arg ATTRIBUTE_UNUSED;
252b5132 5090{
252b5132
RH		 5091 char *filename;
5092 int i;
5093 FILE *try;
5094 char *path;
5095
041ff4dd 5096 if (!flag_m68k_mri)
252b5132
RH		 5097 {
5098 filename = demand_copy_string (&i);
5099 if (filename == NULL)
5100 {
5101 /* demand_copy_string has already printed an error and
5102 called ignore_rest_of_line. */
5103 return;
5104 }
5105 }
5106 else
5107 {
5108 SKIP_WHITESPACE ();
5109 i = 0;
041ff4dd 5110 while (!is_end_of_line[(unsigned char) *input_line_pointer]
252b5132
RH		 5111 && *input_line_pointer != ' '
5112 && *input_line_pointer != '\t')
5113 {
5114 obstack_1grow (&notes, *input_line_pointer);
5115 ++input_line_pointer;
5116 ++i;
5117 }
f0e652b4 5118
252b5132
RH		 5119 obstack_1grow (&notes, '\0');
5120 filename = obstack_finish (&notes);
041ff4dd 5121 while (!is_end_of_line[(unsigned char) *input_line_pointer])
252b5132
RH		 5122 ++input_line_pointer;
5123 }
f0e652b4 5124
252b5132
RH		 5125 demand_empty_rest_of_line ();
5126 path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
f0e652b4 5127
252b5132
RH		 5128 for (i = 0; i < include_dir_count; i++)
5129 {
5130 strcpy (path, include_dirs[i]);
5131 strcat (path, "/");
5132 strcat (path, filename);
f740e790 5133 if (0 != (try = fopen (path, FOPEN_RT)))
252b5132
RH		 5134 {
5135 fclose (try);
5136 goto gotit;
5137 }
5138 }
f0e652b4 5139
252b5132
RH		 5140 free (path);
5141 path = filename;
5142gotit:
041ff4dd 5143 /* malloc Storage leak when file is found on path. FIXME-SOMEDAY. */
252b5132 5144 register_dependency (path);
9f10757c 5145 input_scrub_insert_file (path);
041ff4dd 5146}
252b5132 5147
041ff4dd 5148void
252b5132
RH		 5149add_include_dir (path)
5150 char *path;
5151{
5152 int i;
5153
5154 if (include_dir_count == 0)
5155 {
5156 include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
041ff4dd 5157 include_dirs[0] = "."; /* Current dir. */
252b5132
RH		 5158 include_dir_count = 2;
5159 }
5160 else
5161 {
5162 include_dir_count++;
041ff4dd
NC		 5163 include_dirs =
5164 (char **) realloc (include_dirs,
5165 include_dir_count * sizeof (*include_dirs));
252b5132
RH		 5166 }
5167
041ff4dd 5168 include_dirs[include_dir_count - 1] = path; /* New one. */
252b5132
RH		 5169
5170 i = strlen (path);
5171 if (i > include_dir_maxlen)
5172 include_dir_maxlen = i;
041ff4dd 5173}
252b5132
RH		 5174\f
5175/* Output debugging information to denote the source file. */
5176
5177static void
5178generate_file_debug ()
5179{
5180 if (debug_type == DEBUG_STABS)
5181 stabs_generate_asm_file ();
5182}
5183
5184/* Output line number debugging information for the current source line. */
5185
5186void
5187generate_lineno_debug ()
5188{
252b5132
RH		 5189 switch (debug_type)
5190 {
5191 case DEBUG_UNSPECIFIED:
5192 case DEBUG_NONE:
4dc7ead9 5193 case DEBUG_DWARF:
252b5132
RH		 5194 break;
5195 case DEBUG_STABS:
5196 stabs_generate_asm_lineno ();
5197 break;
5198 case DEBUG_ECOFF:
5199 ecoff_generate_asm_lineno ();
5200 break;
252b5132 5201 case DEBUG_DWARF2:
4dc7ead9
RH		 5202 /* ??? We could here indicate to dwarf2dbg.c that something
5203 has changed. However, since there is additional backend
5204 support that is required (calling dwarf2_emit_insn), we
5205 let dwarf2dbg.c call as_where on its own. */
252b5132
RH		 5206 break;
5207 }
5208}
5209
5210/* Output debugging information to mark a function entry point or end point.
5211 END_P is zero for .func, and non-zero for .endfunc. */
5212
5213void
5214s_func (end_p)
5215 int end_p;
5216{
5217 do_s_func (end_p, NULL);
5218}
5219
5220/* Subroutine of s_func so targets can choose a different default prefix.
5221 If DEFAULT_PREFIX is NULL, use the target's "leading char". */
5222
5223void
5224do_s_func (end_p, default_prefix)
5225 int end_p;
5226 const char *default_prefix;
5227{
5228 /* Record the current function so that we can issue an error message for
5229 misplaced .func,.endfunc, and also so that .endfunc needs no
5230 arguments. */
5231 static char *current_name;
5232 static char *current_label;
5233
5234 if (end_p)
5235 {
5236 if (current_name == NULL)
5237 {
5238 as_bad (_("missing .func"));
5239 ignore_rest_of_line ();
5240 return;
5241 }
5242
5243 if (debug_type == DEBUG_STABS)
5244 stabs_generate_asm_endfunc (current_name, current_label);
5245
5246 current_name = current_label = NULL;
5247 }
5248 else /* ! end_p */
5249 {
041ff4dd
NC		 5250 char *name, *label;
5251 char delim1, delim2;
252b5132
RH		 5252
5253 if (current_name != NULL)
5254 {
5255 as_bad (_(".endfunc missing for previous .func"));
5256 ignore_rest_of_line ();
5257 return;
5258 }
5259
5260 name = input_line_pointer;
5261 delim1 = get_symbol_end ();
5262 name = xstrdup (name);
5263 *input_line_pointer = delim1;
5264 SKIP_WHITESPACE ();
5265 if (*input_line_pointer != ',')
5266 {
5267 if (default_prefix)
5268 asprintf (&label, "%s%s", default_prefix, name);
5269 else
5270 {
5271 char leading_char = 0;
5272#ifdef BFD_ASSEMBLER
5273 leading_char = bfd_get_symbol_leading_char (stdoutput);
5274#endif
5275 /* Missing entry point, use function's name with the leading
5276 char prepended. */
5277 if (leading_char)
5278 asprintf (&label, "%c%s", leading_char, name);
5279 else
5280 label = name;
5281 }
5282 }
5283 else
5284 {
5285 ++input_line_pointer;
5286 SKIP_WHITESPACE ();
5287 label = input_line_pointer;
5288 delim2 = get_symbol_end ();
5289 label = xstrdup (label);
5290 *input_line_pointer = delim2;
5291 }
5292
5293 if (debug_type == DEBUG_STABS)
5294 stabs_generate_asm_func (name, label);
5295
5296 current_name = name;
5297 current_label = label;
5298 }
5299
5300 demand_empty_rest_of_line ();
5301}
5302\f
041ff4dd 5303void
252b5132 5304s_ignore (arg)
ab9da554 5305 int arg ATTRIBUTE_UNUSED;
252b5132
RH		 5306{
5307 while (!is_end_of_line[(unsigned char) *input_line_pointer])
5308 {
5309 ++input_line_pointer;
5310 }
5311 ++input_line_pointer;
5312}
5313
252b5132
RH		 5314void
5315read_print_statistics (file)
5316 FILE *file;
5317{
5318 hash_print_statistics (file, "pseudo-op table", po_hash);
5319}
5320
041ff4dd
NC		 5321/* Inserts the given line into the input stream.
5322
9f10757c
TW		 5323 This call avoids macro/conditionals nesting checking, since the contents of
5324 the line are assumed to replace the contents of a line already scanned.
5325
5326 An appropriate use of this function would be substition of input lines when
5327 called by md_start_line_hook(). The given line is assumed to already be
5328 properly scrubbed. */
5329
5330void
5331input_scrub_insert_line (line)
041ff4dd 5332 const char *line;
9f10757c
TW		 5333{
5334 sb newline;
5335 sb_new (&newline);
5336 sb_add_string (&newline, line);
5337 input_scrub_include_sb (&newline, input_line_pointer, 0);
5338 sb_kill (&newline);
5339 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5340}
5341
5342/* Insert a file into the input stream; the path must resolve to an actual
041ff4dd 5343 file; no include path searching or dependency registering is performed. */
9f10757c
TW		 5344
5345void
5346input_scrub_insert_file (path)
041ff4dd 5347 char *path;
9f10757c
TW		 5348{
5349 input_scrub_include_file (path, input_line_pointer);
5350 buffer_limit = input_scrub_next_buffer (&input_line_pointer);
5351}
GDB Binutils - Deliverables
This page took 0.385606 seconds and 4 git commands to generate.