[deliverable/binutils-gdb.git] / gdb / maint.c

/* Support for GDB maintenance commands.
   Copyright (C) 1992 Free Software Foundation, Inc.
   Written by Fred Fish at Cygnus Support.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */


#include "defs.h"

#if MAINTENANCE_CMDS	/* Entire file goes away if not including maint cmds */

#include <signal.h>
#include "command.h"
#include "gdbcmd.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "demangle.h"
#include "gdbcore.h"
#include "expression.h" /* For language.h */
#include "language.h"

static void
maintenance_command PARAMS ((char *, int));

static void
maintenance_dump_me PARAMS ((char *, int));

static void
maintenance_demangle PARAMS ((char *, int));

/*

LOCAL FUNCTION

	maintenance_command -- access the maintenance subcommands

SYNOPSIS

	void maintenance_command (char *args, int from_tty)

DESCRIPTION

*/

static void
maintenance_command (args, from_tty)
     char *args;
     int from_tty;
{
  printf ("\"maintenance\" must be followed by the name of a maintenance command.\n");
  help_list (maintenancelist, "maintenance ", -1, stdout);
}


/* ARGSUSED */
static void
maintenance_dump_me (args, from_tty)
     char *args;
     int from_tty;
{
  if (query ("Should GDB dump core? "))
    {
      signal (SIGQUIT, SIG_DFL);
      kill (getpid (), SIGQUIT);
    }
}

/*  Someday we should allow demangling for things other than just
    explicit strings.  For example, we might want to be able to
    specify the address of a string in either GDB's process space
    or the debuggee's process space, and have gdb fetch and demangle
    that string.  If we have a char* pointer "ptr" that points to
    a string, we might want to be able to given just the name and
    have GDB demangle and print what it points to, etc.  (FIXME) */

static void
maintenance_demangle (args, from_tty)
     char *args;
     int from_tty;
{
  char *demangled;

  if (args == NULL || *args == '\0')
    {
      printf ("\"maintenance demangle\" takes an argument to demangle.\n");
    }
  else
    {
      demangled = cplus_demangle (args, DMGL_ANSI | DMGL_PARAMS);
      if (demangled != NULL)
	{
	  printf ("%s\n", demangled);
	  free (demangled);
	}
      else
	{
	  printf ("Can't demangle \"%s\"\n", args);
	}
    }
}

/* The "maintenance info" command is defined as a prefix, with allow_unknown 0.
   Therefore, its own definition is called only for "maintenance info" with
   no args.  */

/* ARGSUSED */
static void
maintenance_info_command (arg, from_tty)
     char *arg;
     int from_tty;
{
  printf ("\"maintenance info\" must be followed by the name of an info command.\n");
  help_list (maintenanceinfolist, "maintenance info ", -1, stdout);
}

static void
print_section_table (abfd, asect, ignore)
     bfd *abfd;
     asection *asect;
     PTR ignore;
{
  flagword flags;

  flags = bfd_get_section_flags (abfd, asect);

  printf_filtered ("    %s",
		   local_hex_string_custom
		     ((unsigned long) bfd_section_vma (abfd, asect), "08l"));
  printf_filtered ("->%s",
		   local_hex_string_custom
		     ((unsigned long) (bfd_section_vma (abfd, asect)
				       + bfd_section_size (abfd, asect)),
		      "08l"));
  printf_filtered (" at %s",
		   local_hex_string_custom
		     ((unsigned long) asect->filepos, "08l"));
  printf_filtered (": %s", bfd_section_name (abfd, asect));

  if (flags & SEC_ALLOC)
    printf_filtered (" ALLOC");
  if (flags & SEC_LOAD)
    printf_filtered (" LOAD");
  if (flags & SEC_RELOC)
    printf_filtered (" RELOC");
  if (flags & SEC_READONLY)
    printf_filtered (" READONLY");
  if (flags & SEC_CODE)
    printf_filtered (" CODE");
  if (flags & SEC_DATA)
    printf_filtered (" DATA");
  if (flags & SEC_ROM)
    printf_filtered (" ROM");
  if (flags & SEC_CONSTRUCTOR)
    printf_filtered (" CONSTRUCTOR");
  if (flags & SEC_HAS_CONTENTS)
    printf_filtered (" HAS_CONTENTS");
  if (flags & SEC_NEVER_LOAD)
    printf_filtered (" NEVER_LOAD");
  if (flags & SEC_SHARED_LIBRARY)
    printf_filtered (" SHARED_LIBRARY");
  if (flags & SEC_IS_COMMON)
    printf_filtered (" IS_COMMON");

  printf_filtered ("\n");
}

