gas/as.c

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