/* Target description support for GDB.
- Copyright (C) 2006-2012 Free Software Foundation, Inc.
+ Copyright (C) 2006-2017 Free Software Foundation, Inc.
Contributed by CodeSourcery.
#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 */
+
+/* The interface to visit different elements of target description. */
+
+class tdesc_element_visitor
+{
+public:
+ virtual void visit_pre (const target_desc *e) = 0;
+ virtual void visit_post (const target_desc *e) = 0;
+
+ virtual void visit_pre (const tdesc_feature *e) = 0;
+ virtual void visit_post (const tdesc_feature *e) = 0;
+
+ virtual void visit (const tdesc_type *e) = 0;
+ virtual void visit (const tdesc_reg *e) = 0;
+};
+
+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
+ /* 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 NULL). */
- char *group;
+ 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. */
- char *type;
+ std::string type;
/* The target-described type corresponding to TYPE, if found. */
struct tdesc_type *tdesc_type;
-} *tdesc_reg_p;
-DEF_VEC_P(tdesc_reg_p);
+
+ 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. */
{
char *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_field;
DEF_VEC_O(tdesc_type_field);
-typedef struct tdesc_type_flag
-{
- char *name;
- int start;
-} tdesc_type_flag;
-DEF_VEC_O(tdesc_type_flag);
+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
+};
-typedef struct tdesc_type
+struct tdesc_type : tdesc_element
{
- /* The name of this type. */
- char *name;
+ tdesc_type (const char *name_, enum tdesc_type_kind kind_)
+ : name (xstrdup (name_)), kind (kind_)
+ {
+ memset (&u, 0, sizeof (u));
+ }
- /* Identify the kind of this type. */
- enum
+ virtual ~tdesc_type ()
{
- /* Predefined types. */
- 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,
+ switch (kind)
+ {
+ case TDESC_TYPE_STRUCT:
+ case TDESC_TYPE_UNION:
+ case TDESC_TYPE_FLAGS:
+ case TDESC_TYPE_ENUM:
+ {
+ struct tdesc_type_field *f;
+ int ix;
- /* Types defined by a target feature. */
- TDESC_TYPE_VECTOR,
- TDESC_TYPE_STRUCT,
- TDESC_TYPE_UNION,
- TDESC_TYPE_FLAGS
- } kind;
+ for (ix = 0;
+ VEC_iterate (tdesc_type_field, u.u.fields, ix, f);
+ ix++)
+ xfree (f->name);
+
+ VEC_free (tdesc_type_field, u.u.fields);
+ }
+ break;
+
+ default:
+ break;
+ }
+ xfree ((char *) name);
+ }
+
+ DISABLE_COPY_AND_ASSIGN (tdesc_type);
+
+ /* The name of this type. If this type is a built-in type, this is
+ a pointer to a constant string. Otherwise, it's a
+ malloc-allocated string (and thus must be freed). */
+ const char *name;
+
+ /* Identify the kind of this type. */
+ enum tdesc_type_kind kind;
/* Kind-specific data. */
union
int count;
} v;
- /* Struct or union type. */
+ /* Struct, union, flags, or enum type. */
struct
{
VEC(tdesc_type_field) *fields;
- LONGEST size;
+ int size;
} u;
-
- /* Flags type. */
- struct
- {
- VEC(tdesc_type_flag) *flags;
- LONGEST size;
- } f;
} u;
-} *tdesc_type_p;
-DEF_VEC_P(tdesc_type_p);
+
+ void accept (tdesc_element_visitor &v) const override
+ {
+ v.visit (this);
+ }
+
+ bool operator== (const tdesc_type &other) const
+ {
+ return (streq (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;
/* 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<std::unique_ptr<tdesc_reg>> registers;
/* The types associated with this feature. */
- VEC(tdesc_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);
-/* A compatible architecture from a target description. */
-typedef const struct bfd_arch_info *arch_p;
-DEF_VEC_P(arch_p);
+ 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;
+ enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
/* The list of compatible architectures reported by the target. */
- VEC(arch_p) *compatible;
+ 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<std::unique_ptr<tdesc_feature>> 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
gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
};
-/* 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. */
-/* A flag indicating that a description has already been fetched from
- the current target, so it should not be queried again. */
+struct target_desc_info
+{
+ /* A flag indicating that a description has already been fetched
+ from the target, so it should not be queried again. */
-static int target_desc_fetched;
+ int fetched;
-/* 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. */
+ /* 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. */
-static const struct target_desc *current_target_desc;
+ const struct target_desc *tdesc;
-/* Other global variables. */
+ /* The filename to read a target description from, as set by "set
+ tdesc filename ..." */
-/* The filename to read a target description from. */
+ char *filename;
+};
-static char *target_description_filename;
+/* Get the inferior INF's target description info, allocating one on
+ the stop if necessary. */
+
+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 (target_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 (target_gdbarch, tdesc_data);
+ data = ((struct tdesc_arch_data *)
+ gdbarch_data (target_gdbarch (), tdesc_data));
if (tdesc_has_registers (current_target_desc)
&& data->arch_regs == NULL)
warning (_("Target-supplied registers are not supported "
tdesc_compatible_p (const struct target_desc *target_desc,
const struct bfd_arch_info *arch)
{
- const struct bfd_arch_info *compat;
- int ix;
-
- for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
- ix++)
+ for (const bfd_arch_info *compat : target_desc->compatible)
{
if (compat == arch
|| arch->compatible (arch, compat)
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;
}
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 ();
}
/* Predefined types. */
static struct tdesc_type tdesc_predefined_types[] =
{
+ { "bool", TDESC_TYPE_BOOL },
{ "int8", TDESC_TYPE_INT8 },
{ "int16", TDESC_TYPE_INT16 },
{ "int32", TDESC_TYPE_INT32 },
{ "i387_ext", TDESC_TYPE_I387_EXT }
};
-/* Return the type associated with ID in the context of FEATURE, or
- NULL if none. */
+/* 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 arch/tdesc.h. */
struct tdesc_type *
tdesc_named_type (const struct tdesc_feature *feature, const char *id)
{
- int ix;
- struct tdesc_type *type;
-
/* First try target-defined types. */
- for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
+ for (const tdesc_type_up &type : feature->types)
if (strcmp (type->name, id) == 0)
- return type;
+ return type.get ();
/* Next try the predefined types. */
- for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
+ for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
return &tdesc_predefined_types[ix];
struct tdesc_arch_data *data;
int i, num_regs;
- data = gdbarch_data (gdbarch, tdesc_data);
+ data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
num_regs = VEC_length (tdesc_arch_reg, data->arch_regs);
for (i = 0; i < num_regs; i++)
{
switch (tdesc_type->kind)
{
/* Predefined types. */
+ case TDESC_TYPE_BOOL:
+ return builtin_type (gdbarch)->builtin_bool;
+
case TDESC_TYPE_INT8:
return builtin_type (gdbarch)->builtin_int8;
VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
ix++)
{
- if (f->type == NULL)
+ if (f->start != -1 && f->end != -1)
{
/* Bitfield. */
struct field *fld;
struct type *field_type;
int bitsize, total_size;
- /* This invariant should be preserved while creating
- types. */
+ /* This invariant should be preserved while creating types. */
gdb_assert (tdesc_type->u.u.size != 0);
- if (tdesc_type->u.u.size > 4)
+ if (f->type != NULL)
+ field_type = tdesc_gdb_type (gdbarch, f->type);
+ else if (tdesc_type->u.u.size > 4)
field_type = builtin_type (gdbarch)->builtin_uint64;
else
field_type = builtin_type (gdbarch)->builtin_uint32;
}
else
{
+ gdb_assert (f->start == -1 && f->end == -1);
field_type = tdesc_gdb_type (gdbarch, f->type);
append_composite_type_field (type, xstrdup (f->name),
field_type);
case TDESC_TYPE_FLAGS:
{
- struct tdesc_type_flag *f;
+ struct tdesc_type_field *f;
int ix;
type = arch_flags_type (gdbarch, tdesc_type->name,
- tdesc_type->u.f.size);
+ tdesc_type->u.u.size * TARGET_CHAR_BIT);
+ for (ix = 0;
+ VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
+ ix++)
+ {
+ struct type *field_type;
+ int bitsize = f->end - f->start + 1;
+
+ gdb_assert (f->type != NULL);
+ field_type = tdesc_gdb_type (gdbarch, f->type);
+ append_flags_type_field (type, f->start, bitsize,
+ field_type, f->name);
+ }
+
+ return type;
+ }
+
+ case TDESC_TYPE_ENUM:
+ {
+ struct tdesc_type_field *f;
+ int ix;
+
+ type = arch_type (gdbarch, TYPE_CODE_ENUM,
+ tdesc_type->u.u.size * TARGET_CHAR_BIT,
+ tdesc_type->name);
+ TYPE_UNSIGNED (type) = 1;
for (ix = 0;
- VEC_iterate (tdesc_type_flag, tdesc_type->u.f.flags, ix, f);
+ VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
ix++)
- /* Note that contrary to the function name, this call will
- just set the properties of an already-allocated
- field. */
- append_flags_type_flag (type, f->start,
- *f->name ? f->name : NULL);
+ {
+ struct field *fld
+ = append_composite_type_field_raw (type, xstrdup (f->name),
+ NULL);
+
+ SET_FIELD_BITPOS (fld[0], f->start);
+ }
return type;
}
struct tdesc_arch_data *
tdesc_data_alloc (void)
{
- return XZALLOC (struct tdesc_arch_data);
+ return XCNEW (struct 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_arch_reg, data->arch_regs);
xfree (data);
tdesc_find_register_early (const struct tdesc_feature *feature,
const char *name)
{
- int ixr;
- struct tdesc_reg *reg;
-
- for (ixr = 0;
- VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
- ixr++)
- if (strcasecmp (reg->name, name) == 0)
- return reg;
+ for (const tdesc_reg_up ® : feature->registers)
+ if (strcasecmp (reg->name.c_str (), name) == 0)
+ return reg.get ();
return NULL;
}
{
struct tdesc_arch_data *data;
- data = gdbarch_data (gdbarch, tdesc_data);
+ data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
else
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 (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 (gdbarch, regno);
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);
arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
/* Next try size-sensitive type shortcuts. */
- else if (strcmp (reg->type, "float") == 0)
+ else if (reg->type == "float")
{
if (reg->bitsize == gdbarch_float_bit (gdbarch))
arch_reg->type = builtin_type (gdbarch)->builtin_float;
else
{
warning (_("Register \"%s\" has an unsupported size (%d bits)"),
- reg->name, reg->bitsize);
+ reg->name.c_str (), reg->bitsize);
arch_reg->type = builtin_type (gdbarch)->builtin_double;
}
}
- else if (strcmp (reg->type, "int") == 0)
+ else if (reg->type == "int")
{
if (reg->bitsize == gdbarch_long_bit (gdbarch))
arch_reg->type = builtin_type (gdbarch)->builtin_long;
else
{
warning (_("Register \"%s\" has an unsupported size (%d bits)"),
- reg->name, reg->bitsize);
+ 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, reg->type);
+ reg->name.c_str (), reg->type.c_str ());
}
return arch_reg->type;
{
struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
- if (reg != NULL && reg->group != NULL)
+ if (reg != NULL && !reg->group.empty ())
{
int general_p = 0, float_p = 0, vector_p = 0;
- if (strcmp (reg->group, "general") == 0)
+ if (reg->group == "general")
general_p = 1;
- else if (strcmp (reg->group, "float") == 0)
+ else if (reg->group == "float")
float_p = 1;
- else if (strcmp (reg->group, "vector") == 0)
+ else if (reg->group == "vector")
vector_p = 1;
if (reggroup == float_reggroup)
if (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);
if (data->pseudo_register_reggroup_p != NULL)
return data->pseudo_register_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;
}
struct tdesc_arch_data *early_data)
{
int num_regs = gdbarch_num_regs (gdbarch);
- int ixf, ixr;
- struct tdesc_feature *feature;
- struct tdesc_reg *reg;
struct tdesc_arch_data *data;
struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
htab_t reg_hash;
included. */
gdb_assert (tdesc_has_registers (target_desc));
- data = gdbarch_data (gdbarch, tdesc_data);
+ data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
data->arch_regs = early_data->arch_regs;
xfree (early_data);
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);
+ void **slot = htab_find_slot (reg_hash, reg.get (), INSERT);
- *slot = reg;
+ *slot = reg.get ();
}
/* Remove any registers which were assigned numbers by the
architecture. */
- for (ixr = 0;
+ for (int ixr = 0;
VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
ixr++)
if (arch_reg->reg)
gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
- 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)
+ for (const tdesc_feature_up &feature : target_desc->features)
+ for (const tdesc_reg_up ® : feature->registers)
+ if (htab_find (reg_hash, reg.get ()) != NULL)
{
- new_arch_reg.reg = reg;
+ new_arch_reg.reg = reg.get ();
VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
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 arch/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);
-
- 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>");
-
- /* 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->tdesc_type = tdesc_named_type (feature, reg->type);
+ tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
+ group, bitsize, type);
- VEC_safe_push (tdesc_reg_p, feature->registers, reg);
+ feature->registers.emplace_back (reg);
}
-static void
-tdesc_free_type (struct tdesc_type *type)
-{
- switch (type->kind)
- {
- case TDESC_TYPE_STRUCT:
- case TDESC_TYPE_UNION:
- {
- struct tdesc_type_field *f;
- int ix;
-
- for (ix = 0;
- VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
- ix++)
- xfree (f->name);
-
- VEC_free (tdesc_type_field, type->u.u.fields);
- }
- break;
-
- case TDESC_TYPE_FLAGS:
- {
- struct tdesc_type_flag *f;
- int ix;
-
- for (ix = 0;
- VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
- ix++)
- xfree (f->name);
-
- VEC_free (tdesc_type_flag, type->u.f.flags);
- }
- break;
-
- default:
- break;
- }
-
- xfree (type->name);
- xfree (type);
-}
+/* See arch/tdesc.h. */
struct tdesc_type *
tdesc_create_vector (struct tdesc_feature *feature, const char *name,
struct tdesc_type *field_type, int count)
{
- struct tdesc_type *type = XZALLOC (struct tdesc_type);
+ struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_VECTOR);
- type->name = xstrdup (name);
- type->kind = TDESC_TYPE_VECTOR;
type->u.v.type = field_type;
type->u.v.count = count;
- VEC_safe_push (tdesc_type_p, feature->types, type);
+ feature->types.emplace_back (type);
return type;
}
+/* See arch/tdesc.h. */
+
struct tdesc_type *
tdesc_create_struct (struct tdesc_feature *feature, const char *name)
{
- struct tdesc_type *type = XZALLOC (struct tdesc_type);
-
- type->name = xstrdup (name);
- type->kind = TDESC_TYPE_STRUCT;
+ struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_STRUCT);
- VEC_safe_push (tdesc_type_p, feature->types, type);
+ feature->types.emplace_back (type);
return 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. */
+/* See arch/tdesc.h. */
void
-tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
+tdesc_set_struct_size (struct tdesc_type *type, int size)
{
gdb_assert (type->kind == TDESC_TYPE_STRUCT);
+ gdb_assert (size > 0);
type->u.u.size = size;
}
+/* See arch/tdesc.h. */
+
struct tdesc_type *
tdesc_create_union (struct tdesc_feature *feature, const char *name)
{
- struct tdesc_type *type = XZALLOC (struct tdesc_type);
-
- type->name = xstrdup (name);
- type->kind = TDESC_TYPE_UNION;
+ struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_UNION);
- VEC_safe_push (tdesc_type_p, feature->types, type);
+ feature->types.emplace_back (type);
return type;
}
+/* See arch/tdesc.h. */
+
struct tdesc_type *
tdesc_create_flags (struct tdesc_feature *feature, const char *name,
- LONGEST size)
+ int size)
{
- struct tdesc_type *type = XZALLOC (struct tdesc_type);
+ struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_FLAGS);
- type->name = xstrdup (name);
- type->kind = TDESC_TYPE_FLAGS;
- type->u.f.size = size;
+ gdb_assert (size > 0);
- VEC_safe_push (tdesc_type_p, feature->types, type);
+ type->u.u.size = size;
+
+ feature->types.emplace_back (type);
return type;
}
-/* Add a new field. Return a temporary pointer to the field, which
- is only valid until the next call to tdesc_add_field (the vector
- might be reallocated). */
+struct tdesc_type *
+tdesc_create_enum (struct tdesc_feature *feature, const char *name,
+ int size)
+{
+ struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_ENUM);
+
+ gdb_assert (size > 0);
+
+ type->u.u.size = size;
+
+ feature->types.emplace_back (type);
+ return type;
+}
+
+/* See arch/tdesc.h. */
void
tdesc_add_field (struct tdesc_type *type, const char *field_name,
f.name = xstrdup (field_name);
f.type = field_type;
+ /* Initialize these values so we know this is not a bit-field
+ when we print-c-tdesc. */
+ f.start = -1;
+ f.end = -1;
VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
}
-/* Add a new bitfield. */
-
void
-tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
- int start, int end)
+tdesc_add_typed_bitfield (struct tdesc_type *type, const char *field_name,
+ int start, int end, struct tdesc_type *field_type)
{
struct tdesc_type_field f = { 0 };
- gdb_assert (type->kind == TDESC_TYPE_STRUCT);
+ gdb_assert (type->kind == TDESC_TYPE_STRUCT
+ || type->kind == TDESC_TYPE_FLAGS);
+ gdb_assert (start >= 0 && end >= start);
f.name = xstrdup (field_name);
f.start = start;
f.end = end;
+ f.type = field_type;
VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
}
+/* See arch/tdesc.h. */
+
+void
+tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
+ int start, int end)
+{
+ struct tdesc_type *field_type;
+
+ gdb_assert (start >= 0 && end >= start);
+
+ if (type->u.u.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 arch/tdesc.h. */
+
void
tdesc_add_flag (struct tdesc_type *type, int start,
const char *flag_name)
{
- struct tdesc_type_flag f = { 0 };
+ struct tdesc_type_field f = { 0 };
- gdb_assert (type->kind == TDESC_TYPE_FLAGS);
+ gdb_assert (type->kind == TDESC_TYPE_FLAGS
+ || type->kind == TDESC_TYPE_STRUCT);
f.name = xstrdup (flag_name);
f.start = start;
+ f.end = start;
+ f.type = tdesc_predefined_type (TDESC_TYPE_BOOL);
- VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
+ VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
}
-static void
-tdesc_free_feature (struct tdesc_feature *feature)
+void
+tdesc_add_enum_value (struct tdesc_type *type, int value,
+ const char *name)
{
- struct tdesc_reg *reg;
- struct tdesc_type *type;
- int ix;
+ struct tdesc_type_field f = { 0 };
- for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
- tdesc_free_reg (reg);
- VEC_free (tdesc_reg_p, feature->registers);
+ gdb_assert (type->kind == TDESC_TYPE_ENUM);
- for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
- tdesc_free_type (type);
- VEC_free (tdesc_type_p, feature->types);
+ f.name = xstrdup (name);
+ f.start = value;
+ f.end = -1;
+ f.type = tdesc_predefined_type (TDESC_TYPE_INT32);
- xfree (feature->name);
- xfree (feature);
+ VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
}
+/* See arch/tdesc.h. */
+
struct tdesc_feature *
-tdesc_create_feature (struct target_desc *tdesc, const char *name)
+tdesc_create_feature (struct target_desc *tdesc, const char *name,
+ const char *xml)
{
- struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
+ struct tdesc_feature *new_feature = new tdesc_feature (name);
- new_feature->name = xstrdup (name);
+ tdesc->features.emplace_back (new_feature);
- VEC_safe_push (tdesc_feature_p, tdesc->features, 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);
+ struct target_desc *target_desc = (struct target_desc *) arg;
- 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);
-
- VEC_free (arch_p, target_desc->compatible);
-
- xfree (target_desc);
+ delete target_desc;
}
struct cleanup *
tdesc_add_compatible (struct target_desc *target_desc,
const struct bfd_arch_info *compatible)
{
- const struct bfd_arch_info *compat;
- int ix;
-
/* 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 (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
- ix++)
+ 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);
- VEC_safe_push (arch_p, target_desc->compatible, compatible);
+ 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);
+
+ target_desc->properties.emplace_back (key, value);
+}
+
+/* See arch/tdesc.h. */
- new_prop.key = xstrdup (key);
- new_prop.value = xstrdup (value);
- VEC_safe_push (property_s, target_desc->properties, &new_prop);
+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 arch/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)
{
/* 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"),
value);
}
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 struct bfd_arch_info *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 *type) override
+ {
+ struct tdesc_type_field *f;
+
+ /* Now we do some "filtering" in order to know which variables to
+ declare. This is needed because otherwise we would declare unused
+ variables `field_type' and `type'. */
+ if (!m_printed_field_type)
+ {
+ printf_unfiltered (" struct tdesc_type *field_type;\n");
+ m_printed_field_type = true;
+ }
+
+ if ((type->kind == TDESC_TYPE_UNION
+ || type->kind == TDESC_TYPE_STRUCT
+ || type->kind == TDESC_TYPE_FLAGS
+ || type->kind == TDESC_TYPE_ENUM)
+ && VEC_length (tdesc_type_field, type->u.u.fields) > 0
+ && !m_printed_type)
+ {
+ printf_unfiltered (" struct tdesc_type *type;\n");
+ m_printed_type = true;
+ }
+
+ switch (type->kind)
+ {
+ case TDESC_TYPE_VECTOR:
+ printf_unfiltered
+ (" field_type = tdesc_named_type (feature, \"%s\");\n",
+ type->u.v.type->name);
+ printf_unfiltered
+ (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
+ type->name, type->u.v.count);
+ break;
+ case TDESC_TYPE_STRUCT:
+ case TDESC_TYPE_FLAGS:
+ if (type->kind == TDESC_TYPE_STRUCT)
+ {
+ printf_unfiltered
+ (" type = tdesc_create_struct (feature, \"%s\");\n",
+ type->name);
+ if (type->u.u.size != 0)
+ printf_unfiltered
+ (" tdesc_set_struct_size (type, %d);\n",
+ type->u.u.size);
+ }
+ else
+ {
+ printf_unfiltered
+ (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
+ type->name, type->u.u.size);
+ }
+ for (int ix3 = 0;
+ VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
+ ix3++)
+ {
+ const char *type_name;
+
+ gdb_assert (f->type != NULL);
+ type_name = f->type->name;
+
+ /* 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, %d, \"%s\");\n",
+ f->start, f->name);
+ }
+ else if ((type->u.u.size == 4
+ && f->type->kind == TDESC_TYPE_UINT32)
+ || (type->u.u.size == 8
+ && f->type->kind == TDESC_TYPE_UINT64))
+ {
+ printf_unfiltered
+ (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
+ f->name, f->start, f->end);
+ }
+ else
+ {
+ printf_unfiltered
+ (" field_type = tdesc_named_type (feature,"
+ " \"%s\");\n",
+ type_name);
+ printf_unfiltered
+ (" tdesc_add_typed_bitfield (type, \"%s\","
+ " %d, %d, field_type);\n",
+ f->name, f->start, f->end);
+ }
+ }
+ else /* Not a bitfield. */
+ {
+ gdb_assert (f->end == -1);
+ gdb_assert (type->kind == TDESC_TYPE_STRUCT);
+ printf_unfiltered
+ (" field_type = tdesc_named_type (feature,"
+ " \"%s\");\n",
+ type_name);
+ printf_unfiltered
+ (" tdesc_add_field (type, \"%s\", field_type);\n",
+ f->name);
+ }
+ }
+ break;
+ case TDESC_TYPE_UNION:
+ printf_unfiltered
+ (" type = tdesc_create_union (feature, \"%s\");\n",
+ type->name);
+ for (int ix3 = 0;
+ VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
+ ix3++)
+ {
+ printf_unfiltered
+ (" field_type = tdesc_named_type (feature, \"%s\");\n",
+ f->type->name);
+ printf_unfiltered
+ (" tdesc_add_field (type, \"%s\", field_type);\n",
+ f->name);
+ }
+ break;
+ case TDESC_TYPE_ENUM:
+ printf_unfiltered
+ (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
+ type->name, type->u.u.size);
+ for (int ix3 = 0;
+ VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
+ ix3++)
+ printf_unfiltered
+ (" tdesc_add_enum_value (type, %d, \"%s\");\n",
+ f->start, f->name);
+ break;
+ default:
+ error (_("C output is not supported type \"%s\"."), type->name);
+ }
+ 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:
+ char *m_function;
+ bool m_printed_field_type = false;
+ bool m_printed_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 \"arch/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 (char *args, int from_tty)
+maint_print_c_tdesc_cmd (const char *args, int from_tty)
{
const struct target_desc *tdesc;
- const struct bfd_arch_info *compatible;
- const char *filename, *inp;
- char *function, *outp;
- struct property *prop;
- struct tdesc_feature *feature;
- struct tdesc_reg *reg;
- struct tdesc_type *type;
- struct tdesc_type_field *f;
- struct tdesc_type_flag *flag;
- int ix, ix2, ix3;
-
- /* 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;
+ 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 (target_description_filename == NULL)
+ if (filename == NULL)
error (_("The current target description did not come from an XML file."));
- filename = lbasename (target_description_filename);
- function = alloca (strlen (filename) + 1);
- for (inp = filename, outp = function; *inp != '\0'; inp++)
- if (*inp == '.')
- break;
- else if (*inp == '-')
- *outp++ = '_';
- else
- *outp++ = *inp;
- *outp = '\0';
-
- /* Standard boilerplate. */
- printf_unfiltered ("/* THIS FILE IS GENERATED. Original: %s */\n\n",
- filename);
- 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", function);
- printf_unfiltered ("static void\n");
- printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
- printf_unfiltered ("{\n");
- printf_unfiltered
- (" struct target_desc *result = allocate_target_description ();\n");
- printf_unfiltered (" struct tdesc_feature *feature;\n");
- printf_unfiltered (" struct tdesc_type *field_type, *type;\n");
- printf_unfiltered ("\n");
-
- if (tdesc_architecture (tdesc) != NULL)
- {
- printf_unfiltered
- (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
- tdesc_architecture (tdesc)->printable_name);
- printf_unfiltered ("\n");
- }
+ std::string filename_after_features (filename);
+ auto loc = filename_after_features.rfind ("/features/");
- if (tdesc_osabi (tdesc) > GDB_OSABI_UNKNOWN
- && tdesc_osabi (tdesc) < GDB_OSABI_INVALID)
- {
- printf_unfiltered
- (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
- gdbarch_osabi_name (tdesc_osabi (tdesc)));
- printf_unfiltered ("\n");
- }
+ if (loc != std::string::npos)
+ filename_after_features = filename_after_features.substr (loc + 10);
- for (ix = 0; VEC_iterate (arch_p, tdesc->compatible, ix, compatible);
- ix++)
+ /* 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"))
{
- printf_unfiltered
- (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
- compatible->printable_name);
- }
- if (ix)
- printf_unfiltered ("\n");
+ print_c_feature v (filename_after_features);
- for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
- ix++)
+ tdesc->accept (v);
+ }
+ else
{
- printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
- prop->key, prop->value);
+ print_c_tdesc v (filename_after_features);
+
+ tdesc->accept (v);
}
+}
- for (ix = 0;
- VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
- ix++)
- {
- printf_unfiltered (" \
-feature = tdesc_create_feature (result, \"%s\");\n",
- feature->name);
+namespace selftests {
- for (ix2 = 0;
- VEC_iterate (tdesc_type_p, feature->types, ix2, type);
- ix2++)
- {
- switch (type->kind)
- {
- case TDESC_TYPE_VECTOR:
- printf_unfiltered
- (" field_type = tdesc_named_type (feature, \"%s\");\n",
- type->u.v.type->name);
- printf_unfiltered
- (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
- type->name, type->u.v.count);
- break;
- case TDESC_TYPE_UNION:
- printf_unfiltered
- (" type = tdesc_create_union (feature, \"%s\");\n",
- type->name);
- for (ix3 = 0;
- VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
- ix3++)
- {
- printf_unfiltered
- (" field_type = tdesc_named_type (feature, \"%s\");\n",
- f->type->name);
- printf_unfiltered
- (" tdesc_add_field (type, \"%s\", field_type);\n",
- f->name);
- }
- break;
- case TDESC_TYPE_FLAGS:
- printf_unfiltered
- (" field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
- type->name, (int) type->u.f.size);
- for (ix3 = 0;
- VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
- flag);
- ix3++)
- printf_unfiltered
- (" tdesc_add_flag (field_type, %d, \"%s\");\n",
- flag->start, flag->name);
- break;
- default:
- error (_("C output is not supported type \"%s\"."), type->name);
- }
- printf_unfiltered ("\n");
- }
+static std::vector<std::pair<const char*, const target_desc *>> xml_tdesc;
- for (ix2 = 0;
- VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
- ix2++)
- {
- printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
- reg->name, reg->target_regnum, reg->save_restore);
- if (reg->group)
- printf_unfiltered ("\"%s\", ", reg->group);
- else
- printf_unfiltered ("NULL, ");
- printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
- }
+#if GDB_SELF_TEST
- printf_unfiltered ("\n");
- }
+/* 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
- printf_unfiltered (" tdesc_%s = result;\n", function);
- printf_unfiltered ("}\n");
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_target_descriptions;
+/* 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"), _("\
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);
}
projects / deliverable / binutils-gdb.git / blobdiff