X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=da62e15a3cdbff7200b157bd223e44b4e19d88a8;hb=40bcf0e300a51c02c1cac9d2d26a45f9cd9585f5;hp=fdc465dfd301b802145eeffdbd5c71325e1f7dc0;hpb=1ec30d95387eb392ba5a1adc7958ebd91383d59c;p=libfirm

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index fdc465dfd..da62e15a3 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -40,22 +40,51 @@
 #include "irhooks.h"
 #include "irprintf.h"
 
-/* All this is needed to build the constant node for methods: */
 #include "irprog_t.h"
 #include "ircons.h"
 #include "tv_t.h"
-#include "irdump.h"  /* for output if errors occur. */
+#include "irdump.h"
+#include "irgraph_t.h"
 
-#include "callgraph.h"  /* for dumping debug output */
+#include "callgraph.h"
 
-/*******************************************************************/
+/**
+ * An interval initializer.
+ */
+typedef struct interval_initializer interval_initializer;
+
+/**
+ * A value initializer.
+ */
+typedef struct value_initializer value_initializer;
+
+struct interval_initializer {
+	int                  first_index; /**< The first index of the initialized interval. */
+	int                  last_index;  /**< The last index of the initialized interval. */
+	interval_initializer *next;       /**< Points to the next interval initializer. */
+};
+
+struct value_initializer {
+	ir_entity *ent;           /**< The initialized entity. */
+	value_initializer *next;  /**< Points to the next value initializer. */
+};
+
+typedef union initializer {
+	ir_node              *value;     /**< The value of the initializer. */
+	ir_node              **values;   /**< The values of an interval. */
+	value_initializer    *val_init;  /**< Points the the head of the next value initializers. */
+	interval_initializer *int_init;  /**< Points to the head of the next value initializers. */
+} initializer;
+
+/*-----------------------------------------------------------------*/
 /** general                                                       **/
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 
 ir_entity *unknown_entity = NULL;
 
 ir_entity *get_unknown_entity(void) { return unknown_entity; }
 
+/** The name of the unknown entity. */
 #define UNKNOWN_ENTITY_NAME "unknown_entity"
 
 /*-----------------------------------------------------------------*/
@@ -114,11 +143,13 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
 	res->allocation           = allocation_automatic;
 	res->visibility           = visibility_local;
 	res->volatility           = volatility_non_volatile;
+	res->align                = align_is_aligned;
 	res->stickyness           = stickyness_unsticky;
 	res->peculiarity          = peculiarity_existent;
 	res->address_taken        = ir_address_taken_unknown;
 	res->final                = 0;
 	res->compiler_gen         = 0;
+	res->backend_marked       = 0;
 	res->offset               = -1;
 	res->offset_bit_remainder = 0;
 	res->link                 = NULL;
