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', 'f', '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     {"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
 456     /* When you add options here, check that they do not collide with
 457        OPTION_MD_BASE.  See as.h.  */
 458   };
 459
 460   /* Construct the option lists from the standard list and the target
 461      dependent list.  Include space for an extra NULL option and
 462      always NULL terminate.  */
 463   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 464   longopts = xmalloc (sizeof (std_longopts) + md_longopts_size + sizeof (struct option));
 465   memcpy (longopts, std_longopts, sizeof (std_longopts));
 466   memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
 467   memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
 468           0, sizeof (struct option));
 469
 470   /* Make a local copy of the old argv.  */
 471   old_argc = *pargc;
 472   old_argv = *pargv;
 473
 474   /* Initialize a new argv that contains no options.  */
 475   new_argv = xmalloc (sizeof (char *) * (old_argc + 1));
 476   new_argv[0] = old_argv[0];
 477   new_argc = 1;
 478   new_argv[new_argc] = NULL;
 479
 480   while (1)
 481     {
 482       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 483          indicate a long option.  */
 484       int longind;
 485       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 486                                    &longind);
 487
 488       if (optc == -1)
 489         break;
 490
 491       switch (optc)
 492         {
 493         default:
 494           /* md_parse_option should return 1 if it recognizes optc,
 495              0 if not.  */
 496           if (md_parse_option (optc, optarg) != 0)
 497             break;
 498           /* `-v' isn't included in the general short_opts list, so check for
 499              it explicity here before deciding we've gotten a bad argument.  */
 500           if (optc == 'v')
 501             {
 502 #ifdef VMS
 503               /* Telling getopt to treat -v's value as optional can result
 504                  in it picking up a following filename argument here.  The
 505                  VMS code in md_parse_option can return 0 in that case,
 506                  but it has no way of pushing the filename argument back.  */
 507               if (optarg && *optarg)
 508                 new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
 509               else
 510 #else
 511               case 'v':
 512 #endif
 513               case OPTION_VERBOSE:
 514                 print_version_id ();
 515                 verbose = 1;
 516               break;
 517             }
 518           /* Fall through.  */
 519
 520         case '?':
 521           exit (EXIT_FAILURE);
 522
 523         case 1:                 /* File name.  */
 524           if (!strcmp (optarg, "-"))
 525             optarg = "";
 526           new_argv[new_argc++] = optarg;
 527           new_argv[new_argc] = NULL;
 528           break;
 529
 530         case OPTION_TARGET_HELP:
 531           md_show_usage (stdout);
 532           exit (EXIT_SUCCESS);
 533
 534         case OPTION_HELP:
 535           show_usage (stdout);
 536           exit (EXIT_SUCCESS);
 537
 538         case OPTION_NOCPP:
 539           break;
 540
 541         case OPTION_STATISTICS:
 542           flag_print_statistics = 1;
 543           break;
 544
 545         case OPTION_STRIP_LOCAL_ABSOLUTE:
 546           flag_strip_local_absolute = 1;
 547           break;
 548
 549         case OPTION_TRADITIONAL_FORMAT:
 550           flag_traditional_format = 1;
 551           break;
 552
 553         case OPTION_VERSION:
 554           /* This output is intended to follow the GNU standards document.  */
 555 #ifdef BFD_ASSEMBLER
 556           printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
 557 #else
 558           printf (_("GNU assembler %s\n"), VERSION);
 559 #endif
 560           printf (_("Copyright 2002 Free Software Foundation, Inc.\n"));
 561           printf (_("\
 562 This program is free software; you may redistribute it under the terms of\n\
 563 the GNU General Public License.  This program has absolutely no warranty.\n"));
 564           printf (_("This assembler was configured for a target of `%s'.\n"),
 565                   TARGET_ALIAS);
 566           exit (EXIT_SUCCESS);
 567
 568         case OPTION_EMULATION:
 569 #ifdef USE_EMULATIONS
 570           if (strcmp (optarg, this_emulation->name))
 571             as_fatal (_("multiple emulation names specified"));
 572 #else
 573           as_fatal (_("emulations not handled in this configuration"));
 574 #endif
 575           break;
 576
 577         case OPTION_DUMPCONFIG:
 578           fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
 579           fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
 580           fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
 581 #ifdef TARGET_OBJ_FORMAT
 582           fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
 583 #endif
 584 #ifdef TARGET_FORMAT
 585           fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
 586 #endif
 587           exit (EXIT_SUCCESS);
 588
 589         case OPTION_DEFSYM:
 590           {
 591             char *s;
 592             valueT i;
 593             struct defsym_list *n;
 594
 595             for (s = optarg; *s != '\0' && *s != '='; s++)
 596               ;
 597             if (*s == '\0')
 598               as_fatal (_("bad defsym; format is --defsym name=value"));
 599             *s++ = '\0';
 600 #ifdef BFD_ASSEMBLER
 601             i = bfd_scan_vma (s, (const char **) NULL, 0);
 602 #else
 603             i = strtol (s, (char **) NULL, 0);
 604 #endif
 605             n = xmalloc (sizeof *n);
 606             n->next = defsyms;
 607             n->name = optarg;
 608             n->value = i;
 609             defsyms = n;
 610           }
 611           break;
 612
 613         case OPTION_INSTTBL:
 614         case 't':
 615           {
 616             /* optarg is the name of the file containing the instruction
 617                formats, opcodes, register names, etc.  */
 618             struct itbl_file_list *n;
 619
 620             if (optarg == NULL)
 621               {
 622                 as_warn (_("no file name following -t option"));
 623                 break;
 624               }
 625
 626             n = xmalloc (sizeof * n);
 627             n->next = itbl_files;
 628             n->name = optarg;
 629             itbl_files = n;
 630
 631             /* Parse the file and add the new instructions to our internal
 632                table.  If multiple instruction tables are specified, the
 633                information from this table gets appended onto the existing
 634                internal table.  */
 635             itbl_files->name = xstrdup (optarg);
 636             if (itbl_parse (itbl_files->name) != 0)
 637               as_fatal (_("failed to read instruction table %s\n"),
 638                         itbl_files->name);
 639           }
 640           break;
 641
 642         case OPTION_DEPFILE:
 643           start_dependencies (optarg);
 644           break;
 645
 646         case OPTION_GSTABS:
 647           debug_type = DEBUG_STABS;
 648           break;
 649
 650         case OPTION_GDWARF2:
 651           debug_type = DEBUG_DWARF2;
 652           break;
 653
 654         case 'J':
 655           flag_signed_overflow_ok = 1;
 656           break;
 657
 658 #ifndef WORKING_DOT_WORD
 659         case 'K':
 660           flag_warn_displacement = 1;
 661           break;
 662 #endif
 663         case 'L':
 664           flag_keep_locals = 1;
 665           break;
 666
 667         case OPTION_LISTING_LHS_WIDTH:
 668           listing_lhs_width = atoi (optarg);
 669           if (listing_lhs_width_second < listing_lhs_width)
 670             listing_lhs_width_second = listing_lhs_width;
 671           break;
 672         case OPTION_LISTING_LHS_WIDTH2:
 673           {
 674             int tmp = atoi (optarg);
 675             if (tmp > listing_lhs_width)
 676               listing_lhs_width_second = tmp;
 677           }
 678           break;
 679         case OPTION_LISTING_RHS_WIDTH:
 680           listing_rhs_width = atoi (optarg);
 681           break;
 682         case OPTION_LISTING_CONT_LINES:
 683           listing_lhs_cont_lines = atoi (optarg);
 684           break;
 685
 686         case 'M':
 687           flag_mri = 1;
 688 #ifdef TC_M68K
 689           flag_m68k_mri = 1;
 690 #endif
 691           break;
 692
 693         case 'R':
 694           flag_readonly_data_in_text = 1;
 695           break;
 696
 697         case 'W':
 698           flag_no_warnings = 1;
 699           break;
 700
 701         case OPTION_WARN:
 702           flag_no_warnings = 0;
 703           flag_fatal_warnings = 0;
 704           break;
 705
 706         case OPTION_WARN_FATAL:
 707           flag_no_warnings = 0;
 708           flag_fatal_warnings = 1;
 709           break;
 710
 711 #if defined BFD_ASSEMBLER && (defined OBJ_ELF || defined OBJ_MAYBE_ELF)
 712         case OPTION_EXECSTACK:
 713           flag_execstack = 1;
 714           flag_noexecstack = 0;
 715           break;
 716
 717         case OPTION_NOEXECSTACK:
 718           flag_noexecstack = 1;
 719           flag_execstack = 0;
 720           break;
 721 #endif
 722         case 'Z':
 723           flag_always_generate_output = 1;
 724           break;
 725
 726         case 'a':
 727           if (optarg)
 728             {
 729               if (md_parse_option (optc, optarg) != 0)
 730                 break;
 731
 732               while (*optarg)
 733                 {
 734                   switch (*optarg)
 735                     {
 736                     case 'c':
 737                       listing |= LISTING_NOCOND;
 738                       break;
 739                     case 'd':
 740                       listing |= LISTING_NODEBUG;
 741                       break;
 742                     case 'h':
 743                       listing |= LISTING_HLL;
 744                       break;
 745                     case 'l':
 746                       listing |= LISTING_LISTING;
 747                       break;
 748                     case 'm':
 749                       listing |= LISTING_MACEXP;
 750                       break;
 751                     case 'n':
 752                       listing |= LISTING_NOFORM;
 753                       break;
 754                     case 's':
 755                       listing |= LISTING_SYMBOLS;
 756                       break;
 757                     case '=':
 758                       listing_filename = xstrdup (optarg + 1);
 759                       optarg += strlen (listing_filename);
 760                       break;
 761                     default:
 762                       as_fatal (_("invalid listing option `%c'"), *optarg);
 763                       break;
 764                     }
 765                   optarg++;
 766                 }
 767             }
 768           if (!listing)
 769             listing = LISTING_DEFAULT;
 770           break;
 771
 772         case 'D':
 773           /* DEBUG is implemented: it debugs different
 774              things from other people's assemblers.  */
 775           flag_debug = 1;
 776           break;
 777
 778         case 'f':
 779           flag_no_comments = 1;
 780           break;
 781
 782         case 'I':
 783           {                     /* Include file directory.  */
 784             char *temp = xstrdup (optarg);
 785             add_include_dir (temp);
 786             break;
 787           }
 788
 789         case 'o':
 790           out_file_name = xstrdup (optarg);
 791           break;
 792
 793         case 'w':
 794           break;
 795
 796         case 'X':
 797           /* -X means treat warnings as errors.  */
 798           break;
 799         }
 800     }
 801
 802   free (shortopts);
 803   free (longopts);
 804
 805   *pargc = new_argc;
 806   *pargv = new_argv;
 807
 808 #ifdef md_after_parse_args
 809   md_after_parse_args ();
 810 #endif
 811 }
 812
 813 static void
 814 dump_statistics (void)
 815 {
 816 #ifdef HAVE_SBRK
 817   char *lim = (char *) sbrk (0);
 818 #endif
 819   long run_time = get_run_time () - start_time;
 820
 821   fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
 822            myname, run_time / 1000000, run_time % 1000000);
 823 #ifdef HAVE_SBRK
 824   fprintf (stderr, _("%s: data size %ld\n"),
 825            myname, (long) (lim - (char *) &environ));
 826 #endif
 827
 828   subsegs_print_statistics (stderr);
 829   write_print_statistics (stderr);
 830   symbol_print_statistics (stderr);
 831   read_print_statistics (stderr);
 832
 833 #ifdef tc_print_statistics
 834   tc_print_statistics (stderr);
 835 #endif
 836
 837 #ifdef obj_print_statistics
 838   obj_print_statistics (stderr);
 839 #endif
 840 }
 841
 842 /* The interface between the macro code and gas expression handling.  */
 843
 844 static int
 845 macro_expr (const char *emsg, int idx, sb *in, int *val)
 846 {
 847   char *hold;
 848   expressionS ex;
 849
 850   sb_terminate (in);
 851
 852   hold = input_line_pointer;
 853   input_line_pointer = in->ptr + idx;
 854   expression (&ex);
 855   idx = input_line_pointer - in->ptr;
 856   input_line_pointer = hold;
 857
 858   if (ex.X_op != O_constant)
 859     as_bad ("%s", emsg);
 860
 861   *val = (int) ex.X_add_number;
 862
 863   return idx;
 864 }
 865 \f
 866 /* Here to attempt 1 pass over each input file.
 867    We scan argv[*] looking for filenames or exactly "" which is
 868    shorthand for stdin. Any argv that is NULL is not a file-name.
 869    We set need_pass_2 TRUE if, after this, we still have unresolved
 870    expressions of the form (unknown value)+-(unknown value).
 871
 872    Note the un*x semantics: there is only 1 logical input file, but it
 873    may be a catenation of many 'physical' input files.  */
 874
 875 static void
 876 perform_an_assembly_pass (int argc, char ** argv)
 877 {
 878   int saw_a_file = 0;
 879 #ifdef BFD_ASSEMBLER
 880   flagword applicable;
 881 #endif
 882
 883   need_pass_2 = 0;
 884
 885 #ifndef BFD_ASSEMBLER
 886 #ifdef MANY_SEGMENTS
 887   {
 888     unsigned int i;
 889     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
 890       segment_info[i].fix_root = 0;
 891   }
 892   /* Create the three fixed ones.  */
 893   {
 894     segT seg;
 895
 896 #ifdef TE_APOLLO
 897     seg = subseg_new (".wtext", 0);
 898 #else
 899     seg = subseg_new (".text", 0);
 900 #endif
 901     assert (seg == SEG_E0);
 902     seg = subseg_new (".data", 0);
 903     assert (seg == SEG_E1);
 904     seg = subseg_new (".bss", 0);
 905     assert (seg == SEG_E2);
 906 #ifdef TE_APOLLO
 907     create_target_segments ();
 908 #endif
 909   }
 910
 911 #else /* not MANY_SEGMENTS.  */
 912   text_fix_root = NULL;
 913   data_fix_root = NULL;
 914   bss_fix_root = NULL;
 915 #endif /* not MANY_SEGMENTS.  */
 916 #else /* BFD_ASSEMBLER.  */
 917   /* Create the standard sections, and those the assembler uses
 918      internally.  */
 919   text_section = subseg_new (TEXT_SECTION_NAME, 0);
 920   data_section = subseg_new (DATA_SECTION_NAME, 0);
 921   bss_section = subseg_new (BSS_SECTION_NAME, 0);
 922   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
 923      to have relocs, otherwise we don't find out in time.  */
 924   applicable = bfd_applicable_section_flags (stdoutput);
 925   bfd_set_section_flags (stdoutput, text_section,
 926                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
 927                                        | SEC_CODE | SEC_READONLY));
 928   bfd_set_section_flags (stdoutput, data_section,
 929                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
 930                                        | SEC_DATA));
 931   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
 932   seg_info (bss_section)->bss = 1;
 933   subseg_new (BFD_ABS_SECTION_NAME, 0);
 934   subseg_new (BFD_UND_SECTION_NAME, 0);
 935   reg_section = subseg_new ("*GAS `reg' section*", 0);
 936   expr_section = subseg_new ("*GAS `expr' section*", 0);
 937
 938 #endif /* BFD_ASSEMBLER.  */
 939
 940   subseg_set (text_section, 0);
 941
 942   /* This may add symbol table entries, which requires having an open BFD,
 943      and sections already created, in BFD_ASSEMBLER mode.  */
 944   md_begin ();
 945
 946 #ifdef USING_CGEN
 947   gas_cgen_begin ();
 948 #endif
 949 #ifdef obj_begin
 950   obj_begin ();
 951 #endif
 952
 953   /* Skip argv[0].  */
 954   argv++;
 955   argc--;
 956
 957   while (argc--)
 958     {
 959       if (*argv)
 960         {                       /* Is it a file-name argument?  */
 961           PROGRESS (1);
 962           saw_a_file++;
 963           /* argv->"" if stdin desired, else->filename.  */
 964           read_a_source_file (*argv);
 965         }
 966       argv++;                   /* Completed that argv.  */
 967     }
 968   if (!saw_a_file)
 969     read_a_source_file ("");
 970 }
 971 \f
 972
 973 int
 974 main (int argc, char ** argv)
 975 {
 976   int macro_alternate;
 977   int macro_strip_at;
 978   int keep_it;
 979
 980   start_time = get_run_time ();
 981
 982 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 983   setlocale (LC_MESSAGES, "");
 984 #endif
 985 #if defined (HAVE_SETLOCALE)
 986   setlocale (LC_CTYPE, "");
 987 #endif
 988   bindtextdomain (PACKAGE, LOCALEDIR);
 989   textdomain (PACKAGE);
 990
 991   if (debug_memory)
 992     chunksize = 64;
 993
 994 #ifdef HOST_SPECIAL_INIT
 995   HOST_SPECIAL_INIT (argc, argv);
 996 #endif
 997
 998   myname = argv[0];
 999   xmalloc_set_program_name (myname);
1000
1001   START_PROGRESS (myname, 0);
1002
1003 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1004 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1005 #endif
1006
1007   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1008
1009   hex_init ();
1010 #ifdef BFD_ASSEMBLER
1011   bfd_init ();
1012   bfd_set_error_program_name (myname);
1013 #endif
1014
1015 #ifdef USE_EMULATIONS
1016   select_emulation_mode (argc, argv);
1017 #endif
1018
1019   PROGRESS (1);
1020   symbol_begin ();
1021   frag_init ();
1022   subsegs_begin ();
1023   parse_args (&argc, &argv);
1024   read_begin ();
1025   input_scrub_begin ();
1026   expr_begin ();
1027
1028   if (flag_print_statistics)
1029     xatexit (dump_statistics);
1030
1031   macro_alternate = 0;
1032   macro_strip_at = 0;
1033 #ifdef TC_I960
1034   macro_strip_at = flag_mri;
1035 #endif
1036 #ifdef TC_A29K
1037   /* For compatibility with the AMD 29K family macro assembler
1038      specification.  */
1039   macro_alternate = 1;
1040   macro_strip_at = 1;
1041 #endif
1042
1043   macro_init (macro_alternate, flag_mri, macro_strip_at, macro_expr);
1044
1045   PROGRESS (1);
1046
1047 #ifdef BFD_ASSEMBLER
1048   output_file_create (out_file_name);
1049   assert (stdoutput != 0);
1050 #endif
1051
1052 #ifdef tc_init_after_args
1053   tc_init_after_args ();
1054 #endif
1055
1056   itbl_init ();
1057
1058   /* Now that we have fully initialized, and have created the output
1059      file, define any symbols requested by --defsym command line
1060      arguments.  */
1061   while (defsyms != NULL)
1062     {
1063       symbolS *sym;
1064       struct defsym_list *next;
1065
1066       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
1067                         &zero_address_frag);
1068       symbol_table_insert (sym);
1069       next = defsyms->next;
1070       free (defsyms);
1071       defsyms = next;
1072     }
1073
1074   PROGRESS (1);
1075
1076   /* Assemble it.  */
1077   perform_an_assembly_pass (argc, argv);
1078
1079   cond_finish_check (-1);
1080
1081 #ifdef md_end
1082   md_end ();
1083 #endif
1084
1085 #if defined BFD_ASSEMBLER && (defined OBJ_ELF || defined OBJ_MAYBE_ELF)
1086   if ((flag_execstack || flag_noexecstack)
1087       && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1088     {
1089       segT gnustack;
1090
1091       gnustack = subseg_new (".note.GNU-stack", 0);
1092       bfd_set_section_flags (stdoutput, gnustack,
1093                              SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1094
1095     }
1096 #endif
1097
1098   /* If we've been collecting dwarf2 .debug_line info, either for
1099      assembly debugging or on behalf of the compiler, emit it now.  */
1100   dwarf2_finish ();
1101
1102   /* If we constructed dwarf2 .eh_frame info, either via .cfi
1103      directives from the user or by the backend, emit it now.  */
1104   cfi_finish ();
1105
1106   if (seen_at_least_1_file ()
1107       && (flag_always_generate_output || had_errors () == 0))
1108     keep_it = 1;
1109   else
1110     keep_it = 0;
1111
1112 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1113   /* This used to be done at the start of write_object_file in
1114      write.c, but that caused problems when doing listings when
1115      keep_it was zero.  This could probably be moved above md_end, but
1116      I didn't want to risk the change.  */
1117   subsegs_finish ();
1118 #endif
1119
1120   if (keep_it)
1121     write_object_file ();
1122
1123 #ifndef NO_LISTING
1124   listing_print (listing_filename);
1125 #endif
1126
1127 #ifndef OBJ_VMS /* Does its own file handling.  */
1128 #ifndef BFD_ASSEMBLER
1129   if (keep_it)
1130 #endif
1131     output_file_close (out_file_name);
1132 #endif
1133
1134   if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
1135     as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
1136
1137   if (had_errors () > 0 && ! flag_always_generate_output)
1138     keep_it = 0;
1139
1140   if (!keep_it)
1141     unlink (out_file_name);
1142
1143   input_scrub_end ();
1144
1145   END_PROGRESS (myname);
1146
1147   /* Use xexit instead of return, because under VMS environments they
1148      may not place the same interpretation on the value given.  */
1149   if (had_errors () > 0)
1150     xexit (EXIT_FAILURE);
1151
1152   /* Only generate dependency file if assembler was successful.  */
1153   print_dependencies ();
1154
1155   xexit (EXIT_SUCCESS);
1156 }
1157