gas/as.c

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