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