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