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

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

   Copyright (C) 2001-2014 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 "gdbcmd.h"
#include "ui-out.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;
  volatile 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);
}

/* See cp-abi.h.  */

void
cplus_print_vtable (struct value *value)
{
  if (current_cp_abi.print_vtable == NULL)
    error (_("GDB cannot print the vtable on this target"));
  (*current_cp_abi.print_vtable) (value);
}

/* See cp-abi.h.  */

struct value *
cplus_typeid (struct value *value)
{
  if (current_cp_abi.get_typeid == NULL)
    error (_("GDB cannot find the typeid on this target"));
  return (*current_cp_abi.get_typeid) (value);
}

/* See cp-abi.h.  */

struct type *
cplus_typeid_type (struct gdbarch *gdbarch)
{
  if (current_cp_abi.get_typeid_type == NULL)
    error (_("GDB cannot find the type for 'typeid' on this target"));
  return (*current_cp_abi.get_typeid_type) (gdbarch);
}

/* See cp-abi.h.  */

struct type *
cplus_type_from_type_info (struct value *value)
{
  if (current_cp_abi.get_type_from_type_info == NULL)
    error (_("GDB cannot find the type from a std::type_info on this target"));
  return (*current_cp_abi.get_type_from_type_info) (value);
}

/* See cp-abi.h.  */

char *
cplus_typename_from_type_info (struct value *value)
{
  if (current_cp_abi.get_typename_from_type_info == NULL)
    error (_("GDB cannot find the type name "
	     "from a std::type_info on this target"));
  return (*current_cp_abi.get_typename_from_type_info) (value);
}

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 ui_out *uiout = current_uiout;
  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);
}

/* A completion function for "set cp-abi".  */

static VEC (char_ptr) *
cp_abi_completer (struct cmd_list_element *ignore,
		  const char *text, const char *word)
{
  static const char **cp_abi_names;

  if (cp_abi_names == NULL)
    {
      int i;

      cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
      for (i = 0; i < num_cp_abis; ++i)
	cp_abi_names[i] = cp_abis[i]->shortname;
      cp_abi_names[i] = NULL;
    }

  return complete_on_enum (cp_abi_names, text, word);
}

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

static void
show_cp_abi_cmd (char *args, int from_tty)
{
  struct ui_out *uiout = current_uiout;

  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)
{
  struct cmd_list_element *c;

  register_cp_abi (&auto_cp_abi);
  switch_to_cp_abi ("auto");

  c = 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);
  set_cmd_completer (c, cp_abi_completer);

  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
ecd75fc8	3	Copyright (C) 2001-2014 Free Software Foundation, Inc.
015a42b4 JB	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
015a42b4 JB	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
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
015a42b4 JB	19
	20	#include "defs.h"
	21	#include "value.h"
	22	#include "cp-abi.h"
fe1f4a5e DJ	23	#include "command.h"
	24	#include "gdbcmd.h"
	25	#include "ui-out.h"
fe1f4a5e	26	static struct cp_abi_ops find_cp_abi (const char short_name);
015a42b4	27
fe1f4a5e DJ	28	static struct cp_abi_ops current_cp_abi = { "", NULL };
fe1f4a5e DJ	29	static struct cp_abi_ops auto_cp_abi = { "auto", NULL };
015a42b4	30
fe1f4a5e DJ	31	#define CP_ABI_MAX 8
	32	static struct cp_abi_ops *cp_abis[CP_ABI_MAX];
	33	static int num_cp_abis = 0;
015a42b4 JB	34
	35	enum ctor_kinds
	36	is_constructor_name (const char *name)
	37	{
	38	if ((current_cp_abi.is_constructor_name) == NULL)
8a3fe4f8	39	error (_("ABI doesn't define required function is_constructor_name"));
015a42b4 JB	40	return (*current_cp_abi.is_constructor_name) (name);
	41	}
	42
	43	enum dtor_kinds
	44	is_destructor_name (const char *name)
	45	{
	46	if ((current_cp_abi.is_destructor_name) == NULL)
8a3fe4f8	47	error (_("ABI doesn't define required function is_destructor_name"));
015a42b4 JB	48	return (*current_cp_abi.is_destructor_name) (name);
	49	}
	50
	51	int
	52	is_vtable_name (const char *name)
	53	{
	54	if ((current_cp_abi.is_vtable_name) == NULL)
8a3fe4f8	55	error (_("ABI doesn't define required function is_vtable_name"));
015a42b4 JB	56	return (*current_cp_abi.is_vtable_name) (name);
	57	}
	58
	59	int
	60	is_operator_name (const char *name)
	61	{
	62	if ((current_cp_abi.is_operator_name) == NULL)
8a3fe4f8	63	error (_("ABI doesn't define required function is_operator_name"));
015a42b4 JB	64	return (*current_cp_abi.is_operator_name) (name);
	65	}
	66
