[deliverable/binutils-gdb.git] / gdb / common / tdesc.c

/* Target description support for GDB.

   Copyright (C) 2018 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 "common-defs.h"
#include "common/tdesc.h"

tdesc_reg::tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
		      int regnum, int save_restore_, const char *group_,
		      int bitsize_, const char *type_)
  : name (name_), target_regnum (regnum),
    save_restore (save_restore_),
    group (group_ != NULL ? group_ : ""),
    bitsize (bitsize_),
    type (type_ != NULL ? type_ : "<unknown>")
{
  /* If the register's type is target-defined, look it up now.  We may not
     have easy access to the containing feature when we want it later.  */
  tdesc_type = tdesc_named_type (feature, type.c_str ());
}

/* Predefined types.  */
static tdesc_type_builtin tdesc_predefined_types[] =
{
  { "bool", TDESC_TYPE_BOOL },
  { "int8", TDESC_TYPE_INT8 },
  { "int16", TDESC_TYPE_INT16 },
  { "int32", TDESC_TYPE_INT32 },
  { "int64", TDESC_TYPE_INT64 },
  { "int128", TDESC_TYPE_INT128 },
  { "uint8", TDESC_TYPE_UINT8 },
  { "uint16", TDESC_TYPE_UINT16 },
  { "uint32", TDESC_TYPE_UINT32 },
  { "uint64", TDESC_TYPE_UINT64 },
  { "uint128", TDESC_TYPE_UINT128 },
  { "code_ptr", TDESC_TYPE_CODE_PTR },
  { "data_ptr", TDESC_TYPE_DATA_PTR },
  { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
  { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
  { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
  { "i387_ext", TDESC_TYPE_I387_EXT }
};

void tdesc_feature::accept (tdesc_element_visitor &v) const
{
  v.visit_pre (this);

  for (const tdesc_type_up &type : types)
    type->accept (v);

  for (const tdesc_reg_up &reg : registers)
    reg->accept (v);

  v.visit_post (this);
}

bool tdesc_feature::operator== (const tdesc_feature &other) const
{
  if (name != other.name)
    return false;

  if (registers.size () != other.registers.size ())
    return false;

  for (int ix = 0; ix < registers.size (); ix++)
    {
      const tdesc_reg_up &reg1 = registers[ix];
      const tdesc_reg_up &reg2 = other.registers[ix];

      if (reg1 != reg2 && *reg1 != *reg2)
	return false;
      }

  if (types.size () != other.types.size ())
    return false;

  for (int ix = 0; ix < types.size (); ix++)
    {
      const tdesc_type_up &type1 = types[ix];
      const tdesc_type_up &type2 = other.types[ix];

      if (type1 != type2 && *type1 != *type2)
	return false;
    }

  return true;
}

/* Lookup a predefined type.  */

static struct tdesc_type *
tdesc_predefined_type (enum tdesc_type_kind kind)
{
  for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
    if (tdesc_predefined_types[ix].kind == kind)
      return &tdesc_predefined_types[ix];

  gdb_assert_not_reached ("bad predefined tdesc type");
}

/* See common/tdesc.h.  */

struct tdesc_type *
tdesc_named_type (const struct tdesc_feature *feature, const char *id)
{
  /* First try target-defined types.  */
  for (const tdesc_type_up &type : feature->types)
    if (type->name == id)
      return type.get ();

  /* Next try the predefined types.  */
  for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
    if (tdesc_predefined_types[ix].name == id)
      return &tdesc_predefined_types[ix];

  return NULL;
}

/* See common/tdesc.h.  */

void
tdesc_create_reg (struct tdesc_feature *feature, const char *name,
		  int regnum, int save_restore, const char *group,
		  int bitsize, const char *type)
{
  tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
				  group, bitsize, type);

  feature->registers.emplace_back (reg);
}

/* See common/tdesc.h.  */

struct tdesc_type *
tdesc_create_vector (struct tdesc_feature *feature, const char *name,
		     struct tdesc_type *field_type, int count)
{
  tdesc_type_vector *type = new tdesc_type_vector (name, field_type, count);
  feature->types.emplace_back (type);

  return type;
}

/* See common/tdesc.h.  */

tdesc_type_with_fields *
tdesc_create_struct (struct tdesc_feature *feature, const char *name)
{
  tdesc_type_with_fields *type
    = new tdesc_type_with_fields (name, TDESC_TYPE_STRUCT);
  feature->types.emplace_back (type);

  return type;
}

/* See common/tdesc.h.  */

void
tdesc_set_struct_size (tdesc_type_with_fields *type, int size)
{
  gdb_assert (type->kind == TDESC_TYPE_STRUCT);
  gdb_assert (size > 0);
  type->size = size;
}

/* See common/tdesc.h.  */

tdesc_type_with_fields *
tdesc_create_union (struct tdesc_feature *feature, const char *name)
{
  tdesc_type_with_fields *type
    = new tdesc_type_with_fields (name, TDESC_TYPE_UNION);
  feature->types.emplace_back (type);

  return type;
}

/* See common/tdesc.h.  */

tdesc_type_with_fields *
tdesc_create_flags (struct tdesc_feature *feature, const char *name,
		    int size)
{
  gdb_assert (size > 0);

  tdesc_type_with_fields *type
    = new tdesc_type_with_fields (name, TDESC_TYPE_FLAGS, size);
  feature->types.emplace_back (type);

  return type;
}

/* See common/tdesc.h.  */

tdesc_type_with_fields *
tdesc_create_enum (struct tdesc_feature *feature, const char *name,
		   int size)
{
  gdb_assert (size > 0);

  tdesc_type_with_fields *type
    = new tdesc_type_with_fields (name, TDESC_TYPE_ENUM, size);
  feature->types.emplace_back (type);

  return type;
}

/* See common/tdesc.h.  */

void
tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
		 struct tdesc_type *field_type)
{
  gdb_assert (type->kind == TDESC_TYPE_UNION
	      || type->kind == TDESC_TYPE_STRUCT);

  /* Initialize start and end so we know this is not a bit-field
     when we print-c-tdesc.  */
  type->fields.emplace_back (field_name, field_type, -1, -1);
}

/* See common/tdesc.h.  */

void
tdesc_add_typed_bitfield (tdesc_type_with_fields *type, const char *field_name,
			  int start, int end, struct tdesc_type *field_type)
{
  gdb_assert (type->kind == TDESC_TYPE_STRUCT
	      || type->kind == TDESC_TYPE_FLAGS);
  gdb_assert (start >= 0 && end >= start);

  type->fields.emplace_back (field_name, field_type, start, end);
}

/* See common/tdesc.h.  */

void
tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
		    int start, int end)
{
  struct tdesc_type *field_type;

  gdb_assert (start >= 0 && end >= start);

  if (type->size > 4)
    field_type = tdesc_predefined_type (TDESC_TYPE_UINT64);
  else
    field_type = tdesc_predefined_type (TDESC_TYPE_UINT32);

  tdesc_add_typed_bitfield (type, field_name, start, end, field_type);
}

