# include "ident.h"
# include "type.h"
+# include "dbginfo.h"
/*******************************************************************/
/** general **/
/** ENTITY **/
/*******************************************************************/
+/* to resolve recursion between entity.h and irgraph.h */
#ifndef _IR_GRAPH_TYPEDEF_
#define _IR_GRAPH_TYPEDEF_
-/* to resolve recursion between entity.h and irgraph.h */
typedef struct ir_graph ir_graph;
#endif
* In that case there nowhere exists code for this entity and this entity
* is never dynamically used in the code.
* Values: description, existent. Default: existent.
+ * visited visited flag. Master flag is type_visited.
*
* These fields can only be accessed via access functions.
*
* SOURCE
*/
+/* to resolve recursion between entity.h and type.h */
#ifndef _ENTITY_TYPEDEF_
#define _ENTITY_TYPEDEF_
-/* to resolve recursion between entity.h and type.h */
typedef struct entity entity;
#endif
+
/* Creates a new entity.
Automatically inserts the entity as a member of owner.
Entity is automatic_allocated and uninitialize except if the type
is type_method, then it is static_allocated and constant. The constant
value is a pointer to the method.
Visibility is local, offset -1, and it is not volatile. */
-entity *new_entity (type *owner, ident *name, type *type);
+entity *new_entity (type *owner, ident *name, type *tp);
+entity *new_d_entity (type *owner, ident *name, type *tp, dbg_info *db);
/* Copies the entity if the new_owner is different from the
owner of the old entity. Else returns the old entity.
Automatically inserts the new entity as a member of owner. */
Automatically inserts the new entity as a member of owner.
The mangled name ld_name is set to NULL. */
entity *copy_entity_name (entity *old, ident *new_name);
+/* Frees the entity. The owner will still contain the pointer to this
+ entity, as well as all other references! */
+void free_entity (entity *ent);
/** manipulate fields of entity **/
const char *get_entity_name (entity *ent);
const char *get_entity_ld_name (entity *end);
type *get_entity_owner (entity *ent);
-/* Sets the owner field in entity to owner. */
+/* Sets the owner field in entity to owner. Don't forget to add
+ ent to owner!! */
void set_entity_owner (entity *ent, type *owner);
INLINE void assert_legal_owner_of_ent(type *owner);
type *get_entity_type (entity *ent);
-void set_entity_type (entity *ent, type *type);
+void set_entity_type (entity *ent, type *tp);
typedef enum {
- automatic_allocated,/* The entity is allocated during runtime, implicitly
- as component of a compound type. This is the default. */
- dynamic_allocated, /* The entity is allocated during runtime, explicitly
- by an Alloc node. */
- static_allocated /* The entity is allocated statically. We can use a
- SymConst(?) as address of the entity. */
+ automatic_allocated, /* The entity is allocated during runtime, implicitly
+ as component of a compound type. This is the default. */
+ parameter_allocated, /* The entity is a parameter. It is also automatic allocated.
+ We distinguish the allocation of paramters from the allocation
+ of local variables as their placement depends on the calling
+ conventions. */
+ dynamic_allocated, /* The entity is allocated during runtime, explicitly
+ by an Alloc node. */
+ static_allocated /* The entity is allocated statically. We can use a
+ SymConst(?) as address of the entity. */
} ent_allocation;
ent_allocation get_entity_allocation (entity *ent);
/* This enumeration flags the variability of entities. */
typedef enum {
uninitialized, /* The content of the entity is completely unknown. */
- initialized, /* After allocation the entity is initalized with the
+ initialized, /* After allocation the entity is initalized with the
value given somewhere in the entity. */
part_constant, /* For entities of compound types. Some members of the entity
are constant. The others are uninitialized. Those members
ir_node *get_compound_ent_value(entity *ent, int pos);
entity *get_compound_ent_value_member(entity *ent, int pos);
void set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
+void remove_compound_ent_value(entity *ent, entity *value_ent);
/* Inits the entity ent witch must be of a one dimensional
array type with the values given in the values array.
The array must have a lower and an upper bound. Keeps the
array or union type. */
int is_compound_entity(entity *ent);
+/* Returns true if ent1 and ent2 have are equal except for their owner.
+ Two entities are equal if
+ - they have the same type (the same C-struct)
+ - ...?
+*/
+bool equal_entity(entity *ent1, entity *ent2);
+
+
+unsigned long get_entity_visited(entity *ent);
+void set_entity_visited(entity *ent, unsigned long num);
+/* Sets visited field in entity to entity_visited. */
+void mark_entity_visited(entity *ent);
+
/*****/