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