/* addrmap.c --- implementation of address map data structure.
|
/* addrmap.c --- implementation of address map data structure.
|
|
|
Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
|
|
#include "splay-tree.h"
|
#include "splay-tree.h"
|
#include "gdb_obstack.h"
|
#include "gdb_obstack.h"
|
#include "addrmap.h"
|
#include "addrmap.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
|
|
|
|
|
|
/* The "abstract class". */
|
/* The "abstract class". */
|
|
|
/* Functions implementing the addrmap functions for a particular
|
/* Functions implementing the addrmap functions for a particular
|
implementation. */
|
implementation. */
|
struct addrmap_funcs
|
struct addrmap_funcs
|
{
|
{
|
void (*set_empty) (struct addrmap *this,
|
void (*set_empty) (struct addrmap *this,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
void *obj);
|
void *obj);
|
void *(*find) (struct addrmap *this, CORE_ADDR addr);
|
void *(*find) (struct addrmap *this, CORE_ADDR addr);
|
struct addrmap *(*create_fixed) (struct addrmap *this,
|
struct addrmap *(*create_fixed) (struct addrmap *this,
|
struct obstack *obstack);
|
struct obstack *obstack);
|
void (*relocate) (struct addrmap *this, CORE_ADDR offset);
|
void (*relocate) (struct addrmap *this, CORE_ADDR offset);
|
};
|
};
|
|
|
|
|
struct addrmap
|
struct addrmap
|
{
|
{
|
const struct addrmap_funcs *funcs;
|
const struct addrmap_funcs *funcs;
|
};
|
};
|
|
|
|
|
void
|
void
|
addrmap_set_empty (struct addrmap *map,
|
addrmap_set_empty (struct addrmap *map,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
void *obj)
|
void *obj)
|
{
|
{
|
map->funcs->set_empty (map, start, end_inclusive, obj);
|
map->funcs->set_empty (map, start, end_inclusive, obj);
|
}
|
}
|
|
|
|
|
void *
|
void *
|
addrmap_find (struct addrmap *map, CORE_ADDR addr)
|
addrmap_find (struct addrmap *map, CORE_ADDR addr)
|
{
|
{
|
return map->funcs->find (map, addr);
|
return map->funcs->find (map, addr);
|
}
|
}
|
|
|
|
|
struct addrmap *
|
struct addrmap *
|
addrmap_create_fixed (struct addrmap *original, struct obstack *obstack)
|
addrmap_create_fixed (struct addrmap *original, struct obstack *obstack)
|
{
|
{
|
return original->funcs->create_fixed (original, obstack);
|
return original->funcs->create_fixed (original, obstack);
|
}
|
}
|
|
|
|
|
/* Relocate all the addresses in MAP by OFFSET. (This can be applied
|
/* Relocate all the addresses in MAP by OFFSET. (This can be applied
|
to either mutable or immutable maps.) */
|
to either mutable or immutable maps.) */
|
void
|
void
|
addrmap_relocate (struct addrmap *map, CORE_ADDR offset)
|
addrmap_relocate (struct addrmap *map, CORE_ADDR offset)
|
{
|
{
|
map->funcs->relocate (map, offset);
|
map->funcs->relocate (map, offset);
|
}
|
}
|
|
|
|
|
|
|
/* Fixed address maps. */
|
/* Fixed address maps. */
|
|
|
/* A transition: a point in an address map where the value changes.
|
/* 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
|
The map maps ADDR to VALUE, but if ADDR > 0, it maps ADDR-1 to
|
something else. */
|
something else. */
|
struct addrmap_transition
|
struct addrmap_transition
|
{
|
{
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
void *value;
|
void *value;
|
};
|
};
|
|
|
|
|
struct addrmap_fixed
|
struct addrmap_fixed
|
{
|
{
|
struct addrmap addrmap;
|
struct addrmap addrmap;
|
|
|
/* The number of transitions in TRANSITIONS. */
|
/* The number of transitions in TRANSITIONS. */
|
size_t num_transitions;
|
size_t num_transitions;
|
|
|
/* An array of transitions, sorted by address. For every point in
|
/* 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
|
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
|
ADDR - 1 is mapped to something different, we have an entry here
|
containing ADDR and VALUE. (Note that this means we always have
|
containing ADDR and VALUE. (Note that this means we always have
|
an entry for address 0). */
|
an entry for address 0). */
|
struct addrmap_transition transitions[1];
|
struct addrmap_transition transitions[1];
|
};
|
};
|
|
|
|
|
static void
|
static void
|
addrmap_fixed_set_empty (struct addrmap *this,
|
addrmap_fixed_set_empty (struct addrmap *this,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
void *obj)
|
void *obj)
|
{
|
{
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
"addrmap_fixed_set_empty: "
|
"addrmap_fixed_set_empty: "
|
"fixed addrmaps can't be changed\n");
|
"fixed addrmaps can't be changed\n");
|
}
|
}
|
|
|
|
|
static void *
|
static void *
|
addrmap_fixed_find (struct addrmap *this, CORE_ADDR addr)
|
addrmap_fixed_find (struct addrmap *this, CORE_ADDR addr)
|
{
|
{
|
struct addrmap_fixed *map = (struct addrmap_fixed *) this;
|
struct addrmap_fixed *map = (struct addrmap_fixed *) this;
|
struct addrmap_transition *bottom = &map->transitions[0];
|
struct addrmap_transition *bottom = &map->transitions[0];
|
struct addrmap_transition *top = &map->transitions[map->num_transitions - 1];
|
struct addrmap_transition *top = &map->transitions[map->num_transitions - 1];
|
|
|
while (bottom < top)
|
while (bottom < top)
|
{
|
{
|
/* This needs to round towards top, or else when top = bottom +
|
/* This needs to round towards top, or else when top = bottom +
|
1 (i.e., two entries are under consideration), then mid ==
|
1 (i.e., two entries are under consideration), then mid ==
|
bottom, and then we may not narrow the range when (mid->addr
|
bottom, and then we may not narrow the range when (mid->addr
|
< addr). */
|
< addr). */
|
struct addrmap_transition *mid = top - (top - bottom) / 2;
|
struct addrmap_transition *mid = top - (top - bottom) / 2;
|
|
|
if (mid->addr == addr)
|
if (mid->addr == addr)
|
{
|
{
|
bottom = mid;
|
bottom = mid;
|
break;
|
break;
|
}
|
}
|
else if (mid->addr < addr)
|
else if (mid->addr < addr)
|
/* We don't eliminate mid itself here, since each transition
|
/* We don't eliminate mid itself here, since each transition
|
covers all subsequent addresses until the next. This is why
|
covers all subsequent addresses until the next. This is why
|
we must round up in computing the midpoint. */
|
we must round up in computing the midpoint. */
|
bottom = mid;
|
bottom = mid;
|
else
|
else
|
top = mid - 1;
|
top = mid - 1;
|
}
|
}
|
|
|
return bottom->value;
|
return bottom->value;
|
}
|
}
|
|
|
|
|
static struct addrmap *
|
static struct addrmap *
|
addrmap_fixed_create_fixed (struct addrmap *this, struct obstack *obstack)
|
addrmap_fixed_create_fixed (struct addrmap *this, struct obstack *obstack)
|
{
|
{
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("addrmap_create_fixed is not implemented yet "
|
_("addrmap_create_fixed is not implemented yet "
|
"for fixed addrmaps"));
|
"for fixed addrmaps"));
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_fixed_relocate (struct addrmap *this, CORE_ADDR offset)
|
addrmap_fixed_relocate (struct addrmap *this, CORE_ADDR offset)
|
{
|
{
|
struct addrmap_fixed *map = (struct addrmap_fixed *) this;
|
struct addrmap_fixed *map = (struct addrmap_fixed *) this;
|
size_t i;
|
size_t i;
|
|
|
for (i = 0; i < map->num_transitions; i++)
|
for (i = 0; i < map->num_transitions; i++)
|
map->transitions[i].addr += offset;
|
map->transitions[i].addr += offset;
|
}
|
}
|
|
|
|
|
static const struct addrmap_funcs addrmap_fixed_funcs =
|
static const struct addrmap_funcs addrmap_fixed_funcs =
|
{
|
{
|
addrmap_fixed_set_empty,
|
addrmap_fixed_set_empty,
|
addrmap_fixed_find,
|
addrmap_fixed_find,
|
addrmap_fixed_create_fixed,
|
addrmap_fixed_create_fixed,
|
addrmap_fixed_relocate
|
addrmap_fixed_relocate
|
};
|
};
|
|
|
|
|
|
|
/* Mutable address maps. */
|
/* Mutable address maps. */
|
|
|
struct addrmap_mutable
|
struct addrmap_mutable
|
{
|
{
|
struct addrmap addrmap;
|
struct addrmap addrmap;
|
|
|
/* The obstack to use for allocations for this map. */
|
/* The obstack to use for allocations for this map. */
|
struct obstack *obstack;
|
struct obstack *obstack;
|
|
|
/* A splay tree, with a node for each transition; there is a
|
/* 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.
|
transition at address T if T-1 and T map to different objects.
|
|
|
Any addresses below the first node map to NULL. (Unlike
|
Any addresses below the first node map to NULL. (Unlike
|
fixed maps, we have no entry at (CORE_ADDR) 0; it doesn't
|
fixed maps, we have no entry at (CORE_ADDR) 0; it doesn't
|
simplify enough.)
|
simplify enough.)
|
|
|
The last region is assumed to end at CORE_ADDR_MAX.
|
The last region is assumed to end at CORE_ADDR_MAX.
|
|
|
Since we can't know whether CORE_ADDR is larger or smaller than
|
Since we can't know whether CORE_ADDR is larger or smaller than
|
splay_tree_key (unsigned long) --- I think both are possible,
|
splay_tree_key (unsigned long) --- I think both are possible,
|
given all combinations of 32- and 64-bit hosts and targets ---
|
given all combinations of 32- and 64-bit hosts and targets ---
|
our keys are pointers to CORE_ADDR values. Since the splay tree
|
our keys are pointers to CORE_ADDR values. Since the splay tree
|
library doesn't pass any closure pointer to the key free
|
library doesn't pass any closure pointer to the key free
|
function, we can't keep a freelist for keys. Since mutable
|
function, we can't keep a freelist for keys. Since mutable
|
addrmaps are only used temporarily right now, we just leak keys
|
addrmaps are only used temporarily right now, we just leak keys
|
from deleted nodes; they'll be freed when the obstack is freed. */
|
from deleted nodes; they'll be freed when the obstack is freed. */
|
splay_tree tree;
|
splay_tree tree;
|
|
|
/* A freelist for splay tree nodes, allocated on obstack, and
|
/* A freelist for splay tree nodes, allocated on obstack, and
|
chained together by their 'right' pointers. */
|
chained together by their 'right' pointers. */
|
splay_tree_node free_nodes;
|
splay_tree_node free_nodes;
|
};
|
};
|
|
|
|
|
/* Allocate a copy of CORE_ADDR in MAP's obstack. */
|
/* Allocate a copy of CORE_ADDR in MAP's obstack. */
|
static splay_tree_key
|
static splay_tree_key
|
allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
|
allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
|
{
|
{
|
CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
|
CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
|
*key = addr;
|
*key = addr;
|
|
|
return (splay_tree_key) key;
|
return (splay_tree_key) key;
|
}
|
}
|
|
|
|
|
/* Type-correct wrappers for splay tree access. */
|
/* Type-correct wrappers for splay tree access. */
|
static splay_tree_node
|
static splay_tree_node
|
addrmap_splay_tree_lookup (struct addrmap_mutable *map, CORE_ADDR addr)
|
addrmap_splay_tree_lookup (struct addrmap_mutable *map, CORE_ADDR addr)
|
{
|
{
|
return splay_tree_lookup (map->tree, (splay_tree_key) &addr);
|
return splay_tree_lookup (map->tree, (splay_tree_key) &addr);
|
}
|
}
|
|
|
|
|
static splay_tree_node
|
static splay_tree_node
|
addrmap_splay_tree_predecessor (struct addrmap_mutable *map, CORE_ADDR addr)
|
addrmap_splay_tree_predecessor (struct addrmap_mutable *map, CORE_ADDR addr)
|
{
|
{
|
return splay_tree_predecessor (map->tree, (splay_tree_key) &addr);
|
return splay_tree_predecessor (map->tree, (splay_tree_key) &addr);
|
}
|
}
|
|
|
|
|
static splay_tree_node
|
static splay_tree_node
|
addrmap_splay_tree_successor (struct addrmap_mutable *map, CORE_ADDR addr)
|
addrmap_splay_tree_successor (struct addrmap_mutable *map, CORE_ADDR addr)
|
{
|
{
|
return splay_tree_successor (map->tree, (splay_tree_key) &addr);
|
return splay_tree_successor (map->tree, (splay_tree_key) &addr);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_splay_tree_remove (struct addrmap_mutable *map, CORE_ADDR addr)
|
addrmap_splay_tree_remove (struct addrmap_mutable *map, CORE_ADDR addr)
|
{
|
{
|
splay_tree_remove (map->tree, (splay_tree_key) &addr);
|
splay_tree_remove (map->tree, (splay_tree_key) &addr);
|
}
|
}
|
|
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
addrmap_node_key (splay_tree_node node)
|
addrmap_node_key (splay_tree_node node)
|
{
|
{
|
return * (CORE_ADDR *) node->key;
|
return * (CORE_ADDR *) node->key;
|
}
|
}
|
|
|
|
|
static void *
|
static void *
|
addrmap_node_value (splay_tree_node node)
|
addrmap_node_value (splay_tree_node node)
|
{
|
{
|
return (void *) node->value;
|
return (void *) node->value;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_node_set_value (splay_tree_node node, void *value)
|
addrmap_node_set_value (splay_tree_node node, void *value)
|
{
|
{
|
node->value = (splay_tree_value) value;
|
node->value = (splay_tree_value) value;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_splay_tree_insert (struct addrmap_mutable *map, CORE_ADDR key, void *value)
|
addrmap_splay_tree_insert (struct addrmap_mutable *map, CORE_ADDR key, void *value)
|
{
|
{
|
splay_tree_insert (map->tree,
|
splay_tree_insert (map->tree,
|
allocate_key (map, key),
|
allocate_key (map, key),
|
(splay_tree_value) value);
|
(splay_tree_value) value);
|
}
|
}
|
|
|
|
|
/* Without changing the mapping of any address, ensure that there is a
|
/* Without changing the mapping of any address, ensure that there is a
|
tree node at ADDR, even if it would represent a "transition" from
|
tree node at ADDR, even if it would represent a "transition" from
|
one value to the same value. */
|
one value to the same value. */
|
static void
|
static void
|
force_transition (struct addrmap_mutable *this, CORE_ADDR addr)
|
force_transition (struct addrmap_mutable *this, CORE_ADDR addr)
|
{
|
{
|
splay_tree_node n
|
splay_tree_node n
|
= addrmap_splay_tree_lookup (this, addr);
|
= addrmap_splay_tree_lookup (this, addr);
|
|
|
if (! n)
|
if (! n)
|
{
|
{
|
n = addrmap_splay_tree_predecessor (this, addr);
|
n = addrmap_splay_tree_predecessor (this, addr);
|
addrmap_splay_tree_insert (this, addr,
|
addrmap_splay_tree_insert (this, addr,
|
n ? addrmap_node_value (n) : NULL);
|
n ? addrmap_node_value (n) : NULL);
|
}
|
}
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_mutable_set_empty (struct addrmap *this,
|
addrmap_mutable_set_empty (struct addrmap *this,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
CORE_ADDR start, CORE_ADDR end_inclusive,
|
void *obj)
|
void *obj)
|
{
|
{
|
struct addrmap_mutable *map = (struct addrmap_mutable *) this;
|
struct addrmap_mutable *map = (struct addrmap_mutable *) this;
|
splay_tree_node n, next;
|
splay_tree_node n, next;
|
void *prior_value;
|
void *prior_value;
|
|
|
/* If we're being asked to set all empty portions of the given
|
/* If we're being asked to set all empty portions of the given
|
address range to empty, then probably the caller is confused.
|
address range to empty, then probably the caller is confused.
|
(If that turns out to be useful in some cases, then we can change
|
(If that turns out to be useful in some cases, then we can change
|
this to simply return, since overriding NULL with NULL is a
|
this to simply return, since overriding NULL with NULL is a
|
no-op.) */
|
no-op.) */
|
gdb_assert (obj);
|
gdb_assert (obj);
|
|
|
/* We take a two-pass approach, for simplicity.
|
/* We take a two-pass approach, for simplicity.
|
- Establish transitions where we think we might need them.
|
- Establish transitions where we think we might need them.
|
- First pass: change all NULL regions to OBJ.
|
- First pass: change all NULL regions to OBJ.
|
- Second pass: remove any unnecessary transitions. */
|
- Second pass: remove any unnecessary transitions. */
|
|
|
/* Establish transitions at the start and end. */
|
/* Establish transitions at the start and end. */
|
force_transition (map, start);
|
force_transition (map, start);
|
if (end_inclusive < CORE_ADDR_MAX)
|
if (end_inclusive < CORE_ADDR_MAX)
|
force_transition (map, end_inclusive + 1);
|
force_transition (map, end_inclusive + 1);
|
|
|
/* Walk the area, changing all NULL regions to OBJ. */
|
/* Walk the area, changing all NULL regions to OBJ. */
|
for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
|
for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
|
n && addrmap_node_key (n) <= end_inclusive;
|
n && addrmap_node_key (n) <= end_inclusive;
|
n = addrmap_splay_tree_successor (map, addrmap_node_key (n)))
|
n = addrmap_splay_tree_successor (map, addrmap_node_key (n)))
|
{
|
{
|
if (! addrmap_node_value (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
|
/* Walk the area again, removing transitions from any value to
|
itself. Be sure to visit both the transitions we forced
|
itself. Be sure to visit both the transitions we forced
|
above. */
|
above. */
|
n = addrmap_splay_tree_predecessor (map, start);
|
n = addrmap_splay_tree_predecessor (map, start);
|
prior_value = n ? addrmap_node_value (n) : NULL;
|
prior_value = n ? addrmap_node_value (n) : NULL;
|
for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
|
for (n = addrmap_splay_tree_lookup (map, start), gdb_assert (n);
|
n && (end_inclusive == CORE_ADDR_MAX
|
n && (end_inclusive == CORE_ADDR_MAX
|
|| addrmap_node_key (n) <= end_inclusive + 1);
|
|| addrmap_node_key (n) <= end_inclusive + 1);
|
n = next)
|
n = next)
|
{
|
{
|
next = addrmap_splay_tree_successor (map, addrmap_node_key (n));
|
next = addrmap_splay_tree_successor (map, addrmap_node_key (n));
|
if (addrmap_node_value (n) == prior_value)
|
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
|
else
|
prior_value = addrmap_node_value (n);
|
prior_value = addrmap_node_value (n);
|
}
|
}
|
}
|
}
|
|
|
|
|
static void *
|
static void *
|
addrmap_mutable_find (struct addrmap *this, CORE_ADDR addr)
|
addrmap_mutable_find (struct addrmap *this, CORE_ADDR addr)
|
{
|
{
|
/* Not needed yet. */
|
/* Not needed yet. */
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("addrmap_find is not implemented yet "
|
_("addrmap_find is not implemented yet "
|
"for mutable addrmaps"));
|
"for mutable addrmaps"));
|
}
|
}
|
|
|
|
|
/* A function to pass to splay_tree_foreach to count the number of nodes
|
/* A function to pass to splay_tree_foreach to count the number of nodes
|
in the tree. */
|
in the tree. */
|
static int
|
static int
|
splay_foreach_count (splay_tree_node n, void *closure)
|
splay_foreach_count (splay_tree_node n, void *closure)
|
{
|
{
|
size_t *count = (size_t *) closure;
|
size_t *count = (size_t *) closure;
|
|
|
(*count)++;
|
(*count)++;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* A function to pass to splay_tree_foreach to copy entries into a
|
/* A function to pass to splay_tree_foreach to copy entries into a
|
fixed address map. */
|
fixed address map. */
|
static int
|
static int
|
splay_foreach_copy (splay_tree_node n, void *closure)
|
splay_foreach_copy (splay_tree_node n, void *closure)
|
{
|
{
|
struct addrmap_fixed *fixed = (struct addrmap_fixed *) closure;
|
struct addrmap_fixed *fixed = (struct addrmap_fixed *) closure;
|
struct addrmap_transition *t = &fixed->transitions[fixed->num_transitions];
|
struct addrmap_transition *t = &fixed->transitions[fixed->num_transitions];
|
|
|
t->addr = addrmap_node_key (n);
|
t->addr = addrmap_node_key (n);
|
t->value = addrmap_node_value (n);
|
t->value = addrmap_node_value (n);
|
fixed->num_transitions++;
|
fixed->num_transitions++;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
static struct addrmap *
|
static struct addrmap *
|
addrmap_mutable_create_fixed (struct addrmap *this, struct obstack *obstack)
|
addrmap_mutable_create_fixed (struct addrmap *this, struct obstack *obstack)
|
{
|
{
|
struct addrmap_mutable *mutable = (struct addrmap_mutable *) this;
|
struct addrmap_mutable *mutable = (struct addrmap_mutable *) this;
|
struct addrmap_fixed *fixed;
|
struct addrmap_fixed *fixed;
|
size_t num_transitions;
|
size_t num_transitions;
|
|
|
/* Count the number of transitions in the tree. */
|
/* Count the number of transitions in the tree. */
|
num_transitions = 0;
|
num_transitions = 0;
|
splay_tree_foreach (mutable->tree, splay_foreach_count, &num_transitions);
|
splay_tree_foreach (mutable->tree, splay_foreach_count, &num_transitions);
|
|
|
/* Include an extra entry for the transition at zero (which fixed
|
/* Include an extra entry for the transition at zero (which fixed
|
maps have, but mutable maps do not.) */
|
maps have, but mutable maps do not.) */
|
num_transitions++;
|
num_transitions++;
|
|
|
fixed = obstack_alloc (obstack,
|
fixed = obstack_alloc (obstack,
|
(sizeof (*fixed)
|
(sizeof (*fixed)
|
+ (num_transitions
|
+ (num_transitions
|
* sizeof (fixed->transitions[0]))));
|
* sizeof (fixed->transitions[0]))));
|
fixed->addrmap.funcs = &addrmap_fixed_funcs;
|
fixed->addrmap.funcs = &addrmap_fixed_funcs;
|
fixed->num_transitions = 1;
|
fixed->num_transitions = 1;
|
fixed->transitions[0].addr = 0;
|
fixed->transitions[0].addr = 0;
|
fixed->transitions[0].value = NULL;
|
fixed->transitions[0].value = NULL;
|
|
|
/* Copy all entries from the splay tree to the array, in order
|
/* Copy all entries from the splay tree to the array, in order
|
of increasing address. */
|
of increasing address. */
|
splay_tree_foreach (mutable->tree, splay_foreach_copy, fixed);
|
splay_tree_foreach (mutable->tree, splay_foreach_copy, fixed);
|
|
|
/* We should have filled the array. */
|
/* We should have filled the array. */
|
gdb_assert (fixed->num_transitions == num_transitions);
|
gdb_assert (fixed->num_transitions == num_transitions);
|
|
|
return (struct addrmap *) fixed;
|
return (struct addrmap *) fixed;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
addrmap_mutable_relocate (struct addrmap *this, CORE_ADDR offset)
|
addrmap_mutable_relocate (struct addrmap *this, CORE_ADDR offset)
|
{
|
{
|
/* Not needed yet. */
|
/* Not needed yet. */
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("addrmap_relocate is not implemented yet "
|
_("addrmap_relocate is not implemented yet "
|
"for mutable addrmaps"));
|
"for mutable addrmaps"));
|
}
|
}
|
|
|
|
|
static const struct addrmap_funcs addrmap_mutable_funcs =
|
static const struct addrmap_funcs addrmap_mutable_funcs =
|
{
|
{
|
addrmap_mutable_set_empty,
|
addrmap_mutable_set_empty,
|
addrmap_mutable_find,
|
addrmap_mutable_find,
|
addrmap_mutable_create_fixed,
|
addrmap_mutable_create_fixed,
|
addrmap_mutable_relocate
|
addrmap_mutable_relocate
|
};
|
};
|
|
|
|
|
static void *
|
static void *
|
splay_obstack_alloc (int size, void *closure)
|
splay_obstack_alloc (int size, void *closure)
|
{
|
{
|
struct addrmap_mutable *map = closure;
|
struct addrmap_mutable *map = closure;
|
splay_tree_node n;
|
splay_tree_node n;
|
|
|
/* We should only be asked to allocate nodes and larger things.
|
/* 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
|
(If, at some point in the future, this is no longer true, we can
|
just round up the size to sizeof (*n).) */
|
just round up the size to sizeof (*n).) */
|
gdb_assert (size >= sizeof (*n));
|
gdb_assert (size >= sizeof (*n));
|
|
|
if (map->free_nodes)
|
if (map->free_nodes)
|
{
|
{
|
n = map->free_nodes;
|
n = map->free_nodes;
|
map->free_nodes = n->right;
|
map->free_nodes = n->right;
|
return n;
|
return n;
|
}
|
}
|
else
|
else
|
return obstack_alloc (map->obstack, size);
|
return obstack_alloc (map->obstack, size);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
splay_obstack_free (void *obj, void *closure)
|
splay_obstack_free (void *obj, void *closure)
|
{
|
{
|
struct addrmap_mutable *map = closure;
|
struct addrmap_mutable *map = closure;
|
splay_tree_node n = obj;
|
splay_tree_node n = obj;
|
|
|
/* We've asserted in the allocation function that we only allocate
|
/* We've asserted in the allocation function that we only allocate
|
nodes or larger things, so it should be safe to put whatever
|
nodes or larger things, so it should be safe to put whatever
|
we get passed back on the free list. */
|
we get passed back on the free list. */
|
n->right = map->free_nodes;
|
n->right = map->free_nodes;
|
map->free_nodes = n;
|
map->free_nodes = n;
|
}
|
}
|
|
|
|
|
/* Compare keys as CORE_ADDR * values. */
|
/* Compare keys as CORE_ADDR * values. */
|
static int
|
static int
|
splay_compare_CORE_ADDR_ptr (splay_tree_key ak, splay_tree_key bk)
|
splay_compare_CORE_ADDR_ptr (splay_tree_key ak, splay_tree_key bk)
|
{
|
{
|
CORE_ADDR a = * (CORE_ADDR *) ak;
|
CORE_ADDR a = * (CORE_ADDR *) ak;
|
CORE_ADDR b = * (CORE_ADDR *) bk;
|
CORE_ADDR b = * (CORE_ADDR *) bk;
|
|
|
/* We can't just return a-b here, because of over/underflow. */
|
/* We can't just return a-b here, because of over/underflow. */
|
if (a < b)
|
if (a < b)
|
return -1;
|
return -1;
|
else if (a == b)
|
else if (a == b)
|
return 0;
|
return 0;
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
struct addrmap *
|
struct addrmap *
|
addrmap_create_mutable (struct obstack *obstack)
|
addrmap_create_mutable (struct obstack *obstack)
|
{
|
{
|
struct addrmap_mutable *map = obstack_alloc (obstack, sizeof (*map));
|
struct addrmap_mutable *map = obstack_alloc (obstack, sizeof (*map));
|
|
|
map->addrmap.funcs = &addrmap_mutable_funcs;
|
map->addrmap.funcs = &addrmap_mutable_funcs;
|
map->obstack = obstack;
|
map->obstack = obstack;
|
|
|
/* splay_tree_new_with_allocator uses the provided allocation
|
/* splay_tree_new_with_allocator uses the provided allocation
|
function to allocate the main splay_tree structure itself, so our
|
function to allocate the main splay_tree structure itself, so our
|
free list has to be initialized before we create the tree. */
|
free list has to be initialized before we create the tree. */
|
map->free_nodes = NULL;
|
map->free_nodes = NULL;
|
|
|
map->tree = splay_tree_new_with_allocator (splay_compare_CORE_ADDR_ptr,
|
map->tree = splay_tree_new_with_allocator (splay_compare_CORE_ADDR_ptr,
|
NULL, /* no delete key */
|
NULL, /* no delete key */
|
NULL, /* no delete value */
|
NULL, /* no delete value */
|
splay_obstack_alloc,
|
splay_obstack_alloc,
|
splay_obstack_free,
|
splay_obstack_free,
|
map);
|
map);
|
|
|
return (struct addrmap *) map;
|
return (struct addrmap *) map;
|
}
|
}
|
|
|
|
|
|
|
/* Initialization. */
|
/* Initialization. */
|
|
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
extern initialize_file_ftype _initialize_addrmap;
|
extern initialize_file_ftype _initialize_addrmap;
|
|
|
void
|
void
|
_initialize_addrmap (void)
|
_initialize_addrmap (void)
|
{
|
{
|
/* Make sure splay trees can actually hold the values we want to
|
/* Make sure splay trees can actually hold the values we want to
|
store in them. */
|
store in them. */
|
gdb_assert (sizeof (splay_tree_key) >= sizeof (CORE_ADDR *));
|
gdb_assert (sizeof (splay_tree_key) >= sizeof (CORE_ADDR *));
|
gdb_assert (sizeof (splay_tree_value) >= sizeof (void *));
|
gdb_assert (sizeof (splay_tree_value) >= sizeof (void *));
|
}
|
}
|
|
|
