gas/as.c

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