gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include <setjmp.h>
  23 #include "top.h"
  24 #include "target.h"
  25 #include "inferior.h"
  26 #include "call-cmds.h"
  27
  28 #include "getopt.h"
  29
  30 #include <sys/types.h>
  31 #include "gdb_stat.h"
  32 #include <ctype.h>
  33
  34 #include "gdb_string.h"
  35
  36 /* Temporary variable for SET_TOP_LEVEL.  */
  37
  38 static int top_level_val;
  39
  40 /* Do a setjmp on error_return and quit_return.  catch_errors is
  41    generally a cleaner way to do this, but main() would look pretty
  42    ugly if it had to use catch_errors each time.  */
  43
  44 #define SET_TOP_LEVEL() \
  45   (((top_level_val = SIGSETJMP (error_return)) \
  46     ? (PTR) 0 : (PTR) memcpy (quit_return, error_return, sizeof (SIGJMP_BUF))) \
  47    , top_level_val)
  48
  49 /* If nonzero, display time usage both at startup and for each command.  */
  50
  51 int display_time;
  52
  53 /* If nonzero, display space usage both at startup and for each command.  */
  54
  55 int display_space;
  56
  57 static void print_gdb_help PARAMS ((GDB_FILE *));
  58 extern void gdb_init PARAMS ((char *));
  59 #ifdef __CYGWIN32__
  60 #include <windows.h> /* for MAX_PATH */
  61 extern void cygwin32_conv_to_posix_path (const char *, char *);
  62 #endif
  63
  64 extern void (*pre_add_symbol_hook) PARAMS ((char *));
  65 extern void (*post_add_symbol_hook) PARAMS ((void));
  66
  67 int
  68 main (argc, argv)
  69      int argc;
  70      char **argv;
  71 {
  72   int count;
  73   static int quiet = 0;
  74   static int batch = 0;
  75
  76   /* Pointers to various arguments from command line.  */
  77   char *symarg = NULL;
  78   char *execarg = NULL;
  79   char *corearg = NULL;
  80   char *cdarg = NULL;
  81   char *ttyarg = NULL;
  82
  83   /* These are static so that we can take their address in an initializer.  */
  84   static int print_help;
  85   static int print_version;
  86
  87   /* Pointers to all arguments of --command option.  */
  88   char **cmdarg;
  89   /* Allocated size of cmdarg.  */
  90   int cmdsize;
  91   /* Number of elements of cmdarg used.  */
  92   int ncmd;
  93
  94   /* Indices of all arguments of --directory option.  */
  95   char **dirarg;
  96   /* Allocated size.  */
  97   int dirsize;
  98   /* Number of elements used.  */
  99   int ndir;
 100
 101   struct stat homebuf, cwdbuf;
 102   char *homedir, *homeinit;
 103
 104   register int i;
 105
 106   long time_at_startup = get_run_time ();
 107
 108   START_PROGRESS (argv[0], 0);
 109
 110 #ifdef MPW
 111   /* Do all Mac-specific setup. */
 112   mac_init ();
 113 #endif /* MPW */
 114
 115   /* This needs to happen before the first use of malloc.  */
 116   init_malloc ((PTR) NULL);
 117
 118 #if defined (ALIGN_STACK_ON_STARTUP)
 119   i = (int) &count & 0x3;
 120   if (i != 0)
 121     alloca (4 - i);
 122 #endif
 123
 124   /* If error() is called from initialization code, just exit */
 125   if (SET_TOP_LEVEL ()) {
 126     exit(1);
 127   }
 128
 129   cmdsize = 1;
 130   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 131   ncmd = 0;
 132   dirsize = 1;
 133   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 134   ndir = 0;
 135
 136   quit_flag = 0;
 137   line = (char *) xmalloc (linesize);
 138   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 139   instream = stdin;
 140
 141   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 142   current_directory = gdb_dirbuf;
 143
 144   /* Parse arguments and options.  */
 145   {
 146     int c;
 147     /* When var field is 0, use flag field to record the equivalent
 148        short option (or arbitrary numbers starting at 10 for those
 149        with no equivalent).  */
 150     static struct option long_options[] =
 151       {
 152         {"readnow", no_argument, &readnow_symbol_files, 1},
 153         {"r", no_argument, &readnow_symbol_files, 1},
 154         {"mapped", no_argument, &mapped_symbol_files, 1},
 155         {"m", no_argument, &mapped_symbol_files, 1},
 156         {"quiet", no_argument, &quiet, 1},
 157         {"q", no_argument, &quiet, 1},
 158         {"silent", no_argument, &quiet, 1},
 159         {"nx", no_argument, &inhibit_gdbinit, 1},
 160         {"n", no_argument, &inhibit_gdbinit, 1},
 161         {"batch", no_argument, &batch, 1},
 162         {"epoch", no_argument, &epoch_interface, 1},
 163
 164         /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 165            but keep this here for a long time because people will be running
 166            emacses which use --fullname.  */
 167         {"fullname", no_argument, 0, 'f'},
 168         {"f", no_argument, 0, 'f'},
 169
 170         {"annotate", required_argument, 0, 12},
 171         {"help", no_argument, &print_help, 1},
 172         {"se", required_argument, 0, 10},
 173         {"symbols", required_argument, 0, 's'},
 174         {"s", required_argument, 0, 's'},
 175         {"exec", required_argument, 0, 'e'},
 176         {"e", required_argument, 0, 'e'},
 177         {"core", required_argument, 0, 'c'},
 178         {"c", required_argument, 0, 'c'},
 179         {"command", required_argument, 0, 'x'},
 180         {"version", no_argument, &print_version, 1},
 181         {"x", required_argument, 0, 'x'},
 182 /* start-sanitize-gdbtk */
 183     {"tclcommand", required_argument, 0, 'z'},
 184 /* end-sanitize-gdbtk */
 185         {"directory", required_argument, 0, 'd'},
 186         {"cd", required_argument, 0, 11},
 187         {"tty", required_argument, 0, 't'},
 188         {"baud", required_argument, 0, 'b'},
 189         {"b", required_argument, 0, 'b'},
 190         {"nw", no_argument, &use_windows, 0},
 191         {"nowindows", no_argument, &use_windows, 0},
 192         {"w", no_argument, &use_windows, 1},
 193         {"windows", no_argument, &use_windows, 1},
 194         {"statistics", no_argument, 0, 13},
 195 /* Allow machine descriptions to add more options... */
 196 #ifdef ADDITIONAL_OPTIONS
 197         ADDITIONAL_OPTIONS
 198 #endif
 199         {0, no_argument, 0, 0}
 200       };
 201
 202     while (1)
 203       {
 204         int option_index;
 205
 206         c = getopt_long_only (argc, argv, "",
 207                               long_options, &option_index);
 208         if (c == EOF)
 209           break;
 210
 211         /* Long option that takes an argument.  */
 212         if (c == 0 && long_options[option_index].flag == 0)
 213           c = long_options[option_index].val;
 214
 215         switch (c)
 216           {
 217           case 0:
 218             /* Long option that just sets a flag.  */
 219             break;
 220           case 10:
 221             symarg = optarg;
 222             execarg = optarg;
 223             break;
 224           case 11:
 225             cdarg = optarg;
 226             break;
 227           case 12:
 228             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 229             annotation_level = atoi (optarg);
 230             break;
 231           case 13:
 232             /* Enable the display of both time and space usage.  */
 233             display_time = 1;
 234             display_space = 1;
 235             break;
 236           case 'f':
 237             annotation_level = 1;
 238 /* We have probably been invoked from emacs.  Disable window interface.  */
 239             use_windows = 0;
 240             break;
 241           case 's':
 242             symarg = optarg;
 243             break;
 244           case 'e':
 245             execarg = optarg;
 246             break;
 247           case 'c':
 248             corearg = optarg;
 249             break;
 250           case 'x':
 251             cmdarg[ncmd++] = optarg;
 252             if (ncmd >= cmdsize)
 253               {
 254                 cmdsize *= 2;
 255                 cmdarg = (char **) xrealloc ((char *)cmdarg,
 256                                              cmdsize * sizeof (*cmdarg));
 257               }
 258             break;
 259         /* start-sanitize-gdbtk */
 260       case 'z':
 261         {
 262           extern int gdbtk_test PARAMS ((char *));
 263           if (!gdbtk_test (optarg))
 264             {
 265               fprintf_unfiltered (gdb_stderr, "%s: unable to load tclcommand file \"%s\"",
 266                                   argv[0], optarg);
 267               exit (1);
 268             }
 269           break;
 270         }
 271         /* end-sanitize-gdbtk */
 272           case 'd':
 273             dirarg[ndir++] = optarg;
 274             if (ndir >= dirsize)
 275               {
 276                 dirsize *= 2;
 277                 dirarg = (char **) xrealloc ((char *)dirarg,
 278                                              dirsize * sizeof (*dirarg));
 279               }
 280             break;
 281           case 't':
 282             ttyarg = optarg;
 283             break;
 284           case 'q':
 285             quiet = 1;
 286             break;
 287           case 'b':
 288             {
 289               int i;
 290               char *p;
 291
 292               i = strtol (optarg, &p, 0);
 293               if (i == 0 && p == optarg)
 294
 295                 /* Don't use *_filtered or warning() (which relies on
 296                    current_target) until after initialize_all_files(). */
 297
 298                 fprintf_unfiltered
 299                   (gdb_stderr,
 300                    "warning: could not set baud rate to `%s'.\n", optarg);
 301               else
 302                 baud_rate = i;
 303             }
 304           case 'l':
 305             {
 306               int i;
 307               char *p;
 308
 309               i = strtol (optarg, &p, 0);
 310               if (i == 0 && p == optarg)
 311
 312                 /* Don't use *_filtered or warning() (which relies on
 313                    current_target) until after initialize_all_files(). */
 314
 315                 fprintf_unfiltered
 316                   (gdb_stderr,
 317                    "warning: could not set timeout limit to `%s'.\n", optarg);
 318               else
 319                 remote_timeout = i;
 320             }
 321             break;
 322
 323 #ifdef ADDITIONAL_OPTION_CASES
 324           ADDITIONAL_OPTION_CASES
 325 #endif
 326           case '?':
 327             fprintf_unfiltered (gdb_stderr,
 328                      "Use `%s --help' for a complete list of options.\n",
 329                      argv[0]);
 330             exit (1);
 331           }
 332       }
 333
 334     /* If --help or --version, disable window interface.  */
 335     if (print_help || print_version)
 336       use_windows = 0;
 337
 338     /* OK, that's all the options.  The other arguments are filenames.  */
 339     count = 0;
 340     for (; optind < argc; optind++)
 341       switch (++count)
 342         {
 343         case 1:
 344           symarg = argv[optind];
 345           execarg = argv[optind];
 346           break;
 347         case 2:
 348           corearg = argv[optind];
 349           break;
 350         case 3:
 351           fprintf_unfiltered (gdb_stderr,
 352                    "Excess command line arguments ignored. (%s%s)\n",
 353                    argv[optind], (optind == argc - 1) ? "" : " ...");
 354           break;
 355         }
 356     if (batch)
 357       quiet = 1;
 358   }
 359
 360   gdb_init (argv[0]);
 361
 362   /* Do these (and anything which might call wrap_here or *_filtered)
 363      after initialize_all_files.  */
 364   if (print_version)
 365     {
 366       print_gdb_version (gdb_stdout);
 367       wrap_here ("");
 368       printf_filtered ("\n");
 369       exit (0);
 370     }
 371
 372   if (print_help)
 373     {
 374       print_gdb_help (gdb_stdout);
 375       fputs_unfiltered ("\n", gdb_stdout);
 376       exit (0);
 377     }
 378
 379   if (!quiet)
 380     {
 381       /* Print all the junk at the top, with trailing "..." if we are about
 382          to read a symbol file (possibly slowly).  */
 383       print_gdb_version (gdb_stdout);
 384       if (symarg)
 385         printf_filtered ("..");
 386       wrap_here("");
 387       gdb_flush (gdb_stdout);           /* Force to screen during slow operations */
 388     }
 389
 390   error_pre_print = "\n\n";
 391   quit_pre_print = error_pre_print;
 392
 393   /* We may get more than one warning, don't double space all of them... */
 394   warning_pre_print = "\nwarning: ";
 395
 396   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 397      *before* all the command line arguments are processed; it sets
 398      global parameters, which are independent of what file you are
 399      debugging or what directory you are in.  */
 400 #ifdef __CYGWIN32__
 401   {
 402     char * tmp = getenv ("HOME");
 403
 404     if (tmp != NULL)
 405       {
 406         homedir = (char *) alloca (MAX_PATH+1);
 407         cygwin32_conv_to_posix_path (tmp, homedir);
 408       } else {
 409         homedir = NULL;
 410       }
 411   }
 412 #else
 413   homedir = getenv ("HOME");
 414 #endif
 415   if (homedir)
 416     {
 417       homeinit = (char *) alloca (strlen (homedir) +
 418                                   strlen (gdbinit) + 10);
 419       strcpy (homeinit, homedir);
 420       strcat (homeinit, "/");
 421       strcat (homeinit, gdbinit);
 422
 423       if (!inhibit_gdbinit)
 424         {
 425           if (!SET_TOP_LEVEL ())
 426             source_command (homeinit, 0);
 427         }
 428       do_cleanups (ALL_CLEANUPS);
 429
 430       /* Do stats; no need to do them elsewhere since we'll only
 431          need them if homedir is set.  Make sure that they are
 432          zero in case one of them fails (this guarantees that they
 433          won't match if either exists).  */
 434
 435       memset (&homebuf, 0, sizeof (struct stat));
 436       memset (&cwdbuf, 0, sizeof (struct stat));
 437
 438       stat (homeinit, &homebuf);
 439       stat (gdbinit, &cwdbuf); /* We'll only need this if
 440                                        homedir was set.  */
 441     }
 442
 443   /* Now perform all the actions indicated by the arguments.  */
 444   if (cdarg != NULL)
 445     {
 446       if (!SET_TOP_LEVEL ())
 447         {
 448           cd_command (cdarg, 0);
 449         }
 450     }
 451   do_cleanups (ALL_CLEANUPS);
 452
 453   for (i = 0; i < ndir; i++)
 454     if (!SET_TOP_LEVEL ())
 455       directory_command (dirarg[i], 0);
 456   free ((PTR)dirarg);
 457   do_cleanups (ALL_CLEANUPS);
 458
 459   if (execarg != NULL
 460       && symarg != NULL
 461       && STREQ (execarg, symarg))
 462     {
 463       /* The exec file and the symbol-file are the same.  If we can't open
 464          it, better only print one error message.  */
 465       if (!SET_TOP_LEVEL ())
 466         {
 467       if (pre_add_symbol_hook)
 468         pre_add_symbol_hook (symarg);
 469           exec_file_command (execarg, !batch);
 470           symbol_file_command (symarg, 0);
 471       if (post_add_symbol_hook)
 472         post_add_symbol_hook ();
 473         }
 474     }
 475   else
 476     {
 477       if (execarg != NULL)
 478         if (!SET_TOP_LEVEL ())
 479           exec_file_command (execarg, !batch);
 480       if (symarg != NULL)
 481         if (!SET_TOP_LEVEL ())
 482           symbol_file_command (symarg, 0);
 483     }
 484   do_cleanups (ALL_CLEANUPS);
 485
 486   /* After the symbol file has been read, print a newline to get us
 487      beyond the copyright line...  But errors should still set off
 488      the error message with a (single) blank line.  */
 489   if (!quiet)
 490     printf_filtered ("\n");
 491   error_pre_print = "\n";
 492   quit_pre_print = error_pre_print;
 493   warning_pre_print = "\nwarning: ";
 494
 495   if (corearg != NULL)
 496     if (!SET_TOP_LEVEL ())
 497       core_file_command (corearg, !batch);
 498     else if (isdigit (corearg[0]) && !SET_TOP_LEVEL ())
 499       attach_command (corearg, !batch);
 500   do_cleanups (ALL_CLEANUPS);
 501
 502   if (ttyarg != NULL)
 503     if (!SET_TOP_LEVEL ())
 504       tty_command (ttyarg, !batch);
 505   do_cleanups (ALL_CLEANUPS);
 506
 507 #ifdef ADDITIONAL_OPTION_HANDLER
 508   ADDITIONAL_OPTION_HANDLER;
 509 #endif
 510
 511   /* Error messages should no longer be distinguished with extra output. */
 512   error_pre_print = NULL;
 513   quit_pre_print = NULL;
 514   warning_pre_print = "warning: ";
 515
 516   /* Read the .gdbinit file in the current directory, *if* it isn't
 517      the same as the $HOME/.gdbinit file (it should exist, also).  */
 518
 519   if (!homedir
 520       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 521     if (!inhibit_gdbinit)
 522       {
 523         if (!SET_TOP_LEVEL ())
 524           source_command (gdbinit, 0);
 525       }
 526   do_cleanups (ALL_CLEANUPS);
 527
 528   for (i = 0; i < ncmd; i++)
 529     {
 530       if (!SET_TOP_LEVEL ())
 531         {
 532           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 533             read_command_file (stdin);
 534           else
 535             source_command (cmdarg[i], !batch);
 536           do_cleanups (ALL_CLEANUPS);
 537         }
 538     }
 539   free ((PTR)cmdarg);
 540
 541   /* Read in the old history after all the command files have been read. */
 542   init_history();
 543
 544   if (batch)
 545     {
 546       /* We have hit the end of the batch file.  */
 547       exit (0);
 548     }
 549
 550   /* Do any host- or target-specific hacks.  This is used for i960 targets
 551      to force the user to set a nindy target and spec its parameters.  */
 552
 553 #ifdef BEFORE_MAIN_LOOP_HOOK
 554   BEFORE_MAIN_LOOP_HOOK;
 555 #endif
 556
 557   END_PROGRESS (argv[0]);
 558
 559   /* Show time and/or space usage.  */
 560
 561   if (display_time)
 562     {
 563       long init_time = get_run_time () - time_at_startup;
 564
 565       printf_unfiltered ("Startup time: %ld.%06ld\n",
 566                          init_time / 1000000, init_time % 1000000);
 567     }
 568
 569   if (display_space)
 570     {
 571 #ifdef HAVE_SBRK
 572       extern char **environ;
 573       char *lim = (char *) sbrk (0);
 574
 575       printf_unfiltered ("Startup size: data size %ld\n",
 576                          (long) (lim - (char *) &environ));
 577 #endif
 578     }
 579
 580   /* The default command loop.
 581      The WIN32 Gui calls this main to set up gdb's state, and
 582      has its own command loop. */
 583 #if !defined _WIN32 || defined __GNUC__
 584   while (1)
 585     {
 586       if (!SET_TOP_LEVEL ())
 587         {
 588           do_cleanups (ALL_CLEANUPS);           /* Do complete cleanup */
 589           /* GUIs generally have their own command loop, mainloop, or whatever.
 590              This is a good place to gain control because many error
 591              conditions will end up here via longjmp(). */
 592           if (command_loop_hook)
 593             command_loop_hook ();
 594           else
 595             command_loop ();
 596           quit_command ((char *)0, instream == stdin);
 597         }
 598     }
 599
 600   /* No exit -- exit is through quit_command.  */
 601 #endif
 602
 603 }
 604
 605 /* Don't use *_filtered for printing help.  We don't want to prompt
 606    for continue no matter how small the screen or how much we're going
 607    to print.  */
 608
 609 static void
 610 print_gdb_help (stream)
 611   GDB_FILE *stream;
 612 {
 613       fputs_unfiltered ("\
 614 This is the GNU debugger.  Usage:\n\n\
 615     gdb [options] [executable-file [core-file or process-id]]\n\n\
 616 Options:\n\n\
 617 ", stream);
 618       fputs_unfiltered ("\
 619   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 620   --batch            Exit after processing options.\n\
 621   --cd=DIR           Change current directory to DIR.\n\
 622   --command=FILE     Execute GDB commands from FILE.\n\
 623   --core=COREFILE    Analyze the core dump COREFILE.\n\
 624 ", stream);
 625       fputs_unfiltered ("\
 626   --directory=DIR    Search for source files in DIR.\n\
 627   --epoch            Output information used by epoch emacs-GDB interface.\n\
 628   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 629   --fullname         Output information used by emacs-GDB interface.\n\
 630   --help             Print this message.\n\
 631 ", stream);
 632       fputs_unfiltered ("\
 633   --mapped           Use mapped symbol files if supported on this system.\n\
 634   --nw               Do not use a window interface.\n\
 635   --nx               Do not read .gdbinit file.\n\
 636   --quiet            Do not print version number on startup.\n\
 637   --readnow          Fully read symbol files on first access.\n\
 638 ", stream);
 639       fputs_unfiltered ("\
 640   --se=FILE          Use FILE as symbol file and executable file.\n\
 641   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 642   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 643   --version          Print version information and then exit.\n\
 644 ", stream);
 645 #ifdef ADDITIONAL_OPTION_HELP
 646       fputs_unfiltered (ADDITIONAL_OPTION_HELP, stream);
 647 #endif
 648       fputs_unfiltered ("\n\
 649 For more information, type \"help\" from within GDB, or consult the\n\
 650 GDB manual (available as on-line info or a printed manual).\n\
 651 Report bugs to \"bug-gdb@prep.ai.mit.edu\".\
 652 ", stream);
 653 }
 654
 655 \f
 656 void
 657 init_proc ()
 658 {
 659 }
 660
 661 void
 662 proc_remove_foreign (pid)
 663      int pid;
 664 {
 665 }
 666
 667 /* All I/O sent to the *_filtered and *_unfiltered functions eventually ends up
 668    here.  The fputs_unfiltered_hook is primarily used by GUIs to collect all
 669    output and send it to the GUI, instead of the controlling terminal.  Only
 670    output to gdb_stdout and gdb_stderr are sent to the hook.  Everything else
 671    is sent on to fputs to allow file I/O to be handled appropriately.  */
 672
 673 void
 674 fputs_unfiltered (linebuffer, stream)
 675      const char *linebuffer;
 676      FILE *stream;
 677 {
 678   if (fputs_unfiltered_hook
 679       && (stream == gdb_stdout
 680           || stream == gdb_stderr))
 681     fputs_unfiltered_hook (linebuffer, stream);
 682   else
 683     fputs (linebuffer, stream);
 684 }