@@ -126,10 +157,11 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
 
 	if (is_Method_type(type)) {
 		symconst_symbol sym;
+		ir_mode *mode = is_Method_type(type) ? mode_P_code : mode_P_data;
 		sym.entity_p            = res;
 		rem                     = current_ir_graph;
 		current_ir_graph        = get_const_code_irg();
-		res->value              = new_SymConst(sym, symconst_addr_ent);
+		res->value              = new_SymConst(mode, sym, symconst_addr_ent);
 		current_ir_graph        = rem;
 		res->allocation         = allocation_static;
 		res->variability        = variability_constant;
@@ -138,7 +170,6 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
 		res->attr.mtd_attr.param_access       = NULL;
 		res->attr.mtd_attr.param_weight       = NULL;
 		res->attr.mtd_attr.irg                = NULL;
-		res->attr.mtd_attr.section            = section_text;
 	} else if (is_compound_type(type)) {
 		res->variability = variability_uninitialized;
 		res->value       = NULL;
@@ -201,7 +232,7 @@ static void free_entity_attrs(ir_entity *ent) {
 	}
 	if (is_compound_entity(ent)) {
 		if (ent->attr.cmpd_attr.val_paths) {
-			for (i = 0; i < get_compound_ent_n_values(ent); i++)
+			for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i)
 				if (ent->attr.cmpd_attr.val_paths[i]) {
 					/* free_compound_graph_path(ent->attr.cmpd_attr.val_paths[i]) ;  * @@@ warum nich? */
 					/* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
@@ -223,11 +254,16 @@ static void free_entity_attrs(ir_entity *ent) {
 	}
 }  /* free_entity_attrs */
 
+/*
+ * Copies the entity if the new_owner is different from the
+ * owner of the old entity,  else returns the old entity.
+ */
 ir_entity *
 copy_entity_own(ir_entity *old, ir_type *new_owner) {
 	ir_entity *newe;
 	assert(is_entity(old));
 	assert(is_compound_type(new_owner));
+	assert(get_type_state(new_owner) != layout_fixed);
 
 	if (old->owner == new_owner) return old;
 	newe = xmalloc(sizeof(*newe));
@@ -451,7 +487,7 @@ void
 	_set_entity_volatility(ent, vol);
 }  /* set_entity_volatility */
 
-/* return the name of the volatility */
+/* Return the name of the volatility. */
 const char *get_volatility_name(ir_volatility var)
 {
 #define X(a)    case a: return #a
@@ -463,6 +499,28 @@ const char *get_volatility_name(ir_volatility var)
 #undef X
 }  /* get_volatility_name */
 
+ir_align
+(get_entity_align)(const ir_entity *ent) {
+	return _get_entity_align(ent);
+}  /* get_entity_align */
+
+void
+(set_entity_align)(ir_entity *ent, ir_align a) {
+	_set_entity_align(ent, a);
+}  /* set_entity_align */
+
+/* Return the name of the alignment. */
+const char *get_align_name(ir_align a)
+{
+#define X(a)    case a: return #a
+	switch (a) {
+	X(align_non_aligned);
+	X(align_is_aligned);
+	default: return "BAD VALUE";
+	}
+#undef X
+}  /* get_align_name */
+
 ir_peculiarity
 (get_entity_peculiarity)(const ir_entity *ent) {
 	return _get_entity_peculiarity(ent);
@@ -493,6 +551,16 @@ void (set_entity_compiler_generated)(ir_entity *ent, int flag) {
 	_set_entity_compiler_generated(ent, flag);
 }  /* set_entity_compiler_generated */
 
+/* Checks if an entity is marked by the backend */
+int (is_entity_backend_marked)(const ir_entity *ent) {
+	return _is_entity_backend_marked(ent);
+}  /* is_entity_backend_marked */
+
+/* Sets/resets the compiler generated flag */
+void (set_entity_backend_marked)(ir_entity *ent, int flag) {
+	_set_entity_backend_marked(ent, flag);
+}  /* set_entity_backend_marked */
+
 /* Checks if the address of an entity was taken. */
 ir_address_taken_state (get_entity_address_taken)(const ir_entity *ent) {
 	return _get_entity_address_taken(ent);
@@ -541,6 +609,7 @@ set_atomic_ent_value(ir_entity *ent, ir_node *val) {
 	assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
 	if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
 		return;
+	assert(get_irn_mode(val) == get_type_mode(ent->type));
 	ent->value = val;
 }  /* set_atomic_ent_value */
 
@@ -587,7 +656,7 @@ ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
 		nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
 		break;
 	case iro_SymConst:
-		nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
+		nn = new_d_SymConst_type(dbg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n),
 			get_SymConst_value_type(n));
 		break;
 	case iro_Add:
@@ -622,6 +691,116 @@ ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
 	return nn;
 }  /* copy_const_value */
 
+static ir_initializer_t null_initializer = { IR_INITIALIZER_NULL };
+
+ir_initializer_t *get_initializer_null(void)
+{
+	return &null_initializer;
+}
+
+ir_initializer_t *create_initializer_const(ir_node *value)
+{
+	struct obstack *obst = get_irg_obstack(get_const_code_irg());
+
+	ir_initializer_t *initializer
+		= obstack_alloc(obst, sizeof(ir_initializer_const_t));
+	initializer->kind         = IR_INITIALIZER_CONST;
+	initializer->consti.value = value;
+
+	return initializer;
+}
+
+ir_initializer_t *create_initializer_tarval(tarval *tv)
+{
+	struct obstack *obst = get_irg_obstack(get_const_code_irg());
+
+	ir_initializer_t *initializer
+		= obstack_alloc(obst, sizeof(ir_initializer_tarval_t));
+	initializer->kind         = IR_INITIALIZER_TARVAL;
+	initializer->tarval.value = tv;
+
+	return initializer;
+}
+
+ir_initializer_t *create_initializer_compound(unsigned n_entries)
+{
+	struct obstack *obst = get_irg_obstack(get_const_code_irg());
+
+	size_t i;
+	size_t size  = sizeof(ir_initializer_compound_t)
+	             + (n_entries-1) * sizeof(ir_initializer_t*);
+
+	ir_initializer_t *initializer = obstack_alloc(obst, size);
+	initializer->kind                    = IR_INITIALIZER_COMPOUND;
+	initializer->compound.n_initializers = n_entries;
+
+	for(i = 0; i < n_entries; ++i) {
+		initializer->compound.initializers[i] = get_initializer_null();
+	}
+
+	return initializer;
+}
+
+ir_node *get_initializer_const_value(const ir_initializer_t *initializer)
+{
+	assert(initializer->kind == IR_INITIALIZER_CONST);
+	return initializer->consti.value;
+}
+
+tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
+{
+	assert(initializer->kind == IR_INITIALIZER_TARVAL);
+	return initializer->tarval.value;
+}
+
+unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer)
+{
+	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
+	return initializer->compound.n_initializers;
+}
+
+void set_initializer_compound_value(ir_initializer_t *initializer,
+                                    unsigned index, ir_initializer_t *value)
+{
+	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
+	assert(index < initializer->compound.n_initializers);
+
+	initializer->compound.initializers[index] = value;
+}
+
+ir_initializer_t *get_initializer_compound_value(
+		const ir_initializer_t *initializer, unsigned index)
+{
+	assert(initializer->kind == IR_INITIALIZER_COMPOUND);
+	assert(index < initializer->compound.n_initializers);
+
+	return initializer->compound.initializers[index];
+}
+
+ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer)
+{
+	return initializer->kind;
+}
+
+static void check_entity_initializer(ir_entity *entity)
+{
+	/* TODO */
+	(void) entity;
+}
+
+void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer)
+{
+	entity->attr.initializer = initializer;
+	entity->has_initializer  = 1;
+	check_entity_initializer(entity);
+}
+
+ir_initializer_t *get_entity_initializer(const ir_entity *entity)
+{
+	assert(entity->has_initializer);
+	return entity->attr.initializer;
+}
+
 /* Creates a new compound graph path. */
 compound_graph_path *
 new_compound_graph_path(ir_type *tp, int length) {
@@ -730,6 +909,7 @@ set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path
 
 int
 get_compound_ent_n_values(ir_entity *ent) {
+	assert(!ent->has_initializer);
 	assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 	return ARR_LEN(ent->attr.cmpd_attr.values);
 }  /* get_compound_ent_n_values */
@@ -737,6 +917,7 @@ get_compound_ent_n_values(ir_entity *ent) {
 ir_node *
 get_compound_ent_value(ir_entity *ent, int pos) {
 	assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
+	assert(!ent->has_initializer);
 	assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values));
 	return ent->attr.cmpd_attr.values[pos];
 }  /* get_compound_ent_value */
