gas/as.c

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