gas/as.c

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