gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
   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., 675 Mass Ave, Cambridge, MA 02139, 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 <sys/stat.h>
  32 #include <ctype.h>
  33
  34 #include <string.h>
  35 /* R_OK lives in either unistd.h or sys/file.h.  */
  36 #ifdef USG
  37 #include <unistd.h>
  38 #endif
  39 #ifndef NO_SYS_FILE
  40 #include <sys/file.h>
  41 #endif
  42
  43 /* Temporary variable for SET_TOP_LEVEL.  */
  44 static int top_level_val;
  45
  46 /* Do a setjmp on error_return and quit_return.  catch_errors is
  47    generally a cleaner way to do this, but main() would look pretty
  48    ugly if it had to use catch_errors each time.  */
  49
  50 #define SET_TOP_LEVEL() \
  51   (((top_level_val = setjmp (error_return)) \
  52     ? (PTR) 0 : (PTR) memcpy (quit_return, error_return, sizeof (jmp_buf))) \
  53    , top_level_val)
  54
  55 extern void gdb_init PARAMS ((void));
  56
  57 int
  58 main (argc, argv)
  59      int argc;
  60      char **argv;
  61 {
  62   int count;
  63   static int quiet = 0;
  64   static int batch = 0;
  65
  66   /* Pointers to various arguments from command line.  */
  67   char *symarg = NULL;
  68   char *execarg = NULL;
  69   char *corearg = NULL;
  70   char *cdarg = NULL;
  71   char *ttyarg = NULL;
  72
  73   /* These are static so that we can take their address in an initializer.  */
  74   static int print_help;
  75   static int print_version;
  76
  77   /* Pointers to all arguments of --command option.  */
  78   char **cmdarg;
  79   /* Allocated size of cmdarg.  */
  80   int cmdsize;
  81   /* Number of elements of cmdarg used.  */
  82   int ncmd;
  83
  84   /* Indices of all arguments of --directory option.  */
  85   char **dirarg;
  86   /* Allocated size.  */
  87   int dirsize;
  88   /* Number of elements used.  */
  89   int ndir;
  90
  91   struct stat homebuf, cwdbuf;
  92   char *homedir, *homeinit;
  93
  94   register int i;
  95
  96 /* start-sanitize-mpw */
  97 #ifdef MPW
  98   /* Drop into MacsBug, but only if the executable is specially named. */
  99   if (strcmp(argv[0], "DEBUGGDB") == 0)
 100     DebugStr("\pat start of GDB main");
 101   /* Do all Mac-specific setup. */
 102   mac_init ();
 103 #endif /* MPW */
 104 /* end-sanitize-mpw */
 105   /* This needs to happen before the first use of malloc.  */
 106   init_malloc ((PTR) NULL);
 107
 108 #if defined (ALIGN_STACK_ON_STARTUP)
 109   i = (int) &count & 0x3;
 110   if (i != 0)
 111     alloca (4 - i);
 112 #endif
 113
 114   /* If error() is called from initialization code, just exit */
 115   if (SET_TOP_LEVEL ()) {
 116     exit(1);
 117   }
 118
 119   cmdsize = 1;
 120   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 121   ncmd = 0;
 122   dirsize = 1;
 123   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 124   ndir = 0;
 125
 126   quit_flag = 0;
 127   line = (char *) xmalloc (linesize);
 128   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 129   instream = stdin;
 130
 131   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 132   current_directory = gdb_dirbuf;
 133
 134   /* Parse arguments and options.  */
 135   {
 136     int c;
 137     /* When var field is 0, use flag field to record the equivalent
 138        short option (or arbitrary numbers starting at 10 for those
 139        with no equivalent).  */
 140     static struct option long_options[] =
 141       {
 142         {"readnow", no_argument, &readnow_symbol_files, 1},
 143         {"r", no_argument, &readnow_symbol_files, 1},
 144         {"mapped", no_argument, &mapped_symbol_files, 1},
 145         {"m", no_argument, &mapped_symbol_files, 1},
 146         {"quiet", no_argument, &quiet, 1},
 147         {"q", no_argument, &quiet, 1},
 148         {"silent", no_argument, &quiet, 1},
 149         {"nx", no_argument, &inhibit_gdbinit, 1},
 150         {"n", no_argument, &inhibit_gdbinit, 1},
 151         {"batch", no_argument, &batch, 1},
 152         {"epoch", no_argument, &epoch_interface, 1},
 153
 154         /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 155            but keep this here for a long time because people will be running
 156            emacses which use --fullname.  */
 157         {"fullname", no_argument, 0, 'f'},
 158         {"f", no_argument, 0, 'f'},
 159
 160         {"annotate", required_argument, 0, 12},
 161         {"help", no_argument, &print_help, 1},
 162         {"se", required_argument, 0, 10},
 163         {"symbols", required_argument, 0, 's'},
 164         {"s", required_argument, 0, 's'},
 165         {"exec", required_argument, 0, 'e'},
 166         {"e", required_argument, 0, 'e'},
 167         {"core", required_argument, 0, 'c'},
 168         {"c", required_argument, 0, 'c'},
 169         {"command", required_argument, 0, 'x'},
 170         {"version", no_argument, &print_version, 1},
 171         {"x", required_argument, 0, 'x'},
 172         {"directory", required_argument, 0, 'd'},
 173         {"cd", required_argument, 0, 11},
 174         {"tty", required_argument, 0, 't'},
 175         {"baud", required_argument, 0, 'b'},
 176         {"b", required_argument, 0, 'b'},
 177 /* Allow machine descriptions to add more options... */
 178 #ifdef ADDITIONAL_OPTIONS
 179         ADDITIONAL_OPTIONS
 180 #endif
 181         {0, no_argument, 0, 0},
 182       };
 183
 184     while (1)
 185       {
 186         int option_index;
 187
 188         c = getopt_long_only (argc, argv, "",
 189                               long_options, &option_index);
 190         if (c == EOF)
 191           break;
 192
 193         /* Long option that takes an argument.  */
 194         if (c == 0 && long_options[option_index].flag == 0)
 195           c = long_options[option_index].val;
 196
 197         switch (c)
 198           {
 199           case 0:
 200             /* Long option that just sets a flag.  */
 201             break;
 202           case 10:
 203             symarg = optarg;
 204             execarg = optarg;
 205             break;
 206           case 11:
 207             cdarg = optarg;
 208             break;
 209           case 12:
 210             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 211             annotation_level = atoi (optarg);
 212             break;
 213           case 'f':
 214             annotation_level = 1;
 215             break;
 216           case 's':
 217             symarg = optarg;
 218             break;
 219           case 'e':
 220             execarg = optarg;
 221             break;
 222           case 'c':
 223             corearg = optarg;
 224             break;
 225           case 'x':
 226             cmdarg[ncmd++] = optarg;
 227             if (ncmd >= cmdsize)
 228               {
 229                 cmdsize *= 2;
 230                 cmdarg = (char **) xrealloc ((char *)cmdarg,
 231                                              cmdsize * sizeof (*cmdarg));
 232               }
 233             break;
 234           case 'd':
 235             dirarg[ndir++] = optarg;
 236             if (ndir >= dirsize)
 237               {
 238                 dirsize *= 2;
 239                 dirarg = (char **) xrealloc ((char *)dirarg,
 240                                              dirsize * sizeof (*dirarg));
 241               }
 242             break;
 243           case 't':
 244             ttyarg = optarg;
 245             break;
 246           case 'q':
 247             quiet = 1;
 248             break;
 249           case 'b':
 250             {
 251               int i;
 252               char *p;
 253
 254               i = strtol (optarg, &p, 0);
 255               if (i == 0 && p == optarg)
 256
 257                 /* Don't use *_filtered or warning() (which relies on
 258                    current_target) until after initialize_all_files(). */
 259
 260                 fprintf_unfiltered
 261                   (gdb_stderr,
 262                    "warning: could not set baud rate to `%s'.\n", optarg);
 263               else
 264                 baud_rate = i;
 265             }
 266             break;
 267
 268 #ifdef ADDITIONAL_OPTION_CASES
 269           ADDITIONAL_OPTION_CASES
 270 #endif
 271           case '?':
 272             fprintf_unfiltered (gdb_stderr,
 273                      "Use `%s --help' for a complete list of options.\n",
 274                      argv[0]);
 275             exit (1);
 276           }
 277       }
 278
 279     /* OK, that's all the options.  The other arguments are filenames.  */
 280     count = 0;
 281     for (; optind < argc; optind++)
 282       switch (++count)
 283         {
 284         case 1:
 285           symarg = argv[optind];
 286           execarg = argv[optind];
 287           break;
 288         case 2:
 289           corearg = argv[optind];
 290           break;
 291         case 3:
 292           fprintf_unfiltered (gdb_stderr,
 293                    "Excess command line arguments ignored. (%s%s)\n",
 294                    argv[optind], (optind == argc - 1) ? "" : " ...");
 295           break;
 296         }
 297     if (batch)
 298       quiet = 1;
 299   }
 300
 301   gdb_init ();
 302
 303   /* Do these (and anything which might call wrap_here or *_filtered)
 304      after initialize_all_files.  */
 305   if (print_version)
 306     {
 307       print_gdb_version (gdb_stdout);
 308       wrap_here ("");
 309       printf_filtered ("\n");
 310       exit (0);
 311     }
 312
 313   if (print_help)
 314     {
 315       /* --version is intentionally not documented here, because we
 316          are printing the version here, and the help is long enough
 317          already.  */
 318
 319       print_gdb_version (gdb_stdout);
 320       /* Make sure the output gets printed.  */
 321       wrap_here ("");
 322       printf_filtered ("\n");
 323
 324       /* But don't use *_filtered here.  We don't want to prompt for continue
 325          no matter how small the screen or how much we're going to print.  */
 326 /* start-sanitize-mpw */
 327 /* For reasons too ugly to describe... */
 328 #ifdef MPW_C
 329       fputs_unfiltered ("This is the GNU debugger.\n", gdb_stdout);
 330 #else
 331 /* end-sanitize-mpw */
 332       fputs_unfiltered ("\
 333 This is the GNU debugger.  Usage:\n\
 334     gdb [options] [executable-file [core-file or process-id]]\n\
 335 Options:\n\
 336   --help             Print this message.\n\
 337   --quiet            Do not print version number on startup.\n\
 338   --fullname         Output information used by emacs-GDB interface.\n\
 339   --epoch            Output information used by epoch emacs-GDB interface.\n\
 340   --batch            Exit after processing options.\n\
 341   --nx               Do not read .gdbinit file.\n\
 342   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 343   --cd=DIR           Change current directory to DIR.\n\
 344   --directory=DIR    Search for source files in DIR.\n\
 345   --command=FILE     Execute GDB commands from FILE.\n\
 346   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 347   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 348   --se=FILE          Use FILE as symbol file and executable file.\n\
 349   --core=COREFILE    Analyze the core dump COREFILE.\n\
 350   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 351   --mapped           Use mapped symbol files if supported on this system.\n\
 352   --readnow          Fully read symbol files on first access.\n\
 353 ", gdb_stdout);
 354 /* start-sanitize-mpw */
 355 #endif /* MPW_C */
 356 /* end-sanitize-mpw */
 357 #ifdef ADDITIONAL_OPTION_HELP
 358       fputs_unfiltered (ADDITIONAL_OPTION_HELP, gdb_stdout);
 359 #endif
 360       fputs_unfiltered ("\n\
 361 For more information, type \"help\" from within GDB, or consult the\n\
 362 GDB manual (available as on-line info or a printed manual).\n", gdb_stdout);
 363       exit (0);
 364     }
 365
 366   if (!quiet)
 367     {
 368       /* Print all the junk at the top, with trailing "..." if we are about
 369          to read a symbol file (possibly slowly).  */
 370       print_gnu_advertisement ();
 371       print_gdb_version (gdb_stdout);
 372       if (symarg)
 373         printf_filtered ("..");
 374       wrap_here("");
 375       gdb_flush (gdb_stdout);           /* Force to screen during slow operations */
 376     }
 377
 378   error_pre_print = "\n\n";
 379   /* We may get more than one warning, don't double space all of them... */
 380   warning_pre_print = "\nwarning: ";
 381
 382   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 383      *before* all the command line arguments are processed; it sets
 384      global parameters, which are independent of what file you are
 385      debugging or what directory you are in.  */
 386   homedir = getenv ("HOME");
 387   if (homedir)
 388     {
 389       homeinit = (char *) alloca (strlen (getenv ("HOME")) +
 390                                   strlen (gdbinit) + 10);
 391       strcpy (homeinit, getenv ("HOME"));
 392       strcat (homeinit, "/");
 393       strcat (homeinit, gdbinit);
 394       if (!inhibit_gdbinit && access (homeinit, R_OK) == 0)
 395         {
 396           if (!SET_TOP_LEVEL ())
 397             source_command (homeinit, 0);
 398         }
 399       do_cleanups (ALL_CLEANUPS);
 400
 401       /* Do stats; no need to do them elsewhere since we'll only
 402          need them if homedir is set.  Make sure that they are
 403          zero in case one of them fails (this guarantees that they
 404          won't match if either exists).  */
 405
 406       memset (&homebuf, 0, sizeof (struct stat));
 407       memset (&cwdbuf, 0, sizeof (struct stat));
 408
 409       stat (homeinit, &homebuf);
 410       stat (gdbinit, &cwdbuf); /* We'll only need this if
 411                                        homedir was set.  */
 412     }
 413
 414   /* Now perform all the actions indicated by the arguments.  */
 415   if (cdarg != NULL)
 416     {
 417       if (!SET_TOP_LEVEL ())
 418         {
 419           cd_command (cdarg, 0);
 420         }
 421     }
 422   do_cleanups (ALL_CLEANUPS);
 423
 424   for (i = 0; i < ndir; i++)
 425     if (!SET_TOP_LEVEL ())
 426       directory_command (dirarg[i], 0);
 427   free ((PTR)dirarg);
 428   do_cleanups (ALL_CLEANUPS);
 429
 430   if (execarg != NULL
 431       && symarg != NULL
 432       && STREQ (execarg, symarg))
 433     {
 434       /* The exec file and the symbol-file are the same.  If we can't open
 435          it, better only print one error message.  */
 436       if (!SET_TOP_LEVEL ())
 437         {
 438           exec_file_command (execarg, !batch);
 439           symbol_file_command (symarg, 0);
 440         }
 441     }
 442   else
 443     {
 444       if (execarg != NULL)
 445         if (!SET_TOP_LEVEL ())
 446           exec_file_command (execarg, !batch);
 447       if (symarg != NULL)
 448         if (!SET_TOP_LEVEL ())
 449           symbol_file_command (symarg, 0);
 450     }
 451   do_cleanups (ALL_CLEANUPS);
 452
 453   /* After the symbol file has been read, print a newline to get us
 454      beyond the copyright line...  But errors should still set off
 455      the error message with a (single) blank line.  */
 456   if (!quiet)
 457     printf_filtered ("\n");
 458   error_pre_print = "\n";
 459   warning_pre_print = "\nwarning: ";
 460
 461   if (corearg != NULL)
 462     if (!SET_TOP_LEVEL ())
 463       core_file_command (corearg, !batch);
 464     else if (isdigit (corearg[0]) && !SET_TOP_LEVEL ())
 465       attach_command (corearg, !batch);
 466   do_cleanups (ALL_CLEANUPS);
 467
 468   if (ttyarg != NULL)
 469     if (!SET_TOP_LEVEL ())
 470       tty_command (ttyarg, !batch);
 471   do_cleanups (ALL_CLEANUPS);
 472
 473 #ifdef ADDITIONAL_OPTION_HANDLER
 474   ADDITIONAL_OPTION_HANDLER;
 475 #endif
 476
 477   /* Error messages should no longer be distinguished with extra output. */
 478   error_pre_print = 0;
 479   warning_pre_print = "warning: ";
 480
 481   /* Read the .gdbinit file in the current directory, *if* it isn't
 482      the same as the $HOME/.gdbinit file (it should exist, also).  */
 483
 484   if (!homedir
 485       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 486     if (!inhibit_gdbinit && access (gdbinit, R_OK) == 0)
 487       {
 488         if (!SET_TOP_LEVEL ())
 489           source_command (gdbinit, 0);
 490       }
 491   do_cleanups (ALL_CLEANUPS);
 492
 493   for (i = 0; i < ncmd; i++)
 494     {
 495       if (!SET_TOP_LEVEL ())
 496         {
 497           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 498             read_command_file (stdin);
 499           else
 500             source_command (cmdarg[i], !batch);
 501           do_cleanups (ALL_CLEANUPS);
 502         }
 503     }
 504   free ((PTR)cmdarg);
 505
 506   /* Read in the old history after all the command files have been read. */
 507   init_history();
 508
 509   if (batch)
 510     {
 511       /* We have hit the end of the batch file.  */
 512       exit (0);
 513     }
 514
 515   /* Do any host- or target-specific hacks.  This is used for i960 targets
 516      to force the user to set a nindy target and spec its parameters.  */
 517
 518 #ifdef BEFORE_MAIN_LOOP_HOOK
 519   BEFORE_MAIN_LOOP_HOOK;
 520 #endif
 521
 522   /* The command loop.  */
 523
 524   while (1)
 525     {
 526       if (!SET_TOP_LEVEL ())
 527         {
 528           do_cleanups (ALL_CLEANUPS);           /* Do complete cleanup */
 529 /* start-sanitize-mpw */
 530 #ifdef MPW
 531           /* If we're being a Mac application, go into a Mac-specific
 532              event-handling loop instead.  We still want to be inside
 533              the outer loop, because that will catch longjmps resulting
 534              from some command executions. */
 535           if (mac_app)
 536             mac_command_loop ();
 537           else
 538 #endif /* MPW */
 539 /* end-sanitize-mpw */
 540           command_loop ();
 541           quit_command ((char *)0, instream == stdin);
 542         }
 543     }
 544   /* No exit -- exit is through quit_command.  */
 545 }
 546 \f
 547 void
 548 init_proc ()
 549 {
 550 }
 551
 552 int
 553 proc_wait (pid, status)
 554      int pid;
 555      int *status;
 556 {
 557 #ifndef __GO32__
 558   return wait (status);
 559 #endif
 560 }
 561
 562 void
 563 proc_remove_foreign (pid)
 564      int pid;
 565 {
 566 }
 567
 568 void
 569 fputs_unfiltered (linebuffer, stream)
 570      const char *linebuffer;
 571      FILE *stream;
 572 {
 573   fputs (linebuffer, stream);
 574 }