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