/* ARGSUSED */
static void
maintenance_info_sections (arg, from_tty)
     char *arg;
     int from_tty;
{
  if (exec_bfd)
    {
      printf_filtered ("Exec file:\n");
      printf_filtered ("    `%s', ", bfd_get_filename(exec_bfd));
      wrap_here ("        ");
      printf_filtered ("file type %s.\n", bfd_get_target(exec_bfd));
      bfd_map_over_sections(exec_bfd, print_section_table, 0);
    }

  if (core_bfd)
    {
      printf_filtered ("Core file:\n");
      printf_filtered ("    `%s', ", bfd_get_filename(core_bfd));
      wrap_here ("        ");
      printf_filtered ("file type %s.\n", bfd_get_target(core_bfd));
      bfd_map_over_sections(core_bfd, print_section_table, 0);
    }
}

/* The "maintenance print" command is defined as a prefix, with allow_unknown
   0.  Therefore, its own definition is called only for "maintenance print"
   with no args.  */

/* ARGSUSED */
static void
maintenance_print_command (arg, from_tty)
     char *arg;
     int from_tty;
{
  printf ("\"maintenance print\" must be followed by the name of a print command.\n");
  help_list (maintenanceprintlist, "maintenance print ", -1, stdout);
}

#endif	/* MAINTENANCE_CMDS */

void
_initialize_maint_cmds ()
{
#if MAINTENANCE_CMDS	/* Entire file goes away if not including maint cmds */
  add_prefix_cmd ("maintenance", class_maintenance, maintenance_command,
		  "Commands for use by GDB maintainers.\n\
Includes commands to dump specific internal GDB structures in\n\
a human readable form, to cause GDB to deliberately dump core,\n\
to test internal functions such as the C++ demangler, etc.",
		  &maintenancelist, "maintenance ", 0,
		  &cmdlist);

  add_com_alias ("mt", "maintenance", class_maintenance, 1);

  add_prefix_cmd ("info", class_maintenance, maintenance_info_command,
		  "Commands for showing internal info about the program being debugged.",
		  &maintenanceinfolist, "maintenance info ", 0,
		  &maintenancelist);

  add_cmd ("sections", class_maintenance, maintenance_info_sections,
	   "List the BFD sections of the exec and core files.",
	   &maintenanceinfolist);

  add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
		  "Maintenance command for printing GDB internal state.",
		  &maintenanceprintlist, "maintenance print ", 0,
		  &maintenancelist);

  add_cmd ("dump-me", class_maintenance, maintenance_dump_me,
	   "Get fatal error; make debugger dump its core.\n\
GDB sets it's handling of SIGQUIT back to SIG_DFL and then sends\n\
itself a SIGQUIT signal.",
	   &maintenancelist);

  add_cmd ("demangle", class_maintenance, maintenance_demangle,
	   "Demangle a C++ mangled name.\n\
Call internal GDB demangler routine to demangle a C++ link name\n\
and prints the result.",
	   &maintenancelist);

  add_cmd ("type", class_maintenance, maintenance_print_type,
	   "Print a type chain for a given symbol.\n\
For each node in a type chain, print the raw data for each member of\n\
the type structure, and the interpretation of the data.",
	   &maintenanceprintlist);

  add_cmd ("symbols", class_maintenance, maintenance_print_symbols,
	   "Print dump of current symbol definitions.\n\
Entries in the full symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's symbols.",
	   &maintenanceprintlist);

  add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols,
	   "Print dump of current minimal symbol definitions.\n\
Entries in the minimal symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's minimal symbols.",
	   &maintenanceprintlist);

  add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols,
	   "Print dump of current partial symbol definitions.\n\
Entries in the partial symbol table are dumped to file OUTFILE.\n\
If a SOURCE file is specified, dump only that file's partial symbols.",
	   &maintenanceprintlist);

  add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
	   "Print dump of current object file definitions.",
	   &maintenanceprintlist);
