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