From 3ed0b9b7d1ea19292cf4ad084f542c37b526268e Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Wed, 20 Sep 2006 15:18:38 +0000 Subject: [PATCH] get_entity_repr_class() added, needed to get a class from a type info entity mtp_property_runtime added [r8283] --- ir/tr/entity.c | 50 +++++++++++++++++++++++------------------------- ir/tr/entity.h | 37 ++++++++++++++++++----------------- ir/tr/entity_t.h | 25 ++++++++++++++++-------- ir/tr/type.c | 27 ++++++++++++++------------ ir/tr/type.h | 1 + 5 files changed, 76 insertions(+), 64 deletions(-) diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 82cad4e00..9bd997b11 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -116,6 +116,7 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type) res->compiler_gen = 0; res->offset = -1; res->link = NULL; + res->repr_class = NULL; if (is_Method_type(type)) { symconst_symbol sym; @@ -163,20 +164,20 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type) } entity * -new_d_entity (ir_type *owner, ident *name, ir_type *type, dbg_info *db) { +new_d_entity(ir_type *owner, ident *name, ir_type *type, dbg_info *db) { entity *res; - assert_legal_owner_of_ent(owner); + assert(is_compound_type(owner)); res = new_rd_entity(db, owner, name, type); /* Remember entity in it's owner. */ - insert_entity_in_owner (res); + insert_entity_in_owner(res); hook_new_entity(res); return res; } entity * -new_entity (ir_type *owner, ident *name, ir_type *type) { +new_entity(ir_type *owner, ident *name, ir_type *type) { return new_d_entity(owner, name, type, NULL); } @@ -220,14 +221,14 @@ static void free_entity_attrs(entity *ent) { } entity * -copy_entity_own (entity *old, ir_type *new_owner) { +copy_entity_own(entity *old, ir_type *new_owner) { entity *newe; - assert(old && old->kind == k_entity); - assert_legal_owner_of_ent(new_owner); + assert(is_entity(old)); + assert(is_compound_type(new_owner)); if (old->owner == new_owner) return old; newe = xmalloc(sizeof(*newe)); - memcpy (newe, old, sizeof(*newe)); + memcpy(newe, old, sizeof(*newe)); newe->owner = new_owner; if (is_Class_type(new_owner)) { newe->overwrites = NEW_ARR_F(entity *, 0); @@ -237,13 +238,13 @@ copy_entity_own (entity *old, ir_type *new_owner) { newe->nr = get_irp_new_node_nr(); #endif - insert_entity_in_owner (newe); + insert_entity_in_owner(newe); return newe; } entity * -copy_entity_name (entity *old, ident *new_name) { +copy_entity_name(entity *old, ident *new_name) { entity *newe; assert(old && old->kind == k_entity); @@ -306,21 +307,12 @@ ir_type * } void -set_entity_owner (entity *ent, ir_type *owner) { - assert(ent && ent->kind == k_entity); - assert_legal_owner_of_ent(owner); +set_entity_owner(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(ir_type *owner) { - assert(get_type_tpop_code(owner) == tpo_class || - get_type_tpop_code(owner) == tpo_union || - get_type_tpop_code(owner) == tpo_struct || - 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); @@ -1311,15 +1303,15 @@ int } int is_atomic_entity(entity *ent) { - ir_type *t = get_entity_type(ent); - tp_op *op = get_type_tpop(t); + 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) { - ir_type *t = get_entity_type(ent); - tp_op *op = get_type_tpop(t); + 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); } @@ -1417,6 +1409,12 @@ void set_entity_additional_property(entity *ent, mtp_additional_property flag) } } +/* 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 entity *ent) { + return _get_entity_repr_class(ent); +} + /* Initialize entity module. */ void firm_init_entity(void) { diff --git a/ir/tr/entity.h b/ir/tr/entity.h index ce255acc8..25de511c4 100644 --- a/ir/tr/entity.h +++ b/ir/tr/entity.h @@ -127,7 +127,7 @@ typedef struct entity entity; * value is a pointer to the method. * Visibility is local, offset -1, and it is not volatile. */ -entity *new_entity (ir_type *owner, ident *name, ir_type *tp); +entity *new_entity(ir_type *owner, ident *name, ir_type *tp); /** * Creates a new entity. @@ -138,7 +138,7 @@ entity *new_entity (ir_type *owner, ident *name, ir_type *tp); * value is a pointer to the method. * Visibility is local, offset -1, and it is not volatile. */ -entity *new_d_entity (ir_type *owner, ident *name, ir_type *tp, dbg_info *db); +entity *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db); /** * Copies the entity if the new_owner is different from the @@ -152,7 +152,7 @@ entity *new_d_entity (ir_type *owner, ident *name, ir_type *tp, dbg_info *db * itself and not to the origin. Right now we have to change * the peculiarity and then set a new atomic value by hand. */ -entity *copy_entity_own (entity *old, ir_type *new_owner); +entity *copy_entity_own(entity *old, ir_type *new_owner); /** * Copies the entity if the new_name is different from the @@ -162,7 +162,7 @@ entity *copy_entity_own (entity *old, ir_type *new_owner); * The mangled name ld_name is set to NULL. * Overwrites relation is copied from old. */ -entity *copy_entity_name (entity *old, ident *new_name); +entity *copy_entity_name(entity *old, ident *new_name); /** * Frees the entity. @@ -170,16 +170,16 @@ entity *copy_entity_name (entity *old, ident *new_name); * The owner will still contain the pointer to this * entity, as well as all other references! */ -void free_entity (entity *ent); +void free_entity(entity *ent); /** Returns the name of an entity. */ -const char *get_entity_name (const entity *ent); +const char *get_entity_name(const entity *ent); /** Returns the ident of an entity. */ -ident *get_entity_ident (const entity *ent); +ident *get_entity_ident(const entity *ent); /** Sets the ident of the entity. */ -void set_entity_ident (entity *ent, ident *id); +void set_entity_ident(entity *ent, ident *id); /** Returns the mangled name of the entity. * @@ -187,29 +187,26 @@ void set_entity_ident (entity *ent, ident *id); * Else it generates a name with mangle_entity() * and remembers this new name internally. */ -ident *get_entity_ld_ident (entity *ent); +ident *get_entity_ld_ident(entity *ent); /** Sets the mangled name of the entity. */ -void set_entity_ld_ident (entity *ent, ident *ld_ident); +void set_entity_ld_ident(entity *ent, ident *ld_ident); /** Returns the mangled name of the entity as a string. */ -const char *get_entity_ld_name (entity *ent); +const char *get_entity_ld_name(entity *ent); /** Returns the owner of the entity. */ -ir_type *get_entity_owner (entity *ent); +ir_type *get_entity_owner(entity *ent); /** Sets the owner field in entity to owner. Don't forget to add ent to owner!! */ -void set_entity_owner (entity *ent, ir_type *owner); - -/** Asserts if the type owner is either a compound type or an array */ -void assert_legal_owner_of_ent(ir_type *owner); +void set_entity_owner(entity *ent, ir_type *owner); /** Returns the type of an entity. */ -ir_type *get_entity_type (entity *ent); +ir_type *get_entity_type(entity *ent); /** Sets the type of an entity. */ -void set_entity_type (entity *ent, ir_type *tp); +void set_entity_type(entity *ent, ir_type *tp); /** The allocation type. */ typedef enum { @@ -564,6 +561,10 @@ void set_entity_additional_properties(entity *ent, unsigned property_mask); /** Sets one additional graph property. */ void set_entity_additional_property(entity *ent, mtp_additional_property flag); +/** 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 entity *ent); + /** * @page unknown_entity * diff --git a/ir/tr/entity_t.h b/ir/tr/entity_t.h index 7b83653e5..86a65b7d0 100644 --- a/ir/tr/entity_t.h +++ b/ir/tr/entity_t.h @@ -3,10 +3,10 @@ * File name: ir/tr/entity_t.h * Purpose: Representation of all program known entities -- private header. * 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. */ @@ -59,13 +59,13 @@ struct compound_graph_path { access path. */ }; -/** attributes for atomic entities */ +/** The attributes for atomic entities. */ typedef struct atomic_ent_attr { ir_node *value; /**< value if entity is not of variability uninitialized. Only for atomic entities. */ } atomic_ent_attr; -/** attributes for compound entities */ +/** The attributes for compound entities. */ typedef struct compound_ent_attr { ir_node **values; /**< constant values of compound entities. Only available if variability not uninitialized. Must be set for variability constant. */ @@ -73,10 +73,10 @@ typedef struct compound_ent_attr { variability not uninitialized. Must be set for variability constant. */ } compound_ent_attr; -/** a reserved value for "not yet set" */ +/** A reserved value for "not yet set". */ #define VTABLE_NUM_NOT_SET ((unsigned)(-1)) -/** attributes for methods */ +/** The attributes for methods. */ typedef struct method_ent_attr { ir_graph *irg; /**< The corresponding irg if known. The ir_graph constructor automatically sets this field. */ @@ -93,7 +93,7 @@ typedef struct method_ent_attr { } method_ent_attr; -/** the type of an entity */ +/** The type of an entity. */ struct entity { firm_kind kind; /**< The dynamic type tag for entity. */ ident *name; /**< The name of this entity. */ @@ -120,6 +120,7 @@ struct entity { unsigned long visit; /**< visited counter for walks of the type information. */ struct dbg_info *dbi; /**< A pointer to information for debug support. */ void *link; /**< To store some intermediate information. */ + ir_type *repr_class; /**< If this entity represents a class info, the associated class. */ /* ------------- fields for entities owned by a class type ---------------*/ @@ -144,7 +145,7 @@ struct entity { # endif /* DEBUG_libfirm */ }; -/** Initialize entity module. */ +/** Initialize the entity module. */ void firm_init_entity(void); @@ -357,6 +358,12 @@ _entity_not_visited(entity *ent) { return _get_entity_visited(ent) < firm_type_visited; } +static INLINE ir_type * +_get_entity_repr_class(const entity *ent) { + assert(ent && ent->kind == k_entity); + return ent->repr_class; +} + #define is_entity(thing) _is_entity(thing) #define get_entity_name(ent) _get_entity_name(ent) #define get_entity_ident(ent) _get_entity_ident(ent) @@ -389,5 +396,7 @@ _entity_not_visited(entity *ent) { #define mark_entity_visited(ent) _mark_entity_visited(ent) #define entity_visited(ent) _entity_visited(ent) #define entity_not_visited(ent) _entity_not_visited(ent) +#define get_entity_repr_class(ent) _get_entity_repr_class(ent) + #endif /* _FIRM_TR_ENTITY_T_H_ */ diff --git a/ir/tr/type.c b/ir/tr/type.c index 3eaedfa96..80f2dda57 100644 --- a/ir/tr/type.c +++ b/ir/tr/type.c @@ -55,21 +55,22 @@ # include #endif -# include +#include -# include "type_t.h" +#include "type_t.h" -# include "xmalloc.h" -# include "irprog_t.h" -# include "ircons.h" -# include "tpop_t.h" -# include "typegmod.h" -# include "mangle.h" -# include "tv_t.h" -# include "irhooks.h" -# include "irtools.h" +#include "xmalloc.h" +#include "irprog_t.h" +#include "ircons.h" +#include "tpop_t.h" +#include "typegmod.h" +#include "mangle.h" +#include "tv_t.h" +#include "irhooks.h" +#include "irtools.h" +#include "entity_t.h" -# include "array.h" +#include "array.h" /*-----------------------------------------------------------------*/ /** TYPE **/ @@ -953,6 +954,8 @@ entity *get_class_type_info(const ir_type *clss) { } void set_class_type_info(ir_type *clss, entity *ent) { clss->attr.ca.type_info = ent; + if (ent) + ent->repr_class = clss; } const char *get_peculiarity_name(ir_peculiarity p) { diff --git a/ir/tr/type.h b/ir/tr/type.h index 2e573ea52..9072454b2 100644 --- a/ir/tr/type.h +++ b/ir/tr/type.h @@ -857,6 +857,7 @@ typedef enum { GCC: __attribute__((malloc)). */ mtp_property_intrinsic = 0x00000040, /**< This method is intrinsic. It is expected that a lowering phase will remove all calls to it. */ + mtp_property_runtime = 0x00000080, /**< This method represents a runtime routine. */ mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is inherited from type. */ } mtp_additional_property; -- 2.20.1