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; } }