X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=b3f5808d499ea5d45f704ab37f7ec8154492b55c;hb=2155c74fc9fba5f2de3047d7954ae39bdc90c21e;hp=5dbd292d351ee547909b9f685d72d373ca30dabc;hpb=1ce363f80e6a204d4011f85813362d9bd1d0e7e4;p=libfirm

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 5dbd292d3..b3f5808d4 100644
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -40,13 +40,13 @@
 #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.
@@ -170,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;
@@ -255,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));
@@ -687,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) {
@@ -1216,18 +1330,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);