static void
interval_tree_intersection_1(interval_tree tree, uint64_t start, uint64_t end,
varray * dest)
{
interval_tree_node node;
node = splay_tree_lookup(tree->splay, start);
if (!node)
{
node = splay_tree_predecessor(tree->splay, start);
if (!node || INTERVAL_END(node) <= start)
node = splay_tree_successor(tree->splay, start);
}
if (!node)
node = splay_tree_successor(tree->splay, start);
for (; node && INTERVAL_START(node) < end;
node = splay_tree_successor(tree->splay, INTERVAL_START(node)))
{
interval *x;
VARRAY_EMPTY_PUSH(*dest);
x = &VARRAY_TOP(*dest, interval);
x->start = MAX(start, INTERVAL_START(node));
x->end = MIN(end, INTERVAL_END(node));
}
}
static void
interval_tree_complement_1(interval_tree tree, uint64_t start, uint64_t end,
varray * dest)
{
interval_tree_node node;
uint64_t last;
node = splay_tree_lookup(tree->splay, start);
if (node)
{
last = INTERVAL_END(node);
}
else
{
node = splay_tree_predecessor(tree->splay, start);
if (node && INTERVAL_END(node) > start)
last = INTERVAL_END(node);
else
last = start;
}
node = splay_tree_successor(tree->splay, start);
while (last < end)
{
interval *x;
VARRAY_EMPTY_PUSH(*dest);
x = &VARRAY_TOP(*dest, interval);
x->start = last;
if (node)
{
x->end = INTERVAL_START(node);
last = INTERVAL_END(node);
node = splay_tree_successor(tree->splay, INTERVAL_START(node));
}
else
{
x->end = end;
break;
}
}
}
static void
dcache_info (char *exp, int tty)
{
splay_tree_node n;
int i, refcount;
if (exp)
{
char *linestart;
i = strtol (exp, &linestart, 10);
if (linestart == exp || i < 0)
{
printf_filtered (_("Usage: info dcache [linenumber]\n"));
return;
}
dcache_print_line (i);
return;
}
printf_filtered (_("Dcache %u lines of %u bytes each.\n"),
dcache_size,
last_cache ? (unsigned) last_cache->line_size
: dcache_line_size);
if (!last_cache || ptid_equal (last_cache->ptid, null_ptid))
{
printf_filtered (_("No data cache available.\n"));
return;
}
printf_filtered (_("Contains data for %s\n"),
target_pid_to_str (last_cache->ptid));
refcount = 0;
n = splay_tree_min (last_cache->tree);
i = 0;
while (n)
{
struct dcache_block *db = (struct dcache_block *) n->value;
printf_filtered (_("Line %d: address %s [%d hits]\n"),
i, paddress (target_gdbarch, db->addr), db->refs);
i++;
refcount += db->refs;
n = splay_tree_successor (last_cache->tree, n->key);
}
printf_filtered (_("Cache state: %d active lines, %d hits\n"), i, refcount);
}
static void
dcache_print_line (int index)
{
splay_tree_node n;
struct dcache_block *db;
int i, j;
if (!last_cache)
{
printf_filtered (_("No data cache available.\n"));
return;
}
n = splay_tree_min (last_cache->tree);
for (i = index; i > 0; --i)
{
if (!n)
break;
n = splay_tree_successor (last_cache->tree, n->key);
}
if (!n)
{
printf_filtered (_("No such cache line exists.\n"));
return;
}
db = (struct dcache_block *) n->value;
printf_filtered (_("Line %d: address %s [%d hits]\n"),
index, paddress (target_gdbarch, db->addr), db->refs);
for (j = 0; j < LINE_SIZE; j++)
{
printf_filtered ("%02x ", db->data[j]);
/* Print a newline every 16 bytes (48 characters) */
if ((j % 16 == 15) && (j != LINE_SIZE - 1))
printf_filtered ("\n");
}
printf_filtered ("\n");
}
interval_tree_node interval_tree_lookup(interval_tree tree, uint64_t value)
{
interval_tree_node node;
CHECK_MUTEX_LOCKED(tree->mutex);
/* Return the interval starting with VALUE if it exist. */
node = splay_tree_lookup(tree->splay, value);
if (node)
return node;
/* Return the interval containing VALUE if it exist. */
node = splay_tree_predecessor(tree->splay, value);
if (node && INTERVAL_END(node) > value)
return node;
/* Return the first interval after VALUE. */
return splay_tree_successor(tree->splay, value);
}
static splay_tree_node
addrmap_splay_tree_successor (struct addrmap_mutable *map, CORE_ADDR addr)
{
return splay_tree_successor (map->tree, (splay_tree_key) &addr);
}
interval_tree_node
interval_tree_insert(interval_tree tree, uint64_t start, uint64_t end)
{
splay_tree_node node, prev, next;
CHECK_MUTEX_LOCKED(tree->mutex);
if ((node = splay_tree_lookup(tree->splay, start)) != NULL)
{
/* The START of interval is already in the tree. */
if (INTERVAL_END(node) >= end)
{
/* There already is a larger interval starting in START so we have
nothing to do. */
return node;
}
INTERVAL_END(node) = end;
}
else
{
/* Lookup the predecessor and successor of key START. */
prev = splay_tree_predecessor(tree->splay, start);
next = splay_tree_successor(tree->splay, start);
if (prev && INTERVAL_END(prev) >= start)
{
/* We are extending PREV. */
node = prev;
if (INTERVAL_END(node) < end)
INTERVAL_END(node) = end;
}
else if (next && INTERVAL_START(next) <= end)
{
/* We are extending NEXT. */
node = next;
if (INTERVAL_START(node) > start)
INTERVAL_START(node) = start;
if (INTERVAL_END(node) < end)
INTERVAL_END(node) = end;
}
else
{
/* We are really inserting a new node. */
node = splay_tree_insert(tree->splay, start, end);
tree->size++;
}
}
/* Merge the successors if they are covered by [START, END). */
while ((next = splay_tree_successor(tree->splay,
INTERVAL_START(node))) != NULL)
{
if (INTERVAL_START(next) <= INTERVAL_END(node))
{
if (INTERVAL_END(node) < INTERVAL_END(next))
INTERVAL_END(node) = INTERVAL_END(next);
splay_tree_delete(tree->splay, INTERVAL_START(next));
tree->size--;
}
else
break;
}
return node;
}
interval_tree_node interval_tree_successor(interval_tree tree, uint64_t key)
{
CHECK_MUTEX_LOCKED(tree->mutex);
return splay_tree_successor(tree->splay, key);
}
void interval_tree_delete(interval_tree tree, uint64_t start, uint64_t end)
{
splay_tree_node node, prev, next;
CHECK_MUTEX_LOCKED(tree->mutex);
if ((node = splay_tree_lookup(tree->splay, start)) != NULL)
{
tree->deleted = true;
if (INTERVAL_END(node) > end)
{
/* We are shortening the interval NODE. */
INTERVAL_START(node) = end;
return;
}
else
{
splay_tree_delete(tree->splay, start);
tree->size--;
}
}
else
{
prev = splay_tree_predecessor(tree->splay, start);
if (prev && start < INTERVAL_END(prev))
{
tree->deleted = true;
if (INTERVAL_END(prev) > end)
{
/* We are cutting a subinterval from interval PREV. */
splay_tree_insert(tree->splay, end, INTERVAL_END(prev));
tree->size++;
INTERVAL_END(prev) = start;
return;
}
else
{
/* We are shortening the interval PREV. */
INTERVAL_END(prev) = start;
}
}
}
/* Delete rest intervals which intersect [START, END). */
while (1)
{
next = splay_tree_successor(tree->splay, start);
if (!next || INTERVAL_START(next) >= end)
break;
tree->deleted = true;
if (INTERVAL_END(next) <= end)
{
splay_tree_delete(tree->splay, INTERVAL_START(next));
tree->size--;
}
else
{
INTERVAL_START(next) = end;
return;
}
}
}
