[deliverable/binutils-gdb.git] / gdb / cp-abi.c

/* Generic code for supporting multiple C++ ABI's

   Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   Free Software Foundation, Inc.

   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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "value.h"
#include "cp-abi.h"
#include "command.h"
#include "exceptions.h"
#include "gdbcmd.h"
#include "ui-out.h"
#include "gdb_assert.h"
#include "gdb_string.h"

static struct cp_abi_ops *find_cp_abi (const char *short_name);

static struct cp_abi_ops current_cp_abi = { "", NULL };
static struct cp_abi_ops auto_cp_abi = { "auto", NULL };

#define CP_ABI_MAX 8
static struct cp_abi_ops *cp_abis[CP_ABI_MAX];
static int num_cp_abis = 0;

enum ctor_kinds
is_constructor_name (const char *name)
{
  if ((current_cp_abi.is_constructor_name) == NULL)
    error (_("ABI doesn't define required function is_constructor_name"));
  return (*current_cp_abi.is_constructor_name) (name);
}

enum dtor_kinds
is_destructor_name (const char *name)
{
  if ((current_cp_abi.is_destructor_name) == NULL)
    error (_("ABI doesn't define required function is_destructor_name"));
  return (*current_cp_abi.is_destructor_name) (name);
}

int
is_vtable_name (const char *name)
{
  if ((current_cp_abi.is_vtable_name) == NULL)
    error (_("ABI doesn't define required function is_vtable_name"));
  return (*current_cp_abi.is_vtable_name) (name);
}

int
is_operator_name (const char *name)
{
  if ((current_cp_abi.is_operator_name) == NULL)
    error (_("ABI doesn't define required function is_operator_name"));
  return (*current_cp_abi.is_operator_name) (name);
}

int
baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
		  int embedded_offset, CORE_ADDR address,
		  const struct value *val)
{
  volatile struct gdb_exception ex;
  int res = 0;

  gdb_assert (current_cp_abi.baseclass_offset != NULL);

  TRY_CATCH (ex, RETURN_MASK_ERROR)
    {
      res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
						embedded_offset,
						address, val);
    }

  if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
    throw_error (NOT_AVAILABLE_ERROR,
		 _("Cannot determine virtual baseclass offset "
		   "of incomplete object"));
  else if (ex.reason < 0)
    throw_exception (ex);
  else
    return res;
}

struct value *
value_virtual_fn_field (struct value **arg1p,
			struct fn_field *f, int j,
			struct type *type, int offset)
{
  if ((current_cp_abi.virtual_fn_field) == NULL)
    return NULL;
  return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
					     type, offset);
}

struct type *
value_rtti_type (struct value *v, int *full,
		 int *top, int *using_enc)
{
  struct type *ret = NULL;
  struct gdb_exception e;

  if ((current_cp_abi.rtti_type) == NULL)
    return NULL;
  TRY_CATCH (e, RETURN_MASK_ERROR)
    {
      ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
    }
  if (e.reason < 0)
    return NULL;
  return ret;
}

void
cplus_print_method_ptr (const gdb_byte *contents,
			struct type *type,
			struct ui_file *stream)
{
  if (current_cp_abi.print_method_ptr == NULL)
    error (_("GDB does not support pointers to methods on this target"));
  (*current_cp_abi.print_method_ptr) (contents, type, stream);
}

int
cplus_method_ptr_size (struct type *to_type)
{
  if (current_cp_abi.method_ptr_size == NULL)
    error (_("GDB does not support pointers to methods on this target"));
  return (*current_cp_abi.method_ptr_size) (to_type);
}

void
cplus_make_method_ptr (struct type *type, gdb_byte *contents,
		       CORE_ADDR value, int is_virtual)
{
  if (current_cp_abi.make_method_ptr == NULL)
    error (_("GDB does not support pointers to methods on this target"));
  (*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual);
}

CORE_ADDR
cplus_skip_trampoline (struct frame_info *frame,
		       CORE_ADDR stop_pc)
{
  if (current_cp_abi.skip_trampoline == NULL)
    return 0;
  return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
}

struct value *
cplus_method_ptr_to_value (struct value **this_p,
			   struct value *method_ptr)
{
  if (current_cp_abi.method_ptr_to_value == NULL)
    error (_("GDB does not support pointers to methods on this target"));
  return (*current_cp_abi.method_ptr_to_value) (this_p, method_ptr);
}

int
cp_pass_by_reference (struct type *type)
{
  if ((current_cp_abi.pass_by_reference) == NULL)
    return 0;
  return (*current_cp_abi.pass_by_reference) (type);
}

/* Set the current C++ ABI to SHORT_NAME.  */

