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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [as.c] - Blame information for rev 160

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

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

powered by: WebSVN 2.1.0

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