gas/as.c

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