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