gas/as.c

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