1514d34e	67	int
8af8e3bc PA	68	baseclass_offset (struct type type, int index, const gdb_byte valaddr,
	69	int embedded_offset, CORE_ADDR address,
	70	const struct value *val)
1514d34e	71	{
8af8e3bc PA	72	volatile struct gdb_exception ex;
	73	int res = 0;
	74
	75	gdb_assert (current_cp_abi.baseclass_offset != NULL);
	76
	77	TRY_CATCH (ex, RETURN_MASK_ERROR)
	78	{
	79	res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
	80	embedded_offset,
	81	address, val);
	82	}
	83
	84	if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
	85	throw_error (NOT_AVAILABLE_ERROR,
	86	_("Cannot determine virtual baseclass offset "
	87	"of incomplete object"));
	88	else if (ex.reason < 0)
	89	throw_exception (ex);
	90	else
	91	return res;
1514d34e DJ	92	}
1514d34e DJ	93
e933e538	94	struct value *
aff410f1 MS	95	value_virtual_fn_field (struct value **arg1p,
aff410f1 MS	96	struct fn_field *f, int j,
fe1f4a5e	97	struct type *type, int offset)
015a42b4 JB	98	{
	99	if ((current_cp_abi.virtual_fn_field) == NULL)
	100	return NULL;
aff410f1 MS	101	return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
aff410f1 MS	102	type, offset);
015a42b4	103	}
1514d34e	104
015a42b4	105	struct type *
aff410f1 MS	106	value_rtti_type (struct value v, int full,
aff410f1 MS	107	int top, int using_enc)
015a42b4	108	{
7093c834	109	struct type *ret = NULL;
bfd189b1	110	volatile struct gdb_exception e;
c5504eaf	111
015a42b4 JB	112	if ((current_cp_abi.rtti_type) == NULL)
015a42b4 JB	113	return NULL;
7093c834 PP	114	TRY_CATCH (e, RETURN_MASK_ERROR)
	115	{
	116	ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
	117	}
	118	if (e.reason < 0)
	119	return NULL;
	120	return ret;
015a42b4 JB	121	}
015a42b4 JB	122
0d5de010	123	void
aff410f1 MS	124	cplus_print_method_ptr (const gdb_byte *contents,
aff410f1 MS	125	struct type *type,
0d5de010 DJ	126	struct ui_file *stream)
	127	{
	128	if (current_cp_abi.print_method_ptr == NULL)
	129	error (_("GDB does not support pointers to methods on this target"));
	130	(*current_cp_abi.print_method_ptr) (contents, type, stream);
	131	}
	132
	133	int
ad4820ab	134	cplus_method_ptr_size (struct type *to_type)
0d5de010 DJ	135	{
	136	if (current_cp_abi.method_ptr_size == NULL)
	137	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	138	return (*current_cp_abi.method_ptr_size) (to_type);
0d5de010 DJ	139	}
	140
	141	void
ad4820ab UW	142	cplus_make_method_ptr (struct type type, gdb_byte contents,
ad4820ab UW	143	CORE_ADDR value, int is_virtual)
0d5de010 DJ	144	{
	145	if (current_cp_abi.make_method_ptr == NULL)
	146	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	147	(*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual);
0d5de010 DJ	148	}
0d5de010 DJ	149
b18be20d	150	CORE_ADDR
aff410f1 MS	151	cplus_skip_trampoline (struct frame_info *frame,
aff410f1 MS	152	CORE_ADDR stop_pc)
b18be20d DJ	153	{
	154	if (current_cp_abi.skip_trampoline == NULL)
	155	return 0;
52f729a7	156	return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
b18be20d DJ	157	}
b18be20d DJ	158
0d5de010	159	struct value *
aff410f1 MS	160	cplus_method_ptr_to_value (struct value **this_p,
aff410f1 MS	161	struct value *method_ptr)
0d5de010 DJ	162	{
	163	if (current_cp_abi.method_ptr_to_value == NULL)
	164	error (_("GDB does not support pointers to methods on this target"));
	165	return (*current_cp_abi.method_ptr_to_value) (this_p, method_ptr);
	166	}
	167
