gas/as.c

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