X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Faddrmap.c;h=8c357fbf7e5a44bcc84c97cb21bf30893dfc5ff7;hb=ef186fe54aa6d281a3ff8a9528417e5cc614c797;hp=0dce2bb77517a3c7db07844498355c83c1f999a8;hpb=4c38e0a4fcb69f8586d8db0b9cdb8dbab5980811;p=binutils-gdb.git

diff --git a/gdb/addrmap.c b/gdb/addrmap.c
index 0dce2bb7751..8c357fbf7e5 100644
--- a/gdb/addrmap.c
+++ b/gdb/addrmap.c
@@ -1,6 +1,6 @@
 /* addrmap.c --- implementation of address map data structure.
 
-   Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2007-2022 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -18,244 +18,127 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-
-#include <stdlib.h>
-
-#include "splay-tree.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
 #include "addrmap.h"
-#include "gdb_assert.h"
-
-
-
-/* The "abstract class".  */
-
-/* Functions implementing the addrmap functions for a particular
-   implementation.  */
-struct addrmap_funcs
-{
-  void (*set_empty) (struct addrmap *this,
-                     CORE_ADDR start, CORE_ADDR end_inclusive,
-                     void *obj);
-  void *(*find) (struct addrmap *this, CORE_ADDR addr);
-  struct addrmap *(*create_fixed) (struct addrmap *this,
-                                   struct obstack *obstack);
-  void (*relocate) (struct addrmap *this, CORE_ADDR offset);
-};
-
-
-struct addrmap
-{
-  const struct addrmap_funcs *funcs;
-};
-
-
-void
-addrmap_set_empty (struct addrmap *map,
-                   CORE_ADDR start, CORE_ADDR end_inclusive,
-                   void *obj)
-{
-  map->funcs->set_empty (map, start, end_inclusive, obj);
-}
-
-
-void *
-addrmap_find (struct addrmap *map, CORE_ADDR addr)
-{
-  return map->funcs->find (map, addr);
-}
-
-
-struct addrmap *
-addrmap_create_fixed (struct addrmap *original, struct obstack *obstack)
-{
-  return original->funcs->create_fixed (original, obstack);
-}
-
-
-/* Relocate all the addresses in MAP by OFFSET.  (This can be applied
-   to either mutable or immutable maps.)  */
-void
-addrmap_relocate (struct addrmap *map, CORE_ADDR offset)
-{
-  map->funcs->relocate (map, offset);
-}
+#include "gdbsupport/selftest.h"
 
+/* Make sure splay trees can actually hold the values we want to
+   store in them.  */
+gdb_static_assert (sizeof (splay_tree_key) >= sizeof (CORE_ADDR *));
+gdb_static_assert (sizeof (splay_tree_value) >= sizeof (void *));
 
 
 /* Fixed address maps.  */
 
-/* A transition: a point in an address map where the value changes.
-   The map maps ADDR to VALUE, but if ADDR > 0, it maps ADDR-1 to
-   something else.  */
-struct addrmap_transition
-{
-  CORE_ADDR addr;
-  void *value;
-};
-
-
-struct addrmap_fixed
-{
-  struct addrmap addrmap;
-
-  /* The number of transitions in TRANSITIONS.  */
-  size_t num_transitions;
-
-  /* An array of transitions, sorted by address.  For every point in
-     the map where either ADDR == 0 or ADDR is mapped to one value and
-     ADDR - 1 is mapped to something different, we have an entry here
-     containing ADDR and VALUE.  (Note that this means we always have
-     an entry for address 0).  */
-  struct addrmap_transition transitions[1];
-};
-
-
-static void
-addrmap_fixed_set_empty (struct addrmap *this,
-                   CORE_ADDR start, CORE_ADDR end_inclusive,
-                   void *obj)
+void
+addrmap_fixed::set_empty (CORE_ADDR start, CORE_ADDR end_inclusive,
+			  void *obj)
 {
   internal_error (__FILE__, __LINE__,
-                  "addrmap_fixed_set_empty: "
-                  "fixed addrmaps can't be changed\n");
+		  "addrmap_fixed_set_empty: "
+		  "fixed addrmaps can't be changed\n");
 }
 
 
