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