@@ -744,6 +925,7 @@ get_compound_ent_value(ir_entity *ent, int pos) {
 compound_graph_path *
 get_compound_ent_value_path(ir_entity *ent, int pos) {
 	assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
+	assert(!ent->has_initializer);
 	assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths));
 	return ent->attr.cmpd_attr.val_paths[pos];
 }  /* get_compound_ent_value_path */
@@ -792,7 +974,8 @@ static int equal_paths(compound_graph_path *path1, int *visited_indices, compoun
  * Returns the position of a value with the given path.
  * The path must contain array indices for all array element entities.
  *
- * @todo  This implementation is very low and should be replaced when the new tree oriented
+ * @todo  This implementation is very slow (O(number of initializers^2) and should
+ *        be replaced when the new tree oriented
  *        value representation is finally implemented.
  */
 static int get_compound_ent_pos_by_path(ir_entity *ent, compound_graph_path *path) {
@@ -835,17 +1018,19 @@ ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *pat
 
 void
 remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent) {
-	int i;
+	int i, n;
 	assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
-	for (i = 0; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths)); ++i) {
+
+	n = ARR_LEN(ent->attr.cmpd_attr.val_paths);
+	for (i = 0; i < n; ++i) {
 		compound_graph_path *path = ent->attr.cmpd_attr.val_paths[i];
 		if (path->list[path->len-1].node == value_ent) {
-			for (; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths))-1; ++i) {
+			for (; i < n - 1; ++i) {
 				ent->attr.cmpd_attr.val_paths[i] = ent->attr.cmpd_attr.val_paths[i+1];
 				ent->attr.cmpd_attr.values[i]    = ent->attr.cmpd_attr.values[i+1];
 			}
-			ARR_SETLEN(ir_entity*, ent->attr.cmpd_attr.val_paths, ARR_LEN(ent->attr.cmpd_attr.val_paths) - 1);
-			ARR_SETLEN(ir_node*,   ent->attr.cmpd_attr.values,    ARR_LEN(ent->attr.cmpd_attr.values)    - 1);
+			ARR_SETLEN(ir_entity*, ent->attr.cmpd_attr.val_paths, n - 1);
+			ARR_SETLEN(ir_node*,   ent->attr.cmpd_attr.values,    n - 1);
 			break;
 		}
 	}
@@ -919,57 +1104,58 @@ set_array_entity_values(ir_entity *ent, tarval **values, int num_vals) {
 }  /* set_array_entity_values */
 
 /* Return the overall offset of value at position pos in bytes. */
-int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
+unsigned get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
 	compound_graph_path *path;
 	int path_len, i;
-	int offset = 0;
+	unsigned offset = 0;
 	ir_type *curr_tp;
 
 	assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 
-	path = get_compound_ent_value_path(ent, pos);
+	path     = get_compound_ent_value_path(ent, pos);
 	path_len = get_compound_graph_path_length(path);
-	curr_tp = path->tp;
+	curr_tp  = path->tp;
 
 	for (i = 0; i < path_len; ++i) {
-		ir_entity *node = get_compound_graph_path_node(path, i);
-		ir_type *node_tp = get_entity_type(node);
-
 		if (is_Array_type(curr_tp)) {
-			int size  = get_type_size_bits(node_tp);
-			int align = get_type_alignment_bits(node_tp);
-			int idx;
+			ir_type *elem_type = get_array_element_type(curr_tp);
+			unsigned size      = get_type_size_bytes(elem_type);
+			unsigned align     = get_type_alignment_bytes(elem_type);
+			int      idx;
 
 			assert(size > 0);
 			if(size % align > 0) {
 				size += align - (size % align);
 			}
-			assert(size % 8 == 0);
-			size /= 8;
 			idx = get_compound_graph_path_array_index(path, i);
 			assert(idx >= 0);
 			offset += size * idx;
+			curr_tp = elem_type;
 		} else {
+			ir_entity *node = get_compound_graph_path_node(path, i);
 			offset += get_entity_offset(node);
+			curr_tp = get_entity_type(node);
 		}
-		curr_tp = node_tp;
 	}
 
 	return offset;
 }  /* get_compound_ent_value_offset_bytes */
 
 /* Return the offset in bits from the last byte address. */