#endif	/* MAINTENANCE_CMDS */
}
Commit	Line	Data
0239d9b3 FF	1	/* Support for GDB maintenance commands.
	2	Copyright (C) 1992 Free Software Foundation, Inc.
	3	Written by Fred Fish at Cygnus Support.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21
	22	#include "defs.h"
	23
	24	#if MAINTENANCE_CMDS /* Entire file goes away if not including maint cmds */
	25
	26	#include <signal.h>
	27	#include "command.h"
	28	#include "gdbcmd.h"
	29	#include "symtab.h"
	30	#include "gdbtypes.h"
311592ff	31	#include "demangle.h"
b1eaba9a	32	#include "gdbcore.h"
100f92e2 JK	33	#include "expression.h" /* For language.h */
100f92e2 JK	34	#include "language.h"
0239d9b3 FF	35
	36	static void
	37	maintenance_command PARAMS ((char *, int));
	38
	39	static void
	40	maintenance_dump_me PARAMS ((char *, int));
	41
311592ff FF	42	static void
	43	maintenance_demangle PARAMS ((char *, int));
	44
0239d9b3 FF	45	/*
	46
	47	LOCAL FUNCTION
	48
	49	maintenance_command -- access the maintenance subcommands
	50
	51	SYNOPSIS
	52
	53	void maintenance_command (char *args, int from_tty)
	54
	55	DESCRIPTION
	56
	57	*/
	58
	59	static void
	60	maintenance_command (args, from_tty)
	61	char *args;
	62	int from_tty;
	63	{
2e9309df FF	64	printf ("\"maintenance\" must be followed by the name of a maintenance command.\n");
2e9309df FF	65	help_list (maintenancelist, "maintenance ", -1, stdout);
0239d9b3 FF	66	}
	67
	68
	69	/* ARGSUSED */
	70	static void
	71	maintenance_dump_me (args, from_tty)
	72	char *args;
	73	int from_tty;
	74	{
	75	if (query ("Should GDB dump core? "))
	76	{
	77	signal (SIGQUIT, SIG_DFL);
	78	kill (getpid (), SIGQUIT);
	79	}
	80	}
	81
311592ff FF	82	/* Someday we should allow demangling for things other than just
	83	explicit strings. For example, we might want to be able to
	84	specify the address of a string in either GDB's process space
	85	or the debuggee's process space, and have gdb fetch and demangle
	86	that string. If we have a char* pointer "ptr" that points to
	87	a string, we might want to be able to given just the name and
	88	have GDB demangle and print what it points to, etc. (FIXME) */
	89
	90	static void
	91	maintenance_demangle (args, from_tty)
	92	char *args;
	93	int from_tty;
	94	{
	95	char *demangled;
	96
	97	if (args == NULL \|\| *args == '\0')
	98	{
	99	printf ("\"maintenance demangle\" takes an argument to demangle.\n");
	100	}
	101	else
	102	{
	103	demangled = cplus_demangle (args, DMGL_ANSI \| DMGL_PARAMS);
	104	if (demangled != NULL)
	105	{
	106	printf ("%s\n", demangled);
	107	free (demangled);
	108	}
	109	else
	110	{
	111	printf ("Can't demangle \"%s\"\n", args);
	112	}
	113	}
	114	}
	115
