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