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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Support for GDB maintenance commands.
2
 
3
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
4
   2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
 
6
   Written by Fred Fish at Cygnus Support.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
 
24
#include "defs.h"
25
#include "arch-utils.h"
26
#include <ctype.h>
27
#include <signal.h>
28
#include "command.h"
29
#include "gdbcmd.h"
30
#include "symtab.h"
31
#include "gdbtypes.h"
32
#include "demangle.h"
33
#include "gdbcore.h"
34
#include "expression.h"         /* For language.h */
35
#include "language.h"
36
#include "symfile.h"
37
#include "objfiles.h"
38
#include "value.h"
39
#include "gdb_assert.h"
40
 
41
#include "cli/cli-decode.h"
42
 
43
extern void _initialize_maint_cmds (void);
44
 
45
static void maintenance_command (char *, int);
46
 
47
static void maintenance_internal_error (char *args, int from_tty);
48
 
49
static void maintenance_demangle (char *, int);
50
 
51
static void maintenance_time_display (char *, int);
52
 
53
static void maintenance_space_display (char *, int);
54
 
55
static void maintenance_info_command (char *, int);
56
 
57
static void maintenance_info_sections (char *, int);
58
 
59
static void maintenance_print_command (char *, int);
60
 
61
static void maintenance_do_deprecate (char *, int);
62
 
63
/* Set this to the maximum number of seconds to wait instead of waiting forever
64
   in target_wait().  If this timer times out, then it generates an error and
65
   the command is aborted.  This replaces most of the need for timeouts in the
66
   GDB test suite, and makes it possible to distinguish between a hung target
67
   and one with slow communications.  */
68
 
69
int watchdog = 0;
70
static void
71
show_watchdog (struct ui_file *file, int from_tty,
72
               struct cmd_list_element *c, const char *value)
73
{
74
  fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
75
}
76
 
77
/*
78
 
79
   LOCAL FUNCTION
80
 
81
   maintenance_command -- access the maintenance subcommands
82
 
83
   SYNOPSIS
84
 
85
   void maintenance_command (char *args, int from_tty)
86
 
87
   DESCRIPTION
88
 
89
 */
90
 
91
static void
92
maintenance_command (char *args, int from_tty)
93
{
94
  printf_unfiltered (_("\"maintenance\" must be followed by the name of a maintenance command.\n"));
95
  help_list (maintenancelist, "maintenance ", -1, gdb_stdout);
96
}
97
 
98
#ifndef _WIN32
99
static void
100
maintenance_dump_me (char *args, int from_tty)
101
{
102
  if (query (_("Should GDB dump core? ")))
103
    {
104
#ifdef __DJGPP__
105
      /* SIGQUIT by default is ignored, so use SIGABRT instead.  */
106
      signal (SIGABRT, SIG_DFL);
107
      kill (getpid (), SIGABRT);
108
#else
109
      signal (SIGQUIT, SIG_DFL);
110
      kill (getpid (), SIGQUIT);
111
#endif
112
    }
113
}
114
#endif
115
 
116
/* Stimulate the internal error mechanism that GDB uses when an
117
   internal problem is detected.  Allows testing of the mechanism.
118
   Also useful when the user wants to drop a core file but not exit
119
   GDB. */
120
 
