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