+is_frame_type(type *ftp) {
+ int i;
+ if (is_class_type(ftp)) {
+ for (i = 0; i < get_irp_n_irgs(); i++) {
+ type *frame_tp = get_irg_frame_type(get_irp_irg(i));
+ if (ftp == frame_tp) return true;
+ }
+ }
+ return false;
+}
+
+int
+get_irg_n_locs (ir_graph *irg)
+{
+#if PRECISE_EXC_CONTEXT
+ return irg->n_loc - 1 - 1;
+#else
+ return irg->n_loc - 1;
+#endif
+}
+
+void
+set_irg_n_loc (ir_graph *irg, int n_loc)
+{
+#if PRECISE_EXC_CONTEXT
+ irg->n_loc = n_loc + 1 + 1;
+#else
+ irg->n_loc = n_loc + 1;
+#endif
+}
+
+
+
+/* Returns the obstack associated with the graph. */
+struct obstack *get_irg_obstack(ir_graph *irg) {
+ return irg->obst;
+}
+
+/*
+ * Returns true if the node n is allocated on the storage of graph irg.
+ *
+ * Implementation is GLIBC specific as is uses the internal _obstack_chunk implementation.
+ */
+int node_is_in_irgs_storage(ir_graph *irg, ir_node *n)
+{
+ struct _obstack_chunk *p;
+
+ /*
+ * checks wheater the ir_node pointer i on the obstack.
+ * A more sophisticated check would test the "whole" ir_node
+ */
+ for (p = irg->obst->chunk; p; p = p->prev) {
+ if (((char *)p->contents <= (char *)n) && ((char *)n < (char *)p->limit))
+ return 1;
+ }
+
+ return 0;
+}
+
+irg_phase_state
+get_irg_phase_state (ir_graph *irg) {
+ return irg->phase_state;
+}
+
+void
+set_irg_phase_low(ir_graph *irg) {
+ irg->phase_state = phase_low;
+}
+
+op_pinned
+get_irg_pinned (ir_graph *irg) {
+ return irg->pinned;
+}
+
+irg_outs_state
+get_irg_outs_state(ir_graph *irg) {
+ return irg->outs_state;
+}
+
+void
+set_irg_outs_inconsistent(ir_graph *irg) {
+ irg->outs_state = outs_inconsistent;
+}
+
+irg_dom_state
+get_irg_dom_state(ir_graph *irg) {
+ return irg->dom_state;
+}
+
+void
+set_irg_dom_inconsistent(ir_graph *irg) {
+ irg->dom_state = dom_inconsistent;
+}
+
+irg_loopinfo_state
+get_irg_loopinfo_state(ir_graph *irg) {
+ return irg->loopinfo_state;
+}
+
+void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s) {
+ irg->loopinfo_state = s;
+}
+
+void
+set_irg_loopinfo_inconsistent(ir_graph *irg) {
+ if (irg->loopinfo_state == loopinfo_ip_consistent)
+ irg->loopinfo_state = loopinfo_ip_inconsistent;
+ else
+ irg->loopinfo_state = loopinfo_inconsistent;
+}
+
+INLINE void
+set_irg_pinned (ir_graph *irg, op_pinned p) {
+ irg->pinned = p;
+}
+
+
+irg_callee_info_state get_irg_callee_info_state(ir_graph *irg) {
+ return irg->callee_info_state;
+}
+
+void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s) {
+ irg->callee_info_state = s;
+}
+
+irg_inline_property get_irg_inline_property(ir_graph *irg) {
+ return irg->inline_property;
+}
+void set_irg_inline_property(ir_graph *irg, irg_inline_property s) {
+ irg->inline_property = s;
+}
+
+
+INLINE void
+set_irg_link (ir_graph *irg, void *thing) {
+ irg->link = thing;
+}
+
+INLINE void *
+get_irg_link (ir_graph *irg) {
+ return irg->link;
+}
+
+/* maximum visited flag content of all ir_graph visited fields. */
+static int max_irg_visited = 0;
+
+unsigned long
+get_irg_visited (ir_graph *irg)
+{
+ return irg->visited;
+}
+
+void
+set_irg_visited (ir_graph *irg, unsigned long visited)
+{
+ irg->visited = visited;
+ if (irg->visited > max_irg_visited) {
+ max_irg_visited = irg->visited;
+ }
+}
+
+void
+inc_irg_visited (ir_graph *irg)
+{
+ if (++irg->visited > max_irg_visited) {
+ max_irg_visited = irg->visited;
+ }
+}
+
+unsigned long
+get_max_irg_visited(void)
+{
+ /*
+ int i;
+ for(i = 0; i < get_irp_n_irgs(); i++)
+ assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
+ */
+ return max_irg_visited;
+}
+
+void set_max_irg_visited(int val) {
+ max_irg_visited = val;
+}
+
+unsigned long
+inc_max_irg_visited(void)
+{
+ /*
+ int i;
+ for(i = 0; i < get_irp_n_irgs(); i++)
+ assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
+ */
+ max_irg_visited++;
+ return max_irg_visited;
+}
+
+unsigned long
+get_irg_block_visited (ir_graph *irg)
+{
+ return irg->block_visited;
+}
+
+void
+set_irg_block_visited (ir_graph *irg, unsigned long visited)