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