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

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

   Copyright (C) 2001-2016 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,
		  LONGEST embedded_offset, CORE_ADDR address,
		  const struct value *val)
{
  int res = 0;

  gdb_assert (current_cp_abi.baseclass_offset != NULL);

  TRY
    {
      res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
						embedded_offset,
						address, val);
    }
  CATCH (ex, RETURN_MASK_ERROR)
    {
      if (ex.error != NOT_AVAILABLE_ERROR)
	throw_exception (ex);

      throw_error (NOT_AVAILABLE_ERROR,
		   _("Cannot determine virtual baseclass offset "
		     "of incomplete object"));
    }
  END_CATCH

  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,
		 LONGEST *top, int *using_enc)
{
  struct type *ret = NULL;

  if ((current_cp_abi.rtti_type) == NULL)
    return NULL;
  TRY
    {
      ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
    }
  CATCH (e, RETURN_MASK_ERROR)
    {
      return NULL;
    }
  END_CATCH

  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.  */

std::string
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
618f726f	3	Copyright (C) 2001-2016 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	68	baseclass_offset (struct type type, int index, const gdb_byte valaddr,
6b850546	69	LONGEST embedded_offset, CORE_ADDR address,
8af8e3bc	70	const struct value *val)
1514d34e	71	{
8af8e3bc PA	72	int res = 0;
	73
	74	gdb_assert (current_cp_abi.baseclass_offset != NULL);
	75
492d29ea	76	TRY
8af8e3bc PA	77	{
	78	res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
	79	embedded_offset,
	80	address, val);
	81	}
492d29ea	82	CATCH (ex, RETURN_MASK_ERROR)
7556d4a4 PA	83	{
	84	if (ex.error != NOT_AVAILABLE_ERROR)
	85	throw_exception (ex);
	86
	87	throw_error (NOT_AVAILABLE_ERROR,
	88	_("Cannot determine virtual baseclass offset "
	89	"of incomplete object"));
	90	}
492d29ea	91	END_CATCH
8af8e3bc	92
7556d4a4	93	return res;
1514d34e DJ	94	}
1514d34e DJ	95
e933e538	96	struct value *
aff410f1 MS	97	value_virtual_fn_field (struct value **arg1p,
aff410f1 MS	98	struct fn_field *f, int j,
fe1f4a5e	99	struct type *type, int offset)
015a42b4 JB	100	{
	101	if ((current_cp_abi.virtual_fn_field) == NULL)
	102	return NULL;
aff410f1 MS	103	return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
aff410f1 MS	104	type, offset);
015a42b4	105	}
1514d34e	106
015a42b4	107	struct type *
aff410f1	108	value_rtti_type (struct value v, int full,
6b850546	109	LONGEST top, int using_enc)
015a42b4	110	{
7093c834	111	struct type *ret = NULL;
c5504eaf	112
015a42b4 JB	113	if ((current_cp_abi.rtti_type) == NULL)
015a42b4 JB	114	return NULL;
492d29ea	115	TRY
7093c834 PP	116	{
	117	ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
	118	}
492d29ea PA	119	CATCH (e, RETURN_MASK_ERROR)
	120	{
	121	return NULL;
	122	}
	123	END_CATCH
	124
7093c834	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
c4aeac85 TT	173	/* See cp-abi.h. */
	174
	175	void
	176	cplus_print_vtable (struct value *value)
	177	{
	178	if (current_cp_abi.print_vtable == NULL)
	179	error (_("GDB cannot print the vtable on this target"));
843e694d	180	(*current_cp_abi.print_vtable) (value);
c4aeac85 TT	181	}
c4aeac85 TT	182
6e72ca20 TT	183	/* See cp-abi.h. */
	184
	185	struct value *
	186	cplus_typeid (struct value *value)
	187	{
	188	if (current_cp_abi.get_typeid == NULL)
	189	error (_("GDB cannot find the typeid on this target"));
	190	return (*current_cp_abi.get_typeid) (value);
	191	}
	192
	193	/* See cp-abi.h. */
	194
	195	struct type *
	196	cplus_typeid_type (struct gdbarch *gdbarch)
	197	{
	198	if (current_cp_abi.get_typeid_type == NULL)
	199	error (_("GDB cannot find the type for 'typeid' on this target"));
	200	return (*current_cp_abi.get_typeid_type) (gdbarch);
	201	}
	202
72f1fe8a TT	203	/* See cp-abi.h. */
	204
	205	struct type *
	206	cplus_type_from_type_info (struct value *value)
	207	{
	208	if (current_cp_abi.get_type_from_type_info == NULL)
	209	error (_("GDB cannot find the type from a std::type_info on this target"));
	210	return (*current_cp_abi.get_type_from_type_info) (value);
	211	}
	212
cc16e6c9 TT	213	/* See cp-abi.h. */
cc16e6c9 TT	214
2f408ecb	215	std::string
cc16e6c9 TT	216	cplus_typename_from_type_info (struct value *value)
	217	{
	218	if (current_cp_abi.get_typename_from_type_info == NULL)
	219	error (_("GDB cannot find the type name "
	220	"from a std::type_info on this target"));
	221	return (*current_cp_abi.get_typename_from_type_info) (value);
	222	}
	223
41f1b697 DJ	224	int
	225	cp_pass_by_reference (struct type *type)
	226	{
	227	if ((current_cp_abi.pass_by_reference) == NULL)
	228	return 0;
	229	return (*current_cp_abi.pass_by_reference) (type);
	230	}
	231
fe1f4a5e DJ	232	/* Set the current C++ ABI to SHORT_NAME. */
	233
	234	static int
	235	switch_to_cp_abi (const char *short_name)
	236	{
	237	struct cp_abi_ops *abi;
	238
	239	abi = find_cp_abi (short_name);
	240	if (abi == NULL)
	241	return 0;
	242
	243	current_cp_abi = *abi;
	244	return 1;
	245	}
	246
	247	/* Add ABI to the list of supported C++ ABI's. */
	248
015a42b4	249	int
fe1f4a5e	250	register_cp_abi (struct cp_abi_ops *abi)
015a42b4	251	{
fe1f4a5e DJ	252	if (num_cp_abis == CP_ABI_MAX)
fe1f4a5e DJ	253	internal_error (__FILE__, __LINE__,
3e43a32a MS	254	_("Too many C++ ABIs, please increase "
3e43a32a MS	255	"CP_ABI_MAX in cp-abi.c"));
fe1f4a5e	256
015a42b4 JB	257	cp_abis[num_cp_abis++] = abi;
	258
	259	return 1;
fe1f4a5e DJ	260	}
	261
	262	/* Set the ABI to use in "auto" mode to SHORT_NAME. */
015a42b4	263
fe1f4a5e DJ	264	void
	265	set_cp_abi_as_auto_default (const char *short_name)
	266	{
	267	char new_longname, new_doc;
	268	struct cp_abi_ops *abi = find_cp_abi (short_name);
	269
	270	if (abi == NULL)
	271	internal_error (__FILE__, __LINE__,
e2e0b3e5	272	_("Cannot find C++ ABI \"%s\" to set it as auto default."),
fe1f4a5e DJ	273	short_name);
	274
	275	if (auto_cp_abi.longname != NULL)
	276	xfree ((char *) auto_cp_abi.longname);
	277	if (auto_cp_abi.doc != NULL)
	278	xfree ((char *) auto_cp_abi.doc);
	279
	280	auto_cp_abi = *abi;
	281
	282	auto_cp_abi.shortname = "auto";
0dfdb8ba	283	new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
fe1f4a5e DJ	284	auto_cp_abi.longname = new_longname;
fe1f4a5e DJ	285
0dfdb8ba	286	new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
049742da	287	abi->shortname);
fe1f4a5e DJ	288	auto_cp_abi.doc = new_doc;
	289
	290	/* Since we copy the current ABI into current_cp_abi instead of
	291	using a pointer, if auto is currently the default, we need to
	292	reset it. */
	293	if (strcmp (current_cp_abi.shortname, "auto") == 0)
	294	switch_to_cp_abi ("auto");
015a42b4 JB	295	}
015a42b4 JB	296
fe1f4a5e DJ	297	/* Return the ABI operations associated with SHORT_NAME. */
	298
	299	static struct cp_abi_ops *
	300	find_cp_abi (const char *short_name)