-static void *
-addrmap_fixed_find (struct addrmap *this, CORE_ADDR addr)
+void *
+addrmap_fixed::find (CORE_ADDR addr) const
 {
-  struct addrmap_fixed *map = (struct addrmap_fixed *) this;
-  struct addrmap_transition *bottom = &map->transitions[0];
-  struct addrmap_transition *top = &map->transitions[map->num_transitions - 1];
+  const struct addrmap_transition *bottom = &transitions[0];
+  const struct addrmap_transition *top = &transitions[num_transitions - 1];
 
   while (bottom < top)
     {
       /* This needs to round towards top, or else when top = bottom +
-         1 (i.e., two entries are under consideration), then mid ==
-         bottom, and then we may not narrow the range when (mid->addr
-         < addr).  */
-      struct addrmap_transition *mid = top - (top - bottom) / 2;
+	 1 (i.e., two entries are under consideration), then mid ==
+	 bottom, and then we may not narrow the range when (mid->addr
+	 < addr).  */
+      const addrmap_transition *mid = top - (top - bottom) / 2;
 
       if (mid->addr == addr)
-        {
-          bottom = mid;
-          break;
-        }
+	{
+	  bottom = mid;
+	  break;
+	}
       else if (mid->addr < addr)
-        /* We don't eliminate mid itself here, since each transition
-           covers all subsequent addresses until the next.  This is why
-           we must round up in computing the midpoint.  */
-        bottom = mid;
+	/* We don't eliminate mid itself here, since each transition
+	   covers all subsequent addresses until the next.  This is why
+	   we must round up in computing the midpoint.  */
+	bottom = mid;
       else
-        top = mid - 1;
+	top = mid - 1;
     }
 
   return bottom->value;
 }
 
 
-static struct addrmap *
-addrmap_fixed_create_fixed (struct addrmap *this, struct obstack *obstack)
+void
+addrmap_fixed::relocate (CORE_ADDR offset)
 {
-  internal_error (__FILE__, __LINE__,
-                  _("addrmap_create_fixed is not implemented yet "
-                    "for fixed addrmaps"));
+  size_t i;
+
+  for (i = 0; i < num_transitions; i++)
+    transitions[i].addr += offset;
 }
 
 
-static void
-addrmap_fixed_relocate (struct addrmap *this, CORE_ADDR offset)
+int
+addrmap_fixed::foreach (addrmap_foreach_fn fn)
 {
-  struct addrmap_fixed *map = (struct addrmap_fixed *) this;
   size_t i;
 
-  for (i = 0; i < map->num_transitions; i++)
-    map->transitions[i].addr += offset;
-}
+  for (i = 0; i < num_transitions; i++)
+    {
+      int res = fn (transitions[i].addr, transitions[i].value);
 
+      if (res != 0)
+	return res;
+    }
 
-static const struct addrmap_funcs addrmap_fixed_funcs =
-{
-  addrmap_fixed_set_empty,
-  addrmap_fixed_find,
-  addrmap_fixed_create_fixed,
-  addrmap_fixed_relocate
-};
+  return 0;
+}
 
 
 
 /* Mutable address maps.  */
 