121
static void
122
maintenance_internal_error (char *args, int from_tty)
123
{
124
  internal_error (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
125
}
126
 
127
/* Stimulate the internal error mechanism that GDB uses when an
128
   internal problem is detected.  Allows testing of the mechanism.
129
   Also useful when the user wants to drop a core file but not exit
130
   GDB. */
131
 
132
static void
133
maintenance_internal_warning (char *args, int from_tty)
134
{
135
  internal_warning (__FILE__, __LINE__, "%s", (args == NULL ? "" : args));
136
}
137
 
138
/* Someday we should allow demangling for things other than just
139
   explicit strings.  For example, we might want to be able to specify
140
   the address of a string in either GDB's process space or the
141
   debuggee's process space, and have gdb fetch and demangle that
142
   string.  If we have a char* pointer "ptr" that points to a string,
143
   we might want to be able to given just the name and have GDB
144
   demangle and print what it points to, etc.  (FIXME) */
145
 
146
static void
147
maintenance_demangle (char *args, int from_tty)
148
{
149
  char *demangled;
150
 
151
  if (args == NULL || *args == '\0')
152
    {
153
      printf_unfiltered (_("\"maintenance demangle\" takes an argument to demangle.\n"));
154
    }
155
  else
156
    {
157
      demangled = language_demangle (current_language, args,
158
                                     DMGL_ANSI | DMGL_PARAMS);
159
      if (demangled != NULL)
160
        {
161
          printf_unfiltered ("%s\n", demangled);
162
          xfree (demangled);
163
        }
164
      else
165
        {
166
          printf_unfiltered (_("Can't demangle \"%s\"\n"), args);
167
        }
168
    }
169
}
170
 
171
static void
172
maintenance_time_display (char *args, int from_tty)
173
{
174
  extern int display_time;
175
 
176
  if (args == NULL || *args == '\0')
177
    printf_unfiltered (_("\"maintenance time\" takes a numeric argument.\n"));
178
  else
179
    display_time = strtol (args, NULL, 10);
180
}
181
 
182
static void
183
maintenance_space_display (char *args, int from_tty)
184
{
185
  extern int display_space;
186
 
187
  if (args == NULL || *args == '\0')
188
    printf_unfiltered ("\"maintenance space\" takes a numeric argument.\n");
189
  else
190
    display_space = strtol (args, NULL, 10);
191
}
192
 
193
/* The "maintenance info" command is defined as a prefix, with
194
   allow_unknown 0.  Therefore, its own definition is called only for
195
   "maintenance info" with no args.  */
196
 
197
static void
198
maintenance_info_command (char *arg, int from_tty)
199
{
200
  printf_unfiltered (_("\"maintenance info\" must be followed by the name of an info command.\n"));
201
  help_list (maintenanceinfolist, "maintenance info ", -1, gdb_stdout);
202
}
203
 
204
/* Mini tokenizing lexer for 'maint info sections' command.  */
205
 
206
static int
207
match_substring (const char *string, const char *substr)
208
{
209
  int substr_len = strlen(substr);
210
  const char *tok;
211
 
212
  while ((tok = strstr (string, substr)) != NULL)
213
    {
214
      /* Got a partial match.  Is it a whole word? */
215
      if (tok == string
216
          || tok[-1] == ' '
217
          || tok[-1] == '\t')
218
      {
219
        /* Token is delimited at the front... */
220
        if (tok[substr_len] == ' '
221
            || tok[substr_len] == '\t'
222
            || tok[substr_len] == '\0')
223
        {
224
          /* Token is delimited at the rear.  Got a whole-word match.  */
225
          return 1;
226
        }
227
      }
228
      /* Token didn't match as a whole word.  Advance and try again.  */
229
      string = tok + 1;
230
    }
231
  return 0;
232
}
233
 
234
static int
235
match_bfd_flags (char *string, flagword flags)
236
{
237
  if (flags & SEC_ALLOC)
238
    if (match_substring (string, "ALLOC"))
239
      return 1;
240
  if (flags & SEC_LOAD)
241
    if (match_substring (string, "LOAD"))
242
      return 1;
243
  if (flags & SEC_RELOC)
244
    if (match_substring (string, "RELOC"))
245
      return 1;
246
  if (flags & SEC_READONLY)
247
    if (match_substring (string, "READONLY"))
248
      return 1;
249
  if (flags & SEC_CODE)
250
    if (match_substring (string, "CODE"))
251
      return 1;
252
  if (flags & SEC_DATA)
253
    if (match_substring (string, "DATA"))
254
      return 1;
255
  if (flags & SEC_ROM)
256
    if (match_substring (string, "ROM"))
257
      return 1;
258
  if (flags & SEC_CONSTRUCTOR)
259
    if (match_substring (string, "CONSTRUCTOR"))
260
      return 1;
261
  if (flags & SEC_HAS_CONTENTS)
262
    if (match_substring (string, "HAS_CONTENTS"))
263
      return 1;
264
  if (flags & SEC_NEVER_LOAD)
265
    if (match_substring (string, "NEVER_LOAD"))
266
      return 1;
267
  if (flags & SEC_COFF_SHARED_LIBRARY)
268
    if (match_substring (string, "COFF_SHARED_LIBRARY"))
269
      return 1;
270
  if (flags & SEC_IS_COMMON)
271
    if (match_substring (string, "IS_COMMON"))
272
      return 1;
273
 
274
  return 0;
275
}
276
 
277
static void
278
print_bfd_flags (flagword flags)
279
{
280
  if (flags & SEC_ALLOC)
281
    printf_filtered (" ALLOC");
282
  if (flags & SEC_LOAD)
283
    printf_filtered (" LOAD");
284
  if (flags & SEC_RELOC)
285
    printf_filtered (" RELOC");
286
  if (flags & SEC_READONLY)
287
    printf_filtered (" READONLY");
288
  if (flags & SEC_CODE)
289
    printf_filtered (" CODE");
290
  if (flags & SEC_DATA)
291
    printf_filtered (" DATA");
292
  if (flags & SEC_ROM)
293
    printf_filtered (" ROM");
294
  if (flags & SEC_CONSTRUCTOR)
295
    printf_filtered (" CONSTRUCTOR");
296
  if (flags & SEC_HAS_CONTENTS)
297
    printf_filtered (" HAS_CONTENTS");
298
  if (flags & SEC_NEVER_LOAD)
299
    printf_filtered (" NEVER_LOAD");
300
  if (flags & SEC_COFF_SHARED_LIBRARY)
301
    printf_filtered (" COFF_SHARED_LIBRARY");
302
  if (flags & SEC_IS_COMMON)
303
    printf_filtered (" IS_COMMON");
304
}
305
 
306
static void
307
maint_print_section_info (const char *name, flagword flags,
308
                          CORE_ADDR addr, CORE_ADDR endaddr,
309
                          unsigned long filepos, int addr_size)
310
{
311
  printf_filtered ("    %s", hex_string_custom (addr, addr_size));
312
  printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
313
  printf_filtered (" at %s",
314
                   hex_string_custom ((unsigned long) filepos, 8));
315
  printf_filtered (": %s", name);
316
  print_bfd_flags (flags);
317
  printf_filtered ("\n");
318
}
319
 
320
static void
321
print_bfd_section_info (bfd *abfd,
322
                        asection *asect,
323
                        void *arg)
324
{
325
  flagword flags = bfd_get_section_flags (abfd, asect);
326
  const char *name = bfd_section_name (abfd, asect);
327
 
328
  if (arg == NULL || *((char *) arg) == '\0'
329
      || match_substring ((char *) arg, name)
330
      || match_bfd_flags ((char *) arg, flags))
331
    {
332
      struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
333
      int addr_size = gdbarch_addr_bit (gdbarch) / 8;
334
      CORE_ADDR addr, endaddr;
335
 
336
      addr = bfd_section_vma (abfd, asect);
337
      endaddr = addr + bfd_section_size (abfd, asect);
338
      maint_print_section_info (name, flags, addr, endaddr,
339
                                asect->filepos, addr_size);
340
    }
341
}
342
 
343
static void
344
print_objfile_section_info (bfd *abfd,
345
                            struct obj_section *asect,
346
                            char *string)
347
{
348
  flagword flags = bfd_get_section_flags (abfd, asect->the_bfd_section);
349
  const char *name = bfd_section_name (abfd, asect->the_bfd_section);
350
 
351
  if (string == NULL || *string == '\0'
352
      || match_substring (string, name)
353
      || match_bfd_flags (string, flags))
354
    {
355
      struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
356
      int addr_size = gdbarch_addr_bit (gdbarch) / 8;
357
      maint_print_section_info (name, flags,
358
                                obj_section_addr (asect),
359
                                obj_section_endaddr (asect),
360
                                asect->the_bfd_section->filepos,
361
                                addr_size);
362
    }
363
}
364
 
365
static void
366
maintenance_info_sections (char *arg, int from_tty)
367
{
368
  if (exec_bfd)
369
    {
370
      printf_filtered (_("Exec file:\n"));
371
      printf_filtered ("    `%s', ", bfd_get_filename (exec_bfd));
372
      wrap_here ("        ");
373
      printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd));
374
      if (arg && *arg && match_substring (arg, "ALLOBJ"))
375
        {
376
          struct objfile *ofile;
377
          struct obj_section *osect;
378
 
379
          /* Only this function cares about the 'ALLOBJ' argument;
380
             if 'ALLOBJ' is the only argument, discard it rather than
381
             passing it down to print_objfile_section_info (which
382
             wouldn't know how to handle it).  */
383
          if (strcmp (arg, "ALLOBJ") == 0)
384
            arg = NULL;
385
 
386
          ALL_OBJFILES (ofile)
387
            {
388
              printf_filtered (_("  Object file: %s\n"),
389
                               bfd_get_filename (ofile->obfd));
390
              ALL_OBJFILE_OSECTIONS (ofile, osect)
391
                {
392
                  print_objfile_section_info (ofile->obfd, osect, arg);
393
                }
394
            }
395
        }
396
      else
397
        bfd_map_over_sections (exec_bfd, print_bfd_section_info, arg);
398
    }
