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

/* Copyright (C) 2006-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/>.  */

#ifndef ARCH_TDESC_H
#define ARCH_TDESC_H 1

struct tdesc_feature;
struct tdesc_type;
struct tdesc_type_builtin;
struct tdesc_type_vector;
struct tdesc_type_with_fields;
struct tdesc_reg;
struct target_desc;

/* The interface to visit different elements of target description.  */

class tdesc_element_visitor
{
public:
  virtual void visit_pre (const target_desc *e)
  {}

  virtual void visit_post (const target_desc *e)
  {}

  virtual void visit_pre (const tdesc_feature *e)
  {}

  virtual void visit_post (const tdesc_feature *e)
  {}

  virtual void visit (const tdesc_type_builtin *e)
  {}

  virtual void visit (const tdesc_type_vector *e)
  {}

  virtual void visit (const tdesc_type_with_fields *e)
  {}

  virtual void visit (const tdesc_reg *e)
  {}
};

class tdesc_element
{
public:
  virtual void accept (tdesc_element_visitor &v) const = 0;
};

/* An individual register from a target description.  */

struct tdesc_reg : tdesc_element
{
  tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
	     int regnum, int save_restore_, const char *group_,
	     int bitsize_, const char *type_);

  virtual ~tdesc_reg () = default;

  DISABLE_COPY_AND_ASSIGN (tdesc_reg);

  /* The name of this register.  In standard features, it may be
     recognized by the architecture support code, or it may be purely
     for the user.  */
  std::string name;

  /* The register number used by this target to refer to this
     register.  This is used for remote p/P packets and to determine
     the ordering of registers in the remote g/G packets.  */
  long target_regnum;

  /* If this flag is set, GDB should save and restore this register
     around calls to an inferior function.  */
  int save_restore;

  /* The name of the register group containing this register, or empty
     if the group should be automatically determined from the
     register's type.  If this is "general", "float", or "vector", the
     corresponding "info" command should display this register's
     value.  It can be an arbitrary string, but should be limited to
     alphanumeric characters and internal hyphens.  Currently other
     strings are ignored (treated as empty).  */
  std::string group;

  /* The size of the register, in bits.  */
  int bitsize;

  /* The type of the register.  This string corresponds to either
     a named type from the target description or a predefined
     type from GDB.  */
  std::string type;

  /* The target-described type corresponding to TYPE, if found.  */
  struct tdesc_type *tdesc_type;

  void accept (tdesc_element_visitor &v) const override
  {
    v.visit (this);
  }

  bool operator== (const tdesc_reg &other) const
  {
    return (name == other.name
       && target_regnum == other.target_regnum
       && save_restore == other.save_restore
       && bitsize == other.bitsize
       && group == other.group
       && type == other.type);
  }

  bool operator!= (const tdesc_reg &other) const
  {
    return !(*this == other);
  }
};

typedef std::unique_ptr<tdesc_reg> tdesc_reg_up;

enum tdesc_type_kind
{
  /* Predefined types.  */
  TDESC_TYPE_BOOL,
  TDESC_TYPE_INT8,
  TDESC_TYPE_INT16,
  TDESC_TYPE_INT32,
  TDESC_TYPE_INT64,
  TDESC_TYPE_INT128,
  TDESC_TYPE_UINT8,
  TDESC_TYPE_UINT16,
  TDESC_TYPE_UINT32,
  TDESC_TYPE_UINT64,
  TDESC_TYPE_UINT128,
  TDESC_TYPE_CODE_PTR,
  TDESC_TYPE_DATA_PTR,
  TDESC_TYPE_IEEE_SINGLE,
  TDESC_TYPE_IEEE_DOUBLE,
  TDESC_TYPE_ARM_FPA_EXT,
  TDESC_TYPE_I387_EXT,

  /* Types defined by a target feature.  */
  TDESC_TYPE_VECTOR,
  TDESC_TYPE_STRUCT,
  TDESC_TYPE_UNION,
  TDESC_TYPE_FLAGS,
  TDESC_TYPE_ENUM
};

