gas/as.c

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