mark outs as inconsistent when end node is changed

[libfirm] / ir / tr / entity.c

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 72231c6..0051f86 100644 (file)
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -105,7 +105,7 @@ ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
                res->attr.code_attr.label = (ir_label_t) -1;
        }
 
-       /* Remember entity in it's owner. */
+       /* Remember entity in its owner. */
        if (owner != NULL)
                add_compound_member(owner, res);
 
@@ -301,6 +301,11 @@ const char *(get_entity_ld_name)(const ir_entity *ent)
        return _get_entity_ld_name(ent);
 }
 
+int entity_has_ld_ident(const ir_entity *entity)
+{
+       return entity->ld_name != NULL;
+}
+
 ir_type *(get_entity_type)(const ir_entity *ent)
 {
        return _get_entity_type(ent);
@@ -391,7 +396,7 @@ void set_entity_visibility(ir_entity *entity, ir_visibility visibility)
 
 ir_visibility get_entity_visibility(const ir_entity *entity)
 {
-       return entity->visibility;
+       return (ir_visibility)entity->visibility;
 }
 
 void set_entity_linkage(ir_entity *entity, ir_linkage linkage)
@@ -454,7 +459,7 @@ ir_node *get_atomic_ent_value(ir_entity *entity)
                return new_r_Const(get_const_code_irg(), get_mode_null(mode));
        }
        case IR_INITIALIZER_TARVAL: {
-               tarval *tv = get_initializer_tarval_value(initializer);
+               ir_tarval *tv = get_initializer_tarval_value(initializer);
                return new_r_Const(get_const_code_irg(), tv);
        }
        case IR_INITIALIZER_CONST:
@@ -598,34 +603,36 @@ ir_initializer_t *create_initializer_const(ir_node *value)
        struct obstack *obst = get_irg_obstack(get_const_code_irg());
 
        ir_initializer_t *initializer
-               = obstack_alloc(obst, sizeof(ir_initializer_const_t));
+               = (ir_initializer_t*)OALLOC(obst, ir_initializer_const_t);
        initializer->kind         = IR_INITIALIZER_CONST;
        initializer->consti.value = value;
 
        return initializer;
 }
 
-ir_initializer_t *create_initializer_tarval(tarval *tv)
+ir_initializer_t *create_initializer_tarval(ir_tarval *tv)
 {
        struct obstack *obst = get_irg_obstack(get_const_code_irg());
 
        ir_initializer_t *initializer
-               = obstack_alloc(obst, sizeof(ir_initializer_tarval_t));
+               = (ir_initializer_t*)OALLOC(obst, ir_initializer_tarval_t);
        initializer->kind         = IR_INITIALIZER_TARVAL;
        initializer->tarval.value = tv;
 
        return initializer;
 }
 
-ir_initializer_t *create_initializer_compound(unsigned n_entries)
+ir_initializer_t *create_initializer_compound(size_t n_entries)
 {
        struct obstack *obst = get_irg_obstack(get_const_code_irg());
 
        size_t i;
        size_t size  = sizeof(ir_initializer_compound_t)
-                    + (n_entries-1) * sizeof(ir_initializer_t*);
+                    + n_entries * sizeof(ir_initializer_t*)
+                    - sizeof(ir_initializer_t*);
 
-       ir_initializer_t *initializer = obstack_alloc(obst, size);
+       ir_initializer_t *initializer
+               = (ir_initializer_t*)obstack_alloc(obst, size);
        initializer->kind                    = IR_INITIALIZER_COMPOUND;
        initializer->compound.n_initializers = n_entries;
 
@@ -642,20 +649,20 @@ ir_node *get_initializer_const_value(const ir_initializer_t *initializer)
        return skip_Id(initializer->consti.value);
 }
 
-tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
+ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
 {
        assert(initializer->kind == IR_INITIALIZER_TARVAL);
        return initializer->tarval.value;
 }
 
-unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer)
+size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer)
 {
        assert(initializer->kind == IR_INITIALIZER_COMPOUND);
        return initializer->compound.n_initializers;
 }
 
 void set_initializer_compound_value(ir_initializer_t *initializer,
-                                    unsigned index, ir_initializer_t *value)
+                                    size_t index, ir_initializer_t *value)
 {
        assert(initializer->kind == IR_INITIALIZER_COMPOUND);
        assert(index < initializer->compound.n_initializers);
@@ -664,7 +671,7 @@ void set_initializer_compound_value(ir_initializer_t *initializer,
 }
 
 ir_initializer_t *get_initializer_compound_value(
-               const ir_initializer_t *initializer, unsigned index)
+               const ir_initializer_t *initializer, size_t index)
 {
        assert(initializer->kind == IR_INITIALIZER_COMPOUND);
        assert(index < initializer->compound.n_initializers);
@@ -747,31 +754,31 @@ void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
        ARR_APP1(ir_entity *, overwritten->overwrittenby, ent);
 }
 
-int get_entity_n_overwrites(const ir_entity *ent)
+size_t get_entity_n_overwrites(const ir_entity *ent)
 {
        if (ent->overwrites == NULL)
                return 0;
        return ARR_LEN(ent->overwrites);
 }
 
