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