OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [main.c] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Top level stuff for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5
   2009, 2010 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "top.h"
24
#include "target.h"
25
#include "inferior.h"
26
#include "symfile.h"
27
#include "gdbcore.h"
28
 
29
#include "exceptions.h"
30
#include "getopt.h"
31
 
32
#include <sys/types.h>
33
#include "gdb_stat.h"
34
#include <ctype.h>
35
 
36
#include "gdb_string.h"
37
#include "event-loop.h"
38
#include "ui-out.h"
39
 
40
#include "interps.h"
41
#include "main.h"
42
#include "source.h"
43
#include "cli/cli-cmds.h"
44
#include "python/python.h"
45
 
46
/* The selected interpreter.  This will be used as a set command
47
   variable, so it should always be malloc'ed - since
48
   do_setshow_command will free it. */
49
char *interpreter_p;
50
 
51
/* Whether xdb commands will be handled */
52
int xdb_commands = 0;
53
 
54
/* Whether dbx commands will be handled */
55
int dbx_commands = 0;
56
 
57
/* System root path, used to find libraries etc.  */
58
char *gdb_sysroot = 0;
59
 
60
/* GDB datadir, used to store data files.  */
61
char *gdb_datadir = 0;
62
 
63
/* If gdb was configured with --with-python=/path,
64
   the possibly relocated path to python's lib directory.  */
65
char *python_libdir = 0;
66
 
67
struct ui_file *gdb_stdout;
68
struct ui_file *gdb_stderr;
69
struct ui_file *gdb_stdlog;
70
struct ui_file *gdb_stdin;
71
/* target IO streams */
72
struct ui_file *gdb_stdtargin;
73
struct ui_file *gdb_stdtarg;
74
struct ui_file *gdb_stdtargerr;
75
 
76
/* True if --batch or --batch-silent was seen.  */
77
int batch_flag = 0;
78
 
79
/* Support for the --batch-silent option.  */
80
int batch_silent = 0;
81
 
82
/* Support for --return-child-result option.
83
   Set the default to -1 to return error in the case
84
   that the program does not run or does not complete.  */
85
int return_child_result = 0;
86
int return_child_result_value = -1;
87
 
88
/* Whether to enable writing into executable and core files */
89
extern int write_files;
90
 
91
/* GDB as it has been invoked from the command line (i.e. argv[0]).  */
92
static char *gdb_program_name;
93
 
94
static void print_gdb_help (struct ui_file *);
95
 
96
/* These two are used to set the external editor commands when gdb is farming
97
   out files to be edited by another program. */
98
 
99
extern char *external_editor_command;
100
 
101
/* Relocate a file or directory.  PROGNAME is the name by which gdb
102
   was invoked (i.e., argv[0]).  INITIAL is the default value for the
103
   file or directory.  FLAG is true if the value is relocatable, false
104
   otherwise.  Returns a newly allocated string; this may return NULL
105
   under the same conditions as make_relative_prefix.  */
106
static char *
107
relocate_path (const char *progname, const char *initial, int flag)
108
{
109
  if (flag)
110
    return make_relative_prefix (progname, BINDIR, initial);
111
  return xstrdup (initial);
112
}
113
 
114
/* Like relocate_path, but specifically checks for a directory.
115
   INITIAL is relocated according to the rules of relocate_path.  If
116
   the result is a directory, it is used; otherwise, INITIAL is used.
117
   The chosen directory is then canonicalized using lrealpath.  This
118
   function always returns a newly-allocated string.  */
119
static char *
120
relocate_directory (const char *progname, const char *initial, int flag)
121
{
122
  char *dir;
123
 
124
  dir = relocate_path (progname, initial, flag);
125
  if (dir)
126
    {
127
      struct stat s;
128
 
129
      if (stat (dir, &s) != 0 || !S_ISDIR (s.st_mode))
130
        {
131
          xfree (dir);
132
          dir = NULL;
133
        }
134
    }
135
  if (!dir)
136
    dir = xstrdup (initial);
137
 
138
  /* Canonicalize the directory.  */
139
  if (*dir)
140
    {
141
      char *canon_sysroot = lrealpath (dir);
142
 
143
      if (canon_sysroot)
144
        {
145
          xfree (dir);
146
          dir = canon_sysroot;
147
        }
148
    }
149
 
150
  return dir;
151
}
152
 
153
/* Compute the locations of init files that GDB should source and return
154
   them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT.  If there is
155
   no system gdbinit (resp. home gdbinit and local gdbinit) to be loaded,
156
   then SYSTEM_GDBINIT (resp. HOME_GDBINIT and LOCAL_GDBINIT) is set to
157
   NULL.  */
