void
macro_undef (struct macro_source_file *source, int line,
const char *name)
{
splay_tree_node n = find_definition (name, source, line);
if (n)
{
struct macro_key *key = (struct macro_key *) n->key;
/* If we're removing a definition at exactly the same point that
we defined it, then just delete the entry altogether. GCC
4.1.2 will generate DWARF that says to do this if you pass it
arguments like '-DFOO -UFOO -DFOO=2'. */
if (source == key->start_file
&& line == key->start_line)
splay_tree_remove (source->table->definitions, n->key);
else
{
/* This function is the only place a macro's end-of-scope
location gets set to anything other than "end of the
compilation unit" (i.e., end_file is zero). So if this
macro already has its end-of-scope set, then we're
probably seeing a second #undefinition for the same
#definition. */
if (key->end_file)
{
char *source_fullname, *key_fullname;
source_fullname = macro_source_fullname (source);
key_fullname = macro_source_fullname (key->end_file);
complaint (&symfile_complaints,
_("macro '%s' is #undefined twice,"
" at %s:%d and %s:%d"),
name, source_fullname, line, key_fullname,
key->end_line);
xfree (key_fullname);
xfree (source_fullname);
}
/* Whether or not we've seen a prior #undefinition, wipe out
the old ending point, and make this the ending point. */
key->end_file = source;
key->end_line = line;
}
}
else
{
/* According to the ISO C standard, an #undef for a symbol that
has no macro definition in scope is ignored. So we should
ignore it too. */
#if 0
complaint (&symfile_complaints,
_("no definition for macro `%s' in scope to #undef at %s:%d"),
name, source->filename, line);
#endif
}
}
static void
invalidate_block (struct dcache_block *block, void *param)
{
DCACHE *dcache = (DCACHE *) param;
splay_tree_remove (dcache->tree, (splay_tree_key) block->addr);
append_block (&dcache->freelist, block);
}
static void
dcache_invalidate_line (DCACHE *dcache, CORE_ADDR addr)
{
struct dcache_block *db = dcache_hit (dcache, addr);
if (db)
{
splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
db->newer = dcache->freelist;
dcache->freelist = db;
--dcache->size;
}
}
static void
dcache_invalidate_line (DCACHE *dcache, CORE_ADDR addr)
{
struct dcache_block *db = dcache_hit (dcache, addr);
if (db)
{
splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
remove_block (&dcache->oldest, db);
append_block (&dcache->freelist, db);
--dcache->size;
}
}
static struct dcache_block *
dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
{
struct dcache_block *db;
if (dcache->size >= DCACHE_SIZE)
{
/* Evict the least recently used line. */
db = dcache->oldest;
dcache->oldest = db->newer;
splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
}
else
{
db = dcache->freelist;
if (db)
dcache->freelist = db->newer;
else
db = xmalloc (sizeof (struct dcache_block));
dcache->size++;
}
db->addr = MASK (addr);
db->newer = NULL;
db->refs = 0;
if (dcache->newest)
dcache->newest->newer = db;
dcache->newest = db;
if (!dcache->oldest)
dcache->oldest = db;
splay_tree_insert (dcache->tree, (splay_tree_key) db->addr,
(splay_tree_value) db);
return db;
}
void
dcache_invalidate (DCACHE *dcache)
{
struct dcache_block *block, *next;
block = dcache->oldest;
while (block)
{
splay_tree_remove (dcache->tree, (splay_tree_key) block->addr);
next = block->newer;
block->newer = dcache->freelist;
dcache->freelist = block;
block = next;
}
dcache->oldest = NULL;
dcache->newest = NULL;
dcache->size = 0;
dcache->ptid = null_ptid;
}
static struct dcache_block *
dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
{
struct dcache_block *db;
if (dcache->size >= dcache_size)
{
/* Evict the least recently allocated line. */
db = dcache->oldest;
remove_block (&dcache->oldest, db);
splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
}
else
{
db = dcache->freelist;
if (db)
remove_block (&dcache->freelist, db);
else
db = xmalloc (offsetof (struct dcache_block, data) +
dcache->line_size);
dcache->size++;
}
db->addr = MASK (dcache, addr);
db->refs = 0;
/* Put DB at the end of the list, it's the newest. */
append_block (&dcache->oldest, db);
splay_tree_insert (dcache->tree, (splay_tree_key) db->addr,
(splay_tree_value) db);
return db;
}
static void
addrmap_splay_tree_remove (struct addrmap_mutable *map, CORE_ADDR addr)
{
splay_tree_remove (map->tree, (splay_tree_key) &addr);
}
static void
searchc (struct searchc_env* env, struct cgraph_node *v,
bool (*ignore_edge) (struct cgraph_edge *))
{
struct cgraph_edge *edge;
struct ipa_dfs_info *v_info = (struct ipa_dfs_info *) v->aux;
/* mark node as old */
v_info->new_node = false;
splay_tree_remove (env->nodes_marked_new, v->uid);
v_info->dfn_number = env->count;
v_info->low_link = env->count;
env->count++;
env->stack[(env->stack_size)++] = v;
v_info->on_stack = true;
for (edge = v->callees; edge; edge = edge->next_callee)
{
struct ipa_dfs_info * w_info;
enum availability avail;
struct cgraph_node *w = cgraph_function_or_thunk_node (edge->callee, &avail);
if (!w || (ignore_edge && ignore_edge (edge)))
continue;
if (w->aux
&& (avail > AVAIL_OVERWRITABLE
|| (env->allow_overwritable && avail == AVAIL_OVERWRITABLE)))
{
w_info = (struct ipa_dfs_info *) w->aux;
if (w_info->new_node)
{
searchc (env, w, ignore_edge);
v_info->low_link =
(v_info->low_link < w_info->low_link) ?
v_info->low_link : w_info->low_link;
}
else
if ((w_info->dfn_number < v_info->dfn_number)
&& (w_info->on_stack))
v_info->low_link =
(w_info->dfn_number < v_info->low_link) ?
w_info->dfn_number : v_info->low_link;
}
}
if (v_info->low_link == v_info->dfn_number)
{
struct cgraph_node *last = NULL;
struct cgraph_node *x;
struct ipa_dfs_info *x_info;
do {
x = env->stack[--(env->stack_size)];
x_info = (struct ipa_dfs_info *) x->aux;
x_info->on_stack = false;
x_info->scc_no = v_info->dfn_number;
if (env->reduce)
{
x_info->next_cycle = last;
last = x;
}
else
env->result[env->order_pos++] = x;
}
while (v != x);
if (env->reduce)
env->result[env->order_pos++] = v;
}
}