extended functionality

[libfirm] / ir / ana / irloop.h

diff --git a/ir/ana/irloop.h b/ir/ana/irloop.h
index a8bf5da..ce55201 100644 (file)
--- a/ir/ana/irloop.h
+++ b/ir/ana/irloop.h
@@ -27,9 +27,7 @@
 # include "irgraph.h"
 # include "irnode.h"
 
-
-/* @@@ Interprocedural backedges ... ???? */
-
+/* ------------------------------------------------------------------- */
 /*
  * Backedge information.
  *
@@ -39,8 +37,11 @@
  * The backedge information can only be used if the graph is not in
  * phase phase_building.
  */
+/* ------------------------------------------------------------------- */
 
 /** Returns true if the predesessor pos is a backedge. */
+int  is_inter_backedge(ir_node *n, int pos);
+int  is_intra_backedge(ir_node *n, int pos);
 bool is_backedge (ir_node *n, int pos);
 /** Remarks that edge pos is a backedge. */
 void set_backedge (ir_node *n, int pos);
@@ -51,6 +52,7 @@ bool has_backedges (ir_node *n);
 /** Sets backedge information to zero. */
 void clear_backedges (ir_node *n);
 
+/* ------------------------------------------------------------------- */
 /**
  * The loops datastructure.
  *
@@ -67,6 +69,7 @@ void clear_backedges (ir_node *n);
  * @todo We could add a field pointing from a node to the containing loop,
  * this would cost a lot of memory, though.
  */
+/* ------------------------------------------------------------------- */
 typedef struct ir_loop ir_loop;
 
 /* Loop elements are loop nodes and ir nodes */
@@ -76,6 +79,9 @@ typedef union {
     ir_loop *son;       /**< Pointer to an ir_loop element */
 } loop_element;
 
+int      is_ir_loop(const void *thing);
+
+/** Set the outermost loop in ir graph as basic access to loop tree. */
 void     set_irg_loop(ir_graph *irg, ir_loop *l);
 ir_loop *get_irg_loop(ir_graph *irg);
 
@@ -106,28 +112,57 @@ loop_element get_loop_element (ir_loop *loop, int pos);
 int get_loop_element_pos(ir_loop *loop, void *le);
 
 /** Returns a unique node number for the loop node to make output
-    readable. */
+    readable. If libfirm_debug is not set it returns the loop cast to
+    int. */
 int get_loop_loop_nr(ir_loop *loop);
 
+/** A field to connect additional information to a loop.  Only valid
+    if libfirm_debug is set, else returns NULL.  */
+void  set_loop_link (ir_loop *loop, void *link);
+void *get_loop_link (const ir_loop *loop);
 
-/*
- * Constructing and destructing the loop/backedge information.
- */
+/* ------------------------------------------------------------------- */
+/* Constructing and destructing the loop/backedge information.         */
+/* ------------------------------------------------------------------- */
 
-/** Constructs backedge information for irg in intraprocedural view. */
+/** Constructs backedge information for irg in intraprocedural view.
+ *  @returns Maximal depth of loop tree. */
 /* @@@ Well, maybe construct_loop_information or analyze_loops ? */
-void construct_backedges(ir_graph *irg);
+int construct_backedges(ir_graph *irg);
 
 /** Constructs backedges for all irgs in interprocedural view.  All
     loops in the graph will be marked as such, not only realizeable
     loops and recursions in the program.  E.g., if the same funcion is
     called twice, there is a loop between the first function return and
-    the second call.  */
-void construct_ip_backedges(void);
+    the second call.
+ *  @returns Maximal depth of loop tree. */
+int construct_ip_backedges(void);
+
+/* Construct loop tree only for control flow.
+ * @returns Maximal depth of loop tree. */
+int construct_cf_backedges(ir_graph *irg);
+int construct_ip_cf_backedges (void);
 
 /** Removes all loop information.
     Resets all backedges */
 void free_loop_information(ir_graph *irg);
 void free_all_loop_information (void);
 
+
+
+
+/* ------------------------------------------------------------------- */
+/* Simple analyses based on the loop information                       */
+/* ------------------------------------------------------------------- */
+
+/** Test whether a value is loop invariant.
+ *
+ * @param n      The node to be tested.
+ * @param block  A block node.
+ *
+ * Returns true, if the node n is not changed in the loop block
+ * belongs to or in inner loops of this block. */
+int is_loop_invariant(ir_node *n, ir_node *block);
+
+
 #endif /* _IRLOOP_H_ */