struct tdesc_type : tdesc_element
{
  tdesc_type (const std::string &name_, enum tdesc_type_kind kind_)
    : name (name_), kind (kind_)
  {}

  virtual ~tdesc_type () = default;

  DISABLE_COPY_AND_ASSIGN (tdesc_type);

  /* The name of this type.  */
  std::string name;

  /* Identify the kind of this type.  */
  enum tdesc_type_kind kind;

  bool operator== (const tdesc_type &other) const
  {
    return name == other.name && kind == other.kind;
  }

  bool operator!= (const tdesc_type &other) const
  {
    return !(*this == other);
  }
};

typedef std::unique_ptr<tdesc_type> tdesc_type_up;

struct tdesc_type_builtin : tdesc_type
{
  tdesc_type_builtin (const std::string &name, enum tdesc_type_kind kind)
  : tdesc_type (name, kind)
  {}

  void accept (tdesc_element_visitor &v) const override
  {
    v.visit (this);
  }
};

/* tdesc_type for vector types.  */

struct tdesc_type_vector : tdesc_type
{
  tdesc_type_vector (const std::string &name, tdesc_type *element_type_,
		     int count_)
  : tdesc_type (name, TDESC_TYPE_VECTOR),
    element_type (element_type_), count (count_)
  {}

  void accept (tdesc_element_visitor &v) const override
  {
    v.visit (this);
  }

  struct tdesc_type *element_type;
  int count;
};

/* A named type from a target description.  */

struct tdesc_type_field
{
  tdesc_type_field (const std::string &name_, tdesc_type *type_,
		    int start_, int end_)
  : name (name_), type (type_), start (start_), end (end_)
  {}

  std::string name;
  struct tdesc_type *type;
  /* For non-enum-values, either both are -1 (non-bitfield), or both are
     not -1 (bitfield).  For enum values, start is the value (which could be
     -1), end is -1.  */
  int start, end;
};

/* tdesc_type for struct, union, flags, and enum types.  */

struct tdesc_type_with_fields : tdesc_type
{
  tdesc_type_with_fields (const std::string &name, tdesc_type_kind kind,
			  int size_ = 0)
  : tdesc_type (name, kind), size (size_)
  {}

  void accept (tdesc_element_visitor &v) const override
  {
    v.visit (this);
  }

  std::vector<tdesc_type_field> fields;
  int size;
};

/* A feature from a target description.  Each feature is a collection
   of other elements, e.g. registers and types.  */

struct tdesc_feature : tdesc_element
{
  tdesc_feature (const std::string &name_)
    : name (name_)
  {}

  virtual ~tdesc_feature () = default;

  DISABLE_COPY_AND_ASSIGN (tdesc_feature);

  /* The name of this feature.  It may be recognized by the architecture
     support code.  */
  std::string name;

  /* The registers associated with this feature.  */
  std::vector<tdesc_reg_up> registers;

  /* The types associated with this feature.  */
  std::vector<tdesc_type_up> types;

  void accept (tdesc_element_visitor &v) const override;

  bool operator== (const tdesc_feature &other) const;

  bool operator!= (const tdesc_feature &other) const
  {
    return !(*this == other);
  }
};

typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;

/* Allocate a new target_desc.  */
target_desc *allocate_target_description (void);

/* Set TARGET_DESC's architecture by NAME.  */
void set_tdesc_architecture (target_desc *target_desc,
			     const char *name);

/* Set TARGET_DESC's osabi by NAME.  */
void set_tdesc_osabi (target_desc *target_desc, const char *name);

/* Return the type associated with ID in the context of FEATURE, or
   NULL if none.  */
struct tdesc_type *tdesc_named_type (const struct tdesc_feature *feature,
				     const char *id);

/* Return the created feature named NAME in target description TDESC.  */
struct tdesc_feature *tdesc_create_feature (struct target_desc *tdesc,
					    const char *name,
					    const char *xml = nullptr);


