Add the return type as parameter to the macros set_find() and set_insert().

diff --git a/include/libfirm/adt/set.h b/include/libfirm/adt/set.h
index fbe840a..3208bff 100644 (file)
--- a/include/libfirm/adt/set.h
+++ b/include/libfirm/adt/set.h
@@ -203,10 +203,10 @@ FIRM_API void set_break(set *set);
 
 /* implementation specific */
 #define new_set(cmp, slots) ((new_set) ((cmp), (slots)))
-#define set_find(set, key, size, hash) \
-  _set_search ((set), (key), (size), (hash), _set_find)
-#define set_insert(set, key, size, hash) \
-  _set_search ((set), (key), (size), (hash), _set_insert)
+#define set_find(type, set, key, size, hash) \
+  ((type*)_set_search((set), 1 ? (key) : (type*)0 /* type check */, (size), (hash), _set_find))
+#define set_insert(type, set, key, size, hash) \
+  ((type*)_set_search((set), 1 ? (key) : (type*)0 /* type check */, (size), (hash), _set_insert))
 #define set_hinsert(set, key, size, hash) \
   ((set_entry *)_set_search ((set), (key), (size), (hash), _set_hinsert))
 #define set_hinsert0(set, key, size, hash) \

diff --git a/ir/adt/pmap.c b/ir/adt/pmap.c
index f2ecd28..003218b 100644 (file)
--- a/ir/adt/pmap.c
+++ b/ir/adt/pmap.c
@@ -75,19 +75,19 @@ void pmap_insert(pmap *map, const void *key, void *value)
        pmap_entry entry, *p;
 
        entry.key = key;
-       p = (pmap_entry*) set_insert(M2S(map), &entry, sizeof(pmap_entry), hash_ptr(key));
+       p = set_insert(pmap_entry, M2S(map), &entry, sizeof(pmap_entry), hash_ptr(key));
        p->value = value;
 }
 
 int pmap_contains(pmap *map, const void *key)
 {
-       return set_find(M2S(map), &key, sizeof(pmap_entry), hash_ptr(key)) != NULL;
+       return pmap_find(map, key) != NULL;
 }
 
 pmap_entry * pmap_find(pmap *map, const void *key)
 {
        pmap_entry const entry = { key, 0 };
-       return (pmap_entry*)set_find(M2S(map), &entry, sizeof(entry), hash_ptr(key));
+       return set_find(pmap_entry, M2S(map), &entry, sizeof(entry), hash_ptr(key));
 }
 
 

diff --git a/ir/adt/set.c b/ir/adt/set.c
index fbd804d..90e11d1 100644 (file)
--- a/ir/adt/set.c
+++ b/ir/adt/set.c
@@ -447,13 +447,13 @@ void pset_insert_pset_ptr(pset *target, pset *src)
 
 void *(set_find) (set *se, const void *key, size_t size, unsigned hash)
 {
-       return set_find (se, key, size, hash);
+       return set_find(void, se, key, size, hash);
 }
 
 
 void *(set_insert) (set *se, const void *key, size_t size, unsigned hash)
 {
-       return set_insert (se, key, size, hash);
+       return set_insert(void, se, key, size, hash);
 }
 
 

diff --git a/ir/ana/dfs.c b/ir/ana/dfs.c
index b10895a..d95f6a7 100644 (file)
--- a/ir/ana/dfs.c
+++ b/ir/ana/dfs.c
@@ -68,7 +68,7 @@ static dfs_edge_t *get_edge(const dfs_t *self, const void *src, const void *tgt)
        templ.tgt = tgt;
        templ.kind = (dfs_edge_kind_t) -1;
 
-       return (dfs_edge_t*) set_insert(self->edges, &templ, sizeof(templ), hash);
+       return set_insert(dfs_edge_t, self->edges, &templ, sizeof(templ), hash);
 }
 
 static void dfs_perform(dfs_t *dfs, void *n, void *anc, int level)

diff --git a/ir/ana/dfs_t.h b/ir/ana/dfs_t.h
index 7af7bef..dbc4884 100644 (file)
--- a/ir/ana/dfs_t.h
+++ b/ir/ana/dfs_t.h
@@ -70,7 +70,7 @@ static dfs_node_t *_dfs_get_node(const dfs_t *self, const void *node)
        dfs_node_t templ;
        memset(&templ, 0, sizeof(templ));
        templ.node = node;
-       return (dfs_node_t*) set_insert(self->nodes, &templ, sizeof(templ), hash_ptr(node));
+       return set_insert(dfs_node_t, self->nodes, &templ, sizeof(templ), hash_ptr(node));
 }
 
 #define _dfs_int_is_ancestor(n, m) ((m)->pre_num >= (n)->pre_num && (m)->pre_num <= (n)->max_pre_num)

diff --git a/ir/ana/execfreq.c b/ir/ana/execfreq.c
index 79688af..85bd9f2 100644 (file)
--- a/ir/ana/execfreq.c
+++ b/ir/ana/execfreq.c
@@ -94,7 +94,7 @@ static freq_t *set_find_freq(set *freqs, const ir_node *irn)
 {
        freq_t query;
        query.irn = irn;
-       return (freq_t*) set_find(freqs, &query, sizeof(query), hash_ptr(irn));
+       return set_find(freq_t, freqs, &query, sizeof(query), hash_ptr(irn));
 }
 
 static freq_t *set_insert_freq(set *freqs, const ir_node *irn)
@@ -104,7 +104,7 @@ static freq_t *set_insert_freq(set *freqs, const ir_node *irn)
        query.irn = irn;
        query.freq = 0.0;
        query.idx  = -1;
