/* XML target description support for GDB.
- Copyright (C) 2006
- Free Software Foundation, Inc.
+ Copyright (C) 2006-2019 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 "target.h"
#include "target-descriptions.h"
#include "xml-support.h"
#include "xml-tdesc.h"
-
+#include "osabi.h"
#include "filenames.h"
+#include <unordered_map>
+#include <string>
-#include "gdb_assert.h"
+/* Maximum sizes.
+ This is just to catch obviously wrong values. */
+#define MAX_FIELD_SIZE 65536
+#define MAX_FIELD_BITSIZE (MAX_FIELD_SIZE * TARGET_CHAR_BIT)
+#define MAX_VECTOR_SIZE 65536
#if !defined(HAVE_LIBEXPAT)
#else /* HAVE_LIBEXPAT */
+/* A record of every XML description we have parsed. We never discard
+ old descriptions, because we never discard gdbarches. As long as we
+ have a gdbarch referencing this description, we want to have a copy
+ of it here, so that if we parse the same XML document again we can
+ return the same "struct target_desc *"; if they are not singletons,
+ then we will create unnecessary duplicate gdbarches. See
+ gdbarch_list_lookup_by_info. */
+
+static std::unordered_map<std::string, target_desc_up> xml_cache;
+
/* Callback data for target description parsing. */
struct tdesc_parsing_data
{
/* The target description we are building. */
struct target_desc *tdesc;
+
+ /* The target feature we are currently parsing, or last parsed. */
+ struct tdesc_feature *current_feature;
+
+ /* The register number to use for the next register we see, if
+ it does not have its own. This starts at zero. */
+ int next_regnum;
+
+ /* The struct or union we are currently parsing, or last parsed. */
+ tdesc_type_with_fields *current_type;
+
+ /* The byte size of the current struct/flags type, if specified. Zero
+ if not specified. Flags values must specify a size. */
+ int current_type_size;
};
/* Handle the end of an <architecture> element and its value. */
const struct gdb_xml_element *element,
void *user_data, const char *body_text)
{
- struct tdesc_parsing_data *data = user_data;
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
const struct bfd_arch_info *arch;
arch = bfd_scan_arch (body_text);
set_tdesc_architecture (data->tdesc, arch);
}
-/* The elements and attributes of an XML target description. */
+/* Handle the end of an <osabi> element and its value. */
-const struct gdb_xml_element target_children[] = {
- { "architecture", NULL, NULL, GDB_XML_EF_OPTIONAL,
- NULL, tdesc_end_arch },
- { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
-};
+static void
+tdesc_end_osabi (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, const char *body_text)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ enum gdb_osabi osabi;
-const struct gdb_xml_element tdesc_elements[] = {
- { "target", NULL, target_children, GDB_XML_EF_NONE,
- NULL, NULL },
- { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
-};
+ osabi = osabi_from_tdesc_string (body_text);
+ if (osabi == GDB_OSABI_UNKNOWN)
+ warning (_("Target description specified unknown osabi \"%s\""),
+ body_text);
+ else
+ set_tdesc_osabi (data->tdesc, osabi);
+}
-/* Parse DOCUMENT into a target description and return it. */
+/* Handle the end of a <compatible> element and its value. */
-static struct target_desc *
-tdesc_parse_xml (const char *document, xml_fetch_another fetcher,
- void *fetcher_baton)
+static void
+tdesc_end_compatible (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, const char *body_text)
{
- struct cleanup *back_to, *result_cleanup;
- struct gdb_xml_parser *parser;
- struct tdesc_parsing_data data;
- char *expanded_text;
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ const struct bfd_arch_info *arch;
- /* Expand all XInclude directives. */
- expanded_text = xml_process_xincludes (_("target description"),
- document, fetcher, fetcher_baton, 0);
- if (expanded_text == NULL)
- {
- warning (_("Could not load XML target description; ignoring"));
- return NULL;
- }
- back_to = make_cleanup (xfree, expanded_text);
+ arch = bfd_scan_arch (body_text);
+ tdesc_add_compatible (data->tdesc, arch);
+}
- parser = gdb_xml_create_parser_and_cleanup (_("target description"),
- tdesc_elements, &data);
- gdb_xml_use_dtd (parser, "gdb-target.dtd");
+/* Handle the start of a <target> element. */
- memset (&data, 0, sizeof (struct tdesc_parsing_data));
- data.tdesc = allocate_target_description ();
- result_cleanup = make_cleanup_free_target_description (data.tdesc);
+static void
+tdesc_start_target (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ char *version
+ = (char *) xml_find_attribute (attributes, "version")->value.get ();
- if (gdb_xml_parse (parser, expanded_text) == 0)
- {
- /* Parsed successfully. */
- discard_cleanups (result_cleanup);
- do_cleanups (back_to);
- return data.tdesc;
- }
+ if (strcmp (version, "1.0") != 0)
+ gdb_xml_error (parser,
+ _("Target description has unsupported version \"%s\""),
+ version);
+}
+
+/* Handle the start of a <feature> element. */
+
+static void
+tdesc_start_feature (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ char *name = (char *) xml_find_attribute (attributes, "name")->value.get ();
+
+ data->current_feature = tdesc_create_feature (data->tdesc, name);
+}
+
+/* Handle the start of a <reg> element. Fill in the optional
+ attributes and attach it to the containing feature. */
+
+static void
+tdesc_start_reg (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ int ix = 0;
+ char *name, *group;
+ const char *type;
+ int bitsize, regnum, save_restore;
+
+ int length = attributes.size ();
+
+ name = (char *) attributes[ix++].value.get ();
+ bitsize = * (ULONGEST *) attributes[ix++].value.get ();
+
+ if (ix < length && strcmp (attributes[ix].name, "regnum") == 0)
+ regnum = * (ULONGEST *) attributes[ix++].value.get ();
+ else
+ regnum = data->next_regnum;
+
+ if (ix < length && strcmp (attributes[ix].name, "type") == 0)
+ type = (char *) attributes[ix++].value.get ();
+ else
+ type = "int";
+
+ if (ix < length && strcmp (attributes[ix].name, "group") == 0)
+ group = (char *) attributes[ix++].value.get ();
else
+ group = NULL;
+
+ if (ix < length && strcmp (attributes[ix].name, "save-restore") == 0)
+ save_restore = * (ULONGEST *) attributes[ix++].value.get ();
+ else
+ save_restore = 1;
+
+ if (strcmp (type, "int") != 0
+ && strcmp (type, "float") != 0
+ && tdesc_named_type (data->current_feature, type) == NULL)
+ gdb_xml_error (parser, _("Register \"%s\" has unknown type \"%s\""),
+ name, type);
+
+ tdesc_create_reg (data->current_feature, name, regnum, save_restore, group,
+ bitsize, type);
+
+ data->next_regnum = regnum + 1;
+}
+
+/* Handle the start of a <union> element. Initialize the type and
+ record it with the current feature. */
+
+static void
+tdesc_start_union (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
+
+ data->current_type = tdesc_create_union (data->current_feature, id);
+ data->current_type_size = 0;
+}
+
+/* Handle the start of a <struct> element. Initialize the type and
+ record it with the current feature. */
+
+static void
+tdesc_start_struct (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
+ struct gdb_xml_value *attr;
+
+ tdesc_type_with_fields *type_with_fields
+ = tdesc_create_struct (data->current_feature, id);
+ data->current_type = type_with_fields;
+ data->current_type_size = 0;
+
+ attr = xml_find_attribute (attributes, "size");
+ if (attr != NULL)
{
- warning (_("Could not load XML target description; ignoring"));
- do_cleanups (back_to);
- return NULL;
+ ULONGEST size = * (ULONGEST *) attr->value.get ();
+
+ if (size > MAX_FIELD_SIZE)
+ {
+ gdb_xml_error (parser,
+ _("Struct size %s is larger than maximum (%d)"),
+ pulongest (size), MAX_FIELD_SIZE);
+ }
+ tdesc_set_struct_size (type_with_fields, size);
+ data->current_type_size = size;
}
}
-#endif /* HAVE_LIBEXPAT */
-\f
-/* Close FILE. */
+static void
+tdesc_start_flags (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
+ ULONGEST size = * (ULONGEST *)
+ xml_find_attribute (attributes, "size")->value.get ();
+
+ if (size > MAX_FIELD_SIZE)
+ {
+ gdb_xml_error (parser,
+ _("Flags size %s is larger than maximum (%d)"),
+ pulongest (size), MAX_FIELD_SIZE);
+ }
+
+ data->current_type = tdesc_create_flags (data->current_feature, id, size);
+ data->current_type_size = size;
+}
static void
-do_cleanup_fclose (void *file)
+tdesc_start_enum (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
{
- fclose (file);
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
+ int size = * (ULONGEST *)
+ xml_find_attribute (attributes, "size")->value.get ();
+
+ if (size > MAX_FIELD_SIZE)
+ {
+ gdb_xml_error (parser,
+ _("Enum size %s is larger than maximum (%d)"),
+ pulongest (size), MAX_FIELD_SIZE);
+ }
+
+ data->current_type = tdesc_create_enum (data->current_feature, id, size);
+ data->current_type_size = 0;
}
-/* Open FILENAME, read all its text into memory, close it, and return
- the text. If something goes wrong, return NULL and warn. */
+/* Handle the start of a <field> element. Attach the field to the
+ current struct, union or flags. */
-static char *
-fetch_xml_from_file (const char *filename, void *baton)
+static void
+tdesc_start_field (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
{
- const char *dirname = baton;
- FILE *file;
- struct cleanup *back_to;
- char *text;
- size_t len, offset;
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ struct gdb_xml_value *attr;
+ struct tdesc_type *field_type;
+ char *field_name, *field_type_id;
+ int start, end;
+
+ field_name = (char *) xml_find_attribute (attributes, "name")->value.get ();
- if (dirname && *dirname)
+ attr = xml_find_attribute (attributes, "type");
+ if (attr != NULL)
{
- char *fullname = concat (dirname, "/", filename, NULL);
- if (fullname == NULL)
- nomem (0);
- file = fopen (fullname, FOPEN_RT);
- xfree (fullname);
+ field_type_id = (char *) attr->value.get ();
+ field_type = tdesc_named_type (data->current_feature, field_type_id);
}
else
- file = fopen (filename, FOPEN_RT);
+ {
+ field_type_id = NULL;
+ field_type = NULL;
+ }
- if (file == NULL)
- return NULL;
+ attr = xml_find_attribute (attributes, "start");
+ if (attr != NULL)
+ {
+ ULONGEST ul_start = * (ULONGEST *) attr->value.get ();
- back_to = make_cleanup (do_cleanup_fclose, file);
+ if (ul_start > MAX_FIELD_BITSIZE)
+ {
+ gdb_xml_error (parser,
+ _("Field start %s is larger than maximum (%d)"),
+ pulongest (ul_start), MAX_FIELD_BITSIZE);
+ }
+ start = ul_start;
+ }
+ else
+ start = -1;
- /* Read in the whole file, one chunk at a time. */
- len = 4096;
- offset = 0;
- text = xmalloc (len);
- make_cleanup (free_current_contents, &text);
- while (1)
+ attr = xml_find_attribute (attributes, "end");
+ if (attr != NULL)
{
- size_t bytes_read;
+ ULONGEST ul_end = * (ULONGEST *) attr->value.get ();
- /* Continue reading where the last read left off. Leave at least
- one byte so that we can NUL-terminate the result. */
- bytes_read = fread (text + offset, 1, len - offset - 1, file);
- if (ferror (file))
+ if (ul_end > MAX_FIELD_BITSIZE)
{
- warning (_("Read error from \"%s\""), filename);
- do_cleanups (back_to);
- return NULL;
+ gdb_xml_error (parser,
+ _("Field end %s is larger than maximum (%d)"),
+ pulongest (ul_end), MAX_FIELD_BITSIZE);
}
+ end = ul_end;
+ }
+ else
+ end = -1;
+
+ if (start != -1)
+ {
+ tdesc_type_with_fields *t = data->current_type;
- offset += bytes_read;
+ /* Older versions of gdb can't handle elided end values.
+ Stick with that for now, to help ensure backward compatibility.
+ E.g., If a newer gdbserver is talking to an older gdb. */
+ if (end == -1)
+ gdb_xml_error (parser, _("Missing end value"));
- if (feof (file))
- break;
+ if (data->current_type_size == 0)
+ gdb_xml_error (parser,
+ _("Bitfields must live in explicitly sized types"));
- len = len * 2;
- text = xrealloc (text, len);
+ if (field_type_id != NULL
+ && strcmp (field_type_id, "bool") == 0
+ && start != end)
+ {
+ gdb_xml_error (parser,
+ _("Boolean fields must be one bit in size"));
+ }
+
+ if (end >= 64)
+ gdb_xml_error (parser,
+ _("Bitfield \"%s\" goes past "
+ "64 bits (unsupported)"),
+ field_name);
+
+ /* Assume that the bit numbering in XML is "lsb-zero". Most
+ architectures other than PowerPC use this ordering. In the
+ future, we can add an XML tag to indicate "msb-zero" numbering. */
+ if (start > end)
+ gdb_xml_error (parser, _("Bitfield \"%s\" has start after end"),
+ field_name);
+ if (end >= data->current_type_size * TARGET_CHAR_BIT)
+ gdb_xml_error (parser, _("Bitfield \"%s\" does not fit in struct"),
+ field_name);
+
+ if (field_type != NULL)
+ tdesc_add_typed_bitfield (t, field_name, start, end, field_type);
+ else if (start == end)
+ tdesc_add_flag (t, start, field_name);
+ else
+ tdesc_add_bitfield (t, field_name, start, end);
}
+ else if (start == -1 && end != -1)
+ gdb_xml_error (parser, _("End specified but not start"));
+ else if (field_type_id != NULL)
+ {
+ /* TDESC_TYPE_FLAGS values are explicitly sized, so the following test
+ catches adding non-bitfield types to flags as well. */
+ if (data->current_type_size != 0)
+ gdb_xml_error (parser,
+ _("Explicitly sized type cannot "
+ "contain non-bitfield \"%s\""),
+ field_name);
+
+ if (field_type == NULL)
+ gdb_xml_error (parser, _("Field \"%s\" references undefined "
+ "type \"%s\""),
+ field_name, field_type_id);
+
+ tdesc_add_field (data->current_type, field_name, field_type);
+ }
+ else
+ gdb_xml_error (parser, _("Field \"%s\" has neither type nor bit position"),
+ field_name);
+}
- fclose (file);
- discard_cleanups (back_to);
+/* Handle the start of an <evalue> element. Attach the value to the
+ current enum. */
- text[offset] = '\0';
- return text;
+static void
+tdesc_start_enum_value (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
+{
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ struct gdb_xml_value *attr;
+ char *field_name;
+ ULONGEST ul_value;
+ int value;
+
+ field_name = (char *) xml_find_attribute (attributes, "name")->value.get ();
+
+ attr = xml_find_attribute (attributes, "value");
+ ul_value = * (ULONGEST *) attr->value.get ();
+ if (ul_value > INT_MAX)
+ {
+ gdb_xml_error (parser,
+ _("Enum value %s is larger than maximum (%d)"),
+ pulongest (ul_value), INT_MAX);
+ }
+ value = ul_value;
+
+ tdesc_add_enum_value (data->current_type, value, field_name);
}
-/* Read an XML target description from FILENAME. Parse it, and return
- the parsed description. */
+/* Handle the start of a <vector> element. Initialize the type and
+ record it with the current feature. */
-const struct target_desc *
-file_read_description_xml (const char *filename)
+static void
+tdesc_start_vector (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, std::vector<gdb_xml_value> &attributes)
{
- struct target_desc *tdesc;
- char *tdesc_str;
- struct cleanup *back_to;
- const char *base;
- char *dirname;
+ struct tdesc_parsing_data *data = (struct tdesc_parsing_data *) user_data;
+ struct tdesc_type *field_type;
+ char *id, *field_type_id;
+ ULONGEST count;
+
+ id = (char *) attributes[0].value.get ();
+ field_type_id = (char *) attributes[1].value.get ();
+ count = * (ULONGEST *) attributes[2].value.get ();
- tdesc_str = fetch_xml_from_file (filename, NULL);
- if (tdesc_str == NULL)
+ if (count > MAX_VECTOR_SIZE)
{
- warning (_("Could not open \"%s\""), filename);
+ gdb_xml_error (parser,
+ _("Vector size %s is larger than maximum (%d)"),
+ pulongest (count), MAX_VECTOR_SIZE);
+ }
+
+ field_type = tdesc_named_type (data->current_feature, field_type_id);
+ if (field_type == NULL)
+ gdb_xml_error (parser, _("Vector \"%s\" references undefined type \"%s\""),
+ id, field_type_id);
+
+ tdesc_create_vector (data->current_feature, id, field_type, count);
+}
+
+/* The elements and attributes of an XML target description. */
+
+static const struct gdb_xml_attribute field_attributes[] = {
+ { "name", GDB_XML_AF_NONE, NULL, NULL },
+ { "type", GDB_XML_AF_OPTIONAL, NULL, NULL },
+ { "start", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { "end", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute enum_value_attributes[] = {
+ { "name", GDB_XML_AF_NONE, NULL, NULL },
+ { "value", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element struct_union_children[] = {
+ { "field", field_attributes, NULL, GDB_XML_EF_REPEATABLE,
+ tdesc_start_field, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element enum_children[] = {
+ { "evalue", enum_value_attributes, NULL, GDB_XML_EF_REPEATABLE,
+ tdesc_start_enum_value, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute reg_attributes[] = {
+ { "name", GDB_XML_AF_NONE, NULL, NULL },
+ { "bitsize", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "regnum", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { "type", GDB_XML_AF_OPTIONAL, NULL, NULL },
+ { "group", GDB_XML_AF_OPTIONAL, NULL, NULL },
+ { "save-restore", GDB_XML_AF_OPTIONAL,
+ gdb_xml_parse_attr_enum, gdb_xml_enums_boolean },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute struct_union_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL},
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute flags_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { "size", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL},
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute enum_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { "size", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL},
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute vector_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { "type", GDB_XML_AF_NONE, NULL, NULL },
+ { "count", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute feature_attributes[] = {
+ { "name", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element feature_children[] = {
+ { "reg", reg_attributes, NULL,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_reg, NULL },
+ { "struct", struct_union_attributes, struct_union_children,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_struct, NULL },
+ { "union", struct_union_attributes, struct_union_children,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_union, NULL },
+ { "flags", flags_attributes, struct_union_children,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_flags, NULL },
+ { "enum", enum_attributes, enum_children,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_enum, NULL },
+ { "vector", vector_attributes, NULL,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_vector, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute target_attributes[] = {
+ { "version", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element target_children[] = {
+ { "architecture", NULL, NULL, GDB_XML_EF_OPTIONAL,
+ NULL, tdesc_end_arch },
+ { "osabi", NULL, NULL, GDB_XML_EF_OPTIONAL,
+ NULL, tdesc_end_osabi },
+ { "compatible", NULL, NULL, GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ NULL, tdesc_end_compatible },
+ { "feature", feature_attributes, feature_children,
+ GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
+ tdesc_start_feature, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element tdesc_elements[] = {
+ { "target", target_attributes, target_children, GDB_XML_EF_NONE,
+ tdesc_start_target, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+/* Parse DOCUMENT into a target description and return it. */
+
+static struct target_desc *
+tdesc_parse_xml (const char *document, xml_fetch_another fetcher,
+ void *fetcher_baton)
+{
+ struct tdesc_parsing_data data;
+
+ /* Expand all XInclude directives. */
+ std::string expanded_text;
+
+ if (!xml_process_xincludes (expanded_text,
+ _("target description"),
+ document, fetcher, fetcher_baton, 0))
+ {
+ warning (_("Could not load XML target description; ignoring"));
return NULL;
}
- back_to = make_cleanup (xfree, tdesc_str);
+ /* Check for an exact match in the list of descriptions we have
+ previously parsed. */
+ const auto it = xml_cache.find (expanded_text);
+ if (it != xml_cache.end ())
+ return it->second.get ();
+
+ memset (&data, 0, sizeof (struct tdesc_parsing_data));
+ target_desc_up description (allocate_target_description ());
+ data.tdesc = description.get ();
- /* Simple, portable version of dirname that does not modify its
- argument. */
- base = lbasename (filename);
- while (base > filename && IS_DIR_SEPARATOR (base[-1]))
- --base;
- if (base > filename)
+ if (gdb_xml_parse_quick (_("target description"), "gdb-target.dtd",
+ tdesc_elements, expanded_text.c_str (), &data) == 0)
{
- dirname = xmalloc (base - filename + 2);
- memcpy (dirname, filename, base - filename);
-
- /* On DOS based file systems, convert "d:foo" to "d:.", so that
- we create "d:./bar" later instead of the (different)
- "d:/bar". */
- if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
- && !IS_DIR_SEPARATOR (filename[0]))
- dirname[base++ - filename] = '.';
-
- dirname[base - filename] = '\0';
- make_cleanup (xfree, dirname);
+ /* Parsed successfully. */
+ xml_cache.emplace (std::move (expanded_text), std::move (description));
+ return data.tdesc;
}
else
- dirname = NULL;
+ {
+ warning (_("Could not load XML target description; ignoring"));
+ return NULL;
+ }
+}
+#endif /* HAVE_LIBEXPAT */
+\f
- tdesc = tdesc_parse_xml (tdesc_str, fetch_xml_from_file, dirname);
- do_cleanups (back_to);
+/* Read an XML target description from FILENAME. Parse it, and return
+ the parsed description. */
+
+const struct target_desc *
+file_read_description_xml (const char *filename)
+{
+ gdb::optional<gdb::char_vector> tdesc_str
+ = xml_fetch_content_from_file (filename, NULL);
+ if (!tdesc_str)
+ {
+ warning (_("Could not open \"%s\""), filename);
+ return NULL;
+ }
- return tdesc;
+ return tdesc_parse_xml (tdesc_str->data (), xml_fetch_content_from_file,
+ (void *) ldirname (filename).c_str ());
}
/* Read a string representation of available features from the target,
is "target.xml". Other calls may be performed for the DTD or
for <xi:include>. */
-static char *
+static gdb::optional<gdb::char_vector>
fetch_available_features_from_target (const char *name, void *baton_)
{
- struct target_ops *ops = baton_;
+ struct target_ops *ops = (struct target_ops *) baton_;
/* Read this object as a string. This ensures that a NUL
terminator is added. */
const struct target_desc *
target_read_description_xml (struct target_ops *ops)
{
- struct target_desc *tdesc;
- char *tdesc_str;
- struct cleanup *back_to;
-
- tdesc_str = fetch_available_features_from_target ("target.xml", ops);
- if (tdesc_str == NULL)
+ gdb::optional<gdb::char_vector> tdesc_str
+ = fetch_available_features_from_target ("target.xml", ops);
+ if (!tdesc_str)
return NULL;
- back_to = make_cleanup (xfree, tdesc_str);
- tdesc = tdesc_parse_xml (tdesc_str,
- fetch_available_features_from_target,
- ops);
- do_cleanups (back_to);
+ return tdesc_parse_xml (tdesc_str->data (),
+ fetch_available_features_from_target,
+ ops);
+}
+
+/* Fetches an XML target description using OPS, processing
+ includes, but not parsing it. Used to dump whole tdesc
+ as a single XML file. */
+
+gdb::optional<std::string>
+target_fetch_description_xml (struct target_ops *ops)
+{
+#if !defined(HAVE_LIBEXPAT)
+ static int have_warned;
+
+ if (!have_warned)
+ {
+ have_warned = 1;
+ warning (_("Can not fetch XML target description; XML support was "
+ "disabled at compile time"));
+ }
+
+ return {};
+#else
+ gdb::optional<gdb::char_vector>
+ tdesc_str = fetch_available_features_from_target ("target.xml", ops);
+ if (!tdesc_str)
+ return {};
+
+ std::string output;
+ if (!xml_process_xincludes (output,
+ _("target description"),
+ tdesc_str->data (),
+ fetch_available_features_from_target, ops, 0))
+ {
+ warning (_("Could not load XML target description; ignoring"));
+ return {};
+ }
+ return output;
+#endif
+}
+
+/* See xml-tdesc.h. */
- return tdesc;
+const struct target_desc *
+string_read_description_xml (const char *xml)
+{
+ return tdesc_parse_xml (xml, [] (const char *href, void *baton)
+ {
+ error (_("xincludes are unsupported with this method"));
+ return gdb::optional<gdb::char_vector> ();
+ }, nullptr);
}
projects / deliverable / binutils-gdb.git / blobdiff