gas/as.c

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