X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=3b76b4145b12d257e37d03db4e7538aad344f0c6;hb=17a2631c82913b3d4f94bfcbc64b41dd74bcb842;hp=32baff0a5145dbb6ce6d7732191f146418c89bf9;hpb=f9d916d24111a4b271cee4100a322444bf6cbc3c;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 32baff0a5..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" - -#if DEBUG_libfirm -# include "irdump.h" /* for output if errors occur. */ -#endif +#include "irprog_t.h" +#include "ircons.h" +#include "tv_t.h" +#include "irdump.h" /* for output if errors occur. */ -# 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; @@ -107,31 +113,39 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) else res->allocation = allocation_automatic; - res->visibility = visibility_local; + res->visibility = visibility_local; + res->volatility = volatility_non_volatile; + res->stickyness = stickyness_unsticky; + res->offset = -1; + res->peculiarity = peculiarity_existent; + res->link = NULL; + if (is_Method_type(type)) { symconst_symbol sym; - sym.entity_p = res; - res->variability = variability_constant; - rem = current_ir_graph; - current_ir_graph = get_const_code_irg(); - res->value = new_SymConst(sym, symconst_addr_ent); - current_ir_graph = rem; - res->irg_add_properties = 0; + sym.entity_p = res; + rem = current_ir_graph; + current_ir_graph = get_const_code_irg(); + res->value = new_SymConst(sym, symconst_addr_ent); + current_ir_graph = rem; + res->variability = variability_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.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; } - res->volatility = volatility_non_volatile; - res->stickyness = stickyness_unsticky; - res->offset = -1; - res->link = NULL; - res->peculiarity = peculiarity_existent; - if (is_Class_type(owner)) { res->overwrites = NEW_ARR_F(entity *, 0); res->overwrittenby = NEW_ARR_F(entity *, 0); @@ -139,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(); @@ -152,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); @@ -165,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) { @@ -181,21 +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); */ + 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; + } + 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; + } } - ent->val_paths = NULL; - ent->values = 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); @@ -256,7 +283,7 @@ get_entity_nr(entity *ent) { #ifdef DEBUG_libfirm return ent->nr; #else - return 0; + return (long)PTR_TO_INT(ent); #endif } @@ -267,28 +294,28 @@ const char * ident * (get_entity_ident)(const entity *ent) { - return get_entity_ident(ent); + return _get_entity_ident(ent); } -/* -void set_entitye_ld_name (entity *, char *ld_name); -void set_entity_ld_ident (entity *, ident *ld_ident); -*/ +void +(set_entity_ident)(entity *ent, ident *id) { + _set_entity_ident(ent, id); +} -type * +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 || @@ -311,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); } @@ -389,9 +416,9 @@ set_entity_variability (entity *ent, ent_variability var) if ((is_compound_type(ent->type)) && (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) { - /* Allocate datastructures for constant values */ - ent->values = NEW_ARR_F(ir_node *, 0); - ent->val_paths = NEW_ARR_F(compound_graph_path *, 0); + /* Allocate data structures for constant values */ + 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)) { @@ -401,14 +428,14 @@ set_entity_variability (entity *ent, ent_variability var) if ((is_compound_type(ent->type)) && (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) { - /* Free datastructures for constant values */ - DEL_ARR_F(ent->values); ent->values = NULL; - DEL_ARR_F(ent->val_paths); ent->val_paths = NULL; + /* Free data structures for constant values */ + 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 @@ -454,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) { @@ -512,19 +526,21 @@ int is_irn_const_expression(ir_node *n) { case iro_Const: case iro_SymConst: case iro_Unknown: - return true; break; + return 1; case iro_Conv: case iro_Cast: return is_irn_const_expression(get_irn_n(n, 0)); default: - return false; break; } - return false; + return 0; } - -ir_node *copy_const_value(ir_node *n) { +/* + * Copies a firm subgraph that complies to the restrictions for + * constant expressions to current_block in current_ir_graph. + */ +ir_node *copy_const_value(dbg_info *dbg, ir_node *n) { ir_node *nn; ir_mode *m; @@ -532,40 +548,38 @@ ir_node *copy_const_value(ir_node *n) { dead node elimination/inlineing. */ m = get_irn_mode(n); - switch(get_irn_opcode(n)) { + switch (get_irn_opcode(n)) { case iro_Const: - 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)); + nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n)); break; case iro_SymConst: - nn = new_d_SymConst_type(NULL, get_SymConst_symbol(n), get_SymConst_kind(n), + nn = new_d_SymConst_type(dbg, 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; + nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)), + copy_const_value(dbg, 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; + nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)), + copy_const_value(dbg, 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; + nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)), + copy_const_value(dbg, 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; + nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)), + copy_const_value(dbg, 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; + nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)), + copy_const_value(dbg, 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; + nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)), + copy_const_value(dbg, get_Eor_right(n)), m); break; case iro_Cast: - nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break; + nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break; case iro_Conv: - nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break; + nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break; case iro_Unknown: - nn = new_Unknown(m); break; + nn = new_d_Unknown(m); break; default: DDMN(n); assert(0 && "opcode invalid or not implemented"); @@ -577,7 +591,7 @@ ir_node *copy_const_value(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)); @@ -609,21 +623,21 @@ 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); if (node == NULL) /* Path not yet complete. */ - return true; + return 1; if (get_entity_owner(node) != owner) - return false; + return 0; owner = get_entity_type(node); } if (pos == get_compound_graph_path_length(gr)) if (!is_atomic_type(owner)) - return false; - return true; + return 0; + return 1; } /* Returns the length of a graph path */ @@ -667,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]; } /** @@ -704,14 +723,14 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou int len1 = get_compound_graph_path_length(path1); int len2 = get_compound_graph_path_length(path2); - if (len2 > len1) return false; + 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); - if (node1 != node2) return false; + if (node1 != node2) return 0; tp = get_entity_owner(node1); if (is_Array_type(tp)) { @@ -723,20 +742,24 @@ static int equal_paths(compound_graph_path *path1, int *visited_indicees, compou low = get_array_lower_bound_int(tp, 0); if (low + visited_indicees[i] < get_compound_graph_path_array_index(path2, i)) { visited_indicees[i]++; - return false; + return 0; } else assert(low + visited_indicees[i] == get_compound_graph_path_array_index(path2, i)); } } - return true; + return 1; } /* Returns the position of a value with the given path. * 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; @@ -772,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; } } @@ -789,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; @@ -854,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); @@ -886,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); @@ -912,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; @@ -928,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; @@ -965,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; @@ -993,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; @@ -1014,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)); } @@ -1041,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; @@ -1094,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 @@ -1236,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 @@ -1247,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 @@ -1256,24 +1289,30 @@ 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!!! */ -bool equal_entity(entity *ent1, entity *ent2) { +int equal_entity(entity *ent1, entity *ent2) { fprintf(stderr, " calling unimplemented equal entity!!! \n"); - return true; + return 1; } @@ -1298,39 +1337,78 @@ int (entity_not_visited)(entity *ent) { return _entity_not_visited(ent); } -unsigned (get_entity_additional_properties)(const entity *ent) { - return _get_entity_additional_properties(ent); -} +/* Returns the mask of the additional entity properties. */ +unsigned get_entity_additional_properties(entity *ent) { + ir_graph *irg; -void (set_entity_additional_properties)(entity *ent, unsigned property_mask) { - _set_entity_additional_properties(ent, property_mask); -} + assert(is_method_entity(ent)); + + /* first check, if the graph has additional properties */ + irg = get_entity_irg(ent); -void (set_entity_additional_property)(entity *ent, unsigned flag) { - _set_entity_additional_property(ent, (irg_additional_property)flag); + if (irg) + return get_irg_additional_properties(irg); + + if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited) + return get_method_additional_properties(get_entity_type(ent)); + + return ent->attr.mtd_attr.irg_add_properties; } -/* Returns the calling convention of an entities graph. */ -unsigned (get_entity_calling_convention)(const entity *ent) { - return _get_entity_calling_convention(ent); +/* Sets the mask of the additional graph properties. */ +void set_entity_additional_properties(entity *ent, unsigned property_mask) +{ + ir_graph *irg; + + assert(is_method_entity(ent)); + + /* first check, if the graph exists */ + irg = get_entity_irg(ent); + 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 */ + ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited; + } } -/* Sets the calling convention of an entities graph. */ -void (set_entity_calling_convention)(entity *ent, unsigned cc_mask) { - _set_entity_calling_convention(ent, cc_mask); +/* Sets one additional graph property. */ +void set_entity_additional_property(entity *ent, mtp_additional_property flag) +{ + ir_graph *irg; + + 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->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); + } } +/* 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); }