X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=0ac5c6828add405f5022c623bac49389711936fd;hb=e88385016800d3c56c3fa09770e9f7995c42e106;hp=65af77b8fae422bdcbc898e9ad18898c0f7b6254;hpb=7c36344d22a7c306a4e216f135c974bdb9f6b943;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 65af77b8f..0ac5c6828 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -60,45 +60,10 @@ ir_entity *get_unknown_entity(void) { return unknown_entity; } /* ENTITY */ /*-----------------------------------------------------------------*/ -/** - * Add an entity to it's already set owner type. - */ -static inline void insert_entity_in_owner(ir_entity *ent) -{ - ir_type *owner = ent->owner; - switch (get_type_tpop_code(owner)) { - case tpo_class: - add_class_member(owner, ent); - break; - case tpo_struct: - add_struct_member(owner, ent); - break; - case tpo_union: - add_union_member(owner, ent); - break; - case tpo_array: - set_array_element_entity(owner, ent); - break; - default: - panic("Unsupported type kind"); - } -} /* insert_entity_in_owner */ - -/** - * Creates a new entity. This entity is NOT inserted in the owner type. - * - * @param db debug info for this entity - * @param owner the owner type of the new entity - * @param name the name of the new entity - * @param type the type of the new entity - * - * @return the new created entity - */ -static inline ir_entity *new_rd_entity(dbg_info *db, ir_type *owner, - ident *name, ir_type *type) +ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, + dbg_info *db) { ir_entity *res; - ir_graph *rem; assert(!id_contains_char(name, ' ') && "entity name should not contain spaces"); @@ -122,16 +87,14 @@ static inline ir_entity *new_rd_entity(dbg_info *db, ir_type *owner, res->repr_class = NULL; if (is_Method_type(type)) { + ir_graph *irg = get_const_code_irg(); 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(); - set_atomic_ent_value(res, new_SymConst(mode, sym, symconst_addr_ent)); - current_ir_graph = rem; + set_atomic_ent_value(res, new_r_SymConst(irg, mode, sym, symconst_addr_ent)); res->linkage = IR_LINKAGE_CONSTANT; res->attr.mtd_attr.irg_add_properties = mtp_property_inherited; - res->attr.mtd_attr.vtable_number = VTABLE_NUM_NOT_SET; + res->attr.mtd_attr.vtable_number = IR_VTABLE_NUM_NOT_SET; res->attr.mtd_attr.param_access = NULL; res->attr.mtd_attr.param_weight = NULL; res->attr.mtd_attr.irg = NULL; @@ -142,41 +105,26 @@ static inline ir_entity *new_rd_entity(dbg_info *db, ir_type *owner, res->attr.code_attr.label = (ir_label_t) -1; } - if (is_Class_type(owner)) { - res->overwrites = NEW_ARR_F(ir_entity *, 0); - res->overwrittenby = NEW_ARR_F(ir_entity *, 0); - } else { - res->overwrites = NULL; - res->overwrittenby = NULL; - } + /* Remember entity in it's owner. */ + if (owner != NULL) + add_compound_member(owner, res); #ifdef DEBUG_libfirm res->nr = get_irp_new_node_nr(); -#endif /* DEBUG_libfirm */ +#endif res->visit = 0; set_entity_dbg_info(res, db); - return res; -} /* new_rd_entity */ - -ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, dbg_info *db) -{ - ir_entity *res; - - assert(is_compound_type(owner)); - res = new_rd_entity(db, owner, name, type); - /* Remember entity in it's owner. */ - insert_entity_in_owner(res); - hook_new_entity(res); + return res; -} /* new_d_entity */ +} ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type) { return new_d_entity(owner, name, type, NULL); -} /* new_entity */ +} /** * Free entity attributes. @@ -185,31 +133,23 @@ ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type) */ static void free_entity_attrs(ir_entity *ent) { - int i; - if (get_type_tpop(get_entity_owner(ent)) == type_class) { - DEL_ARR_F(ent->overwrites); ent->overwrites = NULL; - DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL; - } else { - assert(ent->overwrites == NULL); - assert(ent->overwrittenby == NULL); + if (ent->overwrites != NULL) { + DEL_ARR_F(ent->overwrites); + ent->overwrites = NULL; + } + if (ent->overwrittenby != NULL) { + DEL_ARR_F(ent->overwrittenby); + ent->overwrittenby = NULL; } + if (ent->initializer != NULL) { /* TODO: free initializers */ } else if (entity_has_compound_ent_values(ent)) { - if (ent->attr.cmpd_attr.val_paths) { - 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. */ - /* DEL_ARR_F(ent->attr.cmpd_attr.val_paths); */ - } - ent->attr.cmpd_attr.val_paths = NULL; - } + /* can't free compound graph path as it might be used + * multiple times */ + ent->attr.cmpd_attr.val_paths = NULL; } if (is_compound_entity(ent)) { - if (ent->attr.cmpd_attr.values) { - /*DEL_ARR_F(ent->attr.cmpd_attr.values)*/; - } ent->attr.cmpd_attr.values = NULL; } else if (is_method_entity(ent)) { if (ent->attr.mtd_attr.param_access) { @@ -221,7 +161,7 @@ static void free_entity_attrs(ir_entity *ent) ent->attr.mtd_attr.param_weight = NULL; } } -} /* free_entity_attrs */ +} /** * Creates a deep copy of an entity. @@ -247,12 +187,15 @@ static ir_entity *deep_entity_copy(ir_entity *old) newe->attr.mtd_attr.param_access = NULL; newe->attr.mtd_attr.param_weight = NULL; } + newe->overwrites = NULL; + newe->overwrittenby = NULL; #ifdef DEBUG_libfirm newe->nr = get_irp_new_node_nr(); #endif return newe; } + /* * Copies the entity if the new_owner is different from the * owner of the old entity, else returns the old entity. @@ -268,44 +211,39 @@ ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner) return old; /* create a deep copy so we are safe of aliasing and double-freeing. */ - newe = deep_entity_copy(old); + newe = deep_entity_copy(old); newe->owner = new_owner; + add_compound_member(new_owner, newe); - if (is_Class_type(new_owner)) { - newe->overwrites = NEW_ARR_F(ir_entity *, 0); - newe->overwrittenby = NEW_ARR_F(ir_entity *, 0); - } - - insert_entity_in_owner(newe); return newe; -} /* copy_entity_own */ +} ir_entity *copy_entity_name(ir_entity *old, ident *new_name) { ir_entity *newe; assert(old && old->kind == k_entity); - if (old->name == new_name) return old; - newe = deep_entity_copy(old); + if (old->name == new_name) + return old; + + newe = deep_entity_copy(old); newe->name = new_name; newe->ld_name = NULL; - - if (is_Class_type(newe->owner)) { - newe->overwrites = DUP_ARR_F(ir_entity *, old->overwrites); - newe->overwrittenby = DUP_ARR_F(ir_entity *, old->overwrittenby); - } - insert_entity_in_owner(newe); + add_compound_member(old->owner, newe); return newe; -} /* copy_entity_name */ +} void free_entity(ir_entity *ent) { + if (ent->owner != NULL && !is_Array_type(ent->owner)) + remove_compound_member(ent->owner, ent); + assert(ent && ent->kind == k_entity); free_entity_attrs(ent); ent->kind = k_BAD; - free(ent); -} /* free_entity */ + xfree(ent); +} /* Outputs a unique number for this node */ long get_entity_nr(const ir_entity *ent) @@ -316,7 +254,7 @@ long get_entity_nr(const ir_entity *ent) #else return (long)PTR_TO_INT(ent); #endif -} /* get_entity_nr */ +} const char *(get_entity_name)(const ir_entity *ent) { @@ -342,6 +280,9 @@ void set_entity_owner(ir_entity *ent, ir_type *owner) { assert(is_entity(ent)); assert(is_compound_type(owner)); + + remove_compound_member(ent->owner, ent); + add_compound_member(owner, ent); ent->owner = owner; } @@ -360,6 +301,11 @@ const char *(get_entity_ld_name)(const ir_entity *ent) return _get_entity_ld_name(ent); } +int entity_has_ld_ident(const ir_entity *entity) +{ + return entity->ld_name != NULL; +} + ir_type *(get_entity_type)(const ir_entity *ent) { return _get_entity_type(ent); @@ -390,7 +336,7 @@ const char *get_volatility_name(ir_volatility var) default: return "BAD VALUE"; } #undef X -} /* get_volatility_name */ +} ir_align (get_entity_aligned)(const ir_entity *ent) { @@ -422,7 +368,7 @@ const char *get_align_name(ir_align a) default: return "BAD VALUE"; } #undef X -} /* get_align_name */ +} void set_entity_label(ir_entity *ent, ir_label_t label) { @@ -450,7 +396,7 @@ void set_entity_visibility(ir_entity *entity, ir_visibility visibility) ir_visibility get_entity_visibility(const ir_entity *entity) { - return entity->visibility; + return (ir_visibility)entity->visibility; } void set_entity_linkage(ir_entity *entity, ir_linkage linkage) @@ -477,13 +423,13 @@ void remove_entity_linkage(ir_entity *entity, ir_linkage linkage) int (is_entity_compiler_generated)(const ir_entity *ent) { return _is_entity_compiler_generated(ent); -} /* is_entity_compiler_generated */ +} /* Sets/resets the compiler generated flag */ void (set_entity_compiler_generated)(ir_entity *ent, int flag) { _set_entity_compiler_generated(ent, flag); -} /* set_entity_compiler_generated */ +} ir_entity_usage (get_entity_usage)(const ir_entity *ent) { @@ -513,7 +459,7 @@ ir_node *get_atomic_ent_value(ir_entity *entity) return new_r_Const(get_const_code_irg(), get_mode_null(mode)); } case IR_INITIALIZER_TARVAL: { - tarval *tv = get_initializer_tarval_value(initializer); + ir_tarval *tv = get_initializer_tarval_value(initializer); return new_r_Const(get_const_code_irg(), tv); } case IR_INITIALIZER_CONST: @@ -561,14 +507,15 @@ int is_irn_const_expression(ir_node *n) break; } return 0; -} /* is_irn_const_expression */ +} /* * Copies a firm subgraph that complies to the restrictions for - * constant expressions to current_block in current_ir_graph. + * constant expressions to block. */ -ir_node *copy_const_value(dbg_info *dbg, ir_node *n) +ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *block) { + ir_graph *irg = get_irn_irg(block); ir_node *nn; ir_mode *m; @@ -578,41 +525,57 @@ ir_node *copy_const_value(dbg_info *dbg, ir_node *n) m = get_irn_mode(n); switch (get_irn_opcode(n)) { case iro_Const: - nn = new_d_Const_type(dbg, get_Const_tarval(n), get_Const_type(n)); + nn = new_rd_Const(dbg, irg, get_Const_tarval(n)); break; case iro_SymConst: - nn = new_d_SymConst_type(dbg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n), - get_SymConst_value_type(n)); + nn = new_rd_SymConst(dbg, irg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n)); break; case iro_Add: - nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)), - copy_const_value(dbg, get_Add_right(n)), m); break; + nn = new_rd_Add(dbg, block, + copy_const_value(dbg, get_Add_left(n), block), + copy_const_value(dbg, get_Add_right(n), block), m); + break; case iro_Sub: - nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)), - copy_const_value(dbg, get_Sub_right(n)), m); break; + nn = new_rd_Sub(dbg, block, + copy_const_value(dbg, get_Sub_left(n), block), + copy_const_value(dbg, get_Sub_right(n), block), m); + break; case iro_Mul: - nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)), - copy_const_value(dbg, get_Mul_right(n)), m); break; + nn = new_rd_Mul(dbg, block, + copy_const_value(dbg, get_Mul_left(n), block), + copy_const_value(dbg, get_Mul_right(n), block), m); + break; case iro_And: - nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)), - copy_const_value(dbg, get_And_right(n)), m); break; + nn = new_rd_And(dbg, block, + copy_const_value(dbg, get_And_left(n), block), + copy_const_value(dbg, get_And_right(n), block), m); + break; case iro_Or: - nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)), - copy_const_value(dbg, get_Or_right(n)), m); break; + nn = new_rd_Or(dbg, block, + copy_const_value(dbg, get_Or_left(n), block), + copy_const_value(dbg, get_Or_right(n), block), m); + break; case iro_Eor: - nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)), - copy_const_value(dbg, get_Eor_right(n)), m); break; + nn = new_rd_Eor(dbg, block, + copy_const_value(dbg, get_Eor_left(n), block), + copy_const_value(dbg, get_Eor_right(n), block), m); + break; case iro_Cast: - nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break; + nn = new_rd_Cast(dbg, block, + copy_const_value(dbg, get_Cast_op(n), block), + get_Cast_type(n)); + break; case iro_Conv: - nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break; + nn = new_rd_Conv(dbg, block, + copy_const_value(dbg, get_Conv_op(n), block), m); + break; case iro_Unknown: - nn = new_Unknown(m); break; + nn = new_r_Unknown(irg, m); break; default: panic("opcode invalid or not implemented"); } return nn; -} /* copy_const_value */ +} /** Return the name of the initializer kind. */ const char *get_initializer_kind_name(ir_initializer_kind_t ini) @@ -640,19 +603,19 @@ 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)); + = (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(tarval *tv) +ir_initializer_t *create_initializer_tarval(ir_tarval *tv) { struct obstack *obst = get_irg_obstack(get_const_code_irg()); ir_initializer_t *initializer - = obstack_alloc(obst, sizeof(ir_initializer_tarval_t)); + = (ir_initializer_t*)OALLOC(obst, ir_initializer_tarval_t); initializer->kind = IR_INITIALIZER_TARVAL; initializer->tarval.value = tv; @@ -667,7 +630,8 @@ ir_initializer_t *create_initializer_compound(unsigned n_entries) size_t size = sizeof(ir_initializer_compound_t) + (n_entries-1) * sizeof(ir_initializer_t*); - ir_initializer_t *initializer = obstack_alloc(obst, size); + ir_initializer_t *initializer + = (ir_initializer_t*)obstack_alloc(obst, size); initializer->kind = IR_INITIALIZER_COMPOUND; initializer->compound.n_initializers = n_entries; @@ -684,7 +648,7 @@ ir_node *get_initializer_const_value(const ir_initializer_t *initializer) return skip_Id(initializer->consti.value); } -tarval *get_initializer_tarval_value(const ir_initializer_t *initializer) +ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer) { assert(initializer->kind == IR_INITIALIZER_TARVAL); return initializer->tarval.value; @@ -726,7 +690,7 @@ static void check_entity_initializer(ir_entity *entity) ir_type *entity_tp = get_entity_type(entity); switch (initializer->kind) { case IR_INITIALIZER_COMPOUND: - assert(is_compound_type(entity_tp)); + assert(is_compound_type(entity_tp) || is_Array_type(entity_tp)); break; case IR_INITIALIZER_CONST: /* methods are initialized by a SymConst */ @@ -779,27 +743,26 @@ void (set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset) void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten) { -#ifndef NDEBUG - ir_type *owner = get_entity_owner(ent); - ir_type *ovw_ovner = get_entity_owner(overwritten); - assert(is_Class_type(owner)); - assert(is_Class_type(ovw_ovner)); - assert(! is_class_final(ovw_ovner)); -#endif /* NDEBUG */ + 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); } int get_entity_n_overwrites(const ir_entity *ent) { - assert(is_Class_type(get_entity_owner(ent))); - return (ARR_LEN(ent->overwrites)); + if (ent->overwrites == NULL) + return 0; + return ARR_LEN(ent->overwrites); } int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten) { int i, n; - assert(is_Class_type(get_entity_owner(ent))); n = get_entity_n_overwrites(ent); for (i = 0; i < n; ++i) { if (get_entity_overwrites(ent, i) == overwritten) @@ -810,14 +773,12 @@ int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten) ir_entity *get_entity_overwrites(const ir_entity *ent, int pos) { - assert(is_Class_type(get_entity_owner(ent))); assert(pos < get_entity_n_overwrites(ent)); return ent->overwrites[pos]; } void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten) { - assert(is_Class_type(get_entity_owner(ent))); assert(pos < get_entity_n_overwrites(ent)); ent->overwrites[pos] = overwritten; } @@ -825,8 +786,7 @@ void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten) void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) { int i, n; - assert(is_Class_type(get_entity_owner(ent))); - n = ARR_LEN(ent->overwrites); + n = get_entity_n_overwrites(ent); for (i = 0; i < n; ++i) { if (ent->overwrites[i] == overwritten) { for (; i < n - 1; i++) @@ -837,21 +797,17 @@ void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) } } -void add_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) -{ - add_entity_overwrites(overwrites, ent); -} int get_entity_n_overwrittenby(const ir_entity *ent) { - assert(is_Class_type(get_entity_owner(ent))); + if (ent->overwrittenby == NULL) + return 0; return ARR_LEN(ent->overwrittenby); } int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites) { int i, n; - assert(is_Class_type(get_entity_owner(ent))); n = get_entity_n_overwrittenby(ent); for (i = 0; i < n; ++i) { if (get_entity_overwrittenby(ent, i) == overwrites) @@ -862,14 +818,12 @@ int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites) ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos) { - assert(is_Class_type(get_entity_owner(ent))); assert(pos < get_entity_n_overwrittenby(ent)); return ent->overwrittenby[pos]; } void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites) { - assert(is_Class_type(get_entity_owner(ent))); assert(pos < get_entity_n_overwrittenby(ent)); ent->overwrittenby[pos] = overwrites; } @@ -877,9 +831,8 @@ void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites) void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) { int i, n; - assert(is_Class_type(get_entity_owner(ent))); - n = ARR_LEN(ent->overwrittenby); + n = get_entity_n_overwrittenby(ent); for (i = 0; i < n; ++i) { if (ent->overwrittenby[i] == overwrites) { for (; i < n - 1; ++i) @@ -976,7 +929,7 @@ int (entity_not_visited)(const ir_entity *ent) return _entity_not_visited(ent); } -unsigned get_entity_additional_properties(const ir_entity *ent) +mtp_additional_properties get_entity_additional_properties(const ir_entity *ent) { ir_graph *irg; @@ -994,7 +947,7 @@ unsigned get_entity_additional_properties(const ir_entity *ent) return ent->attr.mtd_attr.irg_add_properties; } -void set_entity_additional_properties(ir_entity *ent, unsigned property_mask) +void set_entity_additional_properties(ir_entity *ent, mtp_additional_properties property_mask) { ir_graph *irg; @@ -1005,13 +958,13 @@ void set_entity_additional_properties(ir_entity *ent, unsigned property_mask) if (irg) set_irg_additional_properties(irg, property_mask); else { - /* do not allow to set the mtp_property_inherited flag or - * the automatic inheritance of flags will not work */ + /* do not allow to set the mtp_property_inherited flag or + * the automatic inheritance of flags will not work */ ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited; } } -void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag) +void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties properties) { ir_graph *irg; @@ -1020,16 +973,16 @@ void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag /* first check, if the graph exists */ irg = get_entity_irg(ent); if (irg) - set_irg_additional_property(irg, flag); + add_irg_additional_properties(irg, properties); else { - unsigned mask = ent->attr.mtd_attr.irg_add_properties; + mtp_additional_properties mask = ent->attr.mtd_attr.irg_add_properties; if (mask & mtp_property_inherited) mask = get_method_additional_properties(get_entity_type(ent)); - /* do not allow to set the mtp_property_inherited flag or - * the automatic inheritance of flags will not work */ - ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited); + /* do not allow to set the mtp_property_inherited flag or + * the automatic inheritance of flags will not work */ + ent->attr.mtd_attr.irg_add_properties = mask | (properties & ~mtp_property_inherited); } } @@ -1063,25 +1016,28 @@ int entity_has_definition(const ir_entity *entity) || entity_has_compound_ent_values(entity); } -void firm_init_entity(void) +void ir_init_entity(void) { - symconst_symbol sym; - assert(firm_unknown_type && "Call init_type() before firm_init_entity()!"); assert(!unknown_entity && "Call firm_init_entity() only once!"); - unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type); + unknown_entity = new_d_entity(NULL, new_id_from_str(UNKNOWN_ENTITY_NAME), + firm_unknown_type, NULL); set_entity_visibility(unknown_entity, ir_visibility_external); - set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity)); +} - current_ir_graph = get_const_code_irg(); - sym.entity_p = unknown_entity; +void ir_finish_entity(void) +{ + if (unknown_entity != NULL) { + free_entity(unknown_entity); + unknown_entity = NULL; + } } ir_allocation get_entity_allocation(const ir_entity *entity) { - return entity->allocation; + return (ir_allocation)entity->allocation; } void set_entity_allocation(ir_entity *entity, ir_allocation allocation) @@ -1091,7 +1047,7 @@ void set_entity_allocation(ir_entity *entity, ir_allocation allocation) ir_peculiarity get_entity_peculiarity(const ir_entity *entity) { - return entity->peculiarity; + return (ir_peculiarity)entity->peculiarity; } void set_entity_peculiarity(ir_entity *entity, ir_peculiarity peculiarity)