158
static void
159
get_init_files (char **system_gdbinit,
160
                char **home_gdbinit,
161
                char **local_gdbinit)
162
{
163
  static char *sysgdbinit = NULL;
164
  static char *homeinit = NULL;
165
  static char *localinit = NULL;
166
  static int initialized = 0;
167
 
168
  if (!initialized)
169
    {
170
      struct stat homebuf, cwdbuf, s;
171
      char *homedir, *relocated_sysgdbinit;
172
 
173
      if (SYSTEM_GDBINIT[0])
174
        {
175
          relocated_sysgdbinit = relocate_path (gdb_program_name,
176
                                                SYSTEM_GDBINIT,
177
                                                SYSTEM_GDBINIT_RELOCATABLE);
178
          if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0)
179
            sysgdbinit = relocated_sysgdbinit;
180
          else
181
            xfree (relocated_sysgdbinit);
182
        }
183
 
184
      homedir = getenv ("HOME");
185
 
186
      /* If the .gdbinit file in the current directory is the same as
187
         the $HOME/.gdbinit file, it should not be sourced.  homebuf
188
         and cwdbuf are used in that purpose. Make sure that the stats
189
         are zero in case one of them fails (this guarantees that they
190
         won't match if either exists).  */
191
 
192
      memset (&homebuf, 0, sizeof (struct stat));
193
      memset (&cwdbuf, 0, sizeof (struct stat));
194
 
195
      if (homedir)
196
        {
197
          homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
198
          if (stat (homeinit, &homebuf) != 0)
199
            {
200
              xfree (homeinit);
201
              homeinit = NULL;
202
            }
203
        }
204
 
205
      if (stat (gdbinit, &cwdbuf) == 0)
206
        {
207
          if (!homeinit
208
              || memcmp ((char *) &homebuf, (char *) &cwdbuf,
209
                         sizeof (struct stat)))
210
            localinit = gdbinit;
211
        }
212
 
213
      initialized = 1;
214
    }
215
 
216
  *system_gdbinit = sysgdbinit;
217
  *home_gdbinit = homeinit;
218
  *local_gdbinit = localinit;
219
}
220
 
221
/* Call command_loop.  If it happens to return, pass that through as a
222
   non-zero return status. */
223
 
224
static int
225
captured_command_loop (void *data)
226
{
227
  current_interp_command_loop ();
228
  /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
229
     would clean things up (restoring the cleanup chain) to the state
230
     they were just prior to the call.  Technically, this means that
231
     the do_cleanups() below is redundant.  Unfortunately, many FUNCs
232
     are not that well behaved.  do_cleanups should either be replaced
233
     with a do_cleanups call (to cover the problem) or an assertion
234
     check to detect bad FUNCs code. */
235
  do_cleanups (ALL_CLEANUPS);
236
  /* If the command_loop returned, normally (rather than threw an
237
     error) we try to quit. If the quit is aborted, catch_errors()
238
     which called this catch the signal and restart the command
239
     loop. */
240
  quit_command (NULL, instream == stdin);
241
  return 1;
242
}
243
 
244
static int
245
captured_main (void *data)
246
{
247
  struct captured_main_args *context = data;
248
  int argc = context->argc;
249
  char **argv = context->argv;
250
  static int quiet = 0;
251
  static int set_args = 0;
252
 
253
  /* Pointers to various arguments from command line.  */
254
  char *symarg = NULL;
255
  char *execarg = NULL;
256
  char *pidarg = NULL;
257
  char *corearg = NULL;
258
  char *pid_or_core_arg = NULL;
259
  char *cdarg = NULL;
260
  char *ttyarg = NULL;
261
 
262
  /* These are static so that we can take their address in an initializer.  */
263
  static int print_help;
264
  static int print_version;
265
 
266
  /* Pointers to all arguments of --command option.  */
267
  struct cmdarg {
268
    enum {
269
      CMDARG_FILE,
270
      CMDARG_COMMAND
271
    } type;
272
    char *string;
273
  } *cmdarg;
274
  /* Allocated size of cmdarg.  */
275
  int cmdsize;
276
  /* Number of elements of cmdarg used.  */
277
  int ncmd;
278
 
279
  /* Indices of all arguments of --directory option.  */
280
  char **dirarg;
281
  /* Allocated size.  */
282
  int dirsize;
283
  /* Number of elements used.  */
284
  int ndir;
285
 
286
  /* gdb init files.  */
287
  char *system_gdbinit;
288
  char *home_gdbinit;
289
  char *local_gdbinit;
290
 
291
  int i;
292
  int save_auto_load;
293
 
294
  struct cleanup *pre_stat_chain = make_command_stats_cleanup (0);
295
 
296
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
297
  setlocale (LC_MESSAGES, "");
298
#endif
299
#if defined (HAVE_SETLOCALE)
300
  setlocale (LC_CTYPE, "");
301
#endif
302
  bindtextdomain (PACKAGE, LOCALEDIR);
303
  textdomain (PACKAGE);
304
 
305
#ifdef HAVE_SBRK
306
  lim_at_start = (char *) sbrk (0);
307
#endif
308
 
309
  cmdsize = 1;
310
  cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg));
