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