gas/as.c

   1 /* as.c - GAS main program.
   2    Copyright (C) 1987, 1990, 1991, 1992, 1994 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 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public 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
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  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  *
  27  *                      bugs
  28  *
  29  * : initialisers
  30  *      Since no-one else says they will support them in future: I
  31  * don't support them now.
  32  *
  33  */
  34
  35 #include "ansidecl.h"
  36 #include "libiberty.h"
  37
  38 #define COMMON
  39
  40 #include "as.h"
  41 #include "subsegs.h"
  42 #include "output-file.h"
  43
  44 static void perform_an_assembly_pass PARAMS ((int argc, char **argv));
  45
  46 int listing;                    /* true if a listing is wanted */
  47
  48 char *myname;                   /* argv[0] */
  49 #ifdef BFD_ASSEMBLER
  50 segT reg_section, expr_section;
  51 segT text_section, data_section, bss_section;
  52 #endif
  53
  54 \f
  55 void
  56 print_version_id ()
  57 {
  58   static int printed;
  59   if (printed)
  60     return;
  61   printed = 1;
  62
  63   fprintf (stderr, "GNU assembler version %s (%s)", GAS_VERSION, TARGET_ALIAS);
  64 #ifdef BFD_ASSEMBLER
  65   fprintf (stderr, ", using BFD version %s", BFD_VERSION);
  66 #endif
  67   fprintf (stderr, "\n");
  68 }
  69
  70 void
  71 show_usage (stream)
  72      FILE *stream;
  73 {
  74   fprintf (stream, "Usage: %s [option...] [asmfile...]\n", myname);
  75
  76   fprintf (stream, "\
  77 Options:\n\
  78 -a[sub-option...]       turn on listings\n\
  79   Sub-options [default hls]:\n\
  80   d     omit debugging directives\n\
  81   h     include high-level source\n\
  82   l     include assembly\n\
  83   n     omit forms processing\n\
  84   s     include symbols\n");
  85   fprintf (stream, "\
  86 -D                      produce assembler debugging messages\n\
  87 -f                      skip whitespace and comment preprocessing\n\
  88 --help                  show this message and exit\n\
  89 -I DIR                  add DIR to search list for .include directives\n\
  90 -J                      don't warn about signed overflow\n\
  91 -K                      warn when differences altered for long displacements\n\
  92 -L                      keep local symbols (starting with `L')\n");
  93   fprintf (stream, "\
  94 -nocpp                  ignored\n\
  95 -o OBJFILE              name the object-file output OBJFILE (default a.out)\n\
  96 -R                      fold data section into text section\n\
  97 --statistics            print maximum bytes and total seconds used\n\
  98 --version               print assembler version number and exit\n\
  99 -W                      suppress warnings\n\
 100 -w                      ignored\n\
 101 -X                      ignored\n\
 102 -Z                      generate object file even after errors\n");
 103
 104   md_show_usage (stream);
 105 }
 106
 107 #ifdef USE_EMULATIONS
 108 #define EMULATION_ENVIRON "AS_EMULATION"
 109
 110 extern struct emulation mipsbelf, mipslelf, mipself;
 111 extern struct emulation mipsbecoff, mipslecoff, mipsecoff;
 112
 113 static const char *emulation_name;
 114 static struct emulation *const emulations[] = { EMULATIONS };
 115 static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
 116
 117 static void
 118 select_emulation_mode (argc, argv)
 119      int argc;
 120      char **argv;
 121 {
 122   int i;
 123   char *p, *em = 0;
 124
 125   for (i = 1; i < argc; i++)
 126     if (!strncmp ("--em", argv[i], 4))
 127       break;
 128
 129   if (i == argc)
 130     goto do_default;
 131
 132   p = strchr (argv[i], '=');
 133   if (p)
 134     p++;
 135   else
 136     p = argv[i+1];
 137
 138   if (!p || !*p)
 139     as_fatal ("missing emulation mode name");
 140   em = p;
 141
 142  do_default:
 143   if (em == 0)
 144     em = getenv (EMULATION_ENVIRON);
 145   if (em == 0)
 146     em = DEFAULT_EMULATION;
 147
 148   if (em)
 149     {
 150       for (i = 0; i < n_emulations; i++)
 151         if (!strcmp (emulations[i]->name, em))
 152           break;
 153       if (i == n_emulations)
 154         as_fatal ("unrecognized emulation name `%s'", em);
 155       this_emulation = emulations[i];
 156     }
 157   else
 158     this_emulation = emulations[0];
 159
 160   this_emulation->init ();
 161 }
 162
 163 const char *
 164 default_emul_bfd_name ()
 165 {
 166   abort ();
 167 }
 168
 169 void
 170 common_emul_init ()
 171 {
 172   this_format = this_emulation->format;
 173
 174   if (this_emulation->leading_underscore == 2)
 175     this_emulation->leading_underscore = this_format->dfl_leading_underscore;
 176
 177   if (this_emulation->default_endian != 2)
 178     target_big_endian = this_emulation->default_endian;
 179
 180   if (this_emulation->fake_label_name == 0)
 181     {
 182       if (this_emulation->leading_underscore)
 183         this_emulation->fake_label_name = "L0\001";
 184       else
 185         /* What other parameters should we test?  */
 186         this_emulation->fake_label_name = ".L0\001";
 187     }
 188 }
 189 #endif
 190
 191 /*
 192  * Since it is easy to do here we interpret the special arg "-"
 193  * to mean "use stdin" and we set that argv[] pointing to "".
 194  * After we have munged argv[], the only things left are source file
 195  * name(s) and ""(s) denoting stdin. These file names are used
 196  * (perhaps more than once) later.
 197  *
 198  * check for new machine-dep cmdline options in
 199  * md_parse_option definitions in config/tc-*.c
 200  */
 201
 202 void
 203 parse_args (pargc, pargv)
 204      int *pargc;
 205      char ***pargv;
 206 {
 207   int old_argc, new_argc;
 208   char **old_argv, **new_argv;
 209
 210   /* Starting the short option string with '-' is for programs that
 211      expect options and other ARGV-elements in any order and that care about
 212      the ordering of the two.  We describe each non-option ARGV-element
 213      as if it were the argument of an option with character code 1.  */
 214
 215   char *shortopts;
 216   extern CONST char *md_shortopts;
 217 #ifdef VMS
 218   /* -v takes an argument on VMS, so we don't make it a generic option.  */
 219   CONST char *std_shortopts = "-JKLRWZfa::DI:o:wX";
 220 #else
 221   CONST char *std_shortopts = "-JKLRWZfa::DI:o:vwX";
 222 #endif
 223
 224   struct option *longopts;
 225   extern struct option md_longopts[];
 226   extern size_t md_longopts_size;
 227   static const struct option std_longopts[] = {
 228 #define OPTION_HELP (OPTION_STD_BASE)
 229     {"help", no_argument, NULL, OPTION_HELP},
 230 #define OPTION_NOCPP (OPTION_STD_BASE + 1)
 231     {"nocpp", no_argument, NULL, OPTION_NOCPP},
 232 #define OPTION_STATISTICS (OPTION_STD_BASE + 2)
 233     {"statistics", no_argument, NULL, OPTION_STATISTICS},
 234 #define OPTION_VERSION (OPTION_STD_BASE + 3)
 235     {"version", no_argument, NULL, OPTION_VERSION},
 236 #define OPTION_DUMPCONFIG (OPTION_STD_BASE + 4)
 237     {"dump-config", no_argument, NULL, OPTION_DUMPCONFIG},
 238 #define OPTION_VERBOSE (OPTION_STD_BASE + 5)
 239     {"verbose", no_argument, NULL, OPTION_VERBOSE},
 240 #define OPTION_EMULATION (OPTION_STD_BASE + 6)
 241     {"emulation", required_argument, NULL, OPTION_EMULATION},
 242   };
 243
 244   /* Construct the option lists from the standard list and the
 245      target dependent list.  */
 246   shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
 247   longopts = (struct option *) xmalloc (sizeof (std_longopts) + md_longopts_size);
 248   memcpy (longopts, std_longopts, sizeof (std_longopts));
 249   memcpy ((char *) longopts + sizeof (std_longopts),
 250           md_longopts, md_longopts_size);
 251
 252   /* Make a local copy of the old argv.  */
 253   old_argc = *pargc;
 254   old_argv = *pargv;
 255
 256   /* Initialize a new argv that contains no options.  */
 257   new_argv = (char **) xmalloc (sizeof (char *) * (old_argc + 1));
 258   new_argv[0] = old_argv[0];
 259   new_argc = 1;
 260   new_argv[new_argc] = NULL;
 261
 262   while (1)
 263     {
 264       /* getopt_long_only is like getopt_long, but '-' as well as '--' can
 265          indicate a long option.  */
 266       int longind;
 267       int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
 268                                    &longind);
 269
 270       if (optc == -1)
 271         break;
 272
 273       switch (optc)
 274         {
 275         default:
 276           /* md_parse_option should return 1 if it recognizes optc,
 277              0 if not.  */
 278           if (md_parse_option (optc, optarg) != 0)
 279             break;
 280           /* `-v' isn't included in the general short_opts list, so check for
 281              it explicity here before deciding we've gotten a bad argument.  */
 282           if (optc == 'v')
 283             {
 284 #ifdef VMS
 285               /* Telling getopt to treat -v's value as optional can result
 286                  in it picking up a following filename argument here.  The
 287                  VMS code in md_parse_option can return 0 in that case,
 288                  but it has no way of pushing the filename argument back.  */
 289               if (optarg && *optarg)
 290                 new_argv[new_argc++] = optarg,  new_argv[new_argc] = NULL;
 291               else
 292 #else
 293               case 'v':
 294 #endif
 295               case OPTION_VERBOSE:
 296                 print_version_id ();
 297               break;
 298             }
 299           /*FALLTHRU*/
 300
 301         case '?':
 302           exit (EXIT_FAILURE);
 303
 304         case 1:                 /* File name.  */
 305           if (!strcmp (optarg, "-"))
 306             optarg = "";
 307           new_argv[new_argc++] = optarg;
 308           new_argv[new_argc] = NULL;
 309           break;
 310
 311         case OPTION_HELP:
 312           show_usage (stdout);
 313           exit (EXIT_SUCCESS);
 314
 315         case OPTION_NOCPP:
 316           break;
 317
 318         case OPTION_STATISTICS:
 319           flag_print_statistics = 1;
 320           break;
 321
 322         case OPTION_VERSION:
 323           print_version_id ();
 324           exit (EXIT_SUCCESS);
 325
 326         case OPTION_EMULATION:
 327 #ifdef USE_EMULATIONS
 328           if (strcmp (optarg, this_emulation->name))
 329             as_fatal ("multiple emulation names specified");
 330 #else
 331           as_fatal ("emulations not handled in this configuration");
 332 #endif
 333           break;
 334
 335         case OPTION_DUMPCONFIG:
 336           fprintf (stderr, "alias = %s\n", TARGET_ALIAS);
 337           fprintf (stderr, "canonical = %s\n", TARGET_CANONICAL);
 338           fprintf (stderr, "cpu-type = %s\n", TARGET_CPU);
 339 #ifdef TARGET_OBJ_FORMAT
 340           fprintf (stderr, "format = %s\n", TARGET_OBJ_FORMAT);
 341 #endif
 342 #ifdef TARGET_FORMAT
 343           fprintf (stderr, "bfd-target = %s\n", TARGET_FORMAT);
 344 #endif
 345           exit (EXIT_SUCCESS);
 346
 347         case 'J':
 348           flag_signed_overflow_ok = 1;
 349           break;
 350
 351         case 'K':
 352           flag_warn_displacement = 1;
 353           break;
 354
 355         case 'L':
 356           flag_keep_locals = 1;
 357           break;
 358
 359         case 'R':
 360           flag_readonly_data_in_text = 1;
 361           break;
 362
 363         case 'W':
 364           flag_no_warnings = 1;
 365           break;
 366
 367         case 'Z':
 368           flag_always_generate_output = 1;
 369           break;
 370
 371         case 'a':
 372           if (optarg)
 373             {
 374               while (*optarg)
 375                 {
 376                   switch (*optarg)
 377                     {
 378                     case 'd':
 379                       listing |= LISTING_NODEBUG;
 380                       break;
 381                     case 'h':
 382                       listing |= LISTING_HLL;
 383                       break;
 384                     case 'l':
 385                       listing |= LISTING_LISTING;
 386                       break;
 387                     case 'n':
 388                       listing |= LISTING_NOFORM;
 389                       break;
 390                     case 's':
 391                       listing |= LISTING_SYMBOLS;
 392                       break;
 393                     default:
 394                       as_fatal ("invalid listing option `%c'", *optarg);
 395                       break;
 396                     }
 397                   optarg++;
 398                 }
 399             }
 400           if (!listing)
 401             listing = LISTING_DEFAULT;
 402           break;
 403
 404         case 'D':
 405           /* DEBUG is implemented: it debugs different */
 406           /* things from other people's assemblers. */
 407           flag_debug = 1;
 408           break;
 409
 410         case 'f':
 411           flag_no_comments = 1;
 412           break;
 413
 414         case 'I':
 415           {                     /* Include file directory */
 416             char *temp = strdup (optarg);
 417             if (!temp)
 418               as_fatal ("virtual memory exhausted");
 419             add_include_dir (temp);
 420             break;
 421           }
 422
 423         case 'o':
 424           out_file_name = strdup (optarg);
 425           if (!out_file_name)
 426             as_fatal ("virtual memory exhausted");
 427           break;
 428
 429         case 'w':
 430           break;
 431
 432         case 'X':
 433           /* -X means treat warnings as errors */
 434           break;
 435         }
 436     }
 437
 438   free (shortopts);
 439   free (longopts);
 440
 441   *pargc = new_argc;
 442   *pargv = new_argv;
 443 }
 444
 445 int
 446 main (argc, argv)
 447      int argc;
 448      char **argv;
 449 {
 450   int keep_it;
 451   long start_time = get_run_time ();
 452
 453 #ifdef HOST_SPECIAL_INIT
 454   HOST_SPECIAL_INIT (argc, argv);
 455 #endif
 456
 457   myname = argv[0];
 458   xmalloc_set_program_name (myname);
 459
 460   START_PROGRESS (myname, 0);
 461
 462 #ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
 463 #define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
 464 #endif
 465
 466   out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
 467
 468   hex_init ();
 469 #ifdef BFD_ASSEMBLER
 470   bfd_init ();
 471 #endif
 472
 473 #ifdef USE_EMULATIONS
 474   select_emulation_mode (argc, argv);
 475 #endif
 476
 477   PROGRESS (1);
 478   symbol_begin ();
 479   frag_init ();
 480   subsegs_begin ();
 481   read_begin ();
 482   input_scrub_begin ();
 483   PROGRESS (1);
 484   parse_args (&argc, &argv);
 485
 486   PROGRESS (1);
 487
 488 #ifdef BFD_ASSEMBLER
 489   output_file_create (out_file_name);
 490   assert (stdoutput != 0);
 491 #endif
 492
 493 #ifdef tc_init_after_args
 494   tc_init_after_args ();
 495 #endif
 496
 497   PROGRESS (1);
 498
 499   perform_an_assembly_pass (argc, argv);        /* Assemble it. */
 500 #ifdef TC_I960
 501   brtab_emit ();
 502 #endif
 503 /* start-sanitize-rce */
 504 #ifdef TC_RCE
 505   dump_literals(0);
 506 #endif
 507 /* end-sanitize-rce */
 508
 509   if (seen_at_least_1_file ()
 510       && !((had_warnings () && flag_always_generate_output)
 511            || had_errors () > 0))
 512     keep_it = 1;
 513   else
 514     keep_it = 0;
 515
 516   if (keep_it)
 517     write_object_file ();
 518
 519 #ifndef NO_LISTING
 520   listing_print ("");
 521 #endif
 522
 523 #ifndef OBJ_VMS /* does its own file handling */
 524 #ifndef BFD_ASSEMBLER
 525   if (keep_it)
 526 #endif
 527     output_file_close (out_file_name);
 528 #endif
 529
 530   if (!keep_it)
 531     unlink (out_file_name);
 532
 533   input_scrub_end ();
 534 #ifdef md_end
 535   md_end ();
 536 #endif
 537
 538   END_PROGRESS (myname);
 539
 540   if (flag_print_statistics)
 541     {
 542       extern char **environ;
 543 #ifdef HAVE_SBRK
 544       char *lim = (char *) sbrk (0);
 545 #endif
 546       long run_time = get_run_time () - start_time;
 547
 548       fprintf (stderr, "%s: total time in assembly: %ld.%06ld\n",
 549                myname, run_time / 1000000, run_time % 1000000);
 550 #ifdef HAVE_SBRK
 551       fprintf (stderr, "%s: data size %ld\n",
 552                myname, (long) (lim - (char *) &environ));
 553 #endif
 554     }
 555
 556   /* Use exit instead of return, because under VMS environments they
 557      may not place the same interpretation on the value given.  */
 558   if ((had_warnings () && flag_always_generate_output)
 559       || had_errors () > 0)
 560     exit (EXIT_FAILURE);
 561   exit (EXIT_SUCCESS);
 562 }
 563 \f
 564
 565 /*                      perform_an_assembly_pass()
 566  *
 567  * Here to attempt 1 pass over each input file.
 568  * We scan argv[*] looking for filenames or exactly "" which is
 569  * shorthand for stdin. Any argv that is NULL is not a file-name.
 570  * We set need_pass_2 TRUE if, after this, we still have unresolved
 571  * expressions of the form (unknown value)+-(unknown value).
 572  *
 573  * Note the un*x semantics: there is only 1 logical input file, but it
 574  * may be a catenation of many 'physical' input files.
 575  */
 576 static void
 577 perform_an_assembly_pass (argc, argv)
 578      int argc;
 579      char **argv;
 580 {
 581   int saw_a_file = 0;
 582 #ifdef BFD_ASSEMBLER
 583   flagword applicable;
 584 #endif
 585
 586   need_pass_2 = 0;
 587
 588 #ifndef BFD_ASSEMBLER
 589 #ifdef MANY_SEGMENTS
 590   {
 591     unsigned int i;
 592     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
 593       segment_info[i].fix_root = 0;
 594   }
 595   /* Create the three fixed ones */
 596   {
 597     segT seg;
 598
 599 #ifdef TE_APOLLO
 600     seg = subseg_new (".wtext", 0);
 601 #else
 602     seg = subseg_new (".text", 0);
 603 #endif
 604     assert (seg == SEG_E0);
 605     seg = subseg_new (".data", 0);
 606     assert (seg == SEG_E1);
 607     seg = subseg_new (".bss", 0);
 608     assert (seg == SEG_E2);
 609 #ifdef TE_APOLLO
 610     create_target_segments ();
 611 #endif
 612   }
 613
 614 #else /* not MANY_SEGMENTS */
 615   text_fix_root = NULL;
 616   data_fix_root = NULL;
 617   bss_fix_root = NULL;
 618 #endif /* not MANY_SEGMENTS */
 619 #else /* BFD_ASSEMBLER */
 620   /* Create the standard sections, and those the assembler uses
 621      internally.  */
 622   text_section = subseg_new (".text", 0);
 623   data_section = subseg_new (".data", 0);
 624   bss_section = subseg_new (".bss", 0);
 625   /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
 626      to have relocs, otherwise we don't find out in time. */
 627   applicable = bfd_applicable_section_flags (stdoutput);
 628   bfd_set_section_flags (stdoutput, text_section,
 629                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
 630                                        | SEC_CODE | SEC_READONLY));
 631   /* @@ FIXME -- SEC_CODE seems to mean code only, rather than code possibly.*/
 632   bfd_set_section_flags (stdoutput, data_section,
 633                          applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC));
 634   bfd_set_section_flags (stdoutput, bss_section, applicable & SEC_ALLOC);
 635   seg_info (bss_section)->bss = 1;
 636   subseg_new (BFD_ABS_SECTION_NAME, 0);
 637   subseg_new (BFD_UND_SECTION_NAME, 0);
 638   reg_section = subseg_new ("*GAS `reg' section*", 0);
 639   expr_section = subseg_new ("*GAS `expr' section*", 0);
 640
 641 #endif /* BFD_ASSEMBLER */
 642
 643   subseg_set (text_section, 0);
 644
 645   /* This may add symbol table entries, which requires having an open BFD,
 646      and sections already created, in BFD_ASSEMBLER mode.  */
 647   md_begin ();
 648
 649   argv++;                       /* skip argv[0] */
 650   argc--;                       /* skip argv[0] */
 651   while (argc--)
 652     {
 653       if (*argv)
 654         {                       /* Is it a file-name argument? */
 655           PROGRESS (1);
 656           saw_a_file++;
 657           /* argv->"" if stdin desired, else->filename */
 658           read_a_source_file (*argv);
 659         }
 660       argv++;                   /* completed that argv */
 661     }
 662   if (!saw_a_file)
 663     read_a_source_file ("");
 664 }                               /* perform_an_assembly_pass() */
 665
 666 /* end of as.c */