311
  ncmd = 0;
312
  dirsize = 1;
313
  dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
314
  ndir = 0;
315
 
316
  quit_flag = 0;
317
  line = (char *) xmalloc (linesize);
318
  line[0] = '\0';                /* Terminate saved (now empty) cmd line */
319
  instream = stdin;
320
 
321
  gdb_stdout = stdio_fileopen (stdout);
322
  gdb_stderr = stdio_fileopen (stderr);
323
  gdb_stdlog = gdb_stderr;      /* for moment */
324
  gdb_stdtarg = gdb_stderr;     /* for moment */
325
  gdb_stdin = stdio_fileopen (stdin);
326
  gdb_stdtargerr = gdb_stderr;  /* for moment */
327
  gdb_stdtargin = gdb_stdin;    /* for moment */
328
 
329
  gdb_program_name = xstrdup (argv[0]);
330
 
331
  if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
332
    /* Don't use *_filtered or warning() (which relies on
333
       current_target) until after initialize_all_files(). */
334
    fprintf_unfiltered (gdb_stderr,
335
                        _("%s: warning: error finding working directory: %s\n"),
336
                        argv[0], safe_strerror (errno));
337
 
338
  current_directory = gdb_dirbuf;
339
 
340
  /* Set the sysroot path.  */
341
  gdb_sysroot = relocate_directory (argv[0], TARGET_SYSTEM_ROOT,
342
                                    TARGET_SYSTEM_ROOT_RELOCATABLE);
343
 
344
  debug_file_directory = relocate_directory (argv[0], DEBUGDIR,
345
                                             DEBUGDIR_RELOCATABLE);
346
 
347
  gdb_datadir = relocate_directory (argv[0], GDB_DATADIR,
348
                                    GDB_DATADIR_RELOCATABLE);
349
 
350
#ifdef WITH_PYTHON_PATH
351
  /* For later use in helping Python find itself.  */
352
  python_libdir = relocate_directory (argv[0],
353
                                      concat (WITH_PYTHON_PATH,
354
                                              SLASH_STRING, "lib", NULL),
355
                                      PYTHON_PATH_RELOCATABLE);
356
#endif
357
 
358
#ifdef RELOC_SRCDIR
359
  add_substitute_path_rule (RELOC_SRCDIR,
360
                            make_relative_prefix (argv[0], BINDIR,
361
                                                  RELOC_SRCDIR));
362
#endif
363
 
364
  /* There will always be an interpreter.  Either the one passed into
365
     this captured main, or one specified by the user at start up, or
366
     the console.  Initialize the interpreter to the one requested by
367
     the application.  */
368
  interpreter_p = xstrdup (context->interpreter_p);
369
 
370
  /* Parse arguments and options.  */
