gas/as.c

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