+/* 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);
+
+/** Initializes the entity ent which 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);