/* Return the created vector tdesc_type named NAME in FEATURE.  */
struct tdesc_type *tdesc_create_vector (struct tdesc_feature *feature,
					const char *name,
					struct tdesc_type *field_type,
					int count);

/* Return the created struct tdesc_type named NAME in FEATURE.  */
tdesc_type_with_fields *tdesc_create_struct (struct tdesc_feature *feature,
					     const char *name);

/* Return the created union tdesc_type named NAME in FEATURE.  */
tdesc_type_with_fields *tdesc_create_union (struct tdesc_feature *feature,
					    const char *name);

/* Return the created flags tdesc_type named NAME in FEATURE.  */
tdesc_type_with_fields *tdesc_create_flags (struct tdesc_feature *feature,
					    const char *name,
					    int size);

/* Return the created enum tdesc_type named NAME in FEATURE.  */
tdesc_type_with_fields *tdesc_create_enum (struct tdesc_feature *feature,
					   const char *name,
					   int size);

/* Add a new field to TYPE.  FIELD_NAME is its name, and FIELD_TYPE is
   its type.  */
void tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
		      struct tdesc_type *field_type);

/* Add a new bitfield to TYPE, with range START to END.  FIELD_NAME is its name,
   and FIELD_TYPE is its type.  */
void tdesc_add_typed_bitfield (tdesc_type_with_fields *type,
			       const char *field_name,
			       int start, int end,
			       struct tdesc_type *field_type);

/* Set the total length of TYPE.  Structs which contain bitfields may
   omit the reserved bits, so the end of the last field may not
   suffice.  */
void tdesc_set_struct_size (tdesc_type_with_fields *type, int size);

/* Add a new untyped bitfield to TYPE.
   Untyped bitfields become either uint32 or uint64 depending on the size
   of the underlying type.  */
void tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
			 int start, int end);

/* A flag is just a typed(bool) single-bit bitfield.
   This function is kept to minimize changes in generated files.  */
void tdesc_add_flag (tdesc_type_with_fields *type, int start,
		     const char *flag_name);

/* Add field with VALUE and NAME to the enum TYPE.  */
void tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
			   const char *name);

/* Create a register in feature FEATURE.  */
void tdesc_create_reg (struct tdesc_feature *feature, const char *name,
		       int regnum, int save_restore, const char *group,
		       int bitsize, const char *type);

