/* addrmap.c --- implementation of address map data structure.
- Copyright (C) 2007-2015 Free Software Foundation, Inc.
+ Copyright (C) 2007-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_obstack.h"
#include "addrmap.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 *));
+
\f
/* The "abstract class". */
struct addrmap_funcs
{
void (*set_empty) (struct addrmap *self,
- CORE_ADDR start, CORE_ADDR end_inclusive,
- void *obj);
+ CORE_ADDR start, CORE_ADDR end_inclusive,
+ void *obj);
void *(*find) (struct addrmap *self, CORE_ADDR addr);
struct addrmap *(*create_fixed) (struct addrmap *self,
- struct obstack *obstack);
+ struct obstack *obstack);
void (*relocate) (struct addrmap *self, CORE_ADDR offset);
- int (*foreach) (struct addrmap *self, addrmap_foreach_fn fn, void *data);
+ int (*foreach) (struct addrmap *self, addrmap_foreach_fn fn);
};
void
addrmap_set_empty (struct addrmap *map,
- CORE_ADDR start, CORE_ADDR end_inclusive,
- void *obj)
+ CORE_ADDR start, CORE_ADDR end_inclusive,
+ void *obj)
{
map->funcs->set_empty (map, start, end_inclusive, obj);
}
int
-addrmap_foreach (struct addrmap *map, addrmap_foreach_fn fn, void *data)
+addrmap_foreach (struct addrmap *map, addrmap_foreach_fn fn)
{
- return map->funcs->foreach (map, fn, data);
+ return map->funcs->foreach (map, fn);
}
\f
/* Fixed address maps. */
static void
addrmap_fixed_set_empty (struct addrmap *self,
- CORE_ADDR start, CORE_ADDR end_inclusive,
- void *obj)
+ 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");
}
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). */
+ 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;
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;
addrmap_fixed_create_fixed (struct addrmap *self, struct obstack *obstack)
{
internal_error (__FILE__, __LINE__,
- _("addrmap_create_fixed is not implemented yet "
- "for fixed addrmaps"));
+ _("addrmap_create_fixed is not implemented yet "
+ "for fixed addrmaps"));
}
static int
-addrmap_fixed_foreach (struct addrmap *self, addrmap_foreach_fn fn,
- void *data)
+addrmap_fixed_foreach (struct addrmap *self, addrmap_foreach_fn fn)
{
struct addrmap_fixed *map = (struct addrmap_fixed *) self;
size_t i;
for (i = 0; i < map->num_transitions; i++)
{
- int res = fn (data, map->transitions[i].addr, map->transitions[i].value);
+ int res = fn (map->transitions[i].addr, map->transitions[i].value);
if (res != 0)
return res;
CORE_ADDR key, void *value)
{
splay_tree_insert (map->tree,
- allocate_key (map, key),
- (splay_tree_value) value);
+ allocate_key (map, key),
+ (splay_tree_value) value);
}
{
n = addrmap_splay_tree_predecessor (self, addr);
addrmap_splay_tree_insert (self, addr,
- n ? addrmap_node_value (n) : NULL);
+ n ? addrmap_node_value (n) : NULL);
}
}
static void
addrmap_mutable_set_empty (struct addrmap *self,
- CORE_ADDR start, CORE_ADDR end_inclusive,
- void *obj)
+ CORE_ADDR start, CORE_ADDR end_inclusive,
+ void *obj)
{
struct addrmap_mutable *map = (struct addrmap_mutable *) self;
splay_tree_node n, next;
n = addrmap_splay_tree_successor (map, 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
prior_value = n ? addrmap_node_value (n) : NULL;
for (n = addrmap_splay_tree_lookup (map, 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));
if (addrmap_node_value (n) == prior_value)
- addrmap_splay_tree_remove (map, addrmap_node_key (n));
+ addrmap_splay_tree_remove (map, addrmap_node_key (n));
else
- prior_value = addrmap_node_value (n);
+ prior_value = addrmap_node_value (n);
}
}
{
/* Not needed yet. */
internal_error (__FILE__, __LINE__,
- _("addrmap_find is not implemented yet "
- "for mutable addrmaps"));
+ _("addrmap_find is not implemented yet "
+ "for mutable addrmaps"));
}
{
/* 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"));
}
-/* Struct to map addrmap's foreach function to splay_tree's version. */
-struct mutable_foreach_data
-{
- addrmap_foreach_fn fn;
- void *data;
-};
-
-
/* This is a splay_tree_foreach_fn. */
static int
addrmap_mutable_foreach_worker (splay_tree_node node, void *data)
{
- struct mutable_foreach_data *foreach_data = data;
+ addrmap_foreach_fn *fn = (addrmap_foreach_fn *) data;
- return foreach_data->fn (foreach_data->data,
- addrmap_node_key (node),
- addrmap_node_value (node));
+ return (*fn) (addrmap_node_key (node), addrmap_node_value (node));
}
static int
-addrmap_mutable_foreach (struct addrmap *self, addrmap_foreach_fn fn,
- void *data)
+addrmap_mutable_foreach (struct addrmap *self, addrmap_foreach_fn fn)
{
struct addrmap_mutable *mutable_obj = (struct addrmap_mutable *) self;
- struct mutable_foreach_data foreach_data;
- foreach_data.fn = fn;
- foreach_data.data = data;
return splay_tree_foreach (mutable_obj->tree, addrmap_mutable_foreach_worker,
- &foreach_data);
+ &fn);
}
static void *
splay_obstack_alloc (int size, void *closure)
{
- struct addrmap_mutable *map = closure;
+ struct addrmap_mutable *map = (struct addrmap_mutable *) closure;
splay_tree_node n;
/* We should only be asked to allocate nodes and larger things.
static void
splay_obstack_free (void *obj, void *closure)
{
- struct addrmap_mutable *map = closure;
- splay_tree_node n = obj;
+ struct addrmap_mutable *map = (struct addrmap_mutable *) closure;
+ splay_tree_node n = (splay_tree_node) obj;
/* We've asserted in the allocation function that we only allocate
nodes or larger things, so it should be safe to put whatever
map->free_nodes = NULL;
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);
+ NULL, /* no delete key */
+ NULL, /* no delete value */
+ splay_obstack_alloc,
+ splay_obstack_free,
+ map);
return (struct addrmap *) map;
}
-
-
-\f
-/* Initialization. */
-
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_addrmap;
-
-void
-_initialize_addrmap (void)
-{
- /* 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 *));
-}
projects / deliverable / binutils-gdb.git / blobdiff