gas/as.c

   1 /* as.c - GAS main program.
   2    Copyright 1987-2013 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 /* Main program for AS; a 32-bit assembler of GNU.
  22    Understands command arguments.
  23    Has a few routines that don't fit in other modules because they
  24    are shared.
  25
  26                         bugs
  27
  28    : initialisers
  29         Since no-one else says they will support them in future: I
  30    don't support them now.  */
  31
  32 #define COMMON
  33
  34 #include "as.h"
  35 #include "subsegs.h"
  36 #include "output-file.h"
  37 #include "sb.h"
  38 #include "macro.h"
  39 #include "dwarf2dbg.h"
  40 #include "dw2gencfi.h"
  41 #include "bfdver.h"
  42
  43 #ifdef HAVE_ITBL_CPU
  44 #include "itbl-ops.h"
  45 #else
  46 #define itbl_init()
  47 #endif
  48
  49 #ifdef HAVE_SBRK
  50 #ifdef NEED_DECLARATION_SBRK
  51 extern void *sbrk ();
  52 #endif
  53 #endif
  54
  55 #ifdef USING_CGEN
  56 /* Perform any cgen specific initialisation for gas.  */
  57 extern void gas_cgen_begin (void);
  58 #endif
  59
  60 /* We build a list of defsyms as we read the options, and then define
  61    them after we have initialized everything.  */
  62 struct defsym_list
  63 {
  64   struct defsym_list *next;
  65   char *name;
  66   valueT value;
  67 };
  68
  69
  70 /* True if a listing is wanted.  */
  71 int listing;
  72
  73 /* Type of debugging to generate.  */
  74 enum debug_info_type debug_type = DEBUG_UNSPECIFIED;
  75 int use_gnu_debug_info_extensions = 0;
  76
  77 #ifndef MD_DEBUG_FORMAT_SELECTOR
  78 #define MD_DEBUG_FORMAT_SELECTOR NULL
  79 #endif
  80 static enum debug_info_type (*md_debug_format_selector) (int *) = MD_DEBUG_FORMAT_SELECTOR;
  81
  82 /* Maximum level of macro nesting.  */
  83 int max_macro_nest = 100;
  84
  85 /* argv[0]  */
  86 static char * myname;
  87
  88 /* The default obstack chunk size.  If we set this to zero, the
  89    obstack code will use whatever will fit in a 4096 byte block.  */
  90 int chunksize = 0;
  91
  92 /* To monitor memory allocation more effectively, make this non-zero.
  93    Then the chunk sizes for gas and bfd will be reduced.  */
  94 int debug_memory = 0;
  95
  96 /* Enable verbose mode.  */
  97 int verbose = 0;
  98
  99 /* Keep the output file.  */
 100 int keep_it = 0;
 101
 102 segT reg_section;
 103 segT expr_section;
 104 segT text_section;
 105 segT data_section;
 106 segT bss_section;
 107
 108 /* Name of listing file.  */
 109 static char *listing_filename = NULL;
 110
 111 static struct defsym_list *defsyms;
 112
 113 #ifdef HAVE_ITBL_CPU
 114 /* Keep a record of the itbl files we read in.  */
 115 struct itbl_file_list
 116 {
 117   struct itbl_file_list *next;
 118   char *name;
 119 };
 120 static struct itbl_file_list *itbl_files;
 121 #endif
 122
 123 static long start_time;
 124 #ifdef HAVE_SBRK
 125 char *start_sbrk;
 126 #endif
 127
 128 static int flag_macro_alternate;
 129
 130 \f
 131 #ifdef USE_EMULATIONS
 132 #define EMULATION_ENVIRON "AS_EMULATION"
 133
 134 extern struct emulation mipsbelf, mipslelf, mipself;
 135 extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
 136 extern struct emulation i386coff, i386elf, i386aout;
 137 extern struct emulation crisaout, criself;
 138
 139 static struct emulation *const emulations[] = { EMULATIONS };
 140 static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
 141
 142 static void
 143 select_emulation_mode (int argc, char **argv)
 144 {
 145   int i;
 146   char *p, *em = 0;
 147
 148   for (i = 1; i < argc; i++)
 149     if (!strncmp ("--em", argv[i], 4))
 150       break;
 151
 152   if (i == argc)
 153     goto do_default;
 154
 155   p = strchr (argv[i], '=');
 156   if (p)
 157     p++;
 158   else
 159     p = argv[i + 1];
 160
 161   if (!p || !*p)
 162     as_fatal (_("missing emulation mode name"));
 163   em = p;
 164
 165  do_default:
 166   if (em == 0)
 167     em = getenv (EMULATION_ENVIRON);
 168   if (em == 0)
 169     em = DEFAULT_EMULATION;
 170
 171   if (em)
 172     {
 173       for (i = 0; i < n_emulations; i++)
 174         if (!strcmp (emulations[i]->name, em))
 175           break;
 176       if (i == n_emulations)
 177         as_fatal (_("unrecognized emulation name `%s'"), em);
 178       this_emulation = emulations[i];
 179     }
 180   else
 181     this_emulation = emulations[0];
 182
 183   this_emulation->init ();
 184 }
 185
 186 const char *
 187 default_emul_bfd_name (void)
 188 {
 189   abort ();
 190   return NULL;
 191 }
 192
 193 void
 194 common_emul_init (void)
 195 {
 196   this_format = this_emulation->format;
 197
 198   if (this_emulation->leading_underscore == 2)
 199     this_emulation->leading_underscore = this_format->dfl_leading_underscore;
 200
 201   if (this_emulation->default_endian != 2)
 202     target_big_endian = this_emulation->default_endian;
 203
 204   if (this_emulation->fake_label_name == 0)
 205     {
 206       if (this_emulation->leading_underscore)
 207         this_emulation->fake_label_name = "L0\001";
 208       else
 209         /* What other parameters should we test?  */
 210         this_emulation->fake_label_name = ".L0\001";
 211     }
 212 }
 213 #endif
 214
 215 void
 216 print_version_id (void)
 217 {
 218   static int printed;
 219
 220   if (printed)
 221     return;
 222   printed = 1;
 223
 224   fprintf (stderr, _("GNU assembler version %s (%s) using BFD version %s\n"),
 225            VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
 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                           g      include general info\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   --alternate             initially turn on alternate macro syntax\n"));
 249 #ifdef HAVE_ZLIB_H
 250   fprintf (stream, _("\
 251   --compress-debug-sections\n\
 252                           compress DWARF debug sections using zlib\n"));
 253   fprintf (stream, _("\
 254   --nocompress-debug-sections\n\
 255                           don't compress DWARF debug sections\n"));
 256 #endif /* HAVE_ZLIB_H */
 257   fprintf (stream, _("\
 258   -D                      produce assembler debugging messages\n"));
 259   fprintf (stream, _("\
 260   --debug-prefix-map OLD=NEW\n\
 261                           map OLD to NEW in debug information\n"));
 262   fprintf (stream, _("\
 263   --defsym SYM=VAL        define symbol SYM to given value\n"));
 264 #ifdef USE_EMULATIONS
 265   {
 266     int i;
 267     char *def_em;
 268
 269     fprintf (stream, "\
 270   --em=[");
 271     for (i = 0; i < n_emulations - 1; i++)
 272       fprintf (stream, "%s | ", emulations[i]->name);
 273     fprintf (stream, "%s]\n", emulations[i]->name);
 274
 275     def_em = getenv (EMULATION_ENVIRON);
 276     if (!def_em)
 277       def_em = DEFAULT_EMULATION;
 278     fprintf (stream, _("\
 279                           emulate output (default %s)\n"), def_em);
 280   }
 281 #endif
 282 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 283   fprintf (stream, _("\
 284   --execstack             require executable stack for this object\n"));
 285   fprintf (stream, _("\
 286   --noexecstack           don't require executable stack for this object\n"));
 287   fprintf (stream, _("\
 288   --size-check=[error|warning]\n\
 289                           ELF .size directive check (default --size-check=error)\n"));
 290 #endif
 291   fprintf (stream, _("\
 292   -f                      skip whitespace and comment preprocessing\n"));
 293   fprintf (stream, _("\
 294   -g --gen-debug          generate debugging information\n"));
 295   fprintf (stream, _("\
 296   --gstabs                generate STABS debugging information\n"));
 297   fprintf (stream, _("\
 298   --gstabs+               generate STABS debug info with GNU extensions\n"));
 299   fprintf (stream, _("\
 300   --gdwarf-2              generate DWARF2 debugging information\n"));
 301   fprintf (stream, _("\
 302   --gdwarf-sections       generate per-function section names for DWARF line information\n"));
 303   fprintf (stream, _("\
 304   --hash-size=<value>     set the hash table size close to <value>\n"));
 305   fprintf (stream, _("\
 306   --help                  show this message and exit\n"));
 307   fprintf (stream, _("\
 308   --target-help           show target specific options\n"));
 309   fprintf (stream, _("\
 310   -I DIR                  add DIR to search list for .include directives\n"));
 311   fprintf (stream, _("\
 312   -J                      don't warn about signed overflow\n"));
 313   fprintf (stream, _("\
 314   -K                      warn when differences altered for long displacements\n"));
 315   fprintf (stream, _("\
 316   -L,--keep-locals        keep local symbols (e.g. starting with `L')\n"));
 317   fprintf (stream, _("\
 318   -M,--mri                assemble in MRI compatibility mode\n"));
 319   fprintf (stream, _("\
 320   --MD FILE               write dependency information in FILE (default none)\n"));
 321   fprintf (stream, _("\
 322   -nocpp                  ignored\n"));
 323   fprintf (stream, _("\
 324   -o OBJFILE              name the object-file output OBJFILE (default a.out)\n"));
 325   fprintf (stream, _("\
 326   -R                      fold data section into text section\n"));
 327   fprintf (stream, _("\
 328   --reduce-memory-overheads \n\
 329                           prefer smaller memory use at the cost of longer\n\
 330                           assembly times\n"));
 331   fprintf (stream, _("\
 332   --statistics            print various measured statistics from execution\n"));
 333   fprintf (stream, _("\
 334   --strip-local-absolute  strip local absolute symbols\n"));
 335   fprintf (stream, _("\
 336   --traditional-format    Use same format as native assembler when possible\n"));
 337   fprintf (stream, _("\
 338   --version               print assembler version number and exit\n"));
 339   fprintf (stream, _("\
 340   -W  --no-warn           suppress warnings\n"));
 341   fprintf (stream, _("\
 342   --warn                  don't suppress warnings\n"));
 343   fprintf (stream, _("\
 344   --fatal-warnings        treat warnings as errors\n"));
 345 #ifdef HAVE_ITBL_CPU
 346   fprintf (stream, _("\
 347   --itbl INSTTBL          extend instruction set to include instructions\n\
 348                           matching the specifications defined in file INSTTBL\n"));
 349 #endif
 350   fprintf (stream, _("\
 351   -w                      ignored\n"));
 352   fprintf (stream, _("\
 353   -X                      ignored\n"));
 354   fprintf (stream, _("\
 355   -Z                      generate object file even after errors\n"));
 356   fprintf (stream, _("\
 357   --listing-lhs-width     set the width in words of the output data column of\n\
 358                           the listing\n"));
 359   fprintf (stream, _("\
 360   --listing-lhs-width2    set the width in words of the continuation lines\n\
 361                           of the output data column; ignored if smaller than\n\
 362                           the width of the first line\n"));
 363   fprintf (stream, _("\
 364   --listing-rhs-width     set the max width in characters of the lines from\n\
 365                           the source file\n"));
 366   fprintf (stream, _("\
 367   --listing-cont-lines    set the maximum number of continuation lines used\n\
 368                           for the output data column of the listing\n"));
 369   fprintf (stream, _("\
 370   @FILE                   read options from FILE\n"));
 371
 372   md_show_usage (stream);
 373
 374   fputc ('\n', stream);
 375
 376   if (REPORT_BUGS_TO[0] && stream == stdout)
 377     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 378 }
 379
 380 /* Since it is easy to do here we interpret the special arg "-"
 381    to mean "use stdin" and we set that argv[] pointing to "".
 382    After we have munged argv[], the only things left are source file
 383    name(s) and ""(s) denoting stdin. These file names are used
 384    (perhaps more than once) later.
 385
 386    check for new machine-dep cmdline options in
 387    md_parse_option definitions in config/tc-*.c.  */
 388
 389 static void
 390 parse_args (int * pargc, char *** pargv)
 391 {
 392   int old_argc;
 393   int new_argc;
 394   char ** old_argv;
 395   char ** new_argv;
 396   /* Starting the short option string with '-' is for programs that
 397      expect options and other ARGV-elements in any order and that care about
 398      the ordering of the two.  We describe each non-option ARGV-element
 399      as if it were the argument of an option with character code 1.  */
 400   char *shortopts;
 401   extern const char *md_shortopts;
 402   static const char std_shortopts[] =
 403   {
 404     '-', 'J',
 405 #ifndef WORKING_DOT_WORD
 406     /* -K is not meaningful if .word is not being hacked.  */
 407     'K',
 408 #endif
 409     'L', 'M', 'R', 'W', 'Z', 'a', ':', ':', 'D', 'f', 'g', ':',':', 'I', ':', 'o', ':',
 410 #ifndef VMS
 411     /* -v takes an argument on VMS, so we don't make it a generic
 412        option.  */
 413     'v',
 414 #endif
 415     'w', 'X',
 416 #ifdef HAVE_ITBL_CPU
 417     /* New option for extending instruction set (see also --itbl below).  */
 418     't', ':',
 419 #endif
 420     '\0'
 421   };
 422   struct option *longopts;
 423   extern struct option md_longopts[];
 424   extern size_t md_longopts_size;
 425   /* Codes used for the long options with no short synonyms.  */
 426   enum option_values
 427     {
 428       OPTION_HELP = OPTION_STD_BASE,
 429       OPTION_NOCPP,
 430       OPTION_STATISTICS,
 431       OPTION_VERSION,
 432       OPTION_DUMPCONFIG,
 433       OPTION_VERBOSE,
 434       OPTION_EMULATION,
 435       OPTION_DEBUG_PREFIX_MAP,
 436       OPTION_DEFSYM,
 437       OPTION_LISTING_LHS_WIDTH,
 438       OPTION_LISTING_LHS_WIDTH2,
 439       OPTION_LISTING_RHS_WIDTH,
 440       OPTION_LISTING_CONT_LINES,
 441       OPTION_DEPFILE,
 442       OPTION_GSTABS,
 443       OPTION_GSTABS_PLUS,
 444       OPTION_GDWARF2,
 445       OPTION_GDWARF_SECTIONS,
 446       OPTION_STRIP_LOCAL_ABSOLUTE,
 447       OPTION_TRADITIONAL_FORMAT,
 448       OPTION_WARN,
 449       OPTION_TARGET_HELP,
 450       OPTION_EXECSTACK,
 451       OPTION_NOEXECSTACK,
 452       OPTION_SIZE_CHECK,
 453       OPTION_ALTERNATE,
 454       OPTION_AL,
 455       OPTION_HASH_TABLE_SIZE,
 456       OPTION_REDUCE_MEMORY_OVERHEADS,
 457       OPTION_WARN_FATAL,
 458       OPTION_COMPRESS_DEBUG,
 459       OPTION_NOCOMPRESS_DEBUG
 460     /* When you add options here, check that they do
 461        not collide with OPTION_MD_BASE.  See as.h.  */
 462     };
 463
 464   static const struct option std_longopts[] =
 465   {
 466     /* Note: commas are placed at the start of the line rather than
 467        the end of the preceding line so that it is simpler to
 468        selectively add and remove lines from this list.  */
 469     {"alternate", no_argument, NULL, OPTION_ALTERNATE}
 470     /* The entry for "a" is here to prevent getopt_long_only() from
 471        considering that -a is an abbreviation for --alternate.  This is
 472        necessary because -a=<FILE> is a valid switch but getopt would
 473        normally reject it since --alternate does not take an argument.  */
 474     ,{"a", optional_argument, NULL, 'a'}
 475     /* Handle -al=<FILE>.  */
 476     ,{"al", optional_argument, NULL, OPTION_AL}
 477     ,{"compress-debug-sections", no_argument, NULL, OPTION_COMPRESS_DEBUG}
 478     ,{"nocompress-debug-sections", no_argument, NULL, OPTION_NOCOMPRESS_DEBUG}
 479     ,{"debug-prefix-map", required_argument, NULL, OPTION_DEBUG_PREFIX_MAP}
 480     ,{"defsym", required_argument, NULL, OPTION_DEFSYM}
 481     ,{"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}
 482     ,{"emulation", required_argument, NULL, OPTION_EMULATION}
 483 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 484     ,{"execstack", no_argument, NULL, OPTION_EXECSTACK}
 485     ,{"noexecstack", no_argument, NULL, OPTION_NOEXECSTACK}
 486     ,{"size-check", required_argument, NULL, OPTION_SIZE_CHECK}
 487 #endif
 488     ,{"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
 489     ,{"gdwarf-2", no_argument, NULL, OPTION_GDWARF2}
 490     /* GCC uses --gdwarf-2 but GAS uses to use --gdwarf2,
 491        so we keep it here for backwards compatibility.  */
 492     ,{"gdwarf2", no_argument, NULL, OPTION_GDWARF2}
 493     ,{"gdwarf-sections", no_argument, NULL, OPTION_GDWARF_SECTIONS}
 494     ,{"gen-debug", no_argument, NULL, 'g'}
 495     ,{"gstabs", no_argument, NULL, OPTION_GSTABS}
 496     ,{"gstabs+", no_argument, NULL, OPTION_GSTABS_PLUS}
 497     ,{"hash-size", required_argument, NULL, OPTION_HASH_TABLE_SIZE}
 498     ,{"help", no_argument, NULL, OPTION_HELP}
 499 #ifdef HAVE_ITBL_CPU
 500     /* New option for extending instruction set (see also -t above).
 501        The "-t file" or "--itbl file" option extends the basic set of
 502        valid instructions by reading "file", a text file containing a
 503        list of instruction formats.  The additional opcodes and their
 504        formats are added to the built-in set of instructions, and
 505        mnemonics for new registers may also be defined.  */
 506     ,{"itbl", required_argument, NULL, 't'}
 507 #endif
 508     /* getopt allows abbreviations, so we do this to stop it from
 509        treating -k as an abbreviation for --keep-locals.  Some
 510        ports use -k to enable PIC assembly.  */
 511     ,{"keep-locals", no_argument, NULL, 'L'}
 512     ,{"keep-locals", no_argument, NULL, 'L'}
 513     ,{"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}
 514     ,{"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}
 515     ,{"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}
 516     ,{"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}
 517     ,{"MD", required_argument, NULL, OPTION_DEPFILE}
 518     ,{"mri", no_argument, NULL, 'M'}
 519     ,{"nocpp", no_argument, NULL, OPTION_NOCPP}
 520     ,{"no-warn", no_argument, NULL, 'W'}
 521     ,{"reduce-memory-overheads", no_argument, NULL, OPTION_REDUCE_MEMORY_OVERHEADS}
 522     ,{"statistics", no_argument, NULL, OPTION_STATISTICS}
 523     ,{"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}
 524     ,{"version", no_argument, NULL, OPTION_VERSION}
 525     ,{"verbose", no_argument, NULL, OPTION_VERBOSE}
 526     ,{"target-help", no_argument, NULL, OPTION_TARGET_HELP}
 527     ,{"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
 528     ,{"warn", no_argument, NULL, OPTION_WARN}
 529   };
 530
 531   /* Construct the option lists from the standard list and the target
 532      dependent list.  Include space for an extra NULL option and
 533      always NULL terminate.  */
 534   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 535   longopts = (struct option *) xmalloc (sizeof (std_longopts)
 536                                         + md_longopts_size + sizeof (struct option));
 537   memcpy (longopts, std_longopts, sizeof (std_longopts));
 538   memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
 539   memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
 540           0, sizeof (struct option));
 541
 542   /* Make a local copy of the old argv.  */
 543   old_argc = *pargc;
 544   old_argv = *pargv;
 545
 546   /* Initialize a new argv that contains no options.  */
 547   new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
 548   new_argv[0] = old_argv[0];
 549   new_argc = 1;
 550   new_argv[new_argc] = NULL;
 551
 552   while (1)
 553     {
 554       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 555          indicate a long option.  */
 556       int longind;
 557       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 558                                    &longind);
 559
 560       if (optc == -1)
 561         break;
 562
 563       switch (optc)
 564         {
 565         default:
 566           /* md_parse_option should return 1 if it recognizes optc,
 567              0 if not.  */
 568           if (md_parse_option (optc, optarg) != 0)
 569             break;
 570           /* `-v' isn't included in the general short_opts list, so check for
 571              it explicitly here before deciding we've gotten a bad argument.  */
 572           if (optc == 'v')
 573             {
 574 #ifdef VMS
 575               /* Telling getopt to treat -v's value as optional can result
 576                  in it picking up a following filename argument here.  The
 577                  VMS code in md_parse_option can return 0 in that case,
 578                  but it has no way of pushing the filename argument back.  */
 579               if (optarg && *optarg)
 580                 new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
 581               else
 582 #else
 583               case 'v':
 584 #endif
 585               case OPTION_VERBOSE:
 586                 print_version_id ();
 587                 verbose = 1;
 588               break;
 589             }
 590           else
 591             as_bad (_("unrecognized option -%c%s"), optc, optarg ? optarg : "");
 592           /* Fall through.  */
 593
 594         case '?':
 595           exit (EXIT_FAILURE);
 596
 597         case 1:                 /* File name.  */
 598           if (!strcmp (optarg, "-"))
 599             optarg = "";
 600           new_argv[new_argc++] = optarg;
 601           new_argv[new_argc] = NULL;
 602           break;
 603
 604         case OPTION_TARGET_HELP:
 605           md_show_usage (stdout);
 606           exit (EXIT_SUCCESS);
 607
 608         case OPTION_HELP:
 609           show_usage (stdout);
 610           exit (EXIT_SUCCESS);
 611
 612         case OPTION_NOCPP:
 613           break;
 614
 615         case OPTION_STATISTICS:
 616           flag_print_statistics = 1;
 617           break;
 618
 619         case OPTION_STRIP_LOCAL_ABSOLUTE:
 620           flag_strip_local_absolute = 1;
 621           break;
 622
 623         case OPTION_TRADITIONAL_FORMAT:
 624           flag_traditional_format = 1;
 625           break;
 626
 627         case OPTION_VERSION:
 628           /* This output is intended to follow the GNU standards document.  */
 629           printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
 630           printf (_("Copyright 2013 Free Software Foundation, Inc.\n"));
 631           printf (_("\
 632 This program is free software; you may redistribute it under the terms of\n\
 633 the GNU General Public License version 3 or later.\n\
 634 This program has absolutely no warranty.\n"));
 635           printf (_("This assembler was configured for a target of `%s'.\n"),
 636                   TARGET_ALIAS);
 637           exit (EXIT_SUCCESS);
 638
 639         case OPTION_EMULATION:
 640 #ifdef USE_EMULATIONS
 641           if (strcmp (optarg, this_emulation->name))
 642             as_fatal (_("multiple emulation names specified"));
 643 #else
 644           as_fatal (_("emulations not handled in this configuration"));
 645 #endif
 646           break;
 647
 648         case OPTION_DUMPCONFIG:
 649           fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
 650           fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
 651           fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
 652 #ifdef TARGET_OBJ_FORMAT
 653           fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
 654 #endif
 655 #ifdef TARGET_FORMAT
 656           fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
 657 #endif
 658           exit (EXIT_SUCCESS);
 659
 660         case OPTION_COMPRESS_DEBUG:
 661 #ifdef HAVE_ZLIB_H
 662           flag_compress_debug = 1;
 663 #else
 664           as_warn (_("cannot compress debug sections (zlib not installed)"));
 665 #endif /* HAVE_ZLIB_H */
 666           break;
 667
 668         case OPTION_NOCOMPRESS_DEBUG:
 669           flag_compress_debug = 0;
 670           break;
 671
 672         case OPTION_DEBUG_PREFIX_MAP:
 673           add_debug_prefix_map (optarg);
 674           break;
 675
 676         case OPTION_DEFSYM:
 677           {
 678             char *s;
 679             valueT i;
 680             struct defsym_list *n;
 681
 682             for (s = optarg; *s != '\0' && *s != '='; s++)
 683               ;
 684             if (*s == '\0')
 685               as_fatal (_("bad defsym; format is --defsym name=value"));
 686             *s++ = '\0';
 687             i = bfd_scan_vma (s, (const char **) NULL, 0);
 688             n = (struct defsym_list *) xmalloc (sizeof *n);
 689             n->next = defsyms;
 690             n->name = optarg;
 691             n->value = i;
 692             defsyms = n;
 693           }
 694           break;
 695
 696 #ifdef HAVE_ITBL_CPU
 697         case 't':
 698           {
 699             /* optarg is the name of the file containing the instruction
 700                formats, opcodes, register names, etc.  */
 701             struct itbl_file_list *n;
 702
 703             if (optarg == NULL)
 704               {
 705                 as_warn (_("no file name following -t option"));
 706                 break;
 707               }
 708
 709             n = xmalloc (sizeof * n);
 710             n->next = itbl_files;
 711             n->name = optarg;
 712             itbl_files = n;
 713
 714             /* Parse the file and add the new instructions to our internal
 715                table.  If multiple instruction tables are specified, the
 716                information from this table gets appended onto the existing
 717                internal table.  */
 718             itbl_files->name = xstrdup (optarg);
 719             if (itbl_parse (itbl_files->name) != 0)
 720               as_fatal (_("failed to read instruction table %s\n"),
 721                         itbl_files->name);
 722           }
 723           break;
 724 #endif
 725
 726         case OPTION_DEPFILE:
 727           start_dependencies (optarg);
 728           break;
 729
 730         case 'g':
 731           /* Some backends, eg Alpha and Mips, use the -g switch for their
 732              own purposes.  So we check here for an explicit -g and allow
 733              the backend to decide if it wants to process it.  */
 734           if (   old_argv[optind - 1][1] == 'g'
 735               && md_parse_option (optc, optarg))
 736             continue;
 737
 738           if (md_debug_format_selector)
 739             debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
 740           else if (IS_ELF)
 741             debug_type = DEBUG_DWARF2;
 742           else
 743             debug_type = DEBUG_STABS;
 744           break;
 745
 746         case OPTION_GSTABS_PLUS:
 747           use_gnu_debug_info_extensions = 1;
 748           /* Fall through.  */
 749         case OPTION_GSTABS:
 750           debug_type = DEBUG_STABS;
 751           break;
 752
 753         case OPTION_GDWARF2:
 754           debug_type = DEBUG_DWARF2;
 755           break;
 756
 757         case OPTION_GDWARF_SECTIONS:
 758           flag_dwarf_sections = TRUE;
 759           break;
 760
 761         case 'J':
 762           flag_signed_overflow_ok = 1;
 763           break;
 764
 765 #ifndef WORKING_DOT_WORD
 766         case 'K':
 767           flag_warn_displacement = 1;
 768           break;
 769 #endif
 770         case 'L':
 771           flag_keep_locals = 1;
 772           break;
 773
 774         case OPTION_LISTING_LHS_WIDTH:
 775           listing_lhs_width = atoi (optarg);
 776           if (listing_lhs_width_second < listing_lhs_width)
 777             listing_lhs_width_second = listing_lhs_width;
 778           break;
 779         case OPTION_LISTING_LHS_WIDTH2:
 780           {
 781             int tmp = atoi (optarg);
 782
 783             if (tmp > listing_lhs_width)
 784               listing_lhs_width_second = tmp;
 785           }
 786           break;
 787         case OPTION_LISTING_RHS_WIDTH:
 788           listing_rhs_width = atoi (optarg);
 789           break;
 790         case OPTION_LISTING_CONT_LINES:
 791           listing_lhs_cont_lines = atoi (optarg);
 792           break;
 793
 794         case 'M':
 795           flag_mri = 1;
 796 #ifdef TC_M68K
 797           flag_m68k_mri = 1;
 798 #endif
 799           break;
 800
 801         case 'R':
 802           flag_readonly_data_in_text = 1;
 803           break;
 804
 805         case 'W':
 806           flag_no_warnings = 1;
 807           break;
 808
 809         case OPTION_WARN:
 810           flag_no_warnings = 0;
 811           flag_fatal_warnings = 0;
 812           break;
 813
 814         case OPTION_WARN_FATAL:
 815           flag_no_warnings = 0;
 816           flag_fatal_warnings = 1;
 817           break;
 818
 819 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
 820         case OPTION_EXECSTACK:
 821           flag_execstack = 1;
 822           flag_noexecstack = 0;
 823           break;
 824
 825         case OPTION_NOEXECSTACK:
 826           flag_noexecstack = 1;
 827           flag_execstack = 0;
 828           break;
 829
 830         case OPTION_SIZE_CHECK:
 831           if (strcasecmp (optarg, "error") == 0)
 832             flag_size_check = size_check_error;
 833           else if (strcasecmp (optarg, "warning") == 0)
 834             flag_size_check = size_check_warning;
 835           else
 836             as_fatal (_("Invalid --size-check= option: `%s'"), optarg);
 837           break;
 838 #endif
 839         case 'Z':
 840           flag_always_generate_output = 1;
 841           break;
 842
 843         case OPTION_AL:
 844           listing |= LISTING_LISTING;
 845           if (optarg)
 846             listing_filename = xstrdup (optarg);
 847           break;
 848
 849         case OPTION_ALTERNATE:
 850           optarg = old_argv [optind - 1];
 851           while (* optarg == '-')
 852             optarg ++;
 853
 854           if (strcmp (optarg, "alternate") == 0)
 855             {
 856               flag_macro_alternate = 1;
 857               break;
 858             }
 859           optarg ++;
 860           /* Fall through.  */
 861
 862         case 'a':
 863           if (optarg)
 864             {
 865               if (optarg != old_argv[optind] && optarg[-1] == '=')
 866                 --optarg;
 867
 868               if (md_parse_option (optc, optarg) != 0)
 869                 break;
 870
 871               while (*optarg)
 872                 {
 873                   switch (*optarg)
 874                     {
 875                     case 'c':
 876                       listing |= LISTING_NOCOND;
 877                       break;
 878                     case 'd':
 879                       listing |= LISTING_NODEBUG;
 880                       break;
 881                     case 'g':
 882                       listing |= LISTING_GENERAL;
 883                       break;
 884                     case 'h':
 885                       listing |= LISTING_HLL;
 886                       break;
 887                     case 'l':
 888                       listing |= LISTING_LISTING;
 889                       break;
 890                     case 'm':
 891                       listing |= LISTING_MACEXP;
 892                       break;
 893                     case 'n':
 894                       listing |= LISTING_NOFORM;
 895                       break;
 896                     case 's':
 897                       listing |= LISTING_SYMBOLS;
 898                       break;
 899                     case '=':
 900                       listing_filename = xstrdup (optarg + 1);
 901                       optarg += strlen (listing_filename);
 902                       break;
 903                     default:
 904                       as_fatal (_("invalid listing option `%c'"), *optarg);
 905                       break;
 906                     }
 907                   optarg++;
 908                 }
 909             }
 910           if (!listing)
 911             listing = LISTING_DEFAULT;
 912           break;
 913
 914         case 'D':
 915           /* DEBUG is implemented: it debugs different
 916              things from other people's assemblers.  */
 917           flag_debug = 1;
 918           break;
 919
 920         case 'f':
 921           flag_no_comments = 1;
 922           break;
 923
 924         case 'I':
 925           {                     /* Include file directory.  */
 926             char *temp = xstrdup (optarg);
 927
 928             add_include_dir (temp);
 929             break;
 930           }
 931
 932         case 'o':
 933           out_file_name = xstrdup (optarg);
 934           break;
 935
 936         case 'w':
 937           break;
 938
 939         case 'X':
 940           /* -X means treat warnings as errors.  */
 941           break;
 942
 943         case OPTION_REDUCE_MEMORY_OVERHEADS:
 944           /* The only change we make at the moment is to reduce
 945              the size of the hash tables that we use.  */
 946           set_gas_hash_table_size (4051);
 947           break;
 948
 949         case OPTION_HASH_TABLE_SIZE:
 950           {
 951             unsigned long new_size;
 952
 953             new_size = strtoul (optarg, NULL, 0);
 954             if (new_size)
 955               set_gas_hash_table_size (new_size);
 956             else
 957               as_fatal (_("--hash-size needs a numeric argument"));
 958             break;
 959           }
 960         }
 961     }
 962
 963   free (shortopts);
 964   free (longopts);
 965
 966   *pargc = new_argc;
 967   *pargv = new_argv;
 968
 969 #ifdef md_after_parse_args
 970   md_after_parse_args ();
 971 #endif
 972 }
 973
 974 static void
 975 dump_statistics (void)
 976 {
 977 #ifdef HAVE_SBRK
 978   char *lim = (char *) sbrk (0);
 979 #endif
 980   long run_time = get_run_time () - start_time;
 981
 982   fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
 983            myname, run_time / 1000000, run_time % 1000000);
 984 #ifdef HAVE_SBRK
 985   fprintf (stderr, _("%s: data size %ld\n"),
 986            myname, (long) (lim - start_sbrk));
 987 #endif
 988
 989   subsegs_print_statistics (stderr);
 990   write_print_statistics (stderr);
 991   symbol_print_statistics (stderr);
 992   read_print_statistics (stderr);
 993
 994 #ifdef tc_print_statistics
 995   tc_print_statistics (stderr);
 996 #endif
 997
 998 #ifdef obj_print_statistics
 999   obj_print_statistics (stderr);
1000 #endif
1001 }
1002
1003 static void
1004 close_output_file (void)
1005 {
1006   output_file_close (out_file_name);
1007   if (!keep_it)
1008     unlink_if_ordinary (out_file_name);
1009 }
1010
1011 /* The interface between the macro code and gas expression handling.  */
1012
1013 static size_t
1014 macro_expr (const char *emsg, size_t idx, sb *in, offsetT *val)
1015 {
1016   char *hold;
1017   expressionS ex;
1018
1019   sb_terminate (in);
1020
1021   hold = input_line_pointer;
1022   input_line_pointer = in->ptr + idx;
1023   expression_and_evaluate (&ex);
1024   idx = input_line_pointer - in->ptr;
1025   input_line_pointer = hold;
1026
1027   if (ex.X_op != O_constant)
1028     as_bad ("%s", emsg);
1029
1030   *val = ex.X_add_number;
1031
1032   return idx;
1033 }
1034 \f
1035 /* Here to attempt 1 pass over each input file.
1036    We scan argv[*] looking for filenames or exactly "" which is
1037    shorthand for stdin. Any argv that is NULL is not a file-name.
1038    We set need_pass_2 TRUE if, after this, we still have unresolved
1039    expressions of the form (unknown value)+-(unknown value).
1040
1041    Note the un*x semantics: there is only 1 logical input file, but it
1042    may be a catenation of many 'physical' input files.  */
1043
1044 static void
1045 perform_an_assembly_pass (int argc, char ** argv)
1046 {
1047   int saw_a_file = 0;
1048 #ifndef OBJ_MACH_O
1049   flagword applicable;
1050 #endif
1051
1052   need_pass_2 = 0;
1053
1054 #ifndef OBJ_MACH_O
1055   /* Create the standard sections, and those the assembler uses
1056      internally.  */
1057   text_section = subseg_new (TEXT_SECTION_NAME, 0);
1058   data_section = subseg_new (DATA_SECTION_NAME, 0);
1059   bss_section = subseg_new (BSS_SECTION_NAME, 0);
1060   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1061      to have relocs, otherwise we don't find out in time.  */
1062   applicable = bfd_applicable_section_flags (stdoutput);
1063   bfd_set_section_flags (stdoutput, text_section,
1064                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1065                                        | SEC_CODE | SEC_READONLY));
1066   bfd_set_section_flags (stdoutput, data_section,
1067                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1068                                        | SEC_DATA));
1069   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
1070   seg_info (bss_section)->bss = 1;
1071 #endif
1072   subseg_new (BFD_ABS_SECTION_NAME, 0);
1073   subseg_new (BFD_UND_SECTION_NAME, 0);
1074   reg_section = subseg_new ("*GAS `reg' section*", 0);
1075   expr_section = subseg_new ("*GAS `expr' section*", 0);
1076
1077 #ifndef OBJ_MACH_O
1078   subseg_set (text_section, 0);
1079 #endif
1080
1081   /* This may add symbol table entries, which requires having an open BFD,
1082      and sections already created.  */
1083   md_begin ();
1084
1085 #ifdef USING_CGEN
1086   gas_cgen_begin ();
1087 #endif
1088 #ifdef obj_begin
1089   obj_begin ();
1090 #endif
1091
1092   /* Skip argv[0].  */
1093   argv++;
1094   argc--;
1095
1096   while (argc--)
1097     {
1098       if (*argv)
1099         {                       /* Is it a file-name argument?  */
1100           PROGRESS (1);
1101           saw_a_file++;
1102           /* argv->"" if stdin desired, else->filename.  */
1103           read_a_source_file (*argv);
1104         }
1105       argv++;                   /* Completed that argv.  */
1106     }
1107   if (!saw_a_file)
1108     read_a_source_file ("");
1109 }
1110 \f
1111 #ifdef OBJ_ELF
1112 static void
1113 create_obj_attrs_section (void)
1114 {
1115   segT s;
1116   char *p;
1117   offsetT size;
1118   const char *name;
1119
1120   size = bfd_elf_obj_attr_size (stdoutput);
1121   if (size)
1122     {
1123       name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1124       if (!name)
1125         name = ".gnu.attributes";
1126       s = subseg_new (name, 0);
1127       elf_section_type (s)
1128         = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1129       bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1130       frag_now_fix ();
1131       p = frag_more (size);
1132       bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1133     }
1134 }
1135 #endif
1136 \f
1137
1138 int
1139 main (int argc, char ** argv)
1140 {
1141   char ** argv_orig = argv;
1142
1143   int macro_strip_at;
1144
1145   start_time = get_run_time ();
1146 #ifdef HAVE_SBRK
1147   start_sbrk = (char *) sbrk (0);
1148 #endif
1149
1150 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1151   setlocale (LC_MESSAGES, "");
1152 #endif
1153 #if defined (HAVE_SETLOCALE)
1154   setlocale (LC_CTYPE, "");
1155 #endif
1156   bindtextdomain (PACKAGE, LOCALEDIR);
1157   textdomain (PACKAGE);
1158
1159   if (debug_memory)
1160     chunksize = 64;
1161
1162 #ifdef HOST_SPECIAL_INIT
1163   HOST_SPECIAL_INIT (argc, argv);
1164 #endif
1165
1166   myname = argv[0];
1167   xmalloc_set_program_name (myname);
1168
1169   expandargv (&argc, &argv);
1170
1171   START_PROGRESS (myname, 0);
1172
1173 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1174 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1175 #endif
1176
1177   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1178
1179   hex_init ();
1180   bfd_init ();
1181   bfd_set_error_program_name (myname);
1182
1183 #ifdef USE_EMULATIONS
1184   select_emulation_mode (argc, argv);
1185 #endif
1186
1187   PROGRESS (1);
1188   /* Call parse_args before any of the init/begin functions
1189      so that switches like --hash-size can be honored.  */
1190   parse_args (&argc, &argv);
1191   symbol_begin ();
1192   frag_init ();
1193   subsegs_begin ();
1194   read_begin ();
1195   input_scrub_begin ();
1196   expr_begin ();
1197
1198   /* It has to be called after dump_statistics ().  */
1199   xatexit (close_output_file);
1200
1201   if (flag_print_statistics)
1202     xatexit (dump_statistics);
1203
1204   macro_strip_at = 0;
1205 #ifdef TC_I960
1206   macro_strip_at = flag_mri;
1207 #endif
1208
1209   macro_init (flag_macro_alternate, flag_mri, macro_strip_at, macro_expr);
1210
1211   PROGRESS (1);
1212
1213   output_file_create (out_file_name);
1214   gas_assert (stdoutput != 0);
1215
1216   dot_symbol_init ();
1217
1218 #ifdef tc_init_after_args
1219   tc_init_after_args ();
1220 #endif
1221
1222   itbl_init ();
1223
1224   dwarf2_init ();
1225
1226   local_symbol_make (".gasversion.", absolute_section,
1227                      BFD_VERSION / 10000UL, &predefined_address_frag);
1228
1229   /* Now that we have fully initialized, and have created the output
1230      file, define any symbols requested by --defsym command line
1231      arguments.  */
1232   while (defsyms != NULL)
1233     {
1234       symbolS *sym;
1235       struct defsym_list *next;
1236
1237       sym = symbol_new (defsyms->name, absolute_section, defsyms->value,
1238                         &zero_address_frag);
1239       /* Make symbols defined on the command line volatile, so that they
1240          can be redefined inside a source file.  This makes this assembler's
1241          behaviour compatible with earlier versions, but it may not be
1242          completely intuitive.  */
1243       S_SET_VOLATILE (sym);
1244       symbol_table_insert (sym);
1245       next = defsyms->next;
1246       free (defsyms);
1247       defsyms = next;
1248     }
1249
1250   PROGRESS (1);
1251
1252   /* Assemble it.  */
1253   perform_an_assembly_pass (argc, argv);
1254
1255   cond_finish_check (-1);
1256
1257 #ifdef md_end
1258   md_end ();
1259 #endif
1260
1261 #ifdef OBJ_ELF
1262   if (IS_ELF)
1263     create_obj_attrs_section ();
1264 #endif
1265
1266 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
1267   if ((flag_execstack || flag_noexecstack)
1268       && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1269     {
1270       segT gnustack;
1271
1272       gnustack = subseg_new (".note.GNU-stack", 0);
1273       bfd_set_section_flags (stdoutput, gnustack,
1274                              SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1275
1276     }
1277 #endif
1278
1279   /* If we've been collecting dwarf2 .debug_line info, either for
1280      assembly debugging or on behalf of the compiler, emit it now.  */
1281   dwarf2_finish ();
1282
1283   /* If we constructed dwarf2 .eh_frame info, either via .cfi
1284      directives from the user or by the backend, emit it now.  */
1285   cfi_finish ();
1286
1287   if (seen_at_least_1_file ()
1288       && (flag_always_generate_output || had_errors () == 0))
1289     keep_it = 1;
1290   else
1291     keep_it = 0;
1292
1293   /* This used to be done at the start of write_object_file in
1294      write.c, but that caused problems when doing listings when
1295      keep_it was zero.  This could probably be moved above md_end, but
1296      I didn't want to risk the change.  */
1297   subsegs_finish ();
1298
1299   if (keep_it)
1300     write_object_file ();
1301
1302   fflush (stderr);
1303
1304 #ifndef NO_LISTING
1305   listing_print (listing_filename, argv_orig);
1306 #endif
1307
1308   if (flag_fatal_warnings && had_warnings () > 0 && had_errors () == 0)
1309     as_bad (_("%d warnings, treating warnings as errors"), had_warnings ());
1310
1311   if (had_errors () > 0 && ! flag_always_generate_output)
1312     keep_it = 0;
1313
1314   input_scrub_end ();
1315
1316   END_PROGRESS (myname);
1317
1318   /* Use xexit instead of return, because under VMS environments they
1319      may not place the same interpretation on the value given.  */
1320   if (had_errors () > 0)
1321     xexit (EXIT_FAILURE);
1322
1323   /* Only generate dependency file if assembler was successful.  */
1324   print_dependencies ();
1325
1326   xexit (EXIT_SUCCESS);
1327 }