-struct addrmap_mutable
+/* Allocate a copy of CORE_ADDR.  */
+splay_tree_key
+addrmap_mutable::allocate_key (CORE_ADDR addr)
 {
-  struct addrmap addrmap;
-
-  /* The obstack to use for allocations for this map.  */
-  struct obstack *obstack;
-
-  /* A splay tree, with a node for each transition; there is a
-     transition at address T if T-1 and T map to different objects.
-
-     Any addresses below the first node map to NULL.  (Unlike
-     fixed maps, we have no entry at (CORE_ADDR) 0; it doesn't 
-     simplify enough.)
-
-     The last region is assumed to end at CORE_ADDR_MAX.
-
-     Since we can't know whether CORE_ADDR is larger or smaller than
-     splay_tree_key (unsigned long) --- I think both are possible,
-     given all combinations of 32- and 64-bit hosts and targets ---
-     our keys are pointers to CORE_ADDR values.  Since the splay tree
-     library doesn't pass any closure pointer to the key free
-     function, we can't keep a freelist for keys.  Since mutable
-     addrmaps are only used temporarily right now, we just leak keys
-     from deleted nodes; they'll be freed when the obstack is freed.  */
-  splay_tree tree;
-
-  /* A freelist for splay tree nodes, allocated on obstack, and
-     chained together by their 'right' pointers.  */
-  splay_tree_node free_nodes;
-};
-
+  CORE_ADDR *key = XNEW (CORE_ADDR);
 
-/* Allocate a copy of CORE_ADDR in MAP's obstack.  */
-static splay_tree_key
-allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
-{
-  CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
   *key = addr;
-
   return (splay_tree_key) key;
 }
 
 
 /* Type-correct wrappers for splay tree access.  */
-static splay_tree_node
-addrmap_splay_tree_lookup (struct addrmap_mutable *map, CORE_ADDR addr)
+splay_tree_node
+addrmap_mutable::splay_tree_lookup (CORE_ADDR addr) const
 {
-  return splay_tree_lookup (map->tree, (splay_tree_key) &addr);
+  return ::splay_tree_lookup (tree, (splay_tree_key) &addr);
 }
 
 
-static splay_tree_node
-addrmap_splay_tree_predecessor (struct addrmap_mutable *map, CORE_ADDR addr)
+splay_tree_node
+addrmap_mutable::splay_tree_predecessor (CORE_ADDR addr) const
 {
-  return splay_tree_predecessor (map->tree, (splay_tree_key) &addr);
+  return ::splay_tree_predecessor (tree, (splay_tree_key) &addr);
 }
 
 
-static splay_tree_node
-addrmap_splay_tree_successor (struct addrmap_mutable *map, CORE_ADDR addr)
+splay_tree_node
+addrmap_mutable::splay_tree_successor (CORE_ADDR addr)
 {
-  return splay_tree_successor (map->tree, (splay_tree_key) &addr);
+  return ::splay_tree_successor (tree, (splay_tree_key) &addr);
 }
 
 
-static void
-addrmap_splay_tree_remove (struct addrmap_mutable *map, CORE_ADDR addr)
+void
+addrmap_mutable::splay_tree_remove (CORE_ADDR addr)
 {
-  splay_tree_remove (map->tree, (splay_tree_key) &addr);
+  ::splay_tree_remove (tree, (splay_tree_key) &addr);
 }
 
 
@@ -280,39 +163,35 @@ addrmap_node_set_value (splay_tree_node node, void *value)
 }
 
 
-static void
-addrmap_splay_tree_insert (struct addrmap_mutable *map, CORE_ADDR key, void *value)
+void
+addrmap_mutable::splay_tree_insert (CORE_ADDR key, void *value)
 {
-  splay_tree_insert (map->tree,
-                     allocate_key (map, key),
-                     (splay_tree_value) value);
+  ::splay_tree_insert (tree,
+		       allocate_key (key),
+		       (splay_tree_value) value);
 }
 
 
 /* Without changing the mapping of any address, ensure that there is a
    tree node at ADDR, even if it would represent a "transition" from
    one value to the same value.  */
-static void
-force_transition (struct addrmap_mutable *this, CORE_ADDR addr)
+void
+addrmap_mutable::force_transition (CORE_ADDR addr)
 {
-  splay_tree_node n
-    = addrmap_splay_tree_lookup (this, addr);
+  splay_tree_node n = splay_tree_lookup (addr);
 
   if (! n)
     {
-      n = addrmap_splay_tree_predecessor (this, addr);
-      addrmap_splay_tree_insert (this, addr,
-                                 n ? addrmap_node_value (n) : NULL);
+      n = splay_tree_predecessor (addr);
+      splay_tree_insert (addr, n ? addrmap_node_value (n) : NULL);
     }
 }
 
 
