X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Ftr%2Fentity.c;h=89bab580181430818e82d33b102656e571829974;hb=a748501db974593cc1ddd3955c1663340c5af353;hp=2f73c5c6bb163ab5d2b7c874299a1065cfcca22e;hpb=f6b661eaae85376166a897e8e7b3bf3a177f8524;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 2f73c5c6b..89bab5801 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -3,45 +3,67 @@ * 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 +# include "config.h" #endif +#ifdef HAVE_STRING_H +# include +#endif +#ifdef HAVE_STDLIB_H # include +#endif +#ifdef HAVE_STDDEF_H # include -# 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 "irprintf.h" -# include "entity_t.h" -# include "mangle.h" -# include "typegmod.h" -# include "array.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. */ + +#include "callgraph.h" /* for dumping debug output */ /*******************************************************************/ /** general **/ /*******************************************************************/ -void -init_entity (void) -{ -} +ir_entity *unknown_entity = NULL; + +ir_entity *get_unknown_entity(void) { return unknown_entity; } + +#define UNKNOWN_ENTITY_NAME "unknown_entity" /*-----------------------------------------------------------------*/ /* ENTITY */ /*-----------------------------------------------------------------*/ -static void insert_entity_in_owner (entity *ent) { - type *owner = ent->owner; +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); @@ -59,73 +81,113 @@ static void insert_entity_in_owner (entity *ent) { } } -entity * -new_entity (type *owner, ident *name, type *type) +/** + * 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) { - entity *res; + ir_entity *res; ir_graph *rem; assert(!id_contains_char(name, ' ') && "entity name should not contain spaces"); - res = (entity *) xmalloc (sizeof (entity)); - res->kind = k_entity; - assert_legal_owner_of_ent(owner); - res->owner = owner; - res->name = name; - res->type = type; - - if (get_type_tpop(type) == type_method) - res->allocation = allocation_static; - else - res->allocation = allocation_automatic; - - res->visibility = visibility_local; - res->offset = -1; - if (is_method_type(type)) { + res = xmalloc(sizeof(*res)); + memset(res, 0, sizeof(*res)); + + res->kind = k_entity; + res->name = name; + res->ld_name = NULL; + res->type = type; + res->owner = owner; + + res->allocation = allocation_automatic; + res->visibility = visibility_local; + res->volatility = volatility_non_volatile; + res->stickyness = stickyness_unsticky; + res->peculiarity = peculiarity_existent; + res->final = 0; + res->compiler_gen = 0; + res->offset = -1; + res->link = NULL; + res->repr_class = 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; - } else { + 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->allocation = allocation_static; + 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; + res->attr.mtd_attr.section = section_text; + } + 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->value = NULL; } - res->peculiarity = peculiarity_existent; - res->volatility = volatility_non_volatile; - res->stickyness = stickyness_unsticky; - res->ld_name = NULL; - if (is_class_type(owner)) { - res->overwrites = NEW_ARR_F(entity *, 0); - res->overwrittenby = NEW_ARR_F(entity *, 0); + + 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; } - res->irg = NULL; #ifdef DEBUG_libfirm res->nr = get_irp_new_node_nr(); -#endif +#endif /* DEBUG_libfirm */ res->visit = 0; + set_entity_dbg_info(res, db); - /* Remember entity in it's owner. */ - insert_entity_in_owner (res); return res; } -entity * -new_d_entity (type *owner, ident *name, type *type, dbg_info *db) { - entity *res = new_entity(owner, name, type); - set_entity_dbg_info(res, db); + +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; } -static void free_entity_attrs(entity *ent) { +ir_entity * +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(ir_entity *ent) { int i; if (get_type_tpop(get_entity_owner(ent)) == type_class) { DEL_ARR_F(ent->overwrites); ent->overwrites = NULL; @@ -134,70 +196,81 @@ 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) { - entity *new; - assert(old && old->kind == k_entity); - assert_legal_owner_of_ent(new_owner); +ir_entity * +copy_entity_own(ir_entity *old, ir_type *new_owner) { + ir_entity *newe; + assert(is_entity(old)); + assert(is_compound_type(new_owner)); if (old->owner == new_owner) return old; - new = (entity *) xmalloc (sizeof (entity)); - memcpy (new, old, sizeof (entity)); - new->owner = new_owner; - if (is_class_type(new_owner)) { - new->overwrites = NEW_ARR_F(entity *, 0); - new->overwrittenby = NEW_ARR_F(entity *, 0); + newe = xmalloc(sizeof(*newe)); + memcpy(newe, old, sizeof(*newe)); + newe->owner = new_owner; + if (is_Class_type(new_owner)) { + newe->overwrites = NEW_ARR_F(ir_entity *, 0); + newe->overwrittenby = NEW_ARR_F(ir_entity *, 0); } #ifdef DEBUG_libfirm - new->nr = get_irp_new_node_nr(); + newe->nr = get_irp_new_node_nr(); #endif - insert_entity_in_owner (new); + insert_entity_in_owner(newe); - return new; + return newe; } -entity * -copy_entity_name (entity *old, ident *new_name) { - entity *new; +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; - new = (entity *) xmalloc (sizeof (entity)); - memcpy (new, old, sizeof (entity)); - new->name = new_name; - new->ld_name = NULL; - if (is_class_type(new->owner)) { - new->overwrites = DUP_ARR_F(entity *, old->overwrites); - new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby); + newe = xmalloc(sizeof(*newe)); + memcpy(newe, old, sizeof(*newe)); + 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); } #ifdef DEBUG_libfirm - new->nr = get_irp_new_node_nr(); + newe->nr = get_irp_new_node_nr(); #endif - insert_entity_in_owner (new); + insert_entity_in_owner (newe); - return new; + return newe; } void -free_entity (entity *ent) { +free_entity (ir_entity *ent) { assert(ent && ent->kind == k_entity); - free_tarval_entity(ent); free_entity_attrs(ent); ent->kind = k_BAD; free(ent); @@ -205,88 +278,79 @@ free_entity (entity *ent) { /* Outputs a unique number for this node */ long -get_entity_nr(entity *ent) { +get_entity_nr(ir_entity *ent) { assert(ent && ent->kind == k_entity); #ifdef DEBUG_libfirm return ent->nr; #else - return 0; + return (long)PTR_TO_INT(ent); #endif } const char * -(get_entity_name)(entity *ent) { - return __get_entity_name(ent); +(get_entity_name)(const ir_entity *ent) { + return _get_entity_name(ent); } ident * -(get_entity_ident)(entity *ent) { - return get_entity_ident(ent); +(get_entity_ident)(const ir_entity *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)(ir_entity *ent, ident *id) { + _set_entity_ident(ent, id); +} -type * -(get_entity_owner)(entity *ent) { - return __get_entity_owner(ent); +ir_type * +(get_entity_owner)(ir_entity *ent) { + return _get_entity_owner(ent); } void -set_entity_owner (entity *ent, type *owner) { - assert(ent && ent->kind == k_entity); - assert_legal_owner_of_ent(owner); +set_entity_owner(ir_entity *ent, ir_type *owner) { + assert(is_entity(ent)); + assert(is_compound_type(owner)); ent->owner = owner; } -void /* should this go into type.c? */ -assert_legal_owner_of_ent(type *owner) { - assert(get_type_tpop_code(owner) == tpo_class || - get_type_tpop_code(owner) == tpo_union || - get_type_tpop_code(owner) == tpo_struct || - get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity - -- to select fields! */ -} - ident * -(get_entity_ld_ident)(entity *ent) { - return __get_entity_ld_ident(ent); +(get_entity_ld_ident)(ir_entity *ent) { + return _get_entity_ld_ident(ent); } void -(set_entity_ld_ident)(entity *ent, ident *ld_ident) { - __set_entity_ld_ident(ent, ld_ident); +(set_entity_ld_ident)(ir_entity *ent, ident *ld_ident) { + _set_entity_ld_ident(ent, ld_ident); } const char * -(get_entity_ld_name)(entity *ent) { - return __get_entity_ld_name(ent); +(get_entity_ld_name)(ir_entity *ent) { + return _get_entity_ld_name(ent); } -type * -(get_entity_type)(entity *ent) { - return __get_entity_type(ent); +ir_type * +(get_entity_type)(ir_entity *ent) { + return _get_entity_type(ent); } void -(set_entity_type)(entity *ent, type *type) { - __set_entity_type(ent, type); +(set_entity_type)(ir_entity *ent, ir_type *type) { + _set_entity_type(ent, type); } -ent_allocation -(get_entity_allocation)(entity *ent) { - return __get_entity_allocation(ent); +ir_allocation +(get_entity_allocation)(const ir_entity *ent) { + return _get_entity_allocation(ent); } void -(set_entity_allocation)(entity *ent, ent_allocation al) { - __set_entity_allocation(ent, al); +(set_entity_allocation)(ir_entity *ent, ir_allocation al) { + _set_entity_allocation(ent, al); } /* return the name of the visibility */ -const char *get_allocation_name(ent_allocation all) +const char *get_allocation_name(ir_allocation all) { #define X(a) case a: return #a switch (all) { @@ -300,13 +364,13 @@ const char *get_allocation_name(ent_allocation all) } -ent_visibility -(get_entity_visibility)(entity *ent) { - return __get_entity_visibility(ent); +ir_visibility +(get_entity_visibility)(const ir_entity *ent) { + return _get_entity_visibility(ent); } void -set_entity_visibility (entity *ent, ent_visibility vis) { +set_entity_visibility(ir_entity *ent, ir_visibility vis) { assert(ent && ent->kind == k_entity); if (vis != visibility_local) assert((ent->allocation == allocation_static) || @@ -317,7 +381,7 @@ set_entity_visibility (entity *ent, ent_visibility vis) { } /* return the name of the visibility */ -const char *get_visibility_name(ent_visibility vis) +const char *get_visibility_name(ir_visibility vis) { #define X(a) case a: return #a switch (vis) { @@ -329,36 +393,41 @@ const char *get_visibility_name(ent_visibility vis) #undef X } -ent_variability -(get_entity_variability)(entity *ent) { - return __get_entity_variability(ent); +ir_variability +(get_entity_variability)(const ir_entity *ent) { + return _get_entity_variability(ent); } void -set_entity_variability (entity *ent, ent_variability var) +set_entity_variability (ir_entity *ent, ir_variability var) { assert(ent && ent->kind == k_entity); if (var == variability_part_constant) - assert(is_class_type(ent->type) || is_struct_type(ent->type)); + assert(is_Class_type(ent->type) || is_Struct_type(ent->type)); 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)) { + /* Set default constant value. */ + ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type)); } 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 */ -const char *get_variability_name(ent_variability var) +/* return the name of the variability */ +const char *get_variability_name(ir_variability var) { #define X(a) case a: return #a switch (var) { @@ -371,18 +440,18 @@ const char *get_variability_name(ent_variability var) #undef X } -ent_volatility -(get_entity_volatility)(entity *ent) { - return __get_entity_volatility(ent); +ir_volatility +(get_entity_volatility)(const ir_entity *ent) { + return _get_entity_volatility(ent); } void -(set_entity_volatility)(entity *ent, ent_volatility vol) { - __set_entity_volatility(ent, vol); +(set_entity_volatility)(ir_entity *ent, ir_volatility vol) { + _set_entity_volatility(ent, vol); } /* return the name of the volatility */ -const char *get_volatility_name(ent_volatility var) +const char *get_volatility_name(ir_volatility var) { #define X(a) case a: return #a switch (var) { @@ -393,44 +462,53 @@ const char *get_volatility_name(ent_volatility var) #undef X } -peculiarity -(get_entity_peculiarity)(entity *ent) { - return __get_entity_peculiarity(ent); +ir_peculiarity +(get_entity_peculiarity)(const ir_entity *ent) { + return _get_entity_peculiarity(ent); } void -(set_entity_peculiarity)(entity *ent, peculiarity pec) { - __set_entity_peculiarity(ent, pec); +(set_entity_peculiarity)(ir_entity *ent, ir_peculiarity pec) { + _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 +/* Checks if an entity cannot be overridden anymore. */ +int (get_entity_final)(const ir_entity *ent) { + return _get_entity_final(ent); +} + +/* Sets/resets the final flag of an entity. */ +void (set_entity_final)(ir_entity *ent, int final) { + _set_entity_final(ent, final); +} + +/* Checks if an entity is compiler generated */ +int is_entity_compiler_generated(const ir_entity *ent) { + assert(is_entity(ent)); + return ent->compiler_gen; +} + +/* Sets/resets the compiler generated flag */ +void set_entity_compiler_generated(ir_entity *ent, int flag) { + assert(is_entity(ent)); + ent->compiler_gen = flag ? 1 : 0; } /* Get the entity's stickyness */ -ent_stickyness -(get_entity_stickyness)(entity *ent) { - return __get_entity_stickyness(ent); +ir_stickyness +(get_entity_stickyness)(const ir_entity *ent) { + return _get_entity_stickyness(ent); } /* Set the entity's stickyness */ void -(set_entity_stickyness)(entity *ent, ent_stickyness stickyness) { - __set_entity_stickyness(ent, stickyness); +(set_entity_stickyness)(ir_entity *ent, ir_stickyness stickyness) { + _set_entity_stickyness(ent, stickyness); } /* Set has no effect for existent entities of type method. */ ir_node * -get_atomic_ent_value(entity *ent) +get_atomic_ent_value(ir_entity *ent) { assert(ent && is_atomic_entity(ent)); assert(ent->variability != variability_uninitialized); @@ -438,9 +516,9 @@ get_atomic_ent_value(entity *ent) } void -set_atomic_ent_value(entity *ent, ir_node *val) { +set_atomic_ent_value(ir_entity *ent, ir_node *val) { assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized)); - if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent)) + if (is_Method_type(ent->type) && (ent->peculiarity == peculiarity_existent)) return; ent->value = val; } @@ -450,222 +528,320 @@ set_atomic_ent_value(entity *ent, ir_node *val) { 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: case iro_Unknown: - return true; break; - case iro_Add: - case iro_Sub: - case iro_Mul: - case iro_And: - case iro_Or: - case iro_Eor: - if (is_irn_const_expression(get_binop_left(n))) - return is_irn_const_expression(get_binop_right(n)); + 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; + /* @@@ GL I think we should implement this using the routines from irgopt for + 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)); break; + nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n)); + break; case iro_SymConst: - - nn = new_SymConst(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 && "opdope invalid or not implemented"); + assert(0 && "opcode invalid or not implemented"); nn = NULL; break; } return nn; } +/* 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)); + + assert(is_compound_type(tp)); assert(length > 0); - res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *)); - res->kind = k_ir_compound_graph_path; - res->tp = tp; - res->len = length; - res ->arr_indicees = (int *) calloc(length, sizeof(int)); + res = xmalloc(sizeof(*res) + (length-1) * sizeof(res->list[0])); + memset(res, 0, sizeof(*res) + (length-1) * sizeof(res->list[0])); + res->kind = k_ir_compound_graph_path; + res->tp = tp; + res->len = length; + return res; } -void -free_compound_graph_path (compound_graph_path *gr) { +/* Frees an graph path object */ +void free_compound_graph_path (compound_graph_path *gr) { assert(gr && is_compound_graph_path(gr)); gr->kind = k_BAD; - free(gr ->arr_indicees); free(gr); } -int -is_compound_graph_path(void *thing) { +/* Returns non-zero if an object is a compound graph path */ +int is_compound_graph_path(const void *thing) { return (get_kind(thing) == k_ir_compound_graph_path); } -/* checks whether nodes 0..pos are correct (all lie on a path.) */ -/* @@@ not implemented */ +/* Checks whether the path up to pos is correct. If the path contains a NULL, + * assumes the path is not complete and returns 'true'. */ int is_proper_compound_graph_path(compound_graph_path *gr, int pos) { int i; - entity *node; - type *owner = gr->tp; + ir_entity *node; + ir_type *owner = gr->tp; + for (i = 0; i <= pos; i++) { node = get_compound_graph_path_node(gr, i); - if (get_entity_owner(node) != owner) return false; + if (node == NULL) + /* Path not yet complete. */ + return 1; + if (get_entity_owner(node) != owner) + return 0; owner = get_entity_type(node); } if (pos == get_compound_graph_path_length(gr)) - if (!is_atomic_type(owner)) return false; - return true; + if (!is_atomic_type(owner)) + return 0; + return 1; } -int -get_compound_graph_path_length(compound_graph_path *gr) { +/* Returns the length of a graph path */ +int get_compound_graph_path_length(const compound_graph_path *gr) { assert(gr && is_compound_graph_path(gr)); return gr->len; } -entity * -get_compound_graph_path_node(compound_graph_path *gr, int pos) { +ir_entity * +get_compound_graph_path_node(const compound_graph_path *gr, int pos) { assert(gr && is_compound_graph_path(gr)); assert(pos >= 0 && pos < gr->len); - return gr->nodes[pos]; + return gr->list[pos].node; } void -set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) { +set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node) { assert(gr && is_compound_graph_path(gr)); assert(pos >= 0 && pos < gr->len); assert(is_entity(node)); - gr->nodes[pos] = node; + gr->list[pos].node = node; assert(is_proper_compound_graph_path(gr, pos)); } int -get_compound_graph_path_array_index(compound_graph_path *gr, int pos) { +get_compound_graph_path_array_index(const compound_graph_path *gr, int pos) { assert(gr && is_compound_graph_path(gr)); assert(pos >= 0 && pos < gr->len); - return gr->arr_indicees[pos]; + return gr->list[pos].index; } void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) { assert(gr && is_compound_graph_path(gr)); assert(pos >= 0 && pos < gr->len); - gr->arr_indicees[pos] = index; + gr->list[pos].index = index; } /* A value of a compound entity is a pair of value and the corresponding path to a member of the compound. */ void -add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) { +add_compound_ent_value_w_path(ir_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) { +set_compound_ent_value_w_path(ir_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) { +get_compound_ent_n_values(ir_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 * -get_compound_ent_value(entity *ent, int pos) { +ir_node * +get_compound_ent_value(ir_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) { +get_compound_ent_value_path(ir_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]; } +/** + * Returns non-zero, if two compound_graph_pathes are equal + */ +static int equal_paths(compound_graph_path *path1, int *visited_indices, compound_graph_path *path2) { + int i; + int len1 = get_compound_graph_path_length(path1); + int len2 = get_compound_graph_path_length(path2); + + if (len2 > len1) return 0; + + for (i = 0; i < len1; i++) { + ir_type *tp; + ir_entity *node1 = get_compound_graph_path_node(path1, i); + ir_entity *node2 = get_compound_graph_path_node(path2, i); + + if (node1 != node2) return 0; + + tp = get_entity_owner(node1); + if (is_Array_type(tp)) { + long low; + + /* Compute the index of this node. */ + assert(get_array_n_dimensions(tp) == 1 && "multidim not implemented"); + + low = get_array_lower_bound_int(tp, 0); + if (low + visited_indices[i] < get_compound_graph_path_array_index(path2, i)) { + visited_indices[i]++; + return 0; + } + else + assert(low + visited_indices[i] == get_compound_graph_path_array_index(path2, i)); + } + } + return 1; +} + +/* Returns the position of a value with the given path. + * The path must contain array indices for all array element entities. */ +int get_compound_ent_pos_by_path(ir_entity *ent, compound_graph_path *path) { + int i, n_paths = get_compound_ent_n_values(ent); + int *visited_indices; + int path_len = get_compound_graph_path_length(path); + + NEW_ARR_A(int *, visited_indices, path_len); + memset(visited_indices, 0, sizeof(*visited_indices) * path_len); + for (i = 0; i < n_paths; i ++) { + if (equal_paths(get_compound_ent_value_path(ent, i), visited_indices, path)) + return i; + } + +#if 0 + { + int j; + printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); + printf("Entity %s : ", get_entity_name(ent)); + for (j = 0; j < get_compound_graph_path_length(path); ++j) { + ir_entity *node = get_compound_graph_path_node(path, j); + printf("%s", get_entity_name(node)); + if (is_Array_type(get_entity_owner(node))) + printf("[%d]", get_compound_graph_path_array_index(path, j)); + } + printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); + } +#endif + + assert(0 && "path not found"); + return -1; +} + +/* Returns a constant value given the access path. + * The path must contain array indices for all array element entities. */ +ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path) { + return get_compound_ent_value(ent, get_compound_ent_pos_by_path(ent, path)); +} + + void -remove_compound_ent_value(entity *ent, entity *value_ent) { +remove_compound_ent_value(ir_entity *ent, ir_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]; - if (path->nodes[path->len-1] == 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 = 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->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(ir_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; } } } void -add_compound_ent_value(entity *ent, ir_node *val, entity *member) { +add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member) { compound_graph_path *path; - type *owner_tp = get_entity_owner(ent); + ir_type *owner_tp = get_entity_owner(member); assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); - path = new_compound_graph_path(owner_tp, 1); - path->nodes[0] = member; - if (is_array_type(owner_tp)) { + path = new_compound_graph_path(get_entity_type(ent), 1); + path->list[0].node = member; + if (is_Array_type(owner_tp)) { + int max; + int i, n; + assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0)); - int max = get_array_lower_bound_int(owner_tp, 0) -1; - for (int i = 0; i < get_compound_ent_n_values(ent); ++i) { + max = get_array_lower_bound_int(owner_tp, 0) -1; + for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) { int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0); - if (index > max) max = index; + if (index > max) { + max = index; + } } - path->arr_indicees[0] = max + 1; + path->list[0].index = max + 1; } add_compound_ent_value_w_path(ent, val, path); } @@ -674,7 +850,7 @@ add_compound_ent_value(entity *ent, ir_node *val, entity *member) { the node as constant initialization to ent. The subgraph may not contain control flow operations. void -copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) { +copy_and_add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member) { ir_graph *rem = current_ir_graph; assert(get_entity_variability(ent) != variability_uninitialized); @@ -687,13 +863,13 @@ copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) { /* Copies the value i of the entity to current_block in current_ir_graph. ir_node * -copy_compound_ent_value(entity *ent, int pos) { +copy_compound_ent_value(ir_entity *ent, int pos) { assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); return copy_const_value(ent->values[pos+1]); }*/ -entity * -get_compound_ent_value_member(entity *ent, int pos) { +ir_entity * +get_compound_ent_value_member(ir_entity *ent, int pos) { compound_graph_path *path; assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); path = get_compound_ent_value_path(ent, pos); @@ -702,7 +878,7 @@ get_compound_ent_value_member(entity *ent, int pos) { } void -set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) { +set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int pos) { compound_graph_path *path; assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized)); path = get_compound_ent_value_path(ent, pos); @@ -711,104 +887,94 @@ set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) { } void -set_array_entity_values(entity *ent, tarval **values, int num_vals) { +set_array_entity_values(ir_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; + ir_type *elttp = get_array_element_type(arrtp); - assert(is_array_type(arrtp)); + assert(is_Array_type(arrtp)); assert(get_array_n_dimensions(arrtp) == 1); - /* One bound is sufficient, the nunmber of constant fields makes the + /* One bound is sufficient, the number of constant fields makes the size. */ assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0)); assert(get_entity_variability(ent) != variability_uninitialized); current_ir_graph = get_const_code_irg(); for (i = 0; i < num_vals; i++) { - val = new_Const(get_tarval_mode (values[i]), values[i]); + val = new_Const_type(values[i], elttp); add_compound_ent_value(ent, val, get_array_element_entity(arrtp)); set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i); } current_ir_graph = rem; } -int get_compound_ent_value_offset_bits(entity *ent, int pos) { - assert(get_type_state(get_entity_type(ent)) == layout_fixed); - - compound_graph_path *path = get_compound_ent_value_path(ent, pos); - int i, path_len = get_compound_graph_path_length(path); - int offset = 0; - - 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); - if (is_array_type(owner_tp)) { - int size = get_mode_size_bits (get_type_mode(node_tp)); - int align = get_mode_align_bits(get_type_mode(node_tp)); - if (size <= align) - size = align; - else { - assert(size % align == 0); - /* ansonsten aufrunden */ - } - offset += size * get_compound_graph_path_array_index(path, i); - } else { - offset += get_entity_offset_bits(node); - } - } - return offset; -} +int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) { + compound_graph_path *path; + int path_len, i; + int offset = 0; + + assert(get_type_state(get_entity_type(ent)) == layout_fixed); + + path = get_compound_ent_value_path(ent, pos); + path_len = get_compound_graph_path_length(path); + + for (i = 0; i < path_len; ++i) { + ir_entity *node = get_compound_graph_path_node(path, i); + ir_type *node_tp = get_entity_type(node); + ir_type *owner_tp = get_entity_owner(node); + + if (owner_tp != NULL && is_Array_type(owner_tp)) { + int size = get_type_size_bits(node_tp); + int align = get_type_alignment_bits(node_tp); + if(size % align > 0) { + size += align - (size % align); + } + assert(size % 8 == 0); + size /= 8; + offset += size * get_compound_graph_path_array_index(path, i - 1); + } else { + int node_offset = get_entity_offset_bits(node); + + if(node_offset % 8 != 0) { + assert(i == path_len - 1); + } + offset += node_offset / 8; + } + } -int get_compound_ent_value_offset_bytes(entity *ent, int pos) { - int offset = get_compound_ent_value_offset_bits(ent, pos); - assert(offset % 8 == 0); - return offset >> 3; + return offset; } +int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) { + compound_graph_path *path; + int path_len; + int offset = 0; + ir_entity *last_node; -static void init_index(type *arr) { - int init; - int dim = 0; + assert(get_type_state(get_entity_type(ent)) == layout_fixed); - assert(get_array_n_dimensions(arr) == 1); + path = get_compound_ent_value_path(ent, pos); + path_len = get_compound_graph_path_length(path); + last_node = get_compound_graph_path_node(path, path_len - 1); - if (has_array_lower_bound(arr, dim)) - init = get_array_lower_bound_int(arr, 0) -1; - else - init = get_array_upper_bound_int(arr, 0) +1; + offset = get_entity_offset_bits(last_node); + if(offset < 0) + return 0; - set_entity_link(get_array_element_entity(arr), (void *)init); + return offset % 8; } +typedef struct { + /** number of elements the array can hold */ + int n_elems; + /** current array index */ + int current_elem; + ir_entity *ent; +} array_info; -static int get_next_index(entity *elem_ent) { - type *arr = get_entity_owner(elem_ent); - int next; - int dim = 0; - - assert(get_array_n_dimensions(arr) == 1); - - if (has_array_lower_bound(arr, dim)) { - next = (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; - 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); - return next; -} - -/* Compute the array indicees in compound graph paths of initialized entities. +/* Compute the array indices in compound graph paths of initialized entities. * * All arrays must have fixed lower and upper bounds. One array can * have an open bound. If there are several open bounds, we do @@ -816,478 +982,421 @@ static int get_next_index(entity *elem_ent) { * elements. Uses the link field in the array element entities. The * array bounds must be representable as ints. * + * WARNING: it is impossible to get this 100% right with the current + * design... (in array of structs you cant know when a struct is + * really finished and the next array element starts) + * * (If the bounds are not representable as ints we have to represent - * the indicees as firm nodes. But the still we must be able to + * the indices as firm nodes. But still we must be able to * evaluate the index against the upper bound.) */ -void compute_compound_ent_array_indicees(entity *ent) { - type *tp = get_entity_type(ent); - int i, n_vals; - entity *unknown_bound_entity = NULL; - - if (!is_compound_type(tp) || - (ent->variability == variability_uninitialized)) return ; - - n_vals = get_compound_ent_n_values(ent); - if (n_vals == 0) return; - - /* We can not compute the indicees if there is more than one array - with an unknown bound. For this remember the first entity that - represents such an array. It could be ent. */ - if (is_array_type(tp)) { - assert(get_array_n_dimensions(tp) == 1 && "other not implemented"); - int dim = 0; - if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim)) - unknown_bound_entity = ent; - } - - /* Initialize the entity links to lower bound -1 and test all path elements - for known bounds. */ - for (i = 0; i < n_vals; ++i) { - compound_graph_path *path = get_compound_ent_value_path(ent, i); - 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); - - if (is_array_type(elem_tp)) { - assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented"); - int dim = 0; - if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) { - if (!unknown_bound_entity) unknown_bound_entity = node; - if (node != unknown_bound_entity) return; +int compute_compound_ent_array_indices(ir_entity *ent) { + ir_type *tp = get_entity_type(ent); + int i, n_vals; + int max_len = 0; + array_info *array_infos; + + assert(is_compound_type(tp)); + + if (!is_compound_type(tp) || + (ent->variability == variability_uninitialized)) + return 1; + + n_vals = get_compound_ent_n_values(ent); + for(i = 0; i < n_vals; ++i) { + compound_graph_path *path = get_compound_ent_value_path(ent, i); + int len = get_compound_graph_path_length(path); + if(len > max_len) + max_len = len; } - init_index(elem_tp); - } - } - } - - /* Finally compute the indicees ... */ - for (i = 0; i < n_vals; ++i) { - compound_graph_path *path = get_compound_ent_value_path(ent, i); - 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); - if (is_array_type(owner_tp)) - set_compound_graph_path_array_index (path, j, get_next_index(node)); - } - } - -} - - -static int *resize (int *buf, int new_size) { - int *new_buf = (int *)calloc(new_size, 4); - memcpy(new_buf, buf, new_size>1); - free(buf); - return new_buf; -} - -/* We sort the elements by placing them at their bit offset in an - array where each entry represents one bit called permutation. In - fact, we do not place the values themselves, as we would have to - copy two things, the value and the path. We only remember the - position in the old order. Each value should have a distinct - position in the permutation. - - A second iteration now permutes the actual elements into two - new arrays. */ -void sort_compound_ent_values(entity *ent) { - assert(get_type_state(get_entity_type(ent)) == layout_fixed); - - type *tp = get_entity_type(ent); - int i, n_vals = get_compound_ent_n_values(ent); - int tp_size = get_type_size_bits(tp); - int size; - int *permutation; - - if (!is_compound_type(tp) || - (ent->variability == variability_uninitialized) || - (get_type_state(tp) != layout_fixed) || - (n_vals == 0) ) return; - - /* estimated upper bound for size. Better: use flexible array ... */ - size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4; - permutation = (int *)calloc(size, 4); - for (i = 0; i < n_vals; ++i) { - int pos = get_compound_ent_value_offset_bits(ent, i); - while (pos >= size) { - size = size + size; - permutation = resize(permutation, size); - } - assert(pos < size); - assert(permutation[pos] == 0 && "two values with the same offset"); - permutation[pos] = i + 1; /* We initialized with 0, so we can not distinguish entry 0. - So inc all entries by one. */ - //fprintf(stderr, "i: %d, pos: %d \n", i, pos); - } - - int next = 0; - ir_node **my_values = NEW_ARR_F(ir_node *, n_vals); - compound_graph_path **my_paths = NEW_ARR_F(compound_graph_path *, n_vals); - for (i = 0; i < size; ++i) { - int pos = permutation[i]; - if (pos) { - //fprintf(stderr, "pos: %d i: %d next %d \n", i, pos, next); - assert(next < n_vals); - pos--; /* We increased the pos by one */ - my_values[next] = get_compound_ent_value (ent, pos); - my_paths [next] = get_compound_ent_value_path(ent, pos); - next++; - } - } - free(permutation); + array_infos = alloca(max_len * sizeof(array_infos[0])); + memset(array_infos, 0, max_len * sizeof(array_infos[0])); + + for(i = 0; i < n_vals; ++i) { + compound_graph_path *path = get_compound_ent_value_path(ent, i); + int path_len = get_compound_graph_path_length(path); + int j; + int needadd = 0; + ir_entity *prev_node = NULL; + + for(j = path_len-1; j >= 0; --j) { + int dim, dims; + int n_elems; + ir_entity *node = get_compound_graph_path_node(path, j); + const ir_type *node_type = get_entity_type(node); + array_info *info = &array_infos[j]; + + if(is_atomic_entity(node)) { + needadd = 1; + set_compound_graph_path_array_index(path, j, -1); + prev_node = node; + continue; + } else if(is_compound_type(node_type) && !is_Array_type(node_type)) { + int n_members = get_compound_n_members(node_type); + ir_entity *last = get_compound_member(node_type, n_members - 1); + if(needadd && last == prev_node) { + needadd = 1; + } else { + needadd = 0; + } + set_compound_graph_path_array_index(path, j, -1); + prev_node = node; + continue; + } + + if(info->ent != node) { + n_elems = 1; + dims = get_array_n_dimensions(node_type); + for(dim = 0; dim < dims; ++dim) { + long lower_bound = 0; + long upper_bound = -1; + + if(has_array_lower_bound(node_type, 0)) { + lower_bound = get_array_lower_bound_int(node_type, 0); + } + if(has_array_upper_bound(node_type, 0)) { + upper_bound = get_array_upper_bound_int(node_type, 0); + assert(upper_bound >= lower_bound); + n_elems *= (upper_bound - lower_bound); + } else { + assert(dim == dims-1); + n_elems = -1; + } + } + + info->ent = node; + info->n_elems = n_elems; + info->current_elem = 0; + } + + set_compound_graph_path_array_index(path, j, info->current_elem); + + if(needadd) { + info->current_elem++; + if(info->current_elem >= info->n_elems) { + needadd = 1; + info->current_elem = 0; + } else { + needadd = 0; + } + } + + prev_node = node; + } + } - DEL_ARR_F(ent->values); - ent->values = my_values; - DEL_ARR_F(ent->val_paths); - ent->val_paths = my_paths; + return 1; } int -(get_entity_offset_bytes)(entity *ent) { - return __get_entity_offset_bytes(ent); +(get_entity_offset_bytes)(const ir_entity *ent) { + return _get_entity_offset_bytes(ent); } int -(get_entity_offset_bits)(entity *ent) { - return __get_entity_offset_bits(ent); +(get_entity_offset_bits)(const ir_entity *ent) { + return _get_entity_offset_bits(ent); } void -(set_entity_offset_bytes)(entity *ent, int offset) { - __set_entity_offset_bytes(ent, offset); +(set_entity_offset_bytes)(ir_entity *ent, int offset) { + _set_entity_offset_bytes(ent, offset); } void -(set_entity_offset_bits)(entity *ent, int offset) { - __set_entity_offset_bits(ent, offset); +(set_entity_offset_bits)(ir_entity *ent, int offset) { + _set_entity_offset_bits(ent, offset); } void -add_entity_overwrites(entity *ent, entity *overwritten) { - assert(ent && is_class_type(get_entity_owner(ent))); - ARR_APP1(entity *, ent->overwrites, overwritten); - ARR_APP1(entity *, overwritten->overwrittenby, ent); +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 */ + ARR_APP1(ir_entity *, ent->overwrites, overwritten); + ARR_APP1(ir_entity *, overwritten->overwrittenby, ent); } int -get_entity_n_overwrites(entity *ent) { - assert(ent && is_class_type(get_entity_owner(ent))); +get_entity_n_overwrites(ir_entity *ent) { + assert(is_Class_type(get_entity_owner(ent))); return (ARR_LEN(ent->overwrites)); } int -get_entity_overwrites_index(entity *ent, entity *overwritten) { +get_entity_overwrites_index(ir_entity *ent, ir_entity *overwritten) { int i; - assert(ent && is_class_type(get_entity_owner(ent))); + assert(is_Class_type(get_entity_owner(ent))); for (i = 0; i < get_entity_n_overwrites(ent); i++) if (get_entity_overwrites(ent, i) == overwritten) return i; return -1; } -entity * -get_entity_overwrites (entity *ent, int pos) { - assert(ent && is_class_type(get_entity_owner(ent))); +ir_entity * +get_entity_overwrites (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 (entity *ent, int pos, entity *overwritten) { - assert(ent && is_class_type(get_entity_owner(ent))); +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; } void -remove_entity_overwrites(entity *ent, entity *overwritten) { +remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) { int i; - assert(ent && is_class_type(get_entity_owner(ent))); + assert(is_Class_type(get_entity_owner(ent))); for (i = 0; i < (ARR_LEN (ent->overwrites)); i++) if (ent->overwrites[i] == overwritten) { for(; i < (ARR_LEN (ent->overwrites))-1; i++) ent->overwrites[i] = ent->overwrites[i+1]; - ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1); + ARR_SETLEN(ir_entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1); break; } } void -add_entity_overwrittenby (entity *ent, entity *overwrites) { - assert(ent && is_class_type(get_entity_owner(ent))); +add_entity_overwrittenby (ir_entity *ent, ir_entity *overwrites) { add_entity_overwrites(overwrites, ent); } int -get_entity_n_overwrittenby (entity *ent) { - assert(ent && is_class_type(get_entity_owner(ent))); +get_entity_n_overwrittenby (ir_entity *ent) { + assert(is_Class_type(get_entity_owner(ent))); return (ARR_LEN (ent->overwrittenby)); } int -get_entity_overwrittenby_index(entity *ent, entity *overwrites) { +get_entity_overwrittenby_index(ir_entity *ent, ir_entity *overwrites) { int i; - assert(ent && is_class_type(get_entity_owner(ent))); + assert(is_Class_type(get_entity_owner(ent))); for (i = 0; i < get_entity_n_overwrittenby(ent); i++) if (get_entity_overwrittenby(ent, i) == overwrites) return i; return -1; } -entity * -get_entity_overwrittenby (entity *ent, int pos) { - assert(ent && is_class_type(get_entity_owner(ent))); +ir_entity * +get_entity_overwrittenby (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 (entity *ent, int pos, entity *overwrites) { - assert(ent && is_class_type(get_entity_owner(ent))); +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; } -void remove_entity_overwrittenby(entity *ent, entity *overwrites) { +void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) { int i; - assert(ent && is_class_type(get_entity_owner(ent))); + assert(is_Class_type(get_entity_owner(ent))); for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++) if (ent->overwrittenby[i] == overwrites) { for(; i < (ARR_LEN (ent->overwrittenby))-1; i++) ent->overwrittenby[i] = ent->overwrittenby[i+1]; - ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1); + ARR_SETLEN(ir_entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1); break; } } /* A link to store intermediate information */ void * -(get_entity_link)(entity *ent) { - return __get_entity_link(ent); +(get_entity_link)(const ir_entity *ent) { + return _get_entity_link(ent); } void -(set_entity_link)(entity *ent, void *l) { - __set_entity_link(ent, l); +(set_entity_link)(ir_entity *ent, void *l) { + _set_entity_link(ent, l); } ir_graph * -(get_entity_irg)(entity *ent) { - return __get_entity_irg(ent); +(get_entity_irg)(const ir_entity *ent) { + return _get_entity_irg(ent); } void -set_entity_irg(entity *ent, ir_graph *irg) { - assert(ent && is_method_type(get_entity_type(ent))); +set_entity_irg(ir_entity *ent, ir_graph *irg) { + assert(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. */ + * aber erhalten bleiben soll? Wandle die Entitaet in description oder + * inherited um! */ /* assert(irg); */ assert((irg && ent->peculiarity == peculiarity_existent) || + (!irg && (ent->peculiarity == peculiarity_existent) + && (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(ir_entity *ent) { + assert(is_method_entity(ent)); + return ent->attr.mtd_attr.vtable_number; +} + +void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number) { + assert(is_method_entity(ent)); + ent->attr.mtd_attr.vtable_number = vtable_number; +} + +/* Returns the section of a method. */ +ir_img_section get_method_img_section(const ir_entity *ent) { + assert(is_method_entity(ent)); + return ent->attr.mtd_attr.section; +} + +/* Sets the section of a method. */ +void set_method_img_section(ir_entity *ent, ir_img_section section) { + assert(is_method_entity(ent)); + ent->attr.mtd_attr.section = section; } int -(is_entity)(void *thing) { - return __is_entity(thing); +(is_entity)(const void *thing) { + return _is_entity(thing); } -int is_atomic_entity(entity *ent) { - 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_atomic_entity(ir_entity *ent) { + ir_type *t = get_entity_type(ent); + const tp_op *op = get_type_tpop(t); + return (op == type_primitive || op == type_pointer || + op == type_enumeration || op == type_method); } -int is_compound_entity(entity *ent) { - 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_compound_entity(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); +} + +int is_method_entity(ir_entity *ent) { + ir_type *t = get_entity_type(ent); + return is_Method_type(t); } /** - * @todo not implemnted!!! */ -bool equal_entity(entity *ent1, entity *ent2) { + * @todo not implemented!!! */ +int equal_entity(ir_entity *ent1, ir_entity *ent2) { fprintf(stderr, " calling unimplemented equal entity!!! \n"); - return true; + return 1; } -unsigned long get_entity_visited(entity *ent) { - assert(ent && ent->kind == k_entity); - return ent->visit; +unsigned long (get_entity_visited)(ir_entity *ent) { + return _get_entity_visited(ent); } -void set_entity_visited(entity *ent, unsigned long num) { - assert(ent && ent->kind == k_entity); - ent->visit = num; -} -/* Sets visited field in entity to entity_visited. */ -void mark_entity_visited(entity *ent) { - assert(ent && ent->kind == k_entity); - ent->visit = type_visited; + +void (set_entity_visited)(ir_entity *ent, unsigned long num) { + _set_entity_visited(ent, num); } +/* Sets visited field in ir_entity to entity_visited. */ +void (mark_entity_visited)(ir_entity *ent) { + _mark_entity_visited(ent); +} -bool entity_visited(entity *ent) { - assert(ent && ent->kind == k_entity); - return get_entity_visited(ent) >= type_visited; +int (entity_visited)(ir_entity *ent) { + return _entity_visited(ent); } -bool entity_not_visited(entity *ent) { - assert(ent && ent->kind == k_entity); - return get_entity_visited(ent) < type_visited; +int (entity_not_visited)(ir_entity *ent) { + return _entity_not_visited(ent); } -/* Need two routines because I want to assert the result. */ -static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) { - int i, n_overwrittenby; - entity *res = NULL; +/* Returns the mask of the additional entity properties. */ +unsigned get_entity_additional_properties(ir_entity *ent) { + ir_graph *irg; - if (get_entity_owner(static_ent) == dynamic_class) return static_ent; + assert(is_method_entity(ent)); - n_overwrittenby = get_entity_n_overwrittenby(static_ent); - for (i = 0; i < n_overwrittenby; ++i) { - res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i)); - if (res) break; - } + /* first check, if the graph has additional properties */ + irg = get_entity_irg(ent); - return res; + 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; } -/** Resolve polymorphy in the inheritance relation. - * - * Returns the dynamically referenced entity if the static entity and the - * dynamic type are given. - * Search downwards in overwritten tree. */ -entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) { - entity *res; - assert(static_ent && static_ent->kind == k_entity); - - res = resolve_ent_polymorphy2(dynamic_class, static_ent); - if (!res) { - printf(" Could not find entity "); DDME(static_ent); - printf(" in "); DDMT(dynamic_class); - printf("\n"); - dump_entity(static_ent); - dump_type(get_entity_owner(static_ent)); - dump_type(dynamic_class); +/* Sets the mask of the additional graph properties. */ +void set_entity_additional_properties(ir_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; } - assert(res); - return res; } +/* Sets one additional graph property. */ +void set_entity_additional_property(ir_entity *ent, mtp_additional_property flag) +{ + ir_graph *irg; + assert(is_method_entity(ent)); -/*******************************************************************/ -/** Debug aides **/ -/*******************************************************************/ - + /* 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 1 || DEBUG_libfirm -int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */ + if (mask & mtp_property_inherited) + mask = get_method_additional_properties(get_entity_type(ent)); -#define X(a) case a: printf(#a); break -void dump_entity (entity *ent) { - int i, j; - type *owner = get_entity_owner(ent); - type *type = get_entity_type(ent); - assert(ent && ent->kind == k_entity); - printf("entity %s (%ld)\n", get_entity_name(ent), get_entity_nr(ent)); - printf(" type: %s (%ld)\n", get_type_name(type), get_type_nr(type)); - printf(" owner: %s (%ld)\n", get_type_name(owner), get_type_nr(owner)); - - if (get_entity_n_overwrites(ent) > 0) { - printf(" overwrites:\n"); - for (i = 0; i < get_entity_n_overwrites(ent); ++i) { - entity *ov = get_entity_overwrites(ent, i); - printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov))); - } - } else { - printf(" Does not overwrite other entities. \n"); - } - if (get_entity_n_overwrittenby(ent) > 0) { - printf(" overwritten by:\n"); - for (i = 0; i < get_entity_n_overwrittenby(ent); ++i) { - entity *ov = get_entity_overwrittenby(ent, i); - printf(" %d: %s of class %s\n", i, get_entity_name(ov), get_type_name(get_entity_owner(ov))); - } - } else { - printf(" Is not overwriten by other entities. \n"); - } - - printf(" allocation: "); - switch (get_entity_allocation(ent)) { - X(allocation_dynamic); - X(allocation_automatic); - X(allocation_static); - X(allocation_parameter); + /* 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); } +} - printf("\n visibility: "); - switch (get_entity_visibility(ent)) { - X(visibility_local); - X(visibility_external_visible); - X(visibility_external_allocated); - } +/* Returns the class type that this type info entity represents or NULL + if ent is no type info entity. */ +ir_type *(get_entity_repr_class)(const ir_entity *ent) { + return _get_entity_repr_class(ent); +} - printf("\n variability: "); - switch (get_entity_variability(ent)) { - X(variability_uninitialized); - X(variability_initialized); - X(variability_part_constant); - X(variability_constant); - } +/* Initialize entity module. */ +void firm_init_entity(void) +{ + symconst_symbol sym; - if (get_entity_variability(ent) != variability_uninitialized) { - if (is_atomic_entity(ent)) { - printf("\n atomic value: "); - dump_node_opcode(stdout, get_atomic_ent_value(ent)); - } else { - printf("\n compound values:"); - for (i = 0; i < get_compound_ent_n_values(ent); ++i) { - compound_graph_path *path = get_compound_ent_value_path(ent, i); - entity *ent0 = get_compound_graph_path_node(path, 0); - printf("\n %3d ", get_entity_offset_bits(ent0)); - if (get_type_state(type) == layout_fixed) - printf("(%3d) ", get_compound_ent_value_offset_bits(ent, i)); - printf("%s", get_entity_name(ent0)); - for (j = 0; j < get_compound_graph_path_length(path); ++j) { - entity *node = get_compound_graph_path_node(path, j); - printf(".%s", get_entity_name(node)); - if (is_array_type(get_entity_owner(node))) - printf("[%d]", get_compound_graph_path_array_index(path, j)); - } - printf("\t = "); - dump_node_opcode(stdout, get_compound_ent_value(ent, i)); - } - } - } + assert(firm_unknown_type && "Call init_type() before firm_init_entity()!"); + assert(!unknown_entity && "Call firm_init_entity() only once!"); - printf("\n volatility: "); - switch (get_entity_volatility(ent)) { - X(volatility_non_volatile); - X(volatility_is_volatile); - } + 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)); - printf("\n peculiarity: %s", get_peculiarity_string(get_entity_peculiarity(ent))); - printf("\n ld_name: %s", ent->ld_name ? get_entity_ld_name(ent) : "no yet set"); - printf("\n offset: %d", get_entity_offset_bits(ent)); - if (is_method_type(get_entity_type(ent))) { - if (get_entity_irg(ent)) /* can be null */ - { printf("\n irg = %ld", get_irg_graph_nr(get_entity_irg(ent))); } - else - { printf("\n irg = NULL"); } - } - printf("\n\n"); + current_ir_graph = get_const_code_irg(); + sym.entity_p = unknown_entity; + unknown_entity->value = new_SymConst(sym, symconst_addr_ent); } -#undef X -#else /* DEBUG_libfirm */ -void dump_entity (entity *ent) {} -#endif /* DEBUG_libfirm */