X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firloop.h;h=0e345c664c7918c1dc9402bc5509e692917de228;hb=ce17d46a38be4a88caf3d0a9e455b7ff04ab1668;hp=b7d1180f9dfa04c54e0c7deda0dae8b768626f09;hpb=1ec30d95387eb392ba5a1adc7958ebd91383d59c;p=libfirm diff --git a/include/libfirm/irloop.h b/include/libfirm/irloop.h index b7d1180f9..0e345c664 100644 --- a/include/libfirm/irloop.h +++ b/include/libfirm/irloop.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -23,18 +23,18 @@ * @author Goetz Lindenmaier * @date 7.2002 * @version $Id$ - * @summary + * @brief * Computes backedges in the control and data flow. * * @note * Only Block and Phi/Filter nodes can have incoming backedges. * Constructs loops data structure: indicates loop nesting. */ -# ifndef FIRM_ANA_IRLOOP_H -# define FIRM_ANA_IRLOOP_H +#ifndef FIRM_ANA_IRLOOP_H +#define FIRM_ANA_IRLOOP_H -# include "irgraph.h" -# include "irnode.h" +#include "firm_types.h" +#include "firm_common.h" /* ------------------------------------------------------------------- */ /* @@ -48,28 +48,29 @@ */ /* ------------------------------------------------------------------- */ -/** Returns true if the predecessor pos is a backedge in the interprozeduralem view. */ +#ifdef INTERPROCEDURAL_VIEW +/** Returns true if the predecessor pos is a backedge in the interprocedural view. */ int is_inter_backedge(ir_node *n, int pos); /** Returns true if the predecessor pos is a backedge in the intraprocedural view. */ int is_intra_backedge(ir_node *n, int pos); +#endif /** Returns non-zero if the predecessor pos is a backedge. */ -int is_backedge (ir_node *n, int pos); +int is_backedge(ir_node *n, int pos); /** Marks edge pos as a backedge. */ -void set_backedge (ir_node *n, int pos); +void set_backedge(ir_node *n, int pos); /** Marks edge pos as a non-backedge. */ -void set_not_backedge (ir_node *n, int pos); +void set_not_backedge(ir_node *n, int pos); /** Returns non-zero if n has backedges. */ -int has_backedges (ir_node *n); +int has_backedges(ir_node *n); /** Clears all backedge information. */ -void clear_backedges (ir_node *n); - - +void clear_backedges(ir_node *n); /** 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 */ - ir_loop *son; /**< Pointer to an ir_loop element */ + firm_kind *kind; /**< is either k_ir_node or k_ir_loop */ + ir_node *node; /**< Pointer to an ir_node element */ + ir_loop *son; /**< Pointer to an ir_loop element */ + ir_graph *irg; /**< Pointer to an ir_graph element (only callgraph loop trees) */ } loop_element; int is_ir_loop(const void *thing); @@ -78,51 +79,50 @@ int is_ir_loop(const void *thing); 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); +ir_loop *get_irg_loop(const ir_graph *irg); /** Returns the loop n is contained in. NULL if node is in no loop. */ ir_loop *get_irn_loop(const ir_node *n); /** Returns outer loop, itself if outermost. */ -ir_loop *get_loop_outer_loop (const ir_loop *loop); +ir_loop *get_loop_outer_loop(const ir_loop *loop); /** Returns nesting depth of this loop */ -int get_loop_depth (const ir_loop *loop); +int get_loop_depth(const ir_loop *loop); /* Sons are the inner loops contained in this loop. */ /** Returns the number of inner loops */ -int get_loop_n_sons (const ir_loop *loop); +int get_loop_n_sons(const 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 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); +int get_loop_n_nodes(const 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 NULL if there is not a pos`th ir_node. */ +ir_node *get_loop_node(const ir_loop *loop, int pos); /** Returns the number of elements contained in loop. */ -int get_loop_n_elements (const ir_loop *loop); +int get_loop_n_elements(const ir_loop *loop); /** Returns a loop element. A loop element can be interpreted as a - kind pointer, an ir_node* or an ir_loop*. */ -loop_element get_loop_element (const ir_loop *loop, int pos); +kind pointer, an ir_node* or an ir_loop*. */ +loop_element get_loop_element(const 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(const ir_loop *loop, void *le); /** Returns a unique node number for the loop node to make output - readable. If libfirm_debug is not set it returns the loop cast to - int. */ +readable. If libfirm_debug is not set it returns the loop cast to +int. */ int get_loop_loop_nr(const 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); +/** A field to connect additional information to a loop. */ +void set_loop_link(ir_loop *loop, void *link); +void *get_loop_link(const ir_loop *loop); /* ------------------------------------------------------------------- */ /* Constructing and destructing the loop/backedge information. */ @@ -151,6 +151,7 @@ void *get_loop_link (const ir_loop *loop); /* @@@ Well, maybe construct_loop_information or analyze_loops ? */ int construct_backedges(ir_graph *irg); +#ifdef INTERPROCEDURAL_VIEW /** Constructs backedges for all irgs in interprocedural view. * * @see As construct_backedges(), but for interprocedural view. @@ -162,39 +163,52 @@ int construct_backedges(ir_graph *irg); * function return and the second call. * * @returns Maximal depth of loop tree. -*/ + */ int construct_ip_backedges(void); +#endif -/** Construct loop tree only for control flow. +/** + * Construct Intra-procedural control flow loop tree for a IR-graph. * - * 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 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. + * This algorithm computes only back edge information for Block nodes, not + * for Phi nodes. * - * This algorithm destoyes the link field of block nodes. + * This algorithm destroyes the link field of block nodes. + * + * @param irg the graph * * @returns Maximal depth of loop tree. */ int construct_cf_backedges(ir_graph *irg); -/** Construct interprocedural loop tree for control flow. +/** + * Computes Intra-procedural control flow loop tree on demand. * - * @see construct_cf_backedges() and construct_ip_backedges(). + * @param irg the graph */ -int construct_ip_cf_backedges (void); +void assure_cf_loop(ir_graph *irg); -/** Removes all loop information. - * Resets all backedges. Works for any construction algorithm. +#ifdef INTERPROCEDURAL_VIEW +/** + * Construct Inter-procedural control flow loop tree. + * + * @see construct_cf_backedges() and construct_ip_backedges(). + */ +int construct_ip_cf_backedges(void); +#endif + +/** + * Removes all loop information. + * Resets all backedges. Works for any construction algorithm. */ void free_loop_information(ir_graph *irg); void free_all_loop_information (void); - - /* ------------------------------------------------------------------- */ /* Simple analyses based on the loop information */ /* ------------------------------------------------------------------- */ @@ -206,6 +220,6 @@ void free_all_loop_information (void); * * 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); +int is_loop_invariant(const ir_node *n, const ir_node *block); #endif