gas/as.c

   1 /* as.c - GAS main program.
   2    Copyright (C) 1987-2024 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 #ifdef HAVE_ITBL_CPU
 386   fprintf (stream, _("\
 387   --itbl INSTTBL          extend instruction set to include instructions\n\
 388                           matching the specifications defined in file INSTTBL\n"));
 389 #endif
 390   fprintf (stream, _("\
 391   -w                      ignored\n"));
 392   fprintf (stream, _("\
 393   -X                      ignored\n"));
 394   fprintf (stream, _("\
 395   -Z                      generate object file even after errors\n"));
 396   fprintf (stream, _("\
 397   --listing-lhs-width     set the width in words of the output data column of\n\
 398                           the listing\n"));
 399   fprintf (stream, _("\
 400   --listing-lhs-width2    set the width in words of the continuation lines\n\
 401                           of the output data column; ignored if smaller than\n\
 402                           the width of the first line\n"));
 403   fprintf (stream, _("\
 404   --listing-rhs-width     set the max width in characters of the lines from\n\
 405                           the source file\n"));
 406   fprintf (stream, _("\
 407   --listing-cont-lines    set the maximum number of continuation lines used\n\
 408                           for the output data column of the listing\n"));
 409   fprintf (stream, _("\
 410   @FILE                   read options from FILE\n"));
 411
 412   md_show_usage (stream);
 413
 414   fputc ('\n', stream);
 415
 416   if (REPORT_BUGS_TO[0] && stream == stdout)
 417     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 418 }
 419
 420 /* Since it is easy to do here we interpret the special arg "-"
 421    to mean "use stdin" and we set that argv[] pointing to "".
 422    After we have munged argv[], the only things left are source file
 423    name(s) and ""(s) denoting stdin. These file names are used
 424    (perhaps more than once) later.
 425
 426    check for new machine-dep cmdline options in
 427    md_parse_option definitions in config/tc-*.c.  */
 428
 429 static void
 430 parse_args (int * pargc, char *** pargv)
 431 {
 432   int old_argc;
 433   int new_argc;
 434   char ** old_argv;
 435   char ** new_argv;
 436   /* Starting the short option string with '-' is for programs that
 437      expect options and other ARGV-elements in any order and that care about
 438      the ordering of the two.  We describe each non-option ARGV-element
 439      as if it were the argument of an option with character code 1.  */
 440   char *shortopts;
 441   static const char std_shortopts[] =
 442   {
 443     '-', 'J',
 444 #ifndef WORKING_DOT_WORD
 445     /* -K is not meaningful if .word is not being hacked.  */
 446     'K',
 447 #endif
 448     'L', 'M', 'R', 'W', 'Z', 'a', ':', ':', 'D', 'f', 'g', ':',':', 'I', ':',
 449     'o', ':', 'v', 'w', 'X',
 450 #ifdef HAVE_ITBL_CPU
 451     /* New option for extending instruction set (see also --itbl below).  */
 452     't', ':',
 453 #endif
 454     '\0'
 455   };
 456   struct option *longopts;
 457   /* Codes used for the long options with no short synonyms.  */
 458   enum option_values
 459     {
 460       OPTION_HELP = OPTION_STD_BASE,
 461       OPTION_NOCPP,
 462       OPTION_STATISTICS,
 463       OPTION_VERSION,
 464       OPTION_DUMPCONFIG,
 465       OPTION_EMULATION,
 466       OPTION_DEBUG_PREFIX_MAP,
 467       OPTION_DEFSYM,
 468       OPTION_LISTING_LHS_WIDTH,
 469       OPTION_LISTING_LHS_WIDTH2, /* = STD_BASE + 10 */
 470       OPTION_LISTING_RHS_WIDTH,
 471       OPTION_LISTING_CONT_LINES,
 472       OPTION_DEPFILE,
 473       OPTION_GSTABS,
 474       OPTION_GSTABS_PLUS,
 475       OPTION_GDWARF_2,
 476       OPTION_GDWARF_3,
 477       OPTION_GDWARF_4,
 478       OPTION_GDWARF_5,
 479       OPTION_GDWARF_SECTIONS, /* = STD_BASE + 20 */
 480       OPTION_GDWARF_CIE_VERSION,
 481       OPTION_GCODEVIEW,
 482       OPTION_STRIP_LOCAL_ABSOLUTE,
 483       OPTION_TRADITIONAL_FORMAT,
 484       OPTION_WARN,
 485       OPTION_TARGET_HELP,
 486       OPTION_EXECSTACK,
 487       OPTION_NOEXECSTACK,
 488       OPTION_SIZE_CHECK,
 489       OPTION_ELF_STT_COMMON,
 490       OPTION_ELF_BUILD_NOTES, /* = STD_BASE + 30 */
 491       OPTION_SECTNAME_SUBST,
 492       OPTION_ALTERNATE,
 493       OPTION_AL,
 494       OPTION_HASH_TABLE_SIZE,
 495       OPTION_REDUCE_MEMORY_OVERHEADS,
 496       OPTION_WARN_FATAL,
 497       OPTION_COMPRESS_DEBUG,
 498       OPTION_NOCOMPRESS_DEBUG,
 499       OPTION_NO_PAD_SECTIONS,
 500       OPTION_MULTIBYTE_HANDLING,  /* = STD_BASE + 40 */
 501       OPTION_SFRAME,
 502       OPTION_SCFI
 503     /* When you add options here, check that they do
 504        not collide with OPTION_MD_BASE.  See as.h.  */
 505     };
 506
 507   static const struct option std_longopts[] =
 508   {
 509     /* Note: commas are placed at the start of the line rather than
 510        the end of the preceding line so that it is simpler to
 511        selectively add and remove lines from this list.  */
 512     {"alternate", no_argument, NULL, OPTION_ALTERNATE}
 513     /* The entry for "a" is here to prevent getopt_long_only() from
 514        considering that -a is an abbreviation for --alternate.  This is
 515        necessary because -a=<FILE> is a valid switch but getopt would
 516        normally reject it since --alternate does not take an argument.  */
 517     ,{"a", optional_argument, NULL, 'a'}
 518     /* Handle -al=<FILE>.  */
 519     ,{"al", optional_argument, NULL, OPTION_AL}
 520     ,{"compress-debug-sections", optional_argument, NULL, OPTION_COMPRESS_DEBUG}
 521     ,{"nocompress-debug-sections", no_argument, NULL, OPTION_NOCOMPRESS_DEBUG}
 522     ,{"debug-prefix-map", required_argument, NULL, OPTION_DEBUG_PREFIX_MAP}
 523     ,{"defsym", required_argument, NULL, OPTION_DEFSYM}
 524     ,{"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}
 525     ,{"emulation", required_argument, NULL, OPTION_EMULATION}
 526 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 527     ,{"execstack", no_argument, NULL, OPTION_EXECSTACK}
 528     ,{"noexecstack", no_argument, NULL, OPTION_NOEXECSTACK}
 529     ,{"size-check", required_argument, NULL, OPTION_SIZE_CHECK}
 530     ,{"elf-stt-common", required_argument, NULL, OPTION_ELF_STT_COMMON}
 531     ,{"sectname-subst", no_argument, NULL, OPTION_SECTNAME_SUBST}
 532     ,{"generate-missing-build-notes", required_argument, NULL, OPTION_ELF_BUILD_NOTES}
 533     ,{"gsframe", no_argument, NULL, OPTION_SFRAME}
 534 # if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
 535     ,{"scfi", required_argument, NULL, OPTION_SCFI}
 536 # endif
 537 #endif /* OBJ_ELF || OBJ_MAYBE_ELF.  */
 538     ,{"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
 539     ,{"gdwarf-2", no_argument, NULL, OPTION_GDWARF_2}
 540     ,{"gdwarf-3", no_argument, NULL, OPTION_GDWARF_3}
 541     ,{"gdwarf-4", no_argument, NULL, OPTION_GDWARF_4}
 542     ,{"gdwarf-5", no_argument, NULL, OPTION_GDWARF_5}
 543     /* GCC uses --gdwarf-2 but GAS used to to use --gdwarf2,
 544        so we keep it here for backwards compatibility.  */
 545     ,{"gdwarf2", no_argument, NULL, OPTION_GDWARF_2}
 546     ,{"gdwarf-sections", no_argument, NULL, OPTION_GDWARF_SECTIONS}
 547     ,{"gdwarf-cie-version", required_argument, NULL, OPTION_GDWARF_CIE_VERSION}
 548 #if defined (TE_PE) && defined (O_secrel)
 549     ,{"gcodeview", no_argument, NULL, OPTION_GCODEVIEW}
 550 #endif
 551     ,{"gen-debug", no_argument, NULL, 'g'}
 552     ,{"gstabs", no_argument, NULL, OPTION_GSTABS}
 553     ,{"gstabs+", no_argument, NULL, OPTION_GSTABS_PLUS}
 554     ,{"hash-size", required_argument, NULL, OPTION_HASH_TABLE_SIZE}
 555     ,{"help", no_argument, NULL, OPTION_HELP}
 556 #ifdef HAVE_ITBL_CPU
 557     /* New option for extending instruction set (see also -t above).
 558        The "-t file" or "--itbl file" option extends the basic set of
 559        valid instructions by reading "file", a text file containing a
 560        list of instruction formats.  The additional opcodes and their
 561        formats are added to the built-in set of instructions, and
 562        mnemonics for new registers may also be defined.  */
 563     ,{"itbl", required_argument, NULL, 't'}
 564 #endif
 565     /* getopt allows abbreviations, so we do this to stop it from
 566        treating -k as an abbreviation for --keep-locals.  Some
 567        ports use -k to enable PIC assembly.  */
 568     ,{"keep-locals", no_argument, NULL, 'L'}
 569     ,{"keep-locals", no_argument, NULL, 'L'}
 570     ,{"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}
 571     ,{"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}
 572     ,{"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}
 573     ,{"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}
 574     ,{"MD", required_argument, NULL, OPTION_DEPFILE}
 575     ,{"mri", no_argument, NULL, 'M'}
 576     ,{"nocpp", no_argument, NULL, OPTION_NOCPP}
 577     ,{"no-pad-sections", no_argument, NULL, OPTION_NO_PAD_SECTIONS}
 578     ,{"no-warn", no_argument, NULL, 'W'}
 579     ,{"reduce-memory-overheads", no_argument, NULL, OPTION_REDUCE_MEMORY_OVERHEADS}
 580     ,{"statistics", no_argument, NULL, OPTION_STATISTICS}
 581     ,{"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}
 582     ,{"version", no_argument, NULL, OPTION_VERSION}
 583     ,{"verbose", no_argument, NULL, 'v'}
 584     ,{"target-help", no_argument, NULL, OPTION_TARGET_HELP}
 585     ,{"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
 586     ,{"warn", no_argument, NULL, OPTION_WARN}
 587     ,{"multibyte-handling", required_argument, NULL, OPTION_MULTIBYTE_HANDLING}
 588   };
 589
 590   /* Construct the option lists from the standard list and the target
 591      dependent list.  Include space for an extra NULL option and
 592      always NULL terminate.  */
 593   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 594   longopts = (struct option *) xmalloc (sizeof (std_longopts)
 595                                         + md_longopts_size + sizeof (struct option));
 596   memcpy (longopts, std_longopts, sizeof (std_longopts));
 597   memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
 598   memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
 599           0, sizeof (struct option));
 600
 601   /* Make a local copy of the old argv.  */
 602   old_argc = *pargc;
 603   old_argv = *pargv;
 604
 605   /* Initialize a new argv that contains no options.  */
 606   new_argv = notes_alloc (sizeof (char *) * (old_argc + 1));
 607   new_argv[0] = old_argv[0];
 608   new_argc = 1;
 609   new_argv[new_argc] = NULL;
 610
 611   while (1)
 612     {
 613       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 614          indicate a long option.  */
 615       int longind;
 616       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 617                                    &longind);
 618
 619       if (optc == -1)
 620         break;
 621
 622       switch (optc)
 623         {
 624         default:
 625           /* md_parse_option should return 1 if it recognizes optc,
 626              0 if not.  */
 627           if (md_parse_option (optc, optarg) != 0)
 628             break;
 629           /* `-v' isn't included in the general short_opts list, so check for
 630              it explicitly here before deciding we've gotten a bad argument.  */
 631           if (optc == 'v')
 632             {
 633         case 'v':
 634               print_version_id ();
 635               verbose = 1;
 636               break;
 637             }
 638           else if (is_a_char (optc))
 639             as_bad (_("unrecognized option `-%c%s'"), optc, optarg ? optarg : "");
 640           else if (optarg)
 641             as_bad (_("unrecognized option `--%s=%s'"), longopts[longind].name, optarg);
 642           else
 643             as_bad (_("unrecognized option `--%s'"), longopts[longind].name);
 644           /* Fall through.  */
 645
 646         case '?':
 647           exit (EXIT_FAILURE);
 648
 649         case 1:                 /* File name.  */
 650           if (!strcmp (optarg, "-"))
 651             optarg = (char *) "";
 652           new_argv[new_argc++] = optarg;
 653           new_argv[new_argc] = NULL;
 654           break;
 655
 656         case OPTION_TARGET_HELP:
 657           md_show_usage (stdout);
 658           exit (EXIT_SUCCESS);
 659
 660         case OPTION_HELP:
 661           show_usage (stdout);
 662           exit (EXIT_SUCCESS);
 663
 664         case OPTION_NOCPP:
 665           break;
 666
 667         case OPTION_NO_PAD_SECTIONS:
 668           do_not_pad_sections_to_alignment = 1;
 669           break;
 670
 671         case OPTION_STATISTICS:
 672           flag_print_statistics = 1;
 673           break;
 674
 675         case OPTION_STRIP_LOCAL_ABSOLUTE:
 676           flag_strip_local_absolute = 1;
 677           break;
 678
 679         case OPTION_TRADITIONAL_FORMAT:
 680           flag_traditional_format = 1;
 681           break;
 682
 683         case OPTION_MULTIBYTE_HANDLING:
 684           if (strcmp (optarg, "allow") == 0)
 685             multibyte_handling = multibyte_allow;
 686           else if (strcmp (optarg, "warn") == 0)
 687             multibyte_handling = multibyte_warn;
 688           else if (strcmp (optarg, "warn-sym-only") == 0)
 689             multibyte_handling = multibyte_warn_syms;
 690           else if (strcmp (optarg, "warn_sym_only") == 0)
 691             multibyte_handling = multibyte_warn_syms;
 692           else
 693             as_fatal (_("unexpected argument to --multibyte-input-option: '%s'"), optarg);
 694           break;
 695
 696         case OPTION_VERSION:
 697           /* This output is intended to follow the GNU standards document.  */
 698           printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
 699           printf (_("Copyright (C) 2024 Free Software Foundation, Inc.\n"));
 700           printf (_("\
 701 This program is free software; you may redistribute it under the terms of\n\
 702 the GNU General Public License version 3 or later.\n\
 703 This program has absolutely no warranty.\n"));
 704 #ifdef TARGET_WITH_CPU
 705           printf (_("This assembler was configured for a target of `%s' "
 706                     "and default,\ncpu type `%s'.\n"),
 707                   TARGET_ALIAS, TARGET_WITH_CPU);
 708 #else
 709           printf (_("This assembler was configured for a target of `%s'.\n"),
 710                   TARGET_ALIAS);
 711 #endif
 712           exit (EXIT_SUCCESS);
 713
 714         case OPTION_EMULATION:
 715 #ifdef USE_EMULATIONS
 716           if (strcmp (optarg, this_emulation->name))
 717             as_fatal (_("multiple emulation names specified"));
 718 #else
 719           as_fatal (_("emulations not handled in this configuration"));
 720 #endif
 721           break;
 722
 723         case OPTION_DUMPCONFIG:
 724           fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
 725           fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
 726           fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
 727 #ifdef TARGET_OBJ_FORMAT
 728           fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
 729 #endif
 730 #ifdef TARGET_FORMAT
 731           fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
 732 #endif
 733           exit (EXIT_SUCCESS);
 734
 735         case OPTION_COMPRESS_DEBUG:
 736           if (optarg)
 737             {
 738 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 739               flag_compress_debug = bfd_get_compression_algorithm (optarg);
 740 #ifndef HAVE_ZSTD
 741               if (flag_compress_debug == COMPRESS_DEBUG_ZSTD)
 742                   as_fatal (_ ("--compress-debug-sections=zstd: gas is not "
 743                                "built with zstd support"));
 744 #endif
 745               if (flag_compress_debug == COMPRESS_UNKNOWN)
 746                 as_fatal (_("Invalid --compress-debug-sections option: `%s'"),
 747                           optarg);
 748 #else
 749               as_fatal (_("--compress-debug-sections=%s is unsupported"),
 750                         optarg);
 751 #endif
 752             }
 753           else
 754             flag_compress_debug = DEFAULT_COMPRESSED_DEBUG_ALGORITHM;
 755           break;
 756
 757         case OPTION_NOCOMPRESS_DEBUG:
 758           flag_compress_debug = COMPRESS_DEBUG_NONE;
 759           break;
 760
 761         case OPTION_DEBUG_PREFIX_MAP:
 762           add_debug_prefix_map (optarg);
 763           break;
 764
 765         case OPTION_DEFSYM:
 766           {
 767             char *s;
 768             valueT i;
 769             struct defsym_list *n;
 770
 771             for (s = optarg; *s != '\0' && *s != '='; s++)
 772               ;
 773             if (*s == '\0')
 774               as_fatal (_("bad defsym; format is --defsym name=value"));
 775             *s++ = '\0';
 776             i = bfd_scan_vma (s, (const char **) NULL, 0);
 777             n = XNEW (struct defsym_list);
 778             n->next = defsyms;
 779             n->name = optarg;
 780             n->value = i;
 781             defsyms = n;
 782           }
 783           break;
 784
 785 #ifdef HAVE_ITBL_CPU
 786         case 't':
 787           {
 788             /* optarg is the name of the file containing the instruction
 789                formats, opcodes, register names, etc.  */
 790             if (optarg == NULL)
 791               {
 792                 as_warn (_("no file name following -t option"));
 793                 break;
 794               }
 795
 796             /* Parse the file and add the new instructions to our internal
 797                table.  If multiple instruction tables are specified, the
 798                information from this table gets appended onto the existing
 799                internal table.  */
 800             if (itbl_parse (optarg) != 0)
 801               as_fatal (_("failed to read instruction table %s\n"),
 802                         optarg);
 803           }
 804           break;
 805 #endif
 806
 807         case OPTION_DEPFILE:
 808           start_dependencies (optarg);
 809           break;
 810
 811         case 'g':
 812           /* Some backends, eg Alpha and Mips, use the -g switch for their
 813              own purposes.  So we check here for an explicit -g and allow
 814              the backend to decide if it wants to process it.  */
 815           if (   old_argv[optind - 1][1] == 'g'
 816               && md_parse_option (optc, optarg))
 817             continue;
 818
 819           /* We end up here for any -gsomething-not-already-a-long-option.
 820              give some useful feedback on not (yet) supported -gdwarfxxx
 821              versions/sections/options.  */
 822           if (startswith (old_argv[optind - 1], "-gdwarf"))
 823             as_fatal (_("unknown DWARF option %s\n"), old_argv[optind - 1]);
 824           else if (old_argv[optind - 1][1] == 'g' && optarg != NULL)
 825             as_fatal (_("unknown option `%s'"), old_argv[optind - 1]);
 826
 827           if (md_debug_format_selector)
 828             debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
 829           else if (IS_ELF)
 830             {
 831               debug_type = DEBUG_DWARF2;
 832               dwarf_level = 2;
 833             }
 834           else
 835             debug_type = DEBUG_STABS;
 836           break;
 837
 838         case OPTION_GSTABS_PLUS:
 839           use_gnu_debug_info_extensions = 1;
 840           /* Fall through.  */
 841         case OPTION_GSTABS:
 842           debug_type = DEBUG_STABS;
 843           break;
 844
 845         case OPTION_GDWARF_2:
 846           debug_type = DEBUG_DWARF2;
 847           dwarf_level = 2;
 848           break;
 849
 850         case OPTION_GDWARF_3:
 851           debug_type = DEBUG_DWARF2;
 852           dwarf_level = 3;
 853           break;
 854
 855         case OPTION_GDWARF_4:
 856           debug_type = DEBUG_DWARF2;
 857           dwarf_level = 4;
 858           break;
 859
 860         case OPTION_GDWARF_5:
 861           debug_type = DEBUG_DWARF2;
 862           dwarf_level = 5;
 863           break;
 864
 865         case OPTION_GDWARF_SECTIONS:
 866           flag_dwarf_sections = true;
 867           break;
 868
 869 #if defined (TE_PE) && defined (O_secrel)
 870         case OPTION_GCODEVIEW:
 871           debug_type = DEBUG_CODEVIEW;
 872           break;
 873 #endif
 874
 875         case OPTION_GDWARF_CIE_VERSION:
 876           flag_dwarf_cie_version = atoi (optarg);
 877           /* The available CIE versions are 1 (DWARF 2), 3 (DWARF 3), and 4
 878              (DWARF 4 and 5).  */
 879           if (flag_dwarf_cie_version < 1
 880               || flag_dwarf_cie_version == 2
 881               || flag_dwarf_cie_version > 4)
 882             as_fatal (_("Invalid --gdwarf-cie-version `%s'"), optarg);
 883           switch (flag_dwarf_cie_version)
 884             {
 885             case 1:
 886               if (dwarf_level < 2)
 887                 dwarf_level = 2;
 888               break;
 889             case 3:
 890               if (dwarf_level < 3)
 891                 dwarf_level = 3;
 892               break;
 893             default:
 894               if (dwarf_level < 4)
 895                 dwarf_level = 4;
 896               break;
 897             }
 898           break;
 899
 900         case 'J':
 901           flag_signed_overflow_ok = 1;
 902           break;
 903
 904 #ifndef WORKING_DOT_WORD
 905         case 'K':
 906           flag_warn_displacement = 1;
 907           break;
 908 #endif
 909         case 'L':
 910           flag_keep_locals = 1;
 911           break;
 912
 913         case OPTION_LISTING_LHS_WIDTH:
 914           listing_lhs_width = atoi (optarg);
 915           if (listing_lhs_width_second < listing_lhs_width)
 916             listing_lhs_width_second = listing_lhs_width;
 917           break;
 918         case OPTION_LISTING_LHS_WIDTH2:
 919           {
 920             int tmp = atoi (optarg);
 921
 922             if (tmp > listing_lhs_width)
 923               listing_lhs_width_second = tmp;
 924           }
 925           break;
 926         case OPTION_LISTING_RHS_WIDTH:
 927           listing_rhs_width = atoi (optarg);
 928           break;
 929         case OPTION_LISTING_CONT_LINES:
 930           listing_lhs_cont_lines = atoi (optarg);
 931           break;
 932
 933         case 'M':
 934           flag_mri = 1;
 935 #ifdef TC_M68K
 936           flag_m68k_mri = 1;
 937 #endif
 938           break;
 939
 940         case 'R':
 941           flag_readonly_data_in_text = 1;
 942           break;
 943
 944         case 'W':
 945           flag_no_warnings = 1;
 946           break;
 947
 948         case OPTION_WARN:
 949           flag_no_warnings = 0;
 950           flag_fatal_warnings = 0;
 951           break;
 952
 953         case OPTION_WARN_FATAL:
 954           flag_no_warnings = 0;
 955           flag_fatal_warnings = 1;
 956           break;
 957
 958 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 959         case OPTION_EXECSTACK:
 960           flag_execstack = 1;
 961           flag_noexecstack = 0;
 962           break;
 963
 964         case OPTION_NOEXECSTACK:
 965           flag_noexecstack = 1;
 966           flag_execstack = 0;
 967           break;
 968
 969 # if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
 970         case OPTION_SCFI:
 971           if (optarg && strcasecmp (optarg, "experimental") == 0)
 972             flag_synth_cfi = SYNTH_CFI_EXPERIMENTAL;
 973           else
 974             as_fatal (_("Invalid --scfi= option: `%s'; suggested option: experimental"),
 975                       optarg);
 976           break;
 977 # endif
 978
 979         case OPTION_SIZE_CHECK:
 980           if (strcasecmp (optarg, "error") == 0)
 981             flag_allow_nonconst_size = false;
 982           else if (strcasecmp (optarg, "warning") == 0)
 983             flag_allow_nonconst_size = true;
 984           else
 985             as_fatal (_("Invalid --size-check= option: `%s'"), optarg);
 986           break;
 987
 988         case OPTION_ELF_STT_COMMON:
 989           if (strcasecmp (optarg, "no") == 0)
 990             flag_use_elf_stt_common = 0;
 991           else if (strcasecmp (optarg, "yes") == 0)
 992             flag_use_elf_stt_common = 1;
 993           else
 994             as_fatal (_("Invalid --elf-stt-common= option: `%s'"),
 995                       optarg);
 996           break;
 997
 998         case OPTION_SECTNAME_SUBST:
 999           flag_sectname_subst = 1;
1000           break;
1001
1002         case OPTION_ELF_BUILD_NOTES:
1003           if (strcasecmp (optarg, "no") == 0)
1004             flag_generate_build_notes = false;
1005           else if (strcasecmp (optarg, "yes") == 0)
1006             flag_generate_build_notes = true;
1007           else
1008             as_fatal (_("Invalid --generate-missing-build-notes option: `%s'"),
1009                       optarg);
1010           break;
1011
1012         case OPTION_SFRAME:
1013           flag_gen_sframe = 1;
1014           break;
1015
1016 #endif /* OBJ_ELF */
1017
1018         case 'Z':
1019           flag_always_generate_output = 1;
1020           break;
1021
1022         case OPTION_AL:
1023           listing |= LISTING_LISTING;
1024           if (optarg)
1025             listing_filename = notes_strdup (optarg);
1026           break;
1027
1028         case OPTION_ALTERNATE:
1029           optarg = old_argv [optind - 1];
1030           while (* optarg == '-')
1031             optarg ++;
1032
1033           if (strcmp (optarg, "alternate") == 0)
1034             {
1035               flag_macro_alternate = 1;
1036               break;
1037             }
1038           optarg ++;
1039           /* Fall through.  */
1040
1041         case 'a':
1042           if (optarg)
1043             {
1044               if (optarg != old_argv[optind] && optarg[-1] == '=')
1045                 --optarg;
1046
1047               if (md_parse_option (optc, optarg) != 0)
1048                 break;
1049
1050               while (*optarg)
1051                 {
1052                   switch (*optarg)
1053                     {
1054                     case 'c':
1055                       listing |= LISTING_NOCOND;
1056                       break;
1057                     case 'd':
1058                       listing |= LISTING_NODEBUG;
1059                       break;
1060                     case 'g':
1061                       listing |= LISTING_GENERAL;
1062                       break;
1063                     case 'h':
1064                       listing |= LISTING_HLL;
1065                       break;
1066                     case 'i':
1067                       listing |= LISTING_GINSN_SCFI;
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 \f
1166 /* Here to attempt 1 pass over each input file.
1167    We scan argv[*] looking for filenames or exactly "" which is
1168    shorthand for stdin. Any argv that is NULL is not a file-name.
1169    We set need_pass_2 TRUE if, after this, we still have unresolved
1170    expressions of the form (unknown value)+-(unknown value).
1171
1172    Note the un*x semantics: there is only 1 logical input file, but it
1173    may be a catenation of many 'physical' input files.  */
1174
1175 static void
1176 perform_an_assembly_pass (int argc, char ** argv)
1177 {
1178   int saw_a_file = 0;
1179 #ifndef OBJ_MACH_O
1180   flagword applicable;
1181 #endif
1182
1183   need_pass_2 = 0;
1184
1185 #ifndef OBJ_MACH_O
1186   /* Create the standard sections, and those the assembler uses
1187      internally.  */
1188   text_section = subseg_new (TEXT_SECTION_NAME, 0);
1189   data_section = subseg_new (DATA_SECTION_NAME, 0);
1190   bss_section = subseg_new (BSS_SECTION_NAME, 0);
1191   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1192      to have relocs, otherwise we don't find out in time.  */
1193   applicable = bfd_applicable_section_flags (stdoutput);
1194   bfd_set_section_flags (text_section,
1195                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1196                                        | SEC_CODE | SEC_READONLY));
1197   bfd_set_section_flags (data_section,
1198                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1199                                        | SEC_DATA));
1200   bfd_set_section_flags (bss_section, applicable & SEC_ALLOC);
1201   seg_info (bss_section)->bss = 1;
1202 #endif
1203   subseg_new (BFD_ABS_SECTION_NAME, 0);
1204   subseg_new (BFD_UND_SECTION_NAME, 0);
1205   reg_section = subseg_new ("*GAS `reg' section*", 0);
1206   expr_section = subseg_new ("*GAS `expr' section*", 0);
1207
1208 #ifndef OBJ_MACH_O
1209   subseg_set (text_section, 0);
1210 #endif
1211
1212   /* This may add symbol table entries, which requires having an open BFD,
1213      and sections already created.  */
1214   md_begin ();
1215
1216 #ifdef USING_CGEN
1217   gas_cgen_begin ();
1218 #endif
1219 #ifdef obj_begin
1220   obj_begin ();
1221 #endif
1222
1223   /* Skip argv[0].  */
1224   argv++;
1225   argc--;
1226
1227   while (argc--)
1228     {
1229       if (*argv)
1230         {                       /* Is it a file-name argument?  */
1231           saw_a_file++;
1232           /* argv->"" if stdin desired, else->filename.  */
1233           read_a_source_file (*argv);
1234         }
1235       argv++;                   /* Completed that argv.  */
1236     }
1237   if (!saw_a_file)
1238     read_a_source_file ("");
1239 }
1240
1241 static void
1242 free_notes (void)
1243 {
1244   _obstack_free (&notes, NULL);
1245 }
1246
1247 /* Early initialisation, before gas prints messages.  */
1248
1249 static void
1250 gas_early_init (int *argcp, char ***argvp)
1251 {
1252   start_time = get_run_time ();
1253   signal_init ();
1254
1255 #ifdef HAVE_LC_MESSAGES
1256   setlocale (LC_MESSAGES, "");
1257 #endif
1258   setlocale (LC_CTYPE, "");
1259   bindtextdomain (PACKAGE, LOCALEDIR);
1260   textdomain (PACKAGE);
1261
1262   if (debug_memory)
1263     chunksize = 64;
1264
1265 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1266 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1267 #endif
1268
1269   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1270
1271   hex_init ();
1272   if (bfd_init () != BFD_INIT_MAGIC)
1273     as_fatal (_("libbfd ABI mismatch"));
1274
1275   obstack_begin (&notes, chunksize);
1276   xatexit (free_notes);
1277
1278   myname = **argvp;
1279   xmalloc_set_program_name (myname);
1280   bfd_set_error_program_name (myname);
1281
1282   expandargv (argcp, argvp);
1283
1284   init_include_dir ();
1285
1286 #ifdef HOST_SPECIAL_INIT
1287   HOST_SPECIAL_INIT (*argcp, *argvp);
1288 #endif
1289
1290 #ifdef USE_EMULATIONS
1291   select_emulation_mode (*argcp, *argvp);
1292 #endif
1293 }
1294
1295 /* The bulk of gas initialisation.  This is after args are parsed.  */
1296
1297 static void
1298 gas_init (void)
1299 {
1300   symbol_begin ();
1301   frag_init ();
1302   subsegs_begin ();
1303   read_begin ();
1304   input_scrub_begin ();
1305   expr_begin ();
1306   eh_begin ();
1307
1308   macro_init ();
1309
1310   dwarf2_init ();
1311
1312   local_symbol_make (".gasversion.", absolute_section,
1313                      &predefined_address_frag, BFD_VERSION / 10000UL);
1314
1315   /* Note: Put new initialisation calls that don't depend on stdoutput
1316      being open above this point.  stdoutput must be open for anything
1317      that might use stdoutput objalloc memory, eg. calling bfd_alloc
1318      or creating global symbols (via bfd_make_empty_symbol).  */
1319   xatexit (output_file_close);
1320   output_file_create (out_file_name);
1321   gas_assert (stdoutput != 0);
1322
1323   /* Must be called before output_file_close.  xexit calls the xatexit
1324      list in reverse order.  */
1325   if (flag_print_statistics)
1326     xatexit (dump_statistics);
1327
1328   dot_symbol_init ();
1329
1330 #ifdef tc_init_after_args
1331   tc_init_after_args ();
1332 #endif
1333
1334   itbl_init ();
1335
1336   /* Now that we have fully initialized, and have created the output
1337      file, define any symbols requested by --defsym command line
1338      arguments.  */
1339   while (defsyms != NULL)
1340     {
1341       symbolS *sym;
1342       struct defsym_list *next;
1343
1344       sym = symbol_new (defsyms->name, absolute_section,
1345                         &zero_address_frag, defsyms->value);
1346       /* Make symbols defined on the command line volatile, so that they
1347          can be redefined inside a source file.  This makes this assembler's
1348          behaviour compatible with earlier versions, but it may not be
1349          completely intuitive.  */
1350       S_SET_VOLATILE (sym);
1351       symbol_table_insert (sym);
1352       next = defsyms->next;
1353       free (defsyms);
1354       defsyms = next;
1355     }
1356 }
1357
1358 int
1359 main (int argc, char ** argv)
1360 {
1361   char ** argv_orig = argv;
1362   struct stat sob;
1363
1364   gas_early_init (&argc, &argv);
1365
1366   /* Call parse_args before gas_init so that switches like
1367      --hash-size can be honored.  */
1368   parse_args (&argc, &argv);
1369
1370   if (argc > 1 && stat (out_file_name, &sob) == 0)
1371     {
1372       int i;
1373
1374       for (i = 1; i < argc; ++i)
1375         {
1376           struct stat sib;
1377
1378           /* Check that the input file and output file are different.  */
1379           if (stat (argv[i], &sib) == 0
1380               && sib.st_ino == sob.st_ino
1381               /* POSIX emulating systems may support stat() but if the
1382                  underlying file system does not support a file serial number
1383                  of some kind then they will return 0 for the inode.  So
1384                  two files with an inode of 0 may not actually be the same.
1385                  On real POSIX systems no ordinary file will ever have an
1386                  inode of 0.  */
1387               && sib.st_ino != 0
1388               /* Different files may have the same inode number if they
1389                  reside on different devices, so check the st_dev field as
1390                  well.  */
1391               && sib.st_dev == sob.st_dev
1392               /* PR 25572: Only check regular files.  Devices, sockets and so
1393                  on might actually work as both input and output.  Plus there
1394                  is a use case for using /dev/null as both input and output
1395                  when checking for command line option support in a script:
1396                    as --foo /dev/null -o /dev/null; if $? then ...  */
1397               && S_ISREG (sib.st_mode))
1398             {
1399               const char *saved_out_file_name = out_file_name;
1400
1401               /* Don't let as_fatal remove the output file!  */
1402               out_file_name = NULL;
1403               as_fatal (_("The input '%s' and output '%s' files are the same"),
1404                         argv[i], saved_out_file_name);
1405             }
1406         }
1407     }
1408
1409   gas_init ();
1410
1411   /* Assemble it.  */
1412   perform_an_assembly_pass (argc, argv);
1413
1414   cond_finish_check (-1);
1415
1416 #ifdef md_finish
1417   md_finish ();
1418 #endif
1419
1420 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
1421   if ((flag_execstack || flag_noexecstack)
1422       && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1423     {
1424       segT gnustack;
1425
1426       gnustack = subseg_new (".note.GNU-stack", 0);
1427       bfd_set_section_flags (gnustack,
1428                              SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1429
1430     }
1431 #endif
1432
1433   codeview_finish ();
1434
1435   /* If we've been collecting dwarf2 .debug_line info, either for
1436      assembly debugging or on behalf of the compiler, emit it now.  */
1437   dwarf2_finish ();
1438
1439   /* If we constructed dwarf2 .eh_frame info, either via .cfi
1440      directives from the user or by the backend, emit it now.  */
1441   cfi_finish ();
1442
1443   keep_it = 0;
1444   if (seen_at_least_1_file ())
1445     {
1446       int n_warns, n_errs;
1447       char warn_msg[50];
1448       char err_msg[50];
1449
1450       write_object_file ();
1451
1452       n_warns = had_warnings ();
1453       n_errs = had_errors ();
1454
1455       sprintf (warn_msg,
1456                ngettext ("%d warning", "%d warnings", n_warns), n_warns);
1457       sprintf (err_msg,
1458                ngettext ("%d error", "%d errors", n_errs), n_errs);
1459       if (flag_fatal_warnings && n_warns != 0)
1460         {
1461           if (n_errs == 0)
1462             as_bad (_("%s, treating warnings as errors"), warn_msg);
1463           n_errs += n_warns;
1464         }
1465
1466       if (n_errs == 0)
1467         keep_it = 1;
1468       else if (flag_always_generate_output)
1469         {
1470           /* The -Z flag indicates that an object file should be generated,
1471              regardless of warnings and errors.  */
1472           keep_it = 1;
1473           fprintf (stderr, _("%s, %s, generating bad object file\n"),
1474                    err_msg, warn_msg);
1475         }
1476     }
1477
1478   fflush (stderr);
1479
1480 #ifndef NO_LISTING
1481   listing_print (listing_filename, argv_orig);
1482 #endif
1483
1484   input_scrub_end ();
1485
1486   /* Use xexit instead of return, because under VMS environments they
1487      may not place the same interpretation on the value given.  */
1488   if (had_errors () != 0)
1489     xexit (EXIT_FAILURE);
1490
1491   /* Only generate dependency file if assembler was successful.  */
1492   print_dependencies ();
1493
1494   xexit (EXIT_SUCCESS);
1495 }