X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=3b76b4145b12d257e37d03db4e7538aad344f0c6;hb=17a2631c82913b3d4f94bfcbc64b41dd74bcb842;hp=cac4e821bd4d9b142e9a0879cf3d05dc8ac7988f;hpb=e889884cf7bb899bd853189ec0b62566786a0056;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index cac4e821b..3b76b4145 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -3,14 +3,14 @@ * File name: ir/tr/entity.c * Purpose: Representation of all program known entities. * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier + * Modified by: Goetz Lindenmaier, Michael Beck * Created: * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe + * Copyright: (c) 1998-2006 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ #ifdef HAVE_CONFIG_H -#include "config.h" +# include "config.h" #endif #ifdef HAVE_STRING_H @@ -19,28 +19,34 @@ #ifdef HAVE_STDLIB_H # include #endif +#ifdef HAVE_STDDEF_H # include +#endif +#ifdef HAVE_MALLOC_H +# include +#endif +#ifdef HAVE_ALLOCA_H +# include +#endif #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 "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 "irprog_t.h" +#include "ircons.h" +#include "tv_t.h" +#include "irdump.h" /* for output if errors occur. */ -#if DEBUG_libfirm -# include "irdump.h" /* for output if errors occur. */ -#endif - -# include "callgraph.h" /* for dumping debug output */ +#include "callgraph.h" /* for dumping debug output */ /*******************************************************************/ /** general **/ @@ -57,7 +63,7 @@ entity *get_unknown_entity(void) { return unknown_entity; } /*-----------------------------------------------------------------*/ static INLINE void insert_entity_in_owner (entity *ent) { - type *owner = ent->owner; + ir_type *owner = ent->owner; switch (get_type_tpop_code(owner)) { case tpo_class: { add_class_member (owner, ent); @@ -86,7 +92,7 @@ static INLINE void insert_entity_in_owner (entity *ent) { * @return the new created entity */ static INLINE entity * -new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) +new_rd_entity (dbg_info *db, ir_type *owner, ident *name, ir_type *type) { entity *res; ir_graph *rem; @@ -123,15 +129,21 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) res->value = new_SymConst(sym, symconst_addr_ent); current_ir_graph = rem; res->variability = variability_constant; - res->irg_add_properties = mtp_property_inherited; - res->param_access = NULL; - res->param_weight = NULL; + res->attr.mtd_attr.irg_add_properties = mtp_property_inherited; + res->attr.mtd_attr.vtable_number = VTABLE_NUM_NOT_SET; + res->attr.mtd_attr.param_access = NULL; + res->attr.mtd_attr.param_weight = NULL; + res->attr.mtd_attr.irg = NULL; + } + else if (is_compound_type(type)) { + res->variability = variability_uninitialized; + res->value = NULL; + res->attr.cmpd_attr.values = NULL; + res->attr.cmpd_attr.val_paths = NULL; } else { res->variability = variability_uninitialized; res->value = NULL; - res->values = NULL; - res->val_paths = NULL; } if (is_Class_type(owner)) { @@ -141,7 +153,6 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) res->overwrites = NULL; res->overwrittenby = NULL; } - res->irg = NULL; #ifdef DEBUG_libfirm res->nr = get_irp_new_node_nr(); @@ -154,7 +165,7 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) } entity * -new_d_entity (type *owner, ident *name, type *type, dbg_info *db) { +new_d_entity (ir_type *owner, ident *name, ir_type *type, dbg_info *db) { entity *res; assert_legal_owner_of_ent(owner); @@ -167,13 +178,15 @@ new_d_entity (type *owner, ident *name, type *type, dbg_info *db) { } entity * -new_entity (type *owner, ident *name, type *type) { +new_entity (ir_type *owner, ident *name, ir_type *type) { return new_d_entity(owner, name, type, NULL); } - - - +/** + * Free entity attributes. + * + * @param ent the entity + */ static void free_entity_attrs(entity *ent) { int i; if (get_type_tpop(get_entity_owner(ent)) == type_class) { @@ -183,30 +196,33 @@ static void free_entity_attrs(entity *ent) { assert(ent->overwrites == NULL); assert(ent->overwrittenby == NULL); } - /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */ - if (ent->val_paths) { - if (is_compound_entity(ent)) + if (is_compound_entity(ent)) { + if (ent->attr.cmpd_attr.val_paths) { for (i = 0; i < get_compound_ent_n_values(ent); i++) - if (ent->val_paths[i]) ; - /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */ - /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */ - /* DEL_ARR_F(ent->val_paths); */ - } - ent->val_paths = NULL; - ent->values = NULL; - - if (ent->param_access) { - DEL_ARR_F(ent->param_access); - ent->param_access = NULL; + 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; + } + /* if (ent->attr.cmpd_attr.values) DEL_ARR_F(ent->attr.cmpd_attr.values); *//* @@@ warum nich? */ + ent->attr.cmpd_attr.values = NULL; } - if (ent->param_weight) { - DEL_ARR_F(ent->param_weight); - ent->param_weight = NULL; + else if (is_method_entity(ent)) { + if (ent->attr.mtd_attr.param_access) { + DEL_ARR_F(ent->attr.mtd_attr.param_access); + ent->attr.mtd_attr.param_access = NULL; + } + if (ent->attr.mtd_attr.param_weight) { + DEL_ARR_F(ent->attr.mtd_attr.param_weight); + ent->attr.mtd_attr.param_weight = NULL; + } } } entity * -copy_entity_own (entity *old, type *new_owner) { +copy_entity_own (entity *old, ir_type *new_owner) { entity *newe; assert(old && old->kind == k_entity); assert_legal_owner_of_ent(new_owner); @@ -267,7 +283,7 @@ get_entity_nr(entity *ent) { #ifdef DEBUG_libfirm return ent->nr; #else - return 0; + return (long)PTR_TO_INT(ent); #endif } @@ -278,23 +294,28 @@ const char * ident * (get_entity_ident)(const entity *ent) { - return get_entity_ident(ent); + return _get_entity_ident(ent); } -type * +void +(set_entity_ident)(entity *ent, ident *id) { + _set_entity_ident(ent, id); +} + +ir_type * (get_entity_owner)(entity *ent) { return _get_entity_owner(ent); } void -set_entity_owner (entity *ent, type *owner) { +set_entity_owner (entity *ent, ir_type *owner) { assert(ent && ent->kind == k_entity); assert_legal_owner_of_ent(owner); ent->owner = owner; } void /* should this go into type.c? */ -assert_legal_owner_of_ent(type *owner) { +assert_legal_owner_of_ent(ir_type *owner) { assert(get_type_tpop_code(owner) == tpo_class || get_type_tpop_code(owner) == tpo_union || get_type_tpop_code(owner) == tpo_struct || @@ -317,13 +338,13 @@ const char * return _get_entity_ld_name(ent); } -type * +ir_type * (get_entity_type)(entity *ent) { return _get_entity_type(ent); } void -(set_entity_type)(entity *ent, type *type) { +(set_entity_type)(entity *ent, ir_type *type) { _set_entity_type(ent, type); } @@ -396,8 +417,8 @@ set_entity_variability (entity *ent, ent_variability var) if ((is_compound_type(ent->type)) && (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) { /* Allocate data structures for constant values */ - ent->values = NEW_ARR_F(ir_node *, 0); - ent->val_paths = NEW_ARR_F(compound_graph_path *, 0); + ent->attr.cmpd_attr.values = NEW_ARR_F(ir_node *, 0); + ent->attr.cmpd_attr.val_paths = NEW_ARR_F(compound_graph_path *, 0); } if ((is_atomic_type(ent->type)) && (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) { @@ -408,13 +429,13 @@ set_entity_variability (entity *ent, ent_variability var) if ((is_compound_type(ent->type)) && (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) { /* Free data structures for constant values */ - DEL_ARR_F(ent->values); ent->values = NULL; - DEL_ARR_F(ent->val_paths); ent->val_paths = NULL; + DEL_ARR_F(ent->attr.cmpd_attr.values); ent->attr.cmpd_attr.values = NULL; + DEL_ARR_F(ent->attr.cmpd_attr.val_paths); ent->attr.cmpd_attr.val_paths = NULL; } ent->variability = var; } -/* return the name of the variablity */ +/* return the name of the variability */ const char *get_variability_name(ent_variability var) { #define X(a) case a: return #a @@ -460,19 +481,6 @@ void _set_entity_peculiarity(ent, pec); } -/* return the name of the peculiarity */ -const char *get_peculiarity_name(peculiarity var) -{ -#define X(a) case a: return #a - switch (var) { - X(peculiarity_description); - X(peculiarity_inherited); - X(peculiarity_existent); - default: return "BAD VALUE"; - } -#undef X -} - /* Get the entity's stickyness */ ent_stickyness (get_entity_stickyness)(const entity *ent) { @@ -583,7 +591,7 @@ ir_node *copy_const_value(dbg_info *dbg, ir_node *n) { /* Creates a new compound graph path. */ compound_graph_path * -new_compound_graph_path(type *tp, int length) { +new_compound_graph_path(ir_type *tp, int length) { compound_graph_path *res; assert(is_type(tp) && is_compound_type(tp)); @@ -615,7 +623,7 @@ int is_compound_graph_path(void *thing) { int is_proper_compound_graph_path(compound_graph_path *gr, int pos) { int i; entity *node; - type *owner = gr->tp; + ir_type *owner = gr->tp; for (i = 0; i <= pos; i++) { node = get_compound_graph_path_node(gr, i); @@ -673,33 +681,38 @@ set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) void add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - ARR_APP1 (ir_node *, ent->values, val); - ARR_APP1 (compound_graph_path *, ent->val_paths, path); + assert(is_compound_graph_path(path)); + ARR_APP1(ir_node *, ent->attr.cmpd_attr.values, val); + ARR_APP1(compound_graph_path *, ent->attr.cmpd_attr.val_paths, path); } void set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - ent->values[pos] = val; - ent->val_paths[pos] = path; + assert(is_compound_graph_path(path)); + assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values)); + ent->attr.cmpd_attr.values[pos] = val; + ent->attr.cmpd_attr.val_paths[pos] = path; } int get_compound_ent_n_values(entity *ent) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - return (ARR_LEN (ent->values)); + return ARR_LEN(ent->attr.cmpd_attr.values); } -ir_node * +ir_node * get_compound_ent_value(entity *ent, int pos) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - return ent->values[pos]; + assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.values)); + return ent->attr.cmpd_attr.values[pos]; } compound_graph_path * get_compound_ent_value_path(entity *ent, int pos) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - return ent->val_paths[pos]; + assert(0 <= pos && pos < ARR_LEN(ent->attr.cmpd_attr.val_paths)); + return ent->attr.cmpd_attr.val_paths[pos]; } /** @@ -713,7 +726,7 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou if (len2 > len1) return 0; for (i = 0; i < len1; i++) { - type *tp; + ir_type *tp; entity *node1 = get_compound_graph_path_node(path1, i); entity *node2 = get_compound_graph_path_node(path2, i); @@ -742,7 +755,11 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou * The path must contain array indicees for all array element entities. */ int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path) { int i, n_paths = get_compound_ent_n_values(ent); - int *visited_indicees = (int *)xcalloc(get_compound_graph_path_length(path), sizeof(int)); + int *visited_indicees; + int path_len = get_compound_graph_path_length(path); + + NEW_ARR_A(int *, visited_indicees, path_len); + memset(visited_indicees, 0, sizeof(*visited_indicees) * path_len); for (i = 0; i < n_paths; i ++) { if (equal_paths(get_compound_ent_value_path(ent, i), visited_indicees, path)) return i; @@ -778,15 +795,15 @@ void remove_compound_ent_value(entity *ent, entity *value_ent) { int i; assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) { - compound_graph_path *path = ent->val_paths[i]; + for (i = 0; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths)); ++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->val_paths))-1; i++) { - ent->val_paths[i] = ent->val_paths[i+1]; - ent->values[i] = ent->values[i+1]; + for (; i < (ARR_LEN(ent->attr.cmpd_attr.val_paths))-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(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1); - ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1); + ARR_SETLEN(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); break; } } @@ -795,7 +812,7 @@ remove_compound_ent_value(entity *ent, entity *value_ent) { void add_compound_ent_value(entity *ent, ir_node *val, entity *member) { compound_graph_path *path; - type *owner_tp = get_entity_owner(member); + ir_type *owner_tp = get_entity_owner(member); assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); path = new_compound_graph_path(get_entity_type(ent), 1); path->list[0].node = member; @@ -860,9 +877,9 @@ 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_type *arrtp = get_entity_type(ent); ir_node *val; - type *elttp = get_array_element_type(arrtp); + ir_type *elttp = get_array_element_type(arrtp); assert(is_Array_type(arrtp)); assert(get_array_n_dimensions(arrtp) == 1); @@ -892,8 +909,8 @@ int get_compound_ent_value_offset_bits(entity *ent, int pos) { for (i = 0; i < path_len; ++i) { entity *node = get_compound_graph_path_node(path, i); - type *node_tp = get_entity_type(node); - type *owner_tp = get_entity_owner(node); + ir_type *node_tp = get_entity_type(node); + ir_type *owner_tp = get_entity_owner(node); if (is_Array_type(owner_tp)) { int size = get_type_size_bits(node_tp); int align = get_type_alignment_bits(node_tp); @@ -918,7 +935,7 @@ int get_compound_ent_value_offset_bytes(entity *ent, int pos) { } -static void init_index(type *arr) { +static void init_index(ir_type *arr) { int init; int dim = 0; @@ -934,7 +951,7 @@ static void init_index(type *arr) { static int get_next_index(entity *elem_ent) { - type *arr = get_entity_owner(elem_ent); + ir_type *arr = get_entity_owner(elem_ent); int next; int dim = 0; @@ -971,7 +988,7 @@ static int get_next_index(entity *elem_ent) { * evaluate the index against the upper bound.) */ void compute_compound_ent_array_indicees(entity *ent) { - type *tp = get_entity_type(ent); + ir_type *tp = get_entity_type(ent); int i, n_vals; entity *unknown_bound_entity = NULL; @@ -999,7 +1016,7 @@ void compute_compound_ent_array_indicees(entity *ent) { int j, path_len = get_compound_graph_path_length(path); for (j = 0; j < path_len; ++j) { entity *node = get_compound_graph_path_node(path, j); - type *elem_tp = get_entity_type(node); + ir_type *elem_tp = get_entity_type(node); if (is_Array_type(elem_tp)) { int dim = 0; @@ -1020,7 +1037,7 @@ void compute_compound_ent_array_indicees(entity *ent) { int j, path_len = get_compound_graph_path_length(path); for (j = 0; j < path_len; ++j) { entity *node = get_compound_graph_path_node(path, j); - type *owner_tp = get_entity_owner(node); + ir_type *owner_tp = get_entity_owner(node); if (is_Array_type(owner_tp)) set_compound_graph_path_array_index (path, j, get_next_index(node)); } @@ -1047,7 +1064,7 @@ static int *resize (int *buf, int *size) { A second iteration now permutes the actual elements into two new arrays. */ void sort_compound_ent_values(entity *ent) { - type *tp; + ir_type *tp; int i, n_vals; int tp_size; int size; @@ -1100,10 +1117,10 @@ void sort_compound_ent_values(entity *ent) { } free(permutation); - DEL_ARR_F(ent->values); - ent->values = my_values; - DEL_ARR_F(ent->val_paths); - ent->val_paths = my_paths; + DEL_ARR_F(ent->attr.cmpd_attr.values); + ent->attr.cmpd_attr.values = my_values; + DEL_ARR_F(ent->attr.cmpd_attr.val_paths); + ent->attr.cmpd_attr.val_paths = my_paths; } int @@ -1242,7 +1259,7 @@ ir_graph * void set_entity_irg(entity *ent, ir_graph *irg) { - assert(ent && is_Method_type(get_entity_type(ent))); + assert(ent && is_method_entity(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? Wandle die Entitaet in description oder @@ -1253,7 +1270,17 @@ set_entity_irg(entity *ent, ir_graph *irg) { && (ent -> visibility == visibility_external_allocated)) || (!irg && ent->peculiarity == peculiarity_description) || (!irg && ent->peculiarity == peculiarity_inherited)); - ent->irg = irg; + ent->attr.mtd_attr.irg = irg; +} + +unsigned get_entity_vtable_number(entity *ent) { + assert(ent && is_method_entity(ent)); + return ent->attr.mtd_attr.vtable_number; +} + +void set_entity_vtable_number(entity *ent, unsigned vtable_number) { + assert(ent && is_method_entity(ent)); + ent->attr.mtd_attr.vtable_number = vtable_number; } int @@ -1262,19 +1289,25 @@ int } int is_atomic_entity(entity *ent) { - type* t = get_entity_type(ent); + ir_type *t = get_entity_type(ent); assert(ent && ent->kind == k_entity); return (is_Primitive_type(t) || is_Pointer_type(t) || is_Enumeration_type(t) || is_Method_type(t)); } int is_compound_entity(entity *ent) { - type* t = get_entity_type(ent); + ir_type *t = get_entity_type(ent); assert(ent && ent->kind == k_entity); return (is_Class_type(t) || is_Struct_type(t) || is_Array_type(t) || is_Union_type(t)); } +int is_method_entity(entity *ent) { + ir_type *t = get_entity_type(ent); + assert(ent && ent->kind == k_entity); + return (is_Method_type(t)); +} + /** * @todo not implemented!!! */ int equal_entity(entity *ent1, entity *ent2) { @@ -1308,7 +1341,7 @@ int (entity_not_visited)(entity *ent) { unsigned get_entity_additional_properties(entity *ent) { ir_graph *irg; - assert(is_Method_type(get_entity_type(ent))); + assert(is_method_entity(ent)); /* first check, if the graph has additional properties */ irg = get_entity_irg(ent); @@ -1316,10 +1349,10 @@ unsigned get_entity_additional_properties(entity *ent) { if (irg) return get_irg_additional_properties(irg); - if (ent->irg_add_properties & mtp_property_inherited) + if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited) return get_method_additional_properties(get_entity_type(ent)); - return ent->irg_add_properties; + return ent->attr.mtd_attr.irg_add_properties; } /* Sets the mask of the additional graph properties. */ @@ -1327,7 +1360,7 @@ void set_entity_additional_properties(entity *ent, unsigned property_mask) { ir_graph *irg; - assert(is_Method_type(get_entity_type(ent))); + assert(is_method_entity(ent)); /* first check, if the graph exists */ irg = get_entity_irg(ent); @@ -1336,7 +1369,7 @@ void set_entity_additional_properties(entity *ent, unsigned property_mask) else { /* do not allow to set the mtp_property_inherited flag or * the automatic inheritance of flags will not work */ - ent->irg_add_properties = property_mask & ~mtp_property_inherited; + ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited; } } @@ -1345,35 +1378,37 @@ void set_entity_additional_property(entity *ent, mtp_additional_property flag) { ir_graph *irg; - assert(is_Method_type(get_entity_type(ent))); + assert(is_method_entity(ent)); /* first check, if the graph exists */ irg = get_entity_irg(ent); if (irg) set_irg_additional_property(irg, flag); else { - unsigned mask = ent->irg_add_properties; + unsigned 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->irg_add_properties = mask | (flag & ~mtp_property_inherited); + ent->attr.mtd_attr.irg_add_properties = mask | (flag & ~mtp_property_inherited); } } +/* Initialize entity module. */ void firm_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); set_entity_visibility(unknown_entity, visibility_external_allocated); set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity)); - sym.entity_p = unknown_entity; - current_ir_graph = get_const_code_irg(); + current_ir_graph = get_const_code_irg(); + sym.entity_p = unknown_entity; unknown_entity->value = new_SymConst(sym, symconst_addr_ent); }