gas/as.c

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