gas/as.c

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