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