gas/as.c

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