gas/as.c

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