/* See common/tdesc.h.  */

void
tdesc_add_flag (tdesc_type_with_fields *type, int start,
		const char *flag_name)
{
  gdb_assert (type->kind == TDESC_TYPE_FLAGS
	      || type->kind == TDESC_TYPE_STRUCT);

  type->fields.emplace_back (flag_name,
			     tdesc_predefined_type (TDESC_TYPE_BOOL),
			     start, start);
}

/* See common/tdesc.h.  */

void
tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
		      const char *name)
{
  gdb_assert (type->kind == TDESC_TYPE_ENUM);
  type->fields.emplace_back (name,
			     tdesc_predefined_type (TDESC_TYPE_INT32),
			     value, -1);
}

void print_xml_feature::visit_pre (const tdesc_feature *e)
{
  string_appendf (*m_buffer, "<feature name=\"%s\">\n", e->name.c_str ());
}

void print_xml_feature::visit_post (const tdesc_feature *e)
{
  string_appendf (*m_buffer, "</feature>\n");
}

void print_xml_feature::visit (const tdesc_type_builtin *t)
{
  error (_("xml output is not supported for type \"%s\"."), t->name.c_str ());
}

void print_xml_feature::visit (const tdesc_type_vector *t)
{
  string_appendf (*m_buffer, "<vector id=\"%s\" type=\"%s\" count=\"%d\"/>\n",
		  t->name.c_str (), t->element_type->name.c_str (), t->count);
}

