X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Fentity.c;h=0051f863fe98f508106ed50e7a7422cd9e5ebbec;hb=b7b24e372a1338ecd5eb26bdd285a8cbe7b1fec9;hp=cf61bdead77738fb380fe1a6b7682ebe3402c862;hpb=25a9079a440dca3115aedcc4c22438e187ed9d7d;p=libfirm diff --git a/ir/tr/entity.c b/ir/tr/entity.c index cf61bdead..0051f863f 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -1,837 +1,1067 @@ /* - * Project: libFIRM - * File name: ir/tr/entity.c - * Purpose: Representation of all program known entities. - * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. */ -#ifdef HAVE_CONFIG_H -# include -#endif +/** + * @file + * @brief Representation of all program known entities. + * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck + * @version $Id$ + */ +#include "config.h" + +#include +#include +#include + +#include "xmalloc.h" +#include "entity_t.h" +#include "array.h" +#include "irtools.h" +#include "irhooks.h" +#include "irprintf.h" + +#include "irprog_t.h" +#include "ircons.h" +#include "tv_t.h" +#include "irdump.h" +#include "irgraph_t.h" +#include "callgraph.h" +#include "error.h" +#include "compound_path.h" + +/*-----------------------------------------------------------------*/ +/** general **/ +/*-----------------------------------------------------------------*/ -# include -# include -# include +ir_entity *unknown_entity = NULL; -# 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" +ir_entity *get_unknown_entity(void) { return unknown_entity; } -/*******************************************************************/ -/** general **/ -/*******************************************************************/ - -void -init_entity (void) -{ -} - -/*******************************************************************/ -/** ENTITY **/ -/*******************************************************************/ - -/* redeclared to declare INLINE. */ -INLINE entity *get_entity_overwrites (entity *ent, int pos); -INLINE entity *get_entity_overwrittenby (entity *ent, int pos); -INLINE type *get_entity_owner (entity *ent); - -INLINE void insert_entity_in_owner (entity *ent) { - type *owner = ent->owner; - switch (get_type_tpop_code(owner)) { - case tpo_class: { - add_class_member (owner, ent); - } break; - case tpo_struct: { - add_struct_member (owner, ent); - } break; - case tpo_union: { - add_union_member (owner, ent); - } break; - case tpo_array: { - set_array_element_entity(owner, ent); - } break; - default: assert(0); - } -} - -entity * -new_entity (type *owner, ident *name, type *type) -{ - 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 = static_allocated; - else - res->allocation = automatic_allocated; - res->visibility = local; - res->offset = -1; - if (is_method_type(type)) { - res->variability = constant; - rem = current_ir_graph; - current_ir_graph = get_const_code_irg(); - res->value = new_Const(mode_P_mach, new_tarval_from_entity(res, mode_P_mach)); - current_ir_graph = rem; - } else { - res->variability = uninitialized; - res->value = NULL; - res->values = NULL; - } - res->peculiarity = existent; - res->volatility = non_volatile; - res->ld_name = NULL; - res->overwrites = NEW_ARR_F(entity *, 1); - res->overwrittenby = NEW_ARR_F(entity *, 1); - - res->irg = NULL; +/** The name of the unknown entity. */ +#define UNKNOWN_ENTITY_NAME "unknown_entity" -#ifdef DEBUG_libfirm - res->nr = get_irp_new_node_nr(); -#endif +/*-----------------------------------------------------------------*/ +/* ENTITY */ +/*-----------------------------------------------------------------*/ + +ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type, + dbg_info *db) +{ + ir_entity *res; + + assert(!id_contains_char(name, ' ') && "entity name should not contain spaces"); + + res = XMALLOCZ(ir_entity); + + res->kind = k_entity; + res->name = name; + res->ld_name = NULL; + res->type = type; + res->owner = owner; + + res->volatility = volatility_non_volatile; + res->aligned = align_is_aligned; + res->usage = ir_usage_unknown; + res->compiler_gen = 0; + res->visibility = ir_visibility_default; + res->offset = -1; + res->offset_bit_remainder = 0; + res->alignment = 0; + res->link = NULL; + res->repr_class = NULL; + + 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; + 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; + res->attr.mtd_attr.param_access = NULL; + res->attr.mtd_attr.param_weight = NULL; + res->attr.mtd_attr.irg = NULL; + } else if (is_compound_type(type)) { + res->attr.cmpd_attr.values = NULL; + res->attr.cmpd_attr.val_paths = NULL; + } else if (is_code_type(type)) { + res->attr.code_attr.label = (ir_label_t) -1; + } + + /* Remember entity in its owner. */ + if (owner != NULL) + add_compound_member(owner, res); - res->visit = 0; - - /* 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); - return res; -} -INLINE void free_entity_attrs(entity *ent) { - assert(ent); - if (get_type_tpop(get_entity_owner(ent)) == type_class) { - DEL_ARR_F(ent->overwrites); - DEL_ARR_F(ent->overwrittenby); - } -} - -entity * -copy_entity_own (entity *old, type *new_owner) { - entity *new; - - assert_legal_owner_of_ent(new_owner); - if (old->owner == new_owner) return old; - new = (entity *) xmalloc (sizeof (entity)); - memcpy (new, old, sizeof (entity)); - new->owner = new_owner; - /* - if ((get_type_tpop(get_entity_owner(old)) == type_class) && - (get_type_tpop(new_owner) == type_class)) { - new->overwrites = DUP_ARR_F(entity *, old->overwrites); - new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby); - } else if ((get_type_tpop(get_entity_owner(old)) != type_class) && - (get_type_tpop(new_owner) == type_class)) { - new->overwrites = NEW_ARR_F(entity *, 1); - new->overwrittenby = NEW_ARR_F(entity *, 1); - } - */ - if (is_class_type(new_owner)) { - new->overwrites = NEW_ARR_F(entity *, 1); - new->overwrittenby = NEW_ARR_F(entity *, 1); - } #ifdef DEBUG_libfirm - new->nr = get_irp_new_node_nr(); + res->nr = get_irp_new_node_nr(); #endif - insert_entity_in_owner (new); + res->visit = 0; + set_entity_dbg_info(res, db); + + hook_new_entity(res); - return new; + return res; } -entity * -copy_entity_name (entity *old, ident *new_name) { - entity *new; +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) +{ + if (ent->overwrites != NULL) { + DEL_ARR_F(ent->overwrites); + ent->overwrites = NULL; + } + if (ent->overwrittenby != NULL) { + DEL_ARR_F(ent->overwrittenby); + ent->overwrittenby = NULL; + } + + if (ent->initializer != NULL) { + /* TODO: free initializers */ + } else if (entity_has_compound_ent_values(ent)) { + /* can't free compound graph path as it might be used + * multiple times */ + ent->attr.cmpd_attr.val_paths = NULL; + } + if (is_compound_entity(ent)) { + 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; + } + } +} + +/** + * Creates a deep copy of an entity. + */ +static ir_entity *deep_entity_copy(ir_entity *old) +{ + ir_entity *newe = XMALLOC(ir_entity); + + *newe = *old; + if (old->initializer != NULL) { + /* FIXME: the initializers are NOT copied */ + } else if (entity_has_compound_ent_values(old)) { + newe->attr.cmpd_attr.values = NULL; + newe->attr.cmpd_attr.val_paths = NULL; + if (old->attr.cmpd_attr.values) + newe->attr.cmpd_attr.values = DUP_ARR_F(ir_node *, old->attr.cmpd_attr.values); + + /* FIXME: the compound graph paths are NOT copied */ + if (old->attr.cmpd_attr.val_paths) + newe->attr.cmpd_attr.val_paths = DUP_ARR_F(compound_graph_path *, old->attr.cmpd_attr.val_paths); + } else if (is_method_entity(old)) { + /* do NOT copy them, reanalyze. This might be the best solution */ + newe->attr.mtd_attr.param_access = NULL; + newe->attr.mtd_attr.param_weight = NULL; + } + newe->overwrites = NULL; + newe->overwrittenby = NULL; - 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); - } #ifdef DEBUG_libfirm - new->nr = get_irp_new_node_nr(); + newe->nr = get_irp_new_node_nr(); #endif + return newe; +} - insert_entity_in_owner (new); +/* + * Copies the entity if the new_owner is different from the + * owner of the old entity, else returns the old entity. + */ +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)); + assert(get_type_state(new_owner) != layout_fixed); + + if (old->owner == new_owner) + return old; + + /* create a deep copy so we are safe of aliasing and double-freeing. */ + newe = deep_entity_copy(old); + newe->owner = new_owner; + add_compound_member(new_owner, newe); - return new; + return newe; } +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; -void -free_entity (entity *ent) { - free_tarval_entity(ent); - free_entity_attrs(ent); - free(ent); + newe = deep_entity_copy(old); + newe->name = new_name; + newe->ld_name = NULL; + add_compound_member(old->owner, newe); + + return newe; +} + +void free_entity(ir_entity *ent) +{ + if (ent->owner != NULL && !is_Array_type(ent->owner)) + remove_compound_member(ent->owner, ent); + + assert(ent && ent->kind == k_entity); + free_entity_attrs(ent); + ent->kind = k_BAD; + xfree(ent); } /* Outputs a unique number for this node */ -INLINE long -get_entity_nr(entity *ent) { - assert(ent); +long get_entity_nr(const ir_entity *ent) +{ + assert(ent && ent->kind == k_entity); #ifdef DEBUG_libfirm - return ent->nr; + return ent->nr; #else - return 0; + return (long)PTR_TO_INT(ent); #endif } -INLINE const char * -get_entity_name (entity *ent) { - assert (ent); - return get_id_str(get_entity_ident(ent)); +const char *(get_entity_name)(const ir_entity *ent) +{ + return _get_entity_name(ent); } -ident * -get_entity_ident (entity *ent) { - assert(ent); - return ent->name; +ident *(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); -*/ - -INLINE type * -get_entity_owner (entity *ent) { - return ent->owner = skip_tid(ent->owner); +void (set_entity_ident)(ir_entity *ent, ident *id) +{ + _set_entity_ident(ent, id); } -INLINE void -set_entity_owner (entity *ent, type *owner) { - assert_legal_owner_of_ent(owner); - ent->owner = owner; +ir_type *(get_entity_owner)(const ir_entity *ent) +{ + return _get_entity_owner(ent); } -INLINE 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! */ +void set_entity_owner(ir_entity *ent, ir_type *owner) +{ + assert(is_entity(ent)); + assert(is_compound_type(owner)); + + remove_compound_member(ent->owner, ent); + add_compound_member(owner, ent); + ent->owner = owner; } -INLINE ident * -get_entity_ld_ident (entity *ent) +ident *(get_entity_ld_ident)(const ir_entity *ent) { - if (ent->ld_name == NULL) - ent->ld_name = mangle_entity (ent); - return ent->ld_name; + return _get_entity_ld_ident(ent); } -INLINE void -set_entity_ld_ident (entity *ent, ident *ld_ident) { - ent->ld_name = ld_ident; +void (set_entity_ld_ident)(ir_entity *ent, ident *ld_ident) +{ + _set_entity_ld_ident(ent, ld_ident); } -INLINE const char * -get_entity_ld_name (entity *ent) { - return get_id_str(get_entity_ld_ident(ent)); +const char *(get_entity_ld_name)(const ir_entity *ent) +{ + return _get_entity_ld_name(ent); } -/* -char *get_entity_ld_name (entity *); -void set_entity_ld_name (entity *, char *ld_name); -*/ - -INLINE type * -get_entity_type (entity *ent) { - return ent->type = skip_tid(ent->type); +int entity_has_ld_ident(const ir_entity *entity) +{ + return entity->ld_name != NULL; } -INLINE void -set_entity_type (entity *ent, type *type) { - ent->type = type; +ir_type *(get_entity_type)(const ir_entity *ent) +{ + return _get_entity_type(ent); } +void (set_entity_type)(ir_entity *ent, ir_type *type) +{ + _set_entity_type(ent, type); +} -INLINE ent_allocation -get_entity_allocation (entity *ent) { - return ent->allocation; +ir_volatility (get_entity_volatility)(const ir_entity *ent) +{ + return _get_entity_volatility(ent); } -INLINE void -set_entity_allocation (entity *ent, ent_allocation al) { - ent->allocation = al; +void (set_entity_volatility)(ir_entity *ent, ir_volatility vol) +{ + _set_entity_volatility(ent, vol); } -/* return the name of the visibility */ -const char *get_allocation_name(ent_allocation all) +/* Return the name of the volatility. */ +const char *get_volatility_name(ir_volatility var) { -#define X(a) case a: return #a - switch (all) { - X(automatic_allocated); - X(parameter_allocated); - X(dynamic_allocated); - X(static_allocated); +#define X(a) case a: return #a + switch (var) { + X(volatility_non_volatile); + X(volatility_is_volatile); default: return "BAD VALUE"; - } + } #undef X } +ir_align (get_entity_aligned)(const ir_entity *ent) +{ + return _get_entity_aligned(ent); +} -INLINE ent_visibility -get_entity_visibility (entity *ent) { - return ent->visibility; +void (set_entity_aligned)(ir_entity *ent, ir_align a) +{ + _set_entity_aligned(ent, a); } -INLINE void -set_entity_visibility (entity *ent, ent_visibility vis) { - if (vis != local) - assert((ent->allocation == static_allocated) || - (ent->allocation == automatic_allocated)); - /* @@@ Test that the owner type is not local, but how?? - && get_class_visibility(get_entity_owner(ent)) != local));*/ - ent->visibility = vis; +unsigned (get_entity_alignment)(const ir_entity *ent) +{ + return _get_entity_alignment(ent); } -/* return the name of the visibility */ -const char *get_visibility_name(ent_visibility vis) +void (set_entity_alignment)(ir_entity *ent, unsigned alignment) { -#define X(a) case a: return #a - switch (vis) { - X(local); - X(external_visible); - X(external_allocated); - default: return "BAD VALUE"; - } -#undef X + _set_entity_alignment(ent, alignment); } -INLINE ent_variability -get_entity_variability (entity *ent) { - return ent->variability; -} - -INLINE void -set_entity_variability (entity *ent, ent_variability var){ - if (var == part_constant) - assert(is_class_type(ent->type) || is_struct_type(ent->type)); - if ((is_compound_type(ent->type)) && - (ent->variability == uninitialized) && (var != uninitialized)) { - /* Allocate datastructures for constant values */ - ent->values = NEW_ARR_F(ir_node *, 1); - ent->val_paths = NEW_ARR_F(compound_graph_path *, 1); - } - if ((is_compound_type(ent->type)) && - (var == uninitialized) && (ent->variability != uninitialized)) { - /* Free datastructures for constant values */ - DEL_ARR_F(ent->values); - DEL_ARR_F(ent->val_paths); - } - ent->variability = var; -} - -/* return the name of the variablity */ -const char *get_variability_name(ent_variability var) -{ -#define X(a) case a: return #a - switch (var) { - X(uninitialized); - X(initialized); - X(part_constant); - X(constant); - default: return "BAD VALUE"; - } +/* Return the name of the alignment. */ +const char *get_align_name(ir_align a) +{ +#define X(a) case a: return #a + switch (a) { + X(align_non_aligned); + X(align_is_aligned); + default: return "BAD VALUE"; + } #undef X } -INLINE ent_volatility -get_entity_volatility (entity *ent) { - assert (ent); - return ent->volatility; +void set_entity_label(ir_entity *ent, ir_label_t label) +{ + ent->attr.code_attr.label = label; } -INLINE void -set_entity_volatility (entity *ent, ent_volatility vol) { - assert (ent); - ent->volatility = vol; +ir_label_t get_entity_label(const ir_entity *ent) +{ + return ent->attr.code_attr.label; } -/* return the name of the volatility */ -const char *get_volatility_name(ent_volatility var) +static void verify_visibility(const ir_entity *entity) { -#define X(a) case a: return #a - switch (var) { - X(non_volatile); - X(is_volatile); - default: return "BAD VALUE"; - } -#undef X + if (get_entity_visibility(entity) == ir_visibility_external + && !is_method_entity(entity)) { + assert(!entity_has_definition(entity)); + } +} + +void set_entity_visibility(ir_entity *entity, ir_visibility visibility) +{ + entity->visibility = visibility; + verify_visibility(entity); +} + +ir_visibility get_entity_visibility(const ir_entity *entity) +{ + return (ir_visibility)entity->visibility; +} + +void set_entity_linkage(ir_entity *entity, ir_linkage linkage) +{ + entity->linkage = linkage; +} + +ir_linkage (get_entity_linkage)(const ir_entity *entity) +{ + return get_entity_linkage(entity); +} + +void add_entity_linkage(ir_entity *entity, ir_linkage linkage) +{ + entity->linkage |= linkage; +} + +void remove_entity_linkage(ir_entity *entity, ir_linkage linkage) +{ + entity->linkage &= ~linkage; +} + +/* Checks if an entity is compiler generated */ +int (is_entity_compiler_generated)(const ir_entity *ent) +{ + return _is_entity_compiler_generated(ent); +} + +/* Sets/resets the compiler generated flag */ +void (set_entity_compiler_generated)(ir_entity *ent, int flag) +{ + _set_entity_compiler_generated(ent, flag); } -INLINE peculiarity -get_entity_peculiarity (entity *ent) { - assert (ent); - return ent->peculiarity; +ir_entity_usage (get_entity_usage)(const ir_entity *ent) +{ + return _get_entity_usage(ent); } -INLINE void -set_entity_peculiarity (entity *ent, peculiarity pec) { - assert (ent); - /* @@@ why peculiarity only for methods? */ - assert (is_method_type(ent->type)); - ent->peculiarity = pec; +void (set_entity_usage)(ir_entity *ent, ir_entity_usage flags) +{ + _set_entity_usage(ent, flags); +} + +/* Set has no effect for existent entities of type method. */ +ir_node *get_atomic_ent_value(ir_entity *entity) +{ + ir_initializer_t *initializer = get_entity_initializer(entity); + + assert(entity && is_atomic_entity(entity)); + if (initializer == NULL) { + ir_type *type = get_entity_type(entity); + return new_r_Unknown(get_const_code_irg(), get_type_mode(type)); + } + + switch (get_initializer_kind(initializer)) { + case IR_INITIALIZER_NULL: { + ir_type *type = get_entity_type(entity); + ir_mode *mode = get_type_mode(type); + return new_r_Const(get_const_code_irg(), get_mode_null(mode)); + } + case IR_INITIALIZER_TARVAL: { + ir_tarval *tv = get_initializer_tarval_value(initializer); + return new_r_Const(get_const_code_irg(), tv); + } + case IR_INITIALIZER_CONST: + return get_initializer_const_value(initializer); + case IR_INITIALIZER_COMPOUND: + panic("compound initializer in atomic entity not allowed (%+F)", entity); + } + + panic("invalid initializer kind in get_atomic_ent_value(%+F)", entity); +} + +void set_atomic_ent_value(ir_entity *entity, ir_node *val) +{ + ir_initializer_t *initializer; + + assert(is_atomic_entity(entity)); + + assert(is_Dummy(val) || get_irn_mode(val) == get_type_mode(entity->type)); + initializer = create_initializer_const(val); + entity->initializer = initializer; } -/* return the name of the peculiarity */ -const char *get_peculiarity_name(peculiarity var) +/* Returns true if the the node is representable as code on + * const_code_irg. */ +int is_irn_const_expression(ir_node *n) { -#define X(a) case a: return #a - switch (var) { - X(description); - X(inherited); - X(existent); + 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 1; + case iro_Conv: + case iro_Cast: + return is_irn_const_expression(get_irn_n(n, 0)); + default: + break; + } + return 0; +} + +/* + * Copies a firm subgraph that complies to the restrictions for + * constant expressions to block. + */ +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; + + /* @@@ 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)) { + case iro_Const: + nn = new_rd_Const(dbg, irg, get_Const_tarval(n)); + break; + case iro_SymConst: + nn = new_rd_SymConst(dbg, irg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n)); + break; + case iro_Add: + 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_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_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_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_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_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_rd_Cast(dbg, block, + copy_const_value(dbg, get_Cast_op(n), block), + get_Cast_type(n)); + break; + case iro_Conv: + nn = new_rd_Conv(dbg, block, + copy_const_value(dbg, get_Conv_op(n), block), m); + break; + case iro_Unknown: + nn = new_r_Unknown(irg, m); break; + default: + panic("opcode invalid or not implemented"); + } + return nn; +} + +/** Return the name of the initializer kind. */ +const char *get_initializer_kind_name(ir_initializer_kind_t ini) +{ +#define X(a) case a: return #a + switch (ini) { + X(IR_INITIALIZER_CONST); + X(IR_INITIALIZER_TARVAL); + X(IR_INITIALIZER_NULL); + X(IR_INITIALIZER_COMPOUND); default: return "BAD VALUE"; - } + } #undef X } -/* Set has no effect for existent entities of type method. */ -INLINE ir_node * -get_atomic_ent_value(entity *ent) { - assert(ent); assert(is_atomic_entity(ent)); - assert((ent->variability != uninitialized)); - return ent->value; -} - -INLINE void -set_atomic_ent_value(entity *ent, ir_node *val) { - assert(ent && is_atomic_entity(ent) && (ent->variability != uninitialized)); - if ((is_method_type(ent->type)) && (ent->peculiarity==existent)) return; - ent->value = val; -} - - -ir_node *copy_const_value(ir_node *n) { - ir_node *nn; - ir_mode *m; - - m = get_irn_mode(n); - switch(get_irn_opcode(n)) { - case iro_Const: - nn = new_Const(m, get_Const_tarval(n)); break; - case iro_SymConst: - nn = new_SymConst(get_SymConst_type_or_id(n), get_SymConst_kind(n)); break; - case iro_Add: - nn = new_Add(copy_const_value(get_Add_left(n)), copy_const_value(get_Add_right(n)), m); break; - case iro_Unknown: - nn = new_Unknown(); break; - default: - DDMN(n); - assert(0 && "opdope invalid or not implemented"); - nn = NULL; - break; - } - return nn; -} - -compound_graph_path * -new_compound_graph_path(type *tp, int length) { - compound_graph_path *res; - assert(is_type(tp) && is_compound_type(tp)); - assert(length > 0); - - res = (compound_graph_path *) malloc (sizeof(compound_graph_path) + (length-1) * sizeof(entity *)); - res->kind = k_ir_compound_graph_path; - res->tp = tp; - res->len = length; - memset(res->nodes, 0, sizeof(entity *) * length); - return res; -} - -INLINE void -free_compound_graph_path (compound_graph_path *gr) { - assert(gr && is_compound_graph_path(gr)); - free(gr); -} - -INLINE int -is_compound_graph_path(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 */ -INLINE int is_proper_compound_graph_path(compound_graph_path *gr, int pos) { - int i; - entity *node; - 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; - owner = get_entity_type(node); - } - if (pos == get_compound_graph_path_length(gr) -1) - if (!is_atomic_type(owner)) return false; - return true; -} - -INLINE int -get_compound_graph_path_length(compound_graph_path *gr) { - assert(gr && is_compound_graph_path(gr)); - return gr->len; -} - -INLINE entity * -get_compound_graph_path_node(compound_graph_path *gr, int pos) { - assert(gr && is_compound_graph_path(gr)); - assert(pos >= 0 && pos < gr->len); - return gr->nodes[pos]; -} - -INLINE void -set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) { - assert(gr && is_compound_graph_path(gr)); - assert(pos >= 0 && pos < gr->len); - assert(is_entity(node)); - gr->nodes[pos] = node; - assert(is_proper_compound_graph_path(gr, pos)); -} - -/* A value of a compound entity is a pair of value and the corresponding path to a member of - the compound. */ -INLINE void -add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - ARR_APP1 (ir_node *, ent->values, val); - ARR_APP1 (compound_graph_path *, ent->val_paths, path); -} - -INLINE void -set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - ent->values[pos+1] = val; - ent->val_paths[pos+1] = path; -} - -INLINE int -get_compound_ent_n_values(entity *ent) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - return (ARR_LEN (ent->values))-1; -} - -INLINE ir_node * -get_compound_ent_value(entity *ent, int pos) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - return ent->values[pos+1]; -} - -INLINE compound_graph_path * -get_compound_ent_value_path(entity *ent, int pos) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - return ent->val_paths[pos+1]; -} - -void -remove_compound_ent_value(entity *ent, entity *value_ent) { - int i; - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - for (i = 1; 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]; - } - ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1); - ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1); - break; - } - } -} - -INLINE void -add_compound_ent_value(entity *ent, ir_node *val, entity *member) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - compound_graph_path *path = new_compound_graph_path(get_entity_owner(ent), 1); - path->nodes[0] = member; - add_compound_ent_value_w_path(ent, val, path); -} - -/* Copies the firm subgraph referenced by val to const_code_irg and adds - the node as constant initialization to ent. - The subgraph may not contain control flow operations. -INLINE void -copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) { - ir_graph *rem = current_ir_graph; - - assert(get_entity_variability(ent) != uninitialized); - current_ir_graph = get_const_code_irg(); - - val = copy_const_value(val); - add_compound_ent_value(ent, val, member); - current_ir_graph = rem; - }*/ - -/* Copies the value i of the entity to current_block in current_ir_graph. -ir_node * -copy_compound_ent_value(entity *ent, int pos) { - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - return copy_const_value(ent->values[pos+1]); - }*/ - -INLINE entity * -get_compound_ent_value_member(entity *ent, int pos) { - compound_graph_path *path; - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - path = get_compound_ent_value_path(ent, pos); - assert(path->len == 1); - - return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1); -} - -INLINE void -set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) { - compound_graph_path *path; - assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized)); - path = get_compound_ent_value_path(ent, pos); - set_compound_graph_path_node(path, 0, member); - set_compound_ent_value_w_path(ent, val, path, pos); -} - -void -set_array_entity_values(entity *ent, tarval **values, int num_vals) { - int i; - ir_graph *rem = current_ir_graph; - type *arrtp = get_entity_type(ent); - ir_node *val; - - assert(is_array_type(arrtp)); - assert(get_array_n_dimensions(arrtp) == 1); - /* One bound is sufficient, the nunmber of constant fields makes the - size. */ - assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0)); - assert(get_entity_variability(ent) != 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]); - add_compound_ent_value(ent, val, get_array_element_entity(arrtp)); - } - current_ir_graph = rem; -} - -INLINE int -get_entity_offset (entity *ent) { - return ent->offset; -} - -INLINE void -set_entity_offset (entity *ent, int offset) { - ent->offset = offset; -} - -INLINE void -add_entity_overwrites (entity *ent, entity *overwritten) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - ARR_APP1 (entity *, ent->overwrites, overwritten); - ARR_APP1 (entity *, overwritten->overwrittenby, ent); -} - -INLINE int -get_entity_n_overwrites (entity *ent) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - return (ARR_LEN (ent->overwrites))-1; -} - -int -get_entity_overwrites_index(entity *ent, entity *overwritten) { - int i; - assert(ent && 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; -} - -INLINE entity * -get_entity_overwrites (entity *ent, int pos) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - assert(pos < get_entity_n_overwrites(ent)); - return ent->overwrites[pos+1]; -} - -INLINE void -set_entity_overwrites (entity *ent, int pos, entity *overwritten) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - assert(pos < get_entity_n_overwrites(ent)); - ent->overwrites[pos+1] = overwritten; -} - -void -remove_entity_overwrites(entity *ent, entity *overwritten) { - int i; - assert(ent && is_class_type(get_entity_owner(ent))); - for (i = 1; 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); - break; - } -} - -INLINE void -add_entity_overwrittenby (entity *ent, entity *overwrites) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - add_entity_overwrites(overwrites, ent); -} - -INLINE int -get_entity_n_overwrittenby (entity *ent) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - return (ARR_LEN (ent->overwrittenby))-1; +static ir_initializer_t null_initializer = { IR_INITIALIZER_NULL }; + +ir_initializer_t *get_initializer_null(void) +{ + return &null_initializer; +} + +ir_initializer_t *create_initializer_const(ir_node *value) +{ + struct obstack *obst = get_irg_obstack(get_const_code_irg()); + + ir_initializer_t *initializer + = (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(ir_tarval *tv) +{ + struct obstack *obst = get_irg_obstack(get_const_code_irg()); + + ir_initializer_t *initializer + = (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(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 * sizeof(ir_initializer_t*) + - sizeof(ir_initializer_t*); + + ir_initializer_t *initializer + = (ir_initializer_t*)obstack_alloc(obst, size); + initializer->kind = IR_INITIALIZER_COMPOUND; + initializer->compound.n_initializers = n_entries; + + for (i = 0; i < n_entries; ++i) { + initializer->compound.initializers[i] = get_initializer_null(); + } + + return initializer; +} + +ir_node *get_initializer_const_value(const ir_initializer_t *initializer) +{ + assert(initializer->kind == IR_INITIALIZER_CONST); + return skip_Id(initializer->consti.value); +} + +ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer) +{ + assert(initializer->kind == IR_INITIALIZER_TARVAL); + return initializer->tarval.value; +} + +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, + size_t index, ir_initializer_t *value) +{ + assert(initializer->kind == IR_INITIALIZER_COMPOUND); + assert(index < initializer->compound.n_initializers); + + initializer->compound.initializers[index] = value; +} + +ir_initializer_t *get_initializer_compound_value( + const ir_initializer_t *initializer, size_t index) +{ + assert(initializer->kind == IR_INITIALIZER_COMPOUND); + assert(index < initializer->compound.n_initializers); + + return initializer->compound.initializers[index]; +} + +ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer) +{ + return initializer->kind; +} + +static void check_entity_initializer(ir_entity *entity) +{ +#ifndef NDEBUG + ir_initializer_t *initializer = entity->initializer; + ir_type *entity_tp = get_entity_type(entity); + switch (initializer->kind) { + case IR_INITIALIZER_COMPOUND: + assert(is_compound_type(entity_tp) || is_Array_type(entity_tp)); + break; + case IR_INITIALIZER_CONST: + /* methods are initialized by a SymConst */ + assert(is_atomic_type(entity_tp) || is_Method_type(entity_tp)); + break; + case IR_INITIALIZER_TARVAL: + assert(is_atomic_type(entity_tp)); + break; + case IR_INITIALIZER_NULL: + break; + } +#endif +} + +void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer) +{ + entity->initializer = initializer; + check_entity_initializer(entity); +} + +int has_entity_initializer(const ir_entity *entity) +{ + return entity->initializer != NULL; +} + +ir_initializer_t *get_entity_initializer(const ir_entity *entity) +{ + return entity->initializer; +} + +int (get_entity_offset)(const ir_entity *ent) +{ + return _get_entity_offset(ent); +} + +void (set_entity_offset)(ir_entity *ent, int offset) +{ + _set_entity_offset(ent, offset); +} + +unsigned char (get_entity_offset_bits_remainder)(const ir_entity *ent) +{ + return _get_entity_offset_bits_remainder(ent); +} + +void (set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset) +{ + _set_entity_offset_bits_remainder(ent, offset); +} + +void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten) +{ + if (ent->overwrites == NULL) { + ent->overwrites = NEW_ARR_F(ir_entity*, 0); + } + ARR_APP1(ir_entity *, ent->overwrites, overwritten); + if (overwritten->overwrittenby == NULL) { + overwritten->overwrittenby = NEW_ARR_F(ir_entity*, 0); + } + ARR_APP1(ir_entity *, overwritten->overwrittenby, ent); +} + +size_t get_entity_n_overwrites(const ir_entity *ent) +{ + if (ent->overwrites == NULL) + return 0; + return ARR_LEN(ent->overwrites); +} + +size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten) +{ + 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 (size_t)-1; +} + +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, size_t pos, ir_entity *overwritten) +{ + assert(pos < get_entity_n_overwrites(ent)); + ent->overwrites[pos] = overwritten; +} + +void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten) +{ + 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++) + ent->overwrites[i] = ent->overwrites[i+1]; + ARR_SETLEN(ir_entity*, ent->overwrites, n - 1); + break; + } + } +} + + +size_t get_entity_n_overwrittenby(const ir_entity *ent) +{ + if (ent->overwrittenby == NULL) + return 0; + return ARR_LEN(ent->overwrittenby); +} + +size_t get_entity_overwrittenby_index(const ir_entity *ent, + ir_entity *overwrites) +{ + 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 (size_t)-1; +} + +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, size_t pos, ir_entity *overwrites) +{ + assert(pos < get_entity_n_overwrittenby(ent)); + ent->overwrittenby[pos] = overwrites; +} + +void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites) +{ + 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) + ent->overwrittenby[i] = ent->overwrittenby[i+1]; + ARR_SETLEN(ir_entity*, ent->overwrittenby, n - 1); + break; + } + } +} + +void *(get_entity_link)(const ir_entity *ent) +{ + return _get_entity_link(ent); +} + +void (set_entity_link)(ir_entity *ent, void *l) +{ + _set_entity_link(ent, l); } -int -get_entity_overwrittenby_index(entity *ent, entity *overwrites) { - int i; - assert(ent && 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; +ir_graph *(get_entity_irg)(const ir_entity *ent) +{ + return _get_entity_irg(ent); } -INLINE entity * -get_entity_overwrittenby (entity *ent, int pos) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - assert(pos < get_entity_n_overwrittenby(ent)); - return ent->overwrittenby[pos+1]; +void set_entity_irg(ir_entity *ent, ir_graph *irg) +{ + assert(is_method_entity(ent)); + assert(get_entity_peculiarity(ent) == peculiarity_existent); + ent->attr.mtd_attr.irg = irg; } -INLINE void -set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) { - assert(ent); - assert(is_class_type(get_entity_owner(ent))); - assert(pos < get_entity_n_overwrittenby(ent)); - ent->overwrittenby[pos+1] = overwrites; +unsigned get_entity_vtable_number(const ir_entity *ent) +{ + assert(is_method_entity((ir_entity *)ent)); + return ent->attr.mtd_attr.vtable_number; } -void remove_entity_overwrittenby(entity *ent, entity *overwrites) { - int i; - assert(ent && is_class_type(get_entity_owner(ent))); - for (i = 1; 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); - break; - } +void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number) +{ + assert(is_method_entity(ent)); + ent->attr.mtd_attr.vtable_number = vtable_number; } -/* A link to store intermediate information */ -void * -get_entity_link(entity *ent) { - assert(ent); - return ent->link; +int (is_entity)(const void *thing) +{ + return _is_entity(thing); } -void -set_entity_link(entity *ent, void *l) { - assert(ent); - ent->link = l; +int is_atomic_entity(const 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); } -INLINE ir_graph * -get_entity_irg(entity *ent) { - assert (ent); - assert (is_method_type(ent->type)); - return ent->irg; +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); } -INLINE void -set_entity_irg(entity *ent, ir_graph *irg) { - assert (ent && ent->type); - /* 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. */ - /* assert (irg); */ - assert (is_method_type(ent->type)); - assert (ent->peculiarity == existent); - ent->irg = irg; +int is_method_entity(const ir_entity *ent) +{ + ir_type *t = get_entity_type(ent); + return is_Method_type(t); } -int is_entity (void *thing) { - assert(thing); - if (get_kind(thing) == k_entity) - return 1; - else - return 0; +ir_visited_t (get_entity_visited)(const ir_entity *ent) +{ + return _get_entity_visited(ent); +} + +void (set_entity_visited)(ir_entity *ent, ir_visited_t num) +{ + _set_entity_visited(ent, num); } -int is_atomic_entity(entity *ent) { - type* t = get_entity_type(ent); - return (is_primitive_type(t) || is_pointer_type(t) || - is_enumeration_type(t) || is_method_type(t)); +void (mark_entity_visited)(ir_entity *ent) +{ + _mark_entity_visited(ent); } -int is_compound_entity(entity *ent) { - type* t = get_entity_type(ent); - return (is_class_type(t) || is_struct_type(t) || - is_array_type(t) || is_union_type(t)); +int (entity_visited)(const ir_entity *ent) +{ + return _entity_visited(ent); } -/* @@@ not implemnted!!! */ -bool equal_entity(entity *ent1, entity *ent2) { - printf(" calling unimplemented equal entity!!! \n"); - return true; +int (entity_not_visited)(const ir_entity *ent) +{ + return _entity_not_visited(ent); } +mtp_additional_properties get_entity_additional_properties(const ir_entity *ent) +{ + ir_graph *irg; + + assert(is_method_entity(ent)); + + /* first check, if the graph has additional properties */ + irg = get_entity_irg(ent); + + if (irg) + return get_irg_additional_properties(irg); -unsigned long get_entity_visited(entity *ent) { - assert (ent); - return ent->visit; + 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; } -void set_entity_visited(entity *ent, unsigned long num) { - assert (ent); - ent->visit = num; + +void set_entity_additional_properties(ir_entity *ent, mtp_additional_properties property_mask) +{ + ir_graph *irg; + + assert(is_method_entity(ent)); + + /* first check, if the graph exists */ + irg = get_entity_irg(ent); + if (irg) + set_irg_additional_properties(irg, property_mask); + else { + /* do not allow to set the mtp_property_inherited flag or + * the automatic inheritance of flags will not work */ + ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited; + } } -/* Sets visited field in entity to entity_visited. */ -void mark_entity_visited(entity *ent) { - assert (ent); - ent->visit = type_visited; + +void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties properties) +{ + ir_graph *irg; + + assert(is_method_entity(ent)); + + /* first check, if the graph exists */ + irg = get_entity_irg(ent); + if (irg) + add_irg_additional_properties(irg, properties); + else { + 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 | (properties & ~mtp_property_inherited); + } } +/* 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); +} -INLINE bool entity_visited(entity *ent) { - return get_entity_visited(ent) >= type_visited; +dbg_info *(get_entity_dbg_info)(const ir_entity *ent) +{ + return _get_entity_dbg_info(ent); } -INLINE bool entity_not_visited(entity *ent) { - return get_entity_visited(ent) < type_visited; + +void (set_entity_dbg_info)(ir_entity *ent, dbg_info *db) +{ + _set_entity_dbg_info(ent, db); +} + +int entity_is_externally_visible(const ir_entity *entity) +{ + return get_entity_visibility(entity) != ir_visibility_local + || (get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER); +} + +int entity_has_definition(const ir_entity *entity) +{ + return entity->initializer != NULL + || get_entity_irg(entity) != NULL + || entity_has_compound_ent_values(entity); +} + +void ir_init_entity(void) +{ + assert(firm_unknown_type && "Call init_type() before firm_init_entity()!"); + assert(!unknown_entity && "Call firm_init_entity() only once!"); + + unknown_entity = new_d_entity(NULL, new_id_from_str(UNKNOWN_ENTITY_NAME), + firm_unknown_type, NULL); + set_entity_visibility(unknown_entity, ir_visibility_external); + set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity)); +} + +void ir_finish_entity(void) +{ + if (unknown_entity != NULL) { + free_entity(unknown_entity); + unknown_entity = NULL; + } +} + +ir_allocation get_entity_allocation(const ir_entity *entity) +{ + return (ir_allocation)entity->allocation; +} + +void set_entity_allocation(ir_entity *entity, ir_allocation allocation) +{ + entity->allocation = allocation; +} + +ir_peculiarity get_entity_peculiarity(const ir_entity *entity) +{ + return (ir_peculiarity)entity->peculiarity; +} + +void set_entity_peculiarity(ir_entity *entity, ir_peculiarity peculiarity) +{ + entity->peculiarity = peculiarity; +} + +void set_entity_final(ir_entity *entity, int final) +{ + entity->final = final; +} + +int is_entity_final(const ir_entity *entity) +{ + return entity->final; }