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