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, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, 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_HASH_TABLE_SIZE,
 437       OPTION_REDUCE_MEMORY_OVERHEADS,
 438       OPTION_WARN_FATAL
 439     /* When you add options here, check that they do
 440        not collide with OPTION_MD_BASE.  See as.h.  */
 441     };
 442
 443   static const struct option std_longopts[] =
 444   {
 445     /* Note: commas are placed at the start of the line rather than
 446        the end of the preceeding line so that it is simpler to
 447        selectively add and remove lines from this list.  */
 448     {"alternate", no_argument, NULL, OPTION_ALTERNATE}
 449     /* The entry for "a" is here to prevent getopt_long_only() from
 450        considering that -a is an abbreviation for --alternate.  This is
 451        necessary because -a=<FILE> is a valid switch but getopt would
 452        normally reject it since --alternate does not take an argument.  */
 453     ,{"a", optional_argument, NULL, 'a'}
 454     ,{"defsym", required_argument, NULL, OPTION_DEFSYM}
 455     ,{"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}
 456     ,{"emulation", required_argument, NULL, OPTION_EMULATION}
 457 #if defined BFD_ASSEMBLER && (defined OBJ_ELF || defined OBJ_MAYBE_ELF)
 458     ,{"execstack", no_argument, NULL, OPTION_EXECSTACK}
 459     ,{"noexecstack", no_argument, NULL, OPTION_NOEXECSTACK}
 460 #endif
 461     ,{"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
 462     ,{"gdwarf-2", no_argument, NULL, OPTION_GDWARF2}
 463     /* GCC uses --gdwarf-2 but GAS uses to use --gdwarf2,
 464        so we keep it here for backwards compatibility.  */
 465     ,{"gdwarf2", no_argument, NULL, OPTION_GDWARF2}
 466     ,{"gen-debug", no_argument, NULL, 'g'}
 467     ,{"gstabs", no_argument, NULL, OPTION_GSTABS}
 468     ,{"gstabs+", no_argument, NULL, OPTION_GSTABS_PLUS}
 469     ,{"hash-size", required_argument, NULL, OPTION_HASH_TABLE_SIZE}
 470     ,{"help", no_argument, NULL, OPTION_HELP}
 471     /* New option for extending instruction set (see also -t above).
 472        The "-t file" or "--itbl file" option extends the basic set of
 473        valid instructions by reading "file", a text file containing a
 474        list of instruction formats.  The additional opcodes and their
 475        formats are added to the built-in set of instructions, and
 476        mnemonics for new registers may also be defined.  */
 477     ,{"itbl", required_argument, NULL, OPTION_INSTTBL}
 478     /* getopt allows abbreviations, so we do this to stop it from
 479        treating -k as an abbreviation for --keep-locals.  Some
 480        ports use -k to enable PIC assembly.  */
 481     ,{"keep-locals", no_argument, NULL, 'L'}
 482     ,{"keep-locals", no_argument, NULL, 'L'}
 483     ,{"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}
 484     ,{"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}
 485     ,{"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}
 486     ,{"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}
 487     ,{"MD", required_argument, NULL, OPTION_DEPFILE}
 488     ,{"mri", no_argument, NULL, 'M'}
 489     ,{"nocpp", no_argument, NULL, OPTION_NOCPP}
 490     ,{"no-warn", no_argument, NULL, 'W'}
 491     ,{"reduce-memory-overheads", no_argument, NULL, OPTION_REDUCE_MEMORY_OVERHEADS}
 492     ,{"statistics", no_argument, NULL, OPTION_STATISTICS}
 493     ,{"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}
 494     ,{"version", no_argument, NULL, OPTION_VERSION}
 495     ,{"verbose", no_argument, NULL, OPTION_VERBOSE}
 496     ,{"target-help", no_argument, NULL, OPTION_TARGET_HELP}
 497     ,{"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
 498     ,{"warn", no_argument, NULL, OPTION_WARN}
 499   };
 500
 501   /* Construct the option lists from the standard list and the target
 502      dependent list.  Include space for an extra NULL option and
 503      always NULL terminate.  */
 504   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 505   longopts = xmalloc (sizeof (std_longopts) + md_longopts_size + sizeof (struct option));
 506   memcpy (longopts, std_longopts, sizeof (std_longopts));
 507   memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
 508   memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
 509           0, sizeof (struct option));
 510
 511   /* Make a local copy of the old argv.  */
 512   old_argc = *pargc;
 513   old_argv = *pargv;
 514
 515   /* Initialize a new argv that contains no options.  */
 516   new_argv = xmalloc (sizeof (char *) * (old_argc + 1));
 517   new_argv[0] = old_argv[0];
 518   new_argc = 1;
 519   new_argv[new_argc] = NULL;
 520
 521   while (1)
 522     {
 523       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 524          indicate a long option.  */
 525       int longind;
 526       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 527                                    &longind);
 528
 529       if (optc == -1)
 530         break;
 531
 532       switch (optc)
 533         {
 534         default:
 535           /* md_parse_option should return 1 if it recognizes optc,
 536              0 if not.  */
 537           if (md_parse_option (optc, optarg) != 0)
 538             break;
 539           /* `-v' isn't included in the general short_opts list, so check for
 540              it explicitly here before deciding we've gotten a bad argument.  */
 541           if (optc == 'v')
 542             {
 543 #ifdef VMS
 544               /* Telling getopt to treat -v's value as optional can result
 545                  in it picking up a following filename argument here.  The
 546                  VMS code in md_parse_option can return 0 in that case,
 547                  but it has no way of pushing the filename argument back.  */
 548               if (optarg && *optarg)
 549                 new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
 550               else
 551 #else
 552               case 'v':
 553 #endif
 554               case OPTION_VERBOSE:
 555                 print_version_id ();
 556                 verbose = 1;
 557               break;
 558             }
 559           else
 560             as_bad (_("unrecognized option -%c%s"), optc, optarg ? optarg : "");
 561           /* Fall through.  */
 562
 563         case '?':
 564           exit (EXIT_FAILURE);
 565
 566         case 1:                 /* File name.  */
 567           if (!strcmp (optarg, "-"))
 568             optarg = "";
 569           new_argv[new_argc++] = optarg;
 570           new_argv[new_argc] = NULL;
 571           break;
 572
 573         case OPTION_TARGET_HELP:
 574           md_show_usage (stdout);
 575           exit (EXIT_SUCCESS);
 576
 577         case OPTION_HELP:
 578           show_usage (stdout);
 579           exit (EXIT_SUCCESS);
 580
 581         case OPTION_NOCPP:
 582           break;
 583
 584         case OPTION_STATISTICS:
 585           flag_print_statistics = 1;
 586           break;
 587
 588         case OPTION_STRIP_LOCAL_ABSOLUTE:
 589           flag_strip_local_absolute = 1;
 590           break;
 591
 592         case OPTION_TRADITIONAL_FORMAT:
 593           flag_traditional_format = 1;
 594           break;
 595
 596         case OPTION_VERSION:
 597           /* This output is intended to follow the GNU standards document.  */
 598 #ifdef BFD_ASSEMBLER
 599           printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
 600 #else
 601           printf (_("GNU assembler %s\n"), VERSION);
 602 #endif
 603           printf (_("Copyright 2005 Free Software Foundation, Inc.\n"));
 604           printf (_("\
 605 This program is free software; you may redistribute it under the terms of\n\
 606 the GNU General Public License.  This program has absolutely no warranty.\n"));
 607           printf (_("This assembler was configured for a target of `%s'.\n"),
 608                   TARGET_ALIAS);
 609           exit (EXIT_SUCCESS);
 610
 611         case OPTION_EMULATION:
 612 #ifdef USE_EMULATIONS
 613           if (strcmp (optarg, this_emulation->name))
 614             as_fatal (_("multiple emulation names specified"));
 615 #else
 616           as_fatal (_("emulations not handled in this configuration"));
 617 #endif
 618           break;
 619
 620         case OPTION_DUMPCONFIG:
 621           fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
 622           fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
 623           fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
 624 #ifdef TARGET_OBJ_FORMAT
 625           fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
 626 #endif
 627 #ifdef TARGET_FORMAT
 628           fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
 629 #endif
 630           exit (EXIT_SUCCESS);
 631
 632         case OPTION_DEFSYM:
 633           {
 634             char *s;
 635             valueT i;
 636             struct defsym_list *n;
 637
 638             for (s = optarg; *s != '\0' && *s != '='; s++)
 639               ;
 640             if (*s == '\0')
 641               as_fatal (_("bad defsym; format is --defsym name=value"));
 642             *s++ = '\0';
 643 #ifdef BFD_ASSEMBLER
 644             i = bfd_scan_vma (s, (const char **) NULL, 0);
 645 #else
 646             i = strtol (s, (char **) NULL, 0);
 647 #endif
 648             n = xmalloc (sizeof *n);
 649             n->next = defsyms;
 650             n->name = optarg;
 651             n->value = i;
 652             defsyms = n;
 653           }
 654           break;
 655
 656         case OPTION_INSTTBL:
 657         case 't':
 658           {
 659             /* optarg is the name of the file containing the instruction
 660                formats, opcodes, register names, etc.  */
 661             struct itbl_file_list *n;
 662
 663             if (optarg == NULL)
 664               {
 665                 as_warn (_("no file name following -t option"));
 666                 break;
 667               }
 668
 669             n = xmalloc (sizeof * n);
 670             n->next = itbl_files;
 671             n->name = optarg;
 672             itbl_files = n;
 673
 674             /* Parse the file and add the new instructions to our internal
 675                table.  If multiple instruction tables are specified, the
 676                information from this table gets appended onto the existing
 677                internal table.  */
 678             itbl_files->name = xstrdup (optarg);
 679             if (itbl_parse (itbl_files->name) != 0)
 680               as_fatal (_("failed to read instruction table %s\n"),
 681                         itbl_files->name);
 682           }
 683           break;
 684
 685         case OPTION_DEPFILE:
 686           start_dependencies (optarg);
 687           break;
 688
 689         case 'g':
 690           /* Some backends, eg Alpha and Mips, use the -g switch for their
 691              own purposes.  So we check here for an explicit -g and allow
 692              the backend to decide if it wants to process it.  */
 693           if (   old_argv[optind - 1][1] == 'g'
 694               && md_parse_option (optc, optarg))
 695             continue;
 696
 697           if (md_debug_format_selector)
 698             debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
 699           else if (IS_ELF)
 700             debug_type = DEBUG_DWARF2;
 701           else
 702             debug_type = DEBUG_STABS;
 703           break;
 704
 705         case OPTION_GSTABS_PLUS:
 706           use_gnu_debug_info_extensions = 1;
 707           /* Fall through.  */
 708         case OPTION_GSTABS:
 709           debug_type = DEBUG_STABS;
 710           break;
 711
 712         case OPTION_GDWARF2:
 713           debug_type = DEBUG_DWARF2;
 714           break;
 715
 716         case 'J':
 717           flag_signed_overflow_ok = 1;
 718           break;
 719
 720 #ifndef WORKING_DOT_WORD
 721         case 'K':
 722           flag_warn_displacement = 1;
 723           break;
 724 #endif
 725         case 'L':
 726           flag_keep_locals = 1;
 727           break;
 728
 729         case OPTION_LISTING_LHS_WIDTH:
 730           listing_lhs_width = atoi (optarg);
 731           if (listing_lhs_width_second < listing_lhs_width)
 732             listing_lhs_width_second = listing_lhs_width;
 733           break;
 734         case OPTION_LISTING_LHS_WIDTH2:
 735           {
 736             int tmp = atoi (optarg);
 737
 738             if (tmp > listing_lhs_width)
 739               listing_lhs_width_second = tmp;
 740           }
 741           break;
 742         case OPTION_LISTING_RHS_WIDTH:
 743           listing_rhs_width = atoi (optarg);
 744           break;
 745         case OPTION_LISTING_CONT_LINES:
 746           listing_lhs_cont_lines = atoi (optarg);
 747           break;
 748
 749         case 'M':
 750           flag_mri = 1;
 751 #ifdef TC_M68K
 752           flag_m68k_mri = 1;
 753 #endif
 754           break;
 755
 756         case 'R':
 757           flag_readonly_data_in_text = 1;
 758           break;
 759
 760         case 'W':
 761           flag_no_warnings = 1;
 762           break;
 763
 764         case OPTION_WARN:
 765           flag_no_warnings = 0;
 766           flag_fatal_warnings = 0;
 767           break;
 768
 769         case OPTION_WARN_FATAL:
 770           flag_no_warnings = 0;
 771           flag_fatal_warnings = 1;
 772           break;
 773
 774 #if defined BFD_ASSEMBLER && (defined OBJ_ELF || defined OBJ_MAYBE_ELF)
 775         case OPTION_EXECSTACK:
 776           flag_execstack = 1;
 777           flag_noexecstack = 0;
 778           break;
 779
 780         case OPTION_NOEXECSTACK:
 781           flag_noexecstack = 1;
 782           flag_execstack = 0;
 783           break;
 784 #endif
 785         case 'Z':
 786           flag_always_generate_output = 1;
 787           break;
 788
 789         case OPTION_ALTERNATE:
 790           optarg = old_argv [optind - 1];
 791           while (* optarg == '-')
 792             optarg ++;
 793
 794           if (strcmp (optarg, "alternate") == 0)
 795             {
 796               flag_macro_alternate = 1;
 797               break;
 798             }
 799           optarg ++;
 800           /* Fall through.  */
 801
 802         case 'a':
 803           if (optarg)
 804             {
 805               if (optarg != old_argv[optind] && optarg[-1] == '=')
 806                 --optarg;
 807
 808               if (md_parse_option (optc, optarg) != 0)
 809                 break;
 810
 811               while (*optarg)
 812                 {
 813                   switch (*optarg)
 814                     {
 815                     case 'c':
 816                       listing |= LISTING_NOCOND;
 817                       break;
 818                     case 'd':
 819                       listing |= LISTING_NODEBUG;
 820                       break;
 821                     case 'h':
 822                       listing |= LISTING_HLL;
 823                       break;
 824                     case 'l':
 825                       listing |= LISTING_LISTING;
 826                       break;
 827                     case 'm':
 828                       listing |= LISTING_MACEXP;
 829                       break;
 830                     case 'n':
 831                       listing |= LISTING_NOFORM;
 832                       break;
 833                     case 's':
 834                       listing |= LISTING_SYMBOLS;
 835                       break;
 836                     case '=':
 837                       listing_filename = xstrdup (optarg + 1);
 838                       optarg += strlen (listing_filename);
 839                       break;
 840                     default:
 841                       as_fatal (_("invalid listing option `%c'"), *optarg);
 842                       break;
 843                     }
 844                   optarg++;
 845                 }
 846             }
 847           if (!listing)
 848             listing = LISTING_DEFAULT;
 849           break;
 850
 851         case 'D':
 852           /* DEBUG is implemented: it debugs different
 853              things from other people's assemblers.  */
 854           flag_debug = 1;
 855           break;
 856
 857         case 'f':
 858           flag_no_comments = 1;
 859           break;
 860
 861         case 'I':
 862           {                     /* Include file directory.  */
 863             char *temp = xstrdup (optarg);
 864
 865             add_include_dir (temp);
 866             break;
 867           }
 868
 869         case 'o':
 870           out_file_name = xstrdup (optarg);
 871           break;
 872
 873         case 'w':
 874           break;
 875
 876         case 'X':
 877           /* -X means treat warnings as errors.  */
 878           break;
 879
 880         case OPTION_REDUCE_MEMORY_OVERHEADS:
 881           /* The only change we make at the moment is to reduce
 882              the size of the hash tables that we use.  */
 883           set_gas_hash_table_size (4051);
 884           break;
 885
 886         case OPTION_HASH_TABLE_SIZE:
 887           {
 888             unsigned long new_size;
 889
 890             new_size = strtoul (optarg, NULL, 0);
 891             if (new_size)
 892               set_gas_hash_table_size (new_size);
 893             else
 894               as_fatal (_("--hash-size needs a numeric argument"));
 895             break;
 896           }
 897         }
 898     }
 899
 900   free (shortopts);
 901   free (longopts);
 902
 903   *pargc = new_argc;
 904   *pargv = new_argv;
 905
 906 #ifdef md_after_parse_args
 907   md_after_parse_args ();
 908 #endif
 909 }
 910
 911 static void
 912 dump_statistics (void)
 913 {
 914 #ifdef HAVE_SBRK
 915   char *lim = (char *) sbrk (0);
 916 #endif
 917   long run_time = get_run_time () - start_time;
 918
 919   fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
 920            myname, run_time / 1000000, run_time % 1000000);
 921 #ifdef HAVE_SBRK
 922   fprintf (stderr, _("%s: data size %ld\n"),
 923            myname, (long) (lim - (char *) &environ));
 924 #endif
 925
 926   subsegs_print_statistics (stderr);
 927   write_print_statistics (stderr);
 928   symbol_print_statistics (stderr);
 929   read_print_statistics (stderr);
 930
 931 #ifdef tc_print_statistics
 932   tc_print_statistics (stderr);
 933 #endif
 934
 935 #ifdef obj_print_statistics
 936   obj_print_statistics (stderr);
 937 #endif
 938 }
 939
 940 /* The interface between the macro code and gas expression handling.  */
 941
 942 static int
 943 macro_expr (const char *emsg, int idx, sb *in, int *val)
 944 {
 945   char *hold;
 946   expressionS ex;
 947
 948   sb_terminate (in);
 949
 950   hold = input_line_pointer;
 951   input_line_pointer = in->ptr + idx;
 952   expression (&ex);
 953   idx = input_line_pointer - in->ptr;
 954   input_line_pointer = hold;
 955
 956   if (ex.X_op != O_constant)
 957     as_bad ("%s", emsg);
 958
 959   *val = (int) ex.X_add_number;
 960
 961   return idx;
 962 }
 963 \f
 964 /* Here to attempt 1 pass over each input file.
 965    We scan argv[*] looking for filenames or exactly "" which is
 966    shorthand for stdin. Any argv that is NULL is not a file-name.
 967    We set need_pass_2 TRUE if, after this, we still have unresolved
 968    expressions of the form (unknown value)+-(unknown value).
 969
 970    Note the un*x semantics: there is only 1 logical input file, but it
 971    may be a catenation of many 'physical' input files.  */
 972
 973 static void
 974 perform_an_assembly_pass (int argc, char ** argv)
 975 {
 976   int saw_a_file = 0;
 977 #ifdef BFD_ASSEMBLER
 978   flagword applicable;
 979 #endif
 980
 981   need_pass_2 = 0;
 982
 983 #ifndef BFD_ASSEMBLER
 984 #ifdef MANY_SEGMENTS
 985   {
 986     unsigned int i;
 987     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
 988       segment_info[i].fix_root = 0;
 989   }
 990   /* Create the three fixed ones.  */
 991   {
 992     segT seg;
 993
 994 #ifdef TE_APOLLO
 995     seg = subseg_new (".wtext", 0);
 996 #else
 997     seg = subseg_new (".text", 0);
 998 #endif
 999     assert (seg == SEG_E0);
1000     seg = subseg_new (".data", 0);
1001     assert (seg == SEG_E1);
1002     seg = subseg_new (".bss", 0);
1003     assert (seg == SEG_E2);
1004 #ifdef TE_APOLLO
1005     create_target_segments ();
1006 #endif
1007   }
1008
1009 #else /* not MANY_SEGMENTS.  */
1010   text_fix_root = NULL;
1011   data_fix_root = NULL;
1012   bss_fix_root = NULL;
1013 #endif /* not MANY_SEGMENTS.  */
1014 #else /* BFD_ASSEMBLER.  */
1015   /* Create the standard sections, and those the assembler uses
1016      internally.  */
1017   text_section = subseg_new (TEXT_SECTION_NAME, 0);
1018   data_section = subseg_new (DATA_SECTION_NAME, 0);
1019   bss_section = subseg_new (BSS_SECTION_NAME, 0);
1020   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1021      to have relocs, otherwise we don't find out in time.  */
1022   applicable = bfd_applicable_section_flags (stdoutput);
1023   bfd_set_section_flags (stdoutput, text_section,
1024                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1025                                        | SEC_CODE | SEC_READONLY));
1026   bfd_set_section_flags (stdoutput, data_section,
1027                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1028                                        | SEC_DATA));
1029   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1030   seg_info (bss_section)->bss = 1;
1031   subseg_new (BFD_ABS_SECTION_NAME, 0);
1032   subseg_new (BFD_UND_SECTION_NAME, 0);
1033   reg_section = subseg_new ("*GAS `reg' section*", 0);
1034   expr_section = subseg_new ("*GAS `expr' section*", 0);
1035
1036 #endif /* BFD_ASSEMBLER.  */
1037
1038   subseg_set (text_section, 0);
1039
1040   /* This may add symbol table entries, which requires having an open BFD,
1041      and sections already created, in BFD_ASSEMBLER mode.  */
1042   md_begin ();
1043
1044 #ifdef USING_CGEN
1045   gas_cgen_begin ();
1046 #endif
1047 #ifdef obj_begin
1048   obj_begin ();
1049 #endif
1050
1051   /* Skip argv[0].  */
1052   argv++;
1053   argc--;
1054
1055   while (argc--)
1056     {
1057       if (*argv)
1058         {                       /* Is it a file-name argument?  */
1059           PROGRESS (1);
1060           saw_a_file++;
1061           /* argv->"" if stdin desired, else->filename.  */
1062           read_a_source_file (*argv);
1063         }
1064       argv++;                   /* Completed that argv.  */
1065     }
1066   if (!saw_a_file)
1067     read_a_source_file ("");
1068 }
1069 \f
1070
1071 int
1072 main (int argc, char ** argv)
1073 {
1074   int macro_strip_at;
1075   int keep_it;
1076
1077   start_time = get_run_time ();
1078
1079 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1080   setlocale (LC_MESSAGES, "");
1081 #endif
1082 #if defined (HAVE_SETLOCALE)
1083   setlocale (LC_CTYPE, "");
1084 #endif
1085   bindtextdomain (PACKAGE, LOCALEDIR);
1086   textdomain (PACKAGE);
1087
1088   if (debug_memory)
1089     chunksize = 64;
1090
1091 #ifdef HOST_SPECIAL_INIT
1092   HOST_SPECIAL_INIT (argc, argv);
1093 #endif
1094
1095   myname = argv[0];
1096   xmalloc_set_program_name (myname);
1097
1098   START_PROGRESS (myname, 0);
1099
1100 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1101 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1102 #endif
1103
1104   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1105
1106   hex_init ();
1107 #ifdef BFD_ASSEMBLER
1108   bfd_init ();
1109   bfd_set_error_program_name (myname);
1110 #endif
1111
1112 #ifdef USE_EMULATIONS
1113   select_emulation_mode (argc, argv);
1114 #endif
1115
1116   PROGRESS (1);
1117   /* Call parse_args before any of the init/begin functions
1118      so that switches like --hash-size can be honored.  */
1119   parse_args (&argc, &argv);
1120   symbol_begin ();
1121   frag_init ();
1122   subsegs_begin ();
1123   read_begin ();
1124   input_scrub_begin ();
1125   expr_begin ();
1126
1127   if (flag_print_statistics)
1128     xatexit (dump_statistics);
1129
1130   macro_strip_at = 0;
1131 #ifdef TC_I960
1132   macro_strip_at = flag_mri;
1133 #endif
1134 #ifdef TC_A29K
1135   /* For compatibility with the AMD 29K family macro assembler
1136      specification.  */
1137   flag_macro_alternate = 1;
1138   macro_strip_at = 1;
1139 #endif
1140
1141   macro_init (flag_macro_alternate, flag_mri, macro_strip_at, macro_expr);
1142
1143   PROGRESS (1);
1144
1145 #ifdef BFD_ASSEMBLER
1146   output_file_create (out_file_name);
1147   assert (stdoutput != 0);
1148 #endif
1149
1150 #ifdef tc_init_after_args
1151   tc_init_after_args ();
1152 #endif
1153
1154   itbl_init ();
1155
1156   /* Now that we have fully initialized, and have created the output
1157      file, define any symbols requested by --defsym command line
1158      arguments.  */
1159   while (defsyms != NULL)
1160     {
1161       symbolS *sym;
1162       struct defsym_list *next;
1163
1164       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
1165                         &zero_address_frag);
1166       symbol_table_insert (sym);
1167       next = defsyms->next;
1168       free (defsyms);
1169       defsyms = next;
1170     }
1171
1172   PROGRESS (1);
1173
1174   /* Assemble it.  */
1175   perform_an_assembly_pass (argc, argv);
1176
1177   cond_finish_check (-1);
1178
1179 #ifdef md_end
1180   md_end ();
1181 #endif
1182
1183 #if defined BFD_ASSEMBLER && (defined OBJ_ELF || defined OBJ_MAYBE_ELF)
1184   if ((flag_execstack || flag_noexecstack)
1185       && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1186     {
1187       segT gnustack;
1188
1189       gnustack = subseg_new (".note.GNU-stack", 0);
1190       bfd_set_section_flags (stdoutput, gnustack,
1191                              SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1192
1193     }
1194 #endif
1195
1196   /* If we've been collecting dwarf2 .debug_line info, either for
1197      assembly debugging or on behalf of the compiler, emit it now.  */
1198   dwarf2_finish ();
1199
1200   /* If we constructed dwarf2 .eh_frame info, either via .cfi
1201      directives from the user or by the backend, emit it now.  */
1202   cfi_finish ();
1203
1204   if (seen_at_least_1_file ()
1205       && (flag_always_generate_output || had_errors () == 0))
1206     keep_it = 1;
1207   else
1208     keep_it = 0;
1209
1210 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1211   /* This used to be done at the start of write_object_file in
1212      write.c, but that caused problems when doing listings when
1213      keep_it was zero.  This could probably be moved above md_end, but
1214      I didn't want to risk the change.  */
1215   subsegs_finish ();
1216 #endif
1217
1218   if (keep_it)
1219     write_object_file ();
1220
1221 #ifndef NO_LISTING
1222   listing_print (listing_filename);
1223 #endif
1224
1225 #ifndef OBJ_VMS /* Does its own file handling.  */
1226 #ifndef BFD_ASSEMBLER
1227   if (keep_it)
1228 #endif
1229     output_file_close (out_file_name);
1230 #endif
1231
1232   if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
1233     as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
1234
1235   if (had_errors () > 0 && ! flag_always_generate_output)
1236     keep_it = 0;
1237
1238   if (!keep_it)
1239     unlink_if_ordinary (out_file_name);
1240
1241   input_scrub_end ();
1242
1243   END_PROGRESS (myname);
1244
1245   /* Use xexit instead of return, because under VMS environments they
1246      may not place the same interpretation on the value given.  */
1247   if (had_errors () > 0)
1248     xexit (EXIT_FAILURE);
1249
1250   /* Only generate dependency file if assembler was successful.  */
1251   print_dependencies ();
1252
1253   xexit (EXIT_SUCCESS);
1254 }