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