#endif /* ARCH_TDESC_H */
Commit	Line	Data
e2882c85	1	/* Copyright (C) 2006-2018 Free Software Foundation, Inc.
f49ff000 YQ	2
	3	This file is part of GDB.
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	#ifndef ARCH_TDESC_H
	19	#define ARCH_TDESC_H 1
	20
	21	struct tdesc_feature;
	22	struct tdesc_type;
d4a0e8b5 SM	23	struct tdesc_type_builtin;
	24	struct tdesc_type_vector;
	25	struct tdesc_type_with_fields;
f49ff000 YQ	26	struct tdesc_reg;
	27	struct target_desc;
	28
ea3e7d71 AH	29	/* The interface to visit different elements of target description. */
	30
	31	class tdesc_element_visitor
	32	{
	33	public:
	34	virtual void visit_pre (const target_desc *e)
	35	{}
	36
	37	virtual void visit_post (const target_desc *e)
	38	{}
	39
	40	virtual void visit_pre (const tdesc_feature *e)
	41	{}
	42
	43	virtual void visit_post (const tdesc_feature *e)
	44	{}
	45
	46	virtual void visit (const tdesc_type_builtin *e)
	47	{}
	48
	49	virtual void visit (const tdesc_type_vector *e)
	50	{}
	51
	52	virtual void visit (const tdesc_type_with_fields *e)
	53	{}
	54
	55	virtual void visit (const tdesc_reg *e)
	56	{}
	57	};
	58
	59	class tdesc_element
	60	{
	61	public:
	62	virtual void accept (tdesc_element_visitor &v) const = 0;
	63	};
	64
	65	/* An individual register from a target description. */
	66
	67	struct tdesc_reg : tdesc_element
	68	{
	69	tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
	70	int regnum, int save_restore_, const char *group_,
	71	int bitsize_, const char *type_);
	72
	73	virtual ~tdesc_reg () = default;
	74
	75	DISABLE_COPY_AND_ASSIGN (tdesc_reg);
	76
	77	/* The name of this register. In standard features, it may be
	78	recognized by the architecture support code, or it may be purely
	79	for the user. */
	80	std::string name;
	81
	82	/* The register number used by this target to refer to this
	83	register. This is used for remote p/P packets and to determine
	84	the ordering of registers in the remote g/G packets. */
	85	long target_regnum;
	86
	87	/* If this flag is set, GDB should save and restore this register
	88	around calls to an inferior function. */
	89	int save_restore;
	90
	91	/* The name of the register group containing this register, or empty
	92	if the group should be automatically determined from the
93	register's type. If this is "general", "float", or "vector", the
94	corresponding "info" command should display this register's
95	value. It can be an arbitrary string, but should be limited to
96	alphanumeric characters and internal hyphens. Currently other
97	strings are ignored (treated as empty). */
98	std::string group;
99
100	/* The size of the register, in bits. */
101	int bitsize;
102
103	/* The type of the register. This string corresponds to either
104	a named type from the target description or a predefined
105	type from GDB. */
106	std::string type;
107
108	/* The target-described type corresponding to TYPE, if found. */
109	struct tdesc_type *tdesc_type;
110
111	void accept (tdesc_element_visitor &v) const override
112	{
113	v.visit (this);
114	}
115
116	bool operator== (const tdesc_reg &other) const
117	{
118	return (name == other.name
119	&& target_regnum == other.target_regnum
120	&& save_restore == other.save_restore
121	&& bitsize == other.bitsize
122	&& group == other.group
123	&& type == other.type);
124	}
125
126	bool operator!= (const tdesc_reg &other) const
127	{
128	return !(*this == other);
129	}
130	};
131
132	typedef std::unique_ptr<tdesc_reg> tdesc_reg_up;
133
82ec9bc7 AH	134	enum tdesc_type_kind
	135	{
	136	/* Predefined types. */
	137	TDESC_TYPE_BOOL,
	138	TDESC_TYPE_INT8,
	139	TDESC_TYPE_INT16,
	140	TDESC_TYPE_INT32,
	141	TDESC_TYPE_INT64,
	142	TDESC_TYPE_INT128,
	143	TDESC_TYPE_UINT8,
	144	TDESC_TYPE_UINT16,
	145	TDESC_TYPE_UINT32,
	146	TDESC_TYPE_UINT64,
	147	TDESC_TYPE_UINT128,
	148	TDESC_TYPE_CODE_PTR,
	149	TDESC_TYPE_DATA_PTR,
	150	TDESC_TYPE_IEEE_SINGLE,
	151	TDESC_TYPE_IEEE_DOUBLE,
	152	TDESC_TYPE_ARM_FPA_EXT,
	153	TDESC_TYPE_I387_EXT,
	154
	155	/* Types defined by a target feature. */
	156	TDESC_TYPE_VECTOR,
	157	TDESC_TYPE_STRUCT,
	158	TDESC_TYPE_UNION,
	159	TDESC_TYPE_FLAGS,
	160	TDESC_TYPE_ENUM
	161	};
	162
	163	struct tdesc_type : tdesc_element
	164	{
	165	tdesc_type (const std::string &name_, enum tdesc_type_kind kind_)
	166	: name (name_), kind (kind_)
	167	{}
	168
	169	virtual ~tdesc_type () = default;
	170
	171	DISABLE_COPY_AND_ASSIGN (tdesc_type);
	172
	173	/* The name of this type. */
	174	std::string name;
	175
	176	/* Identify the kind of this type. */
	177	enum tdesc_type_kind kind;
	178
	179	bool operator== (const tdesc_type &other) const
	180	{
	181	return name == other.name && kind == other.kind;
	182	}
	183
	184	bool operator!= (const tdesc_type &other) const
	185	{
	186	return !(*this == other);
	187	}
	188	};
	189
	190	typedef std::unique_ptr<tdesc_type> tdesc_type_up;
	191
