* Copyright: (c) 1998-2003 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
*/
-
#ifdef HAVE_CONFIG_H
-# include <config.h>
+#include "config.h"
#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef HAVE_STDLIB_H
# include <stdlib.h>
+#endif
# include <stddef.h>
-# include <string.h>
+#include "firm_common_t.h"
+
+# include "xmalloc.h"
# include "entity_t.h"
# include "mangle.h"
# include "typegmod.h"
# include "array.h"
+
/* All this is needed to build the constant node for methods: */
# include "irprog_t.h"
# include "ircons.h"
# include "tv_t.h"
+#if DEBUG_libfirm
+# include "irdump.h" /* for output if errors occur. */
+#endif
+
# include "callgraph.h" /* for dumping debug output */
/*******************************************************************/
/** general **/
/*******************************************************************/
+entity *unknown_entity = NULL; entity *get_unknown_entity(void) { return unknown_entity; }
+#define UNKNOWN_ENTITY_NAME "unknown_entity"
+
+static INLINE entity *
+new_rd_entity (dbg_info *db, type *owner, ident *name, type *type);
+
void
init_entity (void)
{
+ 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, 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));
+
+ sym.entity_p = unknown_entity;
+ current_ir_graph = get_const_code_irg();
+ unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
}
+
/*-----------------------------------------------------------------*/
/* ENTITY */
/*-----------------------------------------------------------------*/
-static void insert_entity_in_owner (entity *ent) {
+static INLINE void insert_entity_in_owner (entity *ent) {
type *owner = ent->owner;
switch (get_type_tpop_code(owner)) {
case tpo_class: {
}
}
-entity *
-new_entity (type *owner, ident *name, type *type)
+/**
+ * creates a new entity
+ */
+static INLINE entity *
+new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
{
entity *res;
ir_graph *rem;
assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
- res = (entity *) xmalloc (sizeof (entity));
+ res = xmalloc(sizeof(*res));
+ memset(res, 0, sizeof(*res));
res->kind = k_entity;
- assert_legal_owner_of_ent(owner);
res->owner = owner;
res->name = name;
res->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 {
}
res->irg = NULL;
+ //res->accesses = NULL;
+
#ifdef DEBUG_libfirm
res->nr = get_irp_new_node_nr();
-#endif
+#endif /* DEBUG_libfirm */
res->visit = 0;
+ set_entity_dbg_info(res, db);
- /* Remember entity in it's owner. */
- insert_entity_in_owner (res);
return res;
}
+
entity *
new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
- entity *res = new_entity(owner, name, type);
- set_entity_dbg_info(res, db);
+ entity *res;
+
+ assert_legal_owner_of_ent(owner);
+ res = new_rd_entity(db, owner, name, type);
+ /* Remember entity in it's owner. */
+ insert_entity_in_owner (res);
+
return res;
}
+entity *
+new_entity (type *owner, ident *name, type *type) {
+ return new_d_entity(owner, name, type, NULL);
+}
+
+
+
+
static void free_entity_attrs(entity *ent) {
int i;
if (get_type_tpop(get_entity_owner(ent)) == type_class) {
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();
+ 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)(entity *ent) {
- return __get_entity_name(ent);
+(get_entity_name)(const entity *ent) {
+ return _get_entity_name(ent);
}
ident *
-(get_entity_ident)(entity *ent) {
+(get_entity_ident)(const entity *ent) {
return get_entity_ident(ent);
}
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)(entity *ent) {
- return __get_entity_allocation(ent);
+(get_entity_allocation)(const entity *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
-(get_entity_visibility)(entity *ent) {
- return __get_entity_visibility(ent);
+(get_entity_visibility)(const entity *ent) {
+ return _get_entity_visibility(ent);
}
void
}
ent_variability
-(get_entity_variability)(entity *ent) {
- return __get_entity_variability(ent);
+(get_entity_variability)(const entity *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)(entity *ent) {
- return __get_entity_volatility(ent);
+(get_entity_volatility)(const entity *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)(entity *ent) {
- return __get_entity_peculiarity(ent);
+(get_entity_peculiarity)(const entity *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)(entity *ent) {
- return __get_entity_stickyness(ent);
+(get_entity_stickyness)(const entity *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 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))
+ return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
+
m = get_irn_mode(n);
switch(get_irn_opcode(n)) {
case iro_Const:
case iro_SymConst:
case iro_Unknown:
return true; break;
- case iro_Add:
- case iro_Sub:
- case iro_Mul:
- case iro_And:
- case iro_Or:
- case iro_Eor:
- if (is_irn_const_expression(get_binop_left(n)))
- return is_irn_const_expression(get_binop_right(n));
case iro_Conv:
case iro_Cast:
return is_irn_const_expression(get_irn_n(n, 0));
ir_node *nn;
ir_mode *m;
+ /* @@@ GL I think we should implement this using the routines from irgopt for
+ dead node elimination/inlineing. */
+
m = get_irn_mode(n);
switch(get_irn_opcode(n)) {
case iro_Const:
- nn = new_Const(m, get_Const_tarval(n)); break;
+ nn = new_Const(m, get_Const_tarval(n)); set_Const_type(nn, get_Const_type(n));
+ //nn = new_rd_Const_type(get_irn_dbg_info(n), current_ir_graph, get_cur_block(),
+ // m, get_Const_tarval(n), get_Const_type(n));
+ break;
case iro_SymConst:
-
- nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
+ nn = new_d_SymConst_type(NULL, get_SymConst_symbol(n), get_SymConst_kind(n),
+ get_SymConst_value_type(n));
break;
case iro_Add:
nn = new_Add(copy_const_value(get_Add_left(n)),
- copy_const_value(get_Add_right(n)), m); break;
+ copy_const_value(get_Add_right(n)), m); break;
case iro_Sub:
nn = new_Sub(copy_const_value(get_Sub_left(n)),
- copy_const_value(get_Sub_right(n)), m); break;
+ copy_const_value(get_Sub_right(n)), m); break;
case iro_Mul:
nn = new_Mul(copy_const_value(get_Mul_left(n)),
- copy_const_value(get_Mul_right(n)), m); break;
+ copy_const_value(get_Mul_right(n)), m); break;
case iro_And:
nn = new_And(copy_const_value(get_And_left(n)),
- copy_const_value(get_And_right(n)), m); break;
+ copy_const_value(get_And_right(n)), m); break;
case iro_Or:
nn = new_Or(copy_const_value(get_Or_left(n)),
- copy_const_value(get_Or_right(n)), m); break;
+ copy_const_value(get_Or_right(n)), m); break;
case iro_Eor:
nn = new_Eor(copy_const_value(get_Eor_left(n)),
- copy_const_value(get_Eor_right(n)), m); break;
+ copy_const_value(get_Eor_right(n)), m); break;
case iro_Cast:
nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
case iro_Conv:
nn = new_Unknown(m); break;
default:
DDMN(n);
- assert(0 && "opdope invalid or not implemented");
+ assert(0 && "opcode invalid or not implemented");
nn = NULL;
break;
}
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_graph *rem = current_ir_graph;
type *arrtp = get_entity_type(ent);
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);
current_ir_graph = get_const_code_irg();
for (i = 0; i < num_vals; i++) {
- val = new_Const(get_tarval_mode (values[i]), values[i]);
+ val = new_Const_type(values[i], elttp);
add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
}
}
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)) {
- int size = get_mode_size_bits (get_type_mode(node_tp));
- int align = get_mode_align_bits(get_type_mode(node_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)
- size = align;
+ size = align;
else {
- assert(size % align == 0);
- /* ansonsten aufrunden */
+ assert(size % align == 0);
+ /* ansonsten aufrunden */
}
offset += size * get_compound_graph_path_array_index(path, i);
} else {
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)(entity *ent) {
- return __get_entity_offset_bytes(ent);
+(get_entity_offset_bytes)(const entity *ent) {
+ return _get_entity_offset_bytes(ent);
}
int
-(get_entity_offset_bits)(entity *ent) {
- return __get_entity_offset_bits(ent);
+(get_entity_offset_bits)(const entity *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)(entity *ent) {
- return __get_entity_link(ent);
+(get_entity_link)(const entity *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)(entity *ent) {
- return __get_entity_irg(ent);
+(get_entity_irg)(const entity *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. */
+ * aber erhalten bleiben soll? Wandle die Entitaet in description oder
+ * inherited um! */
/* assert(irg); */
assert((irg && ent->peculiarity == peculiarity_existent) ||
+ (!irg && (ent->peculiarity == peculiarity_existent)
+ && (ent -> visibility == visibility_external_allocated)) ||
(!irg && ent->peculiarity == peculiarity_description) ||
(!irg && ent->peculiarity == peculiarity_inherited));
ent->irg = irg;
}
int
-(is_entity)(void *thing) {
- return __is_entity(thing);
+(is_entity)(const void *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 (!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);
- }
- assert(res);
- return res;
-}
-
-
-
-/*******************************************************************/
-/** Debug aides **/
-/*******************************************************************/
-
-
-#if 1 || DEBUG_libfirm
-int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
-
-
-
-#define X(a) case a: fprintf(F, #a); break
-void dump_entity_to_file (FILE *F, entity *ent) {
- int i, j;
- assert(ent && ent->kind == k_entity);
- type *owner = get_entity_owner(ent);
- type *type = get_entity_type(ent);
- fprintf(F, "entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent));
- fprintf(F, " type: %s (%ld)\n", get_type_name(type), get_type_nr(type));
- fprintf(F, " owner: %s (%ld)\n", get_type_name(owner), get_type_nr(owner));
-
- if (is_class_type(get_entity_owner(ent))) {
- if (get_entity_n_overwrites(ent) > 0) {
- fprintf(F, " overwrites:\n");
- for (i = 0; i < get_entity_n_overwrites(ent); ++i) {
- entity *ov = get_entity_overwrites(ent, i);
- fprintf(F, " %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
- }
- } else {
- fprintf(F, " Does not overwrite other entities. \n");
- }
- if (get_entity_n_overwrittenby(ent) > 0) {
- fprintf(F, " overwritten by:\n");
- for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) {
- entity *ov = get_entity_overwrittenby(ent, i);
- fprintf(F, " %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
- }
- } else {
- fprintf(F, " Is not overwriten by other entities. \n");
- }
- }
-
- fprintf(F, " allocation: ");
- switch (get_entity_allocation(ent)) {
- X(allocation_dynamic);
- X(allocation_automatic);
- X(allocation_static);
- X(allocation_parameter);
- }
-
- fprintf(F, "\n visibility: ");
- switch (get_entity_visibility(ent)) {
- X(visibility_local);
- X(visibility_external_visible);
- X(visibility_external_allocated);
- }
-
- fprintf(F, "\n variability: ");
- switch (get_entity_variability(ent)) {
- X(variability_uninitialized);
- X(variability_initialized);
- X(variability_part_constant);
- X(variability_constant);
- }
-
- if (get_entity_variability(ent) != variability_uninitialized) {
- if (is_atomic_entity(ent)) {
- fprintf(F, "\n atomic value: ");
- dump_node_opcode(F, get_atomic_ent_value(ent));
- } else {
- fprintf(F, "\n compound values:");
- for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
- compound_graph_path *path = get_compound_ent_value_path(ent, i);
- entity *ent0 = get_compound_graph_path_node(path, 0);
- fprintf(F, "\n %3d ", get_entity_offset_bits(ent0));
- if (get_type_state(type) == layout_fixed)
- fprintf(F, "(%3d) ", get_compound_ent_value_offset_bits(ent, i));
- fprintf(F, "%s", get_entity_name(ent0));
- for (j = 0; j < get_compound_graph_path_length(path); ++j) {
- entity *node = get_compound_graph_path_node(path, j);
- fprintf(F, ".%s", get_entity_name(node));
- if (is_array_type(get_entity_owner(node)))
- fprintf(F, "[%d]", get_compound_graph_path_array_index(path, j));
- }
- fprintf(F, "\t = ");
- dump_node_opcode(F, get_compound_ent_value(ent, i));
- }
- }
- }
-
- fprintf(F, "\n volatility: ");
- switch (get_entity_volatility(ent)) {
- X(volatility_non_volatile);
- X(volatility_is_volatile);
- }
-
- fprintf(F, "\n peculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent)));
- fprintf(F, "\n ld_name: %s", ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
- fprintf(F, "\n offset: %d", get_entity_offset_bits(ent));
- if (is_method_type(get_entity_type(ent))) {
- if (get_entity_irg(ent)) /* can be null */ {
- fprintf(F, "\n irg = %ld", get_irg_graph_nr(get_entity_irg(ent)));
- if (get_irp_callgraph_state() == irp_callgraph_and_calltree_consistent) {
- fprintf(F, "\n recursion depth %d", get_irg_recursion_depth(get_entity_irg(ent)));
- fprintf(F, "\n loop depth %d", get_irg_loop_depth(get_entity_irg(ent)));
- }
- } else {
- fprintf(F, "\n irg = NULL");
- }
- }
- fprintf(F, "\n\n");
-}
-#undef X
-
-void dump_entity (entity *ent) {
- dump_entity_to_file(stdout, ent);
-}
-
-#else /* DEBUG_libfirm */
-void dump_entity_to_file (FILE *F, entity *ent) {}
-void dump_entity (entity *ent) {}
-#endif /* DEBUG_libfirm */
projects / libfirm / blobdiff