gdb/memory-map.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Routines for handling XML memory maps provided by target.

  3.    Copyright (C) 2006-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "defs.h"
  21. #include "memory-map.h"

  23. #if !defined(HAVE_LIBEXPAT)

  25. ‌VEC(mem_region_s) *
  26. parse_memory_map (const char *memory_map)
  27. {
  28.   static int have_warned;

  30.   if (!have_warned)
  31.     {
  32.       have_warned = 1;
  33.       warning (_("Can not parse XML memory map; XML support was disabled "
  34.                  "at compile time"));
  35.     }

  37.   return NULL;
  38. }

  40. #else /* HAVE_LIBEXPAT */

  42. #include "xml-support.h"

  44. /* Internal parsing data passed to all XML callbacks.  */
  45. ‌struct memory_map_parsing_data
  46.   {
  47.     VEC(mem_region_s) **memory_map;
  48.     char property_name[32];
  49.   };

  51. /* Handle the start of a <memory> element.  */

  53. static void
  54. ‌memory_map_start_memory (struct gdb_xml_parser *parser,
  55.                          const struct gdb_xml_element *element,
  56.                          void *user_data, VEC(gdb_xml_value_s) *attributes)
  57. {
  58.   struct memory_map_parsing_data *data = user_data;
  59.   struct mem_region *r = VEC_safe_push (mem_region_s, *data->memory_map, NULL);
  60.   ULONGEST *start_p, *length_p, *type_p;

  62.   start_p = xml_find_attribute (attributes, "start")->value;
  63.   length_p = xml_find_attribute (attributes, "length")->value;
  64.   type_p = xml_find_attribute (attributes, "type")->value;

  66.   mem_region_init (r);
  67.   r->lo = *start_p;
  68.   r->hi = r->lo + *length_p;
  69.   r->attrib.mode = *type_p;
  70.   r->attrib.blocksize = -1;
  71. }

  73. /* Handle the end of a <memory> element.  Verify that any necessary
  74.    children were present.  */

  76. static void
  77. ‌memory_map_end_memory (struct gdb_xml_parser *parser,
  78.                        const struct gdb_xml_element *element,
  79.                        void *user_data, const char *body_text)
  80. {
  81.   struct memory_map_parsing_data *data = user_data;
  82.   struct mem_region *r = VEC_last (mem_region_s, *data->memory_map);

  84.   if (r->attrib.mode == MEM_FLASH && r->attrib.blocksize == -1)
  85.     gdb_xml_error (parser, _("Flash block size is not set"));
  86. }

  88. /* Handle the start of a <property> element by saving the name
  89.    attribute for later.  */

  91. static void
  92. ‌memory_map_start_property (struct gdb_xml_parser *parser,
  93.                            const struct gdb_xml_element *element,
  94.                            void *user_data, VEC(gdb_xml_value_s) *attributes)
  95. {
  96.   struct memory_map_parsing_data *data = user_data;
  97.   char *name;

  99.   name = xml_find_attribute (attributes, "name")->value;
  100.   snprintf (data->property_name, sizeof (data->property_name), "%s", name);
  101. }

  103. /* Handle the end of a <property> element and its value.  */

  105. static void
  106. ‌memory_map_end_property (struct gdb_xml_parser *parser,
  107.                          const struct gdb_xml_element *element,
  108.                          void *user_data, const char *body_text)
  109. {
  110.   struct memory_map_parsing_data *data = user_data;
  111.   char *name = data->property_name;

  113.   if (strcmp (name, "blocksize") == 0)
  114.     {
  115.       struct mem_region *r = VEC_last (mem_region_s, *data->memory_map);

  117.       r->attrib.blocksize = gdb_xml_parse_ulongest (parser, body_text);
  118.     }
  119.   else
  120.     gdb_xml_debug (parser, _("Unknown property \"%s\""), name);
  121. }

  123. /* Discard the constructed memory map (if an error occurs).  */

  125. static void
  126. ‌clear_result (void *p)
  127. {
  128.   VEC(mem_region_s) **result = p;
  129.   VEC_free (mem_region_s, *result);
  130.   *result = NULL;
  131. }

  133. /* The allowed elements and attributes for an XML memory map.  */

  135. ‌const struct gdb_xml_attribute property_attributes[] = {
  136.   { "name", GDB_XML_AF_NONE, NULL, NULL },
  137.   { NULL, GDB_XML_AF_NONE, NULL, NULL }
  138. };

  140. ‌const struct gdb_xml_element memory_children[] = {
  141.   { "property", property_attributes, NULL,
  142.     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
  143.     memory_map_start_property, memory_map_end_property },
  144.   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
  145. };

  147. ‌const struct gdb_xml_enum memory_type_enum[] = {
  148.   { "ram", MEM_RW },
  149.   { "rom", MEM_RO },
  150.   { "flash", MEM_FLASH },
  151.   { NULL, 0 }
  152. };

  154. ‌const struct gdb_xml_attribute memory_attributes[] = {
  155.   { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  156.   { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  157.   { "type", GDB_XML_AF_NONE, gdb_xml_parse_attr_enum, &memory_type_enum },
  158.   { NULL, GDB_XML_AF_NONE, NULL, NULL }
  159. };

  161. ‌const struct gdb_xml_element memory_map_children[] = {
  162.   { "memory", memory_attributes, memory_children, GDB_XML_EF_REPEATABLE,
  163.     memory_map_start_memory, memory_map_end_memory },
  164.   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
  165. };

  167. ‌const struct gdb_xml_element memory_map_elements[] = {
  168.   { "memory-map", NULL, memory_map_children, GDB_XML_EF_NONE,
  169.     NULL, NULL },
  170.   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
  171. };

  173. ‌VEC(mem_region_s) *
  174. parse_memory_map (const char *memory_map)
  175. {
  176.   VEC(mem_region_s) *result = NULL;
  177.   struct cleanup *back_to;
  178.   struct memory_map_parsing_data data = { NULL };

  180.   data.memory_map = &result;
  181.   back_to = make_cleanup (clear_result, &result);
  182.   if (gdb_xml_parse_quick (_("target memory map"), NULL, memory_map_elements,
  183.                            memory_map, &data) == 0)
  184.     {
  185.       /* Parsed successfully, keep the result.  */
  186.       discard_cleanups (back_to);
  187.       return result;
  188.     }

  190.   do_cleanups (back_to);
  191.   return NULL;
  192. }

  194. #endif /* HAVE_LIBEXPAT */