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