+
+size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
+{
+ size_t i;
+ size_t n = get_entity_n_overwrites(ent);
+ for (i = 0; i < n; ++i) {
+ if (get_entity_overwrites(ent, i) == overwritten)
+ return i;
+ }
+ return (size_t)-1;
+}
+
+ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos)
+{
+ assert(pos < get_entity_n_overwrites(ent));
+ return ent->overwrites[pos];
+}
+
+void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten)
+{
+ assert(pos < get_entity_n_overwrites(ent));
+ ent->overwrites[pos] = overwritten;
+}
+
+void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
+{
+ size_t i;
+ size_t n = get_entity_n_overwrites(ent);
+ for (i = 0; i < n; ++i) {
+ if (ent->overwrites[i] == overwritten) {
+ for (; i < n - 1; i++)
+ ent->overwrites[i] = ent->overwrites[i+1];
+ ARR_SETLEN(ir_entity*, ent->overwrites, n - 1);
+ break;
+ }
+ }
+}
+
+
+size_t get_entity_n_overwrittenby(const ir_entity *ent)
+{
+ if (ent->overwrittenby == NULL)
+ return 0;
+ return ARR_LEN(ent->overwrittenby);
+}
+
+size_t get_entity_overwrittenby_index(const ir_entity *ent,
+ ir_entity *overwrites)
+{
+ size_t i;
+ size_t n = get_entity_n_overwrittenby(ent);
+ for (i = 0; i < n; ++i) {
+ if (get_entity_overwrittenby(ent, i) == overwrites)
+ return i;
+ }
+ return (size_t)-1;
+}
+
+ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos)
+{
+ assert(pos < get_entity_n_overwrittenby(ent));
+ return ent->overwrittenby[pos];
+}
+
+void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites)
+{
+ assert(pos < get_entity_n_overwrittenby(ent));
+ ent->overwrittenby[pos] = overwrites;
+}
+
+void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites)
+{
+ size_t i;
+ size_t n = get_entity_n_overwrittenby(ent);
+ for (i = 0; i < n; ++i) {
+ if (ent->overwrittenby[i] == overwrites) {
+ for (; i < n - 1; ++i)
+ ent->overwrittenby[i] = ent->overwrittenby[i+1];
+ ARR_SETLEN(ir_entity*, ent->overwrittenby, n - 1);
+ break;
+ }
+ }
+}
+
+void *(get_entity_link)(const ir_entity *ent)
+{
+ return _get_entity_link(ent);
+}
+
+void (set_entity_link)(ir_entity *ent, void *l)
+{
+ _set_entity_link(ent, l);
+}
+
+ir_graph *(get_entity_irg)(const ir_entity *ent)
+{
+ return _get_entity_irg(ent);
+}
+
+void set_entity_irg(ir_entity *ent, ir_graph *irg)
+{
+ assert(is_method_entity(ent));
+ assert(get_entity_peculiarity(ent) == peculiarity_existent);
+ ent->attr.mtd_attr.irg = irg;
+}
+
+unsigned get_entity_vtable_number(const ir_entity *ent)
+{
+ assert(is_method_entity((ir_entity *)ent));
+ return ent->attr.mtd_attr.vtable_number;
+}
+
+void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number)
+{
+ assert(is_method_entity(ent));
+ ent->attr.mtd_attr.vtable_number = vtable_number;
+}
+
+int (is_entity)(const void *thing)
+{
+ return _is_entity(thing);
+}
+
+int is_atomic_entity(const ir_entity *ent)
+{
+ ir_type *t = get_entity_type(ent);
+ const tp_op *op = get_type_tpop(t);
+ return (op == type_primitive || op == type_pointer ||
+ op == type_enumeration || op == type_method);
+}
+
+int is_compound_entity(const ir_entity *ent)
+{
+ ir_type *t = get_entity_type(ent);
+ const tp_op *op = get_type_tpop(t);
+ return (op == type_class || op == type_struct ||
+ op == type_array || op == type_union);
+}
+
+int is_method_entity(const ir_entity *ent)
+{
+ ir_type *t = get_entity_type(ent);
+ return is_Method_type(t);
+}
+
+ir_visited_t (get_entity_visited)(const ir_entity *ent)
+{
+ return _get_entity_visited(ent);
+}
+
+void (set_entity_visited)(ir_entity *ent, ir_visited_t num)
+{
+ _set_entity_visited(ent, num);
+}
+
+void (mark_entity_visited)(ir_entity *ent)
+{
+ _mark_entity_visited(ent);
+}
+
+int (entity_visited)(const ir_entity *ent)
+{
+ return _entity_visited(ent);
+}
+
+int (entity_not_visited)(const ir_entity *ent)
+{
+ return _entity_not_visited(ent);
+}
+
+mtp_additional_properties get_entity_additional_properties(const ir_entity *ent)
+{
+ ir_graph *irg;
+
+ assert(is_method_entity(ent));
+
+ /* first check, if the graph has additional properties */
+ irg = get_entity_irg(ent);
+
+ if (irg)
+ return get_irg_additional_properties(irg);
+
+ if (ent->attr.mtd_attr.irg_add_properties & mtp_property_inherited)
+ return get_method_additional_properties(get_entity_type(ent));
+
+ return ent->attr.mtd_attr.irg_add_properties;
+}
+
+void set_entity_additional_properties(ir_entity *ent, mtp_additional_properties property_mask)
+{
+ ir_graph *irg;
+
+ assert(is_method_entity(ent));
+
+ /* first check, if the graph exists */
+ irg = get_entity_irg(ent);
+ if (irg)
+ set_irg_additional_properties(irg, property_mask);
+ else {
+ /* do not allow to set the mtp_property_inherited flag or
+ * the automatic inheritance of flags will not work */
+ ent->attr.mtd_attr.irg_add_properties = property_mask & ~mtp_property_inherited;
+ }
+}
+
+void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties properties)
+{
+ ir_graph *irg;
+
+ assert(is_method_entity(ent));
+
+ /* first check, if the graph exists */
+ irg = get_entity_irg(ent);
+ if (irg)
+ add_irg_additional_properties(irg, properties);
+ else {
+ mtp_additional_properties mask = ent->attr.mtd_attr.irg_add_properties;
+
+ if (mask & mtp_property_inherited)
+ mask = get_method_additional_properties(get_entity_type(ent));
+
+ /* do not allow to set the mtp_property_inherited flag or
+ * the automatic inheritance of flags will not work */
+ ent->attr.mtd_attr.irg_add_properties = mask | (properties & ~mtp_property_inherited);
+ }
+}
+
+/* Returns the class type that this type info entity represents or NULL
+ if ent is no type info entity. */
+ir_type *(get_entity_repr_class)(const ir_entity *ent)
+{
+ return _get_entity_repr_class(ent);
+}
+
+dbg_info *(get_entity_dbg_info)(const ir_entity *ent)
+{
+ return _get_entity_dbg_info(ent);
+}
+
+void (set_entity_dbg_info)(ir_entity *ent, dbg_info *db)
+{
+ _set_entity_dbg_info(ent, db);
+}
+
+int entity_is_externally_visible(const ir_entity *entity)
+{
+ return get_entity_visibility(entity) != ir_visibility_local
+ || (get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER);
+}
+
+int entity_has_definition(const ir_entity *entity)
+{
+ return entity->initializer != NULL
+ || get_entity_irg(entity) != NULL
+ || entity_has_compound_ent_values(entity);
+}
+
+void ir_init_entity(void)
+{
+ assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
+ assert(!unknown_entity && "Call firm_init_entity() only once!");
+
+ unknown_entity = new_d_entity(NULL, new_id_from_str(UNKNOWN_ENTITY_NAME),
+ firm_unknown_type, NULL);
+ set_entity_visibility(unknown_entity, ir_visibility_external);
+ set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));
+}
+
+void ir_finish_entity(void)
+{
+ if (unknown_entity != NULL) {
+ free_entity(unknown_entity);
+ unknown_entity = NULL;
+ }
+}
+
+ir_allocation get_entity_allocation(const ir_entity *entity)
+{
+ return (ir_allocation)entity->allocation;
+}
+
+void set_entity_allocation(ir_entity *entity, ir_allocation allocation)
+{
+ entity->allocation = allocation;
+}
+
+ir_peculiarity get_entity_peculiarity(const ir_entity *entity)
+{
+ return (ir_peculiarity)entity->peculiarity;
+}
+
+void set_entity_peculiarity(ir_entity *entity, ir_peculiarity peculiarity)
+{
+ entity->peculiarity = peculiarity;
+}
+
+void set_entity_final(ir_entity *entity, int final)
+{
+ entity->final = final;
+}
+
+int is_entity_final(const ir_entity *entity)
+{
+ return entity->final;