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