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\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", no_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           flag_compress_debug = 1;
 659           break;
 660
 661         case OPTION_NOCOMPRESS_DEBUG:
 662           flag_compress_debug = 0;
 663           break;
 664
 665         case OPTION_DEBUG_PREFIX_MAP:
 666           add_debug_prefix_map (optarg);
 667           break;
 668
 669         case OPTION_DEFSYM:
 670           {
 671             char *s;
 672             valueT i;
 673             struct defsym_list *n;
 674
 675             for (s = optarg; *s != '\0' && *s != '='; s++)
 676               ;
 677             if (*s == '\0')
 678               as_fatal (_("bad defsym; format is --defsym name=value"));
 679             *s++ = '\0';
 680             i = bfd_scan_vma (s, (const char **) NULL, 0);
 681             n = (struct defsym_list *) xmalloc (sizeof *n);
 682             n->next = defsyms;
 683             n->name = optarg;
 684             n->value = i;
 685             defsyms = n;
 686           }
 687           break;
 688
 689 #ifdef HAVE_ITBL_CPU
 690         case 't':
 691           {
 692             /* optarg is the name of the file containing the instruction
 693                formats, opcodes, register names, etc.  */
 694             struct itbl_file_list *n;
 695
 696             if (optarg == NULL)
 697               {
 698                 as_warn (_("no file name following -t option"));
 699                 break;
 700               }
 701
 702             n = xmalloc (sizeof * n);
 703             n->next = itbl_files;
 704             n->name = optarg;
 705             itbl_files = n;
 706
 707             /* Parse the file and add the new instructions to our internal
 708                table.  If multiple instruction tables are specified, the
 709                information from this table gets appended onto the existing
 710                internal table.  */
 711             itbl_files->name = xstrdup (optarg);
 712             if (itbl_parse (itbl_files->name) != 0)
 713               as_fatal (_("failed to read instruction table %s\n"),
 714                         itbl_files->name);
 715           }
 716           break;
 717 #endif
 718
 719         case OPTION_DEPFILE:
 720           start_dependencies (optarg);
 721           break;
 722
 723         case 'g':
 724           /* Some backends, eg Alpha and Mips, use the -g switch for their
 725              own purposes.  So we check here for an explicit -g and allow
 726              the backend to decide if it wants to process it.  */
 727           if (   old_argv[optind - 1][1] == 'g'
 728               && md_parse_option (optc, optarg))
 729             continue;
 730
 731           if (md_debug_format_selector)
 732             debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
 733           else if (IS_ELF)
 734             debug_type = DEBUG_DWARF2;
 735           else
 736             debug_type = DEBUG_STABS;
 737           break;
 738
 739         case OPTION_GSTABS_PLUS:
 740           use_gnu_debug_info_extensions = 1;
 741           /* Fall through.  */
 742         case OPTION_GSTABS:
 743           debug_type = DEBUG_STABS;
 744           break;
 745
 746         case OPTION_GDWARF2:
 747           debug_type = DEBUG_DWARF2;
 748           break;
 749
 750         case OPTION_GDWARF_SECTIONS:
 751           flag_dwarf_sections = TRUE;
 752           break;
 753
 754         case 'J':
 755           flag_signed_overflow_ok = 1;
 756           break;
 757
 758 #ifndef WORKING_DOT_WORD
 759         case 'K':
 760           flag_warn_displacement = 1;
 761           break;
 762 #endif
 763         case 'L':
 764           flag_keep_locals = 1;
 765           break;
 766
 767         case OPTION_LISTING_LHS_WIDTH:
 768           listing_lhs_width = atoi (optarg);
 769           if (listing_lhs_width_second < listing_lhs_width)
 770             listing_lhs_width_second = listing_lhs_width;
 771           break;
 772         case OPTION_LISTING_LHS_WIDTH2:
 773           {
 774             int tmp = atoi (optarg);
 775
 776             if (tmp > listing_lhs_width)
 777               listing_lhs_width_second = tmp;
 778           }
 779           break;
 780         case OPTION_LISTING_RHS_WIDTH:
 781           listing_rhs_width = atoi (optarg);
 782           break;
 783         case OPTION_LISTING_CONT_LINES:
 784           listing_lhs_cont_lines = atoi (optarg);
 785           break;
 786
 787         case 'M':
 788           flag_mri = 1;
 789 #ifdef TC_M68K
 790           flag_m68k_mri = 1;
 791 #endif
 792           break;
 793
 794         case 'R':
 795           flag_readonly_data_in_text = 1;
 796           break;
 797
 798         case 'W':
 799           flag_no_warnings = 1;
 800           break;
 801
 802         case OPTION_WARN:
 803           flag_no_warnings = 0;
 804           flag_fatal_warnings = 0;
 805           break;
 806
 807         case OPTION_WARN_FATAL:
 808           flag_no_warnings = 0;
 809           flag_fatal_warnings = 1;
 810           break;
 811
 812 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 813         case OPTION_EXECSTACK:
 814           flag_execstack = 1;
 815           flag_noexecstack = 0;
 816           break;
 817
 818         case OPTION_NOEXECSTACK:
 819           flag_noexecstack = 1;
 820           flag_execstack = 0;
 821           break;
 822
 823         case OPTION_SIZE_CHECK:
 824           if (strcasecmp (optarg, "error") == 0)
 825             flag_size_check = size_check_error;
 826           else if (strcasecmp (optarg, "warning") == 0)
 827             flag_size_check = size_check_warning;
 828           else
 829             as_fatal (_("Invalid --size-check= option: `%s'"), optarg);
 830           break;
 831 #endif
 832         case 'Z':
 833           flag_always_generate_output = 1;
 834           break;
 835
 836         case OPTION_AL:
 837           listing |= LISTING_LISTING;
 838           if (optarg)
 839             listing_filename = xstrdup (optarg);
 840           break;
 841
 842         case OPTION_ALTERNATE:
 843           optarg = old_argv [optind - 1];
 844           while (* optarg == '-')
 845             optarg ++;
 846
 847           if (strcmp (optarg, "alternate") == 0)
 848             {
 849               flag_macro_alternate = 1;
 850               break;
 851             }
 852           optarg ++;
 853           /* Fall through.  */
 854
 855         case 'a':
 856           if (optarg)
 857             {
 858               if (optarg != old_argv[optind] && optarg[-1] == '=')
 859                 --optarg;
 860
 861               if (md_parse_option (optc, optarg) != 0)
 862                 break;
 863
 864               while (*optarg)
 865                 {
 866                   switch (*optarg)
 867                     {
 868                     case 'c':
 869                       listing |= LISTING_NOCOND;
 870                       break;
 871                     case 'd':
 872                       listing |= LISTING_NODEBUG;
 873                       break;
 874                     case 'g':
 875                       listing |= LISTING_GENERAL;
 876                       break;
 877                     case 'h':
 878                       listing |= LISTING_HLL;
 879                       break;
 880                     case 'l':
 881                       listing |= LISTING_LISTING;
 882                       break;
 883                     case 'm':
 884                       listing |= LISTING_MACEXP;
 885                       break;
 886                     case 'n':
 887                       listing |= LISTING_NOFORM;
 888                       break;
 889                     case 's':
 890                       listing |= LISTING_SYMBOLS;
 891                       break;
 892                     case '=':
 893                       listing_filename = xstrdup (optarg + 1);
 894                       optarg += strlen (listing_filename);
 895                       break;
 896                     default:
 897                       as_fatal (_("invalid listing option `%c'"), *optarg);
 898                       break;
 899                     }
 900                   optarg++;
 901                 }
 902             }
 903           if (!listing)
 904             listing = LISTING_DEFAULT;
 905           break;
 906
 907         case 'D':
 908           /* DEBUG is implemented: it debugs different
 909              things from other people's assemblers.  */
 910           flag_debug = 1;
 911           break;
 912
 913         case 'f':
 914           flag_no_comments = 1;
 915           break;
 916
 917         case 'I':
 918           {                     /* Include file directory.  */
 919             char *temp = xstrdup (optarg);
 920
 921             add_include_dir (temp);
 922             break;
 923           }
 924
 925         case 'o':
 926           out_file_name = xstrdup (optarg);
 927           break;
 928
 929         case 'w':
 930           break;
 931
 932         case 'X':
 933           /* -X means treat warnings as errors.  */
 934           break;
 935
 936         case OPTION_REDUCE_MEMORY_OVERHEADS:
 937           /* The only change we make at the moment is to reduce
 938              the size of the hash tables that we use.  */
 939           set_gas_hash_table_size (4051);
 940           break;
 941
 942         case OPTION_HASH_TABLE_SIZE:
 943           {
 944             unsigned long new_size;
 945
 946             new_size = strtoul (optarg, NULL, 0);
 947             if (new_size)
 948               set_gas_hash_table_size (new_size);
 949             else
 950               as_fatal (_("--hash-size needs a numeric argument"));
 951             break;
 952           }
 953         }
 954     }
 955
 956   free (shortopts);
 957   free (longopts);
 958
 959   *pargc = new_argc;
 960   *pargv = new_argv;
 961
 962 #ifdef md_after_parse_args
 963   md_after_parse_args ();
 964 #endif
 965 }
 966
 967 static void
 968 dump_statistics (void)
 969 {
 970 #ifdef HAVE_SBRK
 971   char *lim = (char *) sbrk (0);
 972 #endif
 973   long run_time = get_run_time () - start_time;
 974
 975   fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
 976            myname, run_time / 1000000, run_time % 1000000);
 977 #ifdef HAVE_SBRK
 978   fprintf (stderr, _("%s: data size %ld\n"),
 979            myname, (long) (lim - start_sbrk));
 980 #endif
 981
 982   subsegs_print_statistics (stderr);
 983   write_print_statistics (stderr);
 984   symbol_print_statistics (stderr);
 985   read_print_statistics (stderr);
 986
 987 #ifdef tc_print_statistics
 988   tc_print_statistics (stderr);
 989 #endif
 990
 991 #ifdef obj_print_statistics
 992   obj_print_statistics (stderr);
 993 #endif
 994 }
 995
 996 static void
 997 close_output_file (void)
 998 {
 999   output_file_close (out_file_name);
1000   if (!keep_it)
1001     unlink_if_ordinary (out_file_name);
1002 }
1003
1004 /* The interface between the macro code and gas expression handling.  */
1005
1006 static size_t
1007 macro_expr (const char *emsg, size_t idx, sb *in, offsetT *val)
1008 {
1009   char *hold;
1010   expressionS ex;
1011
1012   sb_terminate (in);
1013
1014   hold = input_line_pointer;
1015   input_line_pointer = in->ptr + idx;
1016   expression_and_evaluate (&ex);
1017   idx = input_line_pointer - in->ptr;
1018   input_line_pointer = hold;
1019
1020   if (ex.X_op != O_constant)
1021     as_bad ("%s", emsg);
1022
1023   *val = ex.X_add_number;
1024
1025   return idx;
1026 }
1027 \f
1028 /* Here to attempt 1 pass over each input file.
1029    We scan argv[*] looking for filenames or exactly "" which is
1030    shorthand for stdin. Any argv that is NULL is not a file-name.
1031    We set need_pass_2 TRUE if, after this, we still have unresolved
1032    expressions of the form (unknown value)+-(unknown value).
1033
1034    Note the un*x semantics: there is only 1 logical input file, but it
1035    may be a catenation of many 'physical' input files.  */
1036
1037 static void
1038 perform_an_assembly_pass (int argc, char ** argv)
1039 {
1040   int saw_a_file = 0;
1041 #ifndef OBJ_MACH_O
1042   flagword applicable;
1043 #endif
1044
1045   need_pass_2 = 0;
1046
1047 #ifndef OBJ_MACH_O
1048   /* Create the standard sections, and those the assembler uses
1049      internally.  */
1050   text_section = subseg_new (TEXT_SECTION_NAME, 0);
1051   data_section = subseg_new (DATA_SECTION_NAME, 0);
1052   bss_section = subseg_new (BSS_SECTION_NAME, 0);
1053   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1054      to have relocs, otherwise we don't find out in time.  */
1055   applicable = bfd_applicable_section_flags (stdoutput);
1056   bfd_set_section_flags (stdoutput, text_section,
1057                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1058                                        | SEC_CODE | SEC_READONLY));
1059   bfd_set_section_flags (stdoutput, data_section,
1060                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1061                                        | SEC_DATA));
1062   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1063   seg_info (bss_section)->bss = 1;
1064 #endif
1065   subseg_new (BFD_ABS_SECTION_NAME, 0);
1066   subseg_new (BFD_UND_SECTION_NAME, 0);
1067   reg_section = subseg_new ("*GAS `reg' section*", 0);
1068   expr_section = subseg_new ("*GAS `expr' section*", 0);
1069
1070 #ifndef OBJ_MACH_O
1071   subseg_set (text_section, 0);
1072 #endif
1073
1074   /* This may add symbol table entries, which requires having an open BFD,
1075      and sections already created.  */
1076   md_begin ();
1077
1078 #ifdef USING_CGEN
1079   gas_cgen_begin ();
1080 #endif
1081 #ifdef obj_begin
1082   obj_begin ();
1083 #endif
1084
1085   /* Skip argv[0].  */
1086   argv++;
1087   argc--;
1088
1089   while (argc--)
1090     {
1091       if (*argv)
1092         {                       /* Is it a file-name argument?  */
1093           PROGRESS (1);
1094           saw_a_file++;
1095           /* argv->"" if stdin desired, else->filename.  */
1096           read_a_source_file (*argv);
1097         }
1098       argv++;                   /* Completed that argv.  */
1099     }
1100   if (!saw_a_file)
1101     read_a_source_file ("");
1102 }
1103 \f
1104
1105 int
1106 main (int argc, char ** argv)
1107 {
1108   char ** argv_orig = argv;
1109
1110   int macro_strip_at;
1111
1112   start_time = get_run_time ();
1113 #ifdef HAVE_SBRK
1114   start_sbrk = (char *) sbrk (0);
1115 #endif
1116
1117 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1118   setlocale (LC_MESSAGES, "");
1119 #endif
1120 #if defined (HAVE_SETLOCALE)
1121   setlocale (LC_CTYPE, "");
1122 #endif
1123   bindtextdomain (PACKAGE, LOCALEDIR);
1124   textdomain (PACKAGE);
1125
1126   if (debug_memory)
1127     chunksize = 64;
1128
1129 #ifdef HOST_SPECIAL_INIT
1130   HOST_SPECIAL_INIT (argc, argv);
1131 #endif
1132
1133   myname = argv[0];
1134   xmalloc_set_program_name (myname);
1135
1136   expandargv (&argc, &argv);
1137
1138   START_PROGRESS (myname, 0);
1139
1140 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1141 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1142 #endif
1143
1144   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1145
1146   hex_init ();
1147   bfd_init ();
1148   bfd_set_error_program_name (myname);
1149
1150 #ifdef USE_EMULATIONS
1151   select_emulation_mode (argc, argv);
1152 #endif
1153
1154   PROGRESS (1);
1155   /* Call parse_args before any of the init/begin functions
1156      so that switches like --hash-size can be honored.  */
1157   parse_args (&argc, &argv);
1158   symbol_begin ();
1159   frag_init ();
1160   subsegs_begin ();
1161   read_begin ();
1162   input_scrub_begin ();
1163   expr_begin ();
1164
1165   /* It has to be called after dump_statistics ().  */
1166   xatexit (close_output_file);
1167
1168   if (flag_print_statistics)
1169     xatexit (dump_statistics);
1170
1171   macro_strip_at = 0;
1172 #ifdef TC_I960
1173   macro_strip_at = flag_mri;
1174 #endif
1175
1176   macro_init (flag_macro_alternate, flag_mri, macro_strip_at, macro_expr);
1177
1178   PROGRESS (1);
1179
1180   output_file_create (out_file_name);
1181   gas_assert (stdoutput != 0);
1182
1183   dot_symbol_init ();
1184
1185 #ifdef tc_init_after_args
1186   tc_init_after_args ();
1187 #endif
1188
1189   itbl_init ();
1190
1191   dwarf2_init ();
1192
1193   local_symbol_make (".gasversion.", absolute_section,
1194                      BFD_VERSION / 10000UL, &predefined_address_frag);
1195
1196   /* Now that we have fully initialized, and have created the output
1197      file, define any symbols requested by --defsym command line
1198      arguments.  */
1199   while (defsyms != NULL)
1200     {
1201       symbolS *sym;
1202       struct defsym_list *next;
1203
1204       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
1205                         &zero_address_frag);
1206       /* Make symbols defined on the command line volatile, so that they
1207          can be redefined inside a source file.  This makes this assembler's
1208          behaviour compatible with earlier versions, but it may not be
1209          completely intuitive.  */
1210       S_SET_VOLATILE (sym);
1211       symbol_table_insert (sym);
1212       next = defsyms->next;
1213       free (defsyms);
1214       defsyms = next;
1215     }
1216
1217   PROGRESS (1);
1218
1219   /* Assemble it.  */
1220   perform_an_assembly_pass (argc, argv);
1221
1222   cond_finish_check (-1);
1223
1224 #ifdef md_end
1225   md_end ();
1226 #endif
1227
1228 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
1229   if ((flag_execstack || flag_noexecstack)
1230       && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1231     {
1232       segT gnustack;
1233
1234       gnustack = subseg_new (".note.GNU-stack", 0);
1235       bfd_set_section_flags (stdoutput, gnustack,
1236                              SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1237
1238     }
1239 #endif
1240
1241   /* If we've been collecting dwarf2 .debug_line info, either for
1242      assembly debugging or on behalf of the compiler, emit it now.  */
1243   dwarf2_finish ();
1244
1245   /* If we constructed dwarf2 .eh_frame info, either via .cfi
1246      directives from the user or by the backend, emit it now.  */
1247   cfi_finish ();
1248
1249   keep_it = 0;
1250   if (seen_at_least_1_file ())
1251     {
1252       int n_warns, n_errs;
1253       char warn_msg[50];
1254       char err_msg[50];
1255
1256       write_object_file ();
1257
1258       n_warns = had_warnings ();
1259       n_errs = had_errors ();
1260
1261       if (n_warns == 1)
1262         sprintf (warn_msg, _("%d warning"), n_warns);
1263       else
1264         sprintf (warn_msg, _("%d warnings"), n_warns);
1265       if (n_errs == 1)
1266         sprintf (err_msg, _("%d error"), n_errs);
1267       else
1268         sprintf (err_msg, _("%d errors"), n_errs);
1269
1270       if (flag_fatal_warnings && n_warns != 0)
1271         {
1272           if (n_errs == 0)
1273             as_bad (_("%s, treating warnings as errors"), warn_msg);
1274           n_errs += n_warns;
1275         }
1276
1277       if (n_errs == 0)
1278         keep_it = 1;
1279       else if (flag_always_generate_output)
1280         {
1281           /* The -Z flag indicates that an object file should be generated,
1282              regardless of warnings and errors.  */
1283           keep_it = 1;
1284           fprintf (stderr, _("%s, %s, generating bad object file\n"),
1285                    err_msg, warn_msg);
1286         }
1287     }
1288
1289   fflush (stderr);
1290
1291 #ifndef NO_LISTING
1292   listing_print (listing_filename, argv_orig);
1293 #endif
1294
1295   input_scrub_end ();
1296
1297   END_PROGRESS (myname);
1298
1299   /* Use xexit instead of return, because under VMS environments they
1300      may not place the same interpretation on the value given.  */
1301   if (had_errors () != 0)
1302     xexit (EXIT_FAILURE);
1303
1304   /* Only generate dependency file if assembler was successful.  */
1305   print_dependencies ();
1306
1307   xexit (EXIT_SUCCESS);
1308 }