* @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
#include <string.h>
#include <stdlib.h>
#include "tv_t.h"
#include "irdump.h"
#include "irgraph_t.h"
-
#include "callgraph.h"
-
-/**
- * An interval initializer.
- */
-typedef struct interval_initializer interval_initializer;
-
-/**
- * A value initializer.
- */
-typedef struct value_initializer value_initializer;
-
-struct interval_initializer {
- int first_index; /**< The first index of the initialized interval. */
- int last_index; /**< The last index of the initialized interval. */
- interval_initializer *next; /**< Points to the next interval initializer. */
-};
-
-struct value_initializer {
- ir_entity *ent; /**< The initialized entity. */
- value_initializer *next; /**< Points to the next value initializer. */
-};
-
-typedef union initializer {
- ir_node *value; /**< The value of the initializer. */
- ir_node **values; /**< The values of an interval. */
- value_initializer *val_init; /**< Points the the head of the next value initializers. */
- interval_initializer *int_init; /**< Points to the head of the next value initializers. */
-} initializer;
+#include "error.h"
/*-----------------------------------------------------------------*/
/** general **/
/**
* Add an entity to it's already set owner type.
*/
-static INLINE void insert_entity_in_owner(ir_entity *ent) {
+static inline void insert_entity_in_owner(ir_entity *ent) {
ir_type *owner = ent->owner;
switch (get_type_tpop_code(owner)) {
case tpo_class:
case tpo_array:
set_array_element_entity(owner, ent);
break;
- default: assert(0);
+ default:
+ panic("Unsupported type kind");
}
} /* insert_entity_in_owner */
*
* @return the new created entity
*/
-static INLINE ir_entity *
+static inline ir_entity *
new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
{
ir_entity *res;
assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
- res = xmalloc(sizeof(*res));
- memset(res, 0, sizeof(*res));
+ res = XMALLOCZ(ir_entity);
res->kind = k_entity;
res->name = name;
res->align = align_is_aligned;
res->stickyness = stickyness_unsticky;
res->peculiarity = peculiarity_existent;
- res->address_taken = ir_address_taken_unknown;
+ res->usage = ir_usage_unknown;
res->final = 0;
res->compiler_gen = 0;
res->backend_marked = 0;
assert(ent->overwrittenby == NULL);
}
if (is_compound_entity(ent)) {
- if (ent->attr.cmpd_attr.val_paths) {
- for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i)
- if (ent->attr.cmpd_attr.val_paths[i]) {
- /* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ; * @@@ warum nich? */
- /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
- /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */
- }
- ent->attr.cmpd_attr.val_paths = NULL;
+ if (ent->has_initializer) {
+ /* TODO: free initializers */
+ } else {
+ if (ent->attr.cmpd_attr.val_paths) {
+ for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i)
+ if (ent->attr.cmpd_attr.val_paths[i]) {
+ /* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ; * @@@ warum nich? */
+ /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
+ /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */
+ }
+ ent->attr.cmpd_attr.val_paths = NULL;
+ }
+ if (ent->attr.cmpd_attr.values) {
+ /*DEL_ARR_F(ent->attr.cmpd_attr.values)*/;
+ }
+ ent->attr.cmpd_attr.values = NULL;
}
- /* if (ent->attr.cmpd_attr.values) DEL_ARR_F(ent->attr.cmpd_attr.values); *//* @@@ warum nich? */
- ent->attr.cmpd_attr.values = NULL;
} else if (is_method_entity(ent)) {
if (ent->attr.mtd_attr.param_access) {
DEL_ARR_F(ent->attr.mtd_attr.param_access);
}
} /* free_entity_attrs */
+/**
+ * Creates a deep copy of an entity.
+ */
+static ir_entity *deep_entity_copy(ir_entity *old)
+{
+ ir_entity *newe = XMALLOC(ir_entity);
+
+ *newe = *old;
+ if (is_compound_entity(old)) {
+ if (old->has_initializer) {
+ /* FIXME: the initializers are NOT copied */
+ } else {
+ newe->attr.cmpd_attr.values = NULL;
+ newe->attr.cmpd_attr.val_paths = NULL;
+ if (old->attr.cmpd_attr.values)
+ newe->attr.cmpd_attr.values = DUP_ARR_F(ir_node *, old->attr.cmpd_attr.values);
+
+ /* FIXME: the compound graph paths are NOT copied */
+ if (old->attr.cmpd_attr.val_paths)
+ newe->attr.cmpd_attr.val_paths = DUP_ARR_F(compound_graph_path *, old->attr.cmpd_attr.val_paths);
+ }
+ } else if (is_method_entity(old)) {
+ /* do NOT copy them, reanalyze. This might be the best solution */
+ newe->attr.mtd_attr.param_access = NULL;
+ newe->attr.mtd_attr.param_weight = NULL;
+ }
+
+#ifdef DEBUG_libfirm
+ newe->nr = get_irp_new_node_nr();
+#endif
+ return newe;
+}
/*
* Copies the entity if the new_owner is different from the
* owner of the old entity, else returns the old entity.
assert(is_compound_type(new_owner));
assert(get_type_state(new_owner) != layout_fixed);
- if (old->owner == new_owner) return old;
- newe = xmalloc(sizeof(*newe));
- memcpy(newe, old, sizeof(*newe));
+ if (old->owner == new_owner)
+ return old;
+
+ /* create a deep copy so we are safe of aliasing and double-freeing. */
+ newe = deep_entity_copy(old);
newe->owner = new_owner;
+
if (is_Class_type(new_owner)) {
newe->overwrites = NEW_ARR_F(ir_entity *, 0);
newe->overwrittenby = NEW_ARR_F(ir_entity *, 0);
}
-#ifdef DEBUG_libfirm
- newe->nr = get_irp_new_node_nr();
-#endif
insert_entity_in_owner(newe);
-
return newe;
} /* copy_entity_own */
assert(old && old->kind == k_entity);
if (old->name == new_name) return old;
- newe = xmalloc(sizeof(*newe));
- memcpy(newe, old, sizeof(*newe));
+ newe = deep_entity_copy(old);
newe->name = new_name;
newe->ld_name = NULL;
+
if (is_Class_type(newe->owner)) {
newe->overwrites = DUP_ARR_F(ir_entity *, old->overwrites);
newe->overwrittenby = DUP_ARR_F(ir_entity *, old->overwrittenby);
}
-#ifdef DEBUG_libfirm
- newe->nr = get_irp_new_node_nr();
-#endif
-
insert_entity_in_owner(newe);
return newe;
} /* copy_entity_name */
-
void
free_entity(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
_set_entity_backend_marked(ent, flag);
} /* set_entity_backend_marked */
-/* Checks if the address of an entity was taken. */
-ir_address_taken_state (get_entity_address_taken)(const ir_entity *ent) {
- return _get_entity_address_taken(ent);
-} /* is_entity_address_taken */
-
-/* Sets/resets the address taken flag. */
-void (set_entity_address_taken)(ir_entity *ent, ir_address_taken_state flag) {
- _set_entity_address_taken(ent, flag);
-} /* set_entity_address_taken */
+ir_entity_usage (get_entity_usage)(const ir_entity *ent) {
+ return _get_entity_usage(ent);
+}
-/* Return the name of the address_taken state. */
-const char *get_address_taken_state_name(ir_address_taken_state state) {
-#define X(a) case a: return #a
- switch (state) {
- X(ir_address_not_taken);
- X(ir_address_taken_unknown);
- X(ir_address_taken);
- default: return "BAD VALUE";
- }
-#undef X
-} /* get_address_taken_state_name */
+void (set_entity_usage)(ir_entity *ent, ir_entity_usage flags) {
+ _set_entity_usage(ent, flags);
+}
/* Get the entity's stickyness */
ir_stickyness
m = get_irn_mode(n);
switch (get_irn_opcode(n)) {
case iro_Const:
- nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
+ nn = new_d_Const_type(dbg, get_Const_tarval(n), get_Const_type(n));
break;
case iro_SymConst:
nn = new_d_SymConst_type(dbg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n),
ir_node *get_initializer_const_value(const ir_initializer_t *initializer)
{
assert(initializer->kind == IR_INITIALIZER_CONST);
- return initializer->consti.value;
+ return skip_Id(initializer->consti.value);
}
tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
gr->list[pos].index = index;
} /* set_compound_graph_path_array_index */
+ir_type *
+get_compound_graph_path_type(const compound_graph_path *gr) {
+ assert(gr && is_compound_graph_path(gr));
+ return gr->tp;
+}
+
/* A value of a compound entity is a pair of value and the corresponding path to a member of
the compound. */
void
int
get_compound_ent_n_values(ir_entity *ent) {
+ assert(!ent->has_initializer);
assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
return ARR_LEN(ent->attr.cmpd_attr.values);
} /* get_compound_ent_n_values */
ir_node *
get_compound_ent_value(ir_entity *ent, int pos) {
assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
+ assert(!ent->has_initializer);
assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
return ent->attr.cmpd_attr.values[pos];
} /* get_compound_ent_value */
compound_graph_path *
get_compound_ent_value_path(ir_entity *ent, int pos) {
assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
+ assert(!ent->has_initializer);
assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths));
return ent->attr.cmpd_attr.val_paths[pos];
} /* get_compound_ent_value_path */
* Returns non-zero, if two compound_graph_pathes are equal
*
* @param path1 the first path
- * @param visited_indices
* @param path2 the second path
*/
-static int equal_paths(compound_graph_path *path1, int *visited_indices, compound_graph_path *path2) {
+static int equal_paths(compound_graph_path *path1, compound_graph_path *path2) {
int i;
int len1 = get_compound_graph_path_length(path1);
int len2 = get_compound_graph_path_length(path2);
if (node1 != node2) return 0;
- /* FIXME: Strange code. What is it good for? */
tp = get_entity_owner(node1);
if (is_Array_type(tp)) {
- long low;
-
- /* Compute the index of this node. */
- assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented");
-
- low = get_array_lower_bound_int(tp, 0);
- if (low + visited_indices[i] < get_compound_graph_path_array_index(path2, i)) {
- visited_indices[i]++;
+ int index1 = get_compound_graph_path_array_index(path1, i);
+ int index2 = get_compound_graph_path_array_index(path2, i);
+ if (index1 != index2)
return 0;
- } else
- assert(low + visited_indices[i] == get_compound_graph_path_array_index(path2, i));
}
}
return 1;
* Returns the position of a value with the given path.
* The path must contain array indices for all array element entities.
*
- * @todo This implementation is very slow (O(number of initializers^2) and should
- * be replaced when the new tree oriented
+ * @todo This implementation is very slow (O(number of initializers * |path|)
+ * and should be replaced when the new tree oriented
* value representation is finally implemented.
*/
static int get_compound_ent_pos_by_path(ir_entity *ent, compound_graph_path *path) {
int i, n_paths = get_compound_ent_n_values(ent);
- int *visited_indices;
- int path_len = get_compound_graph_path_length(path);
- NEW_ARR_A(int *, visited_indices, path_len);
- memset(visited_indices, 0, sizeof(*visited_indices) * path_len);
for (i = 0; i < n_paths; i ++) {
- if (equal_paths(get_compound_ent_value_path(ent, i), visited_indices, path))
+ compound_graph_path *gr = get_compound_ent_value_path(ent, i);
+ if (equal_paths(gr, path))
return i;
}
-
-#if 0
- {
- int j;
- printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
- printf("Entity %s : ", get_entity_name(ent));
- for (j = 0; j < get_compound_graph_path_length(path); ++j) {
- ir_entity *node = get_compound_graph_path_node(path, j);
- printf("%s", get_entity_name(node));
- if (is_Array_type(get_entity_owner(node)))
- printf("[%d]", get_compound_graph_path_array_index(path, j));
- }
- printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
- }
-#endif
-
- assert(0 && "path not found");
return -1;
} /* get_compound_ent_pos_by_path */
/* Returns a constant value given the access path.
* The path must contain array indices for all array element entities. */
ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path) {
- return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
+ int pos = get_compound_ent_pos_by_path(ent, path);
+ if (pos >= 0)
+ return get_compound_ent_value(ent, pos);
+ return NULL;
} /* get_compound_ent_value_by_path */
} /* equal_entity */
-unsigned long (get_entity_visited)(ir_entity *ent) {
+ir_visited_t (get_entity_visited)(ir_entity *ent) {
return _get_entity_visited(ent);
} /* get_entity_visited */
-void (set_entity_visited)(ir_entity *ent, unsigned long num) {
+void (set_entity_visited)(ir_entity *ent, ir_visited_t num) {
_set_entity_visited(ent, num);
} /* set_entity_visited */