X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=27612ca95f49b611503b76105f083ae3e6c79b95;hb=4524bf07ed17f358412754a50a76e7db852160b3;hp=88d0b991e2e615b641dc407b5e3fac65a1a2a46b;hpb=01e81da933ad756dd77cc495726eb1749d42d9b2;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 88d0b991e..27612ca95 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -60,13 +60,10 @@ ir_entity *get_unknown_entity(void) { return unknown_entity; } /* ENTITY */ /*-----------------------------------------------------------------*/ -ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, - dbg_info *db) +static ir_entity *intern_new_entity(ir_type *owner, ident *name, ir_type *type, + dbg_info *dbgi) { ir_entity *res; - ir_graph *rem; - - assert(!id_contains_char(name, ' ') && "entity name should not contain spaces"); res = XMALLOCZ(ir_entity); @@ -86,15 +83,31 @@ ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, res->alignment = 0; res->link = NULL; res->repr_class = NULL; +#ifdef DEBUG_libfirm + res->nr = get_irp_new_node_nr(); +#endif + + /* Remember entity in its owner. */ + if (owner != NULL) + add_compound_member(owner, res); + + res->visit = 0; + set_entity_dbg_info(res, dbgi); + + return res; +} + +ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, + dbg_info *db) +{ + ir_entity *res = intern_new_entity(owner, name, type, db); 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 = IR_VTABLE_NUM_NOT_SET; @@ -108,25 +121,36 @@ ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, res->attr.code_attr.label = (ir_label_t) -1; } - /* Remember entity in it's owner. */ - if (owner != NULL) - add_compound_member(owner, res); + hook_new_entity(res); + return res; +} -#ifdef DEBUG_libfirm - res->nr = get_irp_new_node_nr(); -#endif +ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type) +{ + return new_d_entity(owner, name, type, NULL); +} - res->visit = 0; - set_entity_dbg_info(res, db); +static ident *make_parameter_entity_name(size_t pos) +{ + char buf[64]; + snprintf(buf, sizeof(buf), "parameter.%lu", (unsigned long) pos); + return new_id_from_str(buf); +} +ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos, ir_type *type, + dbg_info *dbgi) +{ + ident *name = make_parameter_entity_name(pos); + ir_entity *res = intern_new_entity(owner, name, type, dbgi); + res->is_parameter = true; + res->attr.parameter.number = pos; hook_new_entity(res); - return res; } -ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type) +ir_entity *new_parameter_entity(ir_type *owner, size_t pos, ir_type *type) { - return new_d_entity(owner, name, type, NULL); + return new_d_parameter_entity(owner, pos, type, NULL); } /** @@ -196,6 +220,7 @@ static ir_entity *deep_entity_copy(ir_entity *old) #ifdef DEBUG_libfirm newe->nr = get_irp_new_node_nr(); #endif + hook_new_entity(newe); return newe; } @@ -304,6 +329,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); @@ -394,7 +424,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) @@ -457,7 +487,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: @@ -484,15 +514,12 @@ void set_atomic_ent_value(ir_entity *entity, ir_node *val) * const_code_irg. */ int is_irn_const_expression(ir_node *n) { - ir_mode *m; - /* we are in danger 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: @@ -509,10 +536,11 @@ int is_irn_const_expression(ir_node *n) /* * 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; @@ -522,36 +550,52 @@ 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"); } @@ -584,34 +628,36 @@ 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; return initializer; } -ir_initializer_t *create_initializer_compound(unsigned n_entries) +ir_initializer_t *create_initializer_compound(size_t n_entries) { struct obstack *obst = get_irg_obstack(get_const_code_irg()); size_t i; size_t size = sizeof(ir_initializer_compound_t) - + (n_entries-1) * sizeof(ir_initializer_t*); + + n_entries * sizeof(ir_initializer_t*) + - 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; @@ -628,20 +674,20 @@ 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; } -unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer) +size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer) { assert(initializer->kind == IR_INITIALIZER_COMPOUND); return initializer->compound.n_initializers; } void set_initializer_compound_value(ir_initializer_t *initializer, - unsigned index, ir_initializer_t *value) + size_t index, ir_initializer_t *value) { assert(initializer->kind == IR_INITIALIZER_COMPOUND); assert(index < initializer->compound.n_initializers); @@ -650,7 +696,7 @@ void set_initializer_compound_value(ir_initializer_t *initializer, } ir_initializer_t *get_initializer_compound_value( - const ir_initializer_t *initializer, unsigned index) + const ir_initializer_t *initializer, size_t index) { assert(initializer->kind == IR_INITIALIZER_COMPOUND); assert(index < initializer->compound.n_initializers); @@ -733,31 +779,31 @@ void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten) ARR_APP1(ir_entity *, overwritten->overwrittenby, ent); } -int get_entity_n_overwrites(const ir_entity *ent) +size_t get_entity_n_overwrites(const ir_entity *ent) { if (ent->overwrites == NULL) return 0; return ARR_LEN(ent->overwrites); } -int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten) +size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten) { - int i, n; - n = get_entity_n_overwrites(ent); + size_t i; + size_t n = get_entity_n_overwrites(ent); for (i = 0; i < n; ++i) { if (get_entity_overwrites(ent, i) == overwritten) return i; } - return -1; + return (size_t)-1; } -ir_entity *get_entity_overwrites(const ir_entity *ent, int pos) +ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos) { assert(pos < get_entity_n_overwrites(ent)); return ent->overwrites[pos]; } -void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten) +void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten) { assert(pos < get_entity_n_overwrites(ent)); ent->overwrites[pos] = overwritten; @@ -765,8 +811,8 @@ 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; - n = get_entity_n_overwrites(ent); + size_t i; + size_t n = get_entity_n_overwrites(ent); for (i = 0; i < n; ++i) { if (ent->overwrites[i] == overwritten) { for (; i < n - 1; i++) @@ -778,31 +824,32 @@ void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) } -int get_entity_n_overwrittenby(const ir_entity *ent) +size_t get_entity_n_overwrittenby(const ir_entity *ent) { if (ent->overwrittenby == NULL) return 0; return ARR_LEN(ent->overwrittenby); } -int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites) +size_t get_entity_overwrittenby_index(const ir_entity *ent, + ir_entity *overwrites) { - int i, n; - n = get_entity_n_overwrittenby(ent); + size_t i; + size_t n = get_entity_n_overwrittenby(ent); for (i = 0; i < n; ++i) { if (get_entity_overwrittenby(ent, i) == overwrites) return i; } - return -1; + return (size_t)-1; } -ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos) +ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos) { assert(pos < get_entity_n_overwrittenby(ent)); return ent->overwrittenby[pos]; } -void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites) +void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites) { assert(pos < get_entity_n_overwrittenby(ent)); ent->overwrittenby[pos] = overwrites; @@ -810,9 +857,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; - - n = get_entity_n_overwrittenby(ent); + size_t i; + size_t n = get_entity_n_overwrittenby(ent); for (i = 0; i < n; ++i) { if (ent->overwrittenby[i] == overwrites) { for (; i < n - 1; ++i) @@ -845,6 +891,22 @@ void set_entity_irg(ir_entity *ent, ir_graph *irg) ent->attr.mtd_attr.irg = irg; } +int (is_parameter_entity)(const ir_entity *entity) +{ + return _is_parameter_entity(entity); +} + +size_t (get_entity_parameter_number)(const ir_entity *entity) +{ + return _get_entity_parameter_number(entity); +} + +void set_entity_parameter_number(ir_entity *entity, size_t n) +{ + assert(is_parameter_entity(entity)); + entity->attr.parameter.number = n; +} + unsigned get_entity_vtable_number(const ir_entity *ent) { assert(is_method_entity((ir_entity *)ent)); @@ -875,7 +937,7 @@ int is_compound_entity(const ir_entity *ent) ir_type *t = get_entity_type(ent); const tp_op *op = get_type_tpop(t); return (op == type_class || op == type_struct || - op == type_array || op == type_union); + op == type_array || op == type_union); } int is_method_entity(const ir_entity *ent) @@ -909,7 +971,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; @@ -927,7 +989,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; @@ -938,13 +1000,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; @@ -953,16 +1015,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); + ent->attr.mtd_attr.irg_add_properties = mask | (properties & ~mtp_property_inherited); } } @@ -1017,7 +1079,7 @@ void ir_finish_entity(void) 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) @@ -1027,7 +1089,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)