+ * Copies the entity if the new_owner is different from the
+ * owner of the old entity, else returns the old entity.
+ */
+ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner)
+{
+ ir_entity *newe;
+ assert(is_entity(old));
+ assert(is_compound_type(new_owner));
+ assert(get_type_state(new_owner) != layout_fixed);
+
+ if (old->owner == new_owner)
+ return old;
+
+ /* create a deep copy so we are safe of aliasing and double-freeing. */
+ newe = deep_entity_copy(old);
+ newe->owner = new_owner;
+ add_compound_member(new_owner, newe);
+
+ return newe;
+}
+
+ir_entity *copy_entity_name(ir_entity *old, ident *new_name)
+{
+ ir_entity *newe;
+ assert(old && old->kind == k_entity);
+
+ if (old->name == new_name)
+ return old;
+
+ newe = deep_entity_copy(old);
+ newe->name = new_name;
+ newe->ld_name = NULL;
+ add_compound_member(old->owner, newe);
+
+ return newe;
+}
+
+void free_entity(ir_entity *ent)
+{
+ if (ent->owner != NULL && !is_Array_type(ent->owner))
+ remove_compound_member(ent->owner, ent);
+
+ assert(ent && ent->kind == k_entity);
+ free_entity_attrs(ent);
+ ent->kind = k_BAD;
+ xfree(ent);
+}
+
+/* Outputs a unique number for this node */
+long get_entity_nr(const ir_entity *ent)
+{
+ assert(ent && ent->kind == k_entity);
+#ifdef DEBUG_libfirm
+ return ent->nr;
+#else
+ return (long)PTR_TO_INT(ent);
+#endif
+}
+
+const char *(get_entity_name)(const ir_entity *ent)
+{
+ return _get_entity_name(ent);
+}
+
+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;
+}