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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [gas/] [as.c] - Blame information for rev 853

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

Line No. Rev Author Line
1 38 julius
/* as.c - GAS main program.
2
   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GAS, the GNU Assembler.
7
 
8
   GAS is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   GAS is distributed in the hope that it will be useful, but WITHOUT
14
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16
   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
/* Main program for AS; a 32-bit assembler of GNU.
24
   Understands command arguments.
25
   Has a few routines that don't fit in other modules because they
26
   are shared.
27
 
28
                        bugs
29
 
30
   : initialisers
31
        Since no-one else says they will support them in future: I
32
   don't support them now.  */
33
 
34
#define COMMON
35
 
36
#include "as.h"
37
#include "subsegs.h"
38
#include "output-file.h"
39
#include "sb.h"
40
#include "macro.h"
41
#include "dwarf2dbg.h"
42
#include "dw2gencfi.h"
43
#include "bfdver.h"
44
 
45
#ifdef HAVE_ITBL_CPU
46
#include "itbl-ops.h"
47
#else
48
#define itbl_init()
49
#endif
50
 
51
#ifdef HAVE_SBRK
52
#ifdef NEED_DECLARATION_SBRK
53
extern PTR sbrk ();
54
#endif
55
#endif
56
 
57
#ifdef USING_CGEN
58
/* Perform any cgen specific initialisation for gas.  */
59
extern void gas_cgen_begin (void);
60
#endif
61
 
62
/* We build a list of defsyms as we read the options, and then define
63
   them after we have initialized everything.  */
64
struct defsym_list
65
{
66
  struct defsym_list *next;
67
  char *name;
68
  valueT value;
69
};
70
 
71
 
72
/* True if a listing is wanted.  */
73
int listing;
74
 
75
/* Type of debugging to generate.  */
76
enum debug_info_type debug_type = DEBUG_UNSPECIFIED;
77
int use_gnu_debug_info_extensions = 0;
78
 
79
#ifndef MD_DEBUG_FORMAT_SELECTOR
80
#define MD_DEBUG_FORMAT_SELECTOR NULL
81
#endif
82
static enum debug_info_type (*md_debug_format_selector) (int *) = MD_DEBUG_FORMAT_SELECTOR;
83
 
84
/* Maximum level of macro nesting.  */
85
int max_macro_nest = 100;
86
 
87
/* argv[0]  */
88
static char * myname;
89
 
90
/* The default obstack chunk size.  If we set this to zero, the
91
   obstack code will use whatever will fit in a 4096 byte block.  */
92
int chunksize = 0;
93
 
94
/* To monitor memory allocation more effectively, make this non-zero.
95
   Then the chunk sizes for gas and bfd will be reduced.  */
96
int debug_memory = 0;
97
 
98
/* Enable verbose mode.  */
99
int verbose = 0;
100
 
101
segT reg_section;
102
segT expr_section;
103
segT text_section;
104
segT data_section;
105
segT bss_section;
106
 
107
/* Name of listing file.  */
108
static char *listing_filename = NULL;
109
 
110
static struct defsym_list *defsyms;
111
 
112
#ifdef HAVE_ITBL_CPU
113
/* Keep a record of the itbl files we read in.  */
114
struct itbl_file_list
115
{
116
  struct itbl_file_list *next;
117
  char *name;
118
};
119
static struct itbl_file_list *itbl_files;
120
#endif
121
 
122
static long start_time;
123
 
124
static int flag_macro_alternate;
125
 
126
 
127
#ifdef USE_EMULATIONS
128
#define EMULATION_ENVIRON "AS_EMULATION"
129
 
130
extern struct emulation mipsbelf, mipslelf, mipself;
131
extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
132
extern struct emulation i386coff, i386elf, i386aout;
133
extern struct emulation crisaout, criself;
134
 
135
static struct emulation *const emulations[] = { EMULATIONS };
136
static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
137
 
138
static void
139
select_emulation_mode (int argc, char **argv)
140
{
141
  int i;
142
  char *p, *em = 0;
143
 
144
  for (i = 1; i < argc; i++)
145
    if (!strncmp ("--em", argv[i], 4))
146
      break;
147
 
148
  if (i == argc)
149
    goto do_default;
150
 
151
  p = strchr (argv[i], '=');
152
  if (p)
153
    p++;
154
  else
155
    p = argv[i + 1];
156
 
157
  if (!p || !*p)
158
    as_fatal (_("missing emulation mode name"));
159
  em = p;
160
 
161
 do_default:
162
  if (em == 0)
163
    em = getenv (EMULATION_ENVIRON);
164
  if (em == 0)
165
    em = DEFAULT_EMULATION;
166
 
167
  if (em)
168
    {
169
      for (i = 0; i < n_emulations; i++)
170
        if (!strcmp (emulations[i]->name, em))
171
          break;
172
      if (i == n_emulations)
173
        as_fatal (_("unrecognized emulation name `%s'"), em);
174
      this_emulation = emulations[i];
175
    }
176
  else
177
    this_emulation = emulations[0];
178
 
179
  this_emulation->init ();
180
}
181
 
182
const char *
183
default_emul_bfd_name (void)
184
{
185
  abort ();
186
  return NULL;
187
}
188
 