-int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos) {
+unsigned get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos) {
 	compound_graph_path *path;
 	int path_len;
 	ir_entity *last_node;
 
 	assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 
-	path = get_compound_ent_value_path(ent, pos);
-	path_len = get_compound_graph_path_length(path);
+	path      = get_compound_ent_value_path(ent, pos);
+	path_len  = get_compound_graph_path_length(path);
 	last_node = get_compound_graph_path_node(path, path_len - 1);
 
+	if(last_node == NULL)
+		return 0;
+
   	return get_entity_offset_bits_remainder(last_node);
 }  /* get_compound_ent_value_offset_bit_remainder */
 
@@ -1014,11 +1200,13 @@ get_entity_n_overwrites(ir_entity *ent) {
 
 int
 get_entity_overwrites_index(ir_entity *ent, ir_entity *overwritten) {
-	int i;
+	int i, n;
 	assert(is_Class_type(get_entity_owner(ent)));
-	for (i = 0; i < get_entity_n_overwrites(ent); i++)
+	n = get_entity_n_overwrites(ent);
+	for (i = 0; i < n; ++i) {
 		if (get_entity_overwrites(ent, i) == overwritten)
 			return i;
+	}
 	return -1;
 }  /* get_entity_overwrites_index */
 
@@ -1038,15 +1226,17 @@ set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten) {
 
 void
 remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) {
-	int i;
+	int i, n;
 	assert(is_Class_type(get_entity_owner(ent)));
-	for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
+	n = ARR_LEN(ent->overwrites);
+	for (i = 0; i < n; ++i) {
 		if (ent->overwrites[i] == overwritten) {
-			for(; i < (ARR_LEN (ent->overwrites))-1; i++)
+			for (; i < n - 1; i++)
 				ent->overwrites[i] = ent->overwrites[i+1];
-			ARR_SETLEN(ir_entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
+			ARR_SETLEN(ir_entity*, ent->overwrites, n - 1);
 			break;
 		}
+	}
 }  /* remove_entity_overwrites */
 
 void
@@ -1057,16 +1247,18 @@ add_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) {
 int
 get_entity_n_overwrittenby(ir_entity *ent) {
 	assert(is_Class_type(get_entity_owner(ent)));
-	return (ARR_LEN (ent->overwrittenby));
+	return ARR_LEN(ent->overwrittenby);
 }  /* get_entity_n_overwrittenby */
 
 int
 get_entity_overwrittenby_index(ir_entity *ent, ir_entity *overwrites) {
-	int i;
+	int i, n;
 	assert(is_Class_type(get_entity_owner(ent)));
-	for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
+	n = get_entity_n_overwrittenby(ent);
+	for (i = 0; i < n; ++i) {
 		if (get_entity_overwrittenby(ent, i) == overwrites)
 			return i;
+	}
 	return -1;
 }  /* get_entity_overwrittenby_index */
 
@@ -1084,16 +1276,19 @@ set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites) {
 	ent->overwrittenby[pos] = overwrites;
 }  /* set_entity_overwrittenby */
 
