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