eee8a18d AH	192	struct tdesc_type_builtin : tdesc_type
	193	{
	194	tdesc_type_builtin (const std::string &name, enum tdesc_type_kind kind)
	195	: tdesc_type (name, kind)
	196	{}
	197
	198	void accept (tdesc_element_visitor &v) const override
	199	{
	200	v.visit (this);
	201	}
	202	};
	203
	204	/* tdesc_type for vector types. */
	205
	206	struct tdesc_type_vector : tdesc_type
	207	{
	208	tdesc_type_vector (const std::string &name, tdesc_type *element_type_,
	209	int count_)
	210	: tdesc_type (name, TDESC_TYPE_VECTOR),
	211	element_type (element_type_), count (count_)
	212	{}
	213
	214	void accept (tdesc_element_visitor &v) const override
	215	{
	216	v.visit (this);
	217	}
	218
	219	struct tdesc_type *element_type;
	220	int count;
	221	};
	222
	223	/* A named type from a target description. */
	224
	225	struct tdesc_type_field
	226	{
	227	tdesc_type_field (const std::string &name_, tdesc_type *type_,
	228	int start_, int end_)
	229	: name (name_), type (type_), start (start_), end (end_)
	230	{}
	231
	232	std::string name;
	233	struct tdesc_type *type;
	234	/* For non-enum-values, either both are -1 (non-bitfield), or both are
	235	not -1 (bitfield). For enum values, start is the value (which could be
	236	-1), end is -1. */
	237	int start, end;
	238	};
	239
	240	/* tdesc_type for struct, union, flags, and enum types. */
	241
	242	struct tdesc_type_with_fields : tdesc_type
	243	{
	244	tdesc_type_with_fields (const std::string &name, tdesc_type_kind kind,
	245	int size_ = 0)
	246	: tdesc_type (name, kind), size (size_)
	247	{}
	248
	249	void accept (tdesc_element_visitor &v) const override
	250	{
	251	v.visit (this);
	252	}
	253
	254	std::vector<tdesc_type_field> fields;
	255	int size;
256	};
257
82ec9bc7 AH	258	/* A feature from a target description. Each feature is a collection
	259	of other elements, e.g. registers and types. */
	260
	261	struct tdesc_feature : tdesc_element
	262	{
	263	tdesc_feature (const std::string &name_)
	264	: name (name_)
	265	{}
	266
	267	virtual ~tdesc_feature () = default;
	268
	269	DISABLE_COPY_AND_ASSIGN (tdesc_feature);
	270
	271	/* The name of this feature. It may be recognized by the architecture
	272	support code. */
	273	std::string name;
	274
	275	/* The registers associated with this feature. */
	276	std::vector<tdesc_reg_up> registers;
	277
	278	/* The types associated with this feature. */
	279	std::vector<tdesc_type_up> types;
	280
	281	void accept (tdesc_element_visitor &v) const override;
	282
	283	bool operator== (const tdesc_feature &other) const;
	284
	285	bool operator!= (const tdesc_feature &other) const
	286	{
	287	return !(*this == other);
	288	}
	289	};
	290
	291	typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;
	292
5f035c07 YQ	293	/* Allocate a new target_desc. */
	294	target_desc *allocate_target_description (void);
	295
	296	/* Set TARGET_DESC's architecture by NAME. */
	297	void set_tdesc_architecture (target_desc *target_desc,
	298	const char *name);
	299
	300	/* Set TARGET_DESC's osabi by NAME. */
	301	void set_tdesc_osabi (target_desc target_desc, const char name);
	302
