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