X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firloop.h;h=48bb1752208b78c685b35793a6edfcab3a740545;hb=f274dcf35aa0d3f4748387dbddfe50e8d7d44951;hp=f84547dc77925531815fb8df0d3d3f940cbd530a;hpb=c19953ed6384686c23fb9d720a7cfdda3d443d19;p=libfirm diff --git a/ir/ana/irloop.h b/ir/ana/irloop.h index f84547dc7..48bb17522 100644 --- a/ir/ana/irloop.h +++ b/ir/ana/irloop.h @@ -42,13 +42,14 @@ /** 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); +/** Returns non-zero if the predecessor pos is a backedge. */ +int is_backedge (ir_node *n, int pos); /** Remarks that edge pos is a backedge. */ void set_backedge (ir_node *n, int pos); /** Remarks that edge pos is not a backedge. */ void set_not_backedge (ir_node *n, int pos); -/** Returns true if n has backedges. */ -bool has_backedges (ir_node *n); +/** Returns non-zero if n has backedges. */ +int has_backedges (ir_node *n); /** Sets backedge information to zero. */ void clear_backedges (ir_node *n); @@ -70,9 +71,12 @@ void clear_backedges (ir_node *n); * this would cost a lot of memory, though. */ /* ------------------------------------------------------------------- */ +#ifndef _IR_LOOP_TYPEDEF_ +#define _IR_LOOP_TYPEDEF_ typedef struct ir_loop ir_loop; +#endif -/* Loop elements are loop nodes and ir nodes */ +/** Loop elements: loop nodes and ir nodes */ typedef union { firm_kind *kind; /**< is either k_ir_node or k_ir_loop */ ir_node *node; /**< Pointer to an ir_node element */ @@ -83,6 +87,8 @@ 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); + +/* Returns the root loop info (if exists) for an irg. */ ir_loop *get_irg_loop(ir_graph *irg); /** Returns the loop n is contained in. NULL if node is in no loop. */ @@ -96,9 +102,16 @@ int get_loop_depth (ir_loop *loop); /* Sons are the inner loops contained in this loop. */ /** Returns the number of inner loops */ int get_loop_n_sons (ir_loop *loop); + +/** Returns the pos`th son loop (inner loop) of a loop. + Returns NULL if there is not a pos`th loop_node. */ ir_loop *get_loop_son (ir_loop *loop, int pos); + /** Returns the number of nodes contained in loop. */ int get_loop_n_nodes (ir_loop *loop); + +/** Returns the pos`th ir_node of a loop. + Returns NULL if there is not a pos`th ir_node. */ ir_node *get_loop_node (ir_loop *loop, int pos); /** Returns the number of elements contained in loop. */ @@ -108,7 +121,7 @@ int get_loop_n_elements (ir_loop *loop); loop_element get_loop_element (ir_loop *loop, int pos); /** Returns the element number of the loop son in loop. - * Returns -1 if not found. O(#elements). */ + * Returns -1 if not found. O(|elements|). */ int get_loop_element_pos(ir_loop *loop, void *le); /** Returns a unique node number for the loop node to make output @@ -125,10 +138,16 @@ void *get_loop_link (const ir_loop *loop); /* Constructing and destructing the loop/backedge information. */ /* ------------------------------------------------------------------- */ -/** Constructs backedge information for irg in intraprocedural view. +/** Constructs backedge information and loop tree for a graph in intraprocedural view. + * + * The algorithm views the program representation as a pure graph. + * It assumes that only block and phi nodes may be loop headers. + * The resulting loop tree is a possible visiting order for dataflow + * analysis. + * * @returns Maximal depth of loop tree. * - * ATTENTION: + * @remark * One assumes, the Phi nodes in a block with a backedge have backedges * at the same positions as the block. This is not the case, as * the scc algorithms does not respect the program semantics in this case. @@ -140,21 +159,41 @@ void *get_loop_link (const ir_loop *loop); /* @@@ Well, maybe construct_loop_information or analyze_loops ? */ 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. - * @returns Maximal depth of loop tree. */ +/** Constructs backedges for all irgs in interprocedural view. + * + * @see As construct_backedges(), but for interprocedural view. + * + * @remark + * 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. + * + * @returns Maximal depth of loop tree. +*/ int construct_ip_backedges(void); -/* Construct loop tree only for control flow. +/** Construct loop tree only for control flow. + * + * This constructs loop information resembling the program structure. + * It is useful for loop optimizations and analyses, as, e.g., finding + * iteration variables or loop invariant code motion. + * + * This algorithm computes only back edge information for Block nodes, not + * for Phi nodes. + * * @returns Maximal depth of loop tree. */ int construct_cf_backedges(ir_graph *irg); + +/** Construct interprocedural loop tree for control flow. + * + * @see construct_cf_backedges() and construct_ip_backedges(). + */ int construct_ip_cf_backedges (void); /** Removes all loop information. - Resets all backedges */ + * Resets all backedges. Works for any construction algorithm. + */ void free_loop_information(ir_graph *irg); void free_all_loop_information (void); @@ -170,7 +209,7 @@ void free_all_loop_information (void); * @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 + * Returns non-zero, 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);