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