-static void
-addrmap_mutable_set_empty (struct addrmap *this,
-                           CORE_ADDR start, CORE_ADDR end_inclusive,
-                           void *obj)
+void
+addrmap_mutable::set_empty (CORE_ADDR start, CORE_ADDR end_inclusive,
+			    void *obj)
 {
-  struct addrmap_mutable *map = (struct addrmap_mutable *) this;
   splay_tree_node n, next;
   void *prior_value;
 
@@ -329,163 +208,120 @@ addrmap_mutable_set_empty (struct addrmap *this,
      - Second pass: remove any unnecessary transitions.  */
 
   /* Establish transitions at the start and end.  */
-  force_transition (map, start);
+  force_transition (start);
   if (end_inclusive < CORE_ADDR_MAX)
-    force_transition (map, end_inclusive + 1);
+    force_transition (end_inclusive + 1);
 
   /* Walk the area, changing all NULL regions to OBJ.  */
-  for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
+  for (n = splay_tree_lookup (start), gdb_assert (n);
        n && addrmap_node_key (n) <= end_inclusive;
-       n = addrmap_splay_tree_successor (map, addrmap_node_key (n)))
+       n = splay_tree_successor (addrmap_node_key (n)))
     {
       if (! addrmap_node_value (n))
-        addrmap_node_set_value (n, obj);
+	addrmap_node_set_value (n, obj);
     }
 
   /* Walk the area again, removing transitions from any value to
      itself.  Be sure to visit both the transitions we forced
      above.  */
-  n = addrmap_splay_tree_predecessor (map, start);
+  n = splay_tree_predecessor (start);
   prior_value = n ? addrmap_node_value (n) : NULL;
-  for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
+  for (n = splay_tree_lookup (start), gdb_assert (n);
        n && (end_inclusive == CORE_ADDR_MAX
-             || addrmap_node_key (n) <= end_inclusive + 1);
+	     || addrmap_node_key (n) <= end_inclusive + 1);
        n = next)
     {
-      next = addrmap_splay_tree_successor (map, addrmap_node_key (n));
+      next = splay_tree_successor (addrmap_node_key (n));
       if (addrmap_node_value (n) == prior_value)
-        addrmap_splay_tree_remove (map, addrmap_node_key (n));
+	splay_tree_remove (addrmap_node_key (n));
       else
-        prior_value = addrmap_node_value (n);
+	prior_value = addrmap_node_value (n);
     }
 }
 
 
-static void *
-addrmap_mutable_find (struct addrmap *this, CORE_ADDR addr)
-{
-  /* Not needed yet.  */
-  internal_error (__FILE__, __LINE__,
-                  _("addrmap_find is not implemented yet "
-                    "for mutable addrmaps"));
-}
-
-
-/* A function to pass to splay_tree_foreach to count the number of nodes
-   in the tree.  */
-static int
-splay_foreach_count (splay_tree_node n, void *closure)
-{
-  size_t *count = (size_t *) closure;
-
-  (*count)++;
-  return 0;
-}
-
-
-/* A function to pass to splay_tree_foreach to copy entries into a
-   fixed address map.  */
-static int
-splay_foreach_copy (splay_tree_node n, void *closure)
+void *
+addrmap_mutable::find (CORE_ADDR addr) const
 {
-  struct addrmap_fixed *fixed = (struct addrmap_fixed *) closure;
-  struct addrmap_transition *t = &fixed->transitions[fixed->num_transitions];
+  splay_tree_node n = splay_tree_lookup (addr);
+  if (n != nullptr)
+    {
+      gdb_assert (addrmap_node_key (n) == addr);
+      return addrmap_node_value (n);
+    }
 
-  t->addr = addrmap_node_key (n);
-  t->value = addrmap_node_value (n);
-  fixed->num_transitions++;
+  n = splay_tree_predecessor (addr);
+  if (n != nullptr)
+    {
+      gdb_assert (addrmap_node_key (n) < addr);
+      return addrmap_node_value (n);
+    }
 
-  return 0;
+  return nullptr;
 }
 
 
