gas/as.c

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