/** general **/
/*******************************************************************/
+entity *unknown_entity = NULL; entity *get_unknown_entity(void) { return unknown_entity; }
+#define UNKNOWN_ENTITY_NAME "unknown_entity"
+
+static INLINE entity *
+new_rd_entity (dbg_info *db, type *owner, ident *name, type *type);
+
void
init_entity (void)
{
+ assert(unknown_type && "Call init_type before init_entity!");
+ assert(!unknown_entity && "Call init_entity only once!");
+ unknown_entity = new_rd_entity(NULL, unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), unknown_type);
+ set_entity_visibility(unknown_entity, visibility_external_allocated);
+ set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
+
+ symconst_symbol sym;
+ sym.entity_p = unknown_entity;
+ current_ir_graph = get_const_code_irg();
+ unknown_entity->value = new_SymConst(sym, symconst_addr_ent);
}
+
/*-----------------------------------------------------------------*/
/* ENTITY */
/*-----------------------------------------------------------------*/
-static void insert_entity_in_owner (entity *ent) {
+static INLINE void insert_entity_in_owner (entity *ent) {
type *owner = ent->owner;
switch (get_type_tpop_code(owner)) {
case tpo_class: {
}
}
-entity *
-new_entity (type *owner, ident *name, type *type)
+static INLINE entity *
+new_rd_entity (dbg_info *db, type *owner, ident *name, type *type)
{
entity *res;
ir_graph *rem;
assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
res = (entity *) xmalloc (sizeof (entity));
+ memset(res, 0, sizeof(res));
res->kind = k_entity;
- assert_legal_owner_of_ent(owner);
res->owner = owner;
res->name = name;
res->type = type;
}
res->irg = NULL;
- res->accesses = NULL;
+ //res->accesses = NULL;
#ifdef DEBUG_libfirm
res->nr = get_irp_new_node_nr();
-#endif
+ res->c_name = (char *)get_id_str (name);
+#endif /* DEBUG_libfirm */
res->visit = 0;
+ set_entity_dbg_info(res, db);
- /* Remember entity in it's owner. */
- insert_entity_in_owner (res);
return res;
}
+
entity *
new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
- entity *res = new_entity(owner, name, type);
- set_entity_dbg_info(res, db);
+ assert_legal_owner_of_ent(owner);
+ entity *res = new_rd_entity(db, owner, name, type);
+ /* Remember entity in it's owner. */
+ insert_entity_in_owner (res);
+
return res;
}
+entity *
+new_entity (type *owner, ident *name, type *type) {
+ return new_d_entity(owner, name, type, NULL);
+}
+
+
+
+
static void free_entity_attrs(entity *ent) {
int i;
if (get_type_tpop(get_entity_owner(ent)) == type_class) {
}
#ifdef DEBUG_libfirm
new->nr = get_irp_new_node_nr();
+ new->c_name = (char *)get_id_str (new->name);
#endif
insert_entity_in_owner (new);
}
const char *
-(get_entity_name)(entity *ent) {
+(get_entity_name)(const entity *ent) {
return __get_entity_name(ent);
}
ident *
-(get_entity_ident)(entity *ent) {
+(get_entity_ident)(const entity *ent) {
return get_entity_ident(ent);
}
}
ent_allocation
-(get_entity_allocation)(entity *ent) {
+(get_entity_allocation)(const entity *ent) {
return __get_entity_allocation(ent);
}
ent_visibility
-(get_entity_visibility)(entity *ent) {
+(get_entity_visibility)(const entity *ent) {
return __get_entity_visibility(ent);
}
}
ent_variability
-(get_entity_variability)(entity *ent) {
+(get_entity_variability)(const entity *ent) {
return __get_entity_variability(ent);
}
}
ent_volatility
-(get_entity_volatility)(entity *ent) {
+(get_entity_volatility)(const entity *ent) {
return __get_entity_volatility(ent);
}
}
peculiarity
-(get_entity_peculiarity)(entity *ent) {
+(get_entity_peculiarity)(const entity *ent) {
return __get_entity_peculiarity(ent);
}
/* Get the entity's stickyness */
ent_stickyness
-(get_entity_stickyness)(entity *ent) {
+(get_entity_stickyness)(const entity *ent) {
return __get_entity_stickyness(ent);
}
int is_irn_const_expression(ir_node *n) {
ir_mode *m;
+ /* we are in dange iff an exception will arise. TODO: be more precisely,
+ * for instance Div. will NOT rise if divisor != 0
+ */
+ if (is_binop(n) && !is_fragile_op(n))
+ return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
+
m = get_irn_mode(n);
switch(get_irn_opcode(n)) {
case iro_Const:
case iro_SymConst:
case iro_Unknown:
return true; break;
- case iro_Add:
- case iro_Sub:
- case iro_Mul:
- case iro_And:
- case iro_Or:
- case iro_Eor:
- if (is_irn_const_expression(get_binop_left(n)))
- return is_irn_const_expression(get_binop_right(n));
case iro_Conv:
case iro_Cast:
return is_irn_const_expression(get_irn_n(n, 0));
ir_node *nn;
ir_mode *m;
+ /* @@@ GL I think we should implement this using the routines from irgopt for
+ dead node elimination/inlineing. */
+
m = get_irn_mode(n);
switch(get_irn_opcode(n)) {
case iro_Const:
- nn = new_Const(m, get_Const_tarval(n)); break;
+ nn = new_Const(m, get_Const_tarval(n)); set_Const_type(nn, get_Const_type(n));
+ //nn = new_rd_Const_type(get_irn_dbg_info(n), current_ir_graph, get_cur_block(),
+ // m, get_Const_tarval(n), get_Const_type(n));
+ break;
case iro_SymConst:
-
- nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
+ nn = new_d_SymConst_type(NULL, get_SymConst_symbol(n), get_SymConst_kind(n),
+ get_SymConst_value_type(n));
break;
case iro_Add:
nn = new_Add(copy_const_value(get_Add_left(n)),
- copy_const_value(get_Add_right(n)), m); break;
+ copy_const_value(get_Add_right(n)), m); break;
case iro_Sub:
nn = new_Sub(copy_const_value(get_Sub_left(n)),
- copy_const_value(get_Sub_right(n)), m); break;
+ copy_const_value(get_Sub_right(n)), m); break;
case iro_Mul:
nn = new_Mul(copy_const_value(get_Mul_left(n)),
- copy_const_value(get_Mul_right(n)), m); break;
+ copy_const_value(get_Mul_right(n)), m); break;
case iro_And:
nn = new_And(copy_const_value(get_And_left(n)),
- copy_const_value(get_And_right(n)), m); break;
+ copy_const_value(get_And_right(n)), m); break;
case iro_Or:
nn = new_Or(copy_const_value(get_Or_left(n)),
- copy_const_value(get_Or_right(n)), m); break;
+ copy_const_value(get_Or_right(n)), m); break;
case iro_Eor:
nn = new_Eor(copy_const_value(get_Eor_left(n)),
- copy_const_value(get_Eor_right(n)), m); break;
+ copy_const_value(get_Eor_right(n)), m); break;
case iro_Cast:
nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
case iro_Conv:
nn = new_Unknown(m); break;
default:
DDMN(n);
- assert(0 && "opdope invalid or not implemented");
+ assert(0 && "opcode invalid or not implemented");
nn = NULL;
break;
}
ir_graph *rem = current_ir_graph;
type *arrtp = get_entity_type(ent);
ir_node *val;
+ type *elttp = get_array_element_type(arrtp);
assert(is_array_type(arrtp));
assert(get_array_n_dimensions(arrtp) == 1);
current_ir_graph = get_const_code_irg();
for (i = 0; i < num_vals; i++) {
- val = new_Const(get_tarval_mode (values[i]), values[i]);
+ val = new_Const_type(values[i], elttp);
add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
}
}
int
-(get_entity_offset_bytes)(entity *ent) {
+(get_entity_offset_bytes)(const entity *ent) {
return __get_entity_offset_bytes(ent);
}
int
-(get_entity_offset_bits)(entity *ent) {
+(get_entity_offset_bits)(const entity *ent) {
return __get_entity_offset_bits(ent);
}
/* A link to store intermediate information */
void *
-(get_entity_link)(entity *ent) {
+(get_entity_link)(const entity *ent) {
return __get_entity_link(ent);
}
}
ir_graph *
-(get_entity_irg)(entity *ent) {
+(get_entity_irg)(const entity *ent) {
return __get_entity_irg(ent);
}
assert(ent && is_method_type(get_entity_type(ent)));
/* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
* Methode selbst nicht mehr aufgerufen werden kann, die Entität
- * aber erhalten bleiben soll. */
+ * aber erhalten bleiben soll? Wandle die Entitaet in description oder
+ * inherited um! */
/* assert(irg); */
assert((irg && ent->peculiarity == peculiarity_existent) ||
(!irg && ent->peculiarity == peculiarity_description) ||
}
int
-(is_entity)(void *thing) {
+(is_entity)(const void *thing) {
return __is_entity(thing);
}