* basic type of the language or a class itself.
* - type *owner: The class this entity belongs to. In case of local
* variables the method they are defined in.
-* - int offset: Offset in byte for this entity. Fixed when layout
+* - int offset: Offset in bits for this entity. Fixed when layout
* of owner is determined.
* - ir_graph *irg: If (type == method_type) this is the corresponding irg.
-* The ir_graph constructor automatically sets this field.
+* The ir_graph constructor automatically sets this field.
* If (type != method_type) access of this field will cause
* an assertion.
*/
* @param variability A flag indicating the variability of this entity (values:
* uninitialized, initalized, part_constant, constant)
* @param volatility @@@
- * @param offset The offset of the entity within the compound object. Only set
+ * @param offset The offset of the entity within the compound object in bits. Only set
* if the owner in the state "layout_fixed".
* @param overwrites A list of entities overwritten by this entity. This list is only
* existent if the owner of this entity is a class. The members in
void set_entity_owner (entity *ent, type *owner);
/** Asserts if the type owner is neither a compound type or an array */
-INLINE void assert_legal_owner_of_ent(type *owner);
+void assert_legal_owner_of_ent(type *owner);
/** Returns the type of an entity. */
type *get_entity_type (entity *ent);
/** The allocation type. */
typedef enum {
allocation_automatic, /**< The entity is allocated during runtime, implicitly
- as component of a compound type. This is the default. */
+ as component of a compound type. This is the default. */
allocation_parameter, /**< 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. */
+ We distinguish the allocation of paramters from the allocation
+ of local variables as their placement depends on the calling
+ conventions. */
allocation_dynamic, /**< The entity is allocated during runtime, explicitly
- by an Alloc node. */
+ by an Alloc node. */
allocation_static /**< The entity is allocated statically. We can use a
Const as address of the entity. */
} ent_allocation;
typedef enum {
visibility_local, /**< The entity is only visible locally. This is the default. */
visibility_external_visible, /**< The entity is visible to other external program parts, but
- it is defined here. It may not be optimized away. The entity must
- be static_allocated. */
- visibility_external_allocated /**< The entity is defined and allocated externally. This compilation
- must not allocate memory for this entity. The entity must
- be static_allocated. This can also be an external defined
- method. */
+ it is defined here. It may not be optimized away. The entity must
+ be static_allocated. */
+ visibility_external_allocated, /**< The entity is defined and allocated externally. This compilation
+ must not allocate memory for this entity. The entity must
+ be static_allocated. This can also be an external defined
+ method. */
} ent_visibility;
/** Returns the visibility of an entity. */
typedef enum {
variability_uninitialized, /**< The content of the entity is completely unknown. */
variability_initialized, /**< After allocation the entity is initalized with the
- value given somewhere in the entity. */
+ value given somewhere in the entity. */
variability_part_constant, /**< For entities of compound types. Some members of the entity
- are constant. The others are uninitialized. Those members
- given a value for are constant. */
+ are constant. The others are uninitialized. Those members
+ given a value for are constant. */
variability_constant /**< The entity is constant. */
} ent_variability;
/* Return the name of the volatility. */
const char *get_volatility_name(ent_volatility var);
-/** Returns the offset of an entity (in a compound). Only set if layout = fixed. */
-int get_entity_offset (entity *ent);
+/** This enumeration flags the stickyness of an entity. */
+typedef enum {
+ stickyness_unsticky, /**< The entity can be removed from
+ the program, unless contraindicated
+ by other attributes */
+ stickyness_sticky /**< The entity must remain in the
+ program in any case */
+} ent_stickyness;
+
+/** Get the entity's stickyness */
+ent_stickyness get_entity_stickyness(entity *ent);
+
+/** Set the entity's stickyness */
+void set_entity_stickyness(entity *ent, ent_stickyness stickyness);
+
+/** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
+int get_entity_offset_bytes(entity *ent);
-/** Sets the offset of an entity (in a compound). */
-void set_entity_offset (entity *ent, int offset);
+/** Returns the offset of an entity (in a compound) in bits. Only set if layout = fixed. */
+int get_entity_offset_bits(entity *ent);
+
+/** Sets the offset of an entity (in a compound) in bytes. */
+void set_entity_offset_bytes(entity *ent, int offset);
+
+/** Sets the offset of an entity (in a compound) in bits. */
+void set_entity_offset_bits(entity *ent, int offset);
/** Returns the stored intermediate information. */
void* get_entity_link(entity *ent);
/** Outputs a unique number for this entity if libfirm is compiled for
debugging, (configure with --enable-debug) else returns 0. */
-INLINE long get_entity_nr(entity *ent);
+long get_entity_nr(entity *ent);
/** Returns the entitys visited count. */
unsigned long get_entity_visited(entity *ent);
/** Returns true if this entity was not visited. */
bool entity_not_visited(entity *ent);
+/** Returns the dynamically referenced entity if the static entity and the
+ * dynamic type are given. */
+entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent);
+
+
+/*-----------------------------------------------------------------*/
+/* Debug aides */
+/*-----------------------------------------------------------------*/
+
+
+/** Write the entity and all its attributes to stdout.
+ *
+ * Writes the entity and all its attributes to stdout if DEBUG_libfirm
+ * is set. Else does nothing. */
+void dump_entity (entity *ent);
+
+
# endif /* _ENTITY_H_ */