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