gas/as.c

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