gas/as.c

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