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