f49ff000 YQ	303	/* Return the type associated with ID in the context of FEATURE, or
	304	NULL if none. */
	305	struct tdesc_type tdesc_named_type (const struct tdesc_feature feature,
	306	const char *id);
	307
	308	/* Return the created feature named NAME in target description TDESC. */
	309	struct tdesc_feature tdesc_create_feature (struct target_desc tdesc,
0abe8a89 YQ	310	const char *name,
	311	const char *xml = nullptr);
	312
f49ff000 YQ	313
	314	/* Return the created vector tdesc_type named NAME in FEATURE. */
	315	struct tdesc_type tdesc_create_vector (struct tdesc_feature feature,
	316	const char *name,
	317	struct tdesc_type *field_type,
	318	int count);
	319
	320	/* Return the created struct tdesc_type named NAME in FEATURE. */
d4a0e8b5 SM	321	tdesc_type_with_fields tdesc_create_struct (struct tdesc_feature feature,
d4a0e8b5 SM	322	const char *name);
f49ff000 YQ	323
f49ff000 YQ	324	/* Return the created union tdesc_type named NAME in FEATURE. */
d4a0e8b5 SM	325	tdesc_type_with_fields tdesc_create_union (struct tdesc_feature feature,
d4a0e8b5 SM	326	const char *name);
f49ff000 YQ	327
f49ff000 YQ	328	/* Return the created flags tdesc_type named NAME in FEATURE. */
d4a0e8b5 SM	329	tdesc_type_with_fields tdesc_create_flags (struct tdesc_feature feature,
	330	const char *name,
	331	int size);
f49ff000	332
eee8a18d AH	333	/* Return the created enum tdesc_type named NAME in FEATURE. */
	334	tdesc_type_with_fields tdesc_create_enum (struct tdesc_feature feature,
	335	const char *name,
	336	int size);
	337
f49ff000 YQ	338	/* Add a new field to TYPE. FIELD_NAME is its name, and FIELD_TYPE is
f49ff000 YQ	339	its type. */
d4a0e8b5	340	void tdesc_add_field (tdesc_type_with_fields type, const char field_name,
f49ff000 YQ	341	struct tdesc_type *field_type);
f49ff000 YQ	342
eee8a18d AH	343	/* Add a new bitfield to TYPE, with range START to END. FIELD_NAME is its name,
	344	and FIELD_TYPE is its type. */
	345	void tdesc_add_typed_bitfield (tdesc_type_with_fields *type,
	346	const char *field_name,
	347	int start, int end,
	348	struct tdesc_type *field_type);
	349
f49ff000 YQ	350	/* Set the total length of TYPE. Structs which contain bitfields may
	351	omit the reserved bits, so the end of the last field may not
	352	suffice. */
d4a0e8b5	353	void tdesc_set_struct_size (tdesc_type_with_fields *type, int size);
f49ff000 YQ	354
	355	/* Add a new untyped bitfield to TYPE.
	356	Untyped bitfields become either uint32 or uint64 depending on the size
	357	of the underlying type. */
d4a0e8b5	358	void tdesc_add_bitfield (tdesc_type_with_fields type, const char field_name,
f49ff000 YQ	359	int start, int end);
	360
	361	/* A flag is just a typed(bool) single-bit bitfield.
	362	This function is kept to minimize changes in generated files. */
d4a0e8b5	363	void tdesc_add_flag (tdesc_type_with_fields *type, int start,
f49ff000 YQ	364	const char *flag_name);
f49ff000 YQ	365
eee8a18d AH	366	/* Add field with VALUE and NAME to the enum TYPE. */
	367	void tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
	368	const char *name);
	369
f49ff000 YQ	370	/* Create a register in feature FEATURE. */
	371	void tdesc_create_reg (struct tdesc_feature feature, const char name,
	372	int regnum, int save_restore, const char *group,
	373	int bitsize, const char *type);
	374
	375	#endif /* ARCH_TDESC_H */