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