399
 
400
  if (core_bfd)
401
    {
402
      printf_filtered (_("Core file:\n"));
403
      printf_filtered ("    `%s', ", bfd_get_filename (core_bfd));
404
      wrap_here ("        ");
405
      printf_filtered (_("file type %s.\n"), bfd_get_target (core_bfd));
406
      bfd_map_over_sections (core_bfd, print_bfd_section_info, arg);
407
    }
408
}
409
 
410
void
411
maintenance_print_statistics (char *args, int from_tty)
412
{
413
  print_objfile_statistics ();
414
  print_symbol_bcache_statistics ();
415
}
416
 
417
static void
418
maintenance_print_architecture (char *args, int from_tty)
419
{
420
  struct gdbarch *gdbarch = get_current_arch ();
421
 
422
  if (args == NULL)
423
    gdbarch_dump (gdbarch, gdb_stdout);
424
  else
425
    {
426
      struct cleanup *cleanups;
427
      struct ui_file *file = gdb_fopen (args, "w");
428
      if (file == NULL)
429
        perror_with_name (_("maintenance print architecture"));
430
      cleanups = make_cleanup_ui_file_delete (file);
431
      gdbarch_dump (gdbarch, file);
432
      do_cleanups (cleanups);
433
    }
434
}
435
 
