Skip to content

GitLab

Commit 0ed495da authored by Matthias Braun's avatar Matthias Braun
Browse files

irdom: move some functions to private API

parent 02f098c9
Hide whitespace changes
Inline Side-by-side
include/libfirm/irdom.h
View file @ 0ed495da
......@@ -49,54 +49,51 @@
* @{
*/
/** Accessing the dominator data structure.
/** return immediate dominator of block */
FIRM_API ir_node *get_Block_idom(const ir_node *block);
/** return immediate postdominator of a block */
FIRM_API ir_node *get_Block_ipostdom(const ir_node *block);
/**
* Check, if a block dominates another block.
*
* These routines only work properly if the ir_graph is in state
* dom_consistent or dom_inconsistent.
* @param a The potential dominator block.
* @param b The potentially dominated block.
*
* If the block is not reachable from Start, returns a Bad node.
* @return 1, if @p a dominates @p b, else 0.
*/
FIRM_API ir_node *get_Block_idom(const ir_node *bl);
FIRM_API void set_Block_idom(ir_node *bl, ir_node *n);
FIRM_API int get_Block_dom_depth(const ir_node *bl);
FIRM_API void set_Block_dom_depth(ir_node *bl, int depth);
FIRM_API int get_Block_dom_pre_num(const ir_node *bl);
FIRM_API void set_Block_dom_pre_num(ir_node *bl, int num);
FIRM_API int block_dominates(const ir_node *a, const ir_node *b);
/** Accessing the post dominator data structure.
/**
* Check, if a block strictly dominates another block, i.e. a != b.
*
* These routines only work properly if the ir_graph is in state
* dom_consistent or dom_inconsistent.
* @param a The potential dominator block.
* @param b The potentially dominated block.
*
* @return 1, if @p a strictly dominates @p b, else 0.
*/
FIRM_API ir_node *get_Block_ipostdom(const ir_node *bl);
FIRM_API void set_Block_ipostdom(ir_node *bl, ir_node *n);
FIRM_API int get_Block_postdom_depth(const ir_node *bl);
FIRM_API void set_Block_postdom_depth(ir_node *bl, int depth);
FIRM_API int get_Block_postdom_pre_num(const ir_node *bl);
FIRM_API void set_Block_postdom_pre_num(ir_node *bl, int num);
FIRM_API int block_strictly_dominates(const ir_node *a, const ir_node *b);
/**
* Get the pre-order number of a block resulting from a
* Depth-First-Search walkover the dominator tree.
* Check, if a block post dominates another block.
*
* @param bl The block.
* @return The pre-order number.
* @param a The potential post dominator block.
* @param b The potentially post dominated block.
*
* @return 1, if @p a post dominates @p b, else 0.
*/
FIRM_API unsigned get_Block_dom_tree_pre_num(const ir_node *bl);
FIRM_API unsigned get_Block_pdom_tree_pre_num(const ir_node *bl);
FIRM_API int block_postdominates(const ir_node *a, const ir_node *b);
/**
* Get the largest pre-order number found in the subtree of the
* dominator tree rooted at a given block.
* @param bl The block.
* @return The largest pre-order number of block's dominator subtree.
* Check, if a block strictly post dominates another block, i.e. a != b.
*
* @param a The potential post dominator block.
* @param b The potentially post dominated block.
*
* @return 1, if @p a strictly post dominates @p b, else 0.
*/
FIRM_API unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl);
FIRM_API unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl);
FIRM_API int block_strictly_postdominates(const ir_node *a, const ir_node *b);
/**
* Get the first node in the list of nodes dominated by a given block.
......@@ -109,7 +106,10 @@ FIRM_API unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl);
* @param bl The block for which to get the first node dominated by @c bl.
* @return The first node dominated by @p bl.
*/
FIRM_API ir_node *get_Block_dominated_first(const ir_node *bl);
FIRM_API ir_node *get_Block_dominated_first(const ir_node *block);
/**
* Get the first node in the list of nodes postdominated by a given blcok.
*/
FIRM_API ir_node *get_Block_postdominated_first(const ir_node *bl);
/**
......@@ -119,8 +119,11 @@ FIRM_API ir_node *get_Block_postdominated_first(const ir_node *bl);
* @param dom The previous node.
* @return The next node in this list or NULL if it was the last.
*/
FIRM_API ir_node *get_Block_dominated_next(const ir_node *dom);
FIRM_API ir_node *get_Block_postdominated_next(const ir_node *dom);
FIRM_API ir_node *get_Block_dominated_next(const ir_node *node);
/**
* Get the next node in a list of nodes which are postdominated by another node
*/
FIRM_API ir_node *get_Block_postdominated_next(const ir_node *node);
/**
* Iterate over all nodes which are immediately dominated by a given
......@@ -142,26 +145,6 @@ FIRM_API ir_node *get_Block_postdominated_next(const ir_node *dom);
for(curr = get_Block_postdominated_first(bl); curr; \
curr = get_Block_postdominated_next(curr))
/**
* Check, if a block dominates another block.
*
* @param a The potential dominator block.
* @param b The potentially dominated block.
*
* @return 1, if @p a dominates @p b, else 0.
*/
FIRM_API int block_dominates(const ir_node *a, const ir_node *b);
/**
* Check, if a block strictly dominates another block, i.e. a != b.
*
* @param a The potential dominator block.
* @param b The potentially dominated block.
*
* @return 1, if @p a strictly dominates @p b, else 0.
*/
FIRM_API int block_strictly_dominates(const ir_node *a, const ir_node *b);
/**
* Returns the smallest common dominator block of two nodes.
* @param a A node.
......@@ -170,41 +153,6 @@ FIRM_API int block_strictly_dominates(const ir_node *a, const ir_node *b);
*/
FIRM_API ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b);
/**
* Returns the smallest common dominator block of all users of a node
* BEWARE: @p irn must not be a block
* If on or more users are Phi nodes, one can request special handling
* with @p handle_phi = 1. In this case the cfg predecessor block
* corresponding to the position of the irn in the argument list of the
* Phi is determined and treated as user.
*
* @param irn A node.
* @param handle_phi 1 if Phis should be handled different
* @return The first block dominating all users of @p irn
*/
FIRM_API ir_node *node_users_smallest_common_dominator(ir_node *irn,
int handle_phi);
/**
* Check, if a block post dominates another block.
*
* @param a The potential post dominator block.
* @param b The potentially post dominated block.
*
* @return 1, if @p a post dominates @p b, else 0.
*/
FIRM_API int block_postdominates(const ir_node *a, const ir_node *b);
/**
* Check, if a block strictly post dominates another block, i.e. a != b.
*
* @param a The potential post dominator block.
* @param b The potentially post dominated block.
*
* @return 1, if @p a strictly post dominates @p b, else 0.
*/
FIRM_API int block_strictly_postdominates(const ir_node *a, const ir_node *b);
/**
* Visit all nodes in the dominator subtree of a given node.
* Call a pre-visitor before descending to the children and call a
......@@ -249,9 +197,7 @@ FIRM_API void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
FIRM_API void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
irg_walk_func *post, void *env);
/* ------------ Building and Removing the dominator data structure ----------- */
/** Computes the dominator trees.
/** Computes the dominance relation for all basic blocks of a given graph.
*
* Sets a flag in irg to "dom_consistent".
* If the control flow of the graph is changed this flag must be set to
......@@ -268,10 +214,10 @@ FIRM_API void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
*/
FIRM_API void compute_doms(ir_graph *irg);
/** Computes the dominator trees on demand, @see compute_doms(). */
/** Recomputes dominator relation of a graph if necessary */
FIRM_API void assure_doms(ir_graph *irg);
/** Computes the post dominator trees.
/** Computes the post dominance relation for all basic blocks of a given graph.
*
* Sets a flag in irg to "dom_consistent".
* If the control flow of the graph is changed this flag must be set to
......@@ -288,15 +234,14 @@ FIRM_API void assure_doms(ir_graph *irg);
*/
FIRM_API void compute_postdoms(ir_graph *irg);
/** Computes the dominator trees on demand */
/** Recompute postdominance relation if necessary */
FIRM_API void assure_postdoms(ir_graph *irg);
/** Frees the dominator data structures. Sets the flag in irg to "dom_none". */
/** Frees the dominance data structures. Sets the flag in irg to "dom_none". */
FIRM_API void free_dom(ir_graph *irg);
/**
* Frees the post dominator data structures.
* Sets the flag in irg to "dom_none".
* Frees the postdominance data structures. Sets the flag in irg to "dom_none".
*/
FIRM_API void free_postdom(ir_graph *irg);
......
ir/ana/cdep.c
View file @ 0ed495da
......@@ -24,7 +24,7 @@
*/
#include <assert.h>
#include <stdlib.h>
#include "irdom.h"
#include "irdom_t.h"
#include "irgraph.h"
#include "irgwalk.h"
#include "irnode.h"
......
ir/ana/dfs.c
View file @ 0ed495da
......@@ -33,7 +33,7 @@
#include <assert.h>
#include "irprintf.h"
#include "irdom.h"
#include "irdom_t.h"
#include "set.h"
#include "statev.h"
#include "dfs_t.h"
......
ir/ana/irdom.c
View file @ 0ed495da
......@@ -225,62 +225,6 @@ ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b)
return dom_bl;
}
ir_node *node_users_smallest_common_dominator(ir_node *irn, int handle_phi)
{
int n, j, i = 0, success;
ir_node **user_blocks, *dom_bl;
const ir_edge_t *edge;
assert(! is_Block(irn) && "WRONG USAGE of node_users_smallest_common_dominator");
assert(edges_activated(get_irn_irg(irn)) && "need edges activated");
n = get_irn_n_edges(irn);
/* get array to hold all block of the node users */
NEW_ARR_A(ir_node *, user_blocks, n);
foreach_out_edge(irn, edge) {
ir_node *src = get_edge_src_irn(edge);
if (is_Phi(src) && handle_phi) {
/* get the corresponding cfg predecessor block if phi handling requested */
j = get_edge_src_pos(edge);
assert(j >= 0 && "kaputt");
user_blocks[i++] = get_Block_cfgpred_block(get_nodes_block(src), j);
}
else
user_blocks[i++] = is_Block(src) ? src : get_nodes_block(src);
}
assert(i == n && "get_irn_n_edges probably broken");
/* in case of only one user: return the block of the user */
if (n == 1)
return user_blocks[0];
i = 0;
/* search the smallest block dominating all user blocks */
do {
dom_bl = node_smallest_common_dominator(user_blocks[i], user_blocks[i + 1]);
success = 1;
/* check if this block dominates all remaining blocks as well */
for (j = i + 2; j < n; j++) {
if (! block_dominates(dom_bl, user_blocks[j]))
success = 0;
}
if (success)
break;
/* inherit the dominator block of the first (i + 1) users */
user_blocks[++i] = dom_bl;
} while (i < n - 1);
assert(success && "no block found dominating all users");
return dom_bl;
}
/* Get the first node in the list of nodes dominated by a given block. */
ir_node *get_Block_dominated_first(const ir_node *bl)
{
......
ir/ana/irdom_t.h
View file @ 0ed495da
......@@ -42,4 +42,26 @@ typedef struct ir_dom_info {
int dom_depth; /**< depth in dominator-tree */
} ir_dom_info;
void set_Block_idom(ir_node *bl, ir_node *n);
int get_Block_dom_depth(const ir_node *bl);
void set_Block_dom_depth(ir_node *bl, int depth);
int get_Block_dom_pre_num(const ir_node *bl);
void set_Block_dom_pre_num(ir_node *bl, int num);
void set_Block_ipostdom(ir_node *bl, ir_node *n);
int get_Block_postdom_depth(const ir_node *bl);
void set_Block_postdom_depth(ir_node *bl, int depth);
int get_Block_postdom_pre_num(const ir_node *bl);
void set_Block_postdom_pre_num(ir_node *bl, int num);
unsigned get_Block_dom_tree_pre_num(const ir_node *bl);
unsigned get_Block_pdom_tree_pre_num(const ir_node *bl);
unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl);
unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl);
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Imprint