gas/as.c

   1 /* as.c - GAS main program.
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  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  *                      bugs
  29  *
  30  * : initialisers
  31  *      Since no-one else says they will support them in future: I
  32  * don't support them now.
  33  */
  34
  35 #include "ansidecl.h"
  36
  37 #define COMMON
  38
  39 #include "as.h"
  40 #include "subsegs.h"
  41 #include "output-file.h"
  42 #include "sb.h"
  43 #include "macro.h"
  44 #include "dwarf2dbg.h"
  45
  46 #ifdef HAVE_ITBL_CPU
  47 #include "itbl-ops.h"
  48 #else
  49 #define itbl_parse(itbl_file) 1
  50 #define itbl_init()
  51 #endif
  52
  53 #ifdef HAVE_SBRK
  54 #ifdef NEED_DECLARATION_SBRK
  55 extern PTR sbrk ();
  56 #endif
  57 #endif
  58
  59 static void show_usage PARAMS ((FILE *));
  60 static void parse_args PARAMS ((int *, char ***));
  61 static void dump_statistics PARAMS ((void));
  62 static void perform_an_assembly_pass PARAMS ((int argc, char **argv));
  63 static int macro_expr PARAMS ((const char *, int, sb *, int *));
  64
  65 /* True if a listing is wanted.  */
  66 int listing;
  67
  68 /* Name of listing file.  */
  69 static char *listing_filename = NULL;
  70
  71 /* Type of debugging to generate.  */
  72
  73 enum debug_info_type debug_type = DEBUG_UNSPECIFIED;
  74
  75 /* Maximum level of macro nesting.  */
  76 int max_macro_nest = 100;
  77
  78 /* argv[0]  */
  79 char *myname;
  80 #ifdef BFD_ASSEMBLER
  81 segT reg_section, expr_section;
  82 segT text_section, data_section, bss_section;
  83 #endif
  84
  85 /* The default obstack chunk size.  If we set this to zero, the
  86    obstack code will use whatever will fit in a 4096 byte block.  */
  87 int chunksize = 0;
  88
  89 /* To monitor memory allocation more effectively, make this non-zero.
  90    Then the chunk sizes for gas and bfd will be reduced.  */
  91 int debug_memory = 0;
  92
  93 /* We build a list of defsyms as we read the options, and then define
  94    them after we have initialized everything.  */
  95
  96 struct defsym_list {
  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   struct itbl_file_list *next;
 108   char *name;
 109 };
 110
 111 static struct itbl_file_list *itbl_files;
 112 \f
 113 #ifdef USE_EMULATIONS
 114 #define EMULATION_ENVIRON "AS_EMULATION"
 115
 116 extern struct emulation mipsbelf, mipslelf, mipself;
 117 extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
 118 extern struct emulation i386coff, i386elf, i386aout;
 119 extern struct emulation crisaout, criself;
 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   --target-help           show target specific options\n"));
 270   fprintf (stream, _("\
 271   -I DIR                  add DIR to search list for .include directives\n"));
 272   fprintf (stream, _("\
 273   -J                      don't warn about signed overflow\n"));
 274   fprintf (stream, _("\
 275   -K                      warn when differences altered for long displacements\n"));
 276   fprintf (stream, _("\
 277   -L,--keep-locals        keep local symbols (e.g. starting with `L')\n"));
 278   fprintf (stream, _("\
 279   -M,--mri                assemble in MRI compatibility mode\n"));
 280   fprintf (stream, _("\
 281   --MD FILE               write dependency information in FILE (default none)\n"));
 282   fprintf (stream, _("\
 283   -nocpp                  ignored\n"));
 284   fprintf (stream, _("\
 285   -o OBJFILE              name the object-file output OBJFILE (default a.out)\n"));
 286   fprintf (stream, _("\
 287   -R                      fold data section into text section\n"));
 288   fprintf (stream, _("\
 289   --statistics            print various measured statistics from execution\n"));
 290   fprintf (stream, _("\
 291   --strip-local-absolute  strip local absolute symbols\n"));
 292   fprintf (stream, _("\
 293   --traditional-format    Use same format as native assembler when possible\n"));
 294   fprintf (stream, _("\
 295   --version               print assembler version number and exit\n"));
 296   fprintf (stream, _("\
 297   -W  --no-warn           suppress warnings\n"));
 298   fprintf (stream, _("\
 299   --warn                  don't suppress warnings\n"));
 300   fprintf (stream, _("\
 301   --fatal-warnings        treat warnings as errors\n"));
 302   fprintf (stream, _("\
 303   --itbl INSTTBL          extend instruction set to include instructions\n\
 304                           matching the specifications defined in file INSTTBL\n"));
 305   fprintf (stream, _("\
 306   -w                      ignored\n"));
 307   fprintf (stream, _("\
 308   -X                      ignored\n"));
 309   fprintf (stream, _("\
 310   -Z                      generate object file even after errors\n"));
 311   fprintf (stream, _("\
 312   --listing-lhs-width     set the width in words of the output data column of\n\
 313                           the listing\n"));
 314   fprintf (stream, _("\
 315   --listing-lhs-width2    set the width in words of the continuation lines\n\
 316                           of the output data column; ignored if smaller than\n\
 317                           the width of the first line\n"));
 318   fprintf (stream, _("\
 319   --listing-rhs-width     set the max width in characters of the lines from\n\
 320                           the source file\n"));
 321   fprintf (stream, _("\
 322   --listing-cont-lines    set the maximum number of continuation lines used\n\
 323                           for the output data column of the listing\n"));
 324
 325   md_show_usage (stream);
 326
 327   fputc ('\n', stream);
 328   fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 329 }
 330
 331 /* Since it is easy to do here we interpret the special arg "-"
 332    to mean "use stdin" and we set that argv[] pointing to "".
 333    After we have munged argv[], the only things left are source file
 334    name(s) and ""(s) denoting stdin. These file names are used
 335    (perhaps more than once) later.
 336
 337    check for new machine-dep cmdline options in
 338    md_parse_option definitions in config/tc-*.c.  */
 339
 340 static void
 341 parse_args (pargc, pargv)
 342      int *pargc;
 343      char ***pargv;
 344 {
 345   int old_argc, new_argc;
 346   char **old_argv, **new_argv;
 347
 348   /* Starting the short option string with '-' is for programs that
 349      expect options and other ARGV-elements in any order and that care about
 350      the ordering of the two.  We describe each non-option ARGV-element
 351      as if it were the argument of an option with character code 1.  */
 352
 353   char *shortopts;
 354   extern CONST char *md_shortopts;
 355   static const char std_shortopts[] = {
 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_TARGET_HELP (OPTION_STD_BASE + 19)
 424     {"target-help", no_argument, NULL, OPTION_TARGET_HELP},
 425 #define OPTION_WARN_FATAL (OPTION_STD_BASE + 20)
 426     {"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
 427     /* When you add options here, check that they do not collide with
 428        OPTION_MD_BASE.  See as.h.  */
 429   };
 430
 431   /* Construct the option lists from the standard list and the target
 432      dependent list.  Include space for an extra NULL option and
 433      always NULL terminate.  */
 434   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 435   longopts = (struct option *) xmalloc (sizeof (std_longopts)
 436                                         + md_longopts_size
 437                                         + sizeof (struct option));
 438   memcpy (longopts, std_longopts, sizeof (std_longopts));
 439   memcpy ((char *) longopts + sizeof (std_longopts),
 440           md_longopts, md_longopts_size);
 441   memset ((char *) longopts + sizeof (std_longopts) + md_longopts_size,
 442           0, sizeof (struct option));
 443
 444   /* Make a local copy of the old argv.  */
 445   old_argc = *pargc;
 446   old_argv = *pargv;
 447
 448   /* Initialize a new argv that contains no options.  */
 449   new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
 450   new_argv[0] = old_argv[0];
 451   new_argc = 1;
 452   new_argv[new_argc] = NULL;
 453
 454   while (1)
 455     {
 456       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 457          indicate a long option.  */
 458       int longind;
 459       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 460                                    &longind);
 461
 462       if (optc == -1)
 463         break;
 464
 465       switch (optc)
 466         {
 467         default:
 468           /* md_parse_option should return 1 if it recognizes optc,
 469              0 if not.  */
 470           if (md_parse_option (optc, optarg) != 0)
 471             break;
 472           /* `-v' isn't included in the general short_opts list, so check for
 473              it explicity here before deciding we've gotten a bad argument.  */
 474           if (optc == 'v')
 475             {
 476 #ifdef VMS
 477               /* Telling getopt to treat -v's value as optional can result
 478                  in it picking up a following filename argument here.  The
 479                  VMS code in md_parse_option can return 0 in that case,
 480                  but it has no way of pushing the filename argument back.  */
 481               if (optarg && *optarg)
 482                 new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
 483               else
 484 #else
 485               case 'v':
 486 #endif
 487               case OPTION_VERBOSE:
 488                 print_version_id ();
 489               break;
 490             }
 491           /* Fall through.  */
 492
 493         case '?':
 494           exit (EXIT_FAILURE);
 495
 496         case 1:                 /* File name.  */
 497           if (!strcmp (optarg, "-"))
 498             optarg = "";
 499           new_argv[new_argc++] = optarg;
 500           new_argv[new_argc] = NULL;
 501           break;
 502
 503         case OPTION_TARGET_HELP:
 504           md_show_usage (stdout);
 505           exit (EXIT_SUCCESS);
 506
 507         case OPTION_HELP:
 508           show_usage (stdout);
 509           exit (EXIT_SUCCESS);
 510
 511         case OPTION_NOCPP:
 512           break;
 513
 514         case OPTION_STATISTICS:
 515           flag_print_statistics = 1;
 516           break;
 517
 518         case OPTION_STRIP_LOCAL_ABSOLUTE:
 519           flag_strip_local_absolute = 1;
 520           break;
 521
 522         case OPTION_TRADITIONAL_FORMAT:
 523           flag_traditional_format = 1;
 524           break;
 525
 526         case OPTION_VERSION:
 527           /* This output is intended to follow the GNU standards document.  */
 528           printf (_("GNU assembler %s\n"), VERSION);
 529           printf (_("Copyright 2001 Free Software Foundation, Inc.\n"));
 530           printf (_("\
 531 This program is free software; you may redistribute it under the terms of\n\
 532 the GNU General Public License.  This program has absolutely no warranty.\n"));
 533           printf (_("This assembler was configured for a target of `%s'.\n"),
 534                   TARGET_ALIAS);
 535           exit (EXIT_SUCCESS);
 536
 537         case OPTION_EMULATION:
 538 #ifdef USE_EMULATIONS
 539           if (strcmp (optarg, this_emulation->name))
 540             as_fatal (_("multiple emulation names specified"));
 541 #else
 542           as_fatal (_("emulations not handled in this configuration"));
 543 #endif
 544           break;
 545
 546         case OPTION_DUMPCONFIG:
 547           fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
 548           fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
 549           fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
 550 #ifdef TARGET_OBJ_FORMAT
 551           fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
 552 #endif
 553 #ifdef TARGET_FORMAT
 554           fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
 555 #endif
 556           exit (EXIT_SUCCESS);
 557
 558         case OPTION_DEFSYM:
 559           {
 560             char *s;
 561             valueT i;
 562             struct defsym_list *n;
 563
 564             for (s = optarg; *s != '\0' && *s != '='; s++)
 565               ;
 566             if (*s == '\0')
 567               as_fatal (_("bad defsym; format is --defsym name=value"));
 568             *s++ = '\0';
 569 #ifdef BFD_ASSEMBLER
 570             i = bfd_scan_vma (s, (const char **) NULL, 0);
 571 #else
 572             i = strtol (s, (char **) NULL, 0);
 573 #endif
 574             n = (struct defsym_list *) xmalloc (sizeof *n);
 575             n->next = defsyms;
 576             n->name = optarg;
 577             n->value = i;
 578             defsyms = n;
 579           }
 580           break;
 581
 582         case OPTION_INSTTBL:
 583         case 't':
 584           {
 585             /* optarg is the name of the file containing the instruction
 586                formats, opcodes, register names, etc.  */
 587             struct itbl_file_list *n;
 588
 589             if (optarg == NULL)
 590               {
 591                 as_warn (_("No file name following -t option\n"));
 592                 break;
 593               }
 594
 595             n = (struct itbl_file_list *) xmalloc (sizeof *n);
 596             n->next = itbl_files;
 597             n->name = optarg;
 598             itbl_files = n;
 599
 600             /* Parse the file and add the new instructions to our internal
 601                table.  If multiple instruction tables are specified, the
 602                information from this table gets appended onto the existing
 603                internal table.  */
 604             itbl_files->name = xstrdup (optarg);
 605             if (itbl_parse (itbl_files->name) != 0)
 606               {
 607                 fprintf (stderr, _("Failed to read instruction table %s\n"),
 608                          itbl_files->name);
 609                 exit (EXIT_SUCCESS);
 610               }
 611           }
 612           break;
 613
 614         case OPTION_DEPFILE:
 615           start_dependencies (optarg);
 616           break;
 617
 618         case OPTION_GSTABS:
 619           debug_type = DEBUG_STABS;
 620           break;
 621
 622         case OPTION_GDWARF2:
 623           debug_type = DEBUG_DWARF2;
 624           break;
 625
 626         case 'J':
 627           flag_signed_overflow_ok = 1;
 628           break;
 629
 630 #ifndef WORKING_DOT_WORD
 631         case 'K':
 632           flag_warn_displacement = 1;
 633           break;
 634 #endif
 635
 636         case 'L':
 637           flag_keep_locals = 1;
 638           break;
 639
 640         case OPTION_LISTING_LHS_WIDTH:
 641           listing_lhs_width = atoi (optarg);
 642           if (listing_lhs_width_second < listing_lhs_width)
 643             listing_lhs_width_second = listing_lhs_width;
 644           break;
 645         case OPTION_LISTING_LHS_WIDTH2:
 646           {
 647             int tmp = atoi (optarg);
 648             if (tmp > listing_lhs_width)
 649               listing_lhs_width_second = tmp;
 650           }
 651           break;
 652         case OPTION_LISTING_RHS_WIDTH:
 653           listing_rhs_width = atoi (optarg);
 654           break;
 655         case OPTION_LISTING_CONT_LINES:
 656           listing_lhs_cont_lines = atoi (optarg);
 657           break;
 658
 659         case 'M':
 660           flag_mri = 1;
 661 #ifdef TC_M68K
 662           flag_m68k_mri = 1;
 663 #endif
 664           break;
 665
 666         case 'R':
 667           flag_readonly_data_in_text = 1;
 668           break;
 669
 670         case 'W':
 671           flag_no_warnings = 1;
 672           break;
 673
 674         case OPTION_WARN:
 675           flag_no_warnings = 0;
 676           flag_fatal_warnings = 0;
 677           break;
 678
 679         case OPTION_WARN_FATAL:
 680           flag_no_warnings = 0;
 681           flag_fatal_warnings = 1;
 682           break;
 683
 684         case 'Z':
 685           flag_always_generate_output = 1;
 686           break;
 687
 688         case 'a':
 689           if (optarg)
 690             {
 691               if (md_parse_option (optc, optarg) != 0)
 692                 break;
 693
 694               while (*optarg)
 695                 {
 696                   switch (*optarg)
 697                     {
 698                     case 'c':
 699                       listing |= LISTING_NOCOND;
 700                       break;
 701                     case 'd':
 702                       listing |= LISTING_NODEBUG;
 703                       break;
 704                     case 'h':
 705                       listing |= LISTING_HLL;
 706                       break;
 707                     case 'l':
 708                       listing |= LISTING_LISTING;
 709                       break;
 710                     case 'm':
 711                       listing |= LISTING_MACEXP;
 712                       break;
 713                     case 'n':
 714                       listing |= LISTING_NOFORM;
 715                       break;
 716                     case 's':
 717                       listing |= LISTING_SYMBOLS;
 718                       break;
 719                     case '=':
 720                       listing_filename = xstrdup (optarg + 1);
 721                       optarg += strlen (listing_filename);
 722                       break;
 723                     default:
 724                       as_fatal (_("invalid listing option `%c'"), *optarg);
 725                       break;
 726                     }
 727                   optarg++;
 728                 }
 729             }
 730           if (!listing)
 731             listing = LISTING_DEFAULT;
 732           break;
 733
 734         case 'D':
 735           /* DEBUG is implemented: it debugs different
 736              things from other people's assemblers.  */
 737           flag_debug = 1;
 738           break;
 739
 740         case 'f':
 741           flag_no_comments = 1;
 742           break;
 743
 744         case 'I':
 745           {                     /* Include file directory.  */
 746             char *temp = xstrdup (optarg);
 747             add_include_dir (temp);
 748             break;
 749           }
 750
 751         case 'o':
 752           out_file_name = xstrdup (optarg);
 753           break;
 754
 755         case 'w':
 756           break;
 757
 758         case 'X':
 759           /* -X means treat warnings as errors.  */
 760           break;
 761         }
 762     }
 763
 764   free (shortopts);
 765   free (longopts);
 766
 767   *pargc = new_argc;
 768   *pargv = new_argv;
 769 }
 770
 771 static long start_time;
 772
 773 int
 774 main (argc, argv)
 775      int argc;
 776      char **argv;
 777 {
 778   int macro_alternate;
 779   int macro_strip_at;
 780   int keep_it;
 781
 782   start_time = get_run_time ();
 783
 784 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 785   setlocale (LC_MESSAGES, "");
 786 #endif
 787   bindtextdomain (PACKAGE, LOCALEDIR);
 788   textdomain (PACKAGE);
 789
 790   if (debug_memory)
 791     {
 792 #ifdef BFD_ASSEMBLER
 793       extern long _bfd_chunksize;
 794       _bfd_chunksize = 64;
 795 #endif
 796       chunksize = 64;
 797     }
 798
 799 #ifdef HOST_SPECIAL_INIT
 800   HOST_SPECIAL_INIT (argc, argv);
 801 #endif
 802
 803   myname = argv[0];
 804   xmalloc_set_program_name (myname);
 805
 806   START_PROGRESS (myname, 0);
 807
 808 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
 809 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
 810 #endif
 811
 812   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
 813
 814   hex_init ();
 815 #ifdef BFD_ASSEMBLER
 816   bfd_init ();
 817   bfd_set_error_program_name (myname);
 818 #endif
 819
 820 #ifdef USE_EMULATIONS
 821   select_emulation_mode (argc, argv);
 822 #endif
 823
 824   PROGRESS (1);
 825   symbol_begin ();
 826   frag_init ();
 827   subsegs_begin ();
 828   parse_args (&argc, &argv);
 829   read_begin ();
 830   input_scrub_begin ();
 831   expr_begin ();
 832
 833   if (flag_print_statistics)
 834     xatexit (dump_statistics);
 835
 836   macro_alternate = 0;
 837   macro_strip_at = 0;
 838 #ifdef TC_I960
 839   macro_strip_at = flag_mri;
 840 #endif
 841 #ifdef TC_A29K
 842   /* For compatibility with the AMD 29K family macro assembler
 843      specification.  */
 844   macro_alternate = 1;
 845   macro_strip_at = 1;
 846 #endif
 847
 848   macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr);
 849
 850   PROGRESS (1);
 851
 852 #ifdef BFD_ASSEMBLER
 853   output_file_create (out_file_name);
 854   assert (stdoutput != 0);
 855 #endif
 856
 857 #ifdef tc_init_after_args
 858   tc_init_after_args ();
 859 #endif
 860
 861   itbl_init ();
 862
 863   /* Now that we have fully initialized, and have created the output
 864      file, define any symbols requested by --defsym command line
 865      arguments.  */
 866   while (defsyms != NULL)
 867     {
 868       symbolS *sym;
 869       struct defsym_list *next;
 870
 871       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
 872                         &zero_address_frag);
 873       symbol_table_insert (sym);
 874       next = defsyms->next;
 875       free (defsyms);
 876       defsyms = next;
 877     }
 878
 879   PROGRESS (1);
 880
 881   /* Assemble it.  */
 882   perform_an_assembly_pass (argc, argv);
 883
 884   cond_finish_check (-1);
 885
 886 #ifdef md_end
 887   md_end ();
 888 #endif
 889
 890   /* If we've been collecting dwarf2 .debug_line info, either for
 891      assembly debugging or on behalf of the compiler, emit it now.  */
 892   dwarf2_finish ();
 893
 894   if (seen_at_least_1_file ()
 895       && (flag_always_generate_output || had_errors () == 0))
 896     keep_it = 1;
 897   else
 898     keep_it = 0;
 899
 900 #if defined (BFD_ASSEMBLER) || !defined (BFD)
 901   /* This used to be done at the start of write_object_file in
 902      write.c, but that caused problems when doing listings when
 903      keep_it was zero.  This could probably be moved above md_end, but
 904      I didn't want to risk the change.  */
 905   subsegs_finish ();
 906 #endif
 907
 908   if (keep_it)
 909     write_object_file ();
 910
 911 #ifndef NO_LISTING
 912   listing_print (listing_filename);
 913 #endif
 914
 915 #ifndef OBJ_VMS /* does its own file handling */
 916 #ifndef BFD_ASSEMBLER
 917   if (keep_it)
 918 #endif
 919     output_file_close (out_file_name);
 920 #endif
 921
 922   if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
 923     as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
 924
 925   if (had_errors () > 0 && ! flag_always_generate_output)
 926     keep_it = 0;
 927
 928   if (!keep_it)
 929     unlink (out_file_name);
 930
 931   input_scrub_end ();
 932
 933   END_PROGRESS (myname);
 934
 935   /* Use xexit instead of return, because under VMS environments they
 936      may not place the same interpretation on the value given.  */
 937   if (had_errors () > 0)
 938     xexit (EXIT_FAILURE);
 939
 940   /* Only generate dependency file if assembler was successful.  */
 941   print_dependencies ();
 942
 943   xexit (EXIT_SUCCESS);
 944 }
 945
 946 static void
 947 dump_statistics ()
 948 {
 949 #ifdef HAVE_SBRK
 950   char *lim = (char *) sbrk (0);
 951 #endif
 952   long run_time = get_run_time () - start_time;
 953
 954   fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
 955            myname, run_time / 1000000, run_time % 1000000);
 956 #ifdef HAVE_SBRK
 957   fprintf (stderr, _("%s: data size %ld\n"),
 958            myname, (long) (lim - (char *) &environ));
 959 #endif
 960
 961   subsegs_print_statistics (stderr);
 962   write_print_statistics (stderr);
 963   symbol_print_statistics (stderr);
 964   read_print_statistics (stderr);
 965
 966 #ifdef tc_print_statistics
 967   tc_print_statistics (stderr);
 968 #endif
 969 #ifdef obj_print_statistics
 970   obj_print_statistics (stderr);
 971 #endif
 972 }
 973 \f
 974 /* Here to attempt 1 pass over each input file.
 975    We scan argv[*] looking for filenames or exactly "" which is
 976    shorthand for stdin. Any argv that is NULL is not a file-name.
 977    We set need_pass_2 TRUE if, after this, we still have unresolved
 978    expressions of the form (unknown value)+-(unknown value).
 979
 980    Note the un*x semantics: there is only 1 logical input file, but it
 981    may be a catenation of many 'physical' input files.  */
 982
 983 static void
 984 perform_an_assembly_pass (argc, argv)
 985      int argc;
 986      char **argv;
 987 {
 988   int saw_a_file = 0;
 989 #ifdef BFD_ASSEMBLER
 990   flagword applicable;
 991 #endif
 992
 993   need_pass_2 = 0;
 994
 995 #ifndef BFD_ASSEMBLER
 996 #ifdef MANY_SEGMENTS
 997   {
 998     unsigned int i;
 999     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1000       segment_info[i].fix_root = 0;
1001   }
1002   /* Create the three fixed ones.  */
1003   {
1004     segT seg;
1005
1006 #ifdef TE_APOLLO
1007     seg = subseg_new (".wtext", 0);
1008 #else
1009     seg = subseg_new (".text", 0);
1010 #endif
1011     assert (seg == SEG_E0);
1012     seg = subseg_new (".data", 0);
1013     assert (seg == SEG_E1);
1014     seg = subseg_new (".bss", 0);
1015     assert (seg == SEG_E2);
1016 #ifdef TE_APOLLO
1017     create_target_segments ();
1018 #endif
1019   }
1020
1021 #else /* not MANY_SEGMENTS */
1022   text_fix_root = NULL;
1023   data_fix_root = NULL;
1024   bss_fix_root = NULL;
1025 #endif /* not MANY_SEGMENTS */
1026 #else /* BFD_ASSEMBLER */
1027   /* Create the standard sections, and those the assembler uses
1028      internally.  */
1029   text_section = subseg_new (TEXT_SECTION_NAME, 0);
1030   data_section = subseg_new (DATA_SECTION_NAME, 0);
1031   bss_section = subseg_new (BSS_SECTION_NAME, 0);
1032   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1033      to have relocs, otherwise we don't find out in time.  */
1034   applicable = bfd_applicable_section_flags (stdoutput);
1035   bfd_set_section_flags (stdoutput, text_section,
1036                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1037                                        | SEC_CODE | SEC_READONLY));
1038   bfd_set_section_flags (stdoutput, data_section,
1039                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1040                                        | SEC_DATA));
1041   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1042   seg_info (bss_section)->bss = 1;
1043   subseg_new (BFD_ABS_SECTION_NAME, 0);
1044   subseg_new (BFD_UND_SECTION_NAME, 0);
1045   reg_section = subseg_new ("*GAS `reg' section*", 0);
1046   expr_section = subseg_new ("*GAS `expr' section*", 0);
1047
1048 #endif /* BFD_ASSEMBLER */
1049
1050   subseg_set (text_section, 0);
1051
1052   /* This may add symbol table entries, which requires having an open BFD,
1053      and sections already created, in BFD_ASSEMBLER mode.  */
1054   md_begin ();
1055
1056 #ifdef obj_begin
1057   obj_begin ();
1058 #endif
1059
1060   /* Skip argv[0].  */
1061   argv++;
1062   argc--;
1063
1064   while (argc--)
1065     {
1066       if (*argv)
1067         {                       /* Is it a file-name argument?  */
1068           PROGRESS (1);
1069           saw_a_file++;
1070           /* argv->"" if stdin desired, else->filename  */
1071           read_a_source_file (*argv);
1072         }
1073       argv++;                   /* completed that argv  */
1074     }
1075   if (!saw_a_file)
1076     read_a_source_file ("");
1077 }
1078
1079 /* The interface between the macro code and gas expression handling.  */
1080
1081 static int
1082 macro_expr (emsg, idx, in, val)
1083      const char *emsg;
1084      int idx;
1085      sb *in;
1086      int *val;
1087 {
1088   char *hold;
1089   expressionS ex;
1090
1091   sb_terminate (in);
1092
1093   hold = input_line_pointer;
1094   input_line_pointer = in->ptr + idx;
1095   expression (&ex);
1096   idx = input_line_pointer - in->ptr;
1097   input_line_pointer = hold;
1098
1099   if (ex.X_op != O_constant)
1100     as_bad ("%s", emsg);
1101
1102   *val = (int) ex.X_add_number;
1103
1104   return idx;
1105 }