[thirdparty/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
015a42b4	1	/* Generic code for supporting multiple C++ ABI's
06c4d4dc	2
7b6bb8da	3	Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
6aba47ca	4	Free Software Foundation, Inc.
015a42b4 JB	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
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
015a42b4 JB	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
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
015a42b4 JB	20
	21	#include "defs.h"
	22	#include "value.h"
	23	#include "cp-abi.h"
fe1f4a5e	24	#include "command.h"
7093c834	25	#include "exceptions.h"
fe1f4a5e DJ	26	#include "gdbcmd.h"
fe1f4a5e DJ	27	#include "ui-out.h"
8af8e3bc	28	#include "gdb_assert.h"
309367d4	29	#include "gdb_string.h"
015a42b4	30
fe1f4a5e	31	static struct cp_abi_ops find_cp_abi (const char short_name);
015a42b4	32
fe1f4a5e DJ	33	static struct cp_abi_ops current_cp_abi = { "", NULL };
fe1f4a5e DJ	34	static struct cp_abi_ops auto_cp_abi = { "auto", NULL };
015a42b4	35
fe1f4a5e DJ	36	#define CP_ABI_MAX 8
	37	static struct cp_abi_ops *cp_abis[CP_ABI_MAX];
	38	static int num_cp_abis = 0;
015a42b4 JB	39
	40	enum ctor_kinds
	41	is_constructor_name (const char *name)
	42	{
	43	if ((current_cp_abi.is_constructor_name) == NULL)
8a3fe4f8	44	error (_("ABI doesn't define required function is_constructor_name"));
015a42b4 JB	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)
8a3fe4f8	52	error (_("ABI doesn't define required function is_destructor_name"));
015a42b4 JB	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)
8a3fe4f8	60	error (_("ABI doesn't define required function is_vtable_name"));
015a42b4 JB	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)
8a3fe4f8	68	error (_("ABI doesn't define required function is_operator_name"));
015a42b4 JB	69	return (*current_cp_abi.is_operator_name) (name);
	70	}
	71
1514d34e	72	int
8af8e3bc PA	73	baseclass_offset (struct type type, int index, const gdb_byte valaddr,
	74	int embedded_offset, CORE_ADDR address,
	75	const struct value *val)
1514d34e	76	{
8af8e3bc PA	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;
1514d34e DJ	97	}
1514d34e DJ	98
e933e538	99	struct value *
aff410f1 MS	100	value_virtual_fn_field (struct value **arg1p,
aff410f1 MS	101	struct fn_field *f, int j,
fe1f4a5e	102	struct type *type, int offset)
015a42b4 JB	103	{
	104	if ((current_cp_abi.virtual_fn_field) == NULL)
	105	return NULL;
aff410f1 MS	106	return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
aff410f1 MS	107	type, offset);
015a42b4	108	}
1514d34e	109
015a42b4	110	struct type *
aff410f1 MS	111	value_rtti_type (struct value v, int full,
aff410f1 MS	112	int top, int using_enc)
015a42b4	113	{
7093c834 PP	114	struct type *ret = NULL;
7093c834 PP	115	struct gdb_exception e;
c5504eaf	116
015a42b4 JB	117	if ((current_cp_abi.rtti_type) == NULL)
015a42b4 JB	118	return NULL;
7093c834 PP	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;
015a42b4 JB	126	}
015a42b4 JB	127
0d5de010	128	void
aff410f1 MS	129	cplus_print_method_ptr (const gdb_byte *contents,
aff410f1 MS	130	struct type *type,
0d5de010 DJ	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
ad4820ab	139	cplus_method_ptr_size (struct type *to_type)
0d5de010 DJ	140	{
	141	if (current_cp_abi.method_ptr_size == NULL)
	142	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	143	return (*current_cp_abi.method_ptr_size) (to_type);
0d5de010 DJ	144	}
	145
	146	void
ad4820ab UW	147	cplus_make_method_ptr (struct type type, gdb_byte contents,
ad4820ab UW	148	CORE_ADDR value, int is_virtual)
0d5de010 DJ	149	{
	150	if (current_cp_abi.make_method_ptr == NULL)
	151	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	152	(*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual);
0d5de010 DJ	153	}
0d5de010 DJ	154
b18be20d	155	CORE_ADDR
aff410f1 MS	156	cplus_skip_trampoline (struct frame_info *frame,
aff410f1 MS	157	CORE_ADDR stop_pc)
b18be20d DJ	158	{
	159	if (current_cp_abi.skip_trampoline == NULL)
	160	return 0;
52f729a7	161	return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
b18be20d DJ	162	}
b18be20d DJ	163
0d5de010	164	struct value *
aff410f1 MS	165	cplus_method_ptr_to_value (struct value **this_p,
aff410f1 MS	166	struct value *method_ptr)
0d5de010 DJ	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
41f1b697 DJ	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
fe1f4a5e DJ	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
015a42b4	198	int
fe1f4a5e	199	register_cp_abi (struct cp_abi_ops *abi)
015a42b4	200	{
fe1f4a5e DJ	201	if (num_cp_abis == CP_ABI_MAX)
fe1f4a5e DJ	202	internal_error (__FILE__, __LINE__,
3e43a32a MS	203	_("Too many C++ ABIs, please increase "
3e43a32a MS	204	"CP_ABI_MAX in cp-abi.c"));
fe1f4a5e	205
015a42b4 JB	206	cp_abis[num_cp_abis++] = abi;
	207
	208	return 1;
fe1f4a5e DJ	209	}
	210
	211	/* Set the ABI to use in "auto" mode to SHORT_NAME. */
015a42b4	212
fe1f4a5e DJ	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__,
e2e0b3e5	221	_("Cannot find C++ ABI \"%s\" to set it as auto default."),
fe1f4a5e DJ	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";
0dfdb8ba	232	new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
fe1f4a5e DJ	233	auto_cp_abi.longname = new_longname;
fe1f4a5e DJ	234
0dfdb8ba	235	new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
049742da	236	abi->shortname);
fe1f4a5e DJ	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");
015a42b4 JB	244	}
015a42b4 JB	245
fe1f4a5e DJ	246	/* Return the ABI operations associated with SHORT_NAME. */
	247
	248	static struct cp_abi_ops *
	249	find_cp_abi (const char *short_name)
015a42b4 JB	250	{
015a42b4 JB	251	int i;
fe1f4a5e	252
015a42b4	253	for (i = 0; i < num_cp_abis; i++)
fe1f4a5e DJ	254	if (strcmp (cp_abis[i]->shortname, short_name) == 0)
	255	return cp_abis[i];
	256
	257	return NULL;
015a42b4 JB	258	}
015a42b4 JB	259
fe1f4a5e DJ	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;
fe1f4a5e	267
c5504eaf	268	ui_out_text (uiout, "The available C++ ABIs are:\n");
aff410f1 MS	269	cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
aff410f1 MS	270	"cp-abi-list");
fe1f4a5e DJ	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))
8a3fe4f8	304	error (_("Could not find \"%s\" in ABI list"), args);
fe1f4a5e DJ	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
b9362cc7 AC	320	extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
b9362cc7 AC	321
fe1f4a5e DJ	322	void
	323	_initialize_cp_abi (void)
	324	{
	325	register_cp_abi (&auto_cp_abi);
	326	switch_to_cp_abi ("auto");
	327
ac74f770 MS	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."),
fe1f4a5e DJ	331	&setlist);
	332
	333	add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
aff410f1 MS	334	_("Show the ABI used for inspecting C++ objects."),
aff410f1 MS	335	&showlist);
fe1f4a5e	336	}