371
  {
372
    int c;
373
    /* When var field is 0, use flag field to record the equivalent
374
       short option (or arbitrary numbers starting at 10 for those
375
       with no equivalent).  */
376
    enum {
377
      OPT_SE = 10,
378
      OPT_CD,
379
      OPT_ANNOTATE,
380
      OPT_STATISTICS,
381
      OPT_TUI,
382
      OPT_NOWINDOWS,
383
      OPT_WINDOWS
384
    };
385
    static struct option long_options[] =
386
    {
387
      {"tui", no_argument, 0, OPT_TUI},
388
      {"xdb", no_argument, &xdb_commands, 1},
389
      {"dbx", no_argument, &dbx_commands, 1},
390
      {"readnow", no_argument, &readnow_symbol_files, 1},
391
      {"r", no_argument, &readnow_symbol_files, 1},
392
      {"quiet", no_argument, &quiet, 1},
393
      {"q", no_argument, &quiet, 1},
394
      {"silent", no_argument, &quiet, 1},
395
      {"nx", no_argument, &inhibit_gdbinit, 1},
396
      {"n", no_argument, &inhibit_gdbinit, 1},
397
      {"batch-silent", no_argument, 0, 'B'},
398
      {"batch", no_argument, &batch_flag, 1},
399
      {"epoch", no_argument, &epoch_interface, 1},
400
 
401
    /* This is a synonym for "--annotate=1".  --annotate is now preferred,
402
       but keep this here for a long time because people will be running
403
       emacses which use --fullname.  */
404
      {"fullname", no_argument, 0, 'f'},
405
      {"f", no_argument, 0, 'f'},
406
 
407
      {"annotate", required_argument, 0, OPT_ANNOTATE},
408
      {"help", no_argument, &print_help, 1},
409
      {"se", required_argument, 0, OPT_SE},
410
      {"symbols", required_argument, 0, 's'},
411
      {"s", required_argument, 0, 's'},
412
      {"exec", required_argument, 0, 'e'},
413
      {"e", required_argument, 0, 'e'},
414
      {"core", required_argument, 0, 'c'},
415
      {"c", required_argument, 0, 'c'},
416
      {"pid", required_argument, 0, 'p'},
417
      {"p", required_argument, 0, 'p'},
418
      {"command", required_argument, 0, 'x'},
419
      {"eval-command", required_argument, 0, 'X'},
420
      {"version", no_argument, &print_version, 1},
421
      {"x", required_argument, 0, 'x'},
422
      {"ex", required_argument, 0, 'X'},
423
#ifdef GDBTK
424
      {"tclcommand", required_argument, 0, 'z'},
425
      {"enable-external-editor", no_argument, 0, 'y'},
426
      {"editor-command", required_argument, 0, 'w'},
427
#endif
428
      {"ui", required_argument, 0, 'i'},
429
      {"interpreter", required_argument, 0, 'i'},
430
      {"i", required_argument, 0, 'i'},
431
      {"directory", required_argument, 0, 'd'},
432
      {"d", required_argument, 0, 'd'},
433
      {"cd", required_argument, 0, OPT_CD},
434
      {"tty", required_argument, 0, 't'},
435
      {"baud", required_argument, 0, 'b'},
436
      {"b", required_argument, 0, 'b'},
437
      {"nw", no_argument, NULL, OPT_NOWINDOWS},
438
      {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
439
      {"w", no_argument, NULL, OPT_WINDOWS},
440
      {"windows", no_argument, NULL, OPT_WINDOWS},
441
      {"statistics", no_argument, 0, OPT_STATISTICS},
442
      {"write", no_argument, &write_files, 1},
443
      {"args", no_argument, &set_args, 1},
444
      {"l", required_argument, 0, 'l'},
445
      {"return-child-result", no_argument, &return_child_result, 1},
446
      {0, no_argument, 0, 0}
447
    };
448
 
449
    while (1)
450
      {
451
        int option_index;
452
 
453
        c = getopt_long_only (argc, argv, "",
454
                              long_options, &option_index);
455
        if (c == EOF || set_args)
456
          break;
457
 
458
        /* Long option that takes an argument.  */
459
        if (c == 0 && long_options[option_index].flag == 0)
460
          c = long_options[option_index].val;
461
 
462
        switch (c)
463
          {
464
          case 0:
465
            /* Long option that just sets a flag.  */
466
            break;
467
          case OPT_SE:
468
            symarg = optarg;
469
            execarg = optarg;
470
            break;
471
          case OPT_CD:
472
            cdarg = optarg;
473
            break;
474
          case OPT_ANNOTATE:
475
            /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
476
            annotation_level = atoi (optarg);
477
            break;
478
          case OPT_STATISTICS:
479
            /* Enable the display of both time and space usage.  */
480
            set_display_time (1);
481
            set_display_space (1);
482
            break;
483
          case OPT_TUI:
484
            /* --tui is equivalent to -i=tui.  */
485
#ifdef TUI
486
            xfree (interpreter_p);
487
            interpreter_p = xstrdup (INTERP_TUI);
488
#else
489
            fprintf_unfiltered (gdb_stderr,
490
                                _("%s: TUI mode is not supported\n"),
491
                                argv[0]);
492
            exit (1);
493
#endif
494
            break;
495
          case OPT_WINDOWS:
496
            /* FIXME: cagney/2003-03-01: Not sure if this option is
497
               actually useful, and if it is, what it should do.  */
498
#ifdef GDBTK
499
            /* --windows is equivalent to -i=insight.  */
500
            xfree (interpreter_p);
501
            interpreter_p = xstrdup (INTERP_INSIGHT);
502
#endif
503
            use_windows = 1;
504
            break;
505
          case OPT_NOWINDOWS:
506
            /* -nw is equivalent to -i=console.  */
507
            xfree (interpreter_p);
508
            interpreter_p = xstrdup (INTERP_CONSOLE);
509
            use_windows = 0;
510
            break;
511
          case 'f':
512
            annotation_level = 1;
513
/* We have probably been invoked from emacs.  Disable window interface.  */
514
            use_windows = 0;
515
            break;
516
          case 's':
517
            symarg = optarg;
518
            break;
519
          case 'e':
520
            execarg = optarg;
521
            break;
522
          case 'c':
523
            corearg = optarg;
524
            break;
525
          case 'p':
526
            pidarg = optarg;
527
            break;
528
          case 'x':
529
            cmdarg[ncmd].type = CMDARG_FILE;
530
            cmdarg[ncmd++].string = optarg;
531
            if (ncmd >= cmdsize)
532
              {
533
                cmdsize *= 2;
534
                cmdarg = xrealloc ((char *) cmdarg,
535
                                   cmdsize * sizeof (*cmdarg));
536
              }
537
            break;
538
          case 'X':
539
            cmdarg[ncmd].type = CMDARG_COMMAND;
540
            cmdarg[ncmd++].string = optarg;
541
            if (ncmd >= cmdsize)
542
              {
543
                cmdsize *= 2;
544
                cmdarg = xrealloc ((char *) cmdarg,
545
                                   cmdsize * sizeof (*cmdarg));
546
              }
547
            break;
548
          case 'B':
549
            batch_flag = batch_silent = 1;
550
            gdb_stdout = ui_file_new();
551
            break;
552
#ifdef GDBTK
553
          case 'z':
554
            {
555
extern int gdbtk_test (char *);
556
              if (!gdbtk_test (optarg))
557
                {
558
                  fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
559
                                      argv[0], optarg);
560
                  exit (1);
561
                }
562
              break;
563
            }
564
          case 'y':
565
            /* Backwards compatibility only.  */
566
            break;
567
          case 'w':
568
            {
569
              external_editor_command = xstrdup (optarg);
570
              break;
571
            }
572
#endif /* GDBTK */
573
          case 'i':
574
            xfree (interpreter_p);
575
            interpreter_p = xstrdup (optarg);
576
            break;
577
          case 'd':
578
            dirarg[ndir++] = optarg;
579
            if (ndir >= dirsize)
580
              {
581
                dirsize *= 2;
582
                dirarg = (char **) xrealloc ((char *) dirarg,
583
                                             dirsize * sizeof (*dirarg));
584
              }
585
            break;
586
          case 't':
587
            ttyarg = optarg;
588
            break;
589
          case 'q':
590
            quiet = 1;
591
            break;
592
          case 'b':
593
            {
594
              int i;
595
              char *p;
596
 
597
              i = strtol (optarg, &p, 0);
598
              if (i == 0 && p == optarg)
599
 
600
                /* Don't use *_filtered or warning() (which relies on
601
                   current_target) until after initialize_all_files(). */
602
 
603
                fprintf_unfiltered
604
                  (gdb_stderr,
605
                   _("warning: could not set baud rate to `%s'.\n"), optarg);
606
              else
607
                baud_rate = i;
608
            }
609
            break;
610
          case 'l':
611
            {
612
              int i;
613
              char *p;
614
 
615
              i = strtol (optarg, &p, 0);
616
              if (i == 0 && p == optarg)
617
 
618
                /* Don't use *_filtered or warning() (which relies on
619
                   current_target) until after initialize_all_files(). */
620
 
621
                fprintf_unfiltered
622
                  (gdb_stderr,
623
                 _("warning: could not set timeout limit to `%s'.\n"), optarg);
624
              else
625
                remote_timeout = i;
626
            }
627
            break;
628
 
629
          case '?':
630
            fprintf_unfiltered (gdb_stderr,
631
                        _("Use `%s --help' for a complete list of options.\n"),
632
                                argv[0]);
633
            exit (1);
634
          }
635
      }
636
 
637
    /* If --help or --version, disable window interface.  */
638
    if (print_help || print_version)
639
      {
640
        use_windows = 0;
641
      }
642
 
643
    if (batch_flag)
644
      quiet = 1;
645
  }