-void    remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) {
-	int i;
+void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) {
+	int i, n;
 	assert(is_Class_type(get_entity_owner(ent)));
-	for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
+
+	n = ARR_LEN(ent->overwrittenby);
+	for (i = 0; i < n; ++i) {
 		if (ent->overwrittenby[i] == overwrites) {
-			for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
+			for(; i < n - 1; ++i)
 				ent->overwrittenby[i] = ent->overwrittenby[i+1];
-			ARR_SETLEN(ir_entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
+			ARR_SETLEN(ir_entity*, ent->overwrittenby, n - 1);
 			break;
 		}
+	}
 }  /* remove_entity_overwrittenby */
 
 /* A link to store intermediate information */
@@ -1138,18 +1333,6 @@ void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number) {
 	ent->attr.mtd_attr.vtable_number = vtable_number;
 }  /* set_entity_vtable_number */
 
-/* Returns the section of a method. */
-ir_img_section get_method_img_section(const ir_entity *ent) {
-	assert(is_method_entity((ir_entity *)ent));
-	return ent->attr.mtd_attr.section;
-}  /* get_method_img_section */
-
-/* Sets the section of a method. */
-void set_method_img_section(ir_entity *ent, ir_img_section section) {
-	assert(is_method_entity(ent));
-	ent->attr.mtd_attr.section = section;
-}  /* set_method_img_section */
-
 int
 (is_entity)(const void *thing) {
 	return _is_entity(thing);
@@ -1177,6 +1360,8 @@ int is_method_entity(ir_entity *ent) {
 /**
  * @todo not implemented!!! */
 int equal_entity(ir_entity *ent1, ir_entity *ent2) {
+	(void) ent1;
+	(void) ent2;
 	fprintf(stderr, " calling unimplemented equal entity!!! \n");
 	return 1;
 }  /* equal_entity */
@@ -1268,6 +1453,14 @@ ir_type *(get_entity_repr_class)(const ir_entity *ent) {
 	return _get_entity_repr_class(ent);
 }  /* get_entity_repr_class */
 
+dbg_info *(get_entity_dbg_info)(const ir_entity *ent) {
+	return _get_entity_dbg_info(ent);
+}  /* get_entity_dbg_info */
+
+void (set_entity_dbg_info)(ir_entity *ent, dbg_info *db) {
+	_set_entity_dbg_info(ent, db);
+}  /* set_entity_dbg_info */
+
 /* Initialize entity module. */
 void firm_init_entity(void)
 {
@@ -1282,5 +1475,6 @@ void firm_init_entity(void)
 
 	current_ir_graph      = get_const_code_irg();
 	sym.entity_p          = unknown_entity;
-	unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
+	/* TODO: we need two unknown_entities here, one for code and one for data */
+	unknown_entity->value = new_SymConst(mode_P_data, sym, symconst_addr_ent);
 }  /* firm_init_entity */