-static struct addrmap *
-addrmap_mutable_create_fixed (struct addrmap *this, struct obstack *obstack)
+addrmap_fixed::addrmap_fixed (struct obstack *obstack, addrmap_mutable *mut)
 {
-  struct addrmap_mutable *mutable = (struct addrmap_mutable *) this;
-  struct addrmap_fixed *fixed;
-  size_t num_transitions;
+  size_t transition_count = 0;
 
   /* Count the number of transitions in the tree.  */
-  num_transitions = 0;
-  splay_tree_foreach (mutable->tree, splay_foreach_count, &num_transitions);
+  mut->foreach ([&] (CORE_ADDR start, void *obj)
+    {
+      ++transition_count;
+      return 0;
+    });
 
   /* Include an extra entry for the transition at zero (which fixed
      maps have, but mutable maps do not.)  */
-  num_transitions++;
+  transition_count++;
 
-  fixed = obstack_alloc (obstack,
-                         (sizeof (*fixed)
-                          + (num_transitions
-                             * sizeof (fixed->transitions[0]))));
-  fixed->addrmap.funcs = &addrmap_fixed_funcs;
-  fixed->num_transitions = 1;
-  fixed->transitions[0].addr = 0;
-  fixed->transitions[0].value = NULL;
+  num_transitions = 1;
+  transitions = XOBNEWVEC (obstack, struct addrmap_transition,
+			   transition_count);
+  transitions[0].addr = 0;
+  transitions[0].value = NULL;
 
   /* Copy all entries from the splay tree to the array, in order 
      of increasing address.  */
-  splay_tree_foreach (mutable->tree, splay_foreach_copy, fixed);
+  mut->foreach ([&] (CORE_ADDR start, void *obj)
+    {
+      transitions[num_transitions].addr = start;
+      transitions[num_transitions].value = obj;
+      ++num_transitions;
+      return 0;
+    });
 
   /* We should have filled the array.  */
-  gdb_assert (fixed->num_transitions == num_transitions);
-
-  return (struct addrmap *) fixed;
+  gdb_assert (num_transitions == transition_count);
 }
 
 
-static void
-addrmap_mutable_relocate (struct addrmap *this, CORE_ADDR offset)
+void
+addrmap_mutable::relocate (CORE_ADDR offset)
 {
   /* Not needed yet.  */
   internal_error (__FILE__, __LINE__,
-                  _("addrmap_relocate is not implemented yet "
-                    "for mutable addrmaps"));
+		  _("addrmap_relocate is not implemented yet "
+		    "for mutable addrmaps"));
 }
 
 
-static const struct addrmap_funcs addrmap_mutable_funcs =
-{
-  addrmap_mutable_set_empty,
-  addrmap_mutable_find,
-  addrmap_mutable_create_fixed,
-  addrmap_mutable_relocate
-};
-
+/* This is a splay_tree_foreach_fn.  */
 
-static void *
-splay_obstack_alloc (int size, void *closure)
+static int
+addrmap_mutable_foreach_worker (splay_tree_node node, void *data)
 {
-  struct addrmap_mutable *map = closure;
-  splay_tree_node n;
-
-  /* We should only be asked to allocate nodes and larger things.
-     (If, at some point in the future, this is no longer true, we can
-     just round up the size to sizeof (*n).)  */
-  gdb_assert (size >= sizeof (*n));
+  addrmap_foreach_fn *fn = (addrmap_foreach_fn *) data;
 
-  if (map->free_nodes)
-    {
-      n = map->free_nodes;
-      map->free_nodes = n->right;
-      return n;
-    }
-  else
-    return obstack_alloc (map->obstack, size);
+  return (*fn) (addrmap_node_key (node), addrmap_node_value (node));
 }
 
 
