{
symconst_symbol sym;
- assert(unknown_type && "Call init_type before init_entity!");
+ 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));
}
}
+/**
+ * creates a new entity
+ */
static INLINE entity *
new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
{
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;
newe = xmalloc(sizeof(*newe));
memcpy (newe, old, sizeof(*newe));
newe->owner = new_owner;
- if (is_class_type(new_owner)) {
+ if (is_Class_type(new_owner)) {
newe->overwrites = NEW_ARR_F(entity *, 0);
newe->overwrittenby = NEW_ARR_F(entity *, 0);
}
memcpy(newe, old, sizeof(*newe));
newe->name = new_name;
newe->ld_name = NULL;
- if (is_class_type(newe->owner)) {
+ 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
newe->nr = get_irp_new_node_nr();
- newe->c_name = (char *)get_id_str (newe->name);
#endif
insert_entity_in_owner (newe);
{
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)) {
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 = calloc (1, sizeof(*res) + (length-1) * sizeof(res->nodes[0]));
- res->kind = k_ir_compound_graph_path;
- res->tp = tp;
- res->len = length;
- res ->arr_indicees = calloc(length, sizeof(*res ->arr_indicees));
+ 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);
}
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);
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 the still we must be able to
* evaluate the index against the upper bound.)
*/
void compute_compound_ent_array_indicees(entity *ent) {
/* 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)) {
+ if (is_Array_type(tp)) {
int dim = 0;
assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
entity *node = get_compound_graph_path_node(path, j);
type *elem_tp = get_entity_type(node);
- if (is_array_type(elem_tp)) {
+ 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)) {
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))
+ if (is_Array_type(owner_tp))
set_compound_graph_path_array_index (path, j, get_next_index(node));
}
}
}
-/* FIXME MMB: the memcpy is very strange */
-static int *resize (int *buf, int new_size) {
- int *new_buf = (int *)calloc(new_size, sizeof(*new_buf));
- 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;
}
/* estimated upper bound for size. Better: use flexible array ... */
size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
- permutation = calloc(size, sizeof(*permutation));
+ 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");
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++)
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_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;
}
/* Need two routines because I want to assert the result. */
-static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
+static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity *static_ent) {
int i, n_overwrittenby;
entity *res = NULL;
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;
+ if (res)
+ break;
}
return res;
* 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 *resolve_ent_polymorphy(type *dynamic_class, entity *static_ent) {
entity *res;
assert(static_ent && static_ent->kind == k_entity);