646
 
647
  /* Initialize all files.  Give the interpreter a chance to take
648
     control of the console via the deprecated_init_ui_hook ().  */
649
  gdb_init (argv[0]);
650
 
651
  /* Now that gdb_init has created the initial inferior, we're in position
652
     to set args for that inferior.  */
653
  if (set_args)
654
    {
655
      /* The remaining options are the command-line options for the
656
         inferior.  The first one is the sym/exec file, and the rest
657
         are arguments.  */
658
      if (optind >= argc)
659
        {
660
          fprintf_unfiltered (gdb_stderr,
661
                              _("%s: `--args' specified but no program specified\n"),
662
                              argv[0]);
663
          exit (1);
664
        }
665
      symarg = argv[optind];
666
      execarg = argv[optind];
667
      ++optind;
668
      set_inferior_args_vector (argc - optind, &argv[optind]);
669
    }
670
  else
671
    {
672
      /* OK, that's all the options.  */
673
 
674
      /* The first argument, if specified, is the name of the
675
         executable.  */
676
      if (optind < argc)
677
        {
678
          symarg = argv[optind];
679
          execarg = argv[optind];
680
          optind++;
681
        }
682
 
683
      /* If the user hasn't already specified a PID or the name of a
684
         core file, then a second optional argument is allowed.  If
685
         present, this argument should be interpreted as either a
686
         PID or a core file, whichever works.  */
687
      if (pidarg == NULL && corearg == NULL && optind < argc)
688
        {
689
          pid_or_core_arg = argv[optind];
690
          optind++;
691
        }
692
 
693
      /* Any argument left on the command line is unexpected and
694
         will be ignored.  Inform the user.  */
695
      if (optind < argc)
696
        fprintf_unfiltered (gdb_stderr, _("\
697
Excess command line arguments ignored. (%s%s)\n"),
698
                            argv[optind],
699
                            (optind == argc - 1) ? "" : " ...");
700
    }
701
 
702
  /* Lookup gdbinit files. Note that the gdbinit file name may be overriden
703
     during file initialization, so get_init_files should be called after
704
     gdb_init.  */
705
  get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
706
 
707
  /* Do these (and anything which might call wrap_here or *_filtered)
708
     after initialize_all_files() but before the interpreter has been
709
     installed.  Otherwize the help/version messages will be eaten by
710
     the interpreter's output handler.  */
711
 
712
  if (print_version)
713
    {
714
      print_gdb_version (gdb_stdout);
715
      wrap_here ("");
716
      printf_filtered ("\n");
717
      exit (0);
718
    }
719
 
720
  if (print_help)
721
    {
722
      print_gdb_help (gdb_stdout);
723
      fputs_unfiltered ("\n", gdb_stdout);
724
      exit (0);
725
    }
726
 
727
  /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
728
     GDB retain the old MI1 interpreter startup behavior.  Output the
729
     copyright message before the interpreter is installed.  That way
730
     it isn't encapsulated in MI output.  */
731
  if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
732
    {
733
      /* Print all the junk at the top, with trailing "..." if we are about
734
         to read a symbol file (possibly slowly).  */
735
      print_gdb_version (gdb_stdout);
736
      if (symarg)
737
        printf_filtered ("..");
738
      wrap_here ("");
739
      printf_filtered ("\n");
740
      gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
741
    }
742
 
743
 
744
  /* Install the default UI.  All the interpreters should have had a
745
     look at things by now.  Initialize the default interpreter. */
746
 
747
  {
748
    /* Find it.  */
749
    struct interp *interp = interp_lookup (interpreter_p);
750
 
751
    if (interp == NULL)
752
      error (_("Interpreter `%s' unrecognized"), interpreter_p);
753
    /* Install it.  */
754
    if (!interp_set (interp, 1))
755
      {
756
        fprintf_unfiltered (gdb_stderr,
757
                            "Interpreter `%s' failed to initialize.\n",
758
                            interpreter_p);
759
        exit (1);
760
      }
761
  }
762
 
763
  /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
764
     GDB retain the old MI1 interpreter startup behavior.  Output the
765
     copyright message after the interpreter is installed when it is
766
     any sane interpreter.  */
767
  if (!quiet && !current_interp_named_p (INTERP_MI1))
768
    {
769
      /* Print all the junk at the top, with trailing "..." if we are about
770
         to read a symbol file (possibly slowly).  */
771
      print_gdb_version (gdb_stdout);
772
      if (symarg)
773
        printf_filtered ("..");
774
      wrap_here ("");
775
      printf_filtered ("\n");
776
      gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
777
    }
778
 
779
  /* Set off error and warning messages with a blank line.  */
780
  error_pre_print = "\n";
781
  quit_pre_print = error_pre_print;
782
  warning_pre_print = _("\nwarning: ");
783
 
784
  /* Read and execute the system-wide gdbinit file, if it exists.
785
     This is done *before* all the command line arguments are
786
     processed; it sets global parameters, which are independent of
787
     what file you are debugging or what directory you are in.  */
788
  if (system_gdbinit && !inhibit_gdbinit)
789
    catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
790
 
791
  /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
792
     *before* all the command line arguments are processed; it sets
793
     global parameters, which are independent of what file you are
794
     debugging or what directory you are in.  */
795
 
796
  if (home_gdbinit && !inhibit_gdbinit)
797
    catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
798
 
799
  /* Now perform all the actions indicated by the arguments.  */
800
  if (cdarg != NULL)
801
    {
802
      catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
803
    }
804
 
805
  for (i = 0; i < ndir; i++)
806
    catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
807
  xfree (dirarg);
808
 
809
  /* Skip auto-loading section-specified scripts until we've sourced
810
     local_gdbinit (which is often used to augment the source search path).  */
811
  save_auto_load = gdbpy_global_auto_load;
812
  gdbpy_global_auto_load = 0;
813
 
814
  if (execarg != NULL
815
      && symarg != NULL
816
      && strcmp (execarg, symarg) == 0)
817
    {
818
      /* The exec file and the symbol-file are the same.  If we can't
819
         open it, better only print one error message.
820
         catch_command_errors returns non-zero on success! */
821
      if (catch_command_errors (exec_file_attach, execarg, !batch_flag, RETURN_MASK_ALL))
822
        catch_command_errors (symbol_file_add_main, symarg, !batch_flag, RETURN_MASK_ALL);
823
    }
824
  else
825
    {
826
      if (execarg != NULL)
827
        catch_command_errors (exec_file_attach, execarg, !batch_flag, RETURN_MASK_ALL);
828
      if (symarg != NULL)
829
        catch_command_errors (symbol_file_add_main, symarg, !batch_flag, RETURN_MASK_ALL);
830
    }
831
 
832
  if (corearg && pidarg)
833
    error (_("\
834
Can't attach to process and specify a core file at the same time."));
835
 
836
  if (corearg != NULL)
837
    catch_command_errors (core_file_command, corearg,
838
                          !batch_flag, RETURN_MASK_ALL);
839
  else if (pidarg != NULL)
840
    catch_command_errors (attach_command, pidarg,
841
                          !batch_flag, RETURN_MASK_ALL);
842
  else if (pid_or_core_arg)
843
    {
844
      /* The user specified 'gdb program pid' or gdb program core'.
845
         If pid_or_core_arg's first character is a digit, try attach
846
         first and then corefile.  Otherwise try just corefile.  */
847
 
848
      if (isdigit (pid_or_core_arg[0]))
849
        {
850
          if (catch_command_errors (attach_command, pid_or_core_arg,
851
                                    !batch_flag, RETURN_MASK_ALL) == 0)
852
            catch_command_errors (core_file_command, pid_or_core_arg,
853
                                  !batch_flag, RETURN_MASK_ALL);
854
        }
855
      else /* Can't be a pid, better be a corefile.  */
856
        catch_command_errors (core_file_command, pid_or_core_arg,
857
                              !batch_flag, RETURN_MASK_ALL);
858
    }
859
 
860
  if (ttyarg != NULL)
861
    set_inferior_io_terminal (ttyarg);
862
 
863
  /* Error messages should no longer be distinguished with extra output. */
864
  error_pre_print = NULL;
865
  quit_pre_print = NULL;
866
  warning_pre_print = _("warning: ");
867
 
868
  /* Read the .gdbinit file in the current directory, *if* it isn't
869
     the same as the $HOME/.gdbinit file (it should exist, also).  */
870
  if (local_gdbinit && !inhibit_gdbinit)
871
    catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
872
 
873
  /* Now that all .gdbinit's have been read and all -d options have been
874
     processed, we can read any scripts mentioned in SYMARG.
875
     We wait until now because it is common to add to the source search
876
     path in local_gdbinit.  */
877
  gdbpy_global_auto_load = save_auto_load;
878
  if (symfile_objfile != NULL)
879
    load_auto_scripts_for_objfile (symfile_objfile);
880
 
881
  for (i = 0; i < ncmd; i++)
882
    {
883
      if (cmdarg[i].type == CMDARG_FILE)
884
        catch_command_errors (source_script, cmdarg[i].string,
885
                              !batch_flag, RETURN_MASK_ALL);
886
      else  /* cmdarg[i].type == CMDARG_COMMAND */
887
        catch_command_errors (execute_command, cmdarg[i].string,
888
                              !batch_flag, RETURN_MASK_ALL);
889
    }
890
  xfree (cmdarg);
891
 
892
  /* Read in the old history after all the command files have been read. */
893
  init_history ();
894
 
895
  if (batch_flag)
896
    {
897
      /* We have hit the end of the batch file.  */
898
      quit_force (NULL, 0);
899
    }
900
 
901
  /* Show time and/or space usage.  */
902
  do_cleanups (pre_stat_chain);
903
 
904
  /* NOTE: cagney/1999-11-07: There is probably no reason for not
905
     moving this loop and the code found in captured_command_loop()
906
     into the command_loop() proper.  The main thing holding back that
907
     change - SET_TOP_LEVEL() - has been eliminated. */
908
  while (1)
909
    {
910
      catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
911
    }
912
  /* No exit -- exit is through quit_command.  */
913
}
914
 
915
int
916
gdb_main (struct captured_main_args *args)
917
{
918
  use_windows = args->use_windows;
919
  catch_errors (captured_main, args, "", RETURN_MASK_ALL);
920
  /* The only way to end up here is by an error (normal exit is
921
     handled by quit_force()), hence always return an error status.  */
922
  return 1;
923
}
924
 
925
 
926
/* Don't use *_filtered for printing help.  We don't want to prompt
927
   for continue no matter how small the screen or how much we're going
928
   to print.  */
929
 
930
static void
931
print_gdb_help (struct ui_file *stream)
932
{
933
  char *system_gdbinit;
934
  char *home_gdbinit;
935
  char *local_gdbinit;
936
 
937
  get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
938
 
939
  fputs_unfiltered (_("\
940
This is the GNU debugger.  Usage:\n\n\
941
    gdb [options] [executable-file [core-file or process-id]]\n\
942
    gdb [options] --args executable-file [inferior-arguments ...]\n\n\
943
Options:\n\n\
944
"), stream);
945
  fputs_unfiltered (_("\
946
  --args             Arguments after executable-file are passed to inferior\n\
947
"), stream);
948
  fputs_unfiltered (_("\
949
  -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
950
  --batch            Exit after processing options.\n\
951
  --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
952
  --return-child-result\n\
953
                     GDB exit code will be the child's exit code.\n\
954
  --cd=DIR           Change current directory to DIR.\n\
955
  --command=FILE, -x Execute GDB commands from FILE.\n\
956
  --eval-command=COMMAND, -ex\n\
957
                     Execute a single GDB command.\n\
958
                     May be used multiple times and in conjunction\n\
959
                     with --command.\n\
960
  --core=COREFILE    Analyze the core dump COREFILE.\n\
961
  --pid=PID          Attach to running process PID.\n\
962
"), stream);
963
  fputs_unfiltered (_("\
964
  --dbx              DBX compatibility mode.\n\
965
  --directory=DIR    Search for source files in DIR.\n\
966
  --epoch            Output information used by epoch emacs-GDB interface.\n\
967
  --exec=EXECFILE    Use EXECFILE as the executable.\n\
968
  --fullname         Output information used by emacs-GDB interface.\n\
969
  --help             Print this message.\n\
970
"), stream);
971
  fputs_unfiltered (_("\
972
  --interpreter=INTERP\n\
973
                     Select a specific interpreter / user interface\n\
974
"), stream);
975
  fputs_unfiltered (_("\
976
  -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
977
  --nw               Do not use a window interface.\n\
978
  --nx               Do not read "), stream);
979
  fputs_unfiltered (gdbinit, stream);
980
  fputs_unfiltered (_(" file.\n\
981
  --quiet            Do not print version number on startup.\n\
982
  --readnow          Fully read symbol files on first access.\n\
983
"), stream);
984
  fputs_unfiltered (_("\
985
  --se=FILE          Use FILE as symbol file and executable file.\n\
986
  --symbols=SYMFILE  Read symbols from SYMFILE.\n\
987
  --tty=TTY          Use TTY for input/output by the program being debugged.\n\
988
"), stream);
989
#if defined(TUI)
990
  fputs_unfiltered (_("\
991
  --tui              Use a terminal user interface.\n\
992
"), stream);
993
#endif
994
  fputs_unfiltered (_("\
995
  --version          Print version information and then exit.\n\
996
  -w                 Use a window interface.\n\
997
  --write            Set writing into executable and core files.\n\
998
  --xdb              XDB compatibility mode.\n\
999
"), stream);
1000
  fputs_unfiltered (_("\n\
1001
At startup, GDB reads the following init files and executes their commands:\n\
1002
"), stream);
1003
  if (system_gdbinit)
1004
    fprintf_unfiltered (stream, _("\
1005
   * system-wide init file: %s\n\
1006
"), system_gdbinit);
1007
  if (home_gdbinit)
1008
    fprintf_unfiltered (stream, _("\
1009
   * user-specific init file: %s\n\
1010
"), home_gdbinit);
1011
  if (local_gdbinit)
1012
    fprintf_unfiltered (stream, _("\
1013
   * local init file: ./%s\n\
1014
"), local_gdbinit);
1015
  fputs_unfiltered (_("\n\
1016
For more information, type \"help\" from within GDB, or consult the\n\
1017
GDB manual (available as on-line info or a printed manual).\n\
1018
"), stream);
1019
  if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1020
    fprintf_unfiltered (stream, _("\
1021
Report bugs to \"%s\".\n\
1022
"), REPORT_BUGS_TO);
1023
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.