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