gas/as.c

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