/* Target description support for GDB.
- Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2006-2018 Free Software Foundation, Inc.
Contributed by CodeSourcery.
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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "arch-utils.h"
#include "vec.h"
#include "xml-support.h"
#include "xml-tdesc.h"
+#include "osabi.h"
-#include "gdb_assert.h"
#include "gdb_obstack.h"
#include "hashtab.h"
+#include "inferior.h"
+#include <algorithm>
+#include "completer.h"
+#include "readline/tilde.h" /* tilde_expand */
+
+static type *make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype);
+
+/* 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;
+};
/* Types. */
-typedef struct property
+struct property
{
- char *key;
- char *value;
-} property_s;
-DEF_VEC_O(property_s);
+ property (const std::string &key_, const std::string &value_)
+ : key (key_), value (value_)
+ {}
+
+ std::string key;
+ std::string value;
+};
/* An individual register from a target description. */
-typedef struct tdesc_reg
+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_)
+ : 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 ());
+ }
+
+ 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. */
- char *name;
+ 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
around calls to an inferior function. */
int save_restore;
- /* The name of the register group containing this register, or NULL
- 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 NULL). */
- char *group;
+ /* The name of the register group containing this register, or empty
+ if the group should be automatically determined from the register's
+ type. This is traditionally "general", "float", "vector" but can
+ also be an arbitrary string. If defined the corresponding "info"
+ command should display this register's value. The string should be
+ limited to alphanumeric characters and internal hyphens. */
+ 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. */
- char *type;
+ std::string type;
/* The target-described type corresponding to TYPE, if found. */
- struct type *gdb_type;
-} *tdesc_reg_p;
-DEF_VEC_P(tdesc_reg_p);
+ 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;
/* A named type from a target description. */
-typedef struct type *type_p;
-DEF_VEC_P(type_p);
+
+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;
+};
+
+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;
+};
+
+/* 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;
+};
+
+/* Convert a tdesc_type to a gdb type. */
+
+static type *
+make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
+{
+ class gdb_type_creator : public tdesc_element_visitor
+ {
+ public:
+ gdb_type_creator (struct gdbarch *gdbarch)
+ : m_gdbarch (gdbarch)
+ {}
+
+ type *get_type ()
+ {
+ return m_type;
+ }
+
+ void visit (const tdesc_type_builtin *e) override
+ {
+ switch (e->kind)
+ {
+ /* Predefined types. */
+ case TDESC_TYPE_BOOL:
+ m_type = builtin_type (m_gdbarch)->builtin_bool;
+ return;
+ case TDESC_TYPE_INT8:
+ m_type = builtin_type (m_gdbarch)->builtin_int8;
+ return;
+ case TDESC_TYPE_INT16:
+ m_type = builtin_type (m_gdbarch)->builtin_int16;
+ return;
+ case TDESC_TYPE_INT32:
+ m_type = builtin_type (m_gdbarch)->builtin_int32;
+ return;
+ case TDESC_TYPE_INT64:
+ m_type = builtin_type (m_gdbarch)->builtin_int64;
+ return;
+ case TDESC_TYPE_INT128:
+ m_type = builtin_type (m_gdbarch)->builtin_int128;
+ return;
+ case TDESC_TYPE_UINT8:
+ m_type = builtin_type (m_gdbarch)->builtin_uint8;
+ return;
+ case TDESC_TYPE_UINT16:
+ m_type = builtin_type (m_gdbarch)->builtin_uint16;
+ return;
+ case TDESC_TYPE_UINT32:
+ m_type = builtin_type (m_gdbarch)->builtin_uint32;
+ return;
+ case TDESC_TYPE_UINT64:
+ m_type = builtin_type (m_gdbarch)->builtin_uint64;
+ return;
+ case TDESC_TYPE_UINT128:
+ m_type = builtin_type (m_gdbarch)->builtin_uint128;
+ return;
+ case TDESC_TYPE_CODE_PTR:
+ m_type = builtin_type (m_gdbarch)->builtin_func_ptr;
+ return;
+ case TDESC_TYPE_DATA_PTR:
+ m_type = builtin_type (m_gdbarch)->builtin_data_ptr;
+ return;
+ }
+
+ m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
+ if (m_type != NULL)
+ return;
+
+ switch (e->kind)
+ {
+ case TDESC_TYPE_IEEE_SINGLE:
+ m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_single",
+ floatformats_ieee_single);
+ return;
+
+ case TDESC_TYPE_IEEE_DOUBLE:
+ m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_double",
+ floatformats_ieee_double);
+ return;
+ case TDESC_TYPE_ARM_FPA_EXT:
+ m_type = arch_float_type (m_gdbarch, -1, "builtin_type_arm_ext",
+ floatformats_arm_ext);
+ return;
+
+ case TDESC_TYPE_I387_EXT:
+ m_type = arch_float_type (m_gdbarch, -1, "builtin_type_i387_ext",
+ floatformats_i387_ext);
+ return;
+ }
+
+ internal_error (__FILE__, __LINE__,
+ "Type \"%s\" has an unknown kind %d",
+ e->name.c_str (), e->kind);
+ }
+
+ void visit (const tdesc_type_vector *e) override
+ {
+ m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
+ if (m_type != NULL)
+ return;
+
+ type *element_gdb_type = make_gdb_type (m_gdbarch, e->element_type);
+ m_type = init_vector_type (element_gdb_type, e->count);
+ TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
+ return;
+ }
+
+ void visit (const tdesc_type_with_fields *e) override
+ {
+ m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
+ if (m_type != NULL)
+ return;
+
+ switch (e->kind)
+ {
+ case TDESC_TYPE_STRUCT:
+ make_gdb_type_struct (e);
+ return;
+ case TDESC_TYPE_UNION:
+ make_gdb_type_union (e);
+ return;
+ case TDESC_TYPE_FLAGS:
+ make_gdb_type_flags (e);
+ return;
+ case TDESC_TYPE_ENUM:
+ make_gdb_type_enum (e);
+ return;
+ }
+
+ internal_error (__FILE__, __LINE__,
+ "Type \"%s\" has an unknown kind %d",
+ e->name.c_str (), e->kind);
+ }
+
+ private:
+
+ void make_gdb_type_struct (const tdesc_type_with_fields *e)
+ {
+ m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_STRUCT);
+ TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
+ TYPE_TAG_NAME (m_type) = TYPE_NAME (m_type);
+
+ for (const tdesc_type_field &f : e->fields)
+ {
+ if (f.start != -1 && f.end != -1)
+ {
+ /* Bitfield. */
+ struct field *fld;
+ struct type *field_gdb_type;
+ int bitsize, total_size;
+
+ /* This invariant should be preserved while creating types. */
+ gdb_assert (e->size != 0);
+ if (f.type != NULL)
+ field_gdb_type = make_gdb_type (m_gdbarch, f.type);
+ else if (e->size > 4)
+ field_gdb_type = builtin_type (m_gdbarch)->builtin_uint64;
+ else
+ field_gdb_type = builtin_type (m_gdbarch)->builtin_uint32;
+
+ fld = append_composite_type_field_raw
+ (m_type, xstrdup (f.name.c_str ()), field_gdb_type);
+
+ /* For little-endian, BITPOS counts from the LSB of
+ the structure and marks the LSB of the field. For
+ big-endian, BITPOS counts from the MSB of the
+ structure and marks the MSB of the field. Either
+ way, it is the number of bits to the "left" of the
+ field. To calculate this in big-endian, we need
+ the total size of the structure. */
+ bitsize = f.end - f.start + 1;
+ total_size = e->size * TARGET_CHAR_BIT;
+ if (gdbarch_bits_big_endian (m_gdbarch))
+ SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize);
+ else
+ SET_FIELD_BITPOS (fld[0], f.start);
+ FIELD_BITSIZE (fld[0]) = bitsize;
+ }
+ else
+ {
+ gdb_assert (f.start == -1 && f.end == -1);
+ type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
+ append_composite_type_field (m_type,
+ xstrdup (f.name.c_str ()),
+ field_gdb_type);
+ }
+ }
+
+ if (e->size != 0)
+ TYPE_LENGTH (m_type) = e->size;
+ }
+
+ void make_gdb_type_union (const tdesc_type_with_fields *e)
+ {
+ m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_UNION);
+ TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
+
+ for (const tdesc_type_field &f : e->fields)
+ {
+ type* field_gdb_type = make_gdb_type (m_gdbarch, f.type);
+ append_composite_type_field (m_type, xstrdup (f.name.c_str ()),
+ field_gdb_type);
+
+ /* If any of the children of a union are vectors, flag the
+ union as a vector also. This allows e.g. a union of two
+ vector types to show up automatically in "info vector". */
+ if (TYPE_VECTOR (field_gdb_type))
+ TYPE_VECTOR (m_type) = 1;
+ }
+ }
+
+ void make_gdb_type_flags (const tdesc_type_with_fields *e)
+ {
+ m_type = arch_flags_type (m_gdbarch, e->name.c_str (),
+ e->size * TARGET_CHAR_BIT);
+
+ for (const tdesc_type_field &f : e->fields)
+ {
+ int bitsize = f.end - f.start + 1;
+
+ gdb_assert (f.type != NULL);
+ type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
+ append_flags_type_field (m_type, f.start, bitsize,
+ field_gdb_type, f.name.c_str ());
+ }
+ }
+
+ void make_gdb_type_enum (const tdesc_type_with_fields *e)
+ {
+ m_type = arch_type (m_gdbarch, TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
+ e->name.c_str ());
+
+ TYPE_UNSIGNED (m_type) = 1;
+ for (const tdesc_type_field &f : e->fields)
+ {
+ struct field *fld
+ = append_composite_type_field_raw (m_type,
+ xstrdup (f.name.c_str ()),
+ NULL);
+
+ SET_FIELD_BITPOS (fld[0], f.start);
+ }
+ }
+
+ /* The gdbarch used. */
+ struct gdbarch *m_gdbarch;
+
+ /* The type created. */
+ type *m_type;
+ };
+
+ gdb_type_creator gdb_type (gdbarch);
+ ttype->accept (gdb_type);
+ return gdb_type.get_type ();
+}
/* A feature from a target description. Each feature is a collection
of other elements, e.g. registers and types. */
-typedef struct tdesc_feature
+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. */
- char *name;
+ std::string name;
/* The registers associated with this feature. */
- VEC(tdesc_reg_p) *registers;
+ std::vector<tdesc_reg_up> registers;
/* The types associated with this feature. */
- VEC(type_p) *types;
-} *tdesc_feature_p;
-DEF_VEC_P(tdesc_feature_p);
+ std::vector<tdesc_type_up> types;
+
+ void accept (tdesc_element_visitor &v) const override
+ {
+ v.visit_pre (this);
+
+ for (const tdesc_type_up &type : types)
+ type->accept (v);
+
+ for (const tdesc_reg_up ® : registers)
+ reg->accept (v);
+
+ v.visit_post (this);
+ }
+
+ bool 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 ®1 = registers[ix];
+ const tdesc_reg_up ®2 = 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;
+ }
+
+ bool operator!= (const tdesc_feature &other) const
+ {
+ return !(*this == other);
+ }
+};
+
+typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;
/* A target description. */
-struct target_desc
+struct target_desc : tdesc_element
{
+ target_desc ()
+ {}
+
+ virtual ~target_desc () = default;
+
+ target_desc (const target_desc &) = delete;
+ void operator= (const target_desc &) = delete;
+
/* The architecture reported by the target, if any. */
- const struct bfd_arch_info *arch;
+ const struct bfd_arch_info *arch = NULL;
+
+ /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
+ otherwise. */
+ enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
+
+ /* The list of compatible architectures reported by the target. */
+ std::vector<const bfd_arch_info *> compatible;
/* Any architecture-specific properties specified by the target. */
- VEC(property_s) *properties;
+ std::vector<property> properties;
/* The features associated with this target. */
- VEC(tdesc_feature_p) *features;
+ std::vector<tdesc_feature_up> features;
+
+ void accept (tdesc_element_visitor &v) const override
+ {
+ v.visit_pre (this);
+
+ for (const tdesc_feature_up &feature : features)
+ feature->accept (v);
+
+ v.visit_post (this);
+ }
+
+ bool operator== (const target_desc &other) const
+ {
+ if (arch != other.arch)
+ return false;
+
+ if (osabi != other.osabi)
+ return false;
+
+ if (features.size () != other.features.size ())
+ return false;
+
+ for (int ix = 0; ix < features.size (); ix++)
+ {
+ const tdesc_feature_up &feature1 = features[ix];
+ const tdesc_feature_up &feature2 = other.features[ix];
+
+ if (feature1 != feature2 && *feature1 != *feature2)
+ return false;
+ }
+
+ return true;
+ }
+
+ bool operator!= (const target_desc &other) const
+ {
+ return !(*this == other);
+ }
};
/* Per-architecture data associated with a target description. The
target description may be shared by multiple architectures, but
this data is private to one gdbarch. */
+struct tdesc_arch_reg
+{
+ tdesc_arch_reg (tdesc_reg *reg_, struct type *type_)
+ : reg (reg_), type (type_)
+ {}
+
+ struct tdesc_reg *reg;
+ struct type *type;
+};
+
struct tdesc_arch_data
{
- /* A list of registers, indexed by GDB's internal register number.
+ /* A list of register/type pairs, indexed by GDB's internal register number.
During initialization of the gdbarch this list is used to store
registers which the architecture assigns a fixed register number.
Registers which are NULL in this array, or off the end, are
treated as zero-sized and nameless (i.e. placeholders in the
numbering). */
- VEC(tdesc_reg_p) *registers;
+ std::vector<tdesc_arch_reg> arch_regs;
/* Functions which report the register name, type, and reggroups for
pseudo-registers. */
- gdbarch_register_name_ftype *pseudo_register_name;
- gdbarch_register_type_ftype *pseudo_register_type;
- gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
+ gdbarch_register_name_ftype *pseudo_register_name = NULL;
+ gdbarch_register_type_ftype *pseudo_register_type = NULL;
+ gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p = NULL;
};
-/* Global state. These variables are associated with the current
- target; if GDB adds support for multiple simultaneous targets, then
- these variables should become target-specific data. */
+/* Info about an inferior's target description. There's one of these
+ for each inferior. */
+
+struct target_desc_info
+{
+ /* A flag indicating that a description has already been fetched
+ from the target, so it should not be queried again. */
-/* A flag indicating that a description has already been fetched from
- the current target, so it should not be queried again. */
+ int fetched;
-static int target_desc_fetched;
+ /* The description fetched from the target, or NULL if the target
+ did not supply any description. Only valid when
+ target_desc_fetched is set. Only the description initialization
+ code should access this; normally, the description should be
+ accessed through the gdbarch object. */
-/* The description fetched from the current target, or NULL if the
- current target did not supply any description. Only valid when
- target_desc_fetched is set. Only the description initialization
- code should access this; normally, the description should be
- accessed through the gdbarch object. */
+ const struct target_desc *tdesc;
-static const struct target_desc *current_target_desc;
+ /* The filename to read a target description from, as set by "set
+ tdesc filename ..." */
-/* Other global variables. */
+ char *filename;
+};
-/* The filename to read a target description from. */
+/* Get the inferior INF's target description info, allocating one on
+ the stop if necessary. */
-static char *target_description_filename;
+static struct target_desc_info *
+get_tdesc_info (struct inferior *inf)
+{
+ if (inf->tdesc_info == NULL)
+ inf->tdesc_info = XCNEW (struct target_desc_info);
+ return inf->tdesc_info;
+}
/* A handle for architecture-specific data associated with the
target description (see struct tdesc_arch_data). */
static struct gdbarch_data *tdesc_data;
+/* See target-descriptions.h. */
+
+int
+target_desc_info_from_user_p (struct target_desc_info *info)
+{
+ return info != NULL && info->filename != NULL;
+}
+
+/* See target-descriptions.h. */
+
+void
+copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
+{
+ struct target_desc_info *src = get_tdesc_info (srcinf);
+ struct target_desc_info *dest = get_tdesc_info (destinf);
+
+ dest->fetched = src->fetched;
+ dest->tdesc = src->tdesc;
+ dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
+}
+
+/* See target-descriptions.h. */
+
+void
+target_desc_info_free (struct target_desc_info *tdesc_info)
+{
+ if (tdesc_info != NULL)
+ {
+ xfree (tdesc_info->filename);
+ xfree (tdesc_info);
+ }
+}
+
+/* Convenience helper macros. */
+
+#define target_desc_fetched \
+ get_tdesc_info (current_inferior ())->fetched
+#define current_target_desc \
+ get_tdesc_info (current_inferior ())->tdesc
+#define target_description_filename \
+ get_tdesc_info (current_inferior ())->filename
+
+/* The string manipulated by the "set tdesc filename ..." command. */
+
+static char *tdesc_filename_cmd_string;
+
/* Fetch the current target's description, and switch the current
architecture to one which incorporates that description. */
/* The current architecture should not have any target description
specified. It should have been cleared, e.g. when we
disconnected from the previous target. */
- gdb_assert (gdbarch_target_desc (current_gdbarch) == NULL);
+ gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
/* First try to fetch an XML description from the user-specified
file. */
{
struct tdesc_arch_data *data;
- data = gdbarch_data (current_gdbarch, tdesc_data);
+ data = ((struct tdesc_arch_data *)
+ gdbarch_data (target_gdbarch (), tdesc_data));
if (tdesc_has_registers (current_target_desc)
- && data->registers == NULL)
+ && data->arch_regs.empty ())
warning (_("Target-supplied registers are not supported "
"by the current architecture"));
}
return NULL;
}
+
+/* Return non-zero if this target description is compatible
+ with the given BFD architecture. */
+
+int
+tdesc_compatible_p (const struct target_desc *target_desc,
+ const struct bfd_arch_info *arch)
+{
+ for (const bfd_arch_info *compat : target_desc->compatible)
+ {
+ if (compat == arch
+ || arch->compatible (arch, compat)
+ || compat->compatible (compat, arch))
+ return 1;
+ }
+
+ return 0;
+}
\f
/* Direct accessors for target descriptions. */
const char *
tdesc_property (const struct target_desc *target_desc, const char *key)
{
- struct property *prop;
- int ix;
-
- for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
- ix++)
- if (strcmp (prop->key, key) == 0)
- return prop->value;
+ for (const property &prop : target_desc->properties)
+ if (prop.key == key)
+ return prop.value.c_str ();
return NULL;
}
{
return target_desc->arch;
}
+
+/* Return the OSABI associated with this target description, or
+ GDB_OSABI_UNKNOWN if no osabi was specified. */
+
+enum gdb_osabi
+tdesc_osabi (const struct target_desc *target_desc)
+{
+ return target_desc->osabi;
+}
+
\f
/* Return 1 if this target description includes any registers. */
int
tdesc_has_registers (const struct target_desc *target_desc)
{
- int ix;
- struct tdesc_feature *feature;
-
if (target_desc == NULL)
return 0;
- for (ix = 0;
- VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
- ix++)
- if (! VEC_empty (tdesc_reg_p, feature->registers))
+ for (const tdesc_feature_up &feature : target_desc->features)
+ if (!feature->registers.empty ())
return 1;
return 0;
tdesc_find_feature (const struct target_desc *target_desc,
const char *name)
{
- int ix;
- struct tdesc_feature *feature;
-
- for (ix = 0;
- VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
- ix++)
- if (strcmp (feature->name, name) == 0)
- return feature;
+ for (const tdesc_feature_up &feature : target_desc->features)
+ if (feature->name == name)
+ return feature.get ();
return NULL;
}
const char *
tdesc_feature_name (const struct tdesc_feature *feature)
{
- return feature->name;
+ return feature->name.c_str ();
}
-/* Return the type associated with ID in the context of FEATURE, or
- NULL if none. */
-
-struct type *
-tdesc_named_type (const struct tdesc_feature *feature, const char *id)
+/* Predefined types. */
+static tdesc_type_builtin tdesc_predefined_types[] =
{
- int ix;
- struct type *gdb_type;
-
- /* First try target-defined types. */
- for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++)
- if (strcmp (TYPE_NAME (gdb_type), id) == 0)
- return gdb_type;
-
- /* Next try some predefined types. Note that none of these types
- depend on the current architecture; some of the builtin_type_foo
- variables are swapped based on the architecture. */
- if (strcmp (id, "int8") == 0)
- return builtin_type_int8;
+ { "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 }
+};
- if (strcmp (id, "int16") == 0)
- return builtin_type_int16;
+/* Lookup a predefined type. */
- if (strcmp (id, "int32") == 0)
- return builtin_type_int32;
+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];
- if (strcmp (id, "int64") == 0)
- return builtin_type_int64;
+ gdb_assert_not_reached ("bad predefined tdesc type");
+}
- if (strcmp (id, "uint8") == 0)
- return builtin_type_uint8;
+/* See common/tdesc.h. */
- if (strcmp (id, "uint16") == 0)
- return builtin_type_uint16;
+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 ();
- if (strcmp (id, "uint32") == 0)
- return builtin_type_uint32;
+ /* 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];
- if (strcmp (id, "uint64") == 0)
- return builtin_type_uint64;
+ return NULL;
+}
- if (strcmp (id, "ieee_single") == 0)
- return builtin_type_ieee_single;
+/* Lookup type associated with ID. */
- if (strcmp (id, "ieee_double") == 0)
- return builtin_type_ieee_double;
+struct type *
+tdesc_find_type (struct gdbarch *gdbarch, const char *id)
+{
+ tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
- if (strcmp (id, "arm_fpa_ext") == 0)
- return builtin_type_arm_ext;
+ for (const tdesc_arch_reg ® : data->arch_regs)
+ {
+ if (reg.reg
+ && reg.reg->tdesc_type
+ && reg.type
+ && reg.reg->tdesc_type->name == id)
+ return reg.type;
+ }
return NULL;
}
-\f
/* Support for registers from target descriptions. */
struct tdesc_arch_data *data;
data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
+ new (data) tdesc_arch_data ();
+
return data;
}
struct tdesc_arch_data *
tdesc_data_alloc (void)
{
- return XZALLOC (struct tdesc_arch_data);
+ return new tdesc_arch_data ();
}
/* Free something allocated by tdesc_data_alloc, if it is not going
void
tdesc_data_cleanup (void *data_untyped)
{
- struct tdesc_arch_data *data = data_untyped;
+ struct tdesc_arch_data *data = (struct tdesc_arch_data *) data_untyped;
- VEC_free (tdesc_reg_p, data->registers);
- xfree (data);
+ delete data;
}
/* Search FEATURE for a register named NAME. */
+static struct tdesc_reg *
+tdesc_find_register_early (const struct tdesc_feature *feature,
+ const char *name)
+{
+ for (const tdesc_reg_up ® : feature->registers)
+ if (strcasecmp (reg->name.c_str (), name) == 0)
+ return reg.get ();
+
+ return NULL;
+}
+
+/* Search FEATURE for a register named NAME. Assign REGNO to it. */
+
int
tdesc_numbered_register (const struct tdesc_feature *feature,
struct tdesc_arch_data *data,
int regno, const char *name)
{
- int ixr;
- struct tdesc_reg *reg;
+ struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
- for (ixr = 0;
- VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
- ixr++)
- if (strcasecmp (reg->name, name) == 0)
- {
- /* Make sure the vector includes a REGNO'th element. */
- while (regno >= VEC_length (tdesc_reg_p, data->registers))
- VEC_safe_push (tdesc_reg_p, data->registers, NULL);
- VEC_replace (tdesc_reg_p, data->registers, regno, reg);
- return 1;
- }
+ if (reg == NULL)
+ return 0;
- return 0;
+ /* Make sure the vector includes a REGNO'th element. */
+ while (regno >= data->arch_regs.size ())
+ data->arch_regs.emplace_back (nullptr, nullptr);
+
+ data->arch_regs[regno] = tdesc_arch_reg (reg, NULL);
+
+ return 1;
+}
+
+/* Search FEATURE for a register named NAME, but do not assign a fixed
+ register number to it. */
+
+int
+tdesc_unnumbered_register (const struct tdesc_feature *feature,
+ const char *name)
+{
+ struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
+
+ if (reg == NULL)
+ return 0;
+
+ return 1;
}
-/* Search FEATURE for a register whose name is in NAMES. */
+/* Search FEATURE for a register whose name is in NAMES and assign
+ REGNO to it. */
int
tdesc_numbered_register_choices (const struct tdesc_feature *feature,
return 0;
}
+/* Search FEATURE for a register named NAME, and return its size in
+ bits. The register must exist. */
+
+int
+tdesc_register_size (const struct tdesc_feature *feature,
+ const char *name)
+{
+ struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
+
+ gdb_assert (reg != NULL);
+ return reg->bitsize;
+}
+
/* Look up a register by its GDB internal register number. */
-static struct tdesc_reg *
-tdesc_find_register (struct gdbarch *gdbarch, int regno)
+static struct tdesc_arch_reg *
+tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
{
- struct tdesc_reg *reg;
struct tdesc_arch_data *data;
- data = gdbarch_data (gdbarch, tdesc_data);
- if (regno < VEC_length (tdesc_reg_p, data->registers))
- return VEC_index (tdesc_reg_p, data->registers, regno);
+ data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
+ if (regno < data->arch_regs.size ())
+ return &data->arch_regs[regno];
else
return NULL;
}
+static struct tdesc_reg *
+tdesc_find_register (struct gdbarch *gdbarch, int regno)
+{
+ struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
+
+ return reg? reg->reg : NULL;
+}
+
/* Return the name of register REGNO, from the target description or
from an architecture-provided pseudo_register_name method. */
const char *
-tdesc_register_name (int regno)
+tdesc_register_name (struct gdbarch *gdbarch, int regno)
{
- struct tdesc_reg *reg = tdesc_find_register (current_gdbarch, regno);
- int num_regs = gdbarch_num_regs (current_gdbarch);
- int num_pseudo_regs = gdbarch_num_pseudo_regs (current_gdbarch);
+ struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
+ int num_regs = gdbarch_num_regs (gdbarch);
+ int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
if (reg != NULL)
- return reg->name;
+ return reg->name.c_str ();
if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
{
- struct tdesc_arch_data *data = gdbarch_data (current_gdbarch,
- tdesc_data);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
+
gdb_assert (data->pseudo_register_name != NULL);
- return data->pseudo_register_name (regno);
+ return data->pseudo_register_name (gdbarch, regno);
}
return "";
}
-static struct type *
+struct type *
tdesc_register_type (struct gdbarch *gdbarch, int regno)
{
- struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
+ struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
+ struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
int num_regs = gdbarch_num_regs (gdbarch);
int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
{
- struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
+
gdb_assert (data->pseudo_register_type != NULL);
return data->pseudo_register_type (gdbarch, regno);
}
if (reg == NULL)
/* Return "int0_t", since "void" has a misleading size of one. */
- return builtin_type_int0;
-
- /* First check for a predefined or target defined type. */
- if (reg->gdb_type)
- return reg->gdb_type;
+ return builtin_type (gdbarch)->builtin_int0;
- /* Next try size-sensitive type shortcuts. */
- if (strcmp (reg->type, "float") == 0)
+ if (arch_reg->type == NULL)
{
- if (reg->bitsize == gdbarch_float_bit (gdbarch))
- return builtin_type_float;
- else if (reg->bitsize == gdbarch_double_bit (gdbarch))
- return builtin_type_double;
- else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
- return builtin_type_long_double;
- }
- else if (strcmp (reg->type, "int") == 0)
- {
- if (reg->bitsize == gdbarch_long_bit (gdbarch))
- return builtin_type_long;
- else if (reg->bitsize == TARGET_CHAR_BIT)
- return builtin_type_char;
- else if (reg->bitsize == gdbarch_short_bit (gdbarch))
- return builtin_type_short;
- else if (reg->bitsize == gdbarch_int_bit (gdbarch))
- return builtin_type_int;
- else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
- return builtin_type_long_long;
- else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
- /* A bit desperate by this point... */
- return builtin_type_void_data_ptr;
+ /* First check for a predefined or target defined type. */
+ if (reg->tdesc_type)
+ arch_reg->type = make_gdb_type (gdbarch, reg->tdesc_type);
+
+ /* Next try size-sensitive type shortcuts. */
+ else if (reg->type == "float")
+ {
+ if (reg->bitsize == gdbarch_float_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_float;
+ else if (reg->bitsize == gdbarch_double_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_double;
+ else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
+ else
+ {
+ warning (_("Register \"%s\" has an unsupported size (%d bits)"),
+ reg->name.c_str (), reg->bitsize);
+ arch_reg->type = builtin_type (gdbarch)->builtin_double;
+ }
+ }
+ else if (reg->type == "int")
+ {
+ if (reg->bitsize == gdbarch_long_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_long;
+ else if (reg->bitsize == TARGET_CHAR_BIT)
+ arch_reg->type = builtin_type (gdbarch)->builtin_char;
+ else if (reg->bitsize == gdbarch_short_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_short;
+ else if (reg->bitsize == gdbarch_int_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_int;
+ else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
+ arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
+ else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
+ /* A bit desperate by this point... */
+ arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
+ else
+ {
+ warning (_("Register \"%s\" has an unsupported size (%d bits)"),
+ reg->name.c_str (), reg->bitsize);
+ arch_reg->type = builtin_type (gdbarch)->builtin_long;
+ }
+ }
+
+ if (arch_reg->type == NULL)
+ internal_error (__FILE__, __LINE__,
+ "Register \"%s\" has an unknown type \"%s\"",
+ reg->name.c_str (), reg->type.c_str ());
}
- else if (strcmp (reg->type, "code_ptr") == 0)
- return builtin_type_void_func_ptr;
- else if (strcmp (reg->type, "data_ptr") == 0)
- return builtin_type_void_data_ptr;
- else
- internal_error (__FILE__, __LINE__,
- "Register \"%s\" has an unknown type \"%s\"",
- reg->name, reg->type);
- warning (_("Register \"%s\" has an unsupported size (%d bits)"),
- reg->name, reg->bitsize);
- return builtin_type_long;
+ return arch_reg->type;
}
static int
}
/* Check whether REGNUM is a member of REGGROUP. Registers from the
- target description may be classified as general, float, or vector.
- Unlike a gdbarch register_reggroup_p method, this function will
- return -1 if it does not know; the caller should handle registers
- with no specified group.
-
- Arbitrary strings (other than "general", "float", and "vector")
- from the description are not used; they cause the register to be
- displayed in "info all-registers" but excluded from "info
- registers" et al. The names of containing features are also not
- used. This might be extended to display registers in some more
- useful groupings.
+ target description may be classified as general, float, vector or other
+ register groups registered with reggroup_add(). Unlike a gdbarch
+ register_reggroup_p method, this function will return -1 if it does not
+ know; the caller should handle registers with no specified group.
+
+ The names of containing features are not used. This might be extended
+ to display registers in some more useful groupings.
The save-restore flag is also implemented here. */
{
struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
- if (reg != NULL && reg->group != NULL)
- {
- int general_p = 0, float_p = 0, vector_p = 0;
-
- if (strcmp (reg->group, "general") == 0)
- general_p = 1;
- else if (strcmp (reg->group, "float") == 0)
- float_p = 1;
- else if (strcmp (reg->group, "vector") == 0)
- vector_p = 1;
-
- if (reggroup == float_reggroup)
- return float_p;
-
- if (reggroup == vector_reggroup)
- return vector_p;
-
- if (reggroup == general_reggroup)
- return general_p;
- }
+ if (reg != NULL && !reg->group.empty ()
+ && (reg->group == reggroup_name (reggroup)))
+ return 1;
if (reg != NULL
&& (reggroup == save_reggroup || reggroup == restore_reggroup))
if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
{
- struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
- gdb_assert (data->pseudo_register_reggroup_p != NULL);
- return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
+
+ if (data->pseudo_register_reggroup_p != NULL)
+ return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
+ /* Otherwise fall through to the default reggroup_p. */
}
ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
gdbarch_register_name_ftype *pseudo_name)
{
- struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
data->pseudo_register_name = pseudo_name;
}
set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
gdbarch_register_type_ftype *pseudo_type)
{
- struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
data->pseudo_register_type = pseudo_type;
}
(struct gdbarch *gdbarch,
gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
{
- struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
+ struct tdesc_arch_data *data
+ = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
data->pseudo_register_reggroup_p = pseudo_reggroup_p;
}
void
tdesc_use_registers (struct gdbarch *gdbarch,
+ const struct target_desc *target_desc,
struct tdesc_arch_data *early_data)
{
int num_regs = gdbarch_num_regs (gdbarch);
- int i, ixf, ixr;
- const struct target_desc *target_desc;
- struct tdesc_feature *feature;
- struct tdesc_reg *reg;
struct tdesc_arch_data *data;
htab_t reg_hash;
- target_desc = gdbarch_target_desc (gdbarch);
-
/* We can't use the description for registers if it doesn't describe
any. This function should only be called after validating
registers, so the caller should know that registers are
included. */
gdb_assert (tdesc_has_registers (target_desc));
- data = gdbarch_data (gdbarch, tdesc_data);
- data->registers = early_data->registers;
- xfree (early_data);
+ data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
+ data->arch_regs = early_data->arch_regs;
+ delete early_data;
/* Build up a set of all registers, so that we can assign register
numbers where needed. The hash table expands as necessary, so
the initial size is arbitrary. */
reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
- for (ixf = 0;
- VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
- ixf++)
- for (ixr = 0;
- VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
- ixr++)
+ for (const tdesc_feature_up &feature : target_desc->features)
+ for (const tdesc_reg_up ® : feature->registers)
{
- void **slot = htab_find_slot (reg_hash, reg, INSERT);
-
- *slot = reg;
+ void **slot = htab_find_slot (reg_hash, reg.get (), INSERT);
+
+ *slot = reg.get ();
+ /* Add reggroup if its new. */
+ if (!reg->group.empty ())
+ if (reggroup_find (gdbarch, reg->group.c_str ()) == NULL)
+ reggroup_add (gdbarch, reggroup_gdbarch_new (gdbarch,
+ reg->group.c_str (),
+ USER_REGGROUP));
}
/* Remove any registers which were assigned numbers by the
architecture. */
- for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
- if (reg)
- htab_remove_elt (reg_hash, reg);
+ for (const tdesc_arch_reg &arch_reg : data->arch_regs)
+ if (arch_reg.reg != NULL)
+ htab_remove_elt (reg_hash, arch_reg.reg);
/* Assign numbers to the remaining registers and add them to the
list of registers. The new numbers are always above gdbarch_num_regs.
Iterate over the features, not the hash table, so that the order
matches that in the target description. */
- gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
- while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
- VEC_safe_push (tdesc_reg_p, data->registers, NULL);
- for (ixf = 0;
- VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
- ixf++)
- for (ixr = 0;
- VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
- ixr++)
- if (htab_find (reg_hash, reg) != NULL)
+ gdb_assert (data->arch_regs.size () <= num_regs);
+ while (data->arch_regs.size () < num_regs)
+ data->arch_regs.emplace_back (nullptr, nullptr);
+
+ for (const tdesc_feature_up &feature : target_desc->features)
+ for (const tdesc_reg_up ® : feature->registers)
+ if (htab_find (reg_hash, reg.get ()) != NULL)
{
- VEC_safe_push (tdesc_reg_p, data->registers, reg);
+ data->arch_regs.emplace_back (reg.get (), nullptr);
num_regs++;
}
}
\f
-/* Methods for constructing a target description. */
-
-static void
-tdesc_free_reg (struct tdesc_reg *reg)
-{
- xfree (reg->name);
- xfree (reg->type);
- xfree (reg->group);
- xfree (reg);
-}
+/* 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)
{
- struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
+ tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
+ group, bitsize, type);
- reg->name = xstrdup (name);
- reg->target_regnum = regnum;
- reg->save_restore = save_restore;
- reg->group = group ? xstrdup (group) : NULL;
- reg->bitsize = bitsize;
- reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
+ feature->registers.emplace_back (reg);
+}
- /* 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. */
- reg->gdb_type = tdesc_named_type (feature, reg->type);
+/* See common/tdesc.h. */
- VEC_safe_push (tdesc_reg_p, feature->registers, reg);
+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;
}
-static void
-tdesc_free_feature (struct tdesc_feature *feature)
+/* See common/tdesc.h. */
+
+tdesc_type_with_fields *
+tdesc_create_struct (struct tdesc_feature *feature, const char *name)
{
- struct tdesc_reg *reg;
- int ix;
+ tdesc_type_with_fields *type
+ = new tdesc_type_with_fields (name, TDESC_TYPE_STRUCT);
+ feature->types.emplace_back (type);
- for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
- tdesc_free_reg (reg);
- VEC_free (tdesc_reg_p, feature->registers);
+ return type;
+}
- /* There is no easy way to free xmalloc-allocated types, nor is
- there a way to allocate types on an obstack not associated with
- an objfile. Therefore we never free types. Since we only ever
- parse an identical XML document once, this memory leak is mostly
- contained. */
- VEC_free (type_p, feature->types);
+/* See common/tdesc.h. */
- xfree (feature->name);
- xfree (feature);
+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;
}
-struct tdesc_feature *
-tdesc_create_feature (struct target_desc *tdesc, const char *name)
+/* See common/tdesc.h. */
+
+tdesc_type_with_fields *
+tdesc_create_union (struct tdesc_feature *feature, const char *name)
{
- struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
+ tdesc_type_with_fields *type
+ = new tdesc_type_with_fields (name, TDESC_TYPE_UNION);
+ feature->types.emplace_back (type);
- new_feature->name = xstrdup (name);
+ return type;
+}
- VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
- return new_feature;
+/* 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;
+}
+
+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);
}
void
-tdesc_record_type (struct tdesc_feature *feature, struct type *type)
+tdesc_add_typed_bitfield (tdesc_type_with_fields *type, const char *field_name,
+ int start, int end, struct tdesc_type *field_type)
{
- /* The type's ID should be used as its TYPE_NAME. */
- gdb_assert (TYPE_NAME (type) != NULL);
+ gdb_assert (type->kind == TDESC_TYPE_STRUCT
+ || type->kind == TDESC_TYPE_FLAGS);
+ gdb_assert (start >= 0 && end >= start);
- VEC_safe_push (type_p, feature->types, type);
+ 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);
+}
+
+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);
+}
+
+/* See common/tdesc.h. */
+
+struct tdesc_feature *
+tdesc_create_feature (struct target_desc *tdesc, const char *name,
+ const char *xml)
+{
+ struct tdesc_feature *new_feature = new tdesc_feature (name);
+
+ tdesc->features.emplace_back (new_feature);
+
+ return new_feature;
}
struct target_desc *
allocate_target_description (void)
{
- return XZALLOC (struct target_desc);
+ return new target_desc ();
}
static void
free_target_description (void *arg)
{
- struct target_desc *target_desc = arg;
- struct tdesc_feature *feature;
- struct property *prop;
- int ix;
-
- for (ix = 0;
- VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
- ix++)
- tdesc_free_feature (feature);
- VEC_free (tdesc_feature_p, target_desc->features);
-
- for (ix = 0;
- VEC_iterate (property_s, target_desc->properties, ix, prop);
- ix++)
- {
- xfree (prop->key);
- xfree (prop->value);
- }
- VEC_free (property_s, target_desc->properties);
+ struct target_desc *target_desc = (struct target_desc *) arg;
- xfree (target_desc);
+ delete target_desc;
}
struct cleanup *
return make_cleanup (free_target_description, target_desc);
}
+void
+tdesc_add_compatible (struct target_desc *target_desc,
+ const struct bfd_arch_info *compatible)
+{
+ /* If this instance of GDB is compiled without BFD support for the
+ compatible architecture, simply ignore it -- we would not be able
+ to handle it anyway. */
+ if (compatible == NULL)
+ return;
+
+ for (const bfd_arch_info *compat : target_desc->compatible)
+ if (compat == compatible)
+ internal_error (__FILE__, __LINE__,
+ _("Attempted to add duplicate "
+ "compatible architecture \"%s\""),
+ compatible->printable_name);
+
+ target_desc->compatible.push_back (compatible);
+}
+
void
set_tdesc_property (struct target_desc *target_desc,
const char *key, const char *value)
{
- struct property *prop, new_prop;
- int ix;
-
gdb_assert (key != NULL && value != NULL);
- for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
- ix++)
- if (strcmp (prop->key, key) == 0)
- internal_error (__FILE__, __LINE__,
- _("Attempted to add duplicate property \"%s\""), key);
+ if (tdesc_property (target_desc, key) != NULL)
+ internal_error (__FILE__, __LINE__,
+ _("Attempted to add duplicate property \"%s\""), key);
- new_prop.key = xstrdup (key);
- new_prop.value = xstrdup (value);
- VEC_safe_push (property_s, target_desc->properties, &new_prop);
+ target_desc->properties.emplace_back (key, value);
+}
+
+/* See common/tdesc.h. */
+
+void
+set_tdesc_architecture (struct target_desc *target_desc,
+ const char *name)
+{
+ set_tdesc_architecture (target_desc, bfd_scan_arch (name));
}
void
{
target_desc->arch = arch;
}
+
+/* See common/tdesc.h. */
+
+void
+set_tdesc_osabi (struct target_desc *target_desc, const char *name)
+{
+ set_tdesc_osabi (target_desc, osabi_from_tdesc_string (name));
+}
+
+void
+set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
+{
+ target_desc->osabi = osabi;
+}
\f
static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
/* Helper functions for the CLI commands. */
static void
-set_tdesc_cmd (char *args, int from_tty)
+set_tdesc_cmd (const char *args, int from_tty)
{
- help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
+ help_list (tdesc_set_cmdlist, "set tdesc ", all_commands, gdb_stdout);
}
static void
-show_tdesc_cmd (char *args, int from_tty)
+show_tdesc_cmd (const char *args, int from_tty)
{
cmd_show_list (tdesc_show_cmdlist, from_tty, "");
}
static void
-unset_tdesc_cmd (char *args, int from_tty)
+unset_tdesc_cmd (const char *args, int from_tty)
{
- help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
+ help_list (tdesc_unset_cmdlist, "unset tdesc ", all_commands, gdb_stdout);
}
static void
-set_tdesc_filename_cmd (char *args, int from_tty,
+set_tdesc_filename_cmd (const char *args, int from_tty,
struct cmd_list_element *c)
{
+ xfree (target_description_filename);
+ target_description_filename = xstrdup (tdesc_filename_cmd_string);
+
target_clear_description ();
target_find_description ();
}
struct cmd_list_element *c,
const char *value)
{
+ value = target_description_filename;
+
if (value != NULL && *value != '\0')
- printf_filtered (_("\
-The target description will be read from \"%s\".\n"),
+ printf_filtered (_("The target description will be read from \"%s\".\n"),
value);
else
- printf_filtered (_("\
-The target description will be read from the target.\n"));
+ printf_filtered (_("The target description will be "
+ "read from the target.\n"));
}
static void
-unset_tdesc_filename_cmd (char *args, int from_tty)
+unset_tdesc_filename_cmd (const char *args, int from_tty)
{
xfree (target_description_filename);
target_description_filename = NULL;
target_find_description ();
}
+/* Print target description in C. */
+
+class print_c_tdesc : public tdesc_element_visitor
+{
+public:
+ print_c_tdesc (std::string &filename_after_features)
+ : m_filename_after_features (filename_after_features)
+ {
+ const char *inp;
+ char *outp;
+ const char *filename = lbasename (m_filename_after_features.c_str ());
+
+ m_function = (char *) xmalloc (strlen (filename) + 1);
+ for (inp = filename, outp = m_function; *inp != '\0'; inp++)
+ if (*inp == '.')
+ break;
+ else if (*inp == '-')
+ *outp++ = '_';
+ else
+ *outp++ = *inp;
+ *outp = '\0';
+
+ /* Standard boilerplate. */
+ printf_unfiltered ("/* THIS FILE IS GENERATED. "
+ "-*- buffer-read-only: t -*- vi"
+ ":set ro:\n");
+ }
+
+ ~print_c_tdesc ()
+ {
+ xfree (m_function);
+ }
+
+ void visit_pre (const target_desc *e) override
+ {
+ printf_unfiltered (" Original: %s */\n\n",
+ lbasename (m_filename_after_features.c_str ()));
+
+ printf_unfiltered ("#include \"defs.h\"\n");
+ printf_unfiltered ("#include \"osabi.h\"\n");
+ printf_unfiltered ("#include \"target-descriptions.h\"\n");
+ printf_unfiltered ("\n");
+
+ printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function);
+ printf_unfiltered ("static void\n");
+ printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function);
+ printf_unfiltered ("{\n");
+ printf_unfiltered
+ (" struct target_desc *result = allocate_target_description ();\n");
+
+ if (tdesc_architecture (e) != NULL)
+ {
+ printf_unfiltered
+ (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
+ tdesc_architecture (e)->printable_name);
+ printf_unfiltered ("\n");
+ }
+ if (tdesc_osabi (e) > GDB_OSABI_UNKNOWN
+ && tdesc_osabi (e) < GDB_OSABI_INVALID)
+ {
+ printf_unfiltered
+ (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
+ gdbarch_osabi_name (tdesc_osabi (e)));
+ printf_unfiltered ("\n");
+ }
+
+ for (const bfd_arch_info_type *compatible : e->compatible)
+ printf_unfiltered
+ (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
+ compatible->printable_name);
+
+ if (!e->compatible.empty ())
+ printf_unfiltered ("\n");
+
+ for (const property &prop : e->properties)
+ printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
+ prop.key.c_str (), prop.value.c_str ());
+
+ printf_unfiltered (" struct tdesc_feature *feature;\n");
+ }
+
+ void visit_pre (const tdesc_feature *e) override
+ {
+ printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
+ e->name.c_str ());
+ }
+
+ void visit_post (const tdesc_feature *e) override
+ {}
+
+ void visit_post (const target_desc *e) override
+ {
+ printf_unfiltered ("\n tdesc_%s = result;\n", m_function);
+ printf_unfiltered ("}\n");
+ }
+
+ void visit (const tdesc_type_builtin *type) override
+ {
+ error (_("C output is not supported type \"%s\"."), type->name.c_str ());
+ }
+
+ void visit (const tdesc_type_vector *type) override
+ {
+ if (!m_printed_element_type)
+ {
+ printf_unfiltered (" tdesc_type *element_type;\n");
+ m_printed_element_type = true;
+ }
+
+ printf_unfiltered
+ (" element_type = tdesc_named_type (feature, \"%s\");\n",
+ type->element_type->name.c_str ());
+ printf_unfiltered
+ (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
+ type->name.c_str (), type->count);
+
+ printf_unfiltered ("\n");
+ }
+
+ void visit (const tdesc_type_with_fields *type) override
+ {
+ if (!m_printed_type_with_fields)
+ {
+ printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
+ m_printed_type_with_fields = true;
+ }
+
+ switch (type->kind)
+ {
+ case TDESC_TYPE_STRUCT:
+ case TDESC_TYPE_FLAGS:
+ if (type->kind == TDESC_TYPE_STRUCT)
+ {
+ printf_unfiltered
+ (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
+ type->name.c_str ());
+ if (type->size != 0)
+ printf_unfiltered
+ (" tdesc_set_struct_size (type_with_fields, %d);\n", type->size);
+ }
+ else
+ {
+ printf_unfiltered
+ (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
+ type->name.c_str (), type->size);
+ }
+ for (const tdesc_type_field &f : type->fields)
+ {
+ const char *type_name;
+
+ gdb_assert (f.type != NULL);
+ type_name = f.type->name.c_str ();
+
+ /* To minimize changes to generated files, don't emit type
+ info for fields that have defaulted types. */
+ if (f.start != -1)
+ {
+ gdb_assert (f.end != -1);
+ if (f.type->kind == TDESC_TYPE_BOOL)
+ {
+ gdb_assert (f.start == f.end);
+ printf_unfiltered
+ (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
+ f.start, f.name.c_str ());
+ }
+ else if ((type->size == 4 && f.type->kind == TDESC_TYPE_UINT32)
+ || (type->size == 8
+ && f.type->kind == TDESC_TYPE_UINT64))
+ {
+ printf_unfiltered
+ (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
+ f.name.c_str (), f.start, f.end);
+ }
+ else
+ {
+ printf_field_type_assignment
+ ("tdesc_named_type (feature, \"%s\");\n",
+ type_name);
+ printf_unfiltered
+ (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
+ " %d, %d, field_type);\n",
+ f.name.c_str (), f.start, f.end);
+ }
+ }
+ else /* Not a bitfield. */
+ {
+ gdb_assert (f.end == -1);
+ gdb_assert (type->kind == TDESC_TYPE_STRUCT);
+ printf_field_type_assignment
+ ("tdesc_named_type (feature, \"%s\");\n", type_name);
+ printf_unfiltered
+ (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
+ f.name.c_str ());
+ }
+ }
+ break;
+ case TDESC_TYPE_UNION:
+ printf_unfiltered
+ (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
+ type->name.c_str ());
+ for (const tdesc_type_field &f : type->fields)
+ {
+ printf_field_type_assignment
+ ("tdesc_named_type (feature, \"%s\");\n", f.type->name.c_str ());
+ printf_unfiltered
+ (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
+ f.name.c_str ());
+ }
+ break;
+ case TDESC_TYPE_ENUM:
+ printf_unfiltered
+ (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
+ type->name.c_str (), type->size);
+ for (const tdesc_type_field &f : type->fields)
+ printf_unfiltered
+ (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
+ f.start, f.name.c_str ());
+ break;
+ default:
+ error (_("C output is not supported type \"%s\"."), type->name.c_str ());
+ }
+
+ printf_unfiltered ("\n");
+ }
+
+ void visit (const tdesc_reg *reg) override
+ {
+ printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
+ reg->name.c_str (), reg->target_regnum,
+ reg->save_restore);
+ if (!reg->group.empty ())
+ printf_unfiltered ("\"%s\", ", reg->group.c_str ());
+ else
+ printf_unfiltered ("NULL, ");
+ printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
+ }
+
+protected:
+ std::string m_filename_after_features;
+
+private:
+
+ /* Print an assignment to the field_type variable. Print the declaration
+ of field_type if that has not been done yet. */
+ ATTRIBUTE_PRINTF (2, 3)
+ void printf_field_type_assignment (const char *fmt, ...)
+ {
+ if (!m_printed_field_type)
+ {
+ printf_unfiltered (" tdesc_type *field_type;\n");
+ m_printed_field_type = true;
+ }
+
+ printf_unfiltered (" field_type = ");
+
+ va_list args;
+ va_start (args, fmt);
+ vprintf_unfiltered (fmt, args);
+ va_end (args);
+ }
+
+ char *m_function;
+
+ /* Did we print "struct tdesc_type *element_type;" yet? */
+ bool m_printed_element_type = false;
+
+ /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
+ bool m_printed_type_with_fields = false;
+
+ /* Did we print "struct tdesc_type *field_type;" yet? */
+ bool m_printed_field_type = false;
+};
+
+/* Print target description feature in C. */
+
+class print_c_feature : public print_c_tdesc
+{
+public:
+ print_c_feature (std::string &file)
+ : print_c_tdesc (file)
+ {
+ /* Trim ".tmp". */
+ auto const pos = m_filename_after_features.find_last_of ('.');
+
+ m_filename_after_features = m_filename_after_features.substr (0, pos);
+ }
+
+ void visit_pre (const target_desc *e) override
+ {
+ printf_unfiltered (" Original: %s */\n\n",
+ lbasename (m_filename_after_features.c_str ()));
+
+ printf_unfiltered ("#include \"common/tdesc.h\"\n");
+ printf_unfiltered ("\n");
+ }
+
+ void visit_post (const target_desc *e) override
+ {}
+
+ void visit_pre (const tdesc_feature *e) override
+ {
+ std::string name (m_filename_after_features);
+
+ auto pos = name.find_first_of ('.');
+
+ name = name.substr (0, pos);
+ std::replace (name.begin (), name.end (), '/', '_');
+ std::replace (name.begin (), name.end (), '-', '_');
+
+ printf_unfiltered ("static int\n");
+ printf_unfiltered ("create_feature_%s ", name.c_str ());
+ printf_unfiltered ("(struct target_desc *result, long regnum)\n");
+
+ printf_unfiltered ("{\n");
+ printf_unfiltered (" struct tdesc_feature *feature;\n");
+
+ printf_unfiltered
+ ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
+ e->name.c_str (), lbasename (m_filename_after_features.c_str ()));
+ }
+
+ void visit_post (const tdesc_feature *e) override
+ {
+ printf_unfiltered (" return regnum;\n");
+ printf_unfiltered ("}\n");
+ }
+
+ void visit (const tdesc_reg *reg) override
+ {
+ /* Most "reg" in XML target descriptions don't have "regnum"
+ attribute, so the register number is allocated sequentially.
+ In case that reg has "regnum" attribute, register number
+ should be set by that explicitly. */
+
+ if (reg->target_regnum < m_next_regnum)
+ {
+ /* The integrity check, it can catch some errors on register
+ number collision, like this,
+
+ <reg name="x0" bitsize="32"/>
+ <reg name="x1" bitsize="32"/>
+ <reg name="x2" bitsize="32"/>
+ <reg name="x3" bitsize="32"/>
+ <reg name="ps" bitsize="32" regnum="3"/>
+
+ but it also has false negatives. The target description
+ below is correct,
+
+ <reg name="x1" bitsize="32" regnum="1"/>
+ <reg name="x3" bitsize="32" regnum="3"/>
+ <reg name="x2" bitsize="32" regnum="2"/>
+ <reg name="x4" bitsize="32" regnum="4"/>
+
+ but it is not a good practice, so still error on this,
+ and also print the message so that it can be saved in the
+ generated c file. */
+
+ printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
+ reg->target_regnum);
+ printf_unfiltered ("is not the largest number (%d).\n",
+ m_next_regnum);
+ error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
+ reg->target_regnum, m_next_regnum);
+ }
+
+ if (reg->target_regnum > m_next_regnum)
+ {
+ printf_unfiltered (" regnum = %ld;\n", reg->target_regnum);
+ m_next_regnum = reg->target_regnum;
+ }
+
+ printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
+ reg->name.c_str (), reg->save_restore);
+ if (!reg->group.empty ())
+ printf_unfiltered ("\"%s\", ", reg->group.c_str ());
+ else
+ printf_unfiltered ("NULL, ");
+ printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
+
+ m_next_regnum++;
+ }
+
+private:
+ /* The register number to use for the next register we see. */
+ int m_next_regnum = 0;
+};
+
+static void
+maint_print_c_tdesc_cmd (const char *args, int from_tty)
+{
+ const struct target_desc *tdesc;
+ const char *filename;
+
+ if (args == NULL)
+ {
+ /* Use the global target-supplied description, not the current
+ architecture's. This lets a GDB for one architecture generate C
+ for another architecture's description, even though the gdbarch
+ initialization code will reject the new description. */
+ tdesc = current_target_desc;
+ filename = target_description_filename;
+ }
+ else
+ {
+ /* Use the target description from the XML file. */
+ filename = args;
+ tdesc = file_read_description_xml (filename);
+ }
+
+ if (tdesc == NULL)
+ error (_("There is no target description to print."));
+
+ if (filename == NULL)
+ error (_("The current target description did not come from an XML file."));
+
+ std::string filename_after_features (filename);
+ auto loc = filename_after_features.rfind ("/features/");
+
+ if (loc != std::string::npos)
+ filename_after_features = filename_after_features.substr (loc + 10);
+
+ /* Print c files for target features instead of target descriptions,
+ because c files got from target features are more flexible than the
+ counterparts. */
+ if (startswith (filename_after_features.c_str (), "i386/32bit-")
+ || startswith (filename_after_features.c_str (), "i386/64bit-")
+ || startswith (filename_after_features.c_str (), "i386/x32-core.xml")
+ || startswith (filename_after_features.c_str (), "tic6x-")
+ || startswith (filename_after_features.c_str (), "aarch64"))
+ {
+ print_c_feature v (filename_after_features);
+
+ tdesc->accept (v);
+ }
+ else
+ {
+ print_c_tdesc v (filename_after_features);
+
+ tdesc->accept (v);
+ }
+}
+
+namespace selftests {
+
+static std::vector<std::pair<const char*, const target_desc *>> xml_tdesc;
+
+#if GDB_SELF_TEST
+
+/* See target-descritpions.h. */
+
+void
+record_xml_tdesc (const char *xml_file, const struct target_desc *tdesc)
+{
+ xml_tdesc.emplace_back (xml_file, tdesc);
+}
+#endif
+
+}
+
+/* Check that the target descriptions created dynamically by
+ architecture-specific code equal the descriptions created from XML files
+ found in the specified directory DIR. */
+
+static void
+maintenance_check_xml_descriptions (const char *dir, int from_tty)
+{
+ if (dir == NULL)
+ error (_("Missing dir name"));
+
+ gdb::unique_xmalloc_ptr<char> dir1 (tilde_expand (dir));
+ std::string feature_dir (dir1.get ());
+ unsigned int failed = 0;
+
+ for (auto const &e : selftests::xml_tdesc)
+ {
+ std::string tdesc_xml = (feature_dir + SLASH_STRING + e.first);
+ const target_desc *tdesc
+ = file_read_description_xml (tdesc_xml.data ());
+
+ if (tdesc == NULL || *tdesc != *e.second)
+ failed++;
+ }
+ printf_filtered (_("Tested %lu XML files, %d failed\n"),
+ (long) selftests::xml_tdesc.size (), failed);
+}
+
void
_initialize_target_descriptions (void)
{
0 /* allow-unknown */, &unsetlist);
add_setshow_filename_cmd ("filename", class_obscure,
- &target_description_filename,
+ &tdesc_filename_cmd_string,
_("\
Set the file to read for an XML target description"), _("\
Show the file to read for an XML target description"), _("\
Unset the file to read for an XML target description. When unset,\n\
GDB will read the description from the target."),
&tdesc_unset_cmdlist);
+
+ add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
+Print the current target description as a C source file."),
+ &maintenanceprintlist);
+
+ cmd_list_element *cmd;
+
+ cmd = add_cmd ("xml-descriptions", class_maintenance,
+ maintenance_check_xml_descriptions, _("\
+Check the target descriptions created in GDB equal the descriptions\n\
+created from XML files in the directory.\n\
+The parameter is the directory name."),
+ &maintenancechecklist);
+ set_cmd_completer (cmd, filename_completer);
}