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