0239d9b3 FF	116	/* The "maintenance info" command is defined as a prefix, with allow_unknown 0.
	117	Therefore, its own definition is called only for "maintenance info" with
	118	no args. */
	119
	120	/* ARGSUSED */
	121	static void
	122	maintenance_info_command (arg, from_tty)
	123	char *arg;
	124	int from_tty;
	125	{
	126	printf ("\"maintenance info\" must be followed by the name of an info command.\n");
	127	help_list (maintenanceinfolist, "maintenance info ", -1, stdout);
	128	}
	129
b1eaba9a SG	130	static void
	131	print_section_table (abfd, asect, ignore)
	132	bfd *abfd;
	133	asection *asect;
	134	PTR ignore;
	135	{
	136	flagword flags;
	137
	138	flags = bfd_get_section_flags (abfd, asect);
	139
	140	printf_filtered (" %s",
5573d7d4 JK	141	local_hex_string_custom
5573d7d4 JK	142	((unsigned long) bfd_section_vma (abfd, asect), "08l"));
b1eaba9a	143	printf_filtered ("->%s",
5573d7d4 JK	144	local_hex_string_custom
	145	((unsigned long) (bfd_section_vma (abfd, asect)
	146	+ bfd_section_size (abfd, asect)),
	147	"08l"));
	148	printf_filtered (" at %s",
	149	local_hex_string_custom
	150	((unsigned long) asect->filepos, "08l"));
b1eaba9a SG	151	printf_filtered (": %s", bfd_section_name (abfd, asect));
	152
	153	if (flags & SEC_ALLOC)
	154	printf_filtered (" ALLOC");
	155	if (flags & SEC_LOAD)
	156	printf_filtered (" LOAD");
	157	if (flags & SEC_RELOC)
	158	printf_filtered (" RELOC");
	159	if (flags & SEC_READONLY)
	160	printf_filtered (" READONLY");
	161	if (flags & SEC_CODE)
	162	printf_filtered (" CODE");
	163	if (flags & SEC_DATA)
	164	printf_filtered (" DATA");
	165	if (flags & SEC_ROM)
	166	printf_filtered (" ROM");
	167	if (flags & SEC_CONSTRUCTOR)
	168	printf_filtered (" CONSTRUCTOR");
	169	if (flags & SEC_HAS_CONTENTS)
	170	printf_filtered (" HAS_CONTENTS");
	171	if (flags & SEC_NEVER_LOAD)
	172	printf_filtered (" NEVER_LOAD");
	173	if (flags & SEC_SHARED_LIBRARY)
	174	printf_filtered (" SHARED_LIBRARY");
	175	if (flags & SEC_IS_COMMON)
	176	printf_filtered (" IS_COMMON");
	177
	178	printf_filtered ("\n");
	179	}
	180
	181	/* ARGSUSED */
	182	static void
	183	maintenance_info_sections (arg, from_tty)
	184	char *arg;
	185	int from_tty;
	186	{
	187	if (exec_bfd)
	188	{
	189	printf_filtered ("Exec file:\n");
	190	printf_filtered (" `%s', ", bfd_get_filename(exec_bfd));
	191	wrap_here (" ");
	192	printf_filtered ("file type %s.\n", bfd_get_target(exec_bfd));
	193	bfd_map_over_sections(exec_bfd, print_section_table, 0);
	194	}
	195
	196	if (core_bfd)
	197	{
	198	printf_filtered ("Core file:\n");
	199	printf_filtered (" `%s', ", bfd_get_filename(core_bfd));
	200	wrap_here (" ");
	201	printf_filtered ("file type %s.\n", bfd_get_target(core_bfd));
	202	bfd_map_over_sections(core_bfd, print_section_table, 0);
	203	}
	204	}
	205
311592ff FF	206	/* The "maintenance print" command is defined as a prefix, with allow_unknown
	207	0. Therefore, its own definition is called only for "maintenance print"
	208	with no args. */
	209
	210	/* ARGSUSED */
	211	static void
	212	maintenance_print_command (arg, from_tty)
	213	char *arg;
	214	int from_tty;
	215	{
	216	printf ("\"maintenance print\" must be followed by the name of a print command.\n");
	217	help_list (maintenanceprintlist, "maintenance print ", -1, stdout);
	218	}
	219
