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