Commit bc772df6 authored by Michael Beck's avatar Michael Beck
Browse files

- add an extra filed for the bit offset\n- renamed access functions\n- renamed entity -> ir_entity

[r8441]
parent 87f7c136
......@@ -108,16 +108,17 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
res->type = type;
res->owner = owner;
res->allocation = allocation_automatic;
res->visibility = visibility_local;
res->volatility = volatility_non_volatile;
res->stickyness = stickyness_unsticky;
res->peculiarity = peculiarity_existent;
res->final = 0;
res->compiler_gen = 0;
res->offset = -1;
res->link = NULL;
res->repr_class = NULL;
res->allocation = allocation_automatic;
res->visibility = visibility_local;
res->volatility = volatility_non_volatile;
res->stickyness = stickyness_unsticky;
res->peculiarity = peculiarity_existent;
res->final = 0;
res->compiler_gen = 0;
res->offset = -1;
res->offset_bit_remainder = 0;
res->link = NULL;
res->repr_class = NULL;
if (is_Method_type(type)) {
symconst_symbol sym;
......@@ -910,6 +911,7 @@ set_array_entity_values(ir_entity *ent, tarval **values, int num_vals) {
current_ir_graph = rem;
}
/* Return the overall offset of value at position pos in bytes. */
int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
compound_graph_path *path;
int path_len, i;
......@@ -925,7 +927,7 @@ int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
ir_type *node_tp = get_entity_type(node);
ir_type *owner_tp = get_entity_owner(node);
if (owner_tp != NULL && is_Array_type(owner_tp)) {
if (is_Array_type(owner_tp)) {
int size = get_type_size_bits(node_tp);
int align = get_type_alignment_bits(node_tp);
if(size % align > 0) {
......@@ -935,22 +937,17 @@ int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
size /= 8;
offset += size * get_compound_graph_path_array_index(path, i - 1);
} else {
int node_offset = get_entity_offset_bits(node);
if(node_offset % 8 != 0) {
assert(i == path_len - 1);
}
offset += node_offset / 8;
offset += get_entity_offset(node);
}
}
return offset;
}
} /* get_compound_ent_value_offset_bytes */
int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) {
/* Return the offset in bits from the last byte address. */
int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos) {
compound_graph_path *path;
int path_len;
int offset = 0;
ir_entity *last_node;
assert(get_type_state(get_entity_type(ent)) == layout_fixed);
......@@ -959,18 +956,12 @@ int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) {
path_len = get_compound_graph_path_length(path);
last_node = get_compound_graph_path_node(path, path_len - 1);
offset = get_entity_offset_bits(last_node);
if(offset < 0)
return 0;
return offset % 8;
}
return get_entity_offset_bits_remainder(last_node);
} /* get_compound_ent_value_offset_bit_remainder */
typedef struct {
/** number of elements the array can hold */
int n_elems;
/** current array index */
int current_elem;
int n_elems; /**< number of elements the array can hold */
int current_elem; /**< current array index */
ir_entity *ent;
} array_info;
......@@ -1090,23 +1081,23 @@ int compute_compound_ent_array_indices(ir_entity *ent) {
}
int
(get_entity_offset_bytes)(const ir_entity *ent) {
return _get_entity_offset_bytes(ent);
(get_entity_offset)(const ir_entity *ent) {
return _get_entity_offset(ent);
}
int
(get_entity_offset_bits)(const ir_entity *ent) {
return _get_entity_offset_bits(ent);
void
(set_entity_offset)(ir_entity *ent, int offset) {
_set_entity_offset(ent, offset);
}
void
(set_entity_offset_bytes)(ir_entity *ent, int offset) {
_set_entity_offset_bytes(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)(ir_entity *ent, int offset) {
_set_entity_offset_bits(ent, offset);
(set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset) {
_set_entity_offset_bits_remainder(ent, offset);
}
void
......
......@@ -291,16 +291,16 @@ ir_stickyness get_entity_stickyness(const ir_entity *ent);
void set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness);
/** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
int get_entity_offset_bytes(const ir_entity *ent);
/** Returns the offset of an entity (in a compound) in bits. Only set if layout = fixed. */
int get_entity_offset_bits(const ir_entity *ent);
int get_entity_offset(const ir_entity *ent);
/** Sets the offset of an entity (in a compound) in bytes. */
void set_entity_offset_bytes(ir_entity *ent, int offset);
void set_entity_offset(ir_entity *ent, int offset);
/** Returns the offset bit remainder of a bitfield entity (in a compound) in bits. Only set if layout = fixed. */
unsigned char get_entity_offset_bits_remainder(const ir_entity *ent);
/** Sets the offset of an entity (in a compound) in bits. */
void set_entity_offset_bits(ir_entity *ent, int offset);
/** Sets the offset bit remainder of a bitfield entity (in a compound) in bits. */
void set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset);
/** Returns the stored intermediate information. */
void *get_entity_link(const ir_entity *ent);
......@@ -440,14 +440,14 @@ void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member,
void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
/**
* Return the offset in bits from the last byte (result is in [0,7])
* Return the offset in bits from the last byte address.
*
* 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_bit_part(ir_entity *ent, int pos);
int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos);
/** Return the overall offset of value at position pos in bytes.
*
......
......@@ -49,14 +49,14 @@
/** A path in a compound graph. */
struct compound_graph_path {
firm_kind kind; /**< The dynamic type tag for compound graph path. */
ir_type *tp; /**< The type this path belongs to. */
int len; /**< The length of the path. */
struct tuple {
int index; /**< Array index. To compute position of array elements */
ir_entity *node; /**< The accessed entity. */
} list[1]; /**< List of entity/index tuple of length len to express the
access path. */
firm_kind kind; /**< The dynamic type tag for compound graph path. */
ir_type *tp; /**< The type this path belongs to. */
int len; /**< The length of the path. */
struct tuple {
int index; /**< Array index. To compute position of array elements */
ir_entity *node; /**< The accessed entity. */
} list[1]; /**< List of entity/index tuple of length len to express the
access path. */
};
/** The attributes for atomic entities. */
......@@ -67,10 +67,11 @@ typedef struct atomic_ent_attr {
/** 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. */
compound_graph_path **val_paths; /**< paths corresponding to constant values. Only available if
variability not uninitialized. Must be set for variability constant. */
ir_node **values; /**< constant values of compound entities. Only available if
variability not uninitialized. Must be set for variability constant. */
compound_graph_path **val_paths;
/**< paths corresponding to constant values. Only available if
variability not uninitialized. Must be set for variability constant. */
} compound_ent_attr;
/** A reserved value for "not yet set". */
......@@ -78,71 +79,74 @@ typedef struct compound_ent_attr {
/** 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. */
unsigned irg_add_properties; /**< Additional graph properties can be
stored in a entity if no irg is available. */
unsigned vtable_number; /**< For a dynamically called method, the number assigned
in the virtual function table. */
ptr_access_kind *param_access; /**< the parameter access */
float *param_weight; /**< The weight of method's parameters. Parameters
with a high weight are good for procedure cloning. */
ir_img_section section; /**< The code section where this method should be placed */
ir_graph *irg; /**< The corresponding irg if known.
The ir_graph constructor automatically sets this field. */
unsigned irg_add_properties; /**< Additional graph properties can be
stored in a entity if no irg is available. */
unsigned vtable_number; /**< For a dynamically called method, the number assigned
in the virtual function table. */
ptr_access_kind *param_access; /**< the parameter access */
float *param_weight; /**< The weight of method's parameters. Parameters
with a high weight are good for procedure cloning. */
ir_img_section section; /**< The code section where this method should be placed */
} method_ent_attr;
/** The type of an entity. */
struct ir_entity {
firm_kind kind; /**< The dynamic type tag for entity. */
ident *name; /**< The name of this entity. */
ident *ld_name; /**< Unique name of this entity, i.e., the mangled
name. If the field is read before written a default
mangling is applies. The name of the owner is prepended
to the name of the entity, separated by a underscore.
E.g., for a class `A' with field `a' this
is the ident for `A_a'. */
ir_type *type; /**< The type of this entity, e.g., a method type, a
basic type of the language or a class itself. */
ir_type *owner; /**< The compound type (e.g. class type) this entity belongs to. */
ir_allocation allocation:3; /**< Distinguishes static and dynamically allocated
entities and some further cases. */
ir_visibility visibility:3; /**< Specifies visibility to external program
fragments. */
ir_variability variability:3; /**< Specifies variability of entities content. */
ir_volatility volatility:2; /**< Specifies volatility of entities content. */
ir_stickyness stickyness:2; /**< Specifies whether this entity is sticky. */
ir_peculiarity peculiarity:3; /**< The peculiarity of this entity. */
unsigned final:1; /**< If set, this entity cannot be overridden. */
unsigned compiler_gen:1; /**< If set, this entity was compiler generated. */
int offset; /**< Offset in bits for this entity. Fixed when layout
of owner is determined. */
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 ---------------*/
ir_entity **overwrites; /**< A list of entities this entity overwrites. */
ir_entity **overwrittenby; /**< A list of entities that overwrite this entity. */
/* ------------- fields for atomic entities --------------- */
ir_node *value; /**< value if entity is not of variability uninitialized.
Only for atomic entities. */
union {
/* ------------- fields for compound entities -------------- */
compound_ent_attr cmpd_attr;
/* ------------- fields for method entities ---------------- */
method_ent_attr mtd_attr;
} attr; /**< type specific attributes */
/* ------------- fields for analyses ---------------*/
firm_kind kind; /**< The dynamic type tag for entity. */
ident *name; /**< The name of this entity. */
ident *ld_name; /**< Unique name of this entity, i.e., the mangled
name. If the field is read before written a default
mangling is applies. The name of the owner is prepended
to the name of the entity, separated by a underscore.
E.g., for a class `A' with field `a' this
is the ident for `A_a'. */
ir_type *type; /**< The type of this entity, e.g., a method type, a
basic type of the language or a class itself. */
ir_type *owner; /**< The compound type (e.g. class type) this entity belongs to. */
ir_allocation allocation:3; /**< Distinguishes static and dynamically allocated
entities and some further cases. */
ir_visibility visibility:3; /**< Specifies visibility to external program
fragments. */
ir_variability variability:3; /**< Specifies variability of entities content. */
ir_volatility volatility:2; /**< Specifies volatility of entities content. */
ir_stickyness stickyness:2; /**< Specifies whether this entity is sticky. */
ir_peculiarity peculiarity:3; /**< The peculiarity of this entity. */
unsigned final:1; /**< If set, this entity cannot be overridden. */
unsigned compiler_gen:1; /**< If set, this entity was compiler generated. */
int offset; /**< Offset in bytes for this entity. Fixed when layout
of owner is determined. */
unsigned char offset_bit_remainder;
/**< If the entity is a bit field, this is the offset of
the start of the bit field within the byte specified
by offset. */
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 ---------------*/
ir_entity **overwrites; /**< A list of entities this entity overwrites. */
ir_entity **overwrittenby; /**< A list of entities that overwrite this entity. */
/* ------------- fields for atomic entities --------------- */
ir_node *value; /**< value if entity is not of variability uninitialized.
Only for atomic entities. */
union {
/* ------------- fields for compound entities -------------- */
compound_ent_attr cmpd_attr;
/* ------------- fields for method entities ---------------- */
method_ent_attr mtd_attr;
} attr; /**< type specific attributes */
/* ------------- fields for analyses ---------------*/
#ifdef DEBUG_libfirm
long nr; /**< A unique node number for each node to make output
readable. */
long nr; /**< A unique node number for each node to make output readable. */
# endif /* DEBUG_libfirm */
};
......@@ -153,106 +157,106 @@ void firm_init_entity(void);
/* ----------------------- inline functions ------------------------ */
static INLINE int
_is_entity(const void *thing) {
return get_kind(thing) == k_entity;
return get_kind(thing) == k_entity;
}
static INLINE const char *
_get_entity_name(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return get_id_str(get_entity_ident(ent));
assert(ent && ent->kind == k_entity);
return get_id_str(get_entity_ident(ent));
}
static INLINE ident *
_get_entity_ident(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->name;
assert(ent && ent->kind == k_entity);
return ent->name;
}
static INLINE void
_set_entity_ident(ir_entity *ent, ident *id) {
assert(ent && ent->kind == k_entity);
ent->name = id;
assert(ent && ent->kind == k_entity);
ent->name = id;
}
static INLINE ir_type *
_get_entity_owner(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->owner = skip_tid(ent->owner);
assert(ent && ent->kind == k_entity);
return ent->owner = skip_tid(ent->owner);
}
static INLINE ident *
_get_entity_ld_ident(ir_entity *ent)
{
assert(ent && ent->kind == k_entity);
if (ent->ld_name == NULL)
ent->ld_name = mangle_entity(ent);
return ent->ld_name;
assert(ent && ent->kind == k_entity);
if (ent->ld_name == NULL)
ent->ld_name = mangle_entity(ent);
return ent->ld_name;
}
static INLINE void
_set_entity_ld_ident(ir_entity *ent, ident *ld_ident) {
assert(ent && ent->kind == k_entity);
ent->ld_name = ld_ident;
assert(ent && ent->kind == k_entity);
ent->ld_name = ld_ident;
}
static INLINE const char *
_get_entity_ld_name(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return get_id_str(get_entity_ld_ident(ent));
assert(ent && ent->kind == k_entity);
return get_id_str(get_entity_ld_ident(ent));
}
static INLINE ir_type *
_get_entity_type(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->type = skip_tid(ent->type);
assert(ent && ent->kind == k_entity);
return ent->type = skip_tid(ent->type);
}
static INLINE void
_set_entity_type(ir_entity *ent, ir_type *type) {
assert(ent && ent->kind == k_entity);
ent->type = type;
assert(ent && ent->kind == k_entity);
ent->type = type;
}
static INLINE ir_allocation
_get_entity_allocation(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->allocation;
assert(ent && ent->kind == k_entity);
return ent->allocation;
}
static INLINE void
_set_entity_allocation(ir_entity *ent, ir_allocation al) {
assert(ent && ent->kind == k_entity);
ent->allocation = al;
assert(ent && ent->kind == k_entity);
ent->allocation = al;
}
static INLINE ir_visibility
_get_entity_visibility(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->visibility;
assert(ent && ent->kind == k_entity);
return ent->visibility;
}
static INLINE ir_variability
_get_entity_variability(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->variability;
assert(ent && ent->kind == k_entity);
return ent->variability;
}
static INLINE ir_volatility
_get_entity_volatility(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->volatility;
assert(ent && ent->kind == k_entity);
return ent->volatility;
}
static INLINE void
_set_entity_volatility(ir_entity *ent, ir_volatility vol) {
assert(ent && ent->kind == k_entity);
ent->volatility = vol;
assert(ent && ent->kind == k_entity);
ent->volatility = vol;
}
static INLINE ir_peculiarity
_get_entity_peculiarity(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->peculiarity;
assert(ent && ent->kind == k_entity);
return ent->peculiarity;
}
/**
......@@ -264,116 +268,115 @@ _get_entity_peculiarity(const ir_entity *ent) {
*/
static INLINE void
_set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec) {
assert(ent && ent->kind == k_entity);
/* @@@ why peculiarity only for methods? */
//assert(is_Method_type(ent->type));
assert(ent && ent->kind == k_entity);
/* @@@ why peculiarity only for methods? */
//assert(is_Method_type(ent->type));
ent->peculiarity = pec;
ent->peculiarity = pec;
}
static INLINE ir_stickyness
_get_entity_stickyness(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->stickyness;
assert(ent && ent->kind == k_entity);
return ent->stickyness;
}
static INLINE void
_set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness) {
assert(ent && ent->kind == k_entity);
ent->stickyness = stickyness;
assert(ent && ent->kind == k_entity);
ent->stickyness = stickyness;
}
static INLINE int
_get_entity_final(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return (int)ent->final;
assert(ent && ent->kind == k_entity);
return (int)ent->final;
}
static INLINE void
_set_entity_final(ir_entity *ent, int final) {
assert(ent && ent->kind == k_entity);
ent->final = final ? 1 : 0;
assert(ent && ent->kind == k_entity);
ent->final = final ? 1 : 0;
}
static INLINE int
_get_entity_offset_bits(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->offset;
_get_entity_offset(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->offset;
}
static INLINE int
_get_entity_offset_bytes(const ir_entity *ent) {
int bits = _get_entity_offset_bits(ent);
if (bits & 7) return -1;
return bits >> 3;
static INLINE void
_set_entity_offset(ir_entity *ent, int offset) {
assert(ent && ent->kind == k_entity);
ent->offset = offset;
}
static INLINE void
_set_entity_offset_bits(ir_entity *ent, int offset) {
assert(ent && ent->kind == k_entity);
ent->offset = offset;
static INLINE unsigned char
_get_entity_offset_bits_remainder(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->offset_bit_remainder;
}
static INLINE void
_set_entity_offset_bytes(ir_entity *ent, int offset) {
_set_entity_offset_bits(ent, offset * 8);
_set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset) {
assert(ent && ent->kind == k_entity);
ent->offset_bit_remainder = offset;
}
static INLINE void *
_get_entity_link(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->link;
assert(ent && ent->kind == k_entity);
return ent->link;
}
static INLINE void
_set_entity_link(ir_entity *ent, void *l) {
assert(ent && ent->kind == k_entity);
ent->link = l;
assert(ent && ent->kind == k_entity);
ent->link = l;
}
static INLINE ir_graph *
_get_entity_irg(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
assert(ent == unknown_entity || is_Method_type(ent->type));
if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
&& is_pseudo_ir_graph(ent->attr.mtd_attr.irg))
return NULL;
return ent->attr.mtd_attr.irg;
assert(ent && ent->kind == k_entity);
assert(ent == unknown_entity || is_Method_type(ent->type));
if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
&& is_pseudo_ir_graph(ent->attr.mtd_attr.irg))
return NULL;
return ent->attr.mtd_attr.irg;
}
static INLINE unsigned long
_get_entity_visited(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->visit;
assert(ent && ent->kind == k_entity);
return ent->visit;
}
static INLINE void
_set_entity_visited(ir_entity *ent, unsigned long num) {
assert(ent && ent->kind == k_entity);
ent->visit = num;
assert(ent && ent->kind == k_entity);
ent->visit = num;
}
static INLINE void
_mark_entity_visited(ir_entity *ent) {