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

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

   Copyright (C) 2001-2019 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 (const gdb_exception_RETURN_MASK_ERROR &ex)
    {
      if (ex.error != NOT_AVAILABLE_ERROR)
	throw_exception (ex);

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

  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 (const gdb_exception_RETURN_MASK_ERROR &e)
    {
      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.  */

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;
  int i;

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

      uiout->text ("  ");
      uiout->field_string ("cp-abi", cp_abis[i]->shortname);

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

      uiout->field_string ("doc", cp_abis[i]->doc);
      uiout->text ("\n");
    }
}

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

static void
set_cp_abi_cmd (const 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 void
cp_abi_completer (struct cmd_list_element *ignore,
		  completion_tracker &tracker,
		  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;
    }

  complete_on_enum (tracker, cp_abi_names, text, word);
}

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

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

  uiout->text ("The currently selected C++ ABI is \"");

  uiout->field_string ("cp-abi", current_cp_abi.shortname);
  uiout->text ("\" (");
  uiout->field_string ("longname", current_cp_abi.longname);
  uiout->text (").\n");
}

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
42a4f53d	3	Copyright (C) 2001-2019 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
015a42b4 JB	20	#include "defs.h"
4de283e4	21	#include "value.h"
d55e5aa6	22	#include "cp-abi.h"
4de283e4	23	#include "command.h"
fe1f4a5e DJ	24	#include "gdbcmd.h"
fe1f4a5e DJ	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
a70b8144	76	try
8af8e3bc PA	77	{
	78	res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
	79	embedded_offset,
	80	address, val);
	81	}
a70b8144	82	catch (const gdb_exception_RETURN_MASK_ERROR &ex)
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	}
8af8e3bc	91
7556d4a4	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	107	value_rtti_type (struct value v, int full,
6b850546	108	LONGEST top, int using_enc)
015a42b4	109	{
7093c834	110	struct type *ret = NULL;
c5504eaf	111
015a42b4 JB	112	if ((current_cp_abi.rtti_type) == NULL)
015a42b4 JB	113	return NULL;
a70b8144	114	try
7093c834 PP	115	{
	116	ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
	117	}
a70b8144	118	catch (const gdb_exception_RETURN_MASK_ERROR &e)
492d29ea PA	119	{
	120	return NULL;
	121	}
492d29ea	122
7093c834	123	return ret;
015a42b4 JB	124	}
015a42b4 JB	125
0d5de010	126	void
aff410f1 MS	127	cplus_print_method_ptr (const gdb_byte *contents,
aff410f1 MS	128	struct type *type,
0d5de010 DJ	129	struct ui_file *stream)
	130	{
	131	if (current_cp_abi.print_method_ptr == NULL)
	132	error (_("GDB does not support pointers to methods on this target"));
	133	(*current_cp_abi.print_method_ptr) (contents, type, stream);
	134	}
	135
	136	int
ad4820ab	137	cplus_method_ptr_size (struct type *to_type)
0d5de010 DJ	138	{
	139	if (current_cp_abi.method_ptr_size == NULL)
	140	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	141	return (*current_cp_abi.method_ptr_size) (to_type);
0d5de010 DJ	142	}
	143
	144	void
ad4820ab UW	145	cplus_make_method_ptr (struct type type, gdb_byte contents,
ad4820ab UW	146	CORE_ADDR value, int is_virtual)
0d5de010 DJ	147	{
	148	if (current_cp_abi.make_method_ptr == NULL)
	149	error (_("GDB does not support pointers to methods on this target"));
ad4820ab	150	(*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual);
0d5de010 DJ	151	}
0d5de010 DJ	152
b18be20d	153	CORE_ADDR
aff410f1 MS	154	cplus_skip_trampoline (struct frame_info *frame,
aff410f1 MS	155	CORE_ADDR stop_pc)
b18be20d DJ	156	{
	157	if (current_cp_abi.skip_trampoline == NULL)
	158	return 0;
52f729a7	159	return (*current_cp_abi.skip_trampoline) (frame, stop_pc);
b18be20d DJ	160	}
b18be20d DJ	161
0d5de010	162	struct value *
aff410f1 MS	163	cplus_method_ptr_to_value (struct value **this_p,
aff410f1 MS	164	struct value *method_ptr)
0d5de010 DJ	165	{
	166	if (current_cp_abi.method_ptr_to_value == NULL)
	167	error (_("GDB does not support pointers to methods on this target"));
	168	return (*current_cp_abi.method_ptr_to_value) (this_p, method_ptr);
	169	}
	170
