gas/as.c

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