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