* - type *type: The type of this entity, e.g., a method type, a
* 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
-* of owner is determined.
+* variables the method they are defined in.
+* - 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.
* If (type != method_type) access of this field will cause
* @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_ld_ident (entity *ent, ident *ld_ident);
/** Returns the mangled name of the entity as a string. */
-const char *get_entity_ld_name (entity *end);
+const char *get_entity_ld_name (entity *ent);
/** Returns the owner of the entity. */
type *get_entity_owner (entity *ent);
ent to owner!! */
void set_entity_owner (entity *ent, type *owner);
-/** Asserts if the type owner is neither a compound type or an array */
+/** Asserts if the type owner is either a compound type or an array */
void assert_legal_owner_of_ent(type *owner);
/** Returns the type of an entity. */
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
+ 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. */
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. */
- 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. */
+ variability_part_constant, /**< For entities of compound types.
+ The members of the entity are mixed constant,
+ initialized or uninitialized. */
variability_constant /**< The entity is constant. */
} ent_variability;
/** This enumeration flags the stickyness of an entity. */
typedef enum {
stickyness_unsticky, /**< The entity can be removed from
- the program, unles contraindicated
+ 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);
+ent_stickyness get_entity_stickyness(entity *ent);
/** Set the entity's stickyness */
-void set_entity_stickyness (entity *ent, ent_stickyness stickyness);
+void set_entity_stickyness(entity *ent, ent_stickyness stickyness);
-/** Returns the offset of an entity (in a compound). Only set if layout = fixed. */
-int get_entity_offset (entity *ent);
+/** 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);
int get_compound_graph_path_length(compound_graph_path *gr);
entity *get_compound_graph_path_node(compound_graph_path *gr, int pos);
void set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node);
+int get_compound_graph_path_array_index(compound_graph_path *gr, int pos);
+void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
/* A value of a compound entity is a pair of a value and the description of the
corresponding access path to the member of the compound. */
void add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path);
void set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos);
+/** Returns the number of constant values needed to initialize the entity.
+ *
+ * Asserts if the entity has variability_uninitialized.
+ * */
int get_compound_ent_n_values(entity *ent);
ir_node *get_compound_ent_value(entity *ent, int pos);
compound_graph_path *get_compound_ent_value_path(entity *ent, int pos);
/* Sets the path at pos 0 */
void set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
-
-
/** 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
values have the proper mode for the array. */
void set_array_entity_values(entity *ent, tarval **values, int num_vals);
+/** Return the overall offset of value at position pos in bits.
+ *
+ * This requires that the layout of all concerned types is fixed.
+ *
+ * @param ent Any entity of compound type with at least pos initialization values.
+ * @param pos The position of the value for which the offset is requested.
+ */
+int get_compound_ent_value_offset_bits(entity *ent, int pos);
+
+/** Return the overall offset of value at position pos in bytes.
+ *
+ * This requires that the layout of all concerned types is fixed.
+ * Asserts if bit offset is not byte aligned.
+ *
+ * @param ent Any entity of compound type with at least pos initialization values.
+ * @param pos The position of the value for which the offset is requested.
+ */
+int get_compound_ent_value_offset_bytes(entity *ent, int pos);
+
+/** Compute the array indicees in compound graph paths of initialized entities.
+ *
+ * All arrays must have fixed lower and upper bounds. One array can
+ * have an open upper bound. If there are several open bounds, we do
+ * nothing. There must be initializer elements for all array
+ * elements. Uses the link field in the array element entities. The
+ * array bounds must be representable as ints.
+ *
+ * @param ent Any entity.
+ */
+void compute_compound_ent_array_indicees(entity *ent);
+
+/** Sort the values of the compound entity by their overall offset.
+ *
+ * This requires that the layout of all concerned types is fixed.
+ * If the entity has no initialization information the method just
+ * returns. This is needed to dump the entity in a backend.
+ *
+ * @param ent Any entity.
+ */
+void sort_compound_ent_values(entity *ent);
+
+
/* --- Fields of entities with a class type as owner --- */
/* Overwrites is a field that specifies that an access to the overwritten
entity in the supertype must use this entity. It's a list as with
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_ */
projects / libfirm / blobdiff