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