-/* Set has no effect for existent entities of type method. */
-INLINE ir_node *
-get_atomic_ent_value(entity *ent) {
- assert(ent); assert(is_atomic_entity(ent));
- assert((ent->variability != uninitialized));
- return ent->value;
-}
-
-INLINE void
-set_atomic_ent_value(entity *ent, ir_node *val) {
- assert(ent && is_atomic_entity(ent) && (ent->variability != uninitialized));
- if ((is_method_type(ent->type)) && (ent->peculiarity==existent)) return;
- ent->value = val;
-}
-
-
-ir_node *copy_const_value(ir_node *n) {
- ir_node *nn;
- ir_mode *m;
-
- m = get_irn_mode(n);
- switch(get_irn_opcode(n)) {
- case iro_Const:
- nn = new_Const(m, get_Const_tarval(n)); break;
- case iro_SymConst:
- nn = new_SymConst(get_SymConst_type_or_id(n), get_SymConst_kind(n)); break;
- case iro_Add:
- nn = new_Add(copy_const_value(get_Add_left(n)), copy_const_value(get_Add_right(n)), m); break;
- case iro_Unknown:
- nn = new_Unknown(); break;
- default:
- DDMN(n);
- assert(0 && "opdope invalid or not implemented");
- nn = NULL;
- break;
- }
- return nn;
-}
-
-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 *) malloc (sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
- res->kind = k_ir_compound_graph_path;
- res->tp = tp;
- res->len = length;
- memset(res->nodes, 0, sizeof(entity *) * length);
- return res;
-}
-
-INLINE void
-free_compound_graph_path (compound_graph_path *gr) {
- assert(gr && is_compound_graph_path(gr));
- free(gr);
-}
-
-INLINE 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 */
-INLINE 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;
- owner = get_entity_type(node);
- }
- if (pos == get_compound_graph_path_length(gr) -1)
- if (!is_atomic_type(owner)) return false;
- return true;
-}
-
-INLINE int
-get_compound_graph_path_length(compound_graph_path *gr) {
- assert(gr && is_compound_graph_path(gr));
- return gr->len;
-}
-
-INLINE entity *
-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];
-}
-
-INLINE void
-set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
- assert(gr && is_compound_graph_path(gr));
- assert(pos >= 0 && pos < gr->len);
- assert(is_entity(node));
- gr->nodes[pos] = node;
- assert(is_proper_compound_graph_path(gr, pos));
-}
-
-/* A value of a compound entity is a pair of value and the corresponding path to a member of
- the compound. */
-INLINE void
-add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- ARR_APP1 (ir_node *, ent->values, val);
- ARR_APP1 (compound_graph_path *, ent->val_paths, path);
-}
-
-INLINE void
-set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- ent->values[pos+1] = val;
- ent->val_paths[pos+1] = path;
-}
-
-INLINE int
-get_compound_ent_n_values(entity *ent) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- return (ARR_LEN (ent->values))-1;
-}
-
-INLINE ir_node *
-get_compound_ent_value(entity *ent, int pos) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- return ent->values[pos+1];
-}
-
-INLINE compound_graph_path *
-get_compound_ent_value_path(entity *ent, int pos) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- return ent->val_paths[pos+1];
-}
-
-void
-remove_compound_ent_value(entity *ent, entity *value_ent) {
- int i;
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- for (i = 1; i < (ARR_LEN (ent->val_paths)); i++) {
- compound_graph_path *path = ent->val_paths[i];
- if (path->nodes[path->len] == 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];
- }
- ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1);
- ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1);
- break;
- }
- }
-}
-
-INLINE void
-add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- compound_graph_path *path = new_compound_graph_path(get_entity_owner(ent), 1);
- path->nodes[0] = member;
- add_compound_ent_value_w_path(ent, val, path);
-}
-
-/* Copies the firm subgraph referenced by val to const_code_irg and adds
- the node as constant initialization to ent.
- The subgraph may not contain control flow operations.
-INLINE void
-copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
- ir_graph *rem = current_ir_graph;
-
- assert(get_entity_variability(ent) != uninitialized);
- current_ir_graph = get_const_code_irg();
-
- val = copy_const_value(val);
- add_compound_ent_value(ent, val, member);
- current_ir_graph = rem;
- }*/
-
-/* Copies the value i of the entity to current_block in current_ir_graph.
-ir_node *
-copy_compound_ent_value(entity *ent, int pos) {
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- return copy_const_value(ent->values[pos+1]);
- }*/
-
-INLINE entity *
-get_compound_ent_value_member(entity *ent, int pos) {
- compound_graph_path *path;
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- path = get_compound_ent_value_path(ent, pos);
- assert(path->len == 1);
-
- return get_compound_graph_path_node(path, 0);
-}
-
-INLINE void
-set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
- compound_graph_path *path;
- assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
- path = new_compound_graph_path(get_entity_owner(ent), 1);
- set_compound_graph_path_node(path, 0, member);
- set_compound_ent_value_w_path(ent, val, path, pos);
-}
-
-void
-set_array_entity_values(entity *ent, tarval **values, int num_vals) {
- int i;
- ir_graph *rem = current_ir_graph;
- type *arrtp = get_entity_type(ent);
- ir_node *val;
-
- assert(is_array_type(arrtp));
- assert(get_array_n_dimensions(arrtp) == 1);
- /* One bound is sufficient, the nunmber of constant fields makes the
- size. */
- assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
- assert(get_entity_variability(ent) != 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]);
- add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
- }
- current_ir_graph = rem;
-}
-
-INLINE int
-get_entity_offset (entity *ent) {
- return ent->offset;
-}
-
-INLINE void
-set_entity_offset (entity *ent, int offset) {
- ent->offset = offset;
-}
-
-INLINE void
-add_entity_overwrites (entity *ent, entity *overwritten) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- ARR_APP1 (entity *, ent->overwrites, overwritten);
- ARR_APP1 (entity *, overwritten->overwrittenby, ent);
-}
-
-INLINE int
-get_entity_n_overwrites (entity *ent) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- return (ARR_LEN (ent->overwrites))-1;
-}
-
-int
-get_entity_overwrites_index(entity *ent, entity *overwritten) {
- int i;
- 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;
- return -1;
-}
-
-INLINE entity *
-get_entity_overwrites (entity *ent, int pos) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- assert(pos < get_entity_n_overwrites(ent));
- return ent->overwrites[pos+1];
-}
-
-INLINE void
-set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- assert(pos < get_entity_n_overwrites(ent));
- ent->overwrites[pos+1] = overwritten;
-}
-
-void
-remove_entity_overwrites(entity *ent, entity *overwritten) {
- int i;
- assert(ent && is_class_type(get_entity_owner(ent)));
- for (i = 1; i < (ARR_LEN (ent->overwrites)); i++)
- if (ent->overwrites[i] == overwritten) {
- for(; i < (ARR_LEN (ent->overwrites))-1; i++)
- ent->overwrites[i] = ent->overwrites[i+1];
- ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
- break;
- }
-}
-
-INLINE void
-add_entity_overwrittenby (entity *ent, entity *overwrites) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- add_entity_overwrites(overwrites, ent);
-}
-
-INLINE int
-get_entity_n_overwrittenby (entity *ent) {
- assert(ent);
- assert(is_class_type(get_entity_owner(ent)));
- return (ARR_LEN (ent->overwrittenby))-1;
+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
+ = (ir_initializer_t*)OALLOC(obst, ir_initializer_const_t);
+ initializer->kind = IR_INITIALIZER_CONST;
+ initializer->consti.value = value;
+
+ return initializer;
+}
+
+ir_initializer_t *create_initializer_tarval(ir_tarval *tv)
+{
+ struct obstack *obst = get_irg_obstack(get_const_code_irg());
+
+ ir_initializer_t *initializer
+ = (ir_initializer_t*)OALLOC(obst, ir_initializer_tarval_t);
+ initializer->kind = IR_INITIALIZER_TARVAL;
+ initializer->tarval.value = tv;
+
+ return initializer;
+}
+
+ir_initializer_t *create_initializer_compound(size_t 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 * sizeof(ir_initializer_t*)
+ - sizeof(ir_initializer_t*);
+
+ ir_initializer_t *initializer
+ = (ir_initializer_t*)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 skip_Id(initializer->consti.value);
+}
+
+ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
+{
+ assert(initializer->kind == IR_INITIALIZER_TARVAL);
+ return initializer->tarval.value;
+}
+
+size_t 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,
+ size_t 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, size_t 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)
+{
+#ifndef NDEBUG
+ ir_initializer_t *initializer = entity->initializer;
+ ir_type *entity_tp = get_entity_type(entity);
+ switch (initializer->kind) {
+ case IR_INITIALIZER_COMPOUND:
+ assert(is_compound_type(entity_tp) || is_Array_type(entity_tp));
+ break;
+ case IR_INITIALIZER_CONST:
+ /* methods are initialized by a SymConst */
+ assert(is_atomic_type(entity_tp) || is_Method_type(entity_tp));
+ break;
+ case IR_INITIALIZER_TARVAL:
+ assert(is_atomic_type(entity_tp));
+ break;
+ case IR_INITIALIZER_NULL:
+ break;
+ }
+#endif
+}
+
+void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer)
+{
+ entity->initializer = initializer;
+ check_entity_initializer(entity);
+}
+
+int has_entity_initializer(const ir_entity *entity)
+{
+ return entity->initializer != NULL;
+}
+
+ir_initializer_t *get_entity_initializer(const ir_entity *entity)
+{
+ return entity->initializer;
+}
+
+int (get_entity_offset)(const ir_entity *ent)
+{
+ return _get_entity_offset(ent);
+}
+
+void (set_entity_offset)(ir_entity *ent, int offset)
+{
+ _set_entity_offset(ent, offset);
+}
+
+unsigned char (get_entity_offset_bits_remainder)(const ir_entity *ent)
+{
+ return _get_entity_offset_bits_remainder(ent);
+}
+
+void (set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset)
+{
+ _set_entity_offset_bits_remainder(ent, offset);
+}
+
+void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
+{
+ if (ent->overwrites == NULL) {
+ ent->overwrites = NEW_ARR_F(ir_entity*, 0);
+ }
+ ARR_APP1(ir_entity *, ent->overwrites, overwritten);
+ if (overwritten->overwrittenby == NULL) {
+ overwritten->overwrittenby = NEW_ARR_F(ir_entity*, 0);
+ }
+ ARR_APP1(ir_entity *, overwritten->overwrittenby, ent);
+}
+
+size_t get_entity_n_overwrites(const ir_entity *ent)
+{
+ if (ent->overwrites == NULL)
+ return 0;
+ return ARR_LEN(ent->overwrites);