015a42b4 JB	301	{
015a42b4 JB	302	int i;
fe1f4a5e	303
015a42b4	304	for (i = 0; i < num_cp_abis; i++)
fe1f4a5e DJ	305	if (strcmp (cp_abis[i]->shortname, short_name) == 0)
	306	return cp_abis[i];
	307
	308	return NULL;
015a42b4 JB	309	}
015a42b4 JB	310
fe1f4a5e DJ	311	/* Display the list of registered C++ ABIs. */
	312
	313	static void
	314	list_cp_abis (int from_tty)
	315	{
79a45e25	316	struct ui_out *uiout = current_uiout;
fe1f4a5e DJ	317	struct cleanup *cleanup_chain;
fe1f4a5e DJ	318	int i;
fe1f4a5e	319
c5504eaf	320	ui_out_text (uiout, "The available C++ ABIs are:\n");
aff410f1 MS	321	cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
aff410f1 MS	322	"cp-abi-list");
fe1f4a5e DJ	323	for (i = 0; i < num_cp_abis; i++)
	324	{
	325	char pad[14];
	326	int padcount;
	327
	328	ui_out_text (uiout, " ");
	329	ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);
	330
	331	padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
	332	pad[padcount] = 0;
	333	while (padcount > 0)
	334	pad[--padcount] = ' ';
	335	ui_out_text (uiout, pad);
	336
	337	ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
	338	ui_out_text (uiout, "\n");
	339	}
	340	do_cleanups (cleanup_chain);
	341	}
	342
	343	/* Set the current C++ ABI, or display the list of options if no
	344	argument is given. */
	345
	346	static void
	347	set_cp_abi_cmd (char *args, int from_tty)
	348	{
	349	if (args == NULL)
	350	{
	351	list_cp_abis (from_tty);
	352	return;
	353	}
	354
	355	if (!switch_to_cp_abi (args))
8a3fe4f8	356	error (_("Could not find \"%s\" in ABI list"), args);
fe1f4a5e DJ	357	}
fe1f4a5e DJ	358
db2b2972 TT	359	/* A completion function for "set cp-abi". */
	360
	361	static VEC (char_ptr) *
	362	cp_abi_completer (struct cmd_list_element *ignore,
6f937416	363	const char text, const char word)
db2b2972 TT	364	{
	365	static const char **cp_abi_names;
	366
	367	if (cp_abi_names == NULL)
	368	{
	369	int i;
	370
	371	cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
	372	for (i = 0; i < num_cp_abis; ++i)
	373	cp_abi_names[i] = cp_abis[i]->shortname;
6108433d	374	cp_abi_names[i] = NULL;
db2b2972 TT	375	}
	376
	377	return complete_on_enum (cp_abi_names, text, word);
	378	}
	379