c4aeac85 TT	171	/* See cp-abi.h. */
	172
	173	void
	174	cplus_print_vtable (struct value *value)
	175	{
	176	if (current_cp_abi.print_vtable == NULL)
	177	error (_("GDB cannot print the vtable on this target"));
843e694d	178	(*current_cp_abi.print_vtable) (value);
c4aeac85 TT	179	}
c4aeac85 TT	180
6e72ca20 TT	181	/* See cp-abi.h. */
	182
	183	struct value *
	184	cplus_typeid (struct value *value)
	185	{
	186	if (current_cp_abi.get_typeid == NULL)
	187	error (_("GDB cannot find the typeid on this target"));
	188	return (*current_cp_abi.get_typeid) (value);
	189	}
	190
	191	/* See cp-abi.h. */
	192
	193	struct type *
	194	cplus_typeid_type (struct gdbarch *gdbarch)
	195	{
	196	if (current_cp_abi.get_typeid_type == NULL)
	197	error (_("GDB cannot find the type for 'typeid' on this target"));
	198	return (*current_cp_abi.get_typeid_type) (gdbarch);
	199	}
	200
72f1fe8a TT	201	/* See cp-abi.h. */
	202
	203	struct type *
	204	cplus_type_from_type_info (struct value *value)
	205	{
	206	if (current_cp_abi.get_type_from_type_info == NULL)
	207	error (_("GDB cannot find the type from a std::type_info on this target"));
	208	return (*current_cp_abi.get_type_from_type_info) (value);
	209	}
	210
cc16e6c9 TT	211	/* See cp-abi.h. */
cc16e6c9 TT	212
2f408ecb	213	std::string
cc16e6c9 TT	214	cplus_typename_from_type_info (struct value *value)
	215	{
	216	if (current_cp_abi.get_typename_from_type_info == NULL)
	217	error (_("GDB cannot find the type name "
	218	"from a std::type_info on this target"));
	219	return (*current_cp_abi.get_typename_from_type_info) (value);
	220	}
	221
41f1b697 DJ	222	int
	223	cp_pass_by_reference (struct type *type)
	224	{
	225	if ((current_cp_abi.pass_by_reference) == NULL)
	226	return 0;
	227	return (*current_cp_abi.pass_by_reference) (type);
	228	}
	229
fe1f4a5e DJ	230	/* Set the current C++ ABI to SHORT_NAME. */
	231
	232	static int
	233	switch_to_cp_abi (const char *short_name)
	234	{
	235	struct cp_abi_ops *abi;
	236
	237	abi = find_cp_abi (short_name);
	238	if (abi == NULL)
	239	return 0;
	240
	241	current_cp_abi = *abi;
	242	return 1;
	243	}
	244
	245	/* Add ABI to the list of supported C++ ABI's. */
	246
015a42b4	247	int
fe1f4a5e	248	register_cp_abi (struct cp_abi_ops *abi)
015a42b4	249	{
fe1f4a5e DJ	250	if (num_cp_abis == CP_ABI_MAX)
fe1f4a5e DJ	251	internal_error (__FILE__, __LINE__,
3e43a32a MS	252	_("Too many C++ ABIs, please increase "
3e43a32a MS	253	"CP_ABI_MAX in cp-abi.c"));
fe1f4a5e	254
015a42b4 JB	255	cp_abis[num_cp_abis++] = abi;
	256
	257	return 1;
fe1f4a5e DJ	258	}
	259
	260	/* Set the ABI to use in "auto" mode to SHORT_NAME. */
015a42b4	261
fe1f4a5e DJ	262	void
	263	set_cp_abi_as_auto_default (const char *short_name)
	264	{
	265	char new_longname, new_doc;
	266	struct cp_abi_ops *abi = find_cp_abi (short_name);
	267
	268	if (abi == NULL)
	269	internal_error (__FILE__, __LINE__,
e2e0b3e5	270	_("Cannot find C++ ABI \"%s\" to set it as auto default."),
fe1f4a5e DJ	271	short_name);
	272
	273	if (auto_cp_abi.longname != NULL)
	274	xfree ((char *) auto_cp_abi.longname);
	275	if (auto_cp_abi.doc != NULL)
	276	xfree ((char *) auto_cp_abi.doc);
	277
	278	auto_cp_abi = *abi;
	279
	280	auto_cp_abi.shortname = "auto";
0dfdb8ba	281	new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
fe1f4a5e DJ	282	auto_cp_abi.longname = new_longname;
fe1f4a5e DJ	283
0dfdb8ba	284	new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
049742da	285	abi->shortname);
fe1f4a5e DJ	286	auto_cp_abi.doc = new_doc;
	287
	288	/* Since we copy the current ABI into current_cp_abi instead of
	289	using a pointer, if auto is currently the default, we need to
	290	reset it. */
	291	if (strcmp (current_cp_abi.shortname, "auto") == 0)
	292	switch_to_cp_abi ("auto");
