void
copy_func_cl_pf_opts_mapping (tree funcold, tree funcnew)
{
PTR *slot;
struct func_cl_pf_opts_mapping map, *entry;
struct cl_perfunc_opts *oldcl_pf_opts;
/* This will be the case for languages whose FEs don't call
record_func_cl_pf_opts_mapping. */
if (!func_cl_pf_opts_mapping_hash_table)
return;
map.func = funcold;
slot = htab_find_slot (func_cl_pf_opts_mapping_hash_table, &map, NO_INSERT);
gcc_assert (*slot);
entry = *slot;
oldcl_pf_opts = entry->cl_pf_opts;
map.func = funcnew;
slot = htab_find_slot (func_cl_pf_opts_mapping_hash_table, &map, INSERT);
if (*slot)
entry = *slot;
else
{
entry = xmalloc (sizeof (struct func_cl_pf_opts_mapping));
entry->func = funcnew;
*slot = entry;
}
entry->cl_pf_opts = oldcl_pf_opts;
}
static void
fill_hash_bucket (void)
{
basic_block bb;
rtx insn;
void **slot;
p_hash_bucket bucket;
struct hash_bucket_def tmp_bucket;
p_hash_elem elem;
unsigned long insn_idx;
insn_idx = 0;
FOR_EACH_BB (bb)
{
FOR_BB_INSNS_REVERSE (bb, insn)
{
if (!ABSTRACTABLE_INSN_P (insn))
continue;
/* Compute hash value for INSN. */
tmp_bucket.hash = compute_hash (insn);
/* Select the hash group. */
bucket = (p_hash_bucket) htab_find (hash_buckets, &tmp_bucket);
if (!bucket)
{
/* Create a new hash group. */
bucket = (p_hash_bucket) xcalloc (1,
sizeof (struct hash_bucket_def));
bucket->hash = tmp_bucket.hash;
bucket->seq_candidates = NULL;
slot = htab_find_slot (hash_buckets, &tmp_bucket, INSERT);
*slot = bucket;
}
/* Create new list for storing sequence candidates. */
if (!bucket->seq_candidates)
bucket->seq_candidates = htab_create (HASH_INIT,
htab_hash_elem,
htab_eq_elem,
htab_del_elem);
elem = (p_hash_elem) xcalloc (1, sizeof (struct hash_elem_def));
elem->insn = insn;
elem->idx = insn_idx;
elem->length = get_attr_length (insn);
/* Insert INSN into BUCKET hash bucket. */
slot = htab_find_slot (bucket->seq_candidates, elem, INSERT);
*slot = elem;
insn_idx++;
}
}
}
void
symtab_register_node (symtab_node node)
{
struct symtab_node_base key;
symtab_node *slot;
node->symbol.next = symtab_nodes;
node->symbol.previous = NULL;
if (symtab_nodes)
symtab_nodes->symbol.previous = node;
symtab_nodes = node;
if (!symtab_hash)
symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
key.decl = node->symbol.decl;
slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
if (*slot == NULL)
*slot = node;
ipa_empty_ref_list (&node->symbol.ref_list);
node->symbol.order = symtab_order++;
/* Be sure to do this last; C++ FE might create new nodes via
DECL_ASSEMBLER_NAME langhook! */
insert_to_assembler_name_hash (node, false);
}
void
symtab_register_node (symtab_node node)
{
struct symtab_node_base key;
symtab_node *slot;
node->symbol.next = symtab_nodes;
node->symbol.previous = NULL;
if (symtab_nodes)
symtab_nodes->symbol.previous = node;
symtab_nodes = node;
if (!symtab_hash)
symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
key.decl = node->symbol.decl;
slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
if (*slot == NULL)
*slot = node;
insert_to_assembler_name_hash (node);
node->symbol.order = symtab_order++;
ipa_empty_ref_list (&node->symbol.ref_list);
}
symtab_node
symtab_get_node (const_tree decl)
{
symtab_node *slot;
struct symtab_node_base key;
#ifdef ENABLE_CHECKING
/* Check that we are called for sane type of object - functions
and static or external variables. */
gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
|| (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
|| in_lto_p)));
#endif
if (!symtab_hash)
return NULL;
key.decl = CONST_CAST2 (tree, const_tree, decl);
slot = (symtab_node *) htab_find_slot (symtab_hash, &key,
NO_INSERT);
if (slot)
return *slot;
return NULL;
}
/* Return varpool node assigned to DECL. Create new one when needed. */
struct varpool_node *
varpool_node (tree decl)
{
struct varpool_node key, *node, **slot;
gcc_assert (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl) || in_lto_p));
if (!varpool_hash)
varpool_hash = htab_create_ggc (10, hash_varpool_node,
eq_varpool_node, NULL);
key.decl = decl;
slot = (struct varpool_node **)
htab_find_slot (varpool_hash, &key, INSERT);
if (*slot)
return *slot;
node = ggc_alloc_cleared_varpool_node ();
node->decl = decl;
node->order = cgraph_order++;
node->next = varpool_nodes;
ipa_empty_ref_list (&node->ref_list);
if (varpool_nodes)
varpool_nodes->prev = node;
varpool_nodes = node;
*slot = node;
return node;
}
struct call_site *
call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
{
struct symtab *symtab;
void **slot = NULL;
/* -1 as tail call PC can be already after the compilation unit range. */
symtab = find_pc_symtab (pc - 1);
if (symtab != NULL && symtab->call_site_htab != NULL)
slot = htab_find_slot (symtab->call_site_htab, &pc, NO_INSERT);
if (slot == NULL)
{
struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (pc);
/* DW_TAG_gnu_call_site will be missing just if GCC could not determine
the call target. */
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_OP_GNU_entry_value resolving cannot find "
"DW_TAG_GNU_call_site %s in %s"),
paddress (gdbarch, pc),
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
return *slot;
}
struct varpool_node *
varpool_extra_name_alias (tree alias, tree decl)
{
struct varpool_node key, *alias_node, *decl_node, **slot;
#ifndef ASM_OUTPUT_DEF
/* If aliases aren't supported by the assembler, fail. */
return false;
#endif
gcc_assert (TREE_CODE (decl) == VAR_DECL);
gcc_assert (TREE_CODE (alias) == VAR_DECL);
/* Make sure the hash table has been created. */
decl_node = varpool_node (decl);
key.decl = alias;
slot = (struct varpool_node **) htab_find_slot (varpool_hash, &key, INSERT);
/* If the varpool_node has been already created, fail. */
if (*slot)
return NULL;
alias_node = ggc_alloc_cleared_varpool_node ();
alias_node->decl = alias;
alias_node->alias = 1;
alias_node->extra_name = decl_node;
alias_node->next = decl_node->extra_name;
ipa_empty_ref_list (&alias_node->ref_list);
if (decl_node->extra_name)
decl_node->extra_name->prev = alias_node;
decl_node->extra_name = alias_node;
*slot = alias_node;
return alias_node;
}
static void
gomp_task_run_post_handle_depend_hash (struct gomp_task *child_task)
{
struct gomp_task *parent = child_task->parent;
size_t i;
for (i = 0; i < child_task->depend_count; i++)
if (!child_task->depend[i].redundant)
{
if (child_task->depend[i].next)
child_task->depend[i].next->prev = child_task->depend[i].prev;
if (child_task->depend[i].prev)
child_task->depend[i].prev->next = child_task->depend[i].next;
else
{
hash_entry_type *slot
= htab_find_slot (&parent->depend_hash, &child_task->depend[i],
NO_INSERT);
if (*slot != &child_task->depend[i])
abort ();
if (child_task->depend[i].next)
*slot = child_task->depend[i].next;
else
htab_clear_slot (parent->depend_hash, slot);
}
}
}
bool
varpool_extra_name_alias (tree alias, tree decl)
{
struct varpool_node key, *alias_node, *decl_node, **slot;
#ifndef ASM_OUTPUT_DEF
/* If aliases aren't supported by the assembler, fail. */
return false;
#endif
gcc_assert (TREE_CODE (decl) == VAR_DECL);
gcc_assert (TREE_CODE (alias) == VAR_DECL);
/* Make sure the hash table has been created. */
decl_node = varpool_node (decl);
key.decl = alias;
slot = (struct varpool_node **) htab_find_slot (varpool_hash, &key, INSERT);
/* If the varpool_node has been already created, fail. */
if (*slot)
return false;
alias_node = GGC_CNEW (struct varpool_node);
alias_node->decl = alias;
alias_node->alias = 1;
alias_node->extra_name = decl_node;
alias_node->next = decl_node->extra_name;
decl_node->extra_name = alias_node;
*slot = alias_node;
return true;
}
bool
lto_output_decl_index (struct lto_output_stream *obs,
struct lto_tree_ref_encoder *encoder,
tree name, unsigned int *this_index)
{
void **slot;
struct lto_decl_slot d_slot;
int index;
bool new_entry_p = FALSE;
d_slot.t = name;
slot = htab_find_slot (encoder->tree_hash_table, &d_slot, INSERT);
if (*slot == NULL)
{
struct lto_decl_slot *new_slot
= (struct lto_decl_slot *) xmalloc (sizeof (struct lto_decl_slot));
index = encoder->next_index++;
new_slot->t = name;
new_slot->slot_num = index;
*slot = new_slot;
VEC_safe_push (tree, heap, encoder->trees, name);
new_entry_p = TRUE;
}
else
{
struct lto_decl_slot *old_slot = (struct lto_decl_slot *)*slot;
index = old_slot->slot_num;
}
if (obs)
streamer_write_uhwi_stream (obs, index);
*this_index = index;
return new_entry_p;
}
void
gdbscm_clear_eqable_gsmob_ptr_slot (htab_t htab, eqable_gdb_smob *base)
{
void **slot = htab_find_slot (htab, base, NO_INSERT);
gdb_assert (slot != NULL);
htab_clear_slot (htab, slot);
}
static void
register_gsmob (scm_t_bits gsmob_code)
{
void **slot;
slot = htab_find_slot (registered_gsmobs, (void *) gsmob_code, INSERT);
gdb_assert (*slot == NULL);
*slot = (void *) gsmob_code;
}
/* Insert candidate CAND into the table if it is not there yet.
Return candidate which is in the table. */
static cand_t
insert_cand (cand_t cand)
{
void **entry_ptr;
entry_ptr = htab_find_slot (cand_table, cand, INSERT);
if (*entry_ptr == NULL)
*entry_ptr = (void *) cand;
return (cand_t) *entry_ptr;
}
intptr_t
lto_orig_address_get (tree t)
{
struct tree_hash_entry ent;
struct tree_hash_entry **slot;
ent.key = t;
slot
= (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, NO_INSERT);
return (slot ? (*slot)->value : 0);
}
static lto_symtab_entry_t
lto_symtab_get (tree id)
{
struct lto_symtab_entry_def temp;
void **slot;
lto_symtab_maybe_init_hash_table ();
temp.id = id;
slot = htab_find_slot (lto_symtab_identifiers, &temp, NO_INSERT);
return slot ? (lto_symtab_entry_t) *slot : NULL;
}
static int
gdbscm_is_gsmob (SCM scm)
{
void **slot;
if (SCM_IMP (scm))
return 0;
slot = htab_find_slot (registered_gsmobs, (void *) SCM_TYP16 (scm),
NO_INSERT);
return slot != NULL;
}
void
solaris_elf_asm_comdat_section (const char *name, unsigned int flags, tree decl)
{
const char *signature;
char *section;
comdat_entry entry, **slot;
if (TREE_CODE (decl) == IDENTIFIER_NODE)
signature = IDENTIFIER_POINTER (decl);
else
signature = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl));
/* Sun as requires group sections to be fragmented, i.e. to have names of
the form <section>%<fragment>. Strictly speaking this is only
necessary to support cc -xF, but is enforced globally in violation of
the ELF gABI. We keep the section names generated by GCC (generally
of the form .text.<signature>) and append %<signature> to pacify as,
despite the redundancy. */
section = concat (name, "%", signature, NULL);
/* Clear SECTION_LINKONCE flag so targetm.asm_out.named_section only
emits this as a regular section. Emit section before .group
directive since Sun as treats undeclared sections as @progbits,
which conflicts with .bss* sections which are @nobits. */
targetm.asm_out.named_section (section, flags & ~SECTION_LINKONCE, decl);
/* Sun as separates declaration of a group section and of the group
itself, using the .group directive and the #comdat flag. */
fprintf (asm_out_file, "\t.group\t%s," SECTION_NAME_FORMAT ",#comdat\n",
signature, section);
/* Unlike GNU as, group signature symbols need to be defined explicitly
for Sun as. With a few exceptions, this is already the case. To
identify the missing ones without changing the affected frontents,
remember the signature symbols and emit those not marked
TREE_SYMBOL_REFERENCED in solaris_file_end. */
if (solaris_comdat_htab == NULL)
solaris_comdat_htab = htab_create_alloc (37, comdat_hash, comdat_eq, NULL,
xcalloc, free);
entry.sig = signature;
slot = (comdat_entry **) htab_find_slot (solaris_comdat_htab, &entry, INSERT);
if (*slot == NULL)
{
*slot = XCNEW (comdat_entry);
/* Remember fragmented section name. */
(*slot)->name = section;
/* Emit as regular section, .group declaration has already been done. */
(*slot)->flags = flags & ~SECTION_LINKONCE;
(*slot)->decl = decl;
(*slot)->sig = signature;
}
}
static void
insert_operand_rank (tree e, unsigned int rank)
{
void **slot;
operand_entry_t new_pair = pool_alloc (operand_entry_pool);
new_pair->op = e;
new_pair->rank = rank;
slot = htab_find_slot (operand_rank, new_pair, INSERT);
gcc_assert (*slot == NULL);
*slot = new_pair;
}
void
symtab_insert_node_to_hashtable (symtab_node node)
{
struct symtab_node_base key;
symtab_node *slot;
if (!symtab_hash)
symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
key.decl = node->symbol.decl;
slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
*slot = node;
}
tree
mf_mark (tree t)
{
void **slot;
if (marked_trees == NULL)
marked_trees = htab_create_ggc (31, htab_hash_pointer, htab_eq_pointer, NULL);
slot = htab_find_slot (marked_trees, t, INSERT);
*slot = t;
return t;
}
static operand_entry_t
find_operand_rank (tree e)
{
void **slot;
struct operand_entry vrd;
vrd.op = e;
slot = htab_find_slot (operand_rank, &vrd, NO_INSERT);
if (!slot)
return NULL;
return ((operand_entry_t) *slot);
}
static void
add_condition (const char *expr)
{
struct c_test *test;
if (expr[0] == 0)
return;
test = XNEW (struct c_test);
test->expr = expr;
*(htab_find_slot (condition_table, test, INSERT)) = test;
}
void
lto_orig_address_remove (tree t)
{
struct tree_hash_entry ent;
struct tree_hash_entry **slot;
ent.key = t;
slot
= (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, NO_INSERT);
gcc_assert (slot);
free (*slot);
htab_clear_slot (tree_htab, (PTR *)slot);
}
static void
record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
{
struct btrace_frame_cache *cache;
void **slot;
cache = this_cache;
slot = htab_find_slot (bfcache, cache, NO_INSERT);
gdb_assert (slot != NULL);
htab_remove_elt (bfcache, cache);
}
void
lto_orig_address_map (tree t, intptr_t orig_t)
{
struct tree_hash_entry ent;
struct tree_hash_entry **slot;
ent.key = t;
ent.value = orig_t;
slot
= (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, INSERT);
gcc_assert (!*slot);
*slot = XNEW (struct tree_hash_entry);
**slot = ent;
}
static void
cache_unref (struct tailcall_cache *cache)
{
gdb_assert (cache->refc > 0);
if (!--cache->refc)
{
gdb_assert (htab_find_slot (cache_htab, cache, NO_INSERT) != NULL);
htab_remove_elt (cache_htab, cache);
xfree (cache->chain);
xfree (cache);
}
}
/* Remove node from the varpool. */
void
varpool_remove_node (struct varpool_node *node)
{
void **slot;
slot = htab_find_slot (varpool_hash, node, NO_INSERT);
gcc_assert (*slot == node);
htab_clear_slot (varpool_hash, slot);
gcc_assert (!varpool_assembled_nodes_queue);
if (node->next)
node->next->prev = node->prev;
if (node->prev)
node->prev->next = node->next;
else
{
gcc_assert (varpool_nodes == node);
varpool_nodes = node->next;
}
if (varpool_first_unanalyzed_node == node)
varpool_first_unanalyzed_node = node->next_needed;
if (node->next_needed)
node->next_needed->prev_needed = node->prev_needed;
else if (node->prev_needed)
{
gcc_assert (varpool_last_needed_node);
varpool_last_needed_node = node->prev_needed;
}
if (node->prev_needed)
node->prev_needed->next_needed = node->next_needed;
else if (node->next_needed)
{
gcc_assert (varpool_nodes_queue == node);
varpool_nodes_queue = node->next_needed;
}
if (node->same_comdat_group)
{
struct varpool_node *prev;
for (prev = node->same_comdat_group;
prev->same_comdat_group != node;
prev = prev->same_comdat_group)
;
if (node->same_comdat_group == prev)
prev->same_comdat_group = NULL;
else
prev->same_comdat_group = node->same_comdat_group;
node->same_comdat_group = NULL;
}
ipa_remove_all_references (&node->ref_list);
ipa_remove_all_refering (&node->ref_list);
ggc_free (node);
}
static struct btrace_frame_cache *
bfcache_new (struct frame_info *frame)
{
struct btrace_frame_cache *cache;
void **slot;
cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
cache->frame = frame;
slot = htab_find_slot (bfcache, cache, INSERT);
gdb_assert (*slot == NULL);
*slot = cache;
return cache;
}
static void
resolve_conflicts (struct plugin_symtab *t, struct plugin_symtab *conflicts)
{
htab_t symtab = htab_create (t->nsyms, hash_sym, eq_sym, NULL);
int i;
int out;
int outlen;
outlen = t->nsyms;
conflicts->syms = xmalloc (sizeof (struct ld_plugin_symbol) * outlen);
conflicts->aux = xmalloc (sizeof (struct sym_aux) * outlen);
/* Move all duplicate symbols into the auxiliary conflicts table. */
out = 0;
for (i = 0; i < t->nsyms; i++)
{
struct ld_plugin_symbol *s = &t->syms[i];
struct sym_aux *aux = &t->aux[i];
void **slot;
slot = htab_find_slot (symtab, s, INSERT);
if (*slot != NULL)
{
int cnf;
struct ld_plugin_symbol *orig = (struct ld_plugin_symbol *)*slot;
struct sym_aux *orig_aux = &t->aux[orig - t->syms];
/* Always let the linker resolve the strongest symbol */
if (symbol_strength (orig) < symbol_strength (s))
{
SWAP (struct ld_plugin_symbol, *orig, *s);
SWAP (uint32_t, orig_aux->slot, aux->slot);
SWAP (unsigned long long, orig_aux->id, aux->id);
/* Don't swap conflict chain pointer */
}
/* Move current symbol into the conflicts table */
cnf = conflicts->nsyms++;
conflicts->syms[cnf] = *s;
conflicts->aux[cnf] = *aux;
aux = &conflicts->aux[cnf];
/* Update conflicts chain of the original symbol */
aux->next_conflict = orig_aux->next_conflict;
orig_aux->next_conflict = cnf;
continue;
}
