void
init_entity (void)
{
- assert(unknown_type && "Call init_type before init_entity!");
+ symconst_symbol sym;
+
+ assert(firm_unknown_type && "Call init_type before init_entity!");
assert(!unknown_entity && "Call init_entity only once!");
- unknown_entity = new_rd_entity(NULL, unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), unknown_type);
+ unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
set_entity_visibility(unknown_entity, visibility_external_allocated);
set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
- symconst_symbol sym;
sym.entity_p = unknown_entity;
current_ir_graph = get_const_code_irg();
unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
}
}
+/**
+ * creates a new entity
+ */
static INLINE entity *
new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
{
assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
- res = (entity *) xmalloc (sizeof (entity));
- memset(res, 0, sizeof(res));
+ res = xmalloc(sizeof(*res));
+ memset(res, 0, sizeof(*res));
res->kind = k_entity;
res->owner = owner;
res->name = name;
res->visibility = visibility_local;
res->offset = -1;
- if (is_method_type(type)) {
+ if (is_Method_type(type)) {
symconst_symbol sym;
sym.entity_p = res;
res->variability = variability_constant;
res->volatility = volatility_non_volatile;
res->stickyness = stickyness_unsticky;
res->ld_name = NULL;
- if (is_class_type(owner)) {
+ if (is_Class_type(owner)) {
res->overwrites = NEW_ARR_F(entity *, 0);
res->overwrittenby = NEW_ARR_F(entity *, 0);
} else {
#ifdef DEBUG_libfirm
res->nr = get_irp_new_node_nr();
- res->c_name = (char *)get_id_str (name);
#endif /* DEBUG_libfirm */
res->visit = 0;
entity *
new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
+ entity *res;
+
assert_legal_owner_of_ent(owner);
- entity *res = new_rd_entity(db, owner, name, type);
+ res = new_rd_entity(db, owner, name, type);
/* Remember entity in it's owner. */
insert_entity_in_owner (res);
entity *
copy_entity_own (entity *old, type *new_owner) {
- entity *new;
+ entity *newe;
assert(old && old->kind == k_entity);
assert_legal_owner_of_ent(new_owner);
if (old->owner == new_owner) return old;
- new = (entity *) xmalloc (sizeof (entity));
- memcpy (new, old, sizeof (entity));
- new->owner = new_owner;
- if (is_class_type(new_owner)) {
- new->overwrites = NEW_ARR_F(entity *, 0);
- new->overwrittenby = NEW_ARR_F(entity *, 0);
+ newe = xmalloc(sizeof(*newe));
+ memcpy (newe, old, sizeof(*newe));
+ newe->owner = new_owner;
+ if (is_Class_type(new_owner)) {
+ newe->overwrites = NEW_ARR_F(entity *, 0);
+ newe->overwrittenby = NEW_ARR_F(entity *, 0);
}
#ifdef DEBUG_libfirm
- new->nr = get_irp_new_node_nr();
+ newe->nr = get_irp_new_node_nr();
#endif
- insert_entity_in_owner (new);
+ insert_entity_in_owner (newe);
- return new;
+ return newe;
}
entity *
copy_entity_name (entity *old, ident *new_name) {
- entity *new;
+ entity *newe;
assert(old && old->kind == k_entity);
if (old->name == new_name) return old;
- new = (entity *) xmalloc (sizeof (entity));
- memcpy (new, old, sizeof (entity));
- new->name = new_name;
- new->ld_name = NULL;
- if (is_class_type(new->owner)) {
- new->overwrites = DUP_ARR_F(entity *, old->overwrites);
- new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
+ newe = xmalloc(sizeof(*newe));
+ memcpy(newe, old, sizeof(*newe));
+ newe->name = new_name;
+ newe->ld_name = NULL;
+ if (is_Class_type(newe->owner)) {
+ newe->overwrites = DUP_ARR_F(entity *, old->overwrites);
+ newe->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
}
#ifdef DEBUG_libfirm
- new->nr = get_irp_new_node_nr();
- new->c_name = (char *)get_id_str (new->name);
+ newe->nr = get_irp_new_node_nr();
#endif
- insert_entity_in_owner (new);
+ insert_entity_in_owner (newe);
- return new;
+ return newe;
}
const char *
(get_entity_name)(const entity *ent) {
- return __get_entity_name(ent);
+ return _get_entity_name(ent);
}
ident *
type *
(get_entity_owner)(entity *ent) {
- return __get_entity_owner(ent);
+ return _get_entity_owner(ent);
}
void
ident *
(get_entity_ld_ident)(entity *ent) {
- return __get_entity_ld_ident(ent);
+ return _get_entity_ld_ident(ent);
}
void
(set_entity_ld_ident)(entity *ent, ident *ld_ident) {
- __set_entity_ld_ident(ent, ld_ident);
+ _set_entity_ld_ident(ent, ld_ident);
}
const char *
(get_entity_ld_name)(entity *ent) {
- return __get_entity_ld_name(ent);
+ return _get_entity_ld_name(ent);
}
type *
(get_entity_type)(entity *ent) {
- return __get_entity_type(ent);
+ return _get_entity_type(ent);
}
void
(set_entity_type)(entity *ent, type *type) {
- __set_entity_type(ent, type);
+ _set_entity_type(ent, type);
}
ent_allocation
(get_entity_allocation)(const entity *ent) {
- return __get_entity_allocation(ent);
+ return _get_entity_allocation(ent);
}
void
(set_entity_allocation)(entity *ent, ent_allocation al) {
- __set_entity_allocation(ent, al);
+ _set_entity_allocation(ent, al);
}
/* return the name of the visibility */
}
-ent_visibility
+visibility
(get_entity_visibility)(const entity *ent) {
- return __get_entity_visibility(ent);
+ return _get_entity_visibility(ent);
}
void
-set_entity_visibility (entity *ent, ent_visibility vis) {
+set_entity_visibility (entity *ent, visibility vis) {
assert(ent && ent->kind == k_entity);
if (vis != visibility_local)
assert((ent->allocation == allocation_static) ||
}
/* return the name of the visibility */
-const char *get_visibility_name(ent_visibility vis)
+const char *get_visibility_name(visibility vis)
{
#define X(a) case a: return #a
switch (vis) {
ent_variability
(get_entity_variability)(const entity *ent) {
- return __get_entity_variability(ent);
+ return _get_entity_variability(ent);
}
void
{
assert(ent && ent->kind == k_entity);
if (var == variability_part_constant)
- assert(is_class_type(ent->type) || is_struct_type(ent->type));
+ assert(is_Class_type(ent->type) || is_Struct_type(ent->type));
if ((is_compound_type(ent->type)) &&
(ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
ent_volatility
(get_entity_volatility)(const entity *ent) {
- return __get_entity_volatility(ent);
+ return _get_entity_volatility(ent);
}
void
(set_entity_volatility)(entity *ent, ent_volatility vol) {
- __set_entity_volatility(ent, vol);
+ _set_entity_volatility(ent, vol);
}
/* return the name of the volatility */
peculiarity
(get_entity_peculiarity)(const entity *ent) {
- return __get_entity_peculiarity(ent);
+ return _get_entity_peculiarity(ent);
}
void
(set_entity_peculiarity)(entity *ent, peculiarity pec) {
- __set_entity_peculiarity(ent, pec);
+ _set_entity_peculiarity(ent, pec);
}
/* return the name of the peculiarity */
/* Get the entity's stickyness */
ent_stickyness
(get_entity_stickyness)(const entity *ent) {
- return __get_entity_stickyness(ent);
+ return _get_entity_stickyness(ent);
}
/* Set the entity's stickyness */
void
(set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
- __set_entity_stickyness(ent, stickyness);
+ _set_entity_stickyness(ent, stickyness);
}
/* Set has no effect for existent entities of type method. */
void
set_atomic_ent_value(entity *ent, ir_node *val) {
assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
- if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
+ if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
return;
ent->value = val;
}
int is_irn_const_expression(ir_node *n) {
ir_mode *m;
- /* we are in dange iff an exception will arise. TODO: be more precisely,
+ /* we are in danger iff an exception will arise. TODO: be more precisely,
* for instance Div. will NOT rise if divisor != 0
*/
if (is_binop(n) && !is_fragile_op(n))
compound_graph_path *
new_compound_graph_path(type *tp, int length) {
compound_graph_path *res;
+
assert(is_type(tp) && is_compound_type(tp));
assert(length > 0);
- res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
- res->kind = k_ir_compound_graph_path;
- res->tp = tp;
- res->len = length;
- res ->arr_indicees = (int *) calloc(length, sizeof(int));
+ res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
+ memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
+ res->kind = k_ir_compound_graph_path;
+ res->tp = tp;
+ res->len = length;
+ res->arr_indicees = xcalloc(length, sizeof(res ->arr_indicees[0]));
+
return res;
}
type *owner = gr->tp;
for (i = 0; i <= pos; i++) {
node = get_compound_graph_path_node(gr, i);
+ if (node == NULL)
+ /* Path not yet complete. */
+ return true;
if (get_entity_owner(node) != owner) return false;
owner = get_entity_type(node);
}
return ent->val_paths[pos];
}
+/**
+ * Returns non-zero, if two compound_graph_pathes are equal
+ */
+static int equal_paths(compound_graph_path *path1, int *visited_indicees, compound_graph_path *path2) {
+ int i;
+ int len1 = get_compound_graph_path_length(path1);
+ int len2 = get_compound_graph_path_length(path2);
+
+ if (len2 > len1) return false;
+
+ for (i = 0; i < len1; i++) {
+ type *tp;
+ entity *node1 = get_compound_graph_path_node(path1, i);
+ entity *node2 = get_compound_graph_path_node(path2, i);
+
+ if (node1 != node2) return false;
+
+ 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_indicees[i] < get_compound_graph_path_array_index(path2, i)) {
+ visited_indicees[i]++;
+ return false;
+ }
+ else
+ assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i));
+ }
+ }
+ return true;
+}
+
+/* Returns the position of a value with the given path.
+ * The path must contain array indicees for all array element entities. */
+int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) {
+ int i, n_paths = get_compound_ent_n_values(ent);
+ int *visited_indicees = (int *)xcalloc(get_compound_graph_path_length(path), sizeof(int));
+ for (i = 0; i < n_paths; i ++) {
+ if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, 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) {
+ 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;
+}
+
+/* Returns a constant value given the access path.
+ * The path must contain array indicees for all array element entities. */
+ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path) {
+ return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path));
+}
+
+
void
remove_compound_ent_value(entity *ent, entity *value_ent) {
int i;
compound_graph_path *path = ent->val_paths[i];
if (path->nodes[path->len-1] == value_ent) {
for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
- ent->val_paths[i] = ent->val_paths[i+1];
- ent->values[i] = ent->values[i+1];
+ ent->val_paths[i] = ent->val_paths[i+1];
+ ent->values[i] = ent->values[i+1];
}
ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1);
ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1);
assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
path = new_compound_graph_path(owner_tp, 1);
path->nodes[0] = member;
- if (is_array_type(owner_tp)) {
+ if (is_Array_type(owner_tp)) {
int max;
int i;
ir_node *val;
type *elttp = get_array_element_type(arrtp);
- assert(is_array_type(arrtp));
+ assert(is_Array_type(arrtp));
assert(get_array_n_dimensions(arrtp) == 1);
- /* One bound is sufficient, the nunmber of constant fields makes the
+ /* One bound is sufficient, the number of constant fields makes the
size. */
assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
assert(get_entity_variability(ent) != variability_uninitialized);
}
int get_compound_ent_value_offset_bits(entity *ent, int pos) {
+ compound_graph_path *path;
+ int i, path_len;
+ int offset = 0;
+
assert(get_type_state(get_entity_type(ent)) == layout_fixed);
- compound_graph_path *path = get_compound_ent_value_path(ent, pos);
- int i, path_len = get_compound_graph_path_length(path);
- int offset = 0;
+ path = get_compound_ent_value_path(ent, pos);
+ path_len = get_compound_graph_path_length(path);
for (i = 0; i < path_len; ++i) {
entity *node = get_compound_graph_path_node(path, i);
type *node_tp = get_entity_type(node);
type *owner_tp = get_entity_owner(node);
- if (is_array_type(owner_tp)) {
+ if (is_Array_type(owner_tp)) {
int size = get_type_size_bits(node_tp);
int align = get_type_alignment_bits(node_tp);
if (size < align)
return next;
}
-/* Compute the array indicees in compound graph paths of initialized entities.
+/* Compute the array indices in compound graph paths of initialized entities.
*
* All arrays must have fixed lower and upper bounds. One array can
* have an open bound. If there are several open bounds, we do
* array bounds must be representable as ints.
*
* (If the bounds are not representable as ints we have to represent
- * the indicees as firm nodes. But the still we must be able to
+ * the indices as firm nodes. But still we must be able to
* evaluate the index against the upper bound.)
*/
void compute_compound_ent_array_indicees(entity *ent) {
n_vals = get_compound_ent_n_values(ent);
if (n_vals == 0) return;
- /* We can not compute the indicees if there is more than one array
+ /* We can not compute the indexes if there is more than one array
with an unknown bound. For this remember the first entity that
represents such an array. It could be ent. */
- if (is_array_type(tp)) {
- assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
+ if (is_Array_type(tp)) {
int dim = 0;
+
+ assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
unknown_bound_entity = ent;
}
entity *node = get_compound_graph_path_node(path, j);
type *elem_tp = get_entity_type(node);
- if (is_array_type(elem_tp)) {
- assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
- int dim = 0;
- if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
- if (!unknown_bound_entity) unknown_bound_entity = node;
- if (node != unknown_bound_entity) return;
- }
+ if (is_Array_type(elem_tp)) {
+ int dim = 0;
+ assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
+ if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
+ if (!unknown_bound_entity) unknown_bound_entity = node;
+ if (node != unknown_bound_entity) return;
+ }
- init_index(elem_tp);
+ init_index(elem_tp);
}
}
}
- /* Finally compute the indicees ... */
+ /* Finally compute the indexes ... */
for (i = 0; i < n_vals; ++i) {
compound_graph_path *path = get_compound_ent_value_path(ent, i);
int j, path_len = get_compound_graph_path_length(path);
for (j = 0; j < path_len; ++j) {
entity *node = get_compound_graph_path_node(path, j);
type *owner_tp = get_entity_owner(node);
- if (is_array_type(owner_tp))
- set_compound_graph_path_array_index (path, j, get_next_index(node));
+ if (is_Array_type(owner_tp))
+ set_compound_graph_path_array_index (path, j, get_next_index(node));
}
}
-
}
-
-static int *resize (int *buf, int new_size) {
- int *new_buf = (int *)calloc(new_size, 4);
- memcpy(new_buf, buf, new_size>1);
+/** resize: double the allocated buffer */
+static int *resize (int *buf, int *size) {
+ int new_size = *size * 2;
+ int *new_buf = xcalloc(new_size, sizeof(new_buf[0]));
+ memcpy(new_buf, buf, *size);
free(buf);
+ *size = new_size;
return new_buf;
}
A second iteration now permutes the actual elements into two
new arrays. */
void sort_compound_ent_values(entity *ent) {
- assert(get_type_state(get_entity_type(ent)) == layout_fixed);
-
- type *tp = get_entity_type(ent);
- int i, n_vals = get_compound_ent_n_values(ent);
- int tp_size = get_type_size_bits(tp);
+ type *tp;
+ int i, n_vals;
+ int tp_size;
int size;
int *permutation;
+ int next;
+ ir_node **my_values;
+ compound_graph_path **my_paths;
+
+ assert(get_type_state(get_entity_type(ent)) == layout_fixed);
+
+ tp = get_entity_type(ent);
+ n_vals = get_compound_ent_n_values(ent);
+ tp_size = get_type_size_bits(tp);
+
if (!is_compound_type(tp) ||
(ent->variability == variability_uninitialized) ||
(get_type_state(tp) != layout_fixed) ||
/* estimated upper bound for size. Better: use flexible array ... */
size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
- permutation = (int *)calloc(size, 4);
+ permutation = xcalloc(size, sizeof(permutation[0]));
+
for (i = 0; i < n_vals; ++i) {
int pos = get_compound_ent_value_offset_bits(ent, i);
while (pos >= size) {
- size = size + size;
- permutation = resize(permutation, size);
+ permutation = resize(permutation, &size);
}
assert(pos < size);
assert(permutation[pos] == 0 && "two values with the same offset");
//fprintf(stderr, "i: %d, pos: %d \n", i, pos);
}
- int next = 0;
- ir_node **my_values = NEW_ARR_F(ir_node *, n_vals);
- compound_graph_path **my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
+ next = 0;
+ my_values = NEW_ARR_F(ir_node *, n_vals);
+ my_paths = NEW_ARR_F(compound_graph_path *, n_vals);
for (i = 0; i < size; ++i) {
int pos = permutation[i];
if (pos) {
int
(get_entity_offset_bytes)(const entity *ent) {
- return __get_entity_offset_bytes(ent);
+ return _get_entity_offset_bytes(ent);
}
int
(get_entity_offset_bits)(const entity *ent) {
- return __get_entity_offset_bits(ent);
+ return _get_entity_offset_bits(ent);
}
void
(set_entity_offset_bytes)(entity *ent, int offset) {
- __set_entity_offset_bytes(ent, offset);
+ _set_entity_offset_bytes(ent, offset);
}
void
(set_entity_offset_bits)(entity *ent, int offset) {
- __set_entity_offset_bits(ent, offset);
+ _set_entity_offset_bits(ent, offset);
}
void
add_entity_overwrites(entity *ent, entity *overwritten) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
ARR_APP1(entity *, ent->overwrites, overwritten);
ARR_APP1(entity *, overwritten->overwrittenby, ent);
}
int
get_entity_n_overwrites(entity *ent) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
return (ARR_LEN(ent->overwrites));
}
int
get_entity_overwrites_index(entity *ent, entity *overwritten) {
int i;
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
for (i = 0; i < get_entity_n_overwrites(ent); i++)
if (get_entity_overwrites(ent, i) == overwritten)
return i;
entity *
get_entity_overwrites (entity *ent, int pos) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
assert(pos < get_entity_n_overwrites(ent));
return ent->overwrites[pos];
}
void
set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
assert(pos < get_entity_n_overwrites(ent));
ent->overwrites[pos] = overwritten;
}
void
remove_entity_overwrites(entity *ent, entity *overwritten) {
int i;
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
if (ent->overwrites[i] == overwritten) {
for(; i < (ARR_LEN (ent->overwrites))-1; i++)
void
add_entity_overwrittenby (entity *ent, entity *overwrites) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
add_entity_overwrites(overwrites, ent);
}
int
get_entity_n_overwrittenby (entity *ent) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
return (ARR_LEN (ent->overwrittenby));
}
int
get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
int i;
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
if (get_entity_overwrittenby(ent, i) == overwrites)
return i;
entity *
get_entity_overwrittenby (entity *ent, int pos) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
assert(pos < get_entity_n_overwrittenby(ent));
return ent->overwrittenby[pos];
}
void
set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
assert(pos < get_entity_n_overwrittenby(ent));
ent->overwrittenby[pos] = overwrites;
}
void remove_entity_overwrittenby(entity *ent, entity *overwrites) {
int i;
- assert(ent && is_class_type(get_entity_owner(ent)));
+ assert(ent && is_Class_type(get_entity_owner(ent)));
for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
if (ent->overwrittenby[i] == overwrites) {
for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
/* A link to store intermediate information */
void *
(get_entity_link)(const entity *ent) {
- return __get_entity_link(ent);
+ return _get_entity_link(ent);
}
void
(set_entity_link)(entity *ent, void *l) {
- __set_entity_link(ent, l);
+ _set_entity_link(ent, l);
}
ir_graph *
(get_entity_irg)(const entity *ent) {
- return __get_entity_irg(ent);
+ return _get_entity_irg(ent);
}
void
set_entity_irg(entity *ent, ir_graph *irg) {
- assert(ent && is_method_type(get_entity_type(ent)));
+ assert(ent && is_Method_type(get_entity_type(ent)));
/* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
* Methode selbst nicht mehr aufgerufen werden kann, die Entität
* aber erhalten bleiben soll? Wandle die Entitaet in description oder
int
(is_entity)(const void *thing) {
- return __is_entity(thing);
+ return _is_entity(thing);
}
int is_atomic_entity(entity *ent) {
type* t = get_entity_type(ent);
assert(ent && ent->kind == k_entity);
- return (is_primitive_type(t) || is_pointer_type(t) ||
- is_enumeration_type(t) || is_method_type(t));
+ return (is_Primitive_type(t) || is_Pointer_type(t) ||
+ is_Enumeration_type(t) || is_Method_type(t));
}
int is_compound_entity(entity *ent) {
type* t = get_entity_type(ent);
assert(ent && ent->kind == k_entity);
- return (is_class_type(t) || is_struct_type(t) ||
- is_array_type(t) || is_union_type(t));
+ return (is_Class_type(t) || is_Struct_type(t) ||
+ is_Array_type(t) || is_Union_type(t));
}
/**
- * @todo not implemnted!!! */
+ * @todo not implemented!!! */
bool equal_entity(entity *ent1, entity *ent2) {
fprintf(stderr, " calling unimplemented equal entity!!! \n");
return true;
assert(ent && ent->kind == k_entity);
return get_entity_visited(ent) < type_visited;
}
-
-/* Need two routines because I want to assert the result. */
-static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
- int i, n_overwrittenby;
- entity *res = NULL;
-
- if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
-
- n_overwrittenby = get_entity_n_overwrittenby(static_ent);
- for (i = 0; i < n_overwrittenby; ++i) {
- res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
- if (res) break;
- }
-
- return res;
-}
-
-/** Resolve polymorphy in the inheritance relation.
- *
- * Returns the dynamically referenced entity if the static entity and the
- * dynamic type are given.
- * Search downwards in overwritten tree. */
-entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) {
- entity *res;
- assert(static_ent && static_ent->kind == k_entity);
-
- res = resolve_ent_polymorphy2(dynamic_class, static_ent);
-#if DEBUG_libfirm
- if (!res) {
- printf(" Could not find entity "); DDME(static_ent);
- printf(" in "); DDMT(dynamic_class);
- printf("\n");
- dump_entity(static_ent);
- dump_type(get_entity_owner(static_ent));
- dump_type(dynamic_class);
- }
-#endif
- assert(res);
- return res;
-}
projects / libfirm / blobdiff