gas/as.c

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