X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcallgraph.h;h=514d74910bf8acf6cd2beeec4d3e1721e0646ea5;hb=ff0e8d7fcb34481652f0bf521ba04b1eca5e2106;hp=89fd0f1bf2a7c5b1c8002371d5cac2c66e1f88a5;hpb=e9af905ab778ca0572283c69bfa050069115d5d8;p=libfirm

diff --git a/ir/ana/callgraph.h b/ir/ana/callgraph.h
index 89fd0f1bf..514d74910 100644
--- a/ir/ana/callgraph.h
+++ b/ir/ana/callgraph.h
@@ -14,42 +14,119 @@
 #define _CALLGRAPH_H_
 
 /**
-* @file callgraph.h
-*
-*  This file contains defines the representation of the callgraph.
-*  The nodes of the call graph are ir_graphs.  The edges between
-*  The nodes are calling relation.  I.e., if method a calls method
-*  b at some point, there is an edge between a and b.
-*
-*  Further this file contains an algorithm to construct the call
-*  graph.  The construction of the callgraph uses the callee
-*  information in Call nodes to determine which methods are called.
-*
-*  Finally this file contains an algorithm that computes backedges
-*  in the callgraph, i.e., the algorithm finds possibly recursive calls.
-*  The algorithm computes an upper bound of all recursive calls.
-*
-*/
+ * @file callgraph.h
+ *
+ *  This file contains the representation of the callgraph.
+ *  The nodes of the call graph are ir_graphs.  The edges between
+ *  the nodes are calling relations.  I.e., if method a calls method
+ *  b at some point, there is an edge between a and b.
+ *
+ *  Further this file contains an algorithm to construct the call
+ *  graph.  The construction of the callgraph uses the callee
+ *  information in Call nodes to determine which methods are called.
+ *
+ *  Finally this file contains an algorithm that computes backedges
+ *  in the callgraph, i.e., the algorithm finds possibly recursive calls.
+ *  The algorithm computes an upper bound of all recursive calls.
+ *
+ */
 
 #include "irgraph.h"
 
+/** Flag to indicate state of callgraph. */
+typedef enum {
+  irp_callgraph_none,
+  irp_callgraph_consistent,   /* calltree is inconsistent */
+  irp_callgraph_inconsistent,
+  irp_callgraph_and_calltree_consistent
+} irp_callgraph_state;
+irp_callgraph_state get_irp_callgraph_state(void);
+void                set_irp_callgraph_state(irp_callgraph_state s);
+
 /** The functions that call irg. */
 int       get_irg_n_callers(ir_graph *irg);
 ir_graph *get_irg_caller(ir_graph *irg, int pos);
-/* int       is_irg_caller_backedge(ir_graph *irg, int pos);  not implemented */
+
+int       is_irg_caller_backedge(ir_graph *irg, int pos);
+int       has_irg_caller_backedge(ir_graph *irg);
+
+/** maximal loop depth of call nodes that call along this edge. */
+int       get_irg_caller_loop_depth(ir_graph *irg, int pos);
 
 /** The functions called by irg. */
 int       get_irg_n_callees(ir_graph *irg);
 ir_graph *get_irg_callee(ir_graph *irg, int pos);
+
 int       is_irg_callee_backedge(ir_graph *irg, int pos);
+int       has_irg_callee_backedge(ir_graph *irg);
 
+/** maximal loop depth of call nodes that call along this edge. */
+int       get_irg_callee_loop_depth(ir_graph *irg, int pos);
 
-/** Construct and destruct the callgraph. */
+/** Maximal loop depth of all paths from an external visible method to
+    this irg. */
+int       get_irg_loop_depth(ir_graph *irg);
+
+/** Maximal recursion depth of all paths from an external visible method to
+    this irg. */
+int       get_irg_recursion_depth(ir_graph *irg);
+
+double get_irg_method_execution_frequency (ir_graph *irg);
+
+/** Construct the callgraph. Expects callee information, i.e.,
+    irg_callee_info_consistent must be set.  This can be computed with
+    cgana(). */
 void compute_callgraph(void);
+/** Destruct the callgraph. */
 void free_callgraph(void);
 
-/** Compute the backedges that represent recursions. */
+
+/** A function type for fuctions passed to the callgraph walker. */
+typedef void callgraph_walk_func(ir_graph *g, void *env);
+
+void callgraph_walk(callgraph_walk_func *pre, callgraph_walk_func *post, void *env);
+
+/** Compute the backedges that represent recursions and a looptree.
+ */
 void find_callgraph_recursions(void);
 
+/** Compute interprocedural performance estimates.
+ *
+ *  Computes
+ *   - the loop depth of the method.
+ *     The loop depth of an edge between two methods is the
+ *     maximal loop depth of the Call nodes that call along this edge.
+ *     The loop depth of the method is the loop depth of the most expensive
+ *     path from main().
+ *   - The recursion depth.  The maximal number of recursions passed
+ *     on all paths reaching this method.
+ *   - The execution frequency.  As loop depth, but the edge weight is the sum
+ *     of the execution frequencies of all Calls along the edge.
+ **/
+void compute_performance_estimates(void);
+
+/** Computes the interprocedural loop nesting information.
+ *
+ * Computes two numbers for each irg:  the depth it is called in 'normal'
+ * loops and the depth of recursions it is in.
+ *
+ * Computes callee info and the callgraph if
+ * this information is not available.
+ */
+void analyse_loop_nesting_depth(void);
+
+/** State of loop nesting depth. */
+typedef enum {
+  loop_nesting_depth_none,             /**< Loop nesting depths are not computed, no memory is
+					    allocated, access fails. */
+  loop_nesting_depth_consistent,       /**< Loop nesting depth information is computed and correct. */
+  loop_nesting_depth_inconsistent      /**< Loop nesting depth is computed but the graphs have been
+					    changed since. */
+} loop_nesting_depth_state;
+
+loop_nesting_depth_state get_irp_loop_nesting_depth_state(void);
+void                     set_irp_loop_nesting_depth_state(loop_nesting_depth_state s);
+void                     set_irp_loop_nesting_depth_state_inconsistent(void);
+
 
 #endif /* _CALLGRAPH_H_ */