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   };
 361
 362   /* Construct the option lists from the standard list and the
 363      target dependent list.  */
 364   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 365   longopts = (struct option *) xmalloc (sizeof (std_longopts) + md_longopts_size);
 366   memcpy (longopts, std_longopts, sizeof (std_longopts));
 367   memcpy ((char *) longopts + sizeof (std_longopts),
 368           md_longopts, md_longopts_size);
 369
 370   /* Make a local copy of the old argv.  */
 371   old_argc = *pargc;
 372   old_argv = *pargv;
 373
 374   /* Initialize a new argv that contains no options.  */
 375   new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
 376   new_argv[0] = old_argv[0];
 377   new_argc = 1;
 378   new_argv[new_argc] = NULL;
 379
 380   while (1)
 381     {
 382       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 383          indicate a long option.  */
 384       int longind;
 385       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 386                                    &longind);
 387
 388       if (optc == -1)
 389         break;
 390
 391       switch (optc)
 392         {
 393         default:
 394           /* md_parse_option should return 1 if it recognizes optc,
 395              0 if not.  */
 396           if (md_parse_option (optc, optarg) != 0)
 397             break;
 398           /* `-v' isn't included in the general short_opts list, so check for
 399              it explicity here before deciding we've gotten a bad argument.  */
 400           if (optc == 'v')
 401             {
 402 #ifdef VMS
 403               /* Telling getopt to treat -v's value as optional can result
 404                  in it picking up a following filename argument here.  The
 405                  VMS code in md_parse_option can return 0 in that case,
 406                  but it has no way of pushing the filename argument back.  */
 407               if (optarg && *optarg)
 408                 new_argv[new_argc++] = optarg,  new_argv[new_argc] = NULL;
 409               else
 410 #else
 411               case 'v':
 412 #endif
 413               case OPTION_VERBOSE:
 414                 print_version_id ();
 415               break;
 416             }
 417           /*FALLTHRU*/
 418
 419         case '?':
 420           exit (EXIT_FAILURE);
 421
 422         case 1:                 /* File name.  */
 423           if (!strcmp (optarg, "-"))
 424             optarg = "";
 425           new_argv[new_argc++] = optarg;
 426           new_argv[new_argc] = NULL;
 427           break;
 428
 429         case OPTION_HELP:
 430           show_usage (stdout);
 431           exit (EXIT_SUCCESS);
 432
 433         case OPTION_NOCPP:
 434           break;
 435
 436         case OPTION_STATISTICS:
 437           flag_print_statistics = 1;
 438           break;
 439
 440         case OPTION_STRIP_LOCAL_ABSOLUTE:
 441           flag_strip_local_absolute = 1;
 442           break;
 443
 444         case OPTION_VERSION:
 445           /* This output is intended to follow the GNU standards document.  */
 446           printf ("GNU assembler %s\n", VERSION);
 447           printf ("Copyright 1997 Free Software Foundation, Inc.\n");
 448           printf ("\
 449 This program is free software; you may redistribute it under the terms of\n\
 450 the GNU General Public License.  This program has absolutely no warranty.\n");
 451           printf ("This assembler was configured for a target of `%s'.\n",
 452                   TARGET_ALIAS);
 453           exit (EXIT_SUCCESS);
 454
 455         case OPTION_EMULATION:
 456 #ifdef USE_EMULATIONS
 457           if (strcmp (optarg, this_emulation->name))
 458             as_fatal ("multiple emulation names specified");
 459 #else
 460           as_fatal ("emulations not handled in this configuration");
 461 #endif
 462           break;
 463
 464         case OPTION_DUMPCONFIG:
 465           fprintf (stderr, "alias = %s\n", TARGET_ALIAS);
 466           fprintf (stderr, "canonical = %s\n", TARGET_CANONICAL);
 467           fprintf (stderr, "cpu-type = %s\n", TARGET_CPU);
 468 #ifdef TARGET_OBJ_FORMAT
 469           fprintf (stderr, "format = %s\n", TARGET_OBJ_FORMAT);
 470 #endif
 471 #ifdef TARGET_FORMAT
 472           fprintf (stderr, "bfd-target = %s\n", TARGET_FORMAT);
 473 #endif
 474           exit (EXIT_SUCCESS);
 475
 476         case OPTION_DEFSYM:
 477           {
 478             char *s;
 479             long i;
 480             struct defsym_list *n;
 481
 482             for (s = optarg; *s != '\0' && *s != '='; s++)
 483               ;
 484             if (*s == '\0')
 485               as_fatal ("bad defsym; format is --defsym name=value");
 486             *s++ = '\0';
 487             i = strtol (s, (char **) NULL, 0);
 488             n = (struct defsym_list *) xmalloc (sizeof *n);
 489             n->next = defsyms;
 490             n->name = optarg;
 491             n->value = i;
 492             defsyms = n;
 493           }
 494           break;
 495
 496         case OPTION_INSTTBL:
 497         case 't':
 498           {
 499             /* optarg is the name of the file containing the instruction
 500                formats, opcodes, register names, etc. */
 501             struct itbl_file_list *n;
 502
 503             if (optarg == NULL)
 504               {
 505                 as_warn ( "No file name following -t option\n" );
 506                 break;
 507               }
 508
 509             n = (struct itbl_file_list *) xmalloc (sizeof *n);
 510             n->next = itbl_files;
 511             n->name = optarg;
 512             itbl_files = n;
 513
 514             /* Parse the file and add the new instructions to our internal
 515                table.  If multiple instruction tables are specified, the
 516                information from this table gets appended onto the existing
 517                internal table. */
 518             itbl_files->name = xstrdup (optarg);
 519             if (itbl_parse (itbl_files->name) != 0)
 520               {
 521                 fprintf (stderr, "Failed to read instruction table %s\n",
 522                          itbl_files->name);
 523                 exit (EXIT_SUCCESS);
 524               }
 525           }
 526           break;
 527
 528         case OPTION_DEPFILE:
 529           start_dependencies (optarg);
 530           break;
 531
 532         case OPTION_GSTABS:
 533           debug_type = DEBUG_STABS;
 534           break;
 535
 536         case 'J':
 537           flag_signed_overflow_ok = 1;
 538           break;
 539
 540 #ifndef WORKING_DOT_WORD
 541         case 'K':
 542           flag_warn_displacement = 1;
 543           break;
 544 #endif
 545
 546         case 'L':
 547           flag_keep_locals = 1;
 548           break;
 549
 550         case OPTION_LISTING_LHS_WIDTH:
 551           listing_lhs_width = atoi(optarg);
 552           if (listing_lhs_width_second < listing_lhs_width)
 553             listing_lhs_width_second = listing_lhs_width;
 554           break;
 555         case OPTION_LISTING_LHS_WIDTH2:
 556           {
 557             int tmp = atoi(optarg);
 558             if (tmp > listing_lhs_width)
 559               listing_lhs_width_second = tmp;
 560           }
 561           break;
 562         case OPTION_LISTING_RHS_WIDTH:
 563           listing_rhs_width = atoi(optarg);
 564           break;
 565         case OPTION_LISTING_CONT_LINES:
 566           listing_lhs_cont_lines = atoi(optarg);
 567           break;
 568
 569         case 'M':
 570           flag_mri = 1;
 571 #ifdef TC_M68K
 572           flag_m68k_mri = 1;
 573 #endif
 574           break;
 575
 576         case 'R':
 577           flag_readonly_data_in_text = 1;
 578           break;
 579
 580         case 'W':
 581           flag_no_warnings = 1;
 582           break;
 583
 584         case 'Z':
 585           flag_always_generate_output = 1;
 586           break;
 587
 588         case 'a':
 589           if (optarg)
 590             {
 591               while (*optarg)
 592                 {
 593                   switch (*optarg)
 594                     {
 595                     case 'c':
 596                       listing |= LISTING_NOCOND;
 597                       break;
 598                     case 'd':
 599                       listing |= LISTING_NODEBUG;
 600                       break;
 601                     case 'h':
 602                       listing |= LISTING_HLL;
 603                       break;
 604                     case 'l':
 605                       listing |= LISTING_LISTING;
 606                       break;
 607                     case 'm':
 608                       listing |= LISTING_MACEXP;
 609                       break;
 610                     case 'n':
 611                       listing |= LISTING_NOFORM;
 612                       break;
 613                     case 's':
 614                       listing |= LISTING_SYMBOLS;
 615                       break;
 616                     case '=':
 617                       listing_filename = xstrdup (optarg + 1);
 618                       optarg += strlen (listing_filename);
 619                       break;
 620                     default:
 621                       as_fatal ("invalid listing option `%c'", *optarg);
 622                       break;
 623                     }
 624                   optarg++;
 625                 }
 626             }
 627           if (!listing)
 628             listing = LISTING_DEFAULT;
 629           break;
 630
 631         case 'D':
 632           /* DEBUG is implemented: it debugs different */
 633           /* things from other people's assemblers. */
 634           flag_debug = 1;
 635           break;
 636
 637         case 'f':
 638           flag_no_comments = 1;
 639           break;
 640
 641         case 'I':
 642           {                     /* Include file directory */
 643             char *temp = xstrdup (optarg);
 644             add_include_dir (temp);
 645             break;
 646           }
 647
 648         case 'o':
 649           out_file_name = xstrdup (optarg);
 650           break;
 651
 652         case 'w':
 653           break;
 654
 655         case 'X':
 656           /* -X means treat warnings as errors */
 657           break;
 658         }
 659     }
 660
 661   free (shortopts);
 662   free (longopts);
 663
 664   *pargc = new_argc;
 665   *pargv = new_argv;
 666 }
 667
 668 static long start_time;
 669
 670 int
 671 main (argc, argv)
 672      int argc;
 673      char **argv;
 674 {
 675   int macro_alternate;
 676   int macro_strip_at;
 677   int keep_it;
 678
 679   start_time = get_run_time ();
 680
 681
 682   if (debug_memory)
 683     {
 684 #ifdef BFD_ASSEMBLER
 685       extern long _bfd_chunksize;
 686       _bfd_chunksize = 64;
 687 #endif
 688       chunksize = 64;
 689     }
 690
 691 #ifdef HOST_SPECIAL_INIT
 692   HOST_SPECIAL_INIT (argc, argv);
 693 #endif
 694
 695   myname = argv[0];
 696   xmalloc_set_program_name (myname);
 697
 698   START_PROGRESS (myname, 0);
 699
 700 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
 701 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
 702 #endif
 703
 704   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
 705
 706   hex_init ();
 707 #ifdef BFD_ASSEMBLER
 708   bfd_init ();
 709   bfd_set_error_program_name (myname);
 710 #endif
 711
 712 #ifdef USE_EMULATIONS
 713   select_emulation_mode (argc, argv);
 714 #endif
 715
 716   PROGRESS (1);
 717   symbol_begin ();
 718   frag_init ();
 719   subsegs_begin ();
 720   parse_args (&argc, &argv);
 721   read_begin ();
 722   input_scrub_begin ();
 723   expr_begin ();
 724
 725   if (flag_print_statistics)
 726     xatexit (dump_statistics);
 727
 728   macro_alternate = 0;
 729   macro_strip_at = 0;
 730 #ifdef TC_I960
 731   macro_strip_at = flag_mri;
 732 #endif
 733 #ifdef TC_A29K
 734   /* For compatibility with the AMD 29K family macro assembler
 735      specification.  */
 736   macro_alternate = 1;
 737   macro_strip_at = 1;
 738 #endif
 739
 740   macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr);
 741
 742   PROGRESS (1);
 743
 744 #ifdef BFD_ASSEMBLER
 745   output_file_create (out_file_name);
 746   assert (stdoutput != 0);
 747 #endif
 748
 749 #ifdef tc_init_after_args
 750   tc_init_after_args ();
 751 #endif
 752
 753   itbl_init ();
 754
 755   /* Now that we have fully initialized, and have created the output
 756      file, define any symbols requested by --defsym command line
 757      arguments.  */
 758   while (defsyms != NULL)
 759     {
 760       symbolS *sym;
 761       struct defsym_list *next;
 762
 763       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
 764                         &zero_address_frag);
 765       symbol_table_insert (sym);
 766       next = defsyms->next;
 767       free (defsyms);
 768       defsyms = next;
 769     }
 770
 771   PROGRESS (1);
 772
 773   perform_an_assembly_pass (argc, argv);        /* Assemble it. */
 774
 775   cond_finish_check (-1);
 776
 777 #ifdef md_end
 778   md_end ();
 779 #endif
 780
 781   if (seen_at_least_1_file ()
 782       && (flag_always_generate_output || had_errors () == 0))
 783     keep_it = 1;
 784   else
 785     keep_it = 0;
 786
 787 #if defined (BFD_ASSEMBLER) || !defined (BFD)
 788   /* This used to be done at the start of write_object_file in
 789      write.c, but that caused problems when doing listings when
 790      keep_it was zero.  This could probably be moved above md_end, but
 791      I didn't want to risk the change.  */
 792   subsegs_finish ();
 793 #endif
 794
 795   if (keep_it)
 796     write_object_file ();
 797
 798 #ifndef NO_LISTING
 799   listing_print (listing_filename);
 800 #endif
 801
 802 #ifndef OBJ_VMS /* does its own file handling */
 803 #ifndef BFD_ASSEMBLER
 804   if (keep_it)
 805 #endif
 806     output_file_close (out_file_name);
 807 #endif
 808
 809   if (had_errors () > 0 && ! flag_always_generate_output)
 810     keep_it = 0;
 811
 812   if (!keep_it)
 813     unlink (out_file_name);
 814
 815   input_scrub_end ();
 816
 817   END_PROGRESS (myname);
 818
 819   /* Use xexit instead of return, because under VMS environments they
 820      may not place the same interpretation on the value given.  */
 821   if (had_errors () > 0)
 822     xexit (EXIT_FAILURE);
 823
 824   /* Only generate dependency file if assembler was successful.  */
 825   print_dependencies ();
 826
 827   xexit (EXIT_SUCCESS);
 828 }
 829
 830 static void
 831 dump_statistics ()
 832 {
 833   extern char **environ;
 834 #ifdef HAVE_SBRK
 835   char *lim = (char *) sbrk (0);
 836 #endif
 837   long run_time = get_run_time () - start_time;
 838
 839   fprintf (stderr, "%s: total time in assembly: %ld.%06ld\n",
 840            myname, run_time / 1000000, run_time % 1000000);
 841 #ifdef HAVE_SBRK
 842   fprintf (stderr, "%s: data size %ld\n",
 843            myname, (long) (lim - (char *) &environ));
 844 #endif
 845
 846   subsegs_print_statistics (stderr);
 847   write_print_statistics (stderr);
 848   symbol_print_statistics (stderr);
 849   read_print_statistics (stderr);
 850
 851 #ifdef tc_print_statistics
 852   tc_print_statistics (stderr);
 853 #endif
 854 #ifdef obj_print_statistics
 855   obj_print_statistics (stderr);
 856 #endif
 857 }
 858 \f
 859
 860 /*                      perform_an_assembly_pass()
 861  *
 862  * Here to attempt 1 pass over each input file.
 863  * We scan argv[*] looking for filenames or exactly "" which is
 864  * shorthand for stdin. Any argv that is NULL is not a file-name.
 865  * We set need_pass_2 TRUE if, after this, we still have unresolved
 866  * expressions of the form (unknown value)+-(unknown value).
 867  *
 868  * Note the un*x semantics: there is only 1 logical input file, but it
 869  * may be a catenation of many 'physical' input files.
 870  */
 871 static void
 872 perform_an_assembly_pass (argc, argv)
 873      int argc;
 874      char **argv;
 875 {
 876   int saw_a_file = 0;
 877 #ifdef BFD_ASSEMBLER
 878   flagword applicable;
 879 #endif
 880
 881   need_pass_2 = 0;
 882
 883 #ifndef BFD_ASSEMBLER
 884 #ifdef MANY_SEGMENTS
 885   {
 886     unsigned int i;
 887     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
 888       segment_info[i].fix_root = 0;
 889   }
 890   /* Create the three fixed ones */
 891   {
 892     segT seg;
 893
 894 #ifdef TE_APOLLO
 895     seg = subseg_new (".wtext", 0);
 896 #else
 897     seg = subseg_new (".text", 0);
 898 #endif
 899     assert (seg == SEG_E0);
 900     seg = subseg_new (".data", 0);
 901     assert (seg == SEG_E1);
 902     seg = subseg_new (".bss", 0);
 903     assert (seg == SEG_E2);
 904 #ifdef TE_APOLLO
 905     create_target_segments ();
 906 #endif
 907   }
 908
 909 #else /* not MANY_SEGMENTS */
 910   text_fix_root = NULL;
 911   data_fix_root = NULL;
 912   bss_fix_root = NULL;
 913 #endif /* not MANY_SEGMENTS */
 914 #else /* BFD_ASSEMBLER */
 915   /* Create the standard sections, and those the assembler uses
 916      internally.  */
 917   text_section = subseg_new (".text", 0);
 918   data_section = subseg_new (".data", 0);
 919   bss_section = subseg_new (".bss", 0);
 920   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
 921      to have relocs, otherwise we don't find out in time. */
 922   applicable = bfd_applicable_section_flags (stdoutput);
 923   bfd_set_section_flags (stdoutput, text_section,
 924                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
 925                                        | SEC_CODE | SEC_READONLY));
 926   /* @@ FIXME -- SEC_CODE seems to mean code only, rather than code possibly.*/
 927   bfd_set_section_flags (stdoutput, data_section,
 928                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC));
 929   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
 930   seg_info (bss_section)->bss = 1;
 931   subseg_new (BFD_ABS_SECTION_NAME, 0);
 932   subseg_new (BFD_UND_SECTION_NAME, 0);
 933   reg_section = subseg_new ("*GAS `reg' section*", 0);
 934   expr_section = subseg_new ("*GAS `expr' section*", 0);
 935
 936 #endif /* BFD_ASSEMBLER */
 937
 938   subseg_set (text_section, 0);
 939
 940   /* This may add symbol table entries, which requires having an open BFD,
 941      and sections already created, in BFD_ASSEMBLER mode.  */
 942   md_begin ();
 943
 944 #ifdef obj_begin
 945   obj_begin ();
 946 #endif
 947
 948   argv++;                       /* skip argv[0] */
 949   argc--;                       /* skip argv[0] */
 950   while (argc--)
 951     {
 952       if (*argv)
 953         {                       /* Is it a file-name argument? */
 954           PROGRESS (1);
 955           saw_a_file++;
 956           /* argv->"" if stdin desired, else->filename */
 957           read_a_source_file (*argv);
 958         }
 959       argv++;                   /* completed that argv */
 960     }
 961   if (!saw_a_file)
 962     read_a_source_file ("");
 963 }                               /* perform_an_assembly_pass() */
 964
 965 /* The interface between the macro code and gas expression handling.  */
 966
 967 static int
 968 macro_expr (emsg, idx, in, val)
 969      const char *emsg;
 970      int idx;
 971      sb *in;
 972      int *val;
 973 {
 974   char *hold;
 975   expressionS ex;
 976
 977   sb_terminate (in);
 978
 979   hold = input_line_pointer;
 980   input_line_pointer = in->ptr + idx;
 981   expression (&ex);
 982   idx = input_line_pointer - in->ptr;
 983   input_line_pointer = hold;
 984
 985   if (ex.X_op != O_constant)
 986     as_bad ("%s", emsg);
 987
 988   *val = (int) ex.X_add_number;
 989
 990   return idx;
 991 }
 992
 993 /* end of as.c */