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