Improved native detection further.

[libfirm] / ir / tr / tr_inheritance.c

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index d6873b2..028a484 100644 (file)
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -56,18 +56,18 @@ static void copy_entities_from_superclass(ir_type *clss, void *env)
        ir_entity *inhent, *thisent;
        mangle_inherited_name_func *mfunc = *(mangle_inherited_name_func **)env;
 
-       for(i = 0; i < get_class_n_supertypes(clss); i++) {
+       for (i = 0; i < get_class_n_supertypes(clss); i++) {
                super = get_class_supertype(clss, i);
                assert(is_Class_type(super) && "not a class");
-               for(j = 0; j < get_class_n_members(super); j++) {
+               for (j = 0; j < get_class_n_members(super); j++) {
                        inhent = get_class_member(super, j);
                        inhenttype = get_entity_type(inhent);
                        /* check whether inhent is already overwritten */
                        overwritten = 0;
                        for (k = 0; (k < get_class_n_members(clss)) && (overwritten == 0); k++) {
                                thisent = get_class_member(clss, k);
-                               for(l = 0; l < get_entity_n_overwrites(thisent); l++) {
-                                       if(inhent == get_entity_overwrites(thisent, l)) {
+                               for (l = 0; l < get_entity_n_overwrites(thisent); l++) {
+                                       if (inhent == get_entity_overwrites(thisent, l)) {
                                                /* overwritten - do not copy */
                                                overwritten = 1;
                                                break;
@@ -163,8 +163,8 @@ static set *tr_inh_trans_set = NULL;
  */
 static int tr_inh_trans_cmp(const void *e1, const void *e2, size_t size)
 {
-       const tr_inh_trans_tp *ef1 = e1;
-       const tr_inh_trans_tp *ef2 = e2;
+       const tr_inh_trans_tp *ef1 = (const tr_inh_trans_tp*)e1;
+       const tr_inh_trans_tp *ef2 = (const tr_inh_trans_tp*)e2;
        (void) size;
 
        return ef1->kind != ef2->kind;
@@ -186,11 +186,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 = set_find(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
+       found = (tr_inh_trans_tp*)set_find(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 = set_insert(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
+               found = (tr_inh_trans_tp*)set_insert(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
        }
        return found;
 }
@@ -408,7 +408,8 @@ void free_inh_transitive_closure(void)
 {
        if (tr_inh_trans_set) {
                tr_inh_trans_tp *elt;
-               for (elt = set_first(tr_inh_trans_set); elt; elt = set_next(tr_inh_trans_set)) {
+               for (elt = (tr_inh_trans_tp*)set_first(tr_inh_trans_set); elt != NULL;
+                    elt = (tr_inh_trans_tp*)set_next(tr_inh_trans_set)) {
                        del_pset(elt->directions[d_up]);
                        del_pset(elt->directions[d_down]);
                }
@@ -423,13 +424,13 @@ void free_inh_transitive_closure(void)
 ir_type *get_class_trans_subtype_first(const ir_type *tp)
 {
        assert_valid_state();
-       return pset_first(get_type_map(tp, d_down));
+       return (ir_type*)pset_first(get_type_map(tp, d_down));
 }
 
 ir_type *get_class_trans_subtype_next(const ir_type *tp)
 {
        assert_valid_state();
-       return pset_next(get_type_map(tp, d_down));
+       return (ir_type*)pset_next(get_type_map(tp, d_down));
 }
 
 int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp)
@@ -443,13 +444,13 @@ int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp)
 ir_type *get_class_trans_supertype_first(const ir_type *tp)
 {
        assert_valid_state();
-       return pset_first(get_type_map(tp, d_up));
+       return (ir_type*)pset_first(get_type_map(tp, d_up));
 }
 
 ir_type *get_class_trans_supertype_next(const ir_type *tp)
 {
        assert_valid_state();
-       return pset_next(get_type_map(tp, d_up));
+       return (ir_type*)pset_next(get_type_map(tp, d_up));
 }
 
 /* - overwrittenby ------------------------------------------------------- */
@@ -457,13 +458,13 @@ ir_type *get_class_trans_supertype_next(const ir_type *tp)
 ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent)
 {
        assert_valid_state();
-       return pset_first(get_entity_map(ent, d_down));
+       return (ir_entity*)pset_first(get_entity_map(ent, d_down));
 }
 
 ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent)
 {
        assert_valid_state();
-       return pset_next(get_entity_map(ent, d_down));
+       return (ir_entity*)pset_next(get_entity_map(ent, d_down));
 }
 
 /* - overwrites ---------------------------------------------------------- */
@@ -473,13 +474,13 @@ ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent)
 ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent)
 {
        assert_valid_state();
-       return pset_first(get_entity_map(ent, d_up));
+       return (ir_entity*)pset_first(get_entity_map(ent, d_up));
 }
 
 ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent)
 {
        assert_valid_state();
-       return pset_next(get_entity_map(ent, d_up));
+       return (ir_entity*)pset_next(get_entity_map(ent, d_up));
 }
 
 
@@ -635,7 +636,7 @@ ir_class_cast_state get_irp_class_cast_state(void)
 const char *get_class_cast_state_string(ir_class_cast_state s)
 {
 #define X(a)    case a: return #a
-       switch(s) {
+       switch (s) {
        X(ir_class_casts_any);
        X(ir_class_casts_transitive);
        X(ir_class_casts_normalized);