976bb0be	220	#endif /* MAINTENANCE_CMDS */
0239d9b3 FF	221
	222	void
	223	_initialize_maint_cmds ()
	224	{
976bb0be	225	#if MAINTENANCE_CMDS /* Entire file goes away if not including maint cmds */
0239d9b3 FF	226	add_prefix_cmd ("maintenance", class_maintenance, maintenance_command,
	227	"Commands for use by GDB maintainers.\n\
	228	Includes commands to dump specific internal GDB structures in\n\
311592ff FF	229	a human readable form, to cause GDB to deliberately dump core,\n\
311592ff FF	230	to test internal functions such as the C++ demangler, etc.",
2e9309df	231	&maintenancelist, "maintenance ", 0,
0239d9b3 FF	232	&cmdlist);
0239d9b3 FF	233
327f7197	234	add_com_alias ("mt", "maintenance", class_maintenance, 1);
311592ff	235
327f7197 JG	236	add_prefix_cmd ("info", class_maintenance, maintenance_info_command,
327f7197 JG	237	"Commands for showing internal info about the program being debugged.",
2e9309df	238	&maintenanceinfolist, "maintenance info ", 0,
0239d9b3 FF	239	&maintenancelist);
0239d9b3 FF	240
b1eaba9a SG	241	add_cmd ("sections", class_maintenance, maintenance_info_sections,
	242	"List the BFD sections of the exec and core files.",
	243	&maintenanceinfolist);
	244
311592ff FF	245	add_prefix_cmd ("print", class_maintenance, maintenance_print_command,
	246	"Maintenance command for printing GDB internal state.",
	247	&maintenanceprintlist, "maintenance print ", 0,
	248	&maintenancelist);
	249
0239d9b3 FF	250	add_cmd ("dump-me", class_maintenance, maintenance_dump_me,
	251	"Get fatal error; make debugger dump its core.\n\
	252	GDB sets it's handling of SIGQUIT back to SIG_DFL and then sends\n\
	253	itself a SIGQUIT signal.",
	254	&maintenancelist);
	255
311592ff FF	256	add_cmd ("demangle", class_maintenance, maintenance_demangle,
	257	"Demangle a C++ mangled name.\n\
	258	Call internal GDB demangler routine to demangle a C++ link name\n\
	259	and prints the result.",
	260	&maintenancelist);
	261
	262	add_cmd ("type", class_maintenance, maintenance_print_type,
0239d9b3 FF	263	"Print a type chain for a given symbol.\n\
	264	For each node in a type chain, print the raw data for each member of\n\
	265	the type structure, and the interpretation of the data.",
311592ff	266	&maintenanceprintlist);
0239d9b3	267
311592ff	268	add_cmd ("symbols", class_maintenance, maintenance_print_symbols,
0239d9b3 FF	269	"Print dump of current symbol definitions.\n\
	270	Entries in the full symbol table are dumped to file OUTFILE.\n\
	271	If a SOURCE file is specified, dump only that file's symbols.",
311592ff	272	&maintenanceprintlist);
0239d9b3	273
311592ff	274	add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols,
0239d9b3 FF	275	"Print dump of current minimal symbol definitions.\n\
	276	Entries in the minimal symbol table are dumped to file OUTFILE.\n\
	277	If a SOURCE file is specified, dump only that file's minimal symbols.",
311592ff	278	&maintenanceprintlist);
0239d9b3	279
311592ff	280	add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols,
0239d9b3 FF	281	"Print dump of current partial symbol definitions.\n\
	282	Entries in the partial symbol table are dumped to file OUTFILE.\n\
	283	If a SOURCE file is specified, dump only that file's partial symbols.",
311592ff	284	&maintenanceprintlist);
0239d9b3	285
311592ff	286	add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
0239d9b3	287	"Print dump of current object file definitions.",
311592ff	288	&maintenanceprintlist);
0239d9b3	289	#endif /* MAINTENANCE_CMDS */
976bb0be	290	}