void print_xml_feature::visit (const tdesc_type_with_fields *t)
{
  const static char *types[] = { "struct", "union", "flags", "enum" };

  gdb_assert (t->kind >= TDESC_TYPE_STRUCT && t->kind <= TDESC_TYPE_ENUM);

  string_appendf (*m_buffer,
		  "<%s id=\"%s\"", types[t->kind - TDESC_TYPE_STRUCT],
		  t->name.c_str ());

  switch (t->kind)
    {
    case TDESC_TYPE_STRUCT:
    case TDESC_TYPE_FLAGS:
      if (t->size > 0)
	string_appendf (*m_buffer, " size=\"%d\"", t->size);
      string_appendf (*m_buffer, ">\n");

      for (const tdesc_type_field &f : t->fields)
	{
	  string_appendf (*m_buffer, "  <field name=\"%s\" ", f.name.c_str ());
	  if (f.start == -1)
	    string_appendf (*m_buffer, "type=\"%s\"/>\n",
			    f.type->name.c_str ());
	  else
	    string_appendf (*m_buffer, "start=\"%d\" end=\"%d\"/>\n", f.start,
			    f.end);
	}
      break;

    case TDESC_TYPE_ENUM:
      string_appendf (*m_buffer, ">\n");
      for (const tdesc_type_field &f : t->fields)
	string_appendf (*m_buffer, "  <field name=\"%s\" start=\"%d\"/>\n",
			f.name.c_str (), f.start);
      break;

    case TDESC_TYPE_UNION:
      string_appendf (*m_buffer, ">\n");
      for (const tdesc_type_field &f : t->fields)
	string_appendf (*m_buffer, "  <field name=\"%s\" type=\"%s\"/>\n",
			f.name.c_str (), f.type->name.c_str ());
      break;

    default:
      error (_("xml output is not supported for type \"%s\"."),
	     t->name.c_str ());
    }

  string_appendf (*m_buffer, "</%s>\n", types[t->kind - TDESC_TYPE_STRUCT]);
}

void print_xml_feature::visit (const tdesc_reg *r)
{
  string_appendf (*m_buffer,
		  "<reg name=\"%s\" bitsize=\"%d\" type=\"%s\" regnum=\"%ld\"",
		  r->name.c_str (), r->bitsize, r->type.c_str (),
		  r->target_regnum);

  if (r->group.length () > 0)
    string_appendf (*m_buffer, " group=\"%s\"", r->group.c_str ());

  if (r->save_restore == 0)
    string_appendf (*m_buffer, " save-restore=\"no\"");

  string_appendf (*m_buffer, "/>\n");
}

void print_xml_feature::visit_pre (const target_desc *e)
{
#ifndef IN_PROCESS_AGENT
  string_appendf (*m_buffer, "<?xml version=\"1.0\"?>\n");
  string_appendf (*m_buffer, "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n");
  string_appendf (*m_buffer, "<target>\n<architecture>%s</architecture>\n",
		  tdesc_architecture_name (e));

  const char *osabi = tdesc_osabi_name (e);
  if (osabi != nullptr)
    string_appendf (*m_buffer, "<osabi>%s</osabi>", osabi);
#endif
}

void print_xml_feature::visit_post (const target_desc *e)
{
  string_appendf (*m_buffer, "</target>\n");
}
Commit	Line	Data
ea3e7d71 AH	1	/* Target description support for GDB.
	2
	3	Copyright (C) 2018 Free Software Foundation, Inc.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	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
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "common-defs.h"
	21	#include "common/tdesc.h"
	22
	23	tdesc_reg::tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
	24	int regnum, int save_restore_, const char *group_,
	25	int bitsize_, const char *type_)
	26	: name (name_), target_regnum (regnum),
	27	save_restore (save_restore_),
	28	group (group_ != NULL ? group_ : ""),
	29	bitsize (bitsize_),
	30	type (type_ != NULL ? type_ : "<unknown>")
	31	{
	32	/* If the register's type is target-defined, look it up now. We may not
	33	have easy access to the containing feature when we want it later. */
	34	tdesc_type = tdesc_named_type (feature, type.c_str ());
	35	}
