fix warning

[libfirm] / ir / tr / entity.c

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 5dbd292..b3f5808 100644 (file)
--- 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);