-static void
-splay_obstack_free (void *obj, void *closure)
+int
+addrmap_mutable::foreach (addrmap_foreach_fn fn)
 {
-  struct addrmap_mutable *map = closure;
-  splay_tree_node n = obj;
-
-  /* We've asserted in the allocation function that we only allocate
-     nodes or larger things, so it should be safe to put whatever
-     we get passed back on the free list.  */
-  n->right = map->free_nodes;
-  map->free_nodes = n;
+  return splay_tree_foreach (tree, addrmap_mutable_foreach_worker, &fn);
 }
 
 
@@ -506,41 +342,152 @@ splay_compare_CORE_ADDR_ptr (splay_tree_key ak, splay_tree_key bk)
 }
 
 
-struct addrmap *
-addrmap_create_mutable (struct obstack *obstack)
+static void
+xfree_wrapper (splay_tree_key key)
+{
+  xfree ((void *) key);
+}
+
+addrmap_mutable::addrmap_mutable ()
+  : tree (splay_tree_new (splay_compare_CORE_ADDR_ptr, xfree_wrapper,
+			  nullptr /* no delete value */))
+{
+}
+
+addrmap_mutable::~addrmap_mutable ()
+{
+  splay_tree_delete (tree);
+}
+
+
+/* See addrmap.h.  */
+
+void
+addrmap_dump (struct addrmap *map, struct ui_file *outfile, void *payload)
 {
-  struct addrmap_mutable *map = obstack_alloc (obstack, sizeof (*map));
+  /* True if the previously printed addrmap entry was for PAYLOAD.
+     If so, we want to print the next one as well (since the next
+     addrmap entry defines the end of the range).  */
+  bool previous_matched = false;
 
-  map->addrmap.funcs = &addrmap_mutable_funcs;
-  map->obstack = obstack;
+  auto callback = [&] (CORE_ADDR start_addr, void *obj)
+  {
+    QUIT;
 
-  /* splay_tree_new_with_allocator uses the provided allocation
-     function to allocate the main splay_tree structure itself, so our
-     free list has to be initialized before we create the tree.  */
-  map->free_nodes = NULL;
+    bool matches = payload == nullptr || payload == obj;
+    const char *addr_str = nullptr;
+    if (matches)
+      addr_str = host_address_to_string (obj);
+    else if (previous_matched)
+      addr_str = "<ends here>";
 
-  map->tree = splay_tree_new_with_allocator (splay_compare_CORE_ADDR_ptr,
-                                             NULL, /* no delete key */
-                                             NULL, /* no delete value */
-                                             splay_obstack_alloc,
-                                             splay_obstack_free,
-                                             map);
+    if (matches || previous_matched)
+      gdb_printf (outfile, "  %s%s %s\n",
+		  payload != nullptr ? "  " : "",
+		  core_addr_to_string (start_addr),
+		  addr_str);
 
-  return (struct addrmap *) map;
+    previous_matched = matches;
+
+    return 0;
+  };
+
+  map->foreach (callback);
 }
 