-int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
+size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
 {
-       int i, n;
-       n = get_entity_n_overwrites(ent);
+       size_t i;
+       size_t n = get_entity_n_overwrites(ent);
        for (i = 0; i < n; ++i) {
                if (get_entity_overwrites(ent, i) == overwritten)
                        return i;
        }
-       return -1;
+       return (size_t)-1;
 }
 
-ir_entity *get_entity_overwrites(const ir_entity *ent, int pos)
+ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos)
 {
        assert(pos < get_entity_n_overwrites(ent));
        return ent->overwrites[pos];
 }
 
-void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten)
+void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten)
 {
        assert(pos < get_entity_n_overwrites(ent));
        ent->overwrites[pos] = overwritten;
@@ -779,8 +786,8 @@ void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten)
 
 void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 {
-       int i, n;
-       n = get_entity_n_overwrites(ent);
+       size_t i;
+       size_t n = get_entity_n_overwrites(ent);
        for (i = 0; i < n; ++i) {
                if (ent->overwrites[i] == overwritten) {
                        for (; i < n - 1; i++)
@@ -792,31 +799,32 @@ void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 }
 
 
-int get_entity_n_overwrittenby(const ir_entity *ent)
+size_t get_entity_n_overwrittenby(const ir_entity *ent)
 {
        if (ent->overwrittenby == NULL)
                return 0;
        return ARR_LEN(ent->overwrittenby);
 }
 
-int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites)
+size_t get_entity_overwrittenby_index(const ir_entity *ent,
+                                      ir_entity *overwrites)
 {
-       int i, n;
-       n = get_entity_n_overwrittenby(ent);
+       size_t i;
+       size_t n = get_entity_n_overwrittenby(ent);
        for (i = 0; i < n; ++i) {
                if (get_entity_overwrittenby(ent, i) == overwrites)
                        return i;
        }
-       return -1;
+       return (size_t)-1;
 }
 
-ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos)
+ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos)
 {
        assert(pos < get_entity_n_overwrittenby(ent));
        return ent->overwrittenby[pos];
 }
 
-void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites)
+void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites)
 {
        assert(pos < get_entity_n_overwrittenby(ent));
        ent->overwrittenby[pos] = overwrites;
@@ -824,9 +832,8 @@ void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites)
 
 void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites)
 {
-       int i, n;
-
-       n = get_entity_n_overwrittenby(ent);
+       size_t i;
+       size_t n = get_entity_n_overwrittenby(ent);
        for (i = 0; i < n; ++i) {
                if (ent->overwrittenby[i] == overwrites) {
                        for (; i < n - 1; ++i)
@@ -923,7 +930,7 @@ int (entity_not_visited)(const ir_entity *ent)
        return _entity_not_visited(ent);
 }
 
-unsigned get_entity_additional_properties(const ir_entity *ent)
+mtp_additional_properties get_entity_additional_properties(const ir_entity *ent)
 {
        ir_graph *irg;
 
@@ -941,7 +948,7 @@ unsigned get_entity_additional_properties(const ir_entity *ent)
        return ent->attr.mtd_attr.irg_add_properties;
 }
 
-void set_entity_additional_properties(ir_entity *ent, unsigned property_mask)
+void set_entity_additional_properties(ir_entity *ent, mtp_additional_properties property_mask)
 {
        ir_graph *irg;
 
@@ -952,13 +959,13 @@ void set_entity_additional_properties(ir_entity *ent, unsigned property_mask)
        if (irg)
                set_irg_additional_properties(irg, property_mask);
        else {
-    /* do not allow to set the mtp_property_inherited flag or
-               * the automatic inheritance of flags will not work */
+               /* do not allow to set the mtp_property_inherited flag or
+                * the automatic inheritance of flags will not work */
                ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
        }
 }
 
-void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag)
+void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties properties)
 {
        ir_graph *irg;
 
@@ -967,16 +974,16 @@ void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag
        /* first check, if the graph exists */
        irg = get_entity_irg(ent);
        if (irg)
-               set_irg_additional_property(irg, flag);
+               add_irg_additional_properties(irg, properties);
        else {
-               unsigned mask = ent->attr.mtd_attr.irg_add_properties;
+               mtp_additional_properties mask = ent->attr.mtd_attr.irg_add_properties;
 
                if (mask & mtp_property_inherited)
                        mask = get_method_additional_properties(get_entity_type(ent));
 
                /* do not allow to set the mtp_property_inherited flag or
                 * the automatic inheritance of flags will not work */
-               ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited);
+               ent->attr.mtd_attr.irg_add_properties = mask | (properties & ~mtp_property_inherited);
        }
 }
 
@@ -1031,7 +1038,7 @@ void ir_finish_entity(void)
 
 ir_allocation get_entity_allocation(const ir_entity *entity)
 {
-       return entity->allocation;
+       return (ir_allocation)entity->allocation;
 }
 
 void set_entity_allocation(ir_entity *entity, ir_allocation allocation)
@@ -1041,7 +1048,7 @@ void set_entity_allocation(ir_entity *entity, ir_allocation allocation)
 
 ir_peculiarity get_entity_peculiarity(const ir_entity *entity)
 {
-       return entity->peculiarity;
+       return (ir_peculiarity)entity->peculiarity;
 }
 
 void set_entity_peculiarity(ir_entity *entity, ir_peculiarity peculiarity)