-       return (freq_t*) set_insert(freqs, &query, sizeof(query), hash_ptr(irn));
+       return set_insert(freq_t, freqs, &query, sizeof(query), hash_ptr(irn));
 }
 
 double get_block_execfreq(const ir_exec_freq *ef, const ir_node *irn)

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index 5989137..859bada 100644 (file)
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -758,13 +758,13 @@ ir_alias_relation get_alias_relation_ex(
        key.adr2  = adr2;
        key.mode1 = mode1;
        key.mode2 = mode2;
-       entry = (mem_disambig_entry*) set_find(result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
+       entry = set_find(mem_disambig_entry, result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
        if (entry != NULL)
                return entry->result;
 
        key.result = get_alias_relation(adr1, mode1, adr2, mode2);
 
-       set_insert(result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
+       set_insert(mem_disambig_entry, result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
        return key.result;
 }
 

diff --git a/ir/be/amd64/amd64_emitter.c b/ir/be/amd64/amd64_emitter.c
index e9d1383..ecabaa7 100644 (file)
--- a/ir/be/amd64/amd64_emitter.c
+++ b/ir/be/amd64/amd64_emitter.c
@@ -131,7 +131,7 @@ static void emit_amd64_SymConst(const ir_node *irn)
        key.u.id     = get_entity_ld_ident(attr->entity);
        key.is_ident = 1;
        key.label    = 0;
-       entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
+       entry = set_insert(sym_or_tv_t, sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
        if (entry->label == 0) {
                /* allocate a label */
                entry->label = get_unique_label();

diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index 0e46713..a0a702a 100644 (file)
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -261,7 +261,7 @@ static void emit_arm_SymConst(const ir_node *irn)
        key.u.entity  = attr->entity;
        key.is_entity = true;
        key.label     = 0;
-       entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
+       entry = set_insert(sym_or_tv_t, sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
        if (entry->label == 0) {
                /* allocate a label */
                entry->label = get_unique_label();
@@ -299,7 +299,7 @@ static void emit_arm_fConst(const ir_node *irn)
        key.u.tv      = get_fConst_value(irn);
        key.is_entity = false;
        key.label     = 0;
-       entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
+       entry = set_insert(sym_or_tv_t, sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
        if (entry->label == 0) {
                /* allocate a label */
                entry->label = get_unique_label();

diff --git a/ir/be/arm/arm_map_regs.c b/ir/be/arm/arm_map_regs.c
index 578a515..5a2f1ea 100644 (file)
--- a/ir/be/arm/arm_map_regs.c
+++ b/ir/be/arm/arm_map_regs.c
@@ -70,7 +70,7 @@ static arm_irn_reg_assoc *get_irn_reg_assoc(const ir_node *irn, set *reg_set)
        templ.reg = NULL;
        hash = hash_ptr(irn);
 
-       return (arm_irn_reg_assoc*)set_insert(reg_set, &templ, sizeof(templ), hash);
+       return set_insert(arm_irn_reg_assoc, reg_set, &templ, sizeof(templ), hash);
 }
 
 void arm_set_firm_reg(ir_node *irn, const arch_register_t *reg, set *reg_set)

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index f5db9fe..9543949 100644 (file)
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -185,7 +185,7 @@ static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos,
 
        hash = is_res * 128 + pos;
 
-       return (be_abi_call_arg_t*)set_find(call->params, &arg, sizeof(arg), hash);
+       return set_find(be_abi_call_arg_t, call->params, &arg, sizeof(arg), hash);
 }
 
 /**
@@ -196,11 +196,11 @@ static void remember_call_arg(be_abi_call_arg_t *arg, be_abi_call_t *call, be_ab
        unsigned hash = arg->is_res * 128 + arg->pos;
        if (context & ABI_CONTEXT_CALLEE) {
                arg->callee = 1;
-               set_insert(call->params, arg, sizeof(*arg), hash);
+               set_insert(be_abi_call_arg_t, call->params, arg, sizeof(*arg), hash);
        }
        if (context & ABI_CONTEXT_CALLER) {
                arg->callee = 0;
-               set_insert(call->params, arg, sizeof(*arg), hash);
+               set_insert(be_abi_call_arg_t, call->params, arg, sizeof(*arg), hash);
        }
 }
 

diff --git a/ir/be/becopyheur.c b/ir/be/becopyheur.c
index bd769bb..e4b7b15 100644 (file)
--- a/ir/be/becopyheur.c
+++ b/ir/be/becopyheur.c
@@ -126,7 +126,7 @@ static inline void qnode_add_conflict(const qnode_t *qn, const ir_node *n1, cons
                c.n1 = n2;
                c.n2 = n1;
        }
-       set_insert(qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c));
+       set_insert(conflict_t, qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c));
 }
 
 /**
@@ -146,7 +146,7 @@ static inline int qnode_are_conflicting(const qnode_t *qn, const ir_node *n1, co
                c.n1 = n2;
                c.n2 = n1;
        }
-       return set_find(qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c)) != 0;
+       return set_find(conflict_t, qn->conflicts, &c, sizeof(c), HASH_CONFLICT(c)) != 0;
 }
 
 static int set_cmp_node_stat_t(const void *x, const void *y, size_t size)
@@ -162,7 +162,7 @@ static inline const node_stat_t *qnode_find_node(const qnode_t *qn, ir_node *irn
 {
        node_stat_t find;
        find.irn = irn;
-       return (const node_stat_t*)set_find(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
+       return set_find(node_stat_t, qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**
@@ -175,7 +175,7 @@ static inline node_stat_t *qnode_find_or_insert_node(const qnode_t *qn, ir_node
        find.irn = irn;
        find.new_color = NO_COLOR;
        find.pinned_local = 0;
-       return (node_stat_t*)set_insert(qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
+       return set_insert(node_stat_t, qn->changed_nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 /**

diff --git a/ir/be/becopyilp2.c b/ir/be/becopyilp2.c
index 17b9262..b4c5213 100644 (file)
--- a/ir/be/becopyilp2.c
+++ b/ir/be/becopyilp2.c
@@ -312,7 +312,7 @@ static inline edge_t *add_edge(set *edges, ir_node *n1, ir_node *n2, size_t *cou
                new_edge.n2 = n1;
        }
        (*counter)++;
-       return (edge_t*)set_insert(edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
+       return set_insert(edge_t, edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
 }
 
 static inline edge_t *find_edge(set *edges, ir_node *n1, ir_node *n2)
@@ -326,7 +326,7 @@ static inline edge_t *find_edge(set *edges, ir_node *n1, ir_node *n2)
                new_edge.n1 = n2;
                new_edge.n2 = n1;
        }
-       return (edge_t*)set_find(edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
+       return set_find(edge_t, edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
 }
 
 static inline void remove_edge(set *edges, ir_node *n1, ir_node *n2, size_t *counter)
@@ -340,7 +340,7 @@ static inline void remove_edge(set *edges, ir_node *n1, ir_node *n2, size_t *cou
                new_edge.n1 = n2;
                new_edge.n2 = n1;
        }
-       e = (edge_t*)set_find(edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
+       e = set_find(edge_t, edges, &new_edge, sizeof(new_edge), HASH_EDGE(&new_edge));
        if (e) {
                e->n1 = NULL;
                e->n2 = NULL;

diff --git a/ir/be/becopyopt.c b/ir/be/becopyopt.c
index acc6402..9941915 100644 (file)
--- a/ir/be/becopyopt.c
+++ b/ir/be/becopyopt.c
@@ -787,7 +787,7 @@ static void add_edge(copy_opt_t *co, ir_node *n1, ir_node *n2, int costs)
        new_node.irn        = n1;
        new_node.degree     = 0;
        new_node.neighbours = NULL;
-       node = (affinity_node_t*)set_insert(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
+       node = set_insert(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
 
        for (nbr = node->neighbours; nbr; nbr = nbr->next)
                if (nbr->irn == n2) {
@@ -878,7 +878,7 @@ int co_gs_is_optimizable(copy_opt_t *co, ir_node *irn)
        ASSERT_GS_AVAIL(co);
 
        new_node.irn = irn;
-       n = (affinity_node_t*)set_find(co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
+       n = set_find(affinity_node_t, co->nodes, &new_node, sizeof(new_node), hash_irn(new_node.irn));
        if (n) {
                return (n->degree > 0);
        } else

diff --git a/ir/be/becopyopt_t.h b/ir/be/becopyopt_t.h
index b5bf032..e32ae71 100644 (file)
--- a/ir/be/becopyopt_t.h
+++ b/ir/be/becopyopt_t.h
@@ -146,7 +146,7 @@ static inline affinity_node_t *get_affinity_info(const copy_opt_t *co, const ir_
        ASSERT_GS_AVAIL(co);
 
        find.irn = irn;
-       return (affinity_node_t*)set_find(co->nodes, &find, sizeof(find), hash_irn(irn));
+       return set_find(affinity_node_t, co->nodes, &find, sizeof(find), hash_irn(irn));
 }
 
 #define co_gs_foreach_aff_node(co, aff_node)     foreach_set((co)->nodes, affinity_node_t, (aff_node))

diff --git a/ir/be/beloopana.c b/ir/be/beloopana.c
index 9d2f812..815b190 100644 (file)
--- a/ir/be/beloopana.c
+++ b/ir/be/beloopana.c
@@ -141,7 +141,7 @@ static unsigned be_compute_loop_pressure(be_loopana_t *loop_ana, ir_loop *loop,
        key.loop            = loop;
        key.cls             = cls;
        key.max_pressure    = 0;
-       entry               = (be_loop_info_t*)set_insert(loop_ana->data, &key, sizeof(key), HASH_LOOP_INFO(&key));
+       entry               = set_insert(be_loop_info_t, loop_ana->data, &key, sizeof(key), HASH_LOOP_INFO(&key));
        entry->max_pressure = MAX(entry->max_pressure, pressure);
 
        return pressure;
@@ -218,7 +218,7 @@ unsigned be_get_loop_pressure(be_loopana_t *loop_ana, const arch_register_class_
 
        key.loop = loop;
        key.cls  = cls;
-       entry    = (be_loop_info_t*)set_find(loop_ana->data, &key, sizeof(key), HASH_LOOP_INFO(&key));
+       entry    = set_find(be_loop_info_t, loop_ana->data, &key, sizeof(key), HASH_LOOP_INFO(&key));
 
        if (entry)
                pressure = entry->max_pressure;

diff --git a/ir/be/bespillslots.c b/ir/be/bespillslots.c
index 66e6f55..7dfcbac 100644 (file)
--- a/ir/be/bespillslots.c
+++ b/ir/be/bespillslots.c
@@ -460,12 +460,12 @@ static memperm_t *get_memperm(be_fec_env_t *env, ir_node *block)
        entry.block = block;
        hash        = hash_irn(block);
 
-       res = (memperm_t*)set_find(env->memperms, &entry, sizeof(entry), hash);
+       res = set_find(memperm_t, env->memperms, &entry, sizeof(entry), hash);
 
        if (res == NULL) {
                entry.entrycount = 0;
                entry.entries = NULL;
-               res = (memperm_t*)set_insert(env->memperms, &entry, sizeof(entry), hash);
+               res = set_insert(memperm_t, env->memperms, &entry, sizeof(entry), hash);
        }
 
        return res;

diff --git a/ir/be/bespillutil.c b/ir/be/bespillutil.c
index 8d32962..ce3b138 100644 (file)
--- a/ir/be/bespillutil.c
+++ b/ir/be/bespillutil.c
@@ -135,7 +135,7 @@ static spill_info_t *get_spillinfo(const spill_env_t *env, ir_node *value)
        int hash = hash_irn(value);
 
        info.to_spill = value;
-       res = (spill_info_t*)set_find(env->spills, &info, sizeof(info), hash);
+       res = set_find(spill_info_t, env->spills, &info, sizeof(info), hash);
 
        if (res == NULL) {
                info.reloaders   = NULL;
@@ -143,7 +143,7 @@ static spill_info_t *get_spillinfo(const spill_env_t *env, ir_node *value)
                info.spill_costs = -1;
                info.reload_cls  = NULL;
                info.spilled_phi = false;
-               res = (spill_info_t*)set_insert(env->spills, &info, sizeof(info), hash);
+               res = set_insert(spill_info_t, env->spills, &info, sizeof(info), hash);
        }
 
        return res;

diff --git a/ir/be/bessadestr.c b/ir/be/bessadestr.c
index 532dc73..2a21667 100644 (file)
--- a/ir/be/bessadestr.c
+++ b/ir/be/bessadestr.c
@@ -130,7 +130,7 @@ static void insert_all_perms_walker(ir_node *bl, void *data)
 
                        hash = hash_irn(arg);
                        templ.arg  = arg;
-                       pp         = (perm_proj_t*)set_find(arg_set, &templ, sizeof(templ), hash);
+                       pp         = set_find(perm_proj_t, arg_set, &templ, sizeof(templ), hash);
 
                        /*
                         * If a proj_perm_t entry has not been made in the argument set,
@@ -141,7 +141,7 @@ static void insert_all_perms_walker(ir_node *bl, void *data)
                         */
                        if (!pp && !be_is_live_in(lv, bl, arg)) {
                                templ.pos = n_projs++;
-                               set_insert(arg_set, &templ, sizeof(templ), hash);
+                               set_insert(perm_proj_t, arg_set, &templ, sizeof(templ), hash);
                        }
                }
 
@@ -188,7 +188,7 @@ static void insert_all_perms_walker(ir_node *bl, void *data)
                                perm_proj_t templ;
 
                                templ.arg = get_irn_n(phi, i);
-                               pp        = (perm_proj_t*)set_find(arg_set, &templ, sizeof(templ), hash_irn(templ.arg));
+                               pp        = set_find(perm_proj_t, arg_set, &templ, sizeof(templ), hash_irn(templ.arg));
 
                                /* If not found, it was an interfering argument */
                                if (pp) {

diff --git a/ir/be/beuses.c b/ir/be/beuses.c
index 87be078..41cd744 100644 (file)
--- a/ir/be/beuses.c
+++ b/ir/be/beuses.c
@@ -104,7 +104,7 @@ static const be_use_t *get_or_set_use_block(be_uses_t *env,
 
        temp.block = block;
        temp.node = def;
-       result = (be_use_t*)set_find(env->uses, &temp, sizeof(temp), hash);
+       result = set_find(be_use_t, env->uses, &temp, sizeof(temp), hash);
 
        if (result == NULL) {
                // insert templ first as we might end in a loop in the get_next_use
@@ -112,7 +112,7 @@ static const be_use_t *get_or_set_use_block(be_uses_t *env,
                temp.next_use = USES_INFINITY;
                temp.outermost_loop = UNKNOWN_OUTERMOST_LOOP;
                temp.visited = 0;
-               result = (be_use_t*)set_insert(env->uses, &temp, sizeof(temp), hash);
+               result = set_insert(be_use_t, env->uses, &temp, sizeof(temp), hash);
        }
 
        if (result->outermost_loop == UNKNOWN_OUTERMOST_LOOP && result->visited < env->visited_counter) {

diff --git a/ir/be/beverify.c b/ir/be/beverify.c
index 6fd9c62..ba652aa 100644 (file)
--- a/ir/be/beverify.c
+++ b/ir/be/beverify.c
@@ -346,7 +346,7 @@ static spill_t *find_spill(be_verify_spillslots_env_t *env, ir_node *node)
        spill_t spill;
 
        spill.spill = node;
-       return (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash_ptr(node));
+       return set_find(spill_t, env->spills, &spill, sizeof(spill), hash_ptr(node));
 }
 
 static spill_t *get_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_entity *ent)
@@ -355,11 +355,11 @@ static spill_t *get_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_ent
        int hash = hash_ptr(node);
 
        spill.spill = node;
-       res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
+       res = set_find(spill_t, env->spills, &spill, sizeof(spill), hash);
 
        if (res == NULL) {
                spill.ent = ent;
-               res = (spill_t*)set_insert(env->spills, &spill, sizeof(spill), hash);
+               res = set_insert(spill_t, env->spills, &spill, sizeof(spill), hash);
        }
 
        return res;
@@ -428,13 +428,13 @@ static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_n
        }
 
        spill.spill = node;
-       res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
+       res = set_find(spill_t, env->spills, &spill, sizeof(spill), hash);
        if (res != NULL) {
                return;
        }
 
        spill.ent = spillent;
-       res = (spill_t*)set_insert(env->spills, &spill, sizeof(spill), hash);
+       res = set_insert(spill_t, env->spills, &spill, sizeof(spill), hash);
 
        for (i = 0, arity = be_get_MemPerm_entity_arity(memperm); i < arity; ++i) {
                ir_node* arg = get_irn_n(memperm, i + 1);
@@ -453,13 +453,13 @@ static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_no
        assert(is_Phi(node));
 
        spill.spill = node;
-       res = (spill_t*)set_find(env->spills, &spill, sizeof(spill), hash);
+       res = set_find(spill_t, env->spills, &spill, sizeof(spill), hash);
        if (res != NULL) {
                return;
        }
 
        spill.ent = ent;
-       res = (spill_t*)set_insert(env->spills, &spill, sizeof(spill), hash);
+       res = set_insert(spill_t, env->spills, &spill, sizeof(spill), hash);
 
        /* is 1 of the arguments a spill? */
        for (i = 0, arity = get_irn_arity(node); i < arity; ++i) {

diff --git a/ir/common/debug.c b/ir/common/debug.c
index 528d5c1..bff1310 100644 (file)
--- a/ir/common/debug.c
+++ b/ir/common/debug.c
@@ -80,7 +80,7 @@ firm_dbg_module_t *firm_dbg_register(const char *name)
   if (!module_set)
     firm_dbg_init();
 
-  return (firm_dbg_module_t*)set_insert(module_set, &mod, sizeof(mod), hash_str(name));
+  return set_insert(firm_dbg_module_t, module_set, &mod, sizeof(mod), hash_str(name));
 }
 
 void firm_dbg_set_mask(firm_dbg_module_t *module, unsigned mask)

diff --git a/ir/debug/debugger.c b/ir/debug/debugger.c
index fb60822..456ccc7 100644 (file)
--- a/ir/debug/debugger.c
+++ b/ir/debug/debugger.c
@@ -243,7 +243,7 @@ static void dbg_new_node(void *ctx, ir_graph *irg, ir_node *node)
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_NEW_THING;
 
-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F created\n", elem->bp.bpnr, node);
                firm_debug_break();
@@ -265,7 +265,7 @@ static void dbg_replace(void *ctx, ir_node *old, ir_node *nw)
        key.nr        = get_irn_node_nr(old);
        key.bp.reason = BP_ON_REPLACE;
 
-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be replaced by %+F\n", elem->bp.bpnr, old, nw);
                firm_debug_break();
@@ -286,7 +286,7 @@ static void dbg_lower(void *ctx, ir_node *node)
        key.nr        = get_irn_node_nr(node);
        key.bp.reason = BP_ON_LOWER;
 
-       elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
        if (elem && elem->bp.active) {
                dbg_printf("Firm BP %u reached, %+F will be lowered\n", elem->bp.bpnr, node);
                firm_debug_break();
@@ -307,7 +307,7 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.nr        = get_irg_graph_nr(irg);
                key.bp.reason = BP_ON_REMIRG;
 
-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, irg);
                        firm_debug_break();
@@ -323,7 +323,7 @@ static void dbg_free_graph(void *ctx, ir_graph *irg)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_REMIRG;
 
-               elem = (bp_ident_t*)set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = set_find(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, ent);
                        firm_debug_break();
@@ -346,7 +346,7 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                key.id        = get_entity_ident(ent);
                key.bp.reason = BP_ON_NEW_ENT;
 
-               elem = (bp_ident_t*)set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+               elem = set_find(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();
@@ -358,7 +358,7 @@ static void dbg_new_entity(void *ctx, ir_entity *ent)
                key.nr        = get_entity_nr(ent);
                key.bp.reason = BP_ON_NEW_THING;
 
-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
                if (elem && elem->bp.active) {
                        dbg_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
                        firm_debug_break();
@@ -381,7 +381,7 @@ static void dbg_new_type(void *ctx, ir_type *tp)
                key.nr        = get_type_nr(tp);
                key.bp.reason = BP_ON_NEW_THING;
 
-               elem = (bp_nr_t*)set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+               elem = set_find(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
                if (elem && elem->bp.active) {
                        ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, tp);
                        firm_debug_break();
@@ -497,7 +497,7 @@ static void break_on_nr(long nr, bp_reasons_t reason)
        key.bp.reason = reason;
        key.nr        = nr;
 
-       elem = (bp_nr_t*)set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
+       elem = set_insert(bp_nr_t, bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 
        if (elem->bp.bpnr == 0) {
                /* new break point */
@@ -524,7 +524,7 @@ static void break_on_ident(const char *name, bp_reasons_t reason)
        key.bp.reason = reason;
        key.id        = new_id_from_str(name);
 
-       elem = (bp_ident_t*)set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
+       elem = set_insert(bp_ident_t, bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 
        if (elem->bp.bpnr == 0) {
                /* new break point */

diff --git a/ir/ir/irio.c b/ir/ir/irio.c
index a61b080..3c9b505 100644 (file)
--- a/ir/ir/irio.c
+++ b/ir/ir/irio.c
@@ -199,7 +199,7 @@ static void symtbl_init(void)
        key.str = (s);                                               \
        key.typetag = (tt);                                          \
        key.code = (cod);                                            \
-       set_insert(symtbl, &key, sizeof(key), hash_str(s) + tt * 17)
+       set_insert(symbol_t, symtbl, &key, sizeof(key), hash_str(s) + tt * 17)
 
 #define INSERTENUM(tt, e) INSERT(tt, #e, e)
 #define INSERTKEYWORD(k) INSERT(tt_keyword, #k, kw_##k)
@@ -360,7 +360,7 @@ static unsigned symbol(const char *str, typetag_t typetag)
        key.str = str;
        key.typetag = typetag;
 
-       entry = (symbol_t*)set_find(symtbl, &key, sizeof(key), hash_str(str) + typetag * 17);
+       entry = set_find(symbol_t, symtbl, &key, sizeof(key), hash_str(str) + typetag * 17);
        return entry ? entry->code : SYMERROR;
 }
 
@@ -1454,7 +1454,7 @@ static void *get_id(read_env_t *env, long id)
        id_entry key, *entry;
        key.id = id;
 
-       entry = (id_entry*)set_find(env->idset, &key, sizeof(key), (unsigned) id);
+       entry = set_find(id_entry, env->idset, &key, sizeof(key), (unsigned) id);
        return entry ? entry->elem : NULL;
 }
 
@@ -1463,7 +1463,7 @@ static void set_id(read_env_t *env, long id, void *elem)
        id_entry key;
        key.id = id;
        key.elem = elem;
-       set_insert(env->idset, &key, sizeof(key), (unsigned) id);
+       set_insert(id_entry, env->idset, &key, sizeof(key), (unsigned) id);
 }
 
 static ir_node *get_node_or_null(read_env_t *env, long nodenr)

diff --git a/ir/ir/irprofile.c b/ir/ir/irprofile.c
index b1cc72a..1f059e2 100644 (file)
--- a/ir/ir/irprofile.c
+++ b/ir/ir/irprofile.c
@@ -557,7 +557,7 @@ static void block_associate_walker(ir_node *bb, void *env)
        query.count = b->counters[(b->i)++];
        DBG((dbg, LEVEL_4, "execcount(%+F, %u): %u\n", bb, query.block,
            query.count));
-       set_insert(profile, &query, sizeof(query), query.block);
+       set_insert(execcount_t, profile, &query, sizeof(query), query.block);
 }
 
 static void irp_associate_blocks(block_assoc_t *env)
@@ -617,7 +617,7 @@ unsigned int ir_profile_get_block_execcount(const ir_node *block)
                return 1;
 
        query.block = get_irn_node_nr(block);
-       ec = (execcount_t*)set_find(profile, &query, sizeof(query), query.block);
+       ec = set_find(execcount_t, profile, &query, sizeof(query), query.block);
 
        if (ec != NULL) {
                return ec->count;

diff --git a/ir/libcore/lc_printf.c b/ir/libcore/lc_printf.c
index 402d271..416fc66 100644 (file)
--- a/ir/libcore/lc_printf.c
+++ b/ir/libcore/lc_printf.c
@@ -113,7 +113,7 @@ int lc_arg_register(lc_arg_env_t *env, const char *name, char letter, const lc_a
                base = 'a';
        }
 
-       ent = (lc_arg_t*)set_insert(env->args, &arg, sizeof(arg), hash_str(name));
+       ent = set_insert(lc_arg_t, env->args, &arg, sizeof(arg), hash_str(name));
 
        if (ent && base != 0)
                map[letter - base] = ent;
@@ -438,7 +438,7 @@ int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt,
                                                name[n] = '\0';
                                                tmp.name = name;
 
-                                               arg = (lc_arg_t*)set_find(env->args, &tmp, sizeof(tmp), hash_str(named));
+                                               arg = set_find(lc_arg_t, env->args, &tmp, sizeof(tmp), hash_str(named));
                                                occ.modifier = "";
                                                occ.modifier_length = 0;
 

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index a2fbd99..f880211 100644 (file)
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -141,7 +141,7 @@ static ir_type *get_conv_type(ir_mode *imode, ir_mode *omode)
        key.omode = omode;
        key.mtd   = NULL;
 
-       entry = (conv_tp_entry_t*)set_insert(conv_types, &key, sizeof(key), hash_ptr(imode) ^ hash_ptr(omode));
+       entry = set_insert(conv_tp_entry_t, conv_types, &key, sizeof(key), hash_ptr(imode) ^ hash_ptr(omode));
        if (! entry->mtd) {
                int n_param = 1, n_res = 1;
 
@@ -513,7 +513,7 @@ static ir_node *get_intrinsic_address(ir_type *method, ir_op *op,
        key.omode = omode;
        key.ent   = NULL;
 
-       entry = (op_mode_entry_t*)set_insert(intrinsic_fkt, &key, sizeof(key),
+       entry = set_insert(op_mode_entry_t, intrinsic_fkt, &key, sizeof(key),
                                hash_ptr(op) ^ hash_ptr(imode) ^ (hash_ptr(omode) << 8));
        if (! entry->ent) {
                /* create a new one */

diff --git a/ir/lpp/lpp.c b/ir/lpp/lpp.c
index d6f0a77..85b3093 100644 (file)
--- a/ir/lpp/lpp.c
+++ b/ir/lpp/lpp.c
@@ -140,8 +140,7 @@ static int name2nr(set *where, const char *name)
 {
        lpp_name_t find, *found;
        find.name = name;
-       found
-               = (lpp_name_t*)set_find(where, &find, sizeof(find), HASH_NAME_T(&find));
+       found = set_find(lpp_name_t, where, &find, sizeof(find), HASH_NAME_T(&find));
        return (found ? found->nr : -1);
 }
 
@@ -177,7 +176,7 @@ int lpp_add_cst(lpp_t *lpp, const char *cst_name, lpp_cst_t cst_type, double rhs
                n.name = get_next_name(lpp);
 
        n.nr  = -1;
-       inner = (lpp_name_t*)set_insert(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
+       inner = set_insert(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
        assert(inner);
 
        if (inner->nr == -1) {
@@ -207,7 +206,7 @@ int lpp_add_cst_uniq(lpp_t *lpp, const char *cst_name, lpp_cst_t cst_type, doubl
 
                n.name = cst_name;
                n.nr   = -1;
-               assert(!set_find(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
+               assert(!set_find(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
                    "constraint already exists");
        }
        return lpp_add_cst(lpp, cst_name, cst_type, rhs);
@@ -252,7 +251,7 @@ int lpp_add_var(lpp_t *lpp, const char *var_name, lpp_var_t var_type, double obj
                n.name = get_next_name(lpp);
 
        n.nr  = -1;
-       inner = (lpp_name_t*)set_insert(lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
+       inner = set_insert(lpp_name_t, lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
        assert(inner);
 
        if (inner->nr == -1) {
@@ -538,7 +537,7 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                        name.name = buf;
                }
 
-               res = (lpp_name_t*)set_insert(lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
+               res = set_insert(lpp_name_t, lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
                lpp->csts[name.nr] = res;
        }
 
@@ -557,7 +556,7 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                        name.name = buf;
                }
 
-               res = (lpp_name_t*)set_insert(lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
+               res = set_insert(lpp_name_t, lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
                lpp->vars[name.nr] = res;
        }
 

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index df59ba0..2d775eb 100644 (file)
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -543,7 +543,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id)
        key.id   = id;
        key.list = NULL;
        key.next = NULL;
-       entry = (listmap_entry_t*)set_insert(map->map, &key, sizeof(key), hash_ptr(id));
+       entry = set_insert(listmap_entry_t, map->map, &key, sizeof(key), hash_ptr(id));
 
        if (entry->list == NULL) {
                /* a new entry, put into the list */
@@ -1702,7 +1702,7 @@ static void *lambda_opcode(const node_t *node, environment_t *env)
 
        key.irn = node->node;
 
-       entry = (opcode_key_t*)set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
+       entry = set_insert(opcode_key_t, env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
        return entry;
 }  /* lambda_opcode */
 

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index 64df7f7..3667f26 100644 (file)
--- a/ir/opt/ldstopt.c
+++ b/ir/opt/ldstopt.c
@@ -1740,13 +1740,13 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env)
 
                                        entry.ptr  = ptr;
                                        entry.mode = load_mode;
-                                       res = (avail_entry_t*)set_find(avail, &entry, sizeof(entry), hash_cache_entry(&entry));
+                                       res = set_find(avail_entry_t, avail, &entry, sizeof(entry), hash_cache_entry(&entry));
                                        if (res != NULL) {
                                                irn = res->load;
                                        } else {
                                                irn = new_rd_Load(db, pred, get_Phi_pred(phi, pos), ptr, load_mode, cons_none);
                                                entry.load = irn;
-                                               set_insert(avail, &entry, sizeof(entry), hash_cache_entry(&entry));
+                                               set_insert(avail_entry_t, avail, &entry, sizeof(entry), hash_cache_entry(&entry));
                                                DB((dbg, LEVEL_1, "  Created %+F in %+F\n", irn, pred));
                                        }
                                        pe->load = irn;

diff --git a/ir/opt/opt_blocks.c b/ir/opt/opt_blocks.c
index 0f49d71..1161337 100644 (file)
--- a/ir/opt/opt_blocks.c
+++ b/ir/opt/opt_blocks.c
@@ -241,7 +241,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id)
        key.id   = id;
        key.list = NULL;
        key.next = NULL;
-       entry    = (listmap_entry_t*)set_insert(map->map, &key, sizeof(key), hash_ptr(id));
+       entry    = set_insert(listmap_entry_t, map->map, &key, sizeof(key), hash_ptr(id));
 
        if (entry->list == NULL) {
                /* a new entry, put into the list */
@@ -438,7 +438,7 @@ static opcode_key_t *opcode(const node_t *node, environment_t *env)
                break;
        }
 
-       entry = (opcode_key_t*)set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
+       entry = set_insert(opcode_key_t, env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
        return entry;
 }  /* opcode */
 

diff --git a/ir/opt/opt_osr.c b/ir/opt/opt_osr.c
index 4463226..53b5535 100644 (file)
--- a/ir/opt/opt_osr.c
+++ b/ir/opt/opt_osr.c
@@ -139,7 +139,7 @@ static LFTR_edge *LFTR_find(ir_node *src, iv_env *env)
 
        key.src  = src;
 
-       return (LFTR_edge*)set_find(env->lftr_edges, &key, sizeof(key), hash_ptr(src));
+       return set_find(LFTR_edge, env->lftr_edges, &key, sizeof(key), hash_ptr(src));
 }  /* LFTR_find */
 
 /**
@@ -164,7 +164,7 @@ static void LFTR_add(ir_node *src, ir_node *dst, unsigned code, ir_node *rc, iv_
         * There might be more than one edge here. This is rather bad
         * because we currently store only one.
         */
-       set_insert(env->lftr_edges, &key, sizeof(key), hash_ptr(src));
+       set_insert(LFTR_edge, env->lftr_edges, &key, sizeof(key), hash_ptr(src));
 }  /* LFTR_add */
 
 /**
@@ -253,8 +253,7 @@ static ir_node *search(unsigned code, ir_node *op1, ir_node *op2, iv_env *env)
        key.op1 = op1;
        key.op2 = op2;
 
-       entry = (quadruple_t*)set_find(env->quad_map, &key, sizeof(key),
-                                      (code * 9) ^ hash_ptr(op1) ^hash_ptr(op2));
+       entry = set_find(quadruple_t, env->quad_map, &key, sizeof(key), (code * 9) ^ hash_ptr(op1) ^ hash_ptr(op2));
        if (entry)
                return entry->res;
        return NULL;
@@ -278,8 +277,7 @@ static void add(unsigned code, ir_node *op1, ir_node *op2, ir_node *result, iv_e
        key.op2  = op2;
        key.res  = result;
 
-       set_insert(env->quad_map, &key, sizeof(key),
-                  (code * 9) ^ hash_ptr(op1) ^hash_ptr(op2));
+       set_insert(quadruple_t, env->quad_map, &key, sizeof(key), (code * 9) ^ hash_ptr(op1) ^ hash_ptr(op2));
 }  /* add */
 
 /**

diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c
index d3536f1..556251a 100644 (file)
--- a/ir/opt/scalar_replace.c
+++ b/ir/opt/scalar_replace.c
@@ -497,7 +497,7 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum
                pset_insert_ptr(sels, sel);
 
                key  = find_path(sel, 0);
-               path = (path_t*)set_find(pathes, key, path_size(key), path_hash(key));
+               path = set_find(path_t, pathes, key, path_size(key), path_hash(key));
 
                if (path) {
                        set_vnum(sel, path->vnum);
@@ -505,7 +505,7 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum
                } else {
                        key->vnum = vnum++;
 
-                       set_insert(pathes, key, path_size(key), path_hash(key));
+                       set_insert(path_t, pathes, key, path_size(key), path_hash(key));
 
                        set_vnum(sel, key->vnum);
                        DB((dbg, SET_LEVEL_3, "  %+F represents value %u\n", sel, key->vnum));
@@ -725,7 +725,7 @@ void scalar_replacement_opt(ir_graph *irg)
                                ent_type = get_entity_type(ent);
 
                                key.ent       = ent;
-                               set_insert(set_ent, &key, sizeof(key), hash_ptr(key.ent));
+                               set_insert(scalars_t, set_ent, &key, sizeof(key), hash_ptr(key.ent));
 
 #ifdef DEBUG_libfirm
                                if (is_Array_type(ent_type)) {

diff --git a/ir/stat/firmstat.c b/ir/stat/firmstat.c
index 949d513..897f2a4 100644 (file)
--- a/ir/stat/firmstat.c
+++ b/ir/stat/firmstat.c
@@ -962,7 +962,7 @@ static void update_node_stat_2(ir_node *node, void *env)
 static unsigned get_adr_mark(graph_entry_t *graph, ir_node *node)
 {
        address_mark_entry_t const val = { node, 0 };
-       address_mark_entry_t *value = (address_mark_entry_t*)set_find(graph->address_mark, &val, sizeof(val), hash_ptr(node));
+       address_mark_entry_t *value = set_find(address_mark_entry_t, graph->address_mark, &val, sizeof(val), hash_ptr(node));
 
        return value ? value->mark : 0;
 }  /* get_adr_mark */
@@ -973,7 +973,7 @@ static unsigned get_adr_mark(graph_entry_t *graph, ir_node *node)
 static void set_adr_mark(graph_entry_t *graph, ir_node *node, unsigned val)
 {
        address_mark_entry_t const value = { node, val };
-       set_insert(graph->address_mark, &value, sizeof(value), hash_ptr(node));
+       set_insert(address_mark_entry_t, graph->address_mark, &value, sizeof(value), hash_ptr(node));
 }  /* set_adr_mark */
 
 #undef DUMP_ADR_MODE

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index 6bdcb44..529bb6d 100644 (file)
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -181,11 +181,11 @@ static tr_inh_trans_tp *get_firm_kind_entry(const firm_kind *k)
 
        if (!tr_inh_trans_set) tr_inh_trans_set = new_set(tr_inh_trans_cmp, 128);
 
-       found = (tr_inh_trans_tp*)set_find(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
+       found = set_find(tr_inh_trans_tp, tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
        if (!found) {
                a.directions[d_up]   = pset_new_ptr(16);
                a.directions[d_down] = pset_new_ptr(16);
-               found = (tr_inh_trans_tp*)set_insert(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
+               found = set_insert(tr_inh_trans_tp, tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
        }
        return found;
 }

diff --git a/ir/tv/tv.c b/ir/tv/tv.c
index d926aea..3c0c995 100644 (file)
--- a/ir/tv/tv.c
+++ b/ir/tv/tv.c
@@ -77,11 +77,11 @@ static float_to_int_mode current_float_to_int_mode = TRUNCATE;
 #  define TARVAL_VERIFY(a) ((void)0)
 #endif
 
-#define INSERT_TARVAL(tv) ((ir_tarval*)set_insert(tarvals, (tv), sizeof(ir_tarval), hash_tv((tv))))
-#define FIND_TARVAL(tv) ((ir_tarval*)set_find(tarvals, (tv), sizeof(ir_tarval), hash_tv((tv))))
+#define INSERT_TARVAL(tv) (set_insert(ir_tarval, tarvals, (tv), sizeof(ir_tarval), hash_tv((tv))))
+#define FIND_TARVAL(tv) (set_find(ir_tarval, tarvals, (tv), sizeof(ir_tarval), hash_tv((tv))))
 
-#define INSERT_VALUE(val, size) (set_insert(values, (val), size, hash_val((val), size)))
-#define FIND_VALUE(val, size) (set_find(values, (val), size, hash_val((val), size)))
+#define INSERT_VALUE(val, size) (set_insert(char, values, (val), size, hash_val((val), size)))
+#define FIND_VALUE(val, size) (set_find(char, values, (val), size, hash_val((val), size)))
 
 #define fail_verify(a) _fail_verify((a), __FILE__, __LINE__)
 
@@ -199,7 +199,7 @@ static ir_tarval *get_tarval(const void *value, size_t length, ir_mode *mode)
        }
        /* if there is such a tarval, it is returned, else tv is copied
         * into the set */
-       return (ir_tarval *)INSERT_TARVAL(&tv);
+       return INSERT_TARVAL(&tv);
 }
 
 /**