fe1f4a5e DJ	380	/* Show the currently selected C++ ABI. */
	381
	382	static void
	383	show_cp_abi_cmd (char *args, int from_tty)
	384	{
79a45e25 PA	385	struct ui_out *uiout = current_uiout;
79a45e25 PA	386
fe1f4a5e DJ	387	ui_out_text (uiout, "The currently selected C++ ABI is \"");
	388
	389	ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
	390	ui_out_text (uiout, "\" (");
	391	ui_out_field_string (uiout, "longname", current_cp_abi.longname);
	392	ui_out_text (uiout, ").\n");
	393	}
	394
b9362cc7 AC	395	extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
b9362cc7 AC	396
fe1f4a5e DJ	397	void
	398	_initialize_cp_abi (void)
	399	{
db2b2972 TT	400	struct cmd_list_element *c;
db2b2972 TT	401
fe1f4a5e DJ	402	register_cp_abi (&auto_cp_abi);
	403	switch_to_cp_abi ("auto");
	404
db2b2972	405	c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
ac74f770 MS	406	Set the ABI used for inspecting C++ objects.\n\
ac74f770 MS	407	\"set cp-abi\" with no arguments will list the available ABIs."),
db2b2972 TT	408	&setlist);
db2b2972 TT	409	set_cmd_completer (c, cp_abi_completer);
fe1f4a5e DJ	410
fe1f4a5e DJ	411	add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
aff410f1 MS	412	_("Show the ABI used for inspecting C++ objects."),
aff410f1 MS	413	&showlist);
fe1f4a5e	414	}