* 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"
+# include "irtools.h"
+# include "irhooks.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 **/
/*******************************************************************/
-void
-init_entity (void)
-{
-}
+entity *unknown_entity = NULL;
+
+entity *get_unknown_entity(void) { return unknown_entity; }
+
+#define UNKNOWN_ENTITY_NAME "unknown_entity"
/*-----------------------------------------------------------------*/
/* 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. This entity is NOT inserted in the owner type.
+ *
+ * @param db debug info for this entity
+ * @param owner the owner type of the new entity
+ * @param name the name of the new entity
+ * @param type the type of the new entity
+ *
+ * @return the new created 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->kind = k_entity;
- assert_legal_owner_of_ent(owner);
- res->owner = owner;
- res->name = name;
- res->type = type;
+ res = xmalloc(sizeof(*res));
+ memset(res, 0, sizeof(*res));
+
+ res->kind = k_entity;
+ res->name = name;
+ res->ld_name = NULL;
+ res->owner = owner;
+ res->type = type;
if (get_type_tpop(type) == type_method)
res->allocation = allocation_static;
else
res->allocation = allocation_automatic;
- res->visibility = visibility_local;
- res->offset = -1;
- if (is_method_type(type)) {
+ res->visibility = visibility_local;
+ res->volatility = volatility_non_volatile;
+ res->stickyness = stickyness_unsticky;
+ res->offset = -1;
+ res->peculiarity = peculiarity_existent;
+ res->link = NULL;
+
+
+ if (is_Method_type(type)) {
symconst_symbol sym;
- sym.entity_p = res;
- res->variability = variability_constant;
- rem = current_ir_graph;
- current_ir_graph = get_const_code_irg();
- res->value = new_SymConst(sym, symconst_addr_ent);
- current_ir_graph = rem;
- } else {
+ sym.entity_p = res;
+ rem = current_ir_graph;
+ current_ir_graph = get_const_code_irg();
+ res->value = new_SymConst(sym, symconst_addr_ent);
+ current_ir_graph = rem;
+ res->variability = variability_constant;
+ res->irg_add_properties = mtp_property_inherited;
+ res->param_access = NULL;
+ res->param_weight = NULL;
+ }
+ else {
res->variability = variability_uninitialized;
- res->value = NULL;
- res->values = NULL;
- res->val_paths = NULL;
+ res->value = NULL;
+ res->values = NULL;
+ res->val_paths = NULL;
}
- res->peculiarity = peculiarity_existent;
- 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();
-#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);
+
+ hook_new_entity(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) {
if (ent->val_paths) {
if (is_compound_entity(ent))
for (i = 0; i < get_compound_ent_n_values(ent); i++)
- if (ent->val_paths[i]) ;
- /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */
- /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
- /* DEL_ARR_F(ent->val_paths); */
+ if (ent->val_paths[i]) ;
+ /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */
+ /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
+ /* DEL_ARR_F(ent->val_paths); */
}
ent->val_paths = NULL;
ent->values = NULL;
+
+ if (ent->param_access) {
+ DEL_ARR_F(ent->param_access);
+ ent->param_access = NULL;
+ }
+ if (ent->param_weight) {
+ DEL_ARR_F(ent->param_weight);
+ ent->param_weight = NULL;
+ }
}
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;
}
void
free_entity (entity *ent) {
assert(ent && ent->kind == k_entity);
- free_tarval_entity(ent);
free_entity_attrs(ent);
ent->kind = k_BAD;
free(ent);
}
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);
}
-/*
-void set_entitye_ld_name (entity *, char *ld_name);
-void set_entity_ld_ident (entity *, ident *ld_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)(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);
+visibility
+(get_entity_visibility)(const entity *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)(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)) {
- /* Allocate datastructures for constant values */
+ /* Allocate data structures for constant values */
ent->values = NEW_ARR_F(ir_node *, 0);
ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
}
+ if ((is_atomic_type(ent->type)) &&
+ (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
+ /* Set default constant value. */
+ ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
+ }
if ((is_compound_type(ent->type)) &&
(var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
- /* Free datastructures for constant values */
+ /* Free data structures for constant values */
DEL_ARR_F(ent->values); ent->values = NULL;
DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
}
}
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));
+ return 1;
case iro_Conv:
case iro_Cast:
return is_irn_const_expression(get_irn_n(n, 0));
default:
- return false;
break;
}
- return false;
+ return 0;
}
-
-ir_node *copy_const_value(ir_node *n) {
+/*
+ * Copies a firm subgraph that complies to the restrictions for
+ * constant expressions to current_block in current_ir_graph.
+ */
+ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
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)) {
+ switch (get_irn_opcode(n)) {
case iro_Const:
- nn = new_Const(m, get_Const_tarval(n)); break;
+ nn = new_d_Const_type(dbg, 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(dbg, 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;
+ nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
+ copy_const_value(dbg, 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;
+ nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
+ copy_const_value(dbg, 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;
+ nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
+ copy_const_value(dbg, 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;
+ nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
+ copy_const_value(dbg, 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;
+ nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
+ copy_const_value(dbg, 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;
+ nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
+ copy_const_value(dbg, get_Eor_right(n)), m); break;
case iro_Cast:
- nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
+ nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
case iro_Conv:
- nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
+ nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
case iro_Unknown:
- nn = new_Unknown(m); break;
+ nn = new_d_Unknown(m); break;
default:
DDMN(n);
- assert(0 && "opdope invalid or not implemented");
+ assert(0 && "opcode invalid or not implemented");
nn = NULL;
break;
}
return nn;
}
+/* Creates a new compound graph path. */
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->list[0]));
+ memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0]));
+ res->kind = k_ir_compound_graph_path;
+ res->tp = tp;
+ res->len = length;
+
return res;
}
-void
-free_compound_graph_path (compound_graph_path *gr) {
+/* Frees an graph path object */
+void free_compound_graph_path (compound_graph_path *gr) {
assert(gr && is_compound_graph_path(gr));
gr->kind = k_BAD;
- free(gr ->arr_indicees);
free(gr);
}
-int
-is_compound_graph_path(void *thing) {
+/* Returns non-zero if an object is a compound graph path */
+int is_compound_graph_path(void *thing) {
return (get_kind(thing) == k_ir_compound_graph_path);
}
-/* checks whether nodes 0..pos are correct (all lie on a path.) */
-/* @@@ not implemented */
+/* Checks whether the path up to pos is correct. If the path contains a NULL,
+ * assumes the path is not complete and returns 'true'. */
int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
int i;
entity *node;
type *owner = gr->tp;
+
for (i = 0; i <= pos; i++) {
node = get_compound_graph_path_node(gr, i);
- if (get_entity_owner(node) != owner) return false;
+ if (node == NULL)
+ /* Path not yet complete. */
+ return 1;
+ if (get_entity_owner(node) != owner)
+ return 0;
owner = get_entity_type(node);
}
if (pos == get_compound_graph_path_length(gr))
- if (!is_atomic_type(owner)) return false;
- return true;
+ if (!is_atomic_type(owner))
+ return 0;
+ return 1;
}
-int
-get_compound_graph_path_length(compound_graph_path *gr) {
+/* Returns the length of a graph path */
+int get_compound_graph_path_length(compound_graph_path *gr) {
assert(gr && is_compound_graph_path(gr));
return gr->len;
}
get_compound_graph_path_node(compound_graph_path *gr, int pos) {
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
- return gr->nodes[pos];
+ return gr->list[pos].node;
}
void
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
assert(is_entity(node));
- gr->nodes[pos] = node;
+ gr->list[pos].node = node;
assert(is_proper_compound_graph_path(gr, pos));
}
get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
- return gr->arr_indicees[pos];
+ return gr->list[pos].index;
}
void
set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
- gr->arr_indicees[pos] = index;
+ gr->list[pos].index = index;
}
/* A value of a compound entity is a pair of value and the corresponding path to a member of
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 0;
+
+ 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 0;
+
+ 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 0;
+ }
+ else
+ assert(low + visited_indicees[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 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;
assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
compound_graph_path *path = ent->val_paths[i];
- if (path->nodes[path->len-1] == value_ent) {
+ if (path->list[path->len-1].node == 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);
void
add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
compound_graph_path *path;
- type *owner_tp = get_entity_owner(ent);
+ type *owner_tp = get_entity_owner(member);
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)) {
+ path = new_compound_graph_path(get_entity_type(ent), 1);
+ path->list[0].node = member;
+ if (is_Array_type(owner_tp)) {
+ int max;
+ int i;
+
assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
- int max = get_array_lower_bound_int(owner_tp, 0) -1;
- for (int i = 0; i < get_compound_ent_n_values(ent); ++i) {
+ max = get_array_lower_bound_int(owner_tp, 0) -1;
+ for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
- if (index > max) max = index;
+ if (index > max) {
+ max = index;
+ }
}
- path->arr_indicees[0] = max + 1;
+ path->list[0].index = max + 1;
}
add_compound_ent_value_w_path(ent, val, path);
}
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 (size <= align)
- size = align;
+ 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;
else {
- assert(size % align == 0);
- /* ansonsten aufrunden */
+ assert(size % align == 0);
+ /* ansonsten aufrunden */
}
offset += size * get_compound_graph_path_array_index(path, i);
} else {
else
init = get_array_upper_bound_int(arr, 0) +1;
- set_entity_link(get_array_element_entity(arr), (void *)init);
+ set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
}
assert(get_array_n_dimensions(arr) == 1);
if (has_array_lower_bound(arr, dim)) {
- next = (int)get_entity_link(elem_ent) +1;
+ next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
if (has_array_upper_bound(arr, dim)) {
int upper = get_array_upper_bound_int(arr, dim);
if (next == upper) next = get_array_lower_bound_int(arr, dim);
}
} else {
- next = (int)get_entity_link(elem_ent) -1;
+ next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
if (has_array_lower_bound(arr, dim)) {
int upper = get_array_upper_bound_int(arr, dim);
if (next == upper) next = get_array_upper_bound_int(arr, dim);
}
}
- set_entity_link(elem_ent, (void *)next);
+ set_entity_link(elem_ent, INT_TO_PTR(next));
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");
permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0.
- So inc all entries by one. */
+ So inc all entries by one. */
//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!!! */
-bool equal_entity(entity *ent1, entity *ent2) {
+ * @todo not implemented!!! */
+int equal_entity(entity *ent1, entity *ent2) {
fprintf(stderr, " calling unimplemented equal entity!!! \n");
- return true;
+ return 1;
}
-unsigned long get_entity_visited(entity *ent) {
- assert(ent && ent->kind == k_entity);
- return ent->visit;
+unsigned long (get_entity_visited)(entity *ent) {
+ return _get_entity_visited(ent);
}
-void set_entity_visited(entity *ent, unsigned long num) {
- assert(ent && ent->kind == k_entity);
- ent->visit = num;
+
+void (set_entity_visited)(entity *ent, unsigned long num) {
+ _set_entity_visited(ent, num);
}
+
/* Sets visited field in entity to entity_visited. */
-void mark_entity_visited(entity *ent) {
- assert(ent && ent->kind == k_entity);
- ent->visit = type_visited;
+void (mark_entity_visited)(entity *ent) {
+ _mark_entity_visited(ent);
}
-
-bool entity_visited(entity *ent) {
- assert(ent && ent->kind == k_entity);
- return get_entity_visited(ent) >= type_visited;
+int (entity_visited)(entity *ent) {
+ return _entity_visited(ent);
}
-bool entity_not_visited(entity *ent) {
- assert(ent && ent->kind == k_entity);
- return get_entity_visited(ent) < type_visited;
+int (entity_not_visited)(entity *ent) {
+ return _entity_not_visited(ent);
}
-/* 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;
+/* Returns the mask of the additional entity properties. */
+unsigned get_entity_additional_properties(entity *ent) {
+ ir_graph *irg;
- if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
+ assert(is_Method_type(get_entity_type(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;
- }
+ /* first check, if the graph has additional properties */
+ irg = get_entity_irg(ent);
- return res;
+ if (irg)
+ return get_irg_additional_properties(irg);
+
+ if (ent->irg_add_properties & mtp_property_inherited)
+ return get_method_additional_properties(get_entity_type(ent));
+
+ return ent->irg_add_properties;
}
-/** 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);
+/* Sets the mask of the additional graph properties. */
+void set_entity_additional_properties(entity *ent, unsigned property_mask)
+{
+ ir_graph *irg;
+
+ assert(is_Method_type(get_entity_type(ent)));
+
+ /* first check, if the graph exists */
+ irg = get_entity_irg(ent);
+ 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 */
+ ent->irg_add_properties = property_mask & ~mtp_property_inherited;
}
- assert(res);
- return res;
}
+/* Sets one additional graph property. */
+void set_entity_additional_property(entity *ent, mtp_additional_property flag)
+{
+ ir_graph *irg;
+ assert(is_Method_type(get_entity_type(ent)));
-/*******************************************************************/
-/** Debug aides **/
-/*******************************************************************/
-
-
-#if 1 || DEBUG_libfirm
-int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
-
-#define X(a) case a: printf(#a); break
-void dump_entity (entity *ent) {
- int i, j;
- type *owner = get_entity_owner(ent);
- type *type = get_entity_type(ent);
- assert(ent && ent->kind == k_entity);
- printf("entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent));
- printf(" type: %s (%ld)\n", get_type_name(type), get_type_nr(type));
- printf(" owner: %s (%ld)\n", get_type_name(owner), get_type_nr(owner));
-
- if (get_entity_n_overwrites(ent) > 0) {
- printf(" overwrites:\n");
- for (i = 0; i < get_entity_n_overwrites(ent); ++i) {
- entity *ov = get_entity_overwrites(ent, i);
- printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
- }
- } else {
- printf(" Does not overwrite other entities. \n");
- }
- if (get_entity_n_overwrittenby(ent) > 0) {
- printf(" overwritten by:\n");
- for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) {
- entity *ov = get_entity_overwrittenby(ent, i);
- printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov)));
- }
- } else {
- printf(" Is not overwriten by other entities. \n");
- }
-
- printf(" allocation: ");
- switch (get_entity_allocation(ent)) {
- X(allocation_dynamic);
- X(allocation_automatic);
- X(allocation_static);
- X(allocation_parameter);
- }
+ /* first check, if the graph exists */
+ irg = get_entity_irg(ent);
+ if (irg)
+ set_irg_additional_property(irg, flag);
+ else {
+ unsigned mask = ent->irg_add_properties;
- printf("\n visibility: ");
- switch (get_entity_visibility(ent)) {
- X(visibility_local);
- X(visibility_external_visible);
- X(visibility_external_allocated);
- }
+ if (mask & mtp_property_inherited)
+ mask = get_method_additional_properties(get_entity_type(ent));
- printf("\n variability: ");
- switch (get_entity_variability(ent)) {
- X(variability_uninitialized);
- X(variability_initialized);
- X(variability_part_constant);
- X(variability_constant);
+ /* do not allow to set the mtp_property_inherited flag or
+ * the automatic inheritance of flags will not work */
+ ent->irg_add_properties = mask | (flag & ~mtp_property_inherited);
}
+}
- if (get_entity_variability(ent) != variability_uninitialized) {
- if (is_atomic_entity(ent)) {
- printf("\n atomic value: ");
- dump_node_opcode(stdout, get_atomic_ent_value(ent));
- } else {
- printf("\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);
- printf("\n %3d ", get_entity_offset_bits(ent0));
- if (get_type_state(type) == layout_fixed)
- printf("(%3d) ", get_compound_ent_value_offset_bits(ent, i));
- printf("%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);
- 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("\t = ");
- dump_node_opcode(stdout, get_compound_ent_value(ent, i));
- }
- }
- }
+void firm_init_entity(void)
+{
+ symconst_symbol sym;
- printf("\n volatility: ");
- switch (get_entity_volatility(ent)) {
- X(volatility_non_volatile);
- X(volatility_is_volatile);
- }
+ assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
+ assert(!unknown_entity && "Call firm_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));
- printf("\n peculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent)));
- printf("\n ld_name: %s", ent->ld_name ? get_entity_ld_name(ent) : "no yet set");
- printf("\n offset: %d", get_entity_offset_bits(ent));
- if (is_method_type(get_entity_type(ent))) {
- if (get_entity_irg(ent)) /* can be null */
- { printf("\n irg = %ld", get_irg_graph_nr(get_entity_irg(ent))); }
- else
- { printf("\n irg = NULL"); }
- }
- printf("\n\n");
+ sym.entity_p = unknown_entity;
+ current_ir_graph = get_const_code_irg();
+ unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
}
-#undef X
-#else /* DEBUG_libfirm */
-void dump_entity (entity *ent) {}
-#endif /* DEBUG_libfirm */
projects / libfirm / blobdiff