OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [main.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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