X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=cac4e821bd4d9b142e9a0879cf3d05dc8ac7988f;hb=f101740bb2e4d4fed7f7874e5aa0df33254fc191;hp=cdf598096423e5d284b161a6148355f6ba3b7426;hpb=20c028dc2eefd23898ecff42a8fdf9e1eef7c90b;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index cdf598096..cac4e821b 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -28,6 +28,8 @@ # include "mangle.h" # include "typegmod.h" # include "array.h" +# include "irtools.h" +# include "irhooks.h" /* All this is needed to build the constant node for methods: */ # include "irprog_t.h" @@ -105,17 +107,25 @@ 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->irg_add_properties = mtp_property_inherited; + res->param_access = NULL; + res->param_weight = NULL; } else { res->variability = variability_uninitialized; @@ -124,12 +134,6 @@ new_rd_entity (dbg_info *db, type *owner, ident *name, type *type) 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); @@ -158,6 +162,7 @@ new_d_entity (type *owner, ident *name, type *type, dbg_info *db) { /* Remember entity in it's owner. */ insert_entity_in_owner (res); + hook_new_entity(res); return res; } @@ -189,6 +194,15 @@ static void free_entity_attrs(entity *ent) { } ent->val_paths = NULL; ent->values = NULL; + + if (ent->param_access) { + DEL_ARR_F(ent->param_access); + ent->param_access = NULL; + } + if (ent->param_weight) { + DEL_ARR_F(ent->param_weight); + ent->param_weight = NULL; + } } entity * @@ -267,11 +281,6 @@ ident * return get_entity_ident(ent); } -/* -void set_entitye_ld_name (entity *, char *ld_name); -void set_entity_ld_ident (entity *, ident *ld_ident); -*/ - type * (get_entity_owner)(entity *ent) { return _get_entity_owner(ent); @@ -386,7 +395,7 @@ 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 */ + /* Allocate data structures for constant values */ ent->values = NEW_ARR_F(ir_node *, 0); ent->val_paths = NEW_ARR_F(compound_graph_path *, 0); } @@ -398,7 +407,7 @@ 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 */ + /* Free data structures for constant values */ DEL_ARR_F(ent->values); ent->values = NULL; DEL_ARR_F(ent->val_paths); ent->val_paths = NULL; } @@ -509,19 +518,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; @@ -529,40 +540,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"); @@ -612,15 +621,15 @@ int is_proper_compound_graph_path(compound_graph_path *gr, int pos) { 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 */ @@ -701,14 +710,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; 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)) { @@ -720,13 +729,13 @@ 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. @@ -920,7 +929,7 @@ static void init_index(type *arr) { else init = get_array_upper_bound_int(arr, 0) +1; - set_entity_link(get_array_element_entity(arr), (void *)init); + set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init)); } @@ -932,20 +941,20 @@ static int get_next_index(entity *elem_ent) { assert(get_array_n_dimensions(arr) == 1); if (has_array_lower_bound(arr, dim)) { - next = (int)get_entity_link(elem_ent) +1; + next = PTR_TO_INT(get_entity_link(elem_ent)) + 1; if (has_array_upper_bound(arr, dim)) { int upper = get_array_upper_bound_int(arr, dim); if (next == upper) next = get_array_lower_bound_int(arr, dim); } } else { - next = (int)get_entity_link(elem_ent) -1; + next = PTR_TO_INT(get_entity_link(elem_ent)) - 1; if (has_array_lower_bound(arr, dim)) { int upper = get_array_upper_bound_int(arr, dim); if (next == upper) next = get_array_upper_bound_int(arr, dim); } } - set_entity_link(elem_ent, (void *)next); + set_entity_link(elem_ent, INT_TO_PTR(next)); return next; } @@ -1268,9 +1277,9 @@ int is_compound_entity(entity *ent) { /** * @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; } @@ -1295,24 +1304,71 @@ 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; + + assert(is_Method_type(get_entity_type(ent))); + + /* first check, if the graph has additional properties */ + irg = get_entity_irg(ent); + + if (irg) + return get_irg_additional_properties(irg); + + if (ent->irg_add_properties & mtp_property_inherited) + return get_method_additional_properties(get_entity_type(ent)); + + return ent->irg_add_properties; } -void (set_entity_additional_properties)(entity *ent, unsigned property_mask) { - _set_entity_additional_properties(ent, property_mask); +/* Sets the mask of the additional graph properties. */ +void set_entity_additional_properties(entity *ent, unsigned property_mask) +{ + ir_graph *irg; + + assert(is_Method_type(get_entity_type(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->irg_add_properties = property_mask & ~mtp_property_inherited; + } } -void (set_entity_additional_property)(entity *ent, unsigned flag) { - _set_entity_additional_property(ent, (irg_additional_property)flag); +/* Sets one additional graph property. */ +void set_entity_additional_property(entity *ent, mtp_additional_property flag) +{ + ir_graph *irg; + + assert(is_Method_type(get_entity_type(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; + + 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); + } } -void init_entity(void) +void firm_init_entity(void) { symconst_symbol sym; - assert(firm_unknown_type && "Call init_type before init_entity!"); - assert(!unknown_entity && "Call init_entity only once!"); + 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));