/*
- * 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.
*
* PURPOSE.
*/
-/*
- * Project: libFIRM
- * File name: ir/tr/entity.c
- * Purpose: Representation of all program known entities.
- * Author: Martin Trapp, Christian Schaefer
- * Modified by: Goetz Lindenmaier, Michael Beck
- * Created:
- * CVS-ID: $Id$
- * Copyright: (c) 1998-2007 Universität Karlsruhe
+/**
+ * @file
+ * @brief Representation of all program known entities.
+ * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
+ * @version $Id$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#ifdef HAVE_STDDEF_H
-# include <stddef.h>
-#endif
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.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"
#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"
-#include "callgraph.h" /* for dumping debug output */
+/**
+ * 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"
/*-----------------------------------------------------------------*/
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;
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;
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;
}
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. */
}
} /* 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));
_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
#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);
_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);
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 */
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:
case iro_Unknown:
nn = new_d_Unknown(m); break;
default:
- DDMN(n);
assert(0 && "opcode invalid or not implemented");
nn = NULL;
break;
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) {
* 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) {
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;
}
}
} /* 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 */
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 */
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
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 */
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 */
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);
/**
* @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 */
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)
{
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 */