#include <assert.h>
#include "firm_common_t.h"
-#include "firm_config.h"
#include "typerep.h"
#include "type_t.h"
unsigned visibility:3; /**< Specifies visibility to external program fragments. */
unsigned variability:3; /**< Specifies variability of entities content. */
unsigned volatility:1; /**< Specifies volatility of entities content. */
- unsigned align:1; /**< Specifies alignment of entities content. */
+ unsigned aligned:1; /**< Specifies alignment of entities content. */
unsigned stickyness:2; /**< Specifies whether this entity is sticky. */
unsigned peculiarity:3; /**< The peculiarity of this entity. */
- unsigned usage:4; /**< flag indicating usage types of this entity. */
+ unsigned usage:4; /**< flag indicating usage types of this entity, see ir_entity_usage. */
unsigned final:1; /**< If set, this entity cannot be overridden. */
unsigned compiler_gen:1; /**< If set, this entity was compiler generated. */
unsigned backend_marked:1; /**< If set, this entity was marked by the backend for emission. */
unsigned has_initializer:1; /**< if set, this entity is initialized by new style initializers. */
int offset; /**< Offset in bytes for this entity. Fixed when layout
of owner is determined. */
+ unsigned alignment; /**< entity alignment in bytes */
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
/* ----------------------- inline functions ------------------------ */
-static INLINE int
+static inline int
_is_entity(const void *thing) {
return get_kind(thing) == k_entity;
}
-static INLINE const char *
+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));
}
-static INLINE ident *
+static inline ident *
_get_entity_ident(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->name;
}
-static INLINE void
+static inline void
_set_entity_ident(ir_entity *ent, ident *id) {
assert(ent && ent->kind == k_entity);
ent->name = id;
}
-static INLINE ir_type *
+static inline ir_type *
_get_entity_owner(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->owner = skip_tid(ent->owner);
}
-static INLINE ident *
+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);
+ ent->ld_name = id_mangle_entity(ent);
return ent->ld_name;
}
-static INLINE void
+static inline void
_set_entity_ld_ident(ir_entity *ent, ident *ld_ident) {
assert(ent && ent->kind == k_entity);
ent->ld_name = ld_ident;
}
-static INLINE const char *
+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));
}
-static INLINE ir_type *
+static inline ir_type *
_get_entity_type(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->type = skip_tid(ent->type);
}
-static INLINE void
+static inline void
_set_entity_type(ir_entity *ent, ir_type *type) {
assert(ent && ent->kind == k_entity);
ent->type = type;
}
-static INLINE ir_allocation
+static inline ir_allocation
_get_entity_allocation(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->allocation;
}
-static INLINE void
+static inline void
_set_entity_allocation(ir_entity *ent, ir_allocation al) {
assert(ent && ent->kind == k_entity);
ent->allocation = al;
}
-static INLINE ir_visibility
+static inline ir_visibility
_get_entity_visibility(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->visibility;
}
-static INLINE ir_variability
+static inline ir_variability
_get_entity_variability(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->variability;
}
-static INLINE ir_volatility
+static inline ir_volatility
_get_entity_volatility(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->volatility;
}
-static INLINE void
+static inline void
_set_entity_volatility(ir_entity *ent, ir_volatility vol) {
assert(ent && ent->kind == k_entity);
ent->volatility = vol;
}
-static INLINE ir_align
-_get_entity_align(const ir_entity *ent) {
+static inline unsigned
+_get_entity_alignment(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
- return ent->align;
+ return ent->alignment;
}
-static INLINE void
-_set_entity_align(ir_entity *ent, ir_align a) {
+static inline void
+_set_entity_alignment(ir_entity *ent, unsigned alignment) {
assert(ent && ent->kind == k_entity);
- ent->align = a;
+ ent->alignment = alignment;
}
-static INLINE ir_peculiarity
+static inline ir_align
+_get_entity_aligned(const ir_entity *ent) {
+ assert(ent && ent->kind == k_entity);
+ return ent->aligned;
+}
+
+static inline void
+_set_entity_aligned(ir_entity *ent, ir_align a) {
+ assert(ent && ent->kind == k_entity);
+ ent->aligned = a;
+}
+
+static inline ir_peculiarity
_get_entity_peculiarity(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->peculiarity;
* describe a field? With inherited the situation changed. So
* I removed the assertion. GL, 28.2.05
*/
-static INLINE void
+static inline void
_set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec) {
assert(ent && ent->kind == k_entity);
/* @@@ why peculiarity only for methods? */
ent->peculiarity = pec;
}
-static INLINE ir_stickyness
+static inline ir_stickyness
_get_entity_stickyness(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->stickyness;
}
-static INLINE void
+static inline void
_set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness) {
assert(ent && ent->kind == k_entity);
ent->stickyness = stickyness;
}
-static INLINE int
+static inline int
_is_entity_final(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return (int)ent->final;
}
-static INLINE void
+static inline void
_set_entity_final(ir_entity *ent, int final) {
assert(ent && ent->kind == k_entity);
ent->final = final ? 1 : 0;
}
-static INLINE int
+static inline int
_is_entity_compiler_generated(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->compiler_gen;
}
-static INLINE void
+static inline void
_set_entity_compiler_generated(ir_entity *ent, int flag) {
assert(ent && ent->kind == k_entity);
ent->compiler_gen = flag ? 1 : 0;
}
-static INLINE int
+static inline int
_is_entity_backend_marked(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->backend_marked;
}
-static INLINE void
+static inline void
_set_entity_backend_marked(ir_entity *ent, int flag) {
assert(ent && ent->kind == k_entity);
ent->backend_marked = flag ? 1 : 0;
}
-static INLINE ir_entity_usage
+static inline ir_entity_usage
_get_entity_usage(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->usage;
}
-static INLINE void
+static inline void
_set_entity_usage(ir_entity *ent, ir_entity_usage state) {
assert(ent && ent->kind == k_entity);
ent->usage = state;
}
-static INLINE int
+static inline int
_get_entity_offset(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->offset;
}
-static INLINE void
+static inline void
_set_entity_offset(ir_entity *ent, int offset) {
assert(ent && ent->kind == k_entity);
ent->offset = offset;
}
-static INLINE unsigned char
+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
+static inline void
_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 *
+static inline void *
_get_entity_link(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->link;
}
-static INLINE void
+static inline void
_set_entity_link(ir_entity *ent, void *l) {
assert(ent && ent->kind == k_entity);
ent->link = l;
}
-static INLINE ir_graph *
+static inline ir_graph *
_get_entity_irg(const ir_entity *ent) {
ir_graph *irg;
assert(ent && ent->kind == k_entity);
- assert(ent == unknown_entity || is_Method_type(ent->type));
+ if (!is_Method_type(ent->type) || ent == unknown_entity) {
+ return NULL;
+ }
+
irg = ent->attr.mtd_attr.irg;
if (irg != NULL && !get_visit_pseudo_irgs() && is_pseudo_ir_graph(irg))
return NULL;
return irg;
}
-static INLINE ir_visited_t
+static inline ir_visited_t
_get_entity_visited(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->visit;
}
-static INLINE void
+static inline void
_set_entity_visited(ir_entity *ent, ir_visited_t num) {
assert(ent && ent->kind == k_entity);
ent->visit = num;
}
-static INLINE void
+static inline void
_mark_entity_visited(ir_entity *ent) {
assert(ent && ent->kind == k_entity);
ent->visit = firm_type_visited;
}
-static INLINE int
+static inline int
_entity_visited(ir_entity *ent) {
return _get_entity_visited(ent) >= firm_type_visited;
}
-static INLINE int
+static inline int
_entity_not_visited(ir_entity *ent) {
return _get_entity_visited(ent) < firm_type_visited;
}
-static INLINE ir_type *
+static inline ir_type *
_get_entity_repr_class(const ir_entity *ent) {
assert(ent && ent->kind == k_entity);
return ent->repr_class;
}
-static INLINE dbg_info *
+static inline dbg_info *
_get_entity_dbg_info(const ir_entity *ent) {
return ent->dbi;
}
-static INLINE void
+static inline void
_set_entity_dbg_info(ir_entity *ent, dbg_info *db) {
ent->dbi = db;
}
#define get_entity_variability(ent) _get_entity_variability(ent)
#define get_entity_volatility(ent) _get_entity_volatility(ent)
#define set_entity_volatility(ent, vol) _set_entity_volatility(ent, vol)
+#define set_entity_alignment(ent, alignment) _set_entity_alignment(ent, alignment)
+#define get_entity_alignment(ent) _get_entity_alignment(ent)
#define get_entity_align(ent) _get_entity_align(ent)
#define set_entity_align(ent, a) _set_entity_align(ent, a)
#define get_entity_peculiarity(ent) _get_entity_peculiarity(ent)
projects / libfirm / blobdiff