static int
switch_to_cp_abi (const char *short_name)
{
  struct cp_abi_ops *abi;

  abi = find_cp_abi (short_name);
  if (abi == NULL)
    return 0;

  current_cp_abi = *abi;
  return 1;
}

/* Add ABI to the list of supported C++ ABI's.  */

int
register_cp_abi (struct cp_abi_ops *abi)
{
  if (num_cp_abis == CP_ABI_MAX)
    internal_error (__FILE__, __LINE__,
		    _("Too many C++ ABIs, please increase "
		      "CP_ABI_MAX in cp-abi.c"));

  cp_abis[num_cp_abis++] = abi;

  return 1;
}

/* Set the ABI to use in "auto" mode to SHORT_NAME.  */

void
set_cp_abi_as_auto_default (const char *short_name)
{
  char *new_longname, *new_doc;
  struct cp_abi_ops *abi = find_cp_abi (short_name);

  if (abi == NULL)
    internal_error (__FILE__, __LINE__,
		    _("Cannot find C++ ABI \"%s\" to set it as auto default."),
		    short_name);

  if (auto_cp_abi.longname != NULL)
    xfree ((char *) auto_cp_abi.longname);
  if (auto_cp_abi.doc != NULL)
    xfree ((char *) auto_cp_abi.doc);

  auto_cp_abi = *abi;

  auto_cp_abi.shortname = "auto";
  new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
  auto_cp_abi.longname = new_longname;

  new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
	     abi->shortname);
  auto_cp_abi.doc = new_doc;

  /* Since we copy the current ABI into current_cp_abi instead of
     using a pointer, if auto is currently the default, we need to
     reset it.  */
  if (strcmp (current_cp_abi.shortname, "auto") == 0)
    switch_to_cp_abi ("auto");
}

/* Return the ABI operations associated with SHORT_NAME.  */

static struct cp_abi_ops *
find_cp_abi (const char *short_name)
{
  int i;

  for (i = 0; i < num_cp_abis; i++)
    if (strcmp (cp_abis[i]->shortname, short_name) == 0)
      return cp_abis[i];

  return NULL;
}

/* Display the list of registered C++ ABIs.  */

static void
list_cp_abis (int from_tty)
{
  struct cleanup *cleanup_chain;
  int i;

  ui_out_text (uiout, "The available C++ ABIs are:\n");
  cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
						       "cp-abi-list");
  for (i = 0; i < num_cp_abis; i++)
    {
      char pad[14];
      int padcount;

      ui_out_text (uiout, "  ");
      ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);

      padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
      pad[padcount] = 0;
      while (padcount > 0)
	pad[--padcount] = ' ';
      ui_out_text (uiout, pad);

      ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
      ui_out_text (uiout, "\n");
    }
  do_cleanups (cleanup_chain);
}

/* Set the current C++ ABI, or display the list of options if no
   argument is given.  */

static void
set_cp_abi_cmd (char *args, int from_tty)
{
  if (args == NULL)
    {
      list_cp_abis (from_tty);
      return;
    }

  if (!switch_to_cp_abi (args))
    error (_("Could not find \"%s\" in ABI list"), args);
}

/* Show the currently selected C++ ABI.  */

static void
show_cp_abi_cmd (char *args, int from_tty)
{
  ui_out_text (uiout, "The currently selected C++ ABI is \"");

  ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
  ui_out_text (uiout, "\" (");
  ui_out_field_string (uiout, "longname", current_cp_abi.longname);
  ui_out_text (uiout, ").\n");
}

extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */

void
_initialize_cp_abi (void)
{
  register_cp_abi (&auto_cp_abi);
  switch_to_cp_abi ("auto");

  add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
Set the ABI used for inspecting C++ objects.\n\
\"set cp-abi\" with no arguments will list the available ABIs."),
	   &setlist);

  add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
	   _("Show the ABI used for inspecting C++ objects."),
	   &showlist);
}
Commit	Line	Data
	1	/* Generic code for supporting multiple C++ ABI's
	2
	3	Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
	4	Free Software Foundation, Inc.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	20
	21	#include "defs.h"
	22	#include "value.h"
	23	#include "cp-abi.h"
	24	#include "command.h"
	25	#include "exceptions.h"
	26	#include "gdbcmd.h"
	27	#include "ui-out.h"
	28	#include "gdb_assert.h"
	29	#include "gdb_string.h"
	30
	31	static struct cp_abi_ops find_cp_abi (const char short_name);
	32
	33	static struct cp_abi_ops current_cp_abi = { "", NULL };
	34	static struct cp_abi_ops auto_cp_abi = { "auto", NULL };
	35
	36	#define CP_ABI_MAX 8
	37	static struct cp_abi_ops *cp_abis[CP_ABI_MAX];
	38	static int num_cp_abis = 0;
	39
	40	enum ctor_kinds
	41	is_constructor_name (const char *name)
	42	{
	43	if ((current_cp_abi.is_constructor_name) == NULL)
	44	error (_("ABI doesn't define required function is_constructor_name"));
	45	return (*current_cp_abi.is_constructor_name) (name);
	46	}
	47
	48	enum dtor_kinds
	49	is_destructor_name (const char *name)
	50	{
	51	if ((current_cp_abi.is_destructor_name) == NULL)
	52	error (_("ABI doesn't define required function is_destructor_name"));
	53	return (*current_cp_abi.is_destructor_name) (name);
	54	}
	55
	56	int
	57	is_vtable_name (const char *name)
	58	{
	59	if ((current_cp_abi.is_vtable_name) == NULL)
	60	error (_("ABI doesn't define required function is_vtable_name"));
	61	return (*current_cp_abi.is_vtable_name) (name);
	62	}
	63
	64	int
	65	is_operator_name (const char *name)
	66	{
	67	if ((current_cp_abi.is_operator_name) == NULL)
	68	error (_("ABI doesn't define required function is_operator_name"));
	69	return (*current_cp_abi.is_operator_name) (name);
	70	}
	71
	72	int
	73	baseclass_offset (struct type type, int index, const gdb_byte valaddr,
	74	int embedded_offset, CORE_ADDR address,
	75	const struct value *val)
	76	{
	77	volatile struct gdb_exception ex;
	78	int res = 0;
	79
	80	gdb_assert (current_cp_abi.baseclass_offset != NULL);
	81
	82	TRY_CATCH (ex, RETURN_MASK_ERROR)
	83	{
	84	res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
	85	embedded_offset,
	86	address, val);
	87	}
	88
	89	if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
	90	throw_error (NOT_AVAILABLE_ERROR,
	91	_("Cannot determine virtual baseclass offset "
	92	"of incomplete object"));
	93	else if (ex.reason < 0)
	94	throw_exception (ex);
	95	else
	96	return res;
	97	}
	98
	99	struct value *
	100	value_virtual_fn_field (struct value **arg1p,
	101	struct fn_field *f, int j,
	102	struct type *type, int offset)
	103	{
	104	if ((current_cp_abi.virtual_fn_field) == NULL)
	105	return NULL;
	106	return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
	107	type, offset);
	108	}
	109
	110	struct type *
	111	value_rtti_type (struct value v, int full,
	112	int top, int using_enc)
	113	{
	114	struct type *ret = NULL;
	115	struct gdb_exception e;
	116
	117	if ((current_cp_abi.rtti_type) == NULL)
	118	return NULL;
	119	TRY_CATCH (e, RETURN_MASK_ERROR)
	120	{
	121	ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
	122	}
	123	if (e.reason < 0)
	124	return NULL;
	125	return ret;
	126	}
	127
	128	void
	129	cplus_print_method_ptr (const gdb_byte *contents,
	130	struct type *type,
	131	struct ui_file *stream)
	132	{
	133	if (current_cp_abi.print_method_ptr == NULL)
	134	error (_("GDB does not support pointers to methods on this target"));
	135	(*current_cp_abi.print_method_ptr) (contents, type, stream);
	136	}
	137
	138	int
	139	cplus_method_ptr_size (struct type *to_type)
	140	{
	141	if (current_cp_abi.method_ptr_size == NULL)
	142	error (_("GDB does not support pointers to methods on this target"));
	143	return (*current_cp_abi.method_ptr_size) (to_type);
	144	}
	145
	146	void
	147	cplus_make_method_ptr (struct type type, gdb_byte contents,
	148	CORE_ADDR value, int is_virtual)
	149	{
	150	if (current_cp_abi.make_method_ptr == NULL)
	151	error (_("GDB does not support pointers to methods on this target"));
	152	(*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual);
	153	}
	154
	155	CORE_ADDR
	156	cplus_skip_trampoline (struct frame_info *frame,
	157	CORE_ADDR stop_pc)
	158	{
	159	if (current_cp_abi.skip_trampoline == NULL)
	160	return 0;
	161	return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
	162	}
	163
	164	struct value *
	165	cplus_method_ptr_to_value (struct value **this_p,
	166	struct value *method_ptr)
	167	{
	168	if (current_cp_abi.method_ptr_to_value == NULL)
	169	error (_("GDB does not support pointers to methods on this target"));
	170	return (*current_cp_abi.method_ptr_to_value) (this_p, method_ptr);
	171	}
	172
	173	int
	174	cp_pass_by_reference (struct type *type)
	175	{
	176	if ((current_cp_abi.pass_by_reference) == NULL)
	177	return 0;
	178	return (*current_cp_abi.pass_by_reference) (type);
	179	}
	180
	181	/* Set the current C++ ABI to SHORT_NAME. */
	182
	183	static int
	184	switch_to_cp_abi (const char *short_name)
	185	{
	186	struct cp_abi_ops *abi;
	187
	188	abi = find_cp_abi (short_name);
	189	if (abi == NULL)
	190	return 0;
	191
	192	current_cp_abi = *abi;
	193	return 1;
	194	}
	195
	196	/* Add ABI to the list of supported C++ ABI's. */
	197
	198	int
	199	register_cp_abi (struct cp_abi_ops *abi)
	200	{
	201	if (num_cp_abis == CP_ABI_MAX)
	202	internal_error (__FILE__, __LINE__,
	203	_("Too many C++ ABIs, please increase "
	204	"CP_ABI_MAX in cp-abi.c"));
	205
	206	cp_abis[num_cp_abis++] = abi;
	207
	208	return 1;
	209	}
	210
	211	/* Set the ABI to use in "auto" mode to SHORT_NAME. */
	212
	213	void
	214	set_cp_abi_as_auto_default (const char *short_name)
	215	{
	216	char new_longname, new_doc;
	217	struct cp_abi_ops *abi = find_cp_abi (short_name);
	218
	219	if (abi == NULL)
	220	internal_error (__FILE__, __LINE__,
	221	_("Cannot find C++ ABI \"%s\" to set it as auto default."),
	222	short_name);
	223
	224	if (auto_cp_abi.longname != NULL)
	225	xfree ((char *) auto_cp_abi.longname);
	226	if (auto_cp_abi.doc != NULL)
	227	xfree ((char *) auto_cp_abi.doc);
	228
	229	auto_cp_abi = *abi;
	230
	231	auto_cp_abi.shortname = "auto";
	232	new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
	233	auto_cp_abi.longname = new_longname;
	234
	235	new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
	236	abi->shortname);
	237	auto_cp_abi.doc = new_doc;
	238
	239	/* Since we copy the current ABI into current_cp_abi instead of
	240	using a pointer, if auto is currently the default, we need to
	241	reset it. */
	242	if (strcmp (current_cp_abi.shortname, "auto") == 0)
	243	switch_to_cp_abi ("auto");
	244	}
	245
	246	/* Return the ABI operations associated with SHORT_NAME. */
	247
	248	static struct cp_abi_ops *
	249	find_cp_abi (const char *short_name)
	250	{
	251	int i;
	252
	253	for (i = 0; i < num_cp_abis; i++)
	254	if (strcmp (cp_abis[i]->shortname, short_name) == 0)
	255	return cp_abis[i];
	256
	257	return NULL;
	258	}
	259
	260	/* Display the list of registered C++ ABIs. */
	261
	262	static void
	263	list_cp_abis (int from_tty)
	264	{
	265	struct cleanup *cleanup_chain;
	266	int i;
	267
	268	ui_out_text (uiout, "The available C++ ABIs are:\n");
	269	cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
	270	"cp-abi-list");
	271	for (i = 0; i < num_cp_abis; i++)
	272	{
	273	char pad[14];
	274	int padcount;
	275
	276	ui_out_text (uiout, " ");
	277	ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);
	278
	279	padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
	280	pad[padcount] = 0;
	281	while (padcount > 0)
	282	pad[--padcount] = ' ';
	283	ui_out_text (uiout, pad);
	284
	285	ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
	286	ui_out_text (uiout, "\n");
	287	}
	288	do_cleanups (cleanup_chain);
	289	}
	290
	291	/* Set the current C++ ABI, or display the list of options if no
	292	argument is given. */
	293
	294	static void
	295	set_cp_abi_cmd (char *args, int from_tty)
	296	{
	297	if (args == NULL)
	298	{
	299	list_cp_abis (from_tty);
	300	return;
	301	}
	302
	303	if (!switch_to_cp_abi (args))
	304	error (_("Could not find \"%s\" in ABI list"), args);
	305	}
	306
	307	/* Show the currently selected C++ ABI. */
	308
	309	static void
	310	show_cp_abi_cmd (char *args, int from_tty)
	311	{
	312	ui_out_text (uiout, "The currently selected C++ ABI is \"");
	313
	314	ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
	315	ui_out_text (uiout, "\" (");
	316	ui_out_field_string (uiout, "longname", current_cp_abi.longname);
	317	ui_out_text (uiout, ").\n");
	318	}
	319
	320	extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
	321
	322	void
	323	_initialize_cp_abi (void)
	324	{
	325	register_cp_abi (&auto_cp_abi);
	326	switch_to_cp_abi ("auto");
	327
	328	add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
	329	Set the ABI used for inspecting C++ objects.\n\
	330	\"set cp-abi\" with no arguments will list the available ABIs."),
	331	&setlist);
	332
	333	add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
	334	_("Show the ABI used for inspecting C++ objects."),
	335	&showlist);
	336	}