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