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