OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gas/] [read.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.