82ec9bc7	36
eee8a18d AH	37	/* Predefined types. */
	38	static tdesc_type_builtin tdesc_predefined_types[] =
	39	{
	40	{ "bool", TDESC_TYPE_BOOL },
	41	{ "int8", TDESC_TYPE_INT8 },
	42	{ "int16", TDESC_TYPE_INT16 },
	43	{ "int32", TDESC_TYPE_INT32 },
	44	{ "int64", TDESC_TYPE_INT64 },
	45	{ "int128", TDESC_TYPE_INT128 },
	46	{ "uint8", TDESC_TYPE_UINT8 },
	47	{ "uint16", TDESC_TYPE_UINT16 },
	48	{ "uint32", TDESC_TYPE_UINT32 },
	49	{ "uint64", TDESC_TYPE_UINT64 },
	50	{ "uint128", TDESC_TYPE_UINT128 },
	51	{ "code_ptr", TDESC_TYPE_CODE_PTR },
	52	{ "data_ptr", TDESC_TYPE_DATA_PTR },
	53	{ "ieee_single", TDESC_TYPE_IEEE_SINGLE },
	54	{ "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
	55	{ "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
	56	{ "i387_ext", TDESC_TYPE_I387_EXT }
	57	};
	58
82ec9bc7 AH	59	void tdesc_feature::accept (tdesc_element_visitor &v) const
	60	{
	61	v.visit_pre (this);
	62
	63	for (const tdesc_type_up &type : types)
	64	type->accept (v);
	65
	66	for (const tdesc_reg_up &reg : registers)
	67	reg->accept (v);
	68
	69	v.visit_post (this);
	70	}
	71
	72	bool tdesc_feature::operator== (const tdesc_feature &other) const
	73	{
	74	if (name != other.name)
	75	return false;
	76
	77	if (registers.size () != other.registers.size ())
	78	return false;
	79
	80	for (int ix = 0; ix < registers.size (); ix++)
	81	{
	82	const tdesc_reg_up &reg1 = registers[ix];
	83	const tdesc_reg_up &reg2 = other.registers[ix];
	84
	85	if (reg1 != reg2 && reg1 != reg2)
	86	return false;
	87	}
	88
	89	if (types.size () != other.types.size ())
	90	return false;
	91
	92	for (int ix = 0; ix < types.size (); ix++)
	93	{
	94	const tdesc_type_up &type1 = types[ix];
	95	const tdesc_type_up &type2 = other.types[ix];
	96
	97	if (type1 != type2 && type1 != type2)
	98	return false;
	99	}
	100
	101	return true;
	102	}
	103
eee8a18d AH	104	/* Lookup a predefined type. */
	105
	106	static struct tdesc_type *
	107	tdesc_predefined_type (enum tdesc_type_kind kind)
	108	{
	109	for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
	110	if (tdesc_predefined_types[ix].kind == kind)
	111	return &tdesc_predefined_types[ix];
	112
	113	gdb_assert_not_reached ("bad predefined tdesc type");
	114	}
	115
	116	/* See common/tdesc.h. */
	117
	118	struct tdesc_type *
	119	tdesc_named_type (const struct tdesc_feature feature, const char id)
	120	{
	121	/* First try target-defined types. */
	122	for (const tdesc_type_up &type : feature->types)
	123	if (type->name == id)
	124	return type.get ();
	125
	126	/* Next try the predefined types. */
	127	for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
	128	if (tdesc_predefined_types[ix].name == id)
	129	return &tdesc_predefined_types[ix];
	130
	131	return NULL;
	132	}
	133
82ec9bc7 AH	134	/* See common/tdesc.h. */
	135
	136	void
	137	tdesc_create_reg (struct tdesc_feature feature, const char name,
	138	int regnum, int save_restore, const char *group,
	139	int bitsize, const char *type)
	140	{
	141	tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
	142	group, bitsize, type);
	143
	144	feature->registers.emplace_back (reg);
	145	}
eee8a18d AH	146
	147	/* See common/tdesc.h. */
	148
	149	struct tdesc_type *
	150	tdesc_create_vector (struct tdesc_feature feature, const char name,
	151	struct tdesc_type *field_type, int count)
	152	{
	153	tdesc_type_vector *type = new tdesc_type_vector (name, field_type, count);
	154	feature->types.emplace_back (type);
	155
	156	return type;
	157	}
	158
	159	/* See common/tdesc.h. */
	160
	161	tdesc_type_with_fields *
	162	tdesc_create_struct (struct tdesc_feature feature, const char name)
	163	{
	164	tdesc_type_with_fields *type
	165	= new tdesc_type_with_fields (name, TDESC_TYPE_STRUCT);
	166	feature->types.emplace_back (type);
	167
	168	return type;
	169	}
	170
	171	/* See common/tdesc.h. */
	172
	173	void
	174	tdesc_set_struct_size (tdesc_type_with_fields *type, int size)
	175	{
	176	gdb_assert (type->kind == TDESC_TYPE_STRUCT);
	177	gdb_assert (size > 0);
	178	type->size = size;
	179	}
	180
	181	/* See common/tdesc.h. */
	182
	183	tdesc_type_with_fields *
	184	tdesc_create_union (struct tdesc_feature feature, const char name)
	185	{
	186	tdesc_type_with_fields *type
	187	= new tdesc_type_with_fields (name, TDESC_TYPE_UNION);
	188	feature->types.emplace_back (type);
	189
	190	return type;
	191	}
	192
	193	/* See common/tdesc.h. */
	194
	195	tdesc_type_with_fields *
	196	tdesc_create_flags (struct tdesc_feature feature, const char name,
	197	int size)
	198	{
	199	gdb_assert (size > 0);
	200
	201	tdesc_type_with_fields *type
	202	= new tdesc_type_with_fields (name, TDESC_TYPE_FLAGS, size);
	203	feature->types.emplace_back (type);
	204
	205	return type;
	206	}
	207
	208	/* See common/tdesc.h. */
	209
210	tdesc_type_with_fields *
211	tdesc_create_enum (struct tdesc_feature feature, const char name,
212	int size)
213	{
214	gdb_assert (size > 0);
215
216	tdesc_type_with_fields *type
217	= new tdesc_type_with_fields (name, TDESC_TYPE_ENUM, size);
218	feature->types.emplace_back (type);
219
220	return type;
221	}
222
223	/* See common/tdesc.h. */
224
225	void
226	tdesc_add_field (tdesc_type_with_fields type, const char field_name,
227	struct tdesc_type *field_type)
228	{
229	gdb_assert (type->kind == TDESC_TYPE_UNION
230	\|\| type->kind == TDESC_TYPE_STRUCT);
231
232	/* Initialize start and end so we know this is not a bit-field
233	when we print-c-tdesc. */
234	type->fields.emplace_back (field_name, field_type, -1, -1);
235	}
236
237	/* See common/tdesc.h. */
238
239	void
240	tdesc_add_typed_bitfield (tdesc_type_with_fields type, const char field_name,
241	int start, int end, struct tdesc_type *field_type)
242	{
243	gdb_assert (type->kind == TDESC_TYPE_STRUCT
244	\|\| type->kind == TDESC_TYPE_FLAGS);
245	gdb_assert (start >= 0 && end >= start);
246
247	type->fields.emplace_back (field_name, field_type, start, end);
248	}
249
250	/* See common/tdesc.h. */
251
252	void
253	tdesc_add_bitfield (tdesc_type_with_fields type, const char field_name,
254	int start, int end)
255	{
256	struct tdesc_type *field_type;
257
258	gdb_assert (start >= 0 && end >= start);
259
260	if (type->size > 4)
261	field_type = tdesc_predefined_type (TDESC_TYPE_UINT64);
262	else
263	field_type = tdesc_predefined_type (TDESC_TYPE_UINT32);
264
265	tdesc_add_typed_bitfield (type, field_name, start, end, field_type);
266	}
267
268	/* See common/tdesc.h. */
269
270	void
271	tdesc_add_flag (tdesc_type_with_fields *type, int start,
272	const char *flag_name)
273	{
274	gdb_assert (type->kind == TDESC_TYPE_FLAGS
275	\|\| type->kind == TDESC_TYPE_STRUCT);
276
277	type->fields.emplace_back (flag_name,
278	tdesc_predefined_type (TDESC_TYPE_BOOL),
279	start, start);
280	}
281
282	/* See common/tdesc.h. */
283
284	void
285	tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
286	const char *name)
287	{
288	gdb_assert (type->kind == TDESC_TYPE_ENUM);
289	type->fields.emplace_back (name,
290	tdesc_predefined_type (TDESC_TYPE_INT32),
291	value, -1);
292	}
e98577a9 AH	293
	294	void print_xml_feature::visit_pre (const tdesc_feature *e)
	295	{
	296	string_appendf (*m_buffer, "<feature name=\"%s\">\n", e->name.c_str ());
	297	}
	298
	299	void print_xml_feature::visit_post (const tdesc_feature *e)
	300	{
	301	string_appendf (*m_buffer, "</feature>\n");
	302	}
	303
	304	void print_xml_feature::visit (const tdesc_type_builtin *t)
	305	{
	306	error (_("xml output is not supported for type \"%s\"."), t->name.c_str ());
	307	}
	308
	309	void print_xml_feature::visit (const tdesc_type_vector *t)
	310	{
	311	string_appendf (*m_buffer, "<vector id=\"%s\" type=\"%s\" count=\"%d\"/>\n",
	312	t->name.c_str (), t->element_type->name.c_str (), t->count);
	313	}
	314
	315	void print_xml_feature::visit (const tdesc_type_with_fields *t)
	316	{
e98577a9 AH	317	const static char *types[] = { "struct", "union", "flags", "enum" };
	318
	319	gdb_assert (t->kind >= TDESC_TYPE_STRUCT && t->kind <= TDESC_TYPE_ENUM);
	320
	321	string_appendf (*m_buffer,
	322	"<%s id=\"%s\"", types[t->kind - TDESC_TYPE_STRUCT],
	323	t->name.c_str ());
	324
	325	switch (t->kind)
	326	{
	327	case TDESC_TYPE_STRUCT:
	328	case TDESC_TYPE_FLAGS:
	329	if (t->size > 0)
	330	string_appendf (*m_buffer, " size=\"%d\"", t->size);
	331	string_appendf (*m_buffer, ">\n");
	332
	333	for (const tdesc_type_field &f : t->fields)
	334	{
	335	string_appendf (*m_buffer, " <field name=\"%s\" ", f.name.c_str ());
	336	if (f.start == -1)
	337	string_appendf (*m_buffer, "type=\"%s\"/>\n",
	338	f.type->name.c_str ());
	339	else
	340	string_appendf (*m_buffer, "start=\"%d\" end=\"%d\"/>\n", f.start,
	341	f.end);
	342	}
	343	break;
	344
	345	case TDESC_TYPE_ENUM:
	346	string_appendf (*m_buffer, ">\n");
	347	for (const tdesc_type_field &f : t->fields)
	348	string_appendf (*m_buffer, " <field name=\"%s\" start=\"%d\"/>\n",
	349	f.name.c_str (), f.start);
	350	break;
	351
	352	case TDESC_TYPE_UNION:
	353	string_appendf (*m_buffer, ">\n");
	354	for (const tdesc_type_field &f : t->fields)
	355	string_appendf (*m_buffer, " <field name=\"%s\" type=\"%s\"/>\n",
	356	f.name.c_str (), f.type->name.c_str ());
	357	break;
	358
	359	default:
	360	error (_("xml output is not supported for type \"%s\"."),
	361	t->name.c_str ());
	362	}
	363
	364	string_appendf (*m_buffer, "</%s>\n", types[t->kind - TDESC_TYPE_STRUCT]);
	365	}
	366
	367	void print_xml_feature::visit (const tdesc_reg *r)
	368	{
	369	string_appendf (*m_buffer,
	370	"<reg name=\"%s\" bitsize=\"%d\" type=\"%s\" regnum=\"%ld\"",
	371	r->name.c_str (), r->bitsize, r->type.c_str (),
	372	r->target_regnum);
	373
	374	if (r->group.length () > 0)
	375	string_appendf (*m_buffer, " group=\"%s\"", r->group.c_str ());
	376
	377	if (r->save_restore == 0)
	378	string_appendf (*m_buffer, " save-restore=\"no\"");
	379
	380	string_appendf (*m_buffer, "/>\n");
381	}
382
383	void print_xml_feature::visit_pre (const target_desc *e)
384	{
385	#ifndef IN_PROCESS_AGENT
386	string_appendf (*m_buffer, "<?xml version=\"1.0\"?>\n");
387	string_appendf (*m_buffer, "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n");
388	string_appendf (*m_buffer, "<target>\n<architecture>%s</architecture>\n",
389	tdesc_architecture_name (e));
390
391	const char *osabi = tdesc_osabi_name (e);
392	if (osabi != nullptr)
393	string_appendf (*m_buffer, "<osabi>%s</osabi>", osabi);
394	#endif
395	}
396
397	void print_xml_feature::visit_post (const target_desc *e)
398	{
399	string_appendf (*m_buffer, "</target>\n");
400	}