gas/as.c

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