c4aeac85 TT	168	/* See cp-abi.h. */
	169
	170	void
	171	cplus_print_vtable (struct value *value)
	172	{
	173	if (current_cp_abi.print_vtable == NULL)
	174	error (_("GDB cannot print the vtable on this target"));
843e694d	175	(*current_cp_abi.print_vtable) (value);
c4aeac85 TT	176	}
c4aeac85 TT	177
6e72ca20 TT	178	/* See cp-abi.h. */
	179
	180	struct value *
	181	cplus_typeid (struct value *value)
	182	{
	183	if (current_cp_abi.get_typeid == NULL)
	184	error (_("GDB cannot find the typeid on this target"));
	185	return (*current_cp_abi.get_typeid) (value);
	186	}
	187
	188	/* See cp-abi.h. */
	189
	190	struct type *
	191	cplus_typeid_type (struct gdbarch *gdbarch)
	192	{
	193	if (current_cp_abi.get_typeid_type == NULL)
	194	error (_("GDB cannot find the type for 'typeid' on this target"));
	195	return (*current_cp_abi.get_typeid_type) (gdbarch);
	196	}
	197
72f1fe8a TT	198	/* See cp-abi.h. */
	199
	200	struct type *
	201	cplus_type_from_type_info (struct value *value)
	202	{
	203	if (current_cp_abi.get_type_from_type_info == NULL)
	204	error (_("GDB cannot find the type from a std::type_info on this target"));
	205	return (*current_cp_abi.get_type_from_type_info) (value);
	206	}
	207
cc16e6c9 TT	208	/* See cp-abi.h. */
	209
	210	char *
	211	cplus_typename_from_type_info (struct value *value)
	212	{
	213	if (current_cp_abi.get_typename_from_type_info == NULL)
	214	error (_("GDB cannot find the type name "
	215	"from a std::type_info on this target"));
	216	return (*current_cp_abi.get_typename_from_type_info) (value);
	217	}
	218
41f1b697 DJ	219	int
	220	cp_pass_by_reference (struct type *type)
	221	{
	222	if ((current_cp_abi.pass_by_reference) == NULL)
	223	return 0;
	224	return (*current_cp_abi.pass_by_reference) (type);
	225	}
	226
fe1f4a5e DJ	227	/* Set the current C++ ABI to SHORT_NAME. */
	228
	229	static int
	230	switch_to_cp_abi (const char *short_name)
	231	{
	232	struct cp_abi_ops *abi;
	233
	234	abi = find_cp_abi (short_name);
	235	if (abi == NULL)
	236	return 0;
	237
	238	current_cp_abi = *abi;
	239	return 1;
	240	}
	241
	242	/* Add ABI to the list of supported C++ ABI's. */
	243
015a42b4	244	int
fe1f4a5e	245	register_cp_abi (struct cp_abi_ops *abi)
015a42b4	246	{
fe1f4a5e DJ	247	if (num_cp_abis == CP_ABI_MAX)
fe1f4a5e DJ	248	internal_error (__FILE__, __LINE__,
3e43a32a MS	249	_("Too many C++ ABIs, please increase "
3e43a32a MS	250	"CP_ABI_MAX in cp-abi.c"));
fe1f4a5e	251
015a42b4 JB	252	cp_abis[num_cp_abis++] = abi;
	253
	254	return 1;
fe1f4a5e DJ	255	}
	256
	257	/* Set the ABI to use in "auto" mode to SHORT_NAME. */
015a42b4	258
fe1f4a5e DJ	259	void
	260	set_cp_abi_as_auto_default (const char *short_name)
	261	{
	262	char new_longname, new_doc;
	263	struct cp_abi_ops *abi = find_cp_abi (short_name);
	264
	265	if (abi == NULL)
	266	internal_error (__FILE__, __LINE__,
e2e0b3e5	267	_("Cannot find C++ ABI \"%s\" to set it as auto default."),
fe1f4a5e DJ	268	short_name);
	269
	270	if (auto_cp_abi.longname != NULL)
	271	xfree ((char *) auto_cp_abi.longname);
	272	if (auto_cp_abi.doc != NULL)
	273	xfree ((char *) auto_cp_abi.doc);
	274
	275	auto_cp_abi = *abi;
	276
	277	auto_cp_abi.shortname = "auto";
0dfdb8ba	278	new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
fe1f4a5e DJ	279	auto_cp_abi.longname = new_longname;
fe1f4a5e DJ	280
0dfdb8ba	281	new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
049742da	282	abi->shortname);
fe1f4a5e DJ	283	auto_cp_abi.doc = new_doc;
	284
	285	/* Since we copy the current ABI into current_cp_abi instead of
	286	using a pointer, if auto is currently the default, we need to
	287	reset it. */
	288	if (strcmp (current_cp_abi.shortname, "auto") == 0)
	289	switch_to_cp_abi ("auto");