189
void
190
common_emul_init (void)
191
{
192
  this_format = this_emulation->format;
193
 
194
  if (this_emulation->leading_underscore == 2)
195
    this_emulation->leading_underscore = this_format->dfl_leading_underscore;
196
 
197
  if (this_emulation->default_endian != 2)
198
    target_big_endian = this_emulation->default_endian;
199
 
200
  if (this_emulation->fake_label_name == 0)
201
    {
202
      if (this_emulation->leading_underscore)
203
        this_emulation->fake_label_name = "L0\001";
204
      else
205
        /* What other parameters should we test?  */
206
        this_emulation->fake_label_name = ".L0\001";
207
    }
208
}
209
#endif
210
 
211
void
212
print_version_id (void)
213
{
214
  static int printed;
215
 
216
  if (printed)
217
    return;
218
  printed = 1;
219
 
220
  fprintf (stderr, _("GNU assembler version %s (%s) using BFD version %s\n"),
221
           VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
222
}
223
 
224
static void
225
show_usage (FILE * stream)
226
{
227
  fprintf (stream, _("Usage: %s [option...] [asmfile...]\n"), myname);
228
 
229
  fprintf (stream, _("\
230
Options:\n\
231
  -a[sub-option...]       turn on listings\n\
232
                          Sub-options [default hls]:\n\
233
                          c      omit false conditionals\n\
234
                          d      omit debugging directives\n\
235
                          g      include general info\n\
236
                          h      include high-level source\n\
237
                          l      include assembly\n\
238
                          m      include macro expansions\n\
239
                          n      omit forms processing\n\
240
                          s      include symbols\n\
241
                          =FILE  list to FILE (must be last sub-option)\n"));
242
 
243
  fprintf (stream, _("\
244
  --alternate             initially turn on alternate macro syntax\n"));
245
  fprintf (stream, _("\
246
  -D                      produce assembler debugging messages\n"));
247
  fprintf (stream, _("\
248
  --debug-prefix-map OLD=NEW  Map OLD to NEW in debug information\n"));
249
  fprintf (stream, _("\
250
  --defsym SYM=VAL        define symbol SYM to given value\n"));
251
#ifdef USE_EMULATIONS
252
  {
253
    int i;
254
    char *def_em;
255
 
256
    fprintf (stream, "\
257
  --em=[");
258
    for (i = 0; i < n_emulations - 1; i++)
259
      fprintf (stream, "%s | ", emulations[i]->name);
260
    fprintf (stream, "%s]\n", emulations[i]->name);
261
 
262
    def_em = getenv (EMULATION_ENVIRON);
263
    if (!def_em)
264
      def_em = DEFAULT_EMULATION;
265
    fprintf (stream, _("\
266
                          emulate output (default %s)\n"), def_em);
267
  }
268
#endif
269
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
270
  fprintf (stream, _("\
271
  --execstack             require executable stack for this object\n"));
272
  fprintf (stream, _("\
273
  --noexecstack           don't require executable stack for this object\n"));
274
#endif
275
  fprintf (stream, _("\
276
  -f                      skip whitespace and comment preprocessing\n"));
277
  fprintf (stream, _("\
278
  -g --gen-debug          generate debugging information\n"));
279
  fprintf (stream, _("\
280
  --gstabs                generate STABS debugging information\n"));
281
  fprintf (stream, _("\
282
  --gstabs+               generate STABS debug info with GNU extensions\n"));
283
  fprintf (stream, _("\
284
  --gdwarf-2              generate DWARF2 debugging information\n"));
285
  fprintf (stream, _("\
286
  --hash-size=<value>     set the hash table size close to <value>\n"));
287
  fprintf (stream, _("\
288
  --help                  show this message and exit\n"));
289
  fprintf (stream, _("\
290
  --target-help           show target specific options\n"));
291
  fprintf (stream, _("\
292
  -I DIR                  add DIR to search list for .include directives\n"));
293
  fprintf (stream, _("\
294
  -J                      don't warn about signed overflow\n"));
295
  fprintf (stream, _("\
296
  -K                      warn when differences altered for long displacements\n"));
297
  fprintf (stream, _("\
298
  -L,--keep-locals        keep local symbols (e.g. starting with `L')\n"));
299
  fprintf (stream, _("\
300
  -M,--mri                assemble in MRI compatibility mode\n"));
301
  fprintf (stream, _("\
302
  --MD FILE               write dependency information in FILE (default none)\n"));
303
  fprintf (stream, _("\
304
  -nocpp                  ignored\n"));
305
  fprintf (stream, _("\
306
  -o OBJFILE              name the object-file output OBJFILE (default a.out)\n"));
307
  fprintf (stream, _("\
308
  -R                      fold data section into text section\n"));
309
  fprintf (stream, _("\
310
  --reduce-memory-overheads \n\
311
                          prefer smaller memory use at the cost of longer\n\
312
                          assembly times\n"));
313
  fprintf (stream, _("\
314
  --statistics            print various measured statistics from execution\n"));
315
  fprintf (stream, _("\
316
  --strip-local-absolute  strip local absolute symbols\n"));
317
  fprintf (stream, _("\
318
  --traditional-format    Use same format as native assembler when possible\n"));
319
  fprintf (stream, _("\
320
  --version               print assembler version number and exit\n"));
321
  fprintf (stream, _("\
322
  -W  --no-warn           suppress warnings\n"));
323
  fprintf (stream, _("\
324
  --warn                  don't suppress warnings\n"));
325
  fprintf (stream, _("\
326
  --fatal-warnings        treat warnings as errors\n"));
327
#ifdef HAVE_ITBL_CPU
328
  fprintf (stream, _("\
329
  --itbl INSTTBL          extend instruction set to include instructions\n\
330
                          matching the specifications defined in file INSTTBL\n"));
331
#endif
332
  fprintf (stream, _("\
333
  -w                      ignored\n"));
334
  fprintf (stream, _("\
335
  -X                      ignored\n"));
336
  fprintf (stream, _("\
337
  -Z                      generate object file even after errors\n"));
338
  fprintf (stream, _("\
339
  --listing-lhs-width     set the width in words of the output data column of\n\
340
                          the listing\n"));
341
  fprintf (stream, _("\
342
  --listing-lhs-width2    set the width in words of the continuation lines\n\
343
                          of the output data column; ignored if smaller than\n\
344
                          the width of the first line\n"));
345
  fprintf (stream, _("\
346
  --listing-rhs-width     set the max width in characters of the lines from\n\
347
                          the source file\n"));
348
  fprintf (stream, _("\
349
  --listing-cont-lines    set the maximum number of continuation lines used\n\
350
                          for the output data column of the listing\n"));
351
  fprintf (stream, _("\
352
  @FILE                   read options from FILE\n"));
353
 
354
  md_show_usage (stream);
355
 
356
  fputc ('\n', stream);
357
 
358
  if (REPORT_BUGS_TO[0] && stream == stdout)
359
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
360
}
361
 
362
/* Since it is easy to do here we interpret the special arg "-"
363
   to mean "use stdin" and we set that argv[] pointing to "".
364
   After we have munged argv[], the only things left are source file
365
   name(s) and ""(s) denoting stdin. These file names are used
366
   (perhaps more than once) later.
367
 
368
   check for new machine-dep cmdline options in
369
   md_parse_option definitions in config/tc-*.c.  */
370
 
371
static void
372
parse_args (int * pargc, char *** pargv)
373
{
374
  int old_argc;
375
  int new_argc;
376
  char ** old_argv;
377
  char ** new_argv;
378
  /* Starting the short option string with '-' is for programs that
379
     expect options and other ARGV-elements in any order and that care about
380
     the ordering of the two.  We describe each non-option ARGV-element
381
     as if it were the argument of an option with character code 1.  */
382
  char *shortopts;
383
  extern const char *md_shortopts;
384
  static const char std_shortopts[] =
385
  {
386
    '-', 'J',
387
#ifndef WORKING_DOT_WORD
388
    /* -K is not meaningful if .word is not being hacked.  */
389
    'K',
390
#endif
391
    'L', 'M', 'R', 'W', 'Z', 'a', ':', ':', 'D', 'f', 'g', ':',':', 'I', ':', 'o', ':',
392
#ifndef VMS
393
    /* -v takes an argument on VMS, so we don't make it a generic
394
       option.  */
395
    'v',
396
#endif
397
    'w', 'X',
398
#ifdef HAVE_ITBL_CPU
399
    /* New option for extending instruction set (see also --itbl below).  */
400
    't', ':',
401
#endif
402
    '\0'
403
  };
404
  struct option *longopts;
405
  extern struct option md_longopts[];
406
  extern size_t md_longopts_size;
407
  /* Codes used for the long options with no short synonyms.  */
408
  enum option_values
409
    {
410
      OPTION_HELP = OPTION_STD_BASE,
411
      OPTION_NOCPP,
412
      OPTION_STATISTICS,
413
      OPTION_VERSION,
414
      OPTION_DUMPCONFIG,
415
      OPTION_VERBOSE,
416
      OPTION_EMULATION,
417
      OPTION_DEBUG_PREFIX_MAP,
418
      OPTION_DEFSYM,
419
      OPTION_LISTING_LHS_WIDTH,
420
      OPTION_LISTING_LHS_WIDTH2,
421
      OPTION_LISTING_RHS_WIDTH,
422
      OPTION_LISTING_CONT_LINES,
423
      OPTION_DEPFILE,
424
      OPTION_GSTABS,
425
      OPTION_GSTABS_PLUS,
426
      OPTION_GDWARF2,
427
      OPTION_STRIP_LOCAL_ABSOLUTE,
428
      OPTION_TRADITIONAL_FORMAT,
429
      OPTION_WARN,
430
      OPTION_TARGET_HELP,
431
      OPTION_EXECSTACK,
432
      OPTION_NOEXECSTACK,
433
      OPTION_ALTERNATE,
434
      OPTION_AL,
435
      OPTION_HASH_TABLE_SIZE,
436
      OPTION_REDUCE_MEMORY_OVERHEADS,
437
      OPTION_WARN_FATAL
438
    /* When you add options here, check that they do
439
       not collide with OPTION_MD_BASE.  See as.h.  */
440
    };
441
 
442
  static const struct option std_longopts[] =
443
  {
444
    /* Note: commas are placed at the start of the line rather than
445
       the end of the preceeding line so that it is simpler to
446
       selectively add and remove lines from this list.  */
447
    {"alternate", no_argument, NULL, OPTION_ALTERNATE}
448
    /* The entry for "a" is here to prevent getopt_long_only() from
449
       considering that -a is an abbreviation for --alternate.  This is
450
       necessary because -a=<FILE> is a valid switch but getopt would
451
       normally reject it since --alternate does not take an argument.  */
452
    ,{"a", optional_argument, NULL, 'a'}
453
    /* Handle -al=<FILE>.  */
454
    ,{"al", optional_argument, NULL, OPTION_AL}
455
    ,{"debug-prefix-map", required_argument, NULL, OPTION_DEBUG_PREFIX_MAP}
456
    ,{"defsym", required_argument, NULL, OPTION_DEFSYM}
457
    ,{"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}
458
    ,{"emulation", required_argument, NULL, OPTION_EMULATION}
459
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
460
    ,{"execstack", no_argument, NULL, OPTION_EXECSTACK}
461
    ,{"noexecstack", no_argument, NULL, OPTION_NOEXECSTACK}
462
#endif
463
    ,{"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
464
    ,{"gdwarf-2", no_argument, NULL, OPTION_GDWARF2}
465
    /* GCC uses --gdwarf-2 but GAS uses to use --gdwarf2,
466
       so we keep it here for backwards compatibility.  */
467
    ,{"gdwarf2", no_argument, NULL, OPTION_GDWARF2}
468
    ,{"gen-debug", no_argument, NULL, 'g'}
469
    ,{"gstabs", no_argument, NULL, OPTION_GSTABS}
470
    ,{"gstabs+", no_argument, NULL, OPTION_GSTABS_PLUS}
471
    ,{"hash-size", required_argument, NULL, OPTION_HASH_TABLE_SIZE}
472
    ,{"help", no_argument, NULL, OPTION_HELP}
473
#ifdef HAVE_ITBL_CPU
474
    /* New option for extending instruction set (see also -t above).
475
       The "-t file" or "--itbl file" option extends the basic set of
476
       valid instructions by reading "file", a text file containing a
477
       list of instruction formats.  The additional opcodes and their
478
       formats are added to the built-in set of instructions, and
479
       mnemonics for new registers may also be defined.  */
480
    ,{"itbl", required_argument, NULL, 't'}
481
#endif
482
    /* getopt allows abbreviations, so we do this to stop it from
483
       treating -k as an abbreviation for --keep-locals.  Some
484
       ports use -k to enable PIC assembly.  */
485
    ,{"keep-locals", no_argument, NULL, 'L'}
486
    ,{"keep-locals", no_argument, NULL, 'L'}
487
    ,{"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}
488
    ,{"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}
489
    ,{"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}
490
    ,{"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}
491
    ,{"MD", required_argument, NULL, OPTION_DEPFILE}
492
    ,{"mri", no_argument, NULL, 'M'}
493
    ,{"nocpp", no_argument, NULL, OPTION_NOCPP}
494
    ,{"no-warn", no_argument, NULL, 'W'}
495
    ,{"reduce-memory-overheads", no_argument, NULL, OPTION_REDUCE_MEMORY_OVERHEADS}
496
    ,{"statistics", no_argument, NULL, OPTION_STATISTICS}
497
    ,{"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}
498
    ,{"version", no_argument, NULL, OPTION_VERSION}
499
    ,{"verbose", no_argument, NULL, OPTION_VERBOSE}
500
    ,{"target-help", no_argument, NULL, OPTION_TARGET_HELP}
501
    ,{"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
502
    ,{"warn", no_argument, NULL, OPTION_WARN}
503
  };
504
 
505
  /* Construct the option lists from the standard list and the target
506
     dependent list.  Include space for an extra NULL option and
507
     always NULL terminate.  */
508
  shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
509
  longopts = xmalloc (sizeof (std_longopts) + md_longopts_size + sizeof (struct option));
510
  memcpy (longopts, std_longopts, sizeof (std_longopts));
511
  memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
512
  memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
513
          0, sizeof (struct option));
514
 
515
  /* Make a local copy of the old argv.  */
516
  old_argc = *pargc;
517
  old_argv = *pargv;
518
 
519
  /* Initialize a new argv that contains no options.  */
520
  new_argv = xmalloc (sizeof (char *) * (old_argc + 1));
521
  new_argv[0] = old_argv[0];
522
  new_argc = 1;
523
  new_argv[new_argc] = NULL;
524
 
525
  while (1)
526
    {
527
      /* getopt_long_only is like getopt_long, but '-' as well as '--' can
528
         indicate a long option.  */
529
      int longind;
530
      int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
531
                                   &longind);
532
 
533
      if (optc == -1)
534
        break;
535
 
536
      switch (optc)
537
        {
538
        default:
539
          /* md_parse_option should return 1 if it recognizes optc,
540
 
541
          if (md_parse_option (optc, optarg) != 0)
542
            break;
543
          /* `-v' isn't included in the general short_opts list, so check for
544
             it explicitly here before deciding we've gotten a bad argument.  */
545
          if (optc == 'v')
546
            {
547
#ifdef VMS
548
              /* Telling getopt to treat -v's value as optional can result
549
                 in it picking up a following filename argument here.  The
550
                 VMS code in md_parse_option can return 0 in that case,
551
                 but it has no way of pushing the filename argument back.  */
552
              if (optarg && *optarg)
553
                new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
554
              else
555
#else
556
              case 'v':
557
#endif
558
              case OPTION_VERBOSE:
559
                print_version_id ();
560
                verbose = 1;
561
              break;
562
            }
563
          else
564
            as_bad (_("unrecognized option -%c%s"), optc, optarg ? optarg : "");
565
          /* Fall through.  */
566
 
567
        case '?':
568
          exit (EXIT_FAILURE);
569
 
570
        case 1:                 /* File name.  */
571
          if (!strcmp (optarg, "-"))
572
            optarg = "";
573
          new_argv[new_argc++] = optarg;
574
          new_argv[new_argc] = NULL;
575
          break;
576
 
577
        case OPTION_TARGET_HELP:
578
          md_show_usage (stdout);
579
          exit (EXIT_SUCCESS);
580
 
581
        case OPTION_HELP:
582
          show_usage (stdout);
583
          exit (EXIT_SUCCESS);
584
 
585
        case OPTION_NOCPP:
586
          break;
587
 
588
        case OPTION_STATISTICS:
589
          flag_print_statistics = 1;
590
          break;
591
 
592
        case OPTION_STRIP_LOCAL_ABSOLUTE:
593
          flag_strip_local_absolute = 1;
594
          break;
595
 
596
        case OPTION_TRADITIONAL_FORMAT:
597
          flag_traditional_format = 1;
598
          break;
599
 
600
        case OPTION_VERSION:
601
          /* This output is intended to follow the GNU standards document.  */
602
          printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
603
          printf (_("Copyright 2007 Free Software Foundation, Inc.\n"));
604
          printf (_("\
605
This program is free software; you may redistribute it under the terms of\n\
606
the GNU General Public License version 3 or later.\n\
607
This program has absolutely no warranty.\n"));
608
          printf (_("This assembler was configured for a target of `%s'.\n"),
609
                  TARGET_ALIAS);
610
          exit (EXIT_SUCCESS);
611
 
612
        case OPTION_EMULATION:
613
#ifdef USE_EMULATIONS
614
          if (strcmp (optarg, this_emulation->name))
615
            as_fatal (_("multiple emulation names specified"));
616
#else
617
          as_fatal (_("emulations not handled in this configuration"));
618
#endif
619
          break;
620
 
621
        case OPTION_DUMPCONFIG:
622
          fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
623
          fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
624
          fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
625
#ifdef TARGET_OBJ_FORMAT
626
          fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
627
#endif
628
#ifdef TARGET_FORMAT
629
          fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
630
#endif
631
          exit (EXIT_SUCCESS);
632
 
633
        case OPTION_DEBUG_PREFIX_MAP:
634
          add_debug_prefix_map (optarg);
635
          break;
636
 
637
        case OPTION_DEFSYM:
638
          {
639
            char *s;
640
            valueT i;
641
            struct defsym_list *n;
642
 
643
            for (s = optarg; *s != '\0' && *s != '='; s++)
644
              ;
645
            if (*s == '\0')
646
              as_fatal (_("bad defsym; format is --defsym name=value"));
647
            *s++ = '\0';
648
            i = bfd_scan_vma (s, (const char **) NULL, 0);
649
            n = xmalloc (sizeof *n);
650
            n->next = defsyms;
651
            n->name = optarg;
652
            n->value = i;
653
            defsyms = n;
654
          }
655
          break;
656
 
657
#ifdef HAVE_ITBL_CPU
658
        case 't':
659
          {
660
            /* optarg is the name of the file containing the instruction
661
               formats, opcodes, register names, etc.  */
662
            struct itbl_file_list *n;
663
 
664
            if (optarg == NULL)
665
              {
666
                as_warn (_("no file name following -t option"));
667
                break;
668
              }
669
 
670
            n = xmalloc (sizeof * n);
671
            n->next = itbl_files;
672
            n->name = optarg;
673
            itbl_files = n;
674
 
675
            /* Parse the file and add the new instructions to our internal
676
               table.  If multiple instruction tables are specified, the
677
               information from this table gets appended onto the existing
678
               internal table.  */
679
            itbl_files->name = xstrdup (optarg);
680
            if (itbl_parse (itbl_files->name) != 0)
681
              as_fatal (_("failed to read instruction table %s\n"),
682
                        itbl_files->name);
683
          }
684
          break;
685
#endif
686
 
687
        case OPTION_DEPFILE:
688
          start_dependencies (optarg);
689
          break;
690
 
691
        case 'g':
692
          /* Some backends, eg Alpha and Mips, use the -g switch for their
693
             own purposes.  So we check here for an explicit -g and allow
694
             the backend to decide if it wants to process it.  */
695
          if (   old_argv[optind - 1][1] == 'g'
696
              && md_parse_option (optc, optarg))
697
            continue;
698
 
699
          if (md_debug_format_selector)
700
            debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
701
          else if (IS_ELF)
702
            debug_type = DEBUG_DWARF2;
703
          else
704
            debug_type = DEBUG_STABS;
705
          break;
706
 
707
        case OPTION_GSTABS_PLUS:
708
          use_gnu_debug_info_extensions = 1;
709
          /* Fall through.  */
710
        case OPTION_GSTABS:
711
          debug_type = DEBUG_STABS;
712
          break;
713
 
714
        case OPTION_GDWARF2:
715
          debug_type = DEBUG_DWARF2;
716
          break;
717
 
718
        case 'J':
719
          flag_signed_overflow_ok = 1;
720
          break;
721
 
722
#ifndef WORKING_DOT_WORD
723
        case 'K':
724
          flag_warn_displacement = 1;
725
          break;
726
#endif
727
        case 'L':
728
          flag_keep_locals = 1;
729
          break;
730
 
731
        case OPTION_LISTING_LHS_WIDTH:
732
          listing_lhs_width = atoi (optarg);
733
          if (listing_lhs_width_second < listing_lhs_width)
734
            listing_lhs_width_second = listing_lhs_width;
735
          break;
736
        case OPTION_LISTING_LHS_WIDTH2:
737
          {
738
            int tmp = atoi (optarg);
739
 
740
            if (tmp > listing_lhs_width)
741
              listing_lhs_width_second = tmp;
742
          }
743
          break;
744
        case OPTION_LISTING_RHS_WIDTH:
745
          listing_rhs_width = atoi (optarg);
746
          break;
747
        case OPTION_LISTING_CONT_LINES:
748
          listing_lhs_cont_lines = atoi (optarg);
749
          break;
750
 
751
        case 'M':
752
          flag_mri = 1;
753
#ifdef TC_M68K
754
          flag_m68k_mri = 1;
755
#endif
756
          break;
757
 
758
        case 'R':
759
          flag_readonly_data_in_text = 1;
760
          break;
761
 
762
        case 'W':
763
          flag_no_warnings = 1;
764
          break;
765
 
766
        case OPTION_WARN:
767
          flag_no_warnings = 0;
768
          flag_fatal_warnings = 0;
769
          break;
770
 
771
        case OPTION_WARN_FATAL:
772
          flag_no_warnings = 0;
773
          flag_fatal_warnings = 1;
774
          break;
775
 
776
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
777
        case OPTION_EXECSTACK:
778
          flag_execstack = 1;
779
          flag_noexecstack = 0;
780
          break;
781
 
782
        case OPTION_NOEXECSTACK:
783
          flag_noexecstack = 1;
784
          flag_execstack = 0;
785
          break;
786
#endif
787
        case 'Z':
788
          flag_always_generate_output = 1;
789
          break;
790
 
791
        case OPTION_AL:
792
          listing |= LISTING_LISTING;
793
          if (optarg)
794
            listing_filename = xstrdup (optarg);
795
          break;
796
 
797
        case OPTION_ALTERNATE:
798
          optarg = old_argv [optind - 1];
799
          while (* optarg == '-')
800
            optarg ++;
801
 
802
          if (strcmp (optarg, "alternate") == 0)
803
            {
804
              flag_macro_alternate = 1;
805
              break;
806
            }
807
          optarg ++;
808
          /* Fall through.  */
809
 
810
        case 'a':
811
          if (optarg)
812
            {
813
              if (optarg != old_argv[optind] && optarg[-1] == '=')
814
                --optarg;
815
 
816
              if (md_parse_option (optc, optarg) != 0)
817
                break;
818
 
819
              while (*optarg)
820
                {
821
                  switch (*optarg)
822
                    {
823
                    case 'c':
824
                      listing |= LISTING_NOCOND;
825
                      break;
826
                    case 'd':
827
                      listing |= LISTING_NODEBUG;
828
                      break;
829
                    case 'g':
830
                      listing |= LISTING_GENERAL;
831
                      break;
832
                    case 'h':
833
                      listing |= LISTING_HLL;
834
                      break;
835
                    case 'l':
836
                      listing |= LISTING_LISTING;
837
                      break;
838
                    case 'm':
839
                      listing |= LISTING_MACEXP;
840
                      break;
841
                    case 'n':
842
                      listing |= LISTING_NOFORM;
843
                      break;
844
                    case 's':
845
                      listing |= LISTING_SYMBOLS;
846
                      break;
847
                    case '=':
848
                      listing_filename = xstrdup (optarg + 1);
849
                      optarg += strlen (listing_filename);
850
                      break;
851
                    default:
852
                      as_fatal (_("invalid listing option `%c'"), *optarg);
853
                      break;
854
                    }
855
                  optarg++;
856
                }
857
            }
858
          if (!listing)
859
            listing = LISTING_DEFAULT;
860
          break;
861
 
862
        case 'D':
863
          /* DEBUG is implemented: it debugs different
864
             things from other people's assemblers.  */
865
          flag_debug = 1;
866
          break;
867
 
868
        case 'f':
869
          flag_no_comments = 1;
870
          break;
871
 
872
        case 'I':
873
          {                     /* Include file directory.  */
874
            char *temp = xstrdup (optarg);
875
 
876
            add_include_dir (temp);
877
            break;
878
          }
879
 
880
        case 'o':
881
          out_file_name = xstrdup (optarg);
882
          break;
883
 
884
        case 'w':
885
          break;
886
 
887
        case 'X':
888
          /* -X means treat warnings as errors.  */
889
          break;
890
 
891
        case OPTION_REDUCE_MEMORY_OVERHEADS:
892
          /* The only change we make at the moment is to reduce
893
             the size of the hash tables that we use.  */
894
          set_gas_hash_table_size (4051);
895
          break;
896
 
897
        case OPTION_HASH_TABLE_SIZE:
898
          {
899
            unsigned long new_size;
900
 
901
            new_size = strtoul (optarg, NULL, 0);
902
            if (new_size)
903
              set_gas_hash_table_size (new_size);
904
            else
905
              as_fatal (_("--hash-size needs a numeric argument"));
906
            break;
907
          }
908
        }
909
    }
910
 
911
  free (shortopts);
912
  free (longopts);
913
 
914
  *pargc = new_argc;
915
  *pargv = new_argv;
916
 
917
#ifdef md_after_parse_args
918
  md_after_parse_args ();
919
#endif
920
}
921
 
922
static void
923
dump_statistics (void)
924
{
925
#ifdef HAVE_SBRK
926
  char *lim = (char *) sbrk (0);
927
#endif
928
  long run_time = get_run_time () - start_time;
929
 
930
  fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
931
           myname, run_time / 1000000, run_time % 1000000);
932
#ifdef HAVE_SBRK
933
  fprintf (stderr, _("%s: data size %ld\n"),
934
           myname, (long) (lim - (char *) &environ));
935
#endif
936
 
937
  subsegs_print_statistics (stderr);
938
  write_print_statistics (stderr);
939
  symbol_print_statistics (stderr);
940
  read_print_statistics (stderr);
941
 
942
#ifdef tc_print_statistics
943
  tc_print_statistics (stderr);
944
#endif
945
 
946
#ifdef obj_print_statistics
947
  obj_print_statistics (stderr);
948
#endif
949
}
950
 
951
#ifndef OBJ_VMS
952
static void
953
close_output_file (void)
954
{
955
  output_file_close (out_file_name);
956
}
957
#endif
958
 
959
/* The interface between the macro code and gas expression handling.  */
960
 
961
static int
962
macro_expr (const char *emsg, int idx, sb *in, int *val)
963
{
964
  char *hold;
965
  expressionS ex;
966
 
967
  sb_terminate (in);
968
 
969
  hold = input_line_pointer;
970
  input_line_pointer = in->ptr + idx;
971
  expression_and_evaluate (&ex);
972
  idx = input_line_pointer - in->ptr;
973
  input_line_pointer = hold;
974
 
975
  if (ex.X_op != O_constant)
976
    as_bad ("%s", emsg);
977
 
978
  *val = (int) ex.X_add_number;
979
 
980
  return idx;
981
}
982
 
983
/* Here to attempt 1 pass over each input file.
984
   We scan argv[*] looking for filenames or exactly "" which is
985
   shorthand for stdin. Any argv that is NULL is not a file-name.
986
   We set need_pass_2 TRUE if, after this, we still have unresolved
987
   expressions of the form (unknown value)+-(unknown value).
988
 
989
   Note the un*x semantics: there is only 1 logical input file, but it
990
   may be a catenation of many 'physical' input files.  */
991
 
992
static void
993
perform_an_assembly_pass (int argc, char ** argv)
994
{
995
  int saw_a_file = 0;
996
  flagword applicable;
997
 
998
  need_pass_2 = 0;
999
 
1000
  /* Create the standard sections, and those the assembler uses
1001
     internally.  */
1002
  text_section = subseg_new (TEXT_SECTION_NAME, 0);
1003
  data_section = subseg_new (DATA_SECTION_NAME, 0);
1004
  bss_section = subseg_new (BSS_SECTION_NAME, 0);
1005
  /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1006
     to have relocs, otherwise we don't find out in time.  */
1007
  applicable = bfd_applicable_section_flags (stdoutput);
1008
  bfd_set_section_flags (stdoutput, text_section,
1009
                         applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1010
                                       | SEC_CODE | SEC_READONLY));
1011
  bfd_set_section_flags (stdoutput, data_section,
1012
                         applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1013
                                       | SEC_DATA));
1014
  bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1015
  seg_info (bss_section)->bss = 1;
1016
  subseg_new (BFD_ABS_SECTION_NAME, 0);
1017
  subseg_new (BFD_UND_SECTION_NAME, 0);
1018
  reg_section = subseg_new ("*GAS `reg' section*", 0);
1019
  expr_section = subseg_new ("*GAS `expr' section*", 0);
1020
 
1021
  subseg_set (text_section, 0);
1022
 
1023
  /* This may add symbol table entries, which requires having an open BFD,
1024
     and sections already created.  */
1025
  md_begin ();
1026
 
1027
#ifdef USING_CGEN
1028
  gas_cgen_begin ();
1029
#endif
1030
#ifdef obj_begin
1031
  obj_begin ();
1032
#endif
1033
 
1034
  /* Skip argv[0].  */
1035
  argv++;
1036
  argc--;
1037
 
1038
  while (argc--)
1039
    {
1040
      if (*argv)
1041
        {                       /* Is it a file-name argument?  */
1042
          PROGRESS (1);
1043
          saw_a_file++;
1044
          /* argv->"" if stdin desired, else->filename.  */
1045
          read_a_source_file (*argv);
1046
        }
1047
      argv++;                   /* Completed that argv.  */
1048
    }
1049
  if (!saw_a_file)
1050
    read_a_source_file ("");
1051
}
1052
 
1053
#ifdef OBJ_ELF
1054
static void
1055
create_obj_attrs_section (void)
1056
{
1057
  segT s;
1058
  char *p;
1059
  addressT addr;
1060
  offsetT size;
1061
  const char *name;
1062
 
1063
  size = bfd_elf_obj_attr_size (stdoutput);
1064
  if (size)
1065
    {
1066
      name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1067
      if (!name)
1068
        name = ".gnu.attributes";
1069
      s = subseg_new (name, 0);
1070
      elf_section_type (s)
1071
        = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1072
      bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1073
      addr = frag_now_fix ();
1074
      p = frag_more (size);
1075
      bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1076
    }
1077
}
1078
#endif
1079
 
1080
 
1081
int
1082
main (int argc, char ** argv)
1083
{
1084
  char ** argv_orig = argv;
1085
 
1086
  int macro_strip_at;
1087
  int keep_it;
1088
 
1089
  start_time = get_run_time ();
1090
 
1091
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1092
  setlocale (LC_MESSAGES, "");
1093
#endif
1094
#if defined (HAVE_SETLOCALE)
1095
  setlocale (LC_CTYPE, "");
1096
#endif
1097
  bindtextdomain (PACKAGE, LOCALEDIR);
1098
  textdomain (PACKAGE);
1099
 
1100
  if (debug_memory)
1101
    chunksize = 64;
1102
 
1103
#ifdef HOST_SPECIAL_INIT
1104
  HOST_SPECIAL_INIT (argc, argv);
1105
#endif
1106
 
1107
  myname = argv[0];
1108
  xmalloc_set_program_name (myname);
1109
 
1110
  expandargv (&argc, &argv);
1111
 
1112
  START_PROGRESS (myname, 0);
1113
 
1114
#ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1115
#define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1116
#endif
1117
 
1118
  out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1119
 
1120
  hex_init ();
1121
  bfd_init ();
1122
  bfd_set_error_program_name (myname);
1123
 
1124
#ifdef USE_EMULATIONS
1125
  select_emulation_mode (argc, argv);
1126
#endif
1127
 
1128
  PROGRESS (1);
1129
  /* Call parse_args before any of the init/begin functions
1130
     so that switches like --hash-size can be honored.  */
1131
  parse_args (&argc, &argv);
1132
  symbol_begin ();
1133
  frag_init ();
1134
  subsegs_begin ();
1135
  read_begin ();
1136
  input_scrub_begin ();
1137
  expr_begin ();
1138
 
1139
#ifndef OBJ_VMS /* Does its own file handling.  */
1140
  /* It has to be called after dump_statistics ().  */
1141
  xatexit (close_output_file);
1142
#endif
1143
 
1144
  if (flag_print_statistics)
1145
    xatexit (dump_statistics);
1146
 
1147
  macro_strip_at = 0;
1148
#ifdef TC_I960
1149
  macro_strip_at = flag_mri;
1150
#endif
1151
 
1152
  macro_init (flag_macro_alternate, flag_mri, macro_strip_at, macro_expr);
1153
 
1154
  PROGRESS (1);
1155
 
1156
  output_file_create (out_file_name);
1157
  assert (stdoutput != 0);
1158
 
1159
#ifdef tc_init_after_args
1160
  tc_init_after_args ();
1161
#endif
1162
 
1163
  itbl_init ();
1164
 
1165
  /* Now that we have fully initialized, and have created the output
1166
     file, define any symbols requested by --defsym command line
1167
     arguments.  */
1168
  while (defsyms != NULL)
1169
    {
1170
      symbolS *sym;
1171
      struct defsym_list *next;
1172
 
1173
      sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
1174
                        &zero_address_frag);
1175
      /* Make symbols defined on the command line volatile, so that they
1176
         can be redefined inside a source file.  This makes this assembler's
1177
         behaviour compatible with earlier versions, but it may not be
1178
         completely intuitive.  */
1179
      S_SET_VOLATILE (sym);
1180
      symbol_table_insert (sym);
1181
      next = defsyms->next;
1182
      free (defsyms);
1183
      defsyms = next;
1184
    }
1185
 
1186
  PROGRESS (1);
1187
 
1188
  /* Assemble it.  */
1189
  perform_an_assembly_pass (argc, argv);
1190
 
1191
  cond_finish_check (-1);
1192
 
1193
#ifdef md_end
1194
  md_end ();
1195
#endif
1196
 
1197
#ifdef OBJ_ELF
1198
  if (IS_ELF)
1199
    create_obj_attrs_section ();
1200
#endif
1201
 
1202
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
1203
  if ((flag_execstack || flag_noexecstack)
1204
      && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1205
    {
1206
      segT gnustack;
1207
 
1208
      gnustack = subseg_new (".note.GNU-stack", 0);
1209
      bfd_set_section_flags (stdoutput, gnustack,
1210
                             SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1211
 
1212
    }
1213
#endif
1214
 
1215
  /* If we've been collecting dwarf2 .debug_line info, either for
1216
     assembly debugging or on behalf of the compiler, emit it now.  */
1217
  dwarf2_finish ();
1218
 
1219
  /* If we constructed dwarf2 .eh_frame info, either via .cfi
1220
     directives from the user or by the backend, emit it now.  */
1221
  cfi_finish ();
1222
 
1223
  if (seen_at_least_1_file ()
1224
      && (flag_always_generate_output || had_errors () == 0))
1225
    keep_it = 1;
1226
  else
1227
    keep_it = 0;
1228
 
1229
  /* This used to be done at the start of write_object_file in
1230
     write.c, but that caused problems when doing listings when
1231
     keep_it was zero.  This could probably be moved above md_end, but
1232
     I didn't want to risk the change.  */
1233
  subsegs_finish ();
1234
 
1235
  if (keep_it)
1236
    write_object_file ();
1237
 
1238
  fflush (stderr);
1239
 
1240
#ifndef NO_LISTING
1241
  listing_print (listing_filename, argv_orig);
1242
#endif
1243
 
1244
  if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
1245
    as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
1246
 
1247
  if (had_errors () > 0 && ! flag_always_generate_output)
1248
    keep_it = 0;
1249
 
1250
  if (!keep_it)
1251
    unlink_if_ordinary (out_file_name);
1252
 
1253
  input_scrub_end ();
1254
 
1255
  END_PROGRESS (myname);
1256
 
1257
  /* Use xexit instead of return, because under VMS environments they
1258
     may not place the same interpretation on the value given.  */
1259
  if (had_errors () > 0)
1260
    xexit (EXIT_FAILURE);
1261
 
1262
  /* Only generate dependency file if assembler was successful.  */
1263
  print_dependencies ();
1264
 
1265
  xexit (EXIT_SUCCESS);
1266
}

powered by: WebSVN 2.1.0

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