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

Subversion Repositories openrisc_me

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

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

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

powered by: WebSVN 2.1.0

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