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