436
/* The "maintenance print" command is defined as a prefix, with
437
   allow_unknown 0.  Therefore, its own definition is called only for
438
   "maintenance print" with no args.  */
439
 
440
static void
441
maintenance_print_command (char *arg, int from_tty)
442
{
443
  printf_unfiltered (_("\"maintenance print\" must be followed by the name of a print command.\n"));
444
  help_list (maintenanceprintlist, "maintenance print ", -1, gdb_stdout);
445
}
446
 
447
/* The "maintenance translate-address" command converts a section and address
448
   to a symbol.  This can be called in two ways:
449
   maintenance translate-address <secname> <addr>
450
   or   maintenance translate-address <addr>
451
 */
452
 
453
static void
454
maintenance_translate_address (char *arg, int from_tty)
455
{
456
  CORE_ADDR address;
457
  struct obj_section *sect;
458
  char *p;
459
  struct minimal_symbol *sym;
460
  struct objfile *objfile;
461
 
462
  if (arg == NULL || *arg == 0)
463
    error (_("requires argument (address or section + address)"));
464
 
465
  sect = NULL;
466
  p = arg;
467
 
468
  if (!isdigit (*p))
469
    {                           /* See if we have a valid section name */
470
      while (*p && !isspace (*p))       /* Find end of section name */
471
        p++;
472
      if (*p == '\000')         /* End of command? */
473
        error (_("Need to specify <section-name> and <address>"));
474
      *p++ = '\000';
475
      while (isspace (*p))
476
        p++;                    /* Skip whitespace */
477
 
478
      ALL_OBJSECTIONS (objfile, sect)
479
      {
480
        if (strcmp (sect->the_bfd_section->name, arg) == 0)
481
          break;
482
      }
483
 
484
      if (!objfile)
485
        error (_("Unknown section %s."), arg);
486
    }
487
 
488
  address = parse_and_eval_address (p);
489
 
490
  if (sect)
491
    sym = lookup_minimal_symbol_by_pc_section (address, sect);
492
  else
493
    sym = lookup_minimal_symbol_by_pc (address);
494
 
495
  if (sym)
496
    {
497
      const char *symbol_name = SYMBOL_PRINT_NAME (sym);
498
      const char *symbol_offset = pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
499
 
500
      sect = SYMBOL_OBJ_SECTION(sym);
501
      if (sect != NULL)
502
        {
503
          const char *section_name;
504
          const char *obj_name;
505
 
506
          gdb_assert (sect->the_bfd_section && sect->the_bfd_section->name);
507
          section_name = sect->the_bfd_section->name;
508
 
509
          gdb_assert (sect->objfile && sect->objfile->name);
510
          obj_name = sect->objfile->name;
511
 
512
          if (MULTI_OBJFILE_P ())
513
            printf_filtered (_("%s + %s in section %s of %s\n"),
514
                             symbol_name, symbol_offset, section_name, obj_name);
515
          else
516
            printf_filtered (_("%s + %s in section %s\n"),
517
                             symbol_name, symbol_offset, section_name);
518
        }
519
      else
520
        printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
521
    }
522
  else if (sect)
523
    printf_filtered (_("no symbol at %s:%s\n"),
524
                     sect->the_bfd_section->name, hex_string (address));
525
  else
526
    printf_filtered (_("no symbol at %s\n"), hex_string (address));
527
 
528
  return;
529
}
530
 
