+/* -- Fields of method entities -- */
+/** The entity knows the corresponding irg if the entity is a method.
+ This allows to get from a Call to the called irg.
+ Only entities of peculiarity "existent" can have a corresponding irg,
+ else the field is fixed to NULL. (Get returns NULL, set asserts.) */
+ir_graph *get_entity_irg(const entity *ent);
+void set_entity_irg(entity *ent, ir_graph *irg);
+
+/** Return the peculiarity of an entity. */
+peculiarity get_entity_peculiarity (const entity *ent);
+
+/** Sets the peculiarity of an entity. */
+void set_entity_peculiarity (entity *ent, peculiarity pec);
+
+/** Return the name of the peculiarity. */
+const char *get_peculiarity_name(peculiarity var);
+
+/* -- Representation of constant values of entites -- */
+/** Returns true if the the node is representable as code on
+ * const_code_irg. */
+int is_irn_const_expression(ir_node *n);
+/* Set current_ir_graph to get_const_code_irg() to generate a constant
+ expression. */
+
+/**
+ * Copies a firm subgraph that complies to the restrictions for
+ * constant expressions to current_block in current_ir_graph.
+ */
+ir_node *copy_const_value(ir_node *n);
+
+/* Set has no effect for existent entities of type method. */
+ir_node *get_atomic_ent_value(entity *ent);
+void set_atomic_ent_value(entity *ent, ir_node *val);
+
+/* The following type describes a path to a leave in the compound graph.
+ Node 0 in the path must be an entity of type tp given in the constructor. If
+ the type of this element is compound, the path node 1 is an element of the type
+ of node 0 an so forth, until an entity of atomic type is reached. */
+#ifndef _COMPOUND_GRAPH_PATH_TYPEDEF_
+#define _COMPOUND_GRAPH_PATH_TYPEDEF_
+typedef struct compound_graph_path compound_graph_path;
+#endif /* _COMPOUND_GRAPH_PATH_TYPEDEF_ */
+compound_graph_path *new_compound_graph_path(type *tp, int length);
+int is_compound_graph_path(void *thing);
+void free_compound_graph_path (compound_graph_path *gr);
+int get_compound_graph_path_length(compound_graph_path *gr);
+entity *get_compound_graph_path_node(compound_graph_path *gr, int pos);
+void set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node);
+int get_compound_graph_path_array_index(compound_graph_path *gr, int pos);
+void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
+
+/** Checks whether the path up to pos is correct. If the path contains a NULL,
+ * assumes the path is not complete and returns 'true'. */
+int is_proper_compound_graph_path(compound_graph_path *gr, int pos);
+
+/* A value of a compound entity is a pair of a value and the description of the
+ corresponding access path to the member of the compound. */
+void add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path);
+void set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos);
+/** Returns the number of constant values needed to initialize the entity.
+ *
+ * Asserts if the entity has variability_uninitialized.
+ * */
+int get_compound_ent_n_values(entity *ent);
+/** Returns a constant value given the position. */
+ir_node *get_compound_ent_value(entity *ent, int pos);
+/** Returns the access path for value at position pos. */
+compound_graph_path *get_compound_ent_value_path(entity *ent, int pos);
+/** Returns the position of a value with the given path.
+ * The path must contain array indicees for all array element entities. */
+int get_compound_ent_pos_by_path(entity *ent, compound_graph_path *path);
+/** Returns a constant value given the access path.
+ * The path must contain array indicees for all array element entities. */
+ir_node *get_compound_ent_value_by_path(entity *ent, compound_graph_path *path);
+
+/** Removes all constant entries where the path ends at value_ent. Does not
+ free the memory of the paths. (The same path might be used for several
+ constant entities. */
+void remove_compound_ent_value(entity *ent, entity *value_ent);
+
+/* Some languages support only trivial access paths, i.e., the member is a
+ direct, atomic member of the constant entities type. In this case the
+ corresponding entity can be accessed directly. The following functions
+ allow direct access. */
+
+/** generates a Path with length 1 */
+void add_compound_ent_value(entity *ent, ir_node *val, entity *member);
+
+/** Returns the last member in the path */
+entity *get_compound_ent_value_member(entity *ent, int pos);
+
+/** Sets the path at pos 0 */
+void set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
+
+/** Inits the entity ent witch must be of a one dimensional
+ array type with the values given in the values array.
+ The array must have a lower and an upper bound. Keeps the
+ order of values. Does not test whether the number of values
+ fits into the given array size. Does not test whether the
+ values have the proper mode for the array. */
+void set_array_entity_values(entity *ent, tarval **values, int num_vals);
+
+/** Return the overall offset of value at position pos in bits.
+ *
+ * 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_bits(entity *ent, int pos);
+
+/** Return the overall offset of value at position pos in bytes.
+ *
+ * This requires that the layout of all concerned types is fixed.
+ * Asserts if bit offset is not byte aligned.
+ *
+ * @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_bytes(entity *ent, int pos);
+
+/** Compute the array indicees in compound graph paths of initialized entities.
+ *
+ * All arrays must have fixed lower and upper bounds. One array can
+ * have an open upper bound. If there are several open bounds, we do
+ * nothing. There must be initializer elements for all array
+ * elements. Uses the link field in the array element entities. The
+ * array bounds must be representable as ints.
+ *
+ * @param ent Any entity.
+ */
+void compute_compound_ent_array_indicees(entity *ent);
+
+/** Sort the values of the compound entity by their overall offset.
+ *
+ * This requires that the layout of all concerned types is fixed.
+ * If the entity has no initialization information the method just
+ * returns. This is needed to dump the entity in a backend.
+ *
+ * @param ent Any entity.
+ */
+void sort_compound_ent_values(entity *ent);
+
+
+/* --- Fields of entities with a class type as owner --- */