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

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

   Copyright (C) 2001-2013 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "value.h"
#include "cp-abi.h"
#include "command.h"
#include "exceptions.h"
#include "gdbcmd.h"
#include "ui-out.h"
#include "gdb_assert.h"
#include "gdb_string.h"

static struct cp_abi_ops *find_cp_abi (const char *short_name);

static struct cp_abi_ops current_cp_abi = { "", NULL };
static struct cp_abi_ops auto_cp_abi = { "auto", NULL };

#define CP_ABI_MAX 8
static struct cp_abi_ops *cp_abis[CP_ABI_MAX];
static int num_cp_abis = 0;

enum ctor_kinds
is_constructor_name (const char *name)
{
  if ((current_cp_abi.is_constructor_name) == NULL)
    error (_("ABI doesn't define required function is_constructor_name"));
  return (*current_cp_abi.is_constructor_name) (name);
}

enum dtor_kinds
is_destructor_name (const char *name)
{
  if ((current_cp_abi.is_destructor_name) == NULL)
    error (_("ABI doesn't define required function is_destructor_name"));
  return (*current_cp_abi.is_destructor_name) (name);
}

int
is_vtable_name (const char *name)
{
  if ((current_cp_abi.is_vtable_name) == NULL)
    error (_("ABI doesn't define required function is_vtable_name"));
  return (*current_cp_abi.is_vtable_name) (name);
}

int
is_operator_name (const char *name)
{
  if ((current_cp_abi.is_operator_name) == NULL)
    error (_("ABI doesn't define required function is_operator_name"));
  return (*current_cp_abi.is_operator_name) (name);
}

int
baseclass_offset (struct type *type, int index, const gdb_byte *valaddr,
		  int embedded_offset, CORE_ADDR address,
		  const struct value *val)
{
  volatile struct gdb_exception ex;
  int res = 0;

  gdb_assert (current_cp_abi.baseclass_offset != NULL);

  TRY_CATCH (ex, RETURN_MASK_ERROR)
    {
      res = (*current_cp_abi.baseclass_offset) (type, index, valaddr,
						embedded_offset,
						address, val);
    }

  if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
    throw_error (NOT_AVAILABLE_ERROR,
		 _("Cannot determine virtual baseclass offset "
		   "of incomplete object"));
  else if (ex.reason < 0)
    throw_exception (ex);
  else
    return res;
}

struct value *
value_virtual_fn_field (struct value **arg1p,
			struct fn_field *f, int j,
			struct type *type, int offset)
{
  if ((current_cp_abi.virtual_fn_field) == NULL)
    return NULL;
  return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
					     type, offset);
}

struct type *
value_rtti_type (struct value *v, int *full,
		 int *top, int *using_enc)
{
  struct type *ret = NULL;
  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);
}

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