531
 
532
/* When a command is deprecated the user will be warned the first time
533
   the command is used.  If possible, a replacement will be
534
   offered. */
535
 
536
static void
537
maintenance_deprecate (char *args, int from_tty)
538
{
539
  if (args == NULL || *args == '\0')
540
    {
541
      printf_unfiltered (_("\"maintenance deprecate\" takes an argument, \n\
542
the command you want to deprecate, and optionally the replacement command \n\
543
enclosed in quotes.\n"));
544
    }
545
 
546
  maintenance_do_deprecate (args, 1);
547
 
548
}
549
 
550
 
551
static void
552
maintenance_undeprecate (char *args, int from_tty)
553
{
554
  if (args == NULL || *args == '\0')
555
    {
556
      printf_unfiltered (_("\"maintenance undeprecate\" takes an argument, \n\
557
the command you want to undeprecate.\n"));
558
    }
559
 
560
  maintenance_do_deprecate (args, 0);
561
 
562
}
563
 
564
/* You really shouldn't be using this. It is just for the testsuite.
565
   Rather, you should use deprecate_cmd() when the command is created
566
   in _initialize_blah().
567
 
568
   This function deprecates a command and optionally assigns it a
569
   replacement.  */
570
 
571
static void
572
maintenance_do_deprecate (char *text, int deprecate)
573
{
574
 
575
  struct cmd_list_element *alias = NULL;
576
  struct cmd_list_element *prefix_cmd = NULL;
577
  struct cmd_list_element *cmd = NULL;
578
 
579
  char *start_ptr = NULL;
580
  char *end_ptr = NULL;
581
  int len;
582
  char *replacement = NULL;
583
 
584
  if (text == NULL)
585
    return;
586
 
587
  if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
588
    {
589
      printf_filtered (_("Can't find command '%s' to deprecate.\n"), text);
590
      return;
591
    }
592
 
593
  if (deprecate)
594
    {
595
      /* look for a replacement command */
596
      start_ptr = strchr (text, '\"');
597
      if (start_ptr != NULL)
598
        {
599
          start_ptr++;
600
          end_ptr = strrchr (start_ptr, '\"');
601
          if (end_ptr != NULL)
602
            {
603
              len = end_ptr - start_ptr;
604
              start_ptr[len] = '\0';
605
              replacement = xstrdup (start_ptr);
606
            }
607
        }
608
    }
609
 
610
  if (!start_ptr || !end_ptr)
611
    replacement = NULL;
612
 
613
 
614
  /* If they used an alias, we only want to deprecate the alias.
615
 
616
     Note the MALLOCED_REPLACEMENT test.  If the command's replacement
617
     string was allocated at compile time we don't want to free the
618
     memory. */
619
  if (alias)
620
    {
621
 
622
      if (alias->flags & MALLOCED_REPLACEMENT)
623
        xfree (alias->replacement);
624
 
625
      if (deprecate)
626
        alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
627
      else
628
        alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
629
      alias->replacement = replacement;
630
      alias->flags |= MALLOCED_REPLACEMENT;
631
      return;
632
    }
633
  else if (cmd)
634
    {
635
      if (cmd->flags & MALLOCED_REPLACEMENT)
636
        xfree (cmd->replacement);
637
 
638
      if (deprecate)
639
        cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED);
640
      else
641
        cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED);
642
      cmd->replacement = replacement;
643
      cmd->flags |= MALLOCED_REPLACEMENT;
644
      return;
645
    }
646
}
647
 
648
/* Maintenance set/show framework.  */
649
 
650
struct cmd_list_element *maintenance_set_cmdlist;
651
struct cmd_list_element *maintenance_show_cmdlist;
652
 
653
static void
654
maintenance_set_cmd (char *args, int from_tty)
655
{
656
  printf_unfiltered (_("\"maintenance set\" must be followed by the name of a set command.\n"));
657
  help_list (maintenance_set_cmdlist, "maintenance set ", -1, gdb_stdout);
658
}
659
 
660
static void
661
maintenance_show_cmd (char *args, int from_tty)
662
{
663
  cmd_show_list (maintenance_show_cmdlist, from_tty, "");
664
}
665
 
666
/* Profiling support.  */
667
 
668
static int maintenance_profile_p;
669
static void
670
show_maintenance_profile_p (struct ui_file *file, int from_tty,
671
                            struct cmd_list_element *c, const char *value)
672
{
673
  fprintf_filtered (file, _("Internal profiling is %s.\n"), value);
674
}
675
 
676
#ifdef HAVE__ETEXT
677
extern char _etext;
678
#define TEXTEND &_etext
679
#elif defined (HAVE_ETEXT)
680
extern char etext;
681
#define TEXTEND &etext
682
#endif
683
 
684
#if defined (HAVE_MONSTARTUP) && defined (HAVE__MCLEANUP) && defined (TEXTEND)
685
 
686
static int profiling_state;
687
 
688
static void
689
mcleanup_wrapper (void)
690
{
691
  extern void _mcleanup (void);
692
 
693
  if (profiling_state)
694
    _mcleanup ();
695
}
696
 
697
static void
698
maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
699
{
700
  if (maintenance_profile_p == profiling_state)
701
    return;
702
 
703
  profiling_state = maintenance_profile_p;
704
 
705
  if (maintenance_profile_p)
706
    {
707
      static int profiling_initialized;
708
 
709
      extern void monstartup (unsigned long, unsigned long);
710
      extern int main();
711
 
712
      if (!profiling_initialized)
713
        {
714
          atexit (mcleanup_wrapper);
715
          profiling_initialized = 1;
716
        }
717
 
718
      /* "main" is now always the first function in the text segment, so use
719
         its address for monstartup.  */
720
      monstartup ((unsigned long) &main, (unsigned long) TEXTEND);
721
    }
722
  else
723
    {
724
      extern void _mcleanup (void);
725
      _mcleanup ();
726
    }
727
}
728
#else
729
static void
730
maintenance_set_profile_cmd (char *args, int from_tty, struct cmd_list_element *c)
731
{
732
  error (_("Profiling support is not available on this system."));
733
}
734
#endif
735
 
736
void
737
_initialize_maint_cmds (void)
738
{
739
  struct cmd_list_element *tmpcmd;
740
 
741
  add_prefix_cmd ("maintenance", class_maintenance, maintenance_command, _("\
742
Commands for use by GDB maintainers.\n\
743
Includes commands to dump specific internal GDB structures in\n\
744
a human readable form, to cause GDB to deliberately dump core,\n\
745
to test internal functions such as the C++/ObjC demangler, etc."),
746
                  &maintenancelist, "maintenance ", 0,
747
                  &cmdlist);
748
 
749
  add_com_alias ("mt", "maintenance", class_maintenance, 1);
750
 
751
  add_prefix_cmd ("info", class_maintenance, maintenance_info_command, _("\
752
Commands for showing internal info about the program being debugged."),
753
                  &maintenanceinfolist, "maintenance info ", 0,
754
                  &maintenancelist);
755
  add_alias_cmd ("i", "info", class_maintenance, 1, &maintenancelist);
756
 
757
  add_cmd ("sections", class_maintenance, maintenance_info_sections, _("\
758
List the BFD sections of the exec and core files. \n\
759
Arguments may be any combination of:\n\
760
        [one or more section names]\n\
761
        ALLOC LOAD RELOC READONLY CODE DATA ROM CONSTRUCTOR\n\
762
        HAS_CONTENTS NEVER_LOAD COFF_SHARED_LIBRARY IS_COMMON\n\
763
Sections matching any argument will be listed (no argument\n\
764
implies all sections).  In addition, the special argument\n\
765
        ALLOBJ\n\
766
lists all sections from all object files, including shared libraries."),
767
           &maintenanceinfolist);
768
 
769
  add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
770
                  _("Maintenance command for printing GDB internal state."),
771
                  &maintenanceprintlist, "maintenance print ", 0,
772
                  &maintenancelist);
773
 
774
  add_prefix_cmd ("set", class_maintenance, maintenance_set_cmd, _("\
775
Set GDB internal variables used by the GDB maintainer.\n\
776
Configure variables internal to GDB that aid in GDB's maintenance"),
777
                  &maintenance_set_cmdlist, "maintenance set ",
778
                  0/*allow-unknown*/,
779
                  &maintenancelist);
780
 
781
  add_prefix_cmd ("show", class_maintenance, maintenance_show_cmd, _("\
782
Show GDB internal variables used by the GDB maintainer.\n\
783
Configure variables internal to GDB that aid in GDB's maintenance"),
784
                  &maintenance_show_cmdlist, "maintenance show ",
785
                  0/*allow-unknown*/,
786
                  &maintenancelist);
787
 
788
#ifndef _WIN32
789
  add_cmd ("dump-me", class_maintenance, maintenance_dump_me, _("\
790
Get fatal error; make debugger dump its core.\n\
791
GDB sets its handling of SIGQUIT back to SIG_DFL and then sends\n\
792
itself a SIGQUIT signal."),
793
           &maintenancelist);
794
#endif
795
 
796
  add_cmd ("internal-error", class_maintenance,
797
           maintenance_internal_error, _("\
798
Give GDB an internal error.\n\
799
Cause GDB to behave as if an internal error was detected."),
800
           &maintenancelist);
801
 
802
  add_cmd ("internal-warning", class_maintenance,
803
           maintenance_internal_warning, _("\
804
Give GDB an internal warning.\n\
805
Cause GDB to behave as if an internal warning was reported."),
806
           &maintenancelist);
807
 
808
  add_cmd ("demangle", class_maintenance, maintenance_demangle, _("\
809
Demangle a C++/ObjC mangled name.\n\
810
Call internal GDB demangler routine to demangle a C++ link name\n\
811
and prints the result."),
812
           &maintenancelist);
813
 
814
  add_cmd ("time", class_maintenance, maintenance_time_display, _("\
815
Set the display of time usage.\n\
816
If nonzero, will cause the execution time for each command to be\n\
817
displayed, following the command's output."),
818
           &maintenancelist);
819
 
820
  add_cmd ("space", class_maintenance, maintenance_space_display, _("\
821
Set the display of space usage.\n\
822
If nonzero, will cause the execution space for each command to be\n\
823
displayed, following the command's output."),
824
           &maintenancelist);
825
 
826
  add_cmd ("type", class_maintenance, maintenance_print_type, _("\
827
Print a type chain for a given symbol.\n\
828
For each node in a type chain, print the raw data for each member of\n\
829
the type structure, and the interpretation of the data."),
830
           &maintenanceprintlist);
831
 
832
  add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
833
Print dump of current symbol definitions.\n\
834
Entries in the full symbol table are dumped to file OUTFILE.\n\
835
If a SOURCE file is specified, dump only that file's symbols."),
836
           &maintenanceprintlist);
837
 
838
  add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
839
Print dump of current minimal symbol definitions.\n\
840
Entries in the minimal symbol table are dumped to file OUTFILE.\n\
841
If a SOURCE file is specified, dump only that file's minimal symbols."),
842
           &maintenanceprintlist);
843
 
844
  add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
845
Print dump of current partial symbol definitions.\n\
846
Entries in the partial symbol table are dumped to file OUTFILE.\n\
847
If a SOURCE file is specified, dump only that file's partial symbols."),
848
           &maintenanceprintlist);
849
 
850
  add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
851
           _("Print dump of current object file definitions."),
852
           &maintenanceprintlist);
853
 
854
  add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
855
List the full symbol tables for all object files.\n\
856
This does not include information about individual symbols, blocks, or\n\
857
linetables --- just the symbol table structures themselves.\n\
858
With an argument REGEXP, list the symbol tables whose names that match that."),
859
           &maintenanceinfolist);
860
 
861
  add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
862
List the partial symbol tables for all object files.\n\
863
This does not include information about individual partial symbols,\n\
864
just the symbol table structures themselves."),
865
           &maintenanceinfolist);
866
 
867
  add_cmd ("statistics", class_maintenance, maintenance_print_statistics,
868
           _("Print statistics about internal gdb state."),
869
           &maintenanceprintlist);
870
 
871
  add_cmd ("architecture", class_maintenance,
872
           maintenance_print_architecture, _("\
873
Print the internal architecture configuration.\n\
874
Takes an optional file parameter."),
875
           &maintenanceprintlist);
876
 
877
  add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
878
           _("Check consistency of psymtabs and symtabs."),
879
           &maintenancelist);
880
 
881
  add_cmd ("translate-address", class_maintenance, maintenance_translate_address,
882
           _("Translate a section name and address to a symbol."),
883
           &maintenancelist);
884
 
885
  add_cmd ("deprecate", class_maintenance, maintenance_deprecate, _("\
886
Deprecate a command.  Note that this is just in here so the \n\
887
testsuite can check the command deprecator. You probably shouldn't use this,\n\
888
rather you should use the C function deprecate_cmd().  If you decide you \n\
889
want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\
890
replacement is optional."), &maintenancelist);
891
 
892
  add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, _("\
893
Undeprecate a command.  Note that this is just in here so the \n\
894
testsuite can check the command deprecator. You probably shouldn't use this,\n\
895
If you decide you want to use it: maintenance undeprecate 'commandname'"),
896
           &maintenancelist);
897
 
898
  add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
899
Set watchdog timer."), _("\
900
Show watchdog timer."), _("\
901
When non-zero, this timeout is used instead of waiting forever for a target\n\
902
to finish a low-level step or continue operation.  If the specified amount\n\
903
of time passes without a response from the target, an error occurs."),
904
                            NULL,
905
                            show_watchdog,
906
                            &setlist, &showlist);
907
 
908
  add_setshow_boolean_cmd ("profile", class_maintenance,
909
                           &maintenance_profile_p, _("\
910
Set internal profiling."), _("\
911
Show internal profiling."), _("\
912
When enabled GDB is profiled."),
913
                           maintenance_set_profile_cmd,
914
                           show_maintenance_profile_p,
915
                           &maintenance_set_cmdlist,
916
                           &maintenance_show_cmdlist);
917
}

powered by: WebSVN 2.1.0

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