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

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

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

   This file is part of GDB.

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

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

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

#include "defs.h"
#include "value.h"
#include "cp-abi.h"
#include "command.h"
#include "gdbcmd.h"
#include "ui-out.h"
static struct cp_abi_ops *find_cp_abi (const char *short_name);

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

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

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

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

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

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

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

  gdb_assert (current_cp_abi.baseclass_offset != NULL);

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