gas/as.c

   1 /* as.c - GAS main program.
   2    Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 1998
   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 --traditional-format    Use same format as native assembler when possible\n\
 163 --version               print assembler version number and exit\n\
 164 -W                      suppress warnings\n\
 165 --itbl INSTTBL          extend instruction set to include instructions\n\
 166                         matching the specifications defined in file INSTTBL\n\
 167 -w                      ignored\n\
 168 -X                      ignored\n\
 169 -Z                      generate object file even after errors\n");
 170   fprintf (stream, "\
 171 --listing-lhs-width     set the width in words of the output data column of\n\
 172                         the listing\n\
 173 --listing-lhs-width2    set the width in words of the continuation lines\n\
 174                         of the output data column; ignored if smaller than\n\
 175                         the width of the first line\n\
 176 --listing-rhs-width     set the max width in characters of the lines from\n\
 177                         the source file\n\
 178 --listing-cont-lines    set the maximum number of continuation lines used\n\
 179                         for the output data column of the listing\n");
 180
 181   md_show_usage (stream);
 182
 183   fprintf (stream, "\nReport bugs to bug-gnu-utils@prep.ai.mit.edu\n");
 184 }
 185
 186 #ifdef USE_EMULATIONS
 187 #define EMULATION_ENVIRON "AS_EMULATION"
 188
 189 extern struct emulation mipsbelf, mipslelf, mipself;
 190 extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
 191 extern struct emulation i386coff, i386elf;
 192
 193 static struct emulation *const emulations[] = { EMULATIONS };
 194 static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
 195
 196 static void select_emulation_mode PARAMS ((int, char **));
 197
 198 static void
 199 select_emulation_mode (argc, argv)
 200      int argc;
 201      char **argv;
 202 {
 203   int i;
 204   char *p, *em = 0;
 205
 206   for (i = 1; i < argc; i++)
 207     if (!strncmp ("--em", argv[i], 4))
 208       break;
 209
 210   if (i == argc)
 211     goto do_default;
 212
 213   p = strchr (argv[i], '=');
 214   if (p)
 215     p++;
 216   else
 217     p = argv[i+1];
 218
 219   if (!p || !*p)
 220     as_fatal ("missing emulation mode name");
 221   em = p;
 222
 223  do_default:
 224   if (em == 0)
 225     em = getenv (EMULATION_ENVIRON);
 226   if (em == 0)
 227     em = DEFAULT_EMULATION;
 228
 229   if (em)
 230     {
 231       for (i = 0; i < n_emulations; i++)
 232         if (!strcmp (emulations[i]->name, em))
 233           break;
 234       if (i == n_emulations)
 235         as_fatal ("unrecognized emulation name `%s'", em);
 236       this_emulation = emulations[i];
 237     }
 238   else
 239     this_emulation = emulations[0];
 240
 241   this_emulation->init ();
 242 }
 243
 244 const char *
 245 default_emul_bfd_name ()
 246 {
 247   abort ();
 248   return NULL;
 249 }
 250
 251 void
 252 common_emul_init ()
 253 {
 254   this_format = this_emulation->format;
 255
 256   if (this_emulation->leading_underscore == 2)
 257     this_emulation->leading_underscore = this_format->dfl_leading_underscore;
 258
 259   if (this_emulation->default_endian != 2)
 260     target_big_endian = this_emulation->default_endian;
 261
 262   if (this_emulation->fake_label_name == 0)
 263     {
 264       if (this_emulation->leading_underscore)
 265         this_emulation->fake_label_name = "L0\001";
 266       else
 267         /* What other parameters should we test?  */
 268         this_emulation->fake_label_name = ".L0\001";
 269     }
 270 }
 271 #endif
 272
 273 /*
 274  * Since it is easy to do here we interpret the special arg "-"
 275  * to mean "use stdin" and we set that argv[] pointing to "".
 276  * After we have munged argv[], the only things left are source file
 277  * name(s) and ""(s) denoting stdin. These file names are used
 278  * (perhaps more than once) later.
 279  *
 280  * check for new machine-dep cmdline options in
 281  * md_parse_option definitions in config/tc-*.c
 282  */
 283
 284 static void
 285 parse_args (pargc, pargv)
 286      int *pargc;
 287      char ***pargv;
 288 {
 289   int old_argc, new_argc;
 290   char **old_argv, **new_argv;
 291
 292   /* Starting the short option string with '-' is for programs that
 293      expect options and other ARGV-elements in any order and that care about
 294      the ordering of the two.  We describe each non-option ARGV-element
 295      as if it were the argument of an option with character code 1.  */
 296
 297   char *shortopts;
 298   extern CONST char *md_shortopts;
 299   static const char std_shortopts[] =
 300     {
 301       '-', 'J',
 302 #ifndef WORKING_DOT_WORD
 303       /* -K is not meaningful if .word is not being hacked.  */
 304       'K',
 305 #endif
 306       'L', 'M', 'R', 'W', 'Z', 'f', 'a', ':', ':', 'D', 'I', ':', 'o', ':',
 307 #ifndef VMS
 308       /* -v takes an argument on VMS, so we don't make it a generic
 309          option.  */
 310       'v',
 311 #endif
 312       'w', 'X',
 313       /* New option for extending instruction set (see also --itbl below) */
 314       't', ':',
 315       '\0'
 316     };
 317   struct option *longopts;
 318   extern struct option md_longopts[];
 319   extern size_t md_longopts_size;
 320   static const struct option std_longopts[] = {
 321 #define OPTION_HELP (OPTION_STD_BASE)
 322     {"help", no_argument, NULL, OPTION_HELP},
 323     {"keep-locals", no_argument, NULL, 'L'},
 324     {"mri", no_argument, NULL, 'M'},
 325 #define OPTION_NOCPP (OPTION_STD_BASE + 1)
 326     {"nocpp", no_argument, NULL, OPTION_NOCPP},
 327 #define OPTION_STATISTICS (OPTION_STD_BASE + 2)
 328     {"statistics", no_argument, NULL, OPTION_STATISTICS},
 329 #define OPTION_VERSION (OPTION_STD_BASE + 3)
 330     {"version", no_argument, NULL, OPTION_VERSION},
 331 #define OPTION_DUMPCONFIG (OPTION_STD_BASE + 4)
 332     {"dump-config", no_argument, NULL, OPTION_DUMPCONFIG},
 333 #define OPTION_VERBOSE (OPTION_STD_BASE + 5)
 334     {"verbose", no_argument, NULL, OPTION_VERBOSE},
 335 #define OPTION_EMULATION (OPTION_STD_BASE + 6)
 336     {"emulation", required_argument, NULL, OPTION_EMULATION},
 337 #define OPTION_DEFSYM (OPTION_STD_BASE + 7)
 338     {"defsym", required_argument, NULL, OPTION_DEFSYM},
 339 #define OPTION_INSTTBL (OPTION_STD_BASE + 8)
 340     /* New option for extending instruction set (see also -t above).
 341        The "-t file" or "--itbl file" option extends the basic set of
 342        valid instructions by reading "file", a text file containing a
 343        list of instruction formats.  The additional opcodes and their
 344        formats are added to the built-in set of instructions, and
 345        mnemonics for new registers may also be defined.  */
 346     {"itbl", required_argument, NULL, OPTION_INSTTBL},
 347 #define OPTION_LISTING_LHS_WIDTH (OPTION_STD_BASE + 9)
 348     {"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH},
 349 #define OPTION_LISTING_LHS_WIDTH2 (OPTION_STD_BASE + 10)
 350     {"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2},
 351 #define OPTION_LISTING_RHS_WIDTH (OPTION_STD_BASE + 11)
 352     {"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH},
 353 #define OPTION_LISTING_CONT_LINES (OPTION_STD_BASE + 12)
 354     {"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES},
 355 #define OPTION_DEPFILE (OPTION_STD_BASE + 13)
 356     {"MD", required_argument, NULL, OPTION_DEPFILE},
 357 #define OPTION_GSTABS (OPTION_STD_BASE + 14)
 358     {"gstabs", no_argument, NULL, OPTION_GSTABS},
 359 #define OPTION_STRIP_LOCAL_ABSOLUTE (OPTION_STD_BASE + 15)
 360     {"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE},
 361 #define OPTION_TRADITIONAL_FORMAT (OPTION_STD_BASE + 16)
 362     {"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
 363   };
 364
 365   /* Construct the option lists from the standard list and the
 366      target dependent list.  */
 367   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 368   longopts = (struct option *) xmalloc (sizeof (std_longopts) + md_longopts_size);
 369   memcpy (longopts, std_longopts, sizeof (std_longopts));
 370   memcpy ((char *) longopts + sizeof (std_longopts),
 371           md_longopts, md_longopts_size);
 372
 373   /* Make a local copy of the old argv.  */
 374   old_argc = *pargc;
 375   old_argv = *pargv;
 376
 377   /* Initialize a new argv that contains no options.  */
 378   new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
 379   new_argv[0] = old_argv[0];
 380   new_argc = 1;
 381   new_argv[new_argc] = NULL;
 382
 383   while (1)
 384     {
 385       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 386          indicate a long option.  */
 387       int longind;
 388       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 389                                    &longind);
 390
 391       if (optc == -1)
 392         break;
 393
 394       switch (optc)
 395         {
 396         default:
 397           /* md_parse_option should return 1 if it recognizes optc,
 398              0 if not.  */
 399           if (md_parse_option (optc, optarg) != 0)
 400             break;
 401           /* `-v' isn't included in the general short_opts list, so check for
 402              it explicity here before deciding we've gotten a bad argument.  */
 403           if (optc == 'v')
 404             {
 405 #ifdef VMS
 406               /* Telling getopt to treat -v's value as optional can result
 407                  in it picking up a following filename argument here.  The
 408                  VMS code in md_parse_option can return 0 in that case,
 409                  but it has no way of pushing the filename argument back.  */
 410               if (optarg && *optarg)
 411                 new_argv[new_argc++] = optarg,  new_argv[new_argc] = NULL;
 412               else
 413 #else
 414               case 'v':
 415 #endif
 416               case OPTION_VERBOSE:
 417                 print_version_id ();
 418               break;
 419             }
 420           /*FALLTHRU*/
 421
 422         case '?':
 423           exit (EXIT_FAILURE);
 424
 425         case 1:                 /* File name.  */
 426           if (!strcmp (optarg, "-"))
 427             optarg = "";
 428           new_argv[new_argc++] = optarg;
 429           new_argv[new_argc] = NULL;
 430           break;
 431
 432         case OPTION_HELP:
 433           show_usage (stdout);
 434           exit (EXIT_SUCCESS);
 435
 436         case OPTION_NOCPP:
 437           break;
 438
 439         case OPTION_STATISTICS:
 440           flag_print_statistics = 1;
 441           break;
 442
 443         case OPTION_STRIP_LOCAL_ABSOLUTE:
 444           flag_strip_local_absolute = 1;
 445           break;
 446
 447         case OPTION_TRADITIONAL_FORMAT:
 448           flag_traditional_format = 1;
 449           break;
 450
 451         case OPTION_VERSION:
 452           /* This output is intended to follow the GNU standards document.  */
 453           printf ("GNU assembler %s\n", VERSION);
 454           printf ("Copyright 1997 Free Software Foundation, Inc.\n");
 455           printf ("\
 456 This program is free software; you may redistribute it under the terms of\n\
 457 the GNU General Public License.  This program has absolutely no warranty.\n");
 458           printf ("This assembler was configured for a target of `%s'.\n",
 459                   TARGET_ALIAS);
 460           exit (EXIT_SUCCESS);
 461
 462         case OPTION_EMULATION:
 463 #ifdef USE_EMULATIONS
 464           if (strcmp (optarg, this_emulation->name))
 465             as_fatal ("multiple emulation names specified");
 466 #else
 467           as_fatal ("emulations not handled in this configuration");
 468 #endif
 469           break;
 470
 471         case OPTION_DUMPCONFIG:
 472           fprintf (stderr, "alias = %s\n", TARGET_ALIAS);
 473           fprintf (stderr, "canonical = %s\n", TARGET_CANONICAL);
 474           fprintf (stderr, "cpu-type = %s\n", TARGET_CPU);
 475 #ifdef TARGET_OBJ_FORMAT
 476           fprintf (stderr, "format = %s\n", TARGET_OBJ_FORMAT);
 477 #endif
 478 #ifdef TARGET_FORMAT
 479           fprintf (stderr, "bfd-target = %s\n", TARGET_FORMAT);
 480 #endif
 481           exit (EXIT_SUCCESS);
 482
 483         case OPTION_DEFSYM:
 484           {
 485             char *s;
 486             long i;
 487             struct defsym_list *n;
 488
 489             for (s = optarg; *s != '\0' && *s != '='; s++)
 490               ;
 491             if (*s == '\0')
 492               as_fatal ("bad defsym; format is --defsym name=value");
 493             *s++ = '\0';
 494             i = strtol (s, (char **) NULL, 0);
 495             n = (struct defsym_list *) xmalloc (sizeof *n);
 496             n->next = defsyms;
 497             n->name = optarg;
 498             n->value = i;
 499             defsyms = n;
 500           }
 501           break;
 502
 503         case OPTION_INSTTBL:
 504         case 't':
 505           {
 506             /* optarg is the name of the file containing the instruction
 507                formats, opcodes, register names, etc. */
 508             struct itbl_file_list *n;
 509
 510             if (optarg == NULL)
 511               {
 512                 as_warn ( "No file name following -t option\n" );
 513                 break;
 514               }
 515
 516             n = (struct itbl_file_list *) xmalloc (sizeof *n);
 517             n->next = itbl_files;
 518             n->name = optarg;
 519             itbl_files = n;
 520
 521             /* Parse the file and add the new instructions to our internal
 522                table.  If multiple instruction tables are specified, the
 523                information from this table gets appended onto the existing
 524                internal table. */
 525             itbl_files->name = xstrdup (optarg);
 526             if (itbl_parse (itbl_files->name) != 0)
 527               {
 528                 fprintf (stderr, "Failed to read instruction table %s\n",
 529                          itbl_files->name);
 530                 exit (EXIT_SUCCESS);
 531               }
 532           }
 533           break;
 534
 535         case OPTION_DEPFILE:
 536           start_dependencies (optarg);
 537           break;
 538
 539         case OPTION_GSTABS:
 540           debug_type = DEBUG_STABS;
 541           break;
 542
 543         case 'J':
 544           flag_signed_overflow_ok = 1;
 545           break;
 546
 547 #ifndef WORKING_DOT_WORD
 548         case 'K':
 549           flag_warn_displacement = 1;
 550           break;
 551 #endif
 552
 553         case 'L':
 554           flag_keep_locals = 1;
 555           break;
 556
 557         case OPTION_LISTING_LHS_WIDTH:
 558           listing_lhs_width = atoi(optarg);
 559           if (listing_lhs_width_second < listing_lhs_width)
 560             listing_lhs_width_second = listing_lhs_width;
 561           break;
 562         case OPTION_LISTING_LHS_WIDTH2:
 563           {
 564             int tmp = atoi(optarg);
 565             if (tmp > listing_lhs_width)
 566               listing_lhs_width_second = tmp;
 567           }
 568           break;
 569         case OPTION_LISTING_RHS_WIDTH:
 570           listing_rhs_width = atoi(optarg);
 571           break;
 572         case OPTION_LISTING_CONT_LINES:
 573           listing_lhs_cont_lines = atoi(optarg);
 574           break;
 575
 576         case 'M':
 577           flag_mri = 1;
 578 #ifdef TC_M68K
 579           flag_m68k_mri = 1;
 580 #endif
 581           break;
 582
 583         case 'R':
 584           flag_readonly_data_in_text = 1;
 585           break;
 586
 587         case 'W':
 588           flag_no_warnings = 1;
 589           break;
 590
 591         case 'Z':
 592           flag_always_generate_output = 1;
 593           break;
 594
 595         case 'a':
 596           if (optarg)
 597             {
 598               while (*optarg)
 599                 {
 600                   switch (*optarg)
 601                     {
 602                     case 'c':
 603                       listing |= LISTING_NOCOND;
 604                       break;
 605                     case 'd':
 606                       listing |= LISTING_NODEBUG;
 607                       break;
 608                     case 'h':
 609                       listing |= LISTING_HLL;
 610                       break;
 611                     case 'l':
 612                       listing |= LISTING_LISTING;
 613                       break;
 614                     case 'm':
 615                       listing |= LISTING_MACEXP;
 616                       break;
 617                     case 'n':
 618                       listing |= LISTING_NOFORM;
 619                       break;
 620                     case 's':
 621                       listing |= LISTING_SYMBOLS;
 622                       break;
 623                     case '=':
 624                       listing_filename = xstrdup (optarg + 1);
 625                       optarg += strlen (listing_filename);
 626                       break;
 627                     default:
 628                       as_fatal ("invalid listing option `%c'", *optarg);
 629                       break;
 630                     }
 631                   optarg++;
 632                 }
 633             }
 634           if (!listing)
 635             listing = LISTING_DEFAULT;
 636           break;
 637
 638         case 'D':
 639           /* DEBUG is implemented: it debugs different */
 640           /* things from other people's assemblers. */
 641           flag_debug = 1;
 642           break;
 643
 644         case 'f':
 645           flag_no_comments = 1;
 646           break;
 647
 648         case 'I':
 649           {                     /* Include file directory */
 650             char *temp = xstrdup (optarg);
 651             add_include_dir (temp);
 652             break;
 653           }
 654
 655         case 'o':
 656           out_file_name = xstrdup (optarg);
 657           break;
 658
 659         case 'w':
 660           break;
 661
 662         case 'X':
 663           /* -X means treat warnings as errors */
 664           break;
 665         }
 666     }
 667
 668   free (shortopts);
 669   free (longopts);
 670
 671   *pargc = new_argc;
 672   *pargv = new_argv;
 673 }
 674
 675 static long start_time;
 676
 677 int
 678 main (argc, argv)
 679      int argc;
 680      char **argv;
 681 {
 682   int macro_alternate;
 683   int macro_strip_at;
 684   int keep_it;
 685
 686   start_time = get_run_time ();
 687
 688
 689   if (debug_memory)
 690     {
 691 #ifdef BFD_ASSEMBLER
 692       extern long _bfd_chunksize;
 693       _bfd_chunksize = 64;
 694 #endif
 695       chunksize = 64;
 696     }
 697
 698 #ifdef HOST_SPECIAL_INIT
 699   HOST_SPECIAL_INIT (argc, argv);
 700 #endif
 701
 702   myname = argv[0];
 703   xmalloc_set_program_name (myname);
 704
 705   START_PROGRESS (myname, 0);
 706
 707 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
 708 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
 709 #endif
 710
 711   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
 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 */