+#if GDB_SELF_TEST
+namespace selftests {
 
-
-/* Initialization.  */
+/* Convert P to CORE_ADDR.  */
+
+static CORE_ADDR
+core_addr (void *p)
+{
+  return (CORE_ADDR)(uintptr_t)p;
+}
+
+/* Check that &ARRAY[LOW]..&ARRAY[HIGH] has VAL in MAP.  */
+
+#define CHECK_ADDRMAP_FIND(MAP, ARRAY, LOW, HIGH, VAL)			\
+  do									\
+    {									\
+      for (unsigned i = LOW; i <= HIGH; ++i)				\
+	SELF_CHECK (MAP->find (core_addr (&ARRAY[i])) == VAL);		\
+    }									\
+  while (0)
+
+/* Entry point for addrmap unit tests.  */
+
+static void
+test_addrmap ()
+{
+  /* We'll verify using the addresses of the elements of this array.  */
+  char array[20];
+
+  /* We'll verify using these values stored into the map.  */
+  void *val1 = &array[1];
+  void *val2 = &array[2];
+
+  /* Create mutable addrmap.  */
+  auto_obstack temp_obstack;
+  std::unique_ptr<struct addrmap_mutable> map (new addrmap_mutable);
+  SELF_CHECK (map != nullptr);
+
+  /* Check initial state.  */
+  CHECK_ADDRMAP_FIND (map, array, 0, 19, nullptr);
+
+  /* Insert address range into mutable addrmap.  */
+  map->set_empty (core_addr (&array[10]), core_addr (&array[12]), val1);
+  CHECK_ADDRMAP_FIND (map, array, 0, 9, nullptr);
+  CHECK_ADDRMAP_FIND (map, array, 10, 12, val1);
+  CHECK_ADDRMAP_FIND (map, array, 13, 19, nullptr);
+
+  /* Create corresponding fixed addrmap.  */
+  struct addrmap *map2
+    = new (&temp_obstack) addrmap_fixed (&temp_obstack, map.get ());
+  SELF_CHECK (map2 != nullptr);
+  CHECK_ADDRMAP_FIND (map2, array, 0, 9, nullptr);
+  CHECK_ADDRMAP_FIND (map2, array, 10, 12, val1);
+  CHECK_ADDRMAP_FIND (map2, array, 13, 19, nullptr);
+
+  /* Iterate over both addrmaps.  */
+  auto callback = [&] (CORE_ADDR start_addr, void *obj)
+    {
+      if (start_addr == core_addr (nullptr))
+	SELF_CHECK (obj == nullptr);
+      else if (start_addr == core_addr (&array[10]))
+	SELF_CHECK (obj == val1);
+      else if (start_addr == core_addr (&array[13]))
+	SELF_CHECK (obj == nullptr);
+      else
+	SELF_CHECK (false);
+      return 0;
+    };
+  SELF_CHECK (map->foreach (callback) == 0);
+  SELF_CHECK (map2->foreach (callback) == 0);
+
+  /* Relocate fixed addrmap.  */
+  map2->relocate (1);
+  CHECK_ADDRMAP_FIND (map2, array, 0, 10, nullptr);
+  CHECK_ADDRMAP_FIND (map2, array, 11, 13, val1);
+  CHECK_ADDRMAP_FIND (map2, array, 14, 19, nullptr);
+
+  /* Insert partially overlapping address range into mutable addrmap.  */
+  map->set_empty (core_addr (&array[11]), core_addr (&array[13]), val2);
+  CHECK_ADDRMAP_FIND (map, array, 0, 9, nullptr);
+  CHECK_ADDRMAP_FIND (map, array, 10, 12, val1);
+  CHECK_ADDRMAP_FIND (map, array, 13, 13, val2);
+  CHECK_ADDRMAP_FIND (map, array, 14, 19, nullptr);
+}
 
-/* Provide a prototype to silence -Wmissing-prototypes.  */
-extern initialize_file_ftype _initialize_addrmap;
+} // namespace selftests
+#endif /* GDB_SELF_TEST */
 
+void _initialize_addrmap ();
 void
-_initialize_addrmap (void)
+_initialize_addrmap ()
 {
-  /* Make sure splay trees can actually hold the values we want to 
-     store in them.  */
-  gdb_assert (sizeof (splay_tree_key) >= sizeof (CORE_ADDR *));
-  gdb_assert (sizeof (splay_tree_value) >= sizeof (void *));
+#if GDB_SELF_TEST
+  selftests::register_test ("addrmap", selftests::test_addrmap);
+#endif /* GDB_SELF_TEST */
 }