/* Hash traits for symbol_compare_collection map. */
-struct symbol_compare_hashmap_traits: default_hashmap_traits
+struct symbol_compare_hash : nofree_ptr_hash <symbol_compare_collection>
{
static hashval_t
- hash (const symbol_compare_collection *v)
+ hash (value_type v)
{
inchash::hash hstate;
hstate.add_int (v->m_references.length ());
for (unsigned i = 0; i < v->m_references.length (); i++)
- hstate.add_ptr (v->m_references[i]->ultimate_alias_target ());
+ hstate.add_int (v->m_references[i]->ultimate_alias_target ()->order);
hstate.add_int (v->m_interposables.length ());
for (unsigned i = 0; i < v->m_interposables.length (); i++)
- hstate.add_ptr (v->m_interposables[i]->ultimate_alias_target ());
+ hstate.add_int (v->m_interposables[i]->ultimate_alias_target ()->order);
return hstate.end ();
}
static bool
- equal_keys (const symbol_compare_collection *a,
- const symbol_compare_collection *b)
+ equal (value_type a, value_type b)
{
if (a->m_references.length () != b->m_references.length ()
|| a->m_interposables.length () != b->m_interposables.length ())
protected:
/* Cached, once calculated hash for the item. */
- /* Accumulate to HSTATE a hash of constructor expression EXP. */
+ /* Accumulate to HSTATE a hash of expression EXP. */
static void add_expr (const_tree exp, inchash::hash &hstate);
+ /* Accumulate to HSTATE a hash of type T. */
+ static void add_type (const_tree t, inchash::hash &hstate);
+
+ /* Compare properties of symbol that does not affect semantics of symbol
+ itself but affects semantics of its references.
+ If ADDRESS is true, do extra checking needed for IPA_REF_ADDR. */
+ static bool compare_referenced_symbol_properties (symtab_node *used_by,
+ symtab_node *n1,
+ symtab_node *n2,
+ bool address);
+
+ /* Compare two attribute lists. */
+ static bool compare_attributes (const_tree list1, const_tree list2);
+
+ /* Hash properties compared by compare_referenced_symbol_properties. */
+ void hash_referenced_symbol_properties (symtab_node *ref,
+ inchash::hash &hstate,
+ bool address);
/* For a given symbol table nodes N1 and N2, we check that FUNCTION_DECLs
point to a same function. Comparison can be skipped if IGNORED_NODES
contains these nodes. ADDRESS indicate if address is taken. */
- bool compare_cgraph_references (hash_map <symtab_node *, sem_item *>
+ bool compare_symbol_references (hash_map <symtab_node *, sem_item *>
&ignored_nodes,
symtab_node *n1, symtab_node *n2,
bool address);
inline virtual void init_wpa (void)
{
- parse_tree_args ();
}
virtual void init (void);
dump_function_to_file (decl, file, TDF_DETAILS);
}
- /* Parses function arguments and result type. */
- void parse_tree_args (void);
-
/* Returns cgraph_node. */
inline cgraph_node *get_node (void)
{
semantic function item. */
static sem_function *parse (cgraph_node *node, bitmap_obstack *stack);
+ /* Perform additional checks needed to match types of used function
+ paramters. */
+ bool compatible_parm_types_p (tree, tree);
+
/* Exception handling region tree. */
eh_region region_tree;
- /* Result type tree node. */
- tree result_type;
-
- /* Array of argument tree types. */
- vec <tree> arg_types;
-
/* Number of function arguments. */
unsigned int arg_count;
/* Array of structures for all basic blocks. */
vec <ipa_icf_gimple::sem_bb *> bb_sorted;
+ /* Return true if parameter I may be used. */
+ bool param_used_p (unsigned int i);
+
private:
/* Calculates hash value based on a BASIC_BLOCK. */
hashval_t get_bb_hash (const ipa_icf_gimple::sem_bb *basic_block);
bool compare_edge_flags (cgraph_edge *e1, cgraph_edge *e2);
/* Processes function equality comparison. */
- bool equals_private (sem_item *item,
- hash_map <symtab_node *, sem_item *> &ignored_nodes);
+ bool equals_private (sem_item *item);
/* Returns true if tree T can be compared as a handled component. */
static bool icf_handled_component_p (tree t);
};
/* Congruence class set structure. */
-struct congruence_class_group_hash: typed_noop_remove <congruence_class_group>
+struct congruence_class_group_hash : nofree_ptr_hash <congruence_class_group>
{
- typedef congruence_class_group value_type;
- typedef congruence_class_group compare_type;
-
- static inline hashval_t hash (const value_type *item)
+ static inline hashval_t hash (const congruence_class_group *item)
{
return item->hash;
}
- static inline int equal (const value_type *item1, const compare_type *item2)
+ static inline int equal (const congruence_class_group *item1,
+ const congruence_class_group *item2)
{
return item1->hash == item2->hash && item1->type == item2->type;
}
congruence_class_group *get_group_by_hash (hashval_t hash,
sem_item_type type);
+ /* Because types can be arbitrarily large, avoid quadratic bottleneck. */
+ hash_map<const_tree, hashval_t> m_type_hash_cache;
private:
/* For each semantic item, append hash values of references. */