015a42b4 JB	290	}
015a42b4 JB	291
fe1f4a5e DJ	292	/* Return the ABI operations associated with SHORT_NAME. */
	293
	294	static struct cp_abi_ops *
	295	find_cp_abi (const char *short_name)
015a42b4 JB	296	{
015a42b4 JB	297	int i;
fe1f4a5e	298
015a42b4	299	for (i = 0; i < num_cp_abis; i++)
fe1f4a5e DJ	300	if (strcmp (cp_abis[i]->shortname, short_name) == 0)
	301	return cp_abis[i];
	302
	303	return NULL;
015a42b4 JB	304	}
015a42b4 JB	305
fe1f4a5e DJ	306	/* Display the list of registered C++ ABIs. */
	307
	308	static void
	309	list_cp_abis (int from_tty)
	310	{
79a45e25	311	struct ui_out *uiout = current_uiout;
fe1f4a5e DJ	312	struct cleanup *cleanup_chain;
fe1f4a5e DJ	313	int i;
fe1f4a5e	314
c5504eaf	315	ui_out_text (uiout, "The available C++ ABIs are:\n");
aff410f1 MS	316	cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
aff410f1 MS	317	"cp-abi-list");
fe1f4a5e DJ	318	for (i = 0; i < num_cp_abis; i++)
	319	{
	320	char pad[14];
	321	int padcount;
	322
	323	ui_out_text (uiout, " ");
	324	ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);
	325
	326	padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
	327	pad[padcount] = 0;
	328	while (padcount > 0)
	329	pad[--padcount] = ' ';
	330	ui_out_text (uiout, pad);
	331
	332	ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
	333	ui_out_text (uiout, "\n");
	334	}
	335	do_cleanups (cleanup_chain);
	336	}
	337
	338	/* Set the current C++ ABI, or display the list of options if no
	339	argument is given. */
	340
	341	static void
	342	set_cp_abi_cmd (char *args, int from_tty)
	343	{
	344	if (args == NULL)
	345	{
	346	list_cp_abis (from_tty);
	347	return;
	348	}
	349
	350	if (!switch_to_cp_abi (args))
8a3fe4f8	351	error (_("Could not find \"%s\" in ABI list"), args);
fe1f4a5e DJ	352	}
fe1f4a5e DJ	353
db2b2972 TT	354	/* A completion function for "set cp-abi". */
	355
	356	static VEC (char_ptr) *
	357	cp_abi_completer (struct cmd_list_element *ignore,
6f937416	358	const char text, const char word)
db2b2972 TT	359	{
	360	static const char **cp_abi_names;
	361
	362	if (cp_abi_names == NULL)
	363	{
	364	int i;
	365
	366	cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
	367	for (i = 0; i < num_cp_abis; ++i)
	368	cp_abi_names[i] = cp_abis[i]->shortname;
6108433d	369	cp_abi_names[i] = NULL;
db2b2972 TT	370	}
	371
	372	return complete_on_enum (cp_abi_names, text, word);
	373	}
	374
fe1f4a5e DJ	375	/* Show the currently selected C++ ABI. */
	376
	377	static void
	378	show_cp_abi_cmd (char *args, int from_tty)
	379	{
79a45e25 PA	380	struct ui_out *uiout = current_uiout;
79a45e25 PA	381
fe1f4a5e DJ	382	ui_out_text (uiout, "The currently selected C++ ABI is \"");
	383
	384	ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
	385	ui_out_text (uiout, "\" (");
	386	ui_out_field_string (uiout, "longname", current_cp_abi.longname);
	387	ui_out_text (uiout, ").\n");
	388	}
	389
b9362cc7 AC	390	extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
b9362cc7 AC	391
fe1f4a5e DJ	392	void
	393	_initialize_cp_abi (void)
	394	{
db2b2972 TT	395	struct cmd_list_element *c;
db2b2972 TT	396
fe1f4a5e DJ	397	register_cp_abi (&auto_cp_abi);
	398	switch_to_cp_abi ("auto");
	399
db2b2972	400	c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
ac74f770 MS	401	Set the ABI used for inspecting C++ objects.\n\
ac74f770 MS	402	\"set cp-abi\" with no arguments will list the available ABIs."),
db2b2972 TT	403	&setlist);
db2b2972 TT	404	set_cmd_completer (c, cp_abi_completer);
fe1f4a5e DJ	405
fe1f4a5e DJ	406	add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
aff410f1 MS	407	_("Show the ABI used for inspecting C++ objects."),
aff410f1 MS	408	&showlist);
fe1f4a5e	409	}