+ident *(get_entity_ident)(const ir_entity *ent)
+{
+ return _get_entity_ident(ent);
+}
+
+void (set_entity_ident)(ir_entity *ent, ident *id)
+{
+ _set_entity_ident(ent, id);
+}
+
+ir_type *(get_entity_owner)(const ir_entity *ent)
+{
+ return _get_entity_owner(ent);
+}
+
+void set_entity_owner(ir_entity *ent, ir_type *owner)
+{
+ assert(is_entity(ent));
+ assert(is_compound_type(owner));
+
+ remove_compound_member(ent->owner, ent);
+ add_compound_member(owner, ent);
+ ent->owner = owner;
+}
+
+ident *(get_entity_ld_ident)(const ir_entity *ent)
+{
+ return _get_entity_ld_ident(ent);
+}
+
+void (set_entity_ld_ident)(ir_entity *ent, ident *ld_ident)
+{
+ _set_entity_ld_ident(ent, ld_ident);
+}
+
+const char *(get_entity_ld_name)(const ir_entity *ent)
+{
+ return _get_entity_ld_name(ent);
+}
+
+int entity_has_ld_ident(const ir_entity *entity)
+{
+ return entity->ld_name != NULL;
+}
+
+ir_type *(get_entity_type)(const ir_entity *ent)
+{
+ return _get_entity_type(ent);
+}
+
+void (set_entity_type)(ir_entity *ent, ir_type *type)
+{
+ _set_entity_type(ent, type);
+}
+
+ir_volatility (get_entity_volatility)(const ir_entity *ent)
+{
+ return _get_entity_volatility(ent);
+}
+
+void (set_entity_volatility)(ir_entity *ent, ir_volatility vol)
+{
+ _set_entity_volatility(ent, vol);
+}
+
+/* Return the name of the volatility. */
+const char *get_volatility_name(ir_volatility var)
+{
+#define X(a) case a: return #a
+ switch (var) {
+ X(volatility_non_volatile);
+ X(volatility_is_volatile);
+ default: return "BAD VALUE";
+ }
+#undef X
+}
+
+ir_align (get_entity_aligned)(const ir_entity *ent)
+{
+ return _get_entity_aligned(ent);
+}
+
+void (set_entity_aligned)(ir_entity *ent, ir_align a)
+{
+ _set_entity_aligned(ent, a);
+}
+
+unsigned (get_entity_alignment)(const ir_entity *ent)
+{
+ return _get_entity_alignment(ent);
+}
+
+void (set_entity_alignment)(ir_entity *ent, unsigned alignment)
+{
+ _set_entity_alignment(ent, alignment);
+}
+
+/* Return the name of the alignment. */
+const char *get_align_name(ir_align a)
+{
+#define X(a) case a: return #a
+ switch (a) {
+ X(align_non_aligned);
+ X(align_is_aligned);
+ default: return "BAD VALUE";
+ }
+#undef X
+}
+
+void set_entity_label(ir_entity *ent, ir_label_t label)
+{
+ ent->attr.code_attr.label = label;
+}
+
+ir_label_t get_entity_label(const ir_entity *ent)
+{
+ return ent->attr.code_attr.label;
+}
+
+static void verify_visibility(const ir_entity *entity)
+{
+ if (get_entity_visibility(entity) == ir_visibility_external
+ && !is_method_entity(entity)) {
+ assert(!entity_has_definition(entity));
+ }
+}
+
+void set_entity_visibility(ir_entity *entity, ir_visibility visibility)
+{
+ entity->visibility = visibility;
+ verify_visibility(entity);
+}
+
+ir_visibility get_entity_visibility(const ir_entity *entity)
+{
+ return (ir_visibility)entity->visibility;
+}
+
+void set_entity_linkage(ir_entity *entity, ir_linkage linkage)
+{
+ entity->linkage = linkage;
+}
+
+ir_linkage (get_entity_linkage)(const ir_entity *entity)
+{
+ return get_entity_linkage(entity);
+}
+
+void add_entity_linkage(ir_entity *entity, ir_linkage linkage)
+{
+ entity->linkage |= linkage;
+}
+
+void remove_entity_linkage(ir_entity *entity, ir_linkage linkage)
+{
+ entity->linkage &= ~linkage;
+}
+
+/* Checks if an entity is compiler generated */
+int (is_entity_compiler_generated)(const ir_entity *ent)
+{
+ return _is_entity_compiler_generated(ent);
+}
+
+/* Sets/resets the compiler generated flag */
+void (set_entity_compiler_generated)(ir_entity *ent, int flag)
+{
+ _set_entity_compiler_generated(ent, flag);
+}
+
+ir_entity_usage (get_entity_usage)(const ir_entity *ent)
+{
+ return _get_entity_usage(ent);
+}
+
+void (set_entity_usage)(ir_entity *ent, ir_entity_usage flags)
+{
+ _set_entity_usage(ent, flags);
+}
+
+/* Set has no effect for existent entities of type method. */
+ir_node *get_atomic_ent_value(ir_entity *entity)
+{
+ ir_initializer_t *initializer = get_entity_initializer(entity);
+
+ assert(entity && is_atomic_entity(entity));
+ if (initializer == NULL) {
+ ir_type *type = get_entity_type(entity);
+ return new_r_Unknown(get_const_code_irg(), get_type_mode(type));
+ }
+
+ switch (get_initializer_kind(initializer)) {
+ case IR_INITIALIZER_NULL: {
+ ir_type *type = get_entity_type(entity);
+ ir_mode *mode = get_type_mode(type);
+ return new_r_Const(get_const_code_irg(), get_mode_null(mode));
+ }
+ case IR_INITIALIZER_TARVAL: {
+ ir_tarval *tv = get_initializer_tarval_value(initializer);
+ return new_r_Const(get_const_code_irg(), tv);
+ }
+ case IR_INITIALIZER_CONST:
+ return get_initializer_const_value(initializer);
+ case IR_INITIALIZER_COMPOUND:
+ panic("compound initializer in atomic entity not allowed (%+F)", entity);
+ }
+
+ panic("invalid initializer kind in get_atomic_ent_value(%+F)", entity);
+}
+
+void set_atomic_ent_value(ir_entity *entity, ir_node *val)
+{
+ ir_initializer_t *initializer;
+
+ assert(is_atomic_entity(entity));
+
+ assert(is_Dummy(val) || get_irn_mode(val) == get_type_mode(entity->type));
+ initializer = create_initializer_const(val);
+ entity->initializer = initializer;
+}
+
+/* Returns true if the the node is representable as code on
+ * const_code_irg. */
+int is_irn_const_expression(ir_node *n)
+{
+ ir_mode *m;
+
+ /* we are in danger iff an exception will arise. TODO: be more precisely,
+ * for instance Div. will NOT rise if divisor != 0
+ */
+ if (is_binop(n) && !is_fragile_op(n))
+ return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
+
+ m = get_irn_mode(n);
+ switch (get_irn_opcode(n)) {
+ case iro_Const:
+ case iro_SymConst:
+ case iro_Unknown:
+ return 1;
+ case iro_Conv:
+ case iro_Cast:
+ return is_irn_const_expression(get_irn_n(n, 0));
+ default:
+ break;
+ }
+ return 0;