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