015a42b4 JB	293	}
015a42b4 JB	294
fe1f4a5e DJ	295	/* Return the ABI operations associated with SHORT_NAME. */
	296
	297	static struct cp_abi_ops *
	298	find_cp_abi (const char *short_name)
015a42b4 JB	299	{
015a42b4 JB	300	int i;
fe1f4a5e	301
015a42b4	302	for (i = 0; i < num_cp_abis; i++)
fe1f4a5e DJ	303	if (strcmp (cp_abis[i]->shortname, short_name) == 0)
	304	return cp_abis[i];
	305
	306	return NULL;
015a42b4 JB	307	}
015a42b4 JB	308
fe1f4a5e DJ	309	/* Display the list of registered C++ ABIs. */
	310
	311	static void
	312	list_cp_abis (int from_tty)
	313	{
79a45e25	314	struct ui_out *uiout = current_uiout;
fe1f4a5e	315	int i;
fe1f4a5e	316
112e8700	317	uiout->text ("The available C++ ABIs are:\n");
2e783024	318	ui_out_emit_tuple tuple_emitter (uiout, "cp-abi-list");
fe1f4a5e DJ	319	for (i = 0; i < num_cp_abis; i++)
	320	{
	321	char pad[14];
	322	int padcount;
	323
112e8700 SM	324	uiout->text (" ");
112e8700 SM	325	uiout->field_string ("cp-abi", cp_abis[i]->shortname);
fe1f4a5e DJ	326
	327	padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
	328	pad[padcount] = 0;
	329	while (padcount > 0)
	330	pad[--padcount] = ' ';
112e8700	331	uiout->text (pad);
fe1f4a5e	332
112e8700 SM	333	uiout->field_string ("doc", cp_abis[i]->doc);
112e8700 SM	334	uiout->text ("\n");
fe1f4a5e	335	}
fe1f4a5e DJ	336	}
	337
	338	/* Set the current C++ ABI, or display the list of options if no
	339	argument is given. */
	340
	341	static void
4ada038f	342	set_cp_abi_cmd (const char *args, int from_tty)
fe1f4a5e DJ	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". */
db2b2972 TT	355
eb3ff9a5	356	static void
db2b2972	357	cp_abi_completer (struct cmd_list_element *ignore,
eb3ff9a5	358	completion_tracker &tracker,
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	}
db2b2972 TT	372
eb3ff9a5	373	complete_on_enum (tracker, cp_abi_names, text, word);
db2b2972 TT	374	}
db2b2972 TT	375
fe1f4a5e DJ	376	/* Show the currently selected C++ ABI. */
	377
	378	static void
4ada038f	379	show_cp_abi_cmd (const char *args, int from_tty)
fe1f4a5e	380	{
79a45e25 PA	381	struct ui_out *uiout = current_uiout;
79a45e25 PA	382
112e8700	383	uiout->text ("The currently selected C++ ABI is \"");
fe1f4a5e	384
112e8700 SM	385	uiout->field_string ("cp-abi", current_cp_abi.shortname);
	386	uiout->text ("\" (");
	387	uiout->field_string ("longname", current_cp_abi.longname);
	388	uiout->text (").\n");
fe1f4a5e DJ	389	}
	390
	391	void
	392	_initialize_cp_abi (void)
	393	{
db2b2972 TT	394	struct cmd_list_element *c;
db2b2972 TT	395
fe1f4a5e DJ	396	register_cp_abi (&auto_cp_abi);
	397	switch_to_cp_abi ("auto");
	398
db2b2972	399	c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
ac74f770 MS	400	Set the ABI used for inspecting C++ objects.\n\
ac74f770 MS	401	\"set cp-abi\" with no arguments will list the available ABIs."),
db2b2972 TT	402	&setlist);
db2b2972 TT	403	set_cmd_completer (c, cp_abi_completer);
fe1f4a5e DJ	404
fe1f4a5e DJ	405	add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
aff410f1 MS	406	_("Show the ABI used for inspecting C++ objects."),
aff410f1 MS	407	&showlist);
fe1f4a5e	408	}