gas/as.c

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