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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [gas/] [read.c] - Blame information for rev 455

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

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

powered by: WebSVN 2.1.0

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