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