gas/as.c

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