* [PATCH 1/2] C++-ify dominance.c
@ 2015-08-14 1:05 Mikhail Maltsev
2015-08-14 1:25 ` [PATCH 2/2] Get rid of global state accesses in dominance.c Mikhail Maltsev
` (2 more replies)
0 siblings, 3 replies; 14+ messages in thread
From: Mikhail Maltsev @ 2015-08-14 1:05 UTC (permalink / raw)
To: gcc-patches, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 2354 bytes --]
Hi all.
These two patches are refactoring of dominator-related code.
The comment in dominance.c says: "We work in a poor-mans object oriented
fashion, and carry an instance of this structure through all our 'methods'". So,
the first patch converts the mentioned structure (dom_info) into a class with
proper encapsulation. It also adds a new member - m_fn (the function currently
being compiled) to this structure and replaces some uses of cfun with m_fn. It
also contains some fixes, related to current coding standards: move variable
declarations to place of first use, replace elaborated type specifiers (i.e.
"struct/enum foo") by simple ones (i.e., just "foo") in function prototypes.
Bootstrapped and regtested on x86_64-linux. Tested build of config-list.mk.
gcc/ChangeLog:
2015-08-14 Mikhail Maltsev <maltsevm@gmail.com>
* (ENABLE_CHECKING): Define as 0 by default.
dominance.c (new_zero_array): Define.
(dom_info): Define as class instead of struct.
(dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
allocations/deallocations. Pass function as parameter (instead of
using cfun).
(dom_info::get_idom): Define accessor method.
(dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
link_roots, calc_idoms): Redefine as class members. Use m_fn instead
of cfun.
(init_dom_info, free_dom_info): Remove (use dom_info ctor/dtor).
(dom_convert_dir_to_idx): Fix prototype.
(assign_dfs_numbers): Move variable declarations to their first uses.
(calculate_dominance_info): Remove conditional compilation, move
variables.
(free_dominance_info, get_immediate_dominator, set_immediate_dominator,
get_dominated_b, get_dominated_by_region, get_dominated_to_depth,
redirect_immediate_dominators, nearest_common_dominator_for_set,
dominated_by_p, bb_dom_dfs_in, bb_dom_dfs_out, verify_dominators,
determine_dominators_for_sons, iterate_fix_dominators, first_dom_son,
next_dom_son, debug_dominance_info, debug_dominance_tree_1): Adjust to
use class dom_info. Move variable declarations to the place of first
use. Fix prototypes (remove struct/enum).
* dominance.h: Fix prototypes (remove struct/enum).
--
Regards,
Mikhail Maltsev
[-- Attachment #2: refactor_dom1.patch --]
[-- Type: text/x-patch, Size: 51765 bytes --]
diff --git a/gcc/dominance.c b/gcc/dominance.c
index d8d87ca..3c4f228 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -44,6 +44,10 @@
#include "timevar.h"
#include "graphds.h"
+#ifndef ENABLE_CHECKING
+# define ENABLE_CHECKING 0
+#endif
+
/* We name our nodes with integers, beginning with 1. Zero is reserved for
'undefined' or 'end of list'. The name of each node is given by the dfs
number of the corresponding basic block. Please note, that we include the
@@ -53,139 +57,154 @@
/* Type of Basic Block aka. TBB */
typedef unsigned int TBB;
-/* We work in a poor-mans object oriented fashion, and carry an instance of
- this structure through all our 'methods'. It holds various arrays
- reflecting the (sub)structure of the flowgraph. Most of them are of type
- TBB and are also indexed by TBB. */
+namespace {
+
+/* This class holds various arrays reflecting the (sub)structure of the
+ flowgraph. Most of them are of type TBB and are also indexed by TBB. */
-struct dom_info
+class dom_info
{
+public:
+ dom_info (function *, cdi_direction);
+ ~dom_info ();
+ void calc_dfs_tree (bool);
+ void calc_idoms (bool);
+
+ inline basic_block get_idom (basic_block);
+private:
+ void calc_dfs_tree_nonrec (basic_block, bool);
+ void compress (TBB);
+ TBB eval (TBB);
+ void link_roots (TBB, TBB);
+
/* The parent of a node in the DFS tree. */
- TBB *dfs_parent;
- /* For a node x key[x] is roughly the node nearest to the root from which
+ TBB *m_dfs_parent;
+ /* For a node x m_key[x] is roughly the node nearest to the root from which
exists a way to x only over nodes behind x. Such a node is also called
semidominator. */
- TBB *key;
- /* The value in path_min[x] is the node y on the path from x to the root of
- the tree x is in with the smallest key[y]. */
- TBB *path_min;
- /* bucket[x] points to the first node of the set of nodes having x as key. */
- TBB *bucket;
- /* And next_bucket[x] points to the next node. */
- TBB *next_bucket;
- /* After the algorithm is done, dom[x] contains the immediate dominator
+ TBB *m_key;
+ /* The value in m_path_min[x] is the node y on the path from x to the root of
+ the tree x is in with the smallest m_key[y]. */
+ TBB *m_path_min;
+ /* m_bucket[x] points to the first node of the set of nodes having x as
+ key. */
+ TBB *m_bucket;
+ /* And m_next_bucket[x] points to the next node. */
+ TBB *m_next_bucket;
+ /* After the algorithm is done, m_dom[x] contains the immediate dominator
of x. */
- TBB *dom;
+ TBB *m_dom;
/* The following few fields implement the structures needed for disjoint
sets. */
- /* set_chain[x] is the next node on the path from x to the representative
- of the set containing x. If set_chain[x]==0 then x is a root. */
- TBB *set_chain;
- /* set_size[x] is the number of elements in the set named by x. */
- unsigned int *set_size;
- /* set_child[x] is used for balancing the tree representing a set. It can
+ /* m_set_chain[x] is the next node on the path from x to the representative
+ of the set containing x. If m_set_chain[x]==0 then x is a root. */
+ TBB *m_set_chain;
+ /* m_set_size[x] is the number of elements in the set named by x. */
+ unsigned int *m_set_size;
+ /* m_set_child[x] is used for balancing the tree representing a set. It can
be understood as the next sibling of x. */
- TBB *set_child;
+ TBB *m_set_child;
- /* If b is the number of a basic block (BB->index), dfs_order[b] is the
+ /* If b is the number of a basic block (BB->index), m_dfs_order[b] is the
number of that node in DFS order counted from 1. This is an index
into most of the other arrays in this structure. */
- TBB *dfs_order;
+ TBB *m_dfs_order;
/* If x is the DFS-index of a node which corresponds with a basic block,
- dfs_to_bb[x] is that basic block. Note, that in our structure there are
- more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
- is true for every basic block bb, but not the opposite. */
- basic_block *dfs_to_bb;
+ m_dfs_to_bb[x] is that basic block. Note, that in our structure there are
+ more nodes that basic blocks, so only
+ m_dfs_to_bb[m_dfs_order[bb->index]]==bb is true for every basic block bb,
+ but not the opposite. */
+ basic_block *m_dfs_to_bb;
/* This is the next free DFS number when creating the DFS tree. */
- unsigned int dfsnum;
- /* The number of nodes in the DFS tree (==dfsnum-1). */
- unsigned int nodes;
+ unsigned int m_dfsnum;
+ /* The number of nodes in the DFS tree (==m_dfsnum-1). */
+ unsigned int m_nodes;
/* Blocks with bits set here have a fake edge to EXIT. These are used
to turn a DFS forest into a proper tree. */
- bitmap fake_exit_edge;
+ bitmap m_fake_exit_edge;
+
+ /* The function being processed. */
+ function *m_fn;
};
-static void init_dom_info (struct dom_info *, enum cdi_direction);
-static void free_dom_info (struct dom_info *);
-static void calc_dfs_tree_nonrec (struct dom_info *, basic_block, bool);
-static void calc_dfs_tree (struct dom_info *, bool);
-static void compress (struct dom_info *, TBB);
-static TBB eval (struct dom_info *, TBB);
-static void link_roots (struct dom_info *, TBB, TBB);
-static void calc_idoms (struct dom_info *, bool);
-void debug_dominance_info (enum cdi_direction);
-void debug_dominance_tree (enum cdi_direction, basic_block);
-
-/* Helper macro for allocating and initializing an array,
- for aesthetic reasons. */
-#define init_ar(var, type, num, content) \
- do \
- { \
- unsigned int i = 1; /* Catch content == i. */ \
- if (! (content)) \
- (var) = XCNEWVEC (type, num); \
- else \
- { \
- (var) = XNEWVEC (type, (num)); \
- for (i = 0; i < num; i++) \
- (var)[i] = (content); \
- } \
- } \
- while (0)
-
-/* Allocate all needed memory in a pessimistic fashion (so we round up).
- This initializes the contents of DI, which already must be allocated. */
+} /* anon namespace */
-static void
-init_dom_info (struct dom_info *di, enum cdi_direction dir)
+void debug_dominance_info (cdi_direction);
+void debug_dominance_tree (cdi_direction, basic_block);
+
+/* Allocate and zero-initialize NUM elements of type T (T must be a
+ POD-type). Note: after transition to C++11 or later,
+ `x = new_zero_array <T> (num);' can be replaced with
+ `x = new T[num] {};'. */
+
+template<typename T>
+inline T *new_zero_array (size_t num)
+{
+ T *result = new T[num];
+ memset (result, 0, sizeof (T) * num);
+ return result;
+}
+
+/* Allocate all needed memory in a pessimistic fashion (so we round up). */
+
+dom_info::dom_info (function *fn, cdi_direction dir) : m_fn (fn)
{
/* We need memory for n_basic_blocks nodes. */
- unsigned int num = n_basic_blocks_for_fn (cfun);
- init_ar (di->dfs_parent, TBB, num, 0);
- init_ar (di->path_min, TBB, num, i);
- init_ar (di->key, TBB, num, i);
- init_ar (di->dom, TBB, num, 0);
+ size_t num = n_basic_blocks_for_fn (fn);
+ m_dfs_parent = new_zero_array <TBB> (num);
+ m_dom = new_zero_array <TBB> (num);
+
+ m_path_min = new TBB[num];
+ m_key = new TBB[num];
+ m_set_size = new unsigned int[num];
+ for (size_t i = 0; i < num; i++)
+ {
+ m_path_min[i] = m_key[i] = i;
+ m_set_size[i] = 1;
+ }
- init_ar (di->bucket, TBB, num, 0);
- init_ar (di->next_bucket, TBB, num, 0);
+ m_bucket = new_zero_array <TBB> (num);
+ m_next_bucket = new_zero_array <TBB> (num);
- init_ar (di->set_chain, TBB, num, 0);
- init_ar (di->set_size, unsigned int, num, 1);
- init_ar (di->set_child, TBB, num, 0);
+ m_set_chain = new_zero_array <TBB> (num);
+ m_set_child = new_zero_array <TBB> (num);
- init_ar (di->dfs_order, TBB,
- (unsigned int) last_basic_block_for_fn (cfun) + 1, 0);
- init_ar (di->dfs_to_bb, basic_block, num, 0);
+ m_dfs_order = new_zero_array <TBB> ((size_t)last_basic_block_for_fn (fn) + 1);
+ m_dfs_to_bb = new_zero_array <basic_block> (num);
- di->dfsnum = 1;
- di->nodes = 0;
+ m_dfsnum = 1;
+ m_nodes = 0;
switch (dir)
{
case CDI_DOMINATORS:
- di->fake_exit_edge = NULL;
+ m_fake_exit_edge = NULL;
break;
case CDI_POST_DOMINATORS:
- di->fake_exit_edge = BITMAP_ALLOC (NULL);
+ m_fake_exit_edge = BITMAP_ALLOC (NULL);
break;
default:
gcc_unreachable ();
- break;
}
}
-#undef init_ar
+inline basic_block
+dom_info::get_idom (basic_block bb)
+{
+ TBB d = m_dom[m_dfs_order[bb->index]];
+ return m_dfs_to_bb[d];
+}
/* Map dominance calculation type to array index used for various
dominance information arrays. This version is simple -- it will need
to be modified, obviously, if additional values are added to
cdi_direction. */
-static unsigned int
-dom_convert_dir_to_idx (enum cdi_direction dir)
+static inline unsigned int
+dom_convert_dir_to_idx (cdi_direction dir)
{
gcc_checking_assert (dir == CDI_DOMINATORS || dir == CDI_POST_DOMINATORS);
return dir - 1;
@@ -193,21 +212,20 @@ dom_convert_dir_to_idx (enum cdi_direction dir)
/* Free all allocated memory in DI, but not DI itself. */
-static void
-free_dom_info (struct dom_info *di)
+dom_info::~dom_info ()
{
- free (di->dfs_parent);
- free (di->path_min);
- free (di->key);
- free (di->dom);
- free (di->bucket);
- free (di->next_bucket);
- free (di->set_chain);
- free (di->set_size);
- free (di->set_child);
- free (di->dfs_order);
- free (di->dfs_to_bb);
- BITMAP_FREE (di->fake_exit_edge);
+ delete[] m_dfs_parent;
+ delete[] m_path_min;
+ delete[] m_key;
+ delete[] m_dom;
+ delete[] m_bucket;
+ delete[] m_next_bucket;
+ delete[] m_set_chain;
+ delete[] m_set_size;
+ delete[] m_set_child;
+ delete[] m_dfs_order;
+ delete[] m_dfs_to_bb;
+ BITMAP_FREE (m_fake_exit_edge);
}
/* The nonrecursive variant of creating a DFS tree. DI is our working
@@ -216,48 +234,45 @@ free_dom_info (struct dom_info *di)
node. After this is done all nodes reachable from BB were visited, have
assigned their dfs number and are linked together to form a tree. */
-static void
-calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
+void
+dom_info::calc_dfs_tree_nonrec (basic_block bb, bool reverse)
{
/* We call this _only_ if bb is not already visited. */
- edge e;
- TBB child_i, my_i = 0;
- edge_iterator *stack;
- edge_iterator ei, einext;
- int sp;
+ edge_iterator ei;
/* Start block (the entry block for forward problem, exit block for backward
problem). */
basic_block en_block;
/* Ending block. */
basic_block ex_block;
- stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
- sp = 0;
+ edge_iterator *stack = new edge_iterator[n_basic_blocks_for_fn (m_fn) + 1];
+ int sp = 0;
/* Initialize our border blocks, and the first edge. */
if (reverse)
{
ei = ei_start (bb->preds);
- en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
- ex_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ en_block = EXIT_BLOCK_PTR_FOR_FN (m_fn);
+ ex_block = ENTRY_BLOCK_PTR_FOR_FN (m_fn);
}
else
{
ei = ei_start (bb->succs);
- en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
- ex_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
+ en_block = ENTRY_BLOCK_PTR_FOR_FN (m_fn);
+ ex_block = EXIT_BLOCK_PTR_FOR_FN (m_fn);
}
/* When the stack is empty we break out of this loop. */
while (1)
{
basic_block bn;
+ edge_iterator einext;
/* This loop traverses edges e in depth first manner, and fills the
stack. */
while (!ei_end_p (ei))
{
- e = ei_edge (ei);
+ edge e = ei_edge (ei);
/* Deduce from E the current and the next block (BB and BN), and the
next edge. */
@@ -268,7 +283,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
/* If the next node BN is either already visited or a border
block the current edge is useless, and simply overwritten
with the next edge out of the current node. */
- if (bn == ex_block || di->dfs_order[bn->index])
+ if (bn == ex_block || m_dfs_order[bn->index])
{
ei_next (&ei);
continue;
@@ -279,7 +294,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
else
{
bn = e->dest;
- if (bn == ex_block || di->dfs_order[bn->index])
+ if (bn == ex_block || m_dfs_order[bn->index])
{
ei_next (&ei);
continue;
@@ -291,13 +306,14 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
gcc_assert (bn != en_block);
/* Fill the DFS tree info calculatable _before_ recursing. */
+ TBB my_i;
if (bb != en_block)
- my_i = di->dfs_order[bb->index];
+ my_i = m_dfs_order[bb->index];
else
- my_i = di->dfs_order[last_basic_block_for_fn (cfun)];
- child_i = di->dfs_order[bn->index] = di->dfsnum++;
- di->dfs_to_bb[child_i] = bn;
- di->dfs_parent[child_i] = my_i;
+ my_i = m_dfs_order[last_basic_block_for_fn (m_fn)];
+ TBB child_i = m_dfs_order[bn->index] = m_dfsnum++;
+ m_dfs_to_bb[child_i] = bn;
+ m_dfs_parent[child_i] = my_i;
/* Save the current point in the CFG on the stack, and recurse. */
stack[sp++] = ei;
@@ -319,7 +335,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
descendants or the tree depth. */
ei_next (&ei);
}
- free (stack);
+ delete[] stack;
}
/* The main entry for calculating the DFS tree or forest. DI is our working
@@ -327,17 +343,17 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
graph. In that case the result is not necessarily a tree but a forest,
because there may be nodes from which the EXIT_BLOCK is unreachable. */
-static void
-calc_dfs_tree (struct dom_info *di, bool reverse)
+void
+dom_info::calc_dfs_tree (bool reverse)
{
/* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
- basic_block begin = (reverse
- ? EXIT_BLOCK_PTR_FOR_FN (cfun) : ENTRY_BLOCK_PTR_FOR_FN (cfun));
- di->dfs_order[last_basic_block_for_fn (cfun)] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = begin;
- di->dfsnum++;
+ basic_block begin = (reverse ? EXIT_BLOCK_PTR_FOR_FN (m_fn)
+ : ENTRY_BLOCK_PTR_FOR_FN (m_fn));
+ m_dfs_order[last_basic_block_for_fn (m_fn)] = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = begin;
+ m_dfsnum++;
- calc_dfs_tree_nonrec (di, begin, reverse);
+ calc_dfs_tree_nonrec (begin, reverse);
if (reverse)
{
@@ -354,48 +370,47 @@ calc_dfs_tree (struct dom_info *di, bool reverse)
basic_block b;
bool saw_unconnected = false;
- FOR_EACH_BB_REVERSE_FN (b, cfun)
+ FOR_EACH_BB_REVERSE_FN (b, m_fn)
{
if (EDGE_COUNT (b->succs) > 0)
{
- if (di->dfs_order[b->index] == 0)
+ if (m_dfs_order[b->index] == 0)
saw_unconnected = true;
continue;
}
- bitmap_set_bit (di->fake_exit_edge, b->index);
- di->dfs_order[b->index] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = b;
- di->dfs_parent[di->dfsnum] =
- di->dfs_order[last_basic_block_for_fn (cfun)];
- di->dfsnum++;
- calc_dfs_tree_nonrec (di, b, reverse);
+ bitmap_set_bit (m_fake_exit_edge, b->index);
+ m_dfs_order[b->index] = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = b;
+ m_dfs_parent[m_dfsnum] =
+ m_dfs_order[last_basic_block_for_fn (m_fn)];
+ m_dfsnum++;
+ calc_dfs_tree_nonrec (b, reverse);
}
if (saw_unconnected)
{
- FOR_EACH_BB_REVERSE_FN (b, cfun)
+ FOR_EACH_BB_REVERSE_FN (b, m_fn)
{
- basic_block b2;
- if (di->dfs_order[b->index])
+ if (m_dfs_order[b->index])
continue;
- b2 = dfs_find_deadend (b);
- gcc_checking_assert (di->dfs_order[b2->index] == 0);
- bitmap_set_bit (di->fake_exit_edge, b2->index);
- di->dfs_order[b2->index] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = b2;
- di->dfs_parent[di->dfsnum] =
- di->dfs_order[last_basic_block_for_fn (cfun)];
- di->dfsnum++;
- calc_dfs_tree_nonrec (di, b2, reverse);
- gcc_checking_assert (di->dfs_order[b->index]);
+ basic_block b2 = dfs_find_deadend (b);
+ gcc_checking_assert (m_dfs_order[b2->index] == 0);
+ bitmap_set_bit (m_fake_exit_edge, b2->index);
+ m_dfs_order[b2->index] = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = b2;
+ m_dfs_parent[m_dfsnum] =
+ m_dfs_order[last_basic_block_for_fn (m_fn)];
+ m_dfsnum++;
+ calc_dfs_tree_nonrec (b2, reverse);
+ gcc_checking_assert (m_dfs_order[b->index]);
}
}
}
- di->nodes = di->dfsnum - 1;
+ m_nodes = m_dfsnum - 1;
/* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
- gcc_assert (di->nodes == (unsigned int) n_basic_blocks_for_fn (cfun) - 1);
+ gcc_assert (m_nodes == (unsigned int) n_basic_blocks_for_fn (m_fn) - 1);
}
/* Compress the path from V to the root of its set and update path_min at the
@@ -403,19 +418,19 @@ calc_dfs_tree (struct dom_info *di, bool reverse)
in and path_min[V] is the node with the smallest key[] value on the path
from V to that root. */
-static void
-compress (struct dom_info *di, TBB v)
+void
+dom_info::compress (TBB v)
{
/* Btw. It's not worth to unrecurse compress() as the depth is usually not
greater than 5 even for huge graphs (I've not seen call depth > 4).
Also performance wise compress() ranges _far_ behind eval(). */
- TBB parent = di->set_chain[v];
- if (di->set_chain[parent])
+ TBB parent = m_set_chain[v];
+ if (m_set_chain[parent])
{
- compress (di, parent);
- if (di->key[di->path_min[parent]] < di->key[di->path_min[v]])
- di->path_min[v] = di->path_min[parent];
- di->set_chain[v] = di->set_chain[parent];
+ compress (parent);
+ if (m_key[m_path_min[parent]] < m_key[m_path_min[v]])
+ m_path_min[v] = m_path_min[parent];
+ m_set_chain[v] = m_set_chain[parent];
}
}
@@ -423,28 +438,28 @@ compress (struct dom_info *di, TBB v)
changed since the last call). Returns the node with the smallest key[]
value on the path from V to the root. */
-static inline TBB
-eval (struct dom_info *di, TBB v)
+inline TBB
+dom_info::eval (TBB v)
{
/* The representative of the set V is in, also called root (as the set
representation is a tree). */
- TBB rep = di->set_chain[v];
+ TBB rep = m_set_chain[v];
/* V itself is the root. */
if (!rep)
- return di->path_min[v];
+ return m_path_min[v];
/* Compress only if necessary. */
- if (di->set_chain[rep])
+ if (m_set_chain[rep])
{
- compress (di, v);
- rep = di->set_chain[v];
+ compress (v);
+ rep = m_set_chain[v];
}
- if (di->key[di->path_min[rep]] >= di->key[di->path_min[v]])
- return di->path_min[v];
+ if (m_key[m_path_min[rep]] >= m_key[m_path_min[v]])
+ return m_path_min[v];
else
- return di->path_min[rep];
+ return m_path_min[rep];
}
/* This essentially merges the two sets of V and W, giving a single set with
@@ -452,72 +467,67 @@ eval (struct dom_info *di, TBB v)
balanced tree. Currently link(V,W) is only used with V being the parent
of W. */
-static void
-link_roots (struct dom_info *di, TBB v, TBB w)
+void
+dom_info::link_roots (TBB v, TBB w)
{
TBB s = w;
/* Rebalance the tree. */
- while (di->key[di->path_min[w]] < di->key[di->path_min[di->set_child[s]]])
+ while (m_key[m_path_min[w]] < m_key[m_path_min[m_set_child[s]]])
{
- if (di->set_size[s] + di->set_size[di->set_child[di->set_child[s]]]
- >= 2 * di->set_size[di->set_child[s]])
+ if (m_set_size[s] + m_set_size[m_set_child[m_set_child[s]]]
+ >= 2 * m_set_size[m_set_child[s]])
{
- di->set_chain[di->set_child[s]] = s;
- di->set_child[s] = di->set_child[di->set_child[s]];
+ m_set_chain[m_set_child[s]] = s;
+ m_set_child[s] = m_set_child[m_set_child[s]];
}
else
{
- di->set_size[di->set_child[s]] = di->set_size[s];
- s = di->set_chain[s] = di->set_child[s];
+ m_set_size[m_set_child[s]] = m_set_size[s];
+ s = m_set_chain[s] = m_set_child[s];
}
}
- di->path_min[s] = di->path_min[w];
- di->set_size[v] += di->set_size[w];
- if (di->set_size[v] < 2 * di->set_size[w])
- std::swap (di->set_child[v], s);
+ m_path_min[s] = m_path_min[w];
+ m_set_size[v] += m_set_size[w];
+ if (m_set_size[v] < 2 * m_set_size[w])
+ std::swap (m_set_child[v], s);
/* Merge all subtrees. */
while (s)
{
- di->set_chain[s] = v;
- s = di->set_child[s];
+ m_set_chain[s] = v;
+ s = m_set_child[s];
}
}
/* This calculates the immediate dominators (or post-dominators if REVERSE is
true). DI is our working structure and should hold the DFS forest.
- On return the immediate dominator to node V is in di->dom[V]. */
+ On return the immediate dominator to node V is in m_dom[V]. */
-static void
-calc_idoms (struct dom_info *di, bool reverse)
+void
+dom_info::calc_idoms (bool reverse)
{
- TBB v, w, k, par;
- basic_block en_block;
- edge_iterator ei, einext;
-
- if (reverse)
- en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
- else
- en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ const basic_block en_block = reverse ? EXIT_BLOCK_PTR_FOR_FN (m_fn)
+ : ENTRY_BLOCK_PTR_FOR_FN (m_fn);
/* Go backwards in DFS order, to first look at the leafs. */
- v = di->nodes;
- while (v > 1)
+ for (TBB v = m_nodes; v > 1; v--)
{
- basic_block bb = di->dfs_to_bb[v];
+ basic_block bb = m_dfs_to_bb[v];
edge e;
- par = di->dfs_parent[v];
- k = v;
+ TBB par = m_dfs_parent[v];
+ TBB k = v;
- ei = (reverse) ? ei_start (bb->succs) : ei_start (bb->preds);
+ edge_iterator ei = (reverse) ? ei_start (bb->succs)
+ : ei_start (bb->preds);
+ edge_iterator einext;
if (reverse)
{
/* If this block has a fake edge to exit, process that first. */
- if (bitmap_bit_p (di->fake_exit_edge, bb->index))
+ if (bitmap_bit_p (m_fake_exit_edge, bb->index))
{
einext = ei;
einext.index = 0;
@@ -542,60 +552,57 @@ calc_idoms (struct dom_info *di, bool reverse)
if (b == en_block)
{
do_fake_exit_edge:
- k1 = di->dfs_order[last_basic_block_for_fn (cfun)];
+ k1 = m_dfs_order[last_basic_block_for_fn (m_fn)];
}
else
- k1 = di->dfs_order[b->index];
+ k1 = m_dfs_order[b->index];
/* Call eval() only if really needed. If k1 is above V in DFS tree,
then we know, that eval(k1) == k1 and key[k1] == k1. */
if (k1 > v)
- k1 = di->key[eval (di, k1)];
+ k1 = m_key[eval (k1)];
if (k1 < k)
k = k1;
ei = einext;
}
- di->key[v] = k;
- link_roots (di, par, v);
- di->next_bucket[v] = di->bucket[k];
- di->bucket[k] = v;
+ m_key[v] = k;
+ link_roots (par, v);
+ m_next_bucket[v] = m_bucket[k];
+ m_bucket[k] = v;
/* Transform semidominators into dominators. */
- for (w = di->bucket[par]; w; w = di->next_bucket[w])
+ for (TBB w = m_bucket[par]; w; w = m_next_bucket[w])
{
- k = eval (di, w);
- if (di->key[k] < di->key[w])
- di->dom[w] = k;
+ k = eval (w);
+ if (m_key[k] < m_key[w])
+ m_dom[w] = k;
else
- di->dom[w] = par;
+ m_dom[w] = par;
}
/* We don't need to cleanup next_bucket[]. */
- di->bucket[par] = 0;
- v--;
+ m_bucket[par] = 0;
}
/* Explicitly define the dominators. */
- di->dom[1] = 0;
- for (v = 2; v <= di->nodes; v++)
- if (di->dom[v] != di->key[v])
- di->dom[v] = di->dom[di->dom[v]];
+ m_dom[1] = 0;
+ for (TBB v = 2; v <= m_nodes; v++)
+ if (m_dom[v] != m_key[v])
+ m_dom[v] = m_dom[m_dom[v]];
}
/* Assign dfs numbers starting from NUM to NODE and its sons. */
static void
-assign_dfs_numbers (struct et_node *node, int *num)
+assign_dfs_numbers (et_node *node, int *num)
{
- struct et_node *son;
-
node->dfs_num_in = (*num)++;
if (node->son)
{
assign_dfs_numbers (node->son, num);
- for (son = node->son->right; son != node->son; son = son->right)
+ for (et_node *son = node->son->right; son != node->son; son = son->right)
assign_dfs_numbers (son, num);
}
@@ -606,7 +613,7 @@ assign_dfs_numbers (struct et_node *node, int *num)
static dominator tree. */
static void
-compute_dom_fast_query (enum cdi_direction dir)
+compute_dom_fast_query (cdi_direction dir)
{
int num = 0;
basic_block bb;
@@ -630,52 +637,46 @@ compute_dom_fast_query (enum cdi_direction dir)
we want to compute dominators or postdominators. */
void
-calculate_dominance_info (enum cdi_direction dir)
+calculate_dominance_info (cdi_direction dir)
{
- struct dom_info di;
- basic_block b;
unsigned int dir_index = dom_convert_dir_to_idx (dir);
bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
if (dom_computed[dir_index] == DOM_OK)
{
-#if ENABLE_CHECKING
- verify_dominators (dir);
-#endif
+ if (ENABLE_CHECKING)
+ verify_dominators (dir);
return;
}
timevar_push (TV_DOMINANCE);
- if (!dom_info_available_p (dir))
+ if (!dom_info_available_p (cfun, dir))
{
gcc_assert (!n_bbs_in_dom_tree[dir_index]);
+ basic_block b;
FOR_ALL_BB_FN (b, cfun)
{
b->dom[dir_index] = et_new_tree (b);
}
n_bbs_in_dom_tree[dir_index] = n_basic_blocks_for_fn (cfun);
- init_dom_info (&di, dir);
- calc_dfs_tree (&di, reverse);
- calc_idoms (&di, reverse);
+ dom_info di (cfun, dir);
+ di.calc_dfs_tree (reverse);
+ di.calc_idoms (reverse);
FOR_EACH_BB_FN (b, cfun)
{
- TBB d = di.dom[di.dfs_order[b->index]];
-
- if (di.dfs_to_bb[d])
- et_set_father (b->dom[dir_index], di.dfs_to_bb[d]->dom[dir_index]);
+ if (basic_block d = di.get_idom (b))
+ et_set_father (b->dom[dir_index], d->dom[dir_index]);
}
- free_dom_info (&di);
dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
else
{
-#if ENABLE_CHECKING
- verify_dominators (dir);
-#endif
+ if (ENABLE_CHECKING)
+ verify_dominators (dir);
}
compute_dom_fast_query (dir);
@@ -685,14 +686,14 @@ calculate_dominance_info (enum cdi_direction dir)
/* Free dominance information for direction DIR. */
void
-free_dominance_info (function *fn, enum cdi_direction dir)
+free_dominance_info (function *fn, cdi_direction dir)
{
- basic_block bb;
unsigned int dir_index = dom_convert_dir_to_idx (dir);
if (!dom_info_available_p (fn, dir))
return;
+ basic_block bb;
FOR_ALL_BB_FN (bb, fn)
{
et_free_tree_force (bb->dom[dir_index]);
@@ -706,17 +707,17 @@ free_dominance_info (function *fn, enum cdi_direction dir)
}
void
-free_dominance_info (enum cdi_direction dir)
+free_dominance_info (cdi_direction dir)
{
free_dominance_info (cfun, dir);
}
/* Return the immediate dominator of basic block BB. */
basic_block
-get_immediate_dominator (enum cdi_direction dir, basic_block bb)
+get_immediate_dominator (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *node = bb->dom[dir_index];
+ et_node *node = bb->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index]);
@@ -729,11 +730,11 @@ get_immediate_dominator (enum cdi_direction dir, basic_block bb)
/* Set the immediate dominator of the block possibly removing
existing edge. NULL can be used to remove any edge. */
void
-set_immediate_dominator (enum cdi_direction dir, basic_block bb,
+set_immediate_dominator (cdi_direction dir, basic_block bb,
basic_block dominated_by)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *node = bb->dom[dir_index];
+ et_node *node = bb->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index]);
@@ -753,11 +754,11 @@ set_immediate_dominator (enum cdi_direction dir, basic_block bb,
/* Returns the list of basic blocks immediately dominated by BB, in the
direction DIR. */
-vec<basic_block>
-get_dominated_by (enum cdi_direction dir, basic_block bb)
+vec<basic_block>
+get_dominated_by (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *node = bb->dom[dir_index], *son = node->son, *ason;
+ et_node *node = bb->dom[dir_index], *son = node->son;
vec<basic_block> bbs = vNULL;
gcc_checking_assert (dom_computed[dir_index]);
@@ -766,7 +767,7 @@ get_dominated_by (enum cdi_direction dir, basic_block bb)
return vNULL;
bbs.safe_push ((basic_block) son->data);
- for (ason = son->right; ason != son; ason = ason->right)
+ for (et_node *ason = son->right; ason != son; ason = ason->right)
bbs.safe_push ((basic_block) ason->data);
return bbs;
@@ -775,24 +776,21 @@ get_dominated_by (enum cdi_direction dir, basic_block bb)
/* Returns the list of basic blocks that are immediately dominated (in
direction DIR) by some block between N_REGION ones stored in REGION,
except for blocks in the REGION itself. */
-
-vec<basic_block>
-get_dominated_by_region (enum cdi_direction dir, basic_block *region,
+vec<basic_block>
+get_dominated_by_region (cdi_direction dir, basic_block *region,
unsigned n_region)
{
- unsigned i;
- basic_block dom;
vec<basic_block> doms = vNULL;
- for (i = 0; i < n_region; i++)
+ for (unsigned i = 0; i < n_region; i++)
region[i]->flags |= BB_DUPLICATED;
- for (i = 0; i < n_region; i++)
- for (dom = first_dom_son (dir, region[i]);
+ for (unsigned i = 0; i < n_region; i++)
+ for (basic_block dom = first_dom_son (dir, region[i]);
dom;
dom = next_dom_son (dir, dom))
if (!(dom->flags & BB_DUPLICATED))
doms.safe_push (dom);
- for (i = 0; i < n_region; i++)
+ for (unsigned i = 0; i < n_region; i++)
region[i]->flags &= ~BB_DUPLICATED;
return doms;
@@ -803,31 +801,25 @@ get_dominated_by_region (enum cdi_direction dir, basic_block *region,
produce a vector containing all dominated blocks. The vector will be sorted
in preorder. */
-vec<basic_block>
-get_dominated_to_depth (enum cdi_direction dir, basic_block bb, int depth)
+vec<basic_block>
+get_dominated_to_depth (cdi_direction dir, basic_block bb, int depth)
{
vec<basic_block> bbs = vNULL;
- unsigned i;
- unsigned next_level_start;
- i = 0;
bbs.safe_push (bb);
- next_level_start = 1; /* = bbs.length (); */
+ unsigned next_level_start = 1; /* = bbs.length (); */
- do
+ for (unsigned i = 0; i < next_level_start; i++)
{
- basic_block son;
-
- bb = bbs[i++];
- for (son = first_dom_son (dir, bb);
+ basic_block level_start_bb = bbs[i];
+ for (basic_block son = first_dom_son (dir, level_start_bb);
son;
son = next_dom_son (dir, son))
bbs.safe_push (son);
- if (i == next_level_start && --depth)
+ if (i + 1 == next_level_start && --depth)
next_level_start = bbs.length ();
}
- while (i < next_level_start);
return bbs;
}
@@ -835,32 +827,28 @@ get_dominated_to_depth (enum cdi_direction dir, basic_block bb, int depth)
/* Returns the list of basic blocks including BB dominated by BB, in the
direction DIR. The vector will be sorted in preorder. */
-vec<basic_block>
-get_all_dominated_blocks (enum cdi_direction dir, basic_block bb)
+vec<basic_block>
+get_all_dominated_blocks (cdi_direction dir, basic_block bb)
{
return get_dominated_to_depth (dir, bb, 0);
}
/* Redirect all edges pointing to BB to TO. */
void
-redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
+redirect_immediate_dominators (cdi_direction dir, basic_block bb,
basic_block to)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *bb_node, *to_node, *son;
-
- bb_node = bb->dom[dir_index];
- to_node = to->dom[dir_index];
+ et_node *bb_node = bb->dom[dir_index],
+ *to_node = to->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index]);
if (!bb_node->son)
return;
- while (bb_node->son)
+ while (et_node *son = bb_node->son)
{
- son = bb_node->son;
-
et_split (son);
et_set_father (son, to_node);
}
@@ -871,7 +859,7 @@ redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
/* Find first basic block in the tree dominating both BB1 and BB2. */
basic_block
-nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
+nearest_common_dominator (cdi_direction dir, basic_block bb1, basic_block bb2)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
@@ -890,14 +878,13 @@ nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block b
using dominance direction DIR. */
basic_block
-nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
+nearest_common_dominator_for_set (cdi_direction dir, bitmap blocks)
{
- unsigned i, first;
+ unsigned i;
bitmap_iterator bi;
- basic_block dom;
- first = bitmap_first_set_bit (blocks);
- dom = BASIC_BLOCK_FOR_FN (cfun, first);
+ unsigned first = bitmap_first_set_bit (blocks);
+ basic_block dom = BASIC_BLOCK_FOR_FN (cfun, first);
EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
if (dom != BASIC_BLOCK_FOR_FN (cfun, i))
dom = nearest_common_dominator (dir, dom, BASIC_BLOCK_FOR_FN (cfun, i));
@@ -982,10 +969,10 @@ nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
/* Return TRUE in case BB1 is dominated by BB2. */
bool
-dominated_by_p (enum cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
+dominated_by_p (cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
+ et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index]);
@@ -999,10 +986,10 @@ dominated_by_p (enum cdi_direction dir, const_basic_block bb1, const_basic_block
/* Returns the entry dfs number for basic block BB, in the direction DIR. */
unsigned
-bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
+bb_dom_dfs_in (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *n = bb->dom[dir_index];
+ et_node *n = bb->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
return n->dfs_num_in;
@@ -1011,10 +998,10 @@ bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
/* Returns the exit dfs number for basic block BB, in the direction DIR. */
unsigned
-bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
+bb_dom_dfs_out (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *n = bb->dom[dir_index];
+ et_node *n = bb->dom[dir_index];
gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
return n->dfs_num_out;
@@ -1022,38 +1009,36 @@ bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
/* Verify invariants of dominator structure. */
DEBUG_FUNCTION void
-verify_dominators (enum cdi_direction dir)
+verify_dominators (cdi_direction dir)
{
- int err = 0;
- basic_block bb, imm_bb, imm_bb_correct;
- struct dom_info di;
bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
gcc_assert (dom_info_available_p (dir));
- init_dom_info (&di, dir);
- calc_dfs_tree (&di, reverse);
- calc_idoms (&di, reverse);
+ dom_info di (cfun, dir);
+ di.calc_dfs_tree (reverse);
+ di.calc_idoms (reverse);
+ bool err = false;
+ basic_block bb;
FOR_EACH_BB_FN (bb, cfun)
{
- imm_bb = get_immediate_dominator (dir, bb);
+ basic_block imm_bb = get_immediate_dominator (dir, bb);
if (!imm_bb)
{
error ("dominator of %d status unknown", bb->index);
- err = 1;
+ err = true;
}
- imm_bb_correct = di.dfs_to_bb[di.dom[di.dfs_order[bb->index]]];
+ basic_block imm_bb_correct = di.get_idom (bb);
if (imm_bb != imm_bb_correct)
{
error ("dominator of %d should be %d, not %d",
bb->index, imm_bb_correct->index, imm_bb->index);
- err = 1;
+ err = true;
}
}
- free_dom_info (&di);
gcc_assert (!err);
}
@@ -1063,7 +1048,7 @@ verify_dominators (enum cdi_direction dir)
reaches a fixed point. */
basic_block
-recompute_dominator (enum cdi_direction dir, basic_block bb)
+recompute_dominator (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
basic_block dom_bb = NULL;
@@ -1100,8 +1085,7 @@ recompute_dominator (enum cdi_direction dir, basic_block bb)
from BBS. */
static void
-prune_bbs_to_update_dominators (vec<basic_block> bbs,
- bool conservative)
+prune_bbs_to_update_dominators (vec<basic_block> bbs, bool conservative)
{
unsigned i;
bool single;
@@ -1160,7 +1144,7 @@ succeed:
BB. */
static basic_block
-root_of_dom_tree (enum cdi_direction dir, basic_block bb)
+root_of_dom_tree (cdi_direction dir, basic_block bb)
{
return (basic_block) et_root (bb->dom[dom_convert_dir_to_idx (dir)])->data;
}
@@ -1171,54 +1155,50 @@ root_of_dom_tree (enum cdi_direction dir, basic_block bb)
blocks. */
static void
-determine_dominators_for_sons (struct graph *g, vec<basic_block> bbs,
- int y, int *son, int *brother)
+determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
+ int *brother)
{
- bitmap gprime;
- int i, a, nc;
- vec<int> *sccs;
- basic_block bb, dom, ybb;
- unsigned si;
- edge e;
- edge_iterator ei;
-
if (son[y] == -1)
return;
- if (y == (int) bbs.length ())
- ybb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
- else
- ybb = bbs[y];
if (brother[son[y]] == -1)
{
/* Handle the common case Y has just one son specially. */
- bb = bbs[son[y]];
+ basic_block bb = bbs[son[y]];
set_immediate_dominator (CDI_DOMINATORS, bb,
recompute_dominator (CDI_DOMINATORS, bb));
identify_vertices (g, y, son[y]);
return;
}
- gprime = BITMAP_ALLOC (NULL);
- for (a = son[y]; a != -1; a = brother[a])
+ bitmap gprime = BITMAP_ALLOC (NULL);
+ for (int a = son[y]; a != -1; a = brother[a])
bitmap_set_bit (gprime, a);
- nc = graphds_scc (g, gprime);
+ int nc = graphds_scc (g, gprime);
BITMAP_FREE (gprime);
- /* ??? Needed to work around the pre-processor confusion with
- using a multi-argument template type as macro argument. */
- typedef vec<int> vec_int_heap;
- sccs = XCNEWVEC (vec_int_heap, nc);
- for (a = son[y]; a != -1; a = brother[a])
+ vec<int> *sccs = XCNEWVEC (vec<int>, nc);
+ for (int a = son[y]; a != -1; a = brother[a])
sccs[g->vertices[a].component].safe_push (a);
- for (i = nc - 1; i >= 0; i--)
+ basic_block ybb;
+ if (y == (int) bbs.length ())
+ ybb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ else
+ ybb = bbs[y];
+
+ for (int i = nc - 1; i >= 0; i--)
{
- dom = NULL;
+ basic_block dom = NULL;
+
+ int a;
+ unsigned si;
FOR_EACH_VEC_ELT (sccs[i], si, a)
{
- bb = bbs[a];
+ basic_block bb = bbs[a];
+ edge e;
+ edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (root_of_dom_tree (CDI_DOMINATORS, e->src) != ybb)
@@ -1231,16 +1211,16 @@ determine_dominators_for_sons (struct graph *g, vec<basic_block> bbs,
gcc_assert (dom != NULL);
FOR_EACH_VEC_ELT (sccs[i], si, a)
{
- bb = bbs[a];
+ basic_block bb = bbs[a];
set_immediate_dominator (CDI_DOMINATORS, bb, dom);
}
}
- for (i = 0; i < nc; i++)
+ for (int i = 0; i < nc; i++)
sccs[i].release ();
free (sccs);
- for (a = son[y]; a != -1; a = brother[a])
+ for (int a = son[y]; a != -1; a = brother[a])
identify_vertices (g, y, a);
}
@@ -1252,17 +1232,9 @@ determine_dominators_for_sons (struct graph *g, vec<basic_block> bbs,
a block of BBS in the current dominance tree dominate it. */
void
-iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
+iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
bool conservative)
{
- unsigned i;
- basic_block bb, dom;
- struct graph *g;
- int n, y;
- size_t dom_i;
- edge e;
- edge_iterator ei;
- int *parent, *son, *brother;
unsigned int dir_index = dom_convert_dir_to_idx (dir);
/* We only support updating dominators. There are some problems with
@@ -1330,19 +1302,21 @@ iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
conservatively correct, setting the dominators using the
heuristics in prune_bbs_to_update_dominators could
create cycles in the dominance "tree", and cause ICE. */
+ unsigned i;
+ basic_block bb;
FOR_EACH_VEC_ELT (bbs, i, bb)
set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
}
prune_bbs_to_update_dominators (bbs, conservative);
- n = bbs.length ();
+ int n = bbs.length ();
if (n == 0)
return;
if (n == 1)
{
- bb = bbs[0];
+ basic_block bb = bbs[0];
set_immediate_dominator (CDI_DOMINATORS, bb,
recompute_dominator (CDI_DOMINATORS, bb));
return;
@@ -1350,6 +1324,8 @@ iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
/* Construct the graph G. */
hash_map<basic_block, int> map (251);
+ basic_block bb;
+ unsigned i;
FOR_EACH_VEC_ELT (bbs, i, bb)
{
/* If the dominance tree is conservatively correct, split it now. */
@@ -1359,18 +1335,20 @@ iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
}
map.put (ENTRY_BLOCK_PTR_FOR_FN (cfun), n);
- g = new_graph (n + 1);
- for (y = 0; y < g->n_vertices; y++)
+ graph *g = new_graph (n + 1);
+ for (int y = 0; y < g->n_vertices; y++)
g->vertices[y].data = BITMAP_ALLOC (NULL);
FOR_EACH_VEC_ELT (bbs, i, bb)
{
+ edge e;
+ edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
{
- dom = root_of_dom_tree (CDI_DOMINATORS, e->src);
+ basic_block dom = root_of_dom_tree (CDI_DOMINATORS, e->src);
if (dom == bb)
continue;
- dom_i = *map.get (dom);
+ int dom_i = *map.get (dom);
/* Do not include parallel edges to G. */
if (!bitmap_set_bit ((bitmap) g->vertices[dom_i].data, i))
@@ -1379,16 +1357,17 @@ iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
add_edge (g, dom_i, i);
}
}
- for (y = 0; y < g->n_vertices; y++)
+ for (int y = 0; y < g->n_vertices; y++)
BITMAP_FREE (g->vertices[y].data);
/* Find the dominator tree of G. */
- son = XNEWVEC (int, n + 1);
- brother = XNEWVEC (int, n + 1);
- parent = XNEWVEC (int, n + 1);
+ int *son = new int[n + 1],
+ *brother = new int[n + 1],
+ *parent = new int[n + 1];
graphds_domtree (g, n, parent, son, brother);
/* Finally, traverse the tree and find the immediate dominators. */
+ int y;
for (y = n; son[y] != -1; y = son[y])
continue;
while (y != -1)
@@ -1405,15 +1384,15 @@ iterate_fix_dominators (enum cdi_direction dir, vec<basic_block> bbs,
y = parent[y];
}
- free (son);
- free (brother);
- free (parent);
+ delete[] son;
+ delete[] brother;
+ delete[] parent;
free_graph (g);
}
void
-add_to_dominance_info (enum cdi_direction dir, basic_block bb)
+add_to_dominance_info (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
@@ -1428,7 +1407,7 @@ add_to_dominance_info (enum cdi_direction dir, basic_block bb)
}
void
-delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
+delete_from_dominance_info (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
@@ -1446,10 +1425,10 @@ delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
as determined by DIR. */
basic_block
-first_dom_son (enum cdi_direction dir, basic_block bb)
+first_dom_son (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *son = bb->dom[dir_index]->son;
+ et_node *son = bb->dom[dir_index]->son;
return (basic_block) (son ? son->data : NULL);
}
@@ -1458,18 +1437,18 @@ first_dom_son (enum cdi_direction dir, basic_block bb)
tree as determined by DIR, or NULL if it was the last one. */
basic_block
-next_dom_son (enum cdi_direction dir, basic_block bb)
+next_dom_son (cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- struct et_node *next = bb->dom[dir_index]->right;
+ et_node *next = bb->dom[dir_index]->right;
return (basic_block) (next->father->son == next ? NULL : next->data);
}
/* Return dominance availability for dominance info DIR. */
-enum dom_state
-dom_info_state (function *fn, enum cdi_direction dir)
+dom_state
+dom_info_state (function *fn, cdi_direction dir)
{
if (!fn->cfg)
return DOM_NONE;
@@ -1478,8 +1457,8 @@ dom_info_state (function *fn, enum cdi_direction dir)
return fn->cfg->x_dom_computed[dir_index];
}
-enum dom_state
-dom_info_state (enum cdi_direction dir)
+dom_state
+dom_info_state (cdi_direction dir)
{
return dom_info_state (cfun, dir);
}
@@ -1487,7 +1466,7 @@ dom_info_state (enum cdi_direction dir)
/* Set the dominance availability for dominance info DIR to NEW_STATE. */
void
-set_dom_info_availability (enum cdi_direction dir, enum dom_state new_state)
+set_dom_info_availability (cdi_direction dir, dom_state new_state)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
@@ -1497,23 +1476,23 @@ set_dom_info_availability (enum cdi_direction dir, enum dom_state new_state)
/* Returns true if dominance information for direction DIR is available. */
bool
-dom_info_available_p (function *fn, enum cdi_direction dir)
+dom_info_available_p (function *fn, cdi_direction dir)
{
return dom_info_state (fn, dir) != DOM_NONE;
}
bool
-dom_info_available_p (enum cdi_direction dir)
+dom_info_available_p (cdi_direction dir)
{
return dom_info_available_p (cfun, dir);
}
DEBUG_FUNCTION void
-debug_dominance_info (enum cdi_direction dir)
+debug_dominance_info (cdi_direction dir)
{
- basic_block bb, bb2;
+ basic_block bb;
FOR_EACH_BB_FN (bb, cfun)
- if ((bb2 = get_immediate_dominator (dir, bb)))
+ if (basic_block bb2 = get_immediate_dominator (dir, bb))
fprintf (stderr, "%i %i\n", bb->index, bb2->index);
}
@@ -1522,19 +1501,16 @@ debug_dominance_info (enum cdi_direction dir)
the first line of the output is not indented. */
static void
-debug_dominance_tree_1 (enum cdi_direction dir, basic_block root,
- unsigned indent, bool indent_first)
+debug_dominance_tree_1 (cdi_direction dir, basic_block root, unsigned indent,
+ bool indent_first)
{
- basic_block son;
- unsigned i;
- bool first = true;
-
if (indent_first)
- for (i = 0; i < indent; i++)
+ for (unsigned i = 0; i < indent; i++)
fprintf (stderr, "\t");
fprintf (stderr, "%d\t", root->index);
- for (son = first_dom_son (dir, root);
+ bool first = true;
+ for (basic_block son = first_dom_son (dir, root);
son;
son = next_dom_son (dir, son))
{
@@ -1550,7 +1526,7 @@ debug_dominance_tree_1 (enum cdi_direction dir, basic_block root,
rooted in ROOT. */
DEBUG_FUNCTION void
-debug_dominance_tree (enum cdi_direction dir, basic_block root)
+debug_dominance_tree (cdi_direction dir, basic_block root)
{
debug_dominance_tree_1 (dir, root, 0, false);
}
diff --git a/gcc/dominance.h b/gcc/dominance.h
index 37e138b..cc5be88 100644
--- a/gcc/dominance.h
+++ b/gcc/dominance.h
@@ -35,44 +35,38 @@ enum dom_state
DOM_OK /* Everything is ok. */
};
-extern void calculate_dominance_info (enum cdi_direction);
-extern void free_dominance_info (function *, enum cdi_direction);
-extern void free_dominance_info (enum cdi_direction);
-extern basic_block get_immediate_dominator (enum cdi_direction, basic_block);
-extern void set_immediate_dominator (enum cdi_direction, basic_block,
+extern void calculate_dominance_info (cdi_direction);
+extern void free_dominance_info (function *, cdi_direction);
+extern void free_dominance_info (cdi_direction);
+extern basic_block get_immediate_dominator (cdi_direction, basic_block);
+extern void set_immediate_dominator (cdi_direction, basic_block,
basic_block);
-extern vec<basic_block> get_dominated_by (enum cdi_direction, basic_block);
-extern vec<basic_block> get_dominated_by_region (enum cdi_direction,
- basic_block *,
- unsigned);
-extern vec<basic_block> get_dominated_to_depth (enum cdi_direction,
- basic_block, int);
-extern vec<basic_block> get_all_dominated_blocks (enum cdi_direction,
- basic_block);
-extern void redirect_immediate_dominators (enum cdi_direction, basic_block,
+extern vec<basic_block> get_dominated_by (cdi_direction, basic_block);
+extern vec<basic_block> get_dominated_by_region (cdi_direction, basic_block *,
+ unsigned);
+extern vec<basic_block> get_dominated_to_depth (cdi_direction, basic_block,
+ int);
+extern vec<basic_block> get_all_dominated_blocks (cdi_direction, basic_block);
+extern void redirect_immediate_dominators (cdi_direction, basic_block,
basic_block);
-extern basic_block nearest_common_dominator (enum cdi_direction,
+extern basic_block nearest_common_dominator (cdi_direction,
basic_block, basic_block);
-extern basic_block nearest_common_dominator_for_set (enum cdi_direction,
- bitmap);
-extern bool dominated_by_p (enum cdi_direction, const_basic_block,
+extern basic_block nearest_common_dominator_for_set (cdi_direction, bitmap);
+extern bool dominated_by_p (cdi_direction, const_basic_block,
const_basic_block);
-unsigned bb_dom_dfs_in (enum cdi_direction, basic_block);
-unsigned bb_dom_dfs_out (enum cdi_direction, basic_block);
-extern void verify_dominators (enum cdi_direction);
-basic_block recompute_dominator (enum cdi_direction, basic_block);
-extern void iterate_fix_dominators (enum cdi_direction,
- vec<basic_block> , bool);
-extern void add_to_dominance_info (enum cdi_direction, basic_block);
-extern void delete_from_dominance_info (enum cdi_direction, basic_block);
-extern basic_block first_dom_son (enum cdi_direction, basic_block);
-extern basic_block next_dom_son (enum cdi_direction, basic_block);
-extern enum dom_state dom_info_state (function *, enum cdi_direction);
-extern enum dom_state dom_info_state (enum cdi_direction);
-extern void set_dom_info_availability (enum cdi_direction, enum dom_state);
-extern bool dom_info_available_p (function *, enum cdi_direction);
-extern bool dom_info_available_p (enum cdi_direction);
-
-
+unsigned bb_dom_dfs_in (cdi_direction, basic_block);
+unsigned bb_dom_dfs_out (cdi_direction, basic_block);
+extern void verify_dominators (cdi_direction);
+basic_block recompute_dominator (cdi_direction, basic_block);
+extern void iterate_fix_dominators (cdi_direction, vec<basic_block> , bool);
+extern void add_to_dominance_info (cdi_direction, basic_block);
+extern void delete_from_dominance_info (cdi_direction, basic_block);
+extern basic_block first_dom_son (cdi_direction, basic_block);
+extern basic_block next_dom_son (cdi_direction, basic_block);
+extern dom_state dom_info_state (function *, cdi_direction);
+extern dom_state dom_info_state (cdi_direction);
+extern void set_dom_info_availability (cdi_direction, dom_state);
+extern bool dom_info_available_p (function *, cdi_direction);
+extern bool dom_info_available_p (cdi_direction);
#endif /* GCC_DOMINANCE_H */
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-14 1:05 [PATCH 1/2] C++-ify dominance.c Mikhail Maltsev
@ 2015-08-14 1:25 ` Mikhail Maltsev
2015-08-14 8:17 ` Richard Biener
2015-08-14 7:54 ` [PATCH 1/2] C++-ify dominance.c Richard Biener
2015-08-14 18:25 ` Jeff Law
2 siblings, 1 reply; 14+ messages in thread
From: Mikhail Maltsev @ 2015-08-14 1:25 UTC (permalink / raw)
To: gcc-patches, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 450 bytes --]
The second part removes all global state accesses (i.e. accesses to cfun and
it's members) from dominance.c. This requires to change lots of code, but I hope
that this is a step in right direction (if my understanding of ongoing
re-architecture w.r.t. to global state is correct).
For now this second part lacks a changelog entry, but it's very "mechanical". I
will, of course, write it if the patch gets approved.
--
Regards,
Mikhail Maltsev
[-- Attachment #2: refactor_dom2.patch --]
[-- Type: text/x-patch, Size: 188734 bytes --]
diff --git a/gcc/asan.c b/gcc/asan.c
index 4f5adaa..a9c597b 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -1536,8 +1536,8 @@ create_cond_insert_point (gimple_stmt_iterator *iter,
/* Update dominance info for the newly created then_bb; note that
fallthru_bb's dominance info has already been updated by
split_bock. */
- if (dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ set_immediate_dominator (cfun, CDI_DOMINATORS, then_bb, cond_bb);
*then_block = then_bb;
*fallthrough_block = fallthru_bb;
diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
index fa0cd07..15f3f93 100644
--- a/gcc/auto-profile.c
+++ b/gcc/auto-profile.c
@@ -1118,7 +1118,7 @@ afdo_find_equiv_class (bb_set *annotated_bb)
bb->aux = bb;
dom_bbs = get_dominated_by (CDI_DOMINATORS, bb);
FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
- if (bb1->aux == NULL && dominated_by_p (CDI_POST_DOMINATORS, bb, bb1)
+ if (bb1->aux == NULL && dominated_by_p (cfun, CDI_POST_DOMINATORS, bb, bb1)
&& bb1->loop_father == bb->loop_father)
{
bb1->aux = bb;
@@ -1130,7 +1130,7 @@ afdo_find_equiv_class (bb_set *annotated_bb)
}
dom_bbs = get_dominated_by (CDI_POST_DOMINATORS, bb);
FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
- if (bb1->aux == NULL && dominated_by_p (CDI_DOMINATORS, bb, bb1)
+ if (bb1->aux == NULL && dominated_by_p (cfun, CDI_DOMINATORS, bb, bb1)
&& bb1->loop_father == bb->loop_father)
{
bb1->aux = bb;
@@ -1351,8 +1351,8 @@ afdo_calculate_branch_prob (bb_set *annotated_bb, edge_set *annotated_edge)
if (!has_sample)
return;
- calculate_dominance_info (CDI_POST_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
loop_optimizer_init (0);
afdo_find_equiv_class (annotated_bb);
@@ -1389,8 +1389,8 @@ afdo_calculate_branch_prob (bb_set *annotated_bb, edge_set *annotated_edge)
}
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
}
/* Perform value profile transformation using AutoFDO profile. Add the
@@ -1516,8 +1516,8 @@ afdo_annotate_cfg (const stmt_set &promoted_stmts)
if (flag_value_profile_transformations)
{
gimple_value_profile_transformations ();
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
update_ssa (TODO_update_ssa);
}
}
@@ -1602,8 +1602,8 @@ auto_profile (void)
if (execute_fixup_cfg () & TODO_cleanup_cfg)
cleanup_tree_cfg ();
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
cgraph_edge::rebuild_edges ();
compute_inline_parameters (cgraph_node::get (current_function_decl), true);
pop_cfun ();
diff --git a/gcc/bt-load.c b/gcc/bt-load.c
index 031b95d..27e0f15 100644
--- a/gcc/bt-load.c
+++ b/gcc/bt-load.c
@@ -899,7 +899,7 @@ augment_live_range (bitmap live_range, HARD_REG_SET *btrs_live_in_range,
tos = worklist = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun) + 1);
- if (dominated_by_p (CDI_DOMINATORS, new_bb, head_bb))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, new_bb, head_bb))
{
if (new_bb == head_bb)
{
@@ -916,7 +916,7 @@ augment_live_range (bitmap live_range, HARD_REG_SET *btrs_live_in_range,
edge_iterator ei;
int new_block = new_bb->index;
- gcc_assert (dominated_by_p (CDI_DOMINATORS, head_bb, new_bb));
+ gcc_assert (dominated_by_p (cfun, CDI_DOMINATORS, head_bb, new_bb));
IOR_HARD_REG_SET (*btrs_live_in_range, btrs_live[head_bb->index]);
bitmap_set_bit (live_range, new_block);
@@ -1061,7 +1061,7 @@ combine_btr_defs (btr_def def, HARD_REG_SET *btrs_live_in_range)
if (other_def != def
&& other_def->uses != NULL
&& ! other_def->has_ambiguous_use
- && dominated_by_p (CDI_DOMINATORS, other_def->bb, def->bb))
+ && dominated_by_p (cfun, CDI_DOMINATORS, other_def->bb, def->bb))
{
/* def->bb dominates the other def, so def and other_def could
be combined. */
@@ -1478,12 +1478,12 @@ branch_target_load_optimize (bool after_prologue_epilogue_gen)
/* Dominator info is also needed for migrate_btr_def. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
migrate_btr_defs (klass,
(targetm.branch_target_register_callee_saved
(after_prologue_epilogue_gen)));
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
}
\f
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 7e576bc..680b2e9 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -2909,7 +2909,7 @@ delete_unreachable_blocks (void)
better chance of retaining most debug information than
otherwise. */
if (MAY_HAVE_DEBUG_INSNS && current_ir_type () == IR_GIMPLE
- && dom_info_available_p (CDI_DOMINATORS))
+ && dom_info_available_p (cfun, CDI_DOMINATORS))
{
for (b = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
b != ENTRY_BLOCK_PTR_FOR_FN (cfun); b = prev_bb)
@@ -3087,10 +3087,10 @@ cleanup_cfg (int mode)
{
timevar_push (TV_REPAIR_LOOPS);
/* The above doesn't preserve dominance info if available. */
- gcc_assert (!dom_info_available_p (CDI_DOMINATORS));
- calculate_dominance_info (CDI_DOMINATORS);
+ gcc_assert (!dom_info_available_p (cfun, CDI_DOMINATORS));
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
fix_loop_structure (NULL);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
timevar_pop (TV_REPAIR_LOOPS);
}
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 7df9d06..fcd8785 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -5845,7 +5845,7 @@ pass_expand::execute (function *fun)
/* Some backends want to know that we are expanding to RTL. */
currently_expanding_to_rtl = 1;
/* Dominators are not kept up-to-date as we may create new basic-blocks. */
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
@@ -6032,8 +6032,8 @@ pass_expand::execute (function *fun)
}
/* Free stuff we no longer need after GIMPLE optimizations. */
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
delete_tree_cfg_annotations ();
timevar_push (TV_OUT_OF_SSA);
diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 2cfdcfc..be99736 100644
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -464,8 +464,8 @@ redirect_edge_and_branch_force (edge e, basic_block dest)
ret = cfg_hooks->redirect_edge_and_branch_force (e, dest);
- if (ret != NULL && dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, ret, src);
+ if (ret != NULL && dom_info_available_p (cfun, CDI_DOMINATORS))
+ set_immediate_dominator (cfun, CDI_DOMINATORS, ret, src);
if (current_loops != NULL)
{
@@ -504,10 +504,10 @@ split_block_1 (basic_block bb, void *i)
new_bb->frequency = bb->frequency;
new_bb->discriminator = bb->discriminator;
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
- redirect_immediate_dominators (CDI_DOMINATORS, bb, new_bb);
- set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
+ redirect_immediate_dominators (cfun, CDI_DOMINATORS, bb, new_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bb, bb);
}
if (current_loops != NULL)
@@ -598,10 +598,10 @@ delete_basic_block (basic_block bb)
while (EDGE_COUNT (bb->succs) != 0)
remove_edge (EDGE_SUCC (bb, 0));
- if (dom_info_available_p (CDI_DOMINATORS))
- delete_from_dominance_info (CDI_DOMINATORS, bb);
- if (dom_info_available_p (CDI_POST_DOMINATORS))
- delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ delete_from_dominance_info (cfun, CDI_DOMINATORS, bb);
+ if (dom_info_available_p (cfun, CDI_POST_DOMINATORS))
+ delete_from_dominance_info (cfun, CDI_POST_DOMINATORS, bb);
/* Remove the basic block from the array. */
expunge_block (bb);
@@ -639,10 +639,10 @@ split_edge (edge e)
single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
}
- if (dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret));
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ set_immediate_dominator (cfun, CDI_DOMINATORS, ret, single_pred (ret));
- if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
+ if (dom_info_state (cfun, CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
{
/* There are two cases:
@@ -662,13 +662,14 @@ split_edge (edge e)
if (f == single_succ_edge (ret))
continue;
- if (!dominated_by_p (CDI_DOMINATORS, f->src,
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, f->src,
single_succ (ret)))
break;
}
if (!f)
- set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret);
+ set_immediate_dominator (cfun, CDI_DOMINATORS,
+ single_succ (ret), ret);
}
}
@@ -700,10 +701,10 @@ create_basic_block_1 (void *head, void *end, basic_block after)
ret = cfg_hooks->create_basic_block (head, end, after);
- if (dom_info_available_p (CDI_DOMINATORS))
- add_to_dominance_info (CDI_DOMINATORS, ret);
- if (dom_info_available_p (CDI_POST_DOMINATORS))
- add_to_dominance_info (CDI_POST_DOMINATORS, ret);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ add_to_dominance_info (cfun, CDI_DOMINATORS, ret);
+ if (dom_info_available_p (cfun, CDI_POST_DOMINATORS))
+ add_to_dominance_info (cfun, CDI_POST_DOMINATORS, ret);
return ret;
}
@@ -827,13 +828,13 @@ merge_blocks (basic_block a, basic_block b)
/* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
b->preds = b->succs = NULL;
- if (dom_info_available_p (CDI_DOMINATORS))
- redirect_immediate_dominators (CDI_DOMINATORS, b, a);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ redirect_immediate_dominators (cfun, CDI_DOMINATORS, b, a);
- if (dom_info_available_p (CDI_DOMINATORS))
- delete_from_dominance_info (CDI_DOMINATORS, b);
- if (dom_info_available_p (CDI_POST_DOMINATORS))
- delete_from_dominance_info (CDI_POST_DOMINATORS, b);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ delete_from_dominance_info (cfun, CDI_DOMINATORS, b);
+ if (dom_info_available_p (cfun, CDI_POST_DOMINATORS))
+ delete_from_dominance_info (cfun, CDI_POST_DOMINATORS, b);
expunge_block (b);
}
@@ -896,13 +897,13 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
}
}
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
vec<basic_block> doms_to_fix;
doms_to_fix.create (2);
doms_to_fix.quick_push (dummy);
doms_to_fix.quick_push (bb);
- iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, doms_to_fix, false);
doms_to_fix.release ();
}
@@ -1014,8 +1015,8 @@ force_nonfallthru (edge e)
ret = cfg_hooks->force_nonfallthru (e);
if (ret != NULL)
{
- if (dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, ret, src);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ set_immediate_dominator (cfun, CDI_DOMINATORS, ret, src);
if (current_loops != NULL)
{
@@ -1370,7 +1371,7 @@ copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
if (dom_bb->flags & BB_DUPLICATED)
{
dom_bb = get_bb_copy (dom_bb);
- set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bb, dom_bb);
}
}
}
diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index b8a1244..742ffcd 100644
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -97,7 +97,7 @@ get_loop_latch_edges (const struct loop *loop)
FOR_EACH_EDGE (e, ei, loop->header->preds)
{
- if (dominated_by_p (CDI_DOMINATORS, e->src, loop->header))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, e->src, loop->header))
ret.safe_push (e);
}
@@ -235,7 +235,7 @@ flow_loop_nodes_find (basic_block header, struct loop *loop)
FOR_EACH_EDGE (latch, latch_ei, loop->header->preds)
{
if (latch->src->loop_father == loop
- || !dominated_by_p (CDI_DOMINATORS, latch->src, loop->header))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, latch->src, loop->header))
continue;
num_nodes++;
@@ -384,7 +384,7 @@ bb_loop_header_p (basic_block header)
{
basic_block latch = e->src;
if (latch != ENTRY_BLOCK_PTR_FOR_FN (cfun)
- && dominated_by_p (CDI_DOMINATORS, latch, header))
+ && dominated_by_p (cfun, CDI_DOMINATORS, latch, header))
return true;
}
@@ -408,7 +408,7 @@ flow_loops_find (struct loops *loops)
unsigned i;
/* Ensure that the dominators are computed. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
if (!loops)
{
@@ -582,12 +582,12 @@ find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, vec<edge> la
/* Find the candidate for the latch edge. */
for (i = 1; latches.iterate (i, &e); i++)
- if (dominated_by_p (CDI_DOMINATORS, latch->src, e->src))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, latch->src, e->src))
latch = e;
/* Verify that it dominates all the latch edges. */
FOR_EACH_VEC_ELT (latches, i, e)
- if (!dominated_by_p (CDI_DOMINATORS, e->src, latch->src))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, e->src, latch->src))
return NULL;
/* Check for a phi node that would deny that this is a latch edge of
@@ -793,7 +793,7 @@ glb_enum_p (const_basic_block bb, const void *glb_loop)
{
const struct loop *const loop = (const struct loop *) glb_loop;
return (bb != loop->header
- && dominated_by_p (CDI_DOMINATORS, bb, loop->header));
+ && dominated_by_p (cfun, CDI_DOMINATORS, bb, loop->header));
}
/* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
@@ -859,7 +859,7 @@ fill_sons_in_loop (const struct loop *loop, basic_block bb,
if (!flow_bb_inside_loop_p (loop, son))
continue;
- if (dominated_by_p (CDI_DOMINATORS, loop->latch, son))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, son))
{
postpone = son;
continue;
@@ -1317,7 +1317,7 @@ verify_loop_structure (void)
edge e;
unsigned num = number_of_loops (cfun);
struct loop_exit *exit, *mexit;
- bool dom_available = dom_info_available_p (CDI_DOMINATORS);
+ bool dom_available = dom_info_available_p (cfun, CDI_DOMINATORS);
sbitmap visited;
if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
@@ -1328,9 +1328,9 @@ verify_loop_structure (void)
/* We need up-to-date dominators, compute or verify them. */
if (!dom_available)
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
else
- verify_dominators (CDI_DOMINATORS);
+ verify_dominators (cfun, CDI_DOMINATORS);
/* Check the loop tree root. */
if (current_loops->tree_root->header != ENTRY_BLOCK_PTR_FOR_FN (cfun)
@@ -1437,7 +1437,7 @@ verify_loop_structure (void)
error ("loop %d%'s latch does not have an edge to its header", i);
err = 1;
}
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, loop->header))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, loop->header))
{
error ("loop %d%'s latch is not dominated by its header", i);
err = 1;
@@ -1647,7 +1647,7 @@ verify_loop_structure (void)
gcc_assert (!err);
if (!dom_available)
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* Returns latch edge of LOOP. */
diff --git a/gcc/cfgloopanal.c b/gcc/cfgloopanal.c
index b178650..8a5e326 100644
--- a/gcc/cfgloopanal.c
+++ b/gcc/cfgloopanal.c
@@ -50,7 +50,7 @@ bool
just_once_each_iteration_p (const struct loop *loop, const_basic_block bb)
{
/* It must be executed at least once each iteration. */
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
return false;
/* And just once. */
diff --git a/gcc/cfgloopmanip.c b/gcc/cfgloopmanip.c
index 1f9a2b3..8245dd9 100644
--- a/gcc/cfgloopmanip.c
+++ b/gcc/cfgloopmanip.c
@@ -48,7 +48,7 @@ static void fix_bb_placements (basic_block, bool *, bitmap);
static bool
rpe_enum_p (const_basic_block bb, const void *data)
{
- return dominated_by_p (CDI_DOMINATORS, bb, (const_basic_block) data);
+ return dominated_by_p (cfun, CDI_DOMINATORS, bb, (const_basic_block) data);
}
/* Remove basic blocks BBS. NBBS is the number of the basic blocks. */
@@ -338,7 +338,7 @@ remove_path (edge e)
for (l = e->src->loop_father; loop_outer (l); l = f)
{
f = loop_outer (l);
- if (dominated_by_p (CDI_DOMINATORS, l->latch, e->dest))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, l->latch, e->dest))
unloop (l, &irred_invalidated, NULL);
}
@@ -405,14 +405,14 @@ remove_path (edge e)
for (ldom = first_dom_son (CDI_DOMINATORS, bb);
ldom;
ldom = next_dom_son (CDI_DOMINATORS, ldom))
- if (!dominated_by_p (CDI_DOMINATORS, from, ldom))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, from, ldom))
dom_bbs.safe_push (ldom);
}
free (seen);
/* Recount dominators. */
- iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, true);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, dom_bbs, true);
dom_bbs.release ();
free (bord_bbs);
@@ -643,7 +643,7 @@ update_dominators_in_loop (struct loop *loop)
}
}
- iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, dom_bbs, false);
free (body);
free (seen);
dom_bbs.release ();
@@ -717,15 +717,15 @@ create_empty_if_region_on_edge (edge entry_edge, tree condition)
e_false->flags &= ~EDGE_FALLTHRU;
e_false->flags |= EDGE_FALSE_VALUE;
- set_immediate_dominator (CDI_DOMINATORS, cond_bb, entry_edge->src);
- set_immediate_dominator (CDI_DOMINATORS, true_bb, cond_bb);
- set_immediate_dominator (CDI_DOMINATORS, false_bb, cond_bb);
- set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, cond_bb, entry_edge->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, true_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, false_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, join_bb, cond_bb);
exit_edge = single_succ_edge (join_bb);
if (single_pred_p (exit_edge->dest))
- set_immediate_dominator (CDI_DOMINATORS, exit_edge->dest, join_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, exit_edge->dest, join_bb);
return exit_edge;
}
@@ -791,9 +791,9 @@ create_empty_loop_on_edge (edge entry_edge,
redirect_edge_succ_nodup (single_succ_edge (loop_latch), loop_header);
/* Set immediate dominator information. */
- set_immediate_dominator (CDI_DOMINATORS, loop_header, pred_bb);
- set_immediate_dominator (CDI_DOMINATORS, loop_latch, loop_header);
- set_immediate_dominator (CDI_DOMINATORS, succ_bb, loop_header);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, loop_header, pred_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, loop_latch, loop_header);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, succ_bb, loop_header);
/* Initialize a loop structure and put it in a loop hierarchy. */
loop = alloc_loop ();
@@ -891,11 +891,11 @@ loopify (edge latch_edge, edge header_edge,
loop_redirect_edge (false_edge, loop->header);
/* Update dominators. */
- set_immediate_dominator (CDI_DOMINATORS, switch_bb, pred_bb);
- set_immediate_dominator (CDI_DOMINATORS, loop->header, switch_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, switch_bb, pred_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, loop->header, switch_bb);
}
- set_immediate_dominator (CDI_DOMINATORS, succ_bb, switch_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, succ_bb, switch_bb);
/* Compute new loop. */
add_loop (loop, outer);
@@ -1230,7 +1230,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e,
for (i = 0; i < n; i++)
{
if (bbs[i] != orig->src
- && dominated_by_p (CDI_DOMINATORS, bbs[i], orig->src))
+ && dominated_by_p (cfun, CDI_DOMINATORS, bbs[i], orig->src))
bitmap_set_bit (bbs_to_scale, i);
}
}
@@ -1360,7 +1360,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e,
redirect_edge_and_branch_force (latch_edge, new_bbs[0]);
redirect_edge_and_branch_force (new_spec_edges[SE_LATCH],
loop->header);
- set_immediate_dominator (CDI_DOMINATORS, new_bbs[0], latch);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bbs[0], latch);
latch = loop->latch = new_bbs[n - 1];
e = latch_edge = new_spec_edges[SE_LATCH];
}
@@ -1369,7 +1369,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e,
redirect_edge_and_branch_force (new_spec_edges[SE_LATCH],
loop->header);
redirect_edge_and_branch_force (e, new_bbs[0]);
- set_immediate_dominator (CDI_DOMINATORS, new_bbs[0], e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bbs[0], e->src);
e = new_spec_edges[SE_LATCH];
}
@@ -1429,7 +1429,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e,
/* Update the original loop. */
if (!is_latch)
- set_immediate_dominator (CDI_DOMINATORS, e->dest, e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, e->dest, e->src);
if (flags & DLTHE_FLAG_UPDATE_FREQ)
{
scale_bbs_frequencies_int (bbs, n, scale_main, REG_BR_PROB_BASE);
@@ -1453,7 +1453,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e,
continue;
dom_bb = nearest_common_dominator (
CDI_DOMINATORS, first_active[i], first_active_latch);
- set_immediate_dominator (CDI_DOMINATORS, dominated, dom_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dominated, dom_bb);
}
dom_bbs.release ();
}
@@ -1664,8 +1664,8 @@ lv_adjust_loop_entry_edge (basic_block first_head, basic_block second_head,
e1->count = apply_probability (e->count, e1->probability);
e->count = apply_probability (e->count, e->probability);
- set_immediate_dominator (CDI_DOMINATORS, first_head, new_head);
- set_immediate_dominator (CDI_DOMINATORS, second_head, new_head);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, first_head, new_head);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, second_head, new_head);
/* Adjust loop header phi nodes. */
lv_adjust_loop_header_phi (first_head, second_head, new_head, e1);
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 15ce8a7..b882ac9 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -2317,10 +2317,10 @@ find_partition_fixes (bool flag_only)
if (bbs_in_cold_partition.is_empty ())
return vNULL;
- bool dom_calculated_here = !dom_info_available_p (CDI_DOMINATORS);
+ bool dom_calculated_here = !dom_info_available_p (cfun, CDI_DOMINATORS);
if (dom_calculated_here)
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
while (! bbs_in_cold_partition.is_empty ())
{
@@ -2348,7 +2348,7 @@ find_partition_fixes (bool flag_only)
}
if (dom_calculated_here)
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
return bbs_to_fix;
}
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 22a9852..b4bc359 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -1704,8 +1704,8 @@ release_function_body (tree decl)
}
if (cfun->cfg)
{
- gcc_assert (!dom_info_available_p (CDI_DOMINATORS));
- gcc_assert (!dom_info_available_p (CDI_POST_DOMINATORS));
+ gcc_assert (!dom_info_available_p (cfun, CDI_DOMINATORS));
+ gcc_assert (!dom_info_available_p (cfun, CDI_POST_DOMINATORS));
clear_edges ();
cfun->cfg = NULL;
}
@@ -3322,8 +3322,8 @@ cgraph_node::get_body (void)
push_cfun (DECL_STRUCT_FUNCTION (decl));
execute_all_ipa_transforms ();
cgraph_edge::rebuild_edges ();
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
pop_cfun ();
updated = true;
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index a95ce9e..071478b 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -305,6 +305,7 @@ symbol_table::process_new_functions (void)
{
cgraph_node *node = cgraph_new_nodes[i];
fndecl = node->decl;
+ function *fn = DECL_STRUCT_FUNCTION (fndecl);
switch (state)
{
case CONSTRUCTION:
@@ -326,14 +327,14 @@ symbol_table::process_new_functions (void)
gimple_register_cfg_hooks ();
if (!node->analyzed)
node->analyze ();
- push_cfun (DECL_STRUCT_FUNCTION (fndecl));
+ push_cfun (fn);
if ((state == IPA_SSA || state == IPA_SSA_AFTER_INLINING)
- && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
+ && !gimple_in_ssa_p (fn))
g->get_passes ()->execute_early_local_passes ();
else if (inline_summaries != NULL)
compute_inline_parameters (node, true);
- free_dominance_info (CDI_POST_DOMINATORS);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fn, CDI_POST_DOMINATORS);
+ free_dominance_info (fn, CDI_DOMINATORS);
pop_cfun ();
call_cgraph_insertion_hooks (node);
break;
@@ -645,8 +646,8 @@ cgraph_node::analyze (void)
gimple_register_cfg_hooks ();
bitmap_obstack_initialize (NULL);
execute_pass_list (cfun, g->get_passes ()->all_lowering_passes);
- free_dominance_info (CDI_POST_DOMINATORS);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
compact_blocks ();
bitmap_obstack_release (NULL);
lowered = true;
@@ -1827,7 +1828,7 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
/* Since we want to emit the thunk, we explicitly mark its name as
referenced. */
diff --git a/gcc/compare-elim.c b/gcc/compare-elim.c
index b65d09e..1f72fc6 100644
--- a/gcc/compare-elim.c
+++ b/gcc/compare-elim.c
@@ -436,13 +436,13 @@ find_comparison_dom_walker::before_dom_children (basic_block bb)
static void
find_comparisons (void)
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
find_comparison_dom_walker (CDI_DOMINATORS)
.walk (cfun->cfg->x_entry_block_ptr);
clear_aux_for_blocks ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* Select an alternate CC_MODE for a comparison insn comparing A and B.
diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c
index 238b9b0..6c35ba6 100644
--- a/gcc/config/mips/mips.c
+++ b/gcc/config/mips/mips.c
@@ -15475,7 +15475,7 @@ r10k_simplify_address (rtx x, rtx_insn *insn)
&& DF_REF_BB (def) == ENTRY_BLOCK_PTR_FOR_FN (cfun))
newx = virtual_incoming_args_rtx;
}
- else if (dominated_by_p (CDI_DOMINATORS, DF_REF_BB (use),
+ else if (dominated_by_p (cfun, CDI_DOMINATORS, DF_REF_BB (use),
DF_REF_BB (def)))
{
/* Make sure that DEF_INSN is a single set of REG. */
@@ -15692,7 +15692,7 @@ r10k_insert_cache_barriers (void)
}
/* Calculate dominators. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* Bit X of PROTECTED_BBS is set if the last operation in basic block
X is protected by a cache barrier. */
@@ -15768,7 +15768,7 @@ r10k_insert_cache_barriers (void)
sbitmap_free (protected_bbs);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
\f
/* If INSN is a call, return the underlying CALL expr. Return NULL_RTX
diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c
index 5814694..60977a4 100644
--- a/gcc/config/s390/s390.c
+++ b/gcc/config/s390/s390.c
@@ -9548,9 +9548,9 @@ s390_optimize_nonescaping_tx (void)
if (tbegin_bb == NULL || tend_bb == NULL)
return;
- calculate_dominance_info (CDI_POST_DOMINATORS);
- result = dominated_by_p (CDI_POST_DOMINATORS, tbegin_bb, tend_bb);
- free_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
+ result = dominated_by_p (cfun, CDI_POST_DOMINATORS, tbegin_bb, tend_bb);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
if (!result)
return;
diff --git a/gcc/dominance.c b/gcc/dominance.c
index 3c4f228..c8d655d 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -613,73 +613,73 @@ assign_dfs_numbers (et_node *node, int *num)
static dominator tree. */
static void
-compute_dom_fast_query (cdi_direction dir)
+compute_dom_fast_query (function *fn, cdi_direction dir)
{
int num = 0;
basic_block bb;
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- gcc_checking_assert (dom_info_available_p (dir));
+ gcc_checking_assert (dom_info_available_p (fn, dir));
- if (dom_computed[dir_index] == DOM_OK)
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
return;
- FOR_ALL_BB_FN (bb, cfun)
+ FOR_ALL_BB_FN (bb, fn)
{
if (!bb->dom[dir_index]->father)
assign_dfs_numbers (bb->dom[dir_index], &num);
}
- dom_computed[dir_index] = DOM_OK;
+ fn->cfg->x_dom_computed[dir_index] = DOM_OK;
}
/* The main entry point into this module. DIR is set depending on whether
we want to compute dominators or postdominators. */
void
-calculate_dominance_info (cdi_direction dir)
+calculate_dominance_info (function *fn, cdi_direction dir)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
- if (dom_computed[dir_index] == DOM_OK)
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
{
if (ENABLE_CHECKING)
- verify_dominators (dir);
+ verify_dominators (fn, dir);
return;
}
timevar_push (TV_DOMINANCE);
- if (!dom_info_available_p (cfun, dir))
+ if (!dom_info_available_p (fn, dir))
{
- gcc_assert (!n_bbs_in_dom_tree[dir_index]);
+ gcc_assert (!fn->cfg->x_n_bbs_in_dom_tree[dir_index]);
basic_block b;
- FOR_ALL_BB_FN (b, cfun)
+ FOR_ALL_BB_FN (b, fn)
{
b->dom[dir_index] = et_new_tree (b);
}
- n_bbs_in_dom_tree[dir_index] = n_basic_blocks_for_fn (cfun);
+ fn->cfg->x_n_bbs_in_dom_tree[dir_index] = n_basic_blocks_for_fn (fn);
- dom_info di (cfun, dir);
+ dom_info di (fn, dir);
di.calc_dfs_tree (reverse);
di.calc_idoms (reverse);
- FOR_EACH_BB_FN (b, cfun)
+ FOR_EACH_BB_FN (b, fn)
{
if (basic_block d = di.get_idom (b))
et_set_father (b->dom[dir_index], d->dom[dir_index]);
}
- dom_computed[dir_index] = DOM_NO_FAST_QUERY;
+ fn->cfg->x_dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
else
{
if (ENABLE_CHECKING)
- verify_dominators (dir);
+ verify_dominators (fn, dir);
}
- compute_dom_fast_query (dir);
+ compute_dom_fast_query (fn, dir);
timevar_pop (TV_DOMINANCE);
}
@@ -706,12 +706,6 @@ free_dominance_info (function *fn, cdi_direction dir)
fn->cfg->x_dom_computed[dir_index] = DOM_NONE;
}
-void
-free_dominance_info (cdi_direction dir)
-{
- free_dominance_info (cfun, dir);
-}
-
/* Return the immediate dominator of basic block BB. */
basic_block
get_immediate_dominator (cdi_direction dir, basic_block bb)
@@ -719,8 +713,6 @@ get_immediate_dominator (cdi_direction dir, basic_block bb)
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *node = bb->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index]);
-
if (!node->father)
return NULL;
@@ -730,13 +722,13 @@ get_immediate_dominator (cdi_direction dir, basic_block bb)
/* Set the immediate dominator of the block possibly removing
existing edge. NULL can be used to remove any edge. */
void
-set_immediate_dominator (cdi_direction dir, basic_block bb,
+set_immediate_dominator (function *fn, cdi_direction dir, basic_block bb,
basic_block dominated_by)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *node = bb->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index]);
+ gcc_checking_assert (fn->cfg->x_dom_computed[dir_index]);
if (node->father)
{
@@ -748,8 +740,8 @@ set_immediate_dominator (cdi_direction dir, basic_block bb,
if (dominated_by)
et_set_father (node, dominated_by->dom[dir_index]);
- if (dom_computed[dir_index] == DOM_OK)
- dom_computed[dir_index] = DOM_NO_FAST_QUERY;
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
+ fn->cfg->x_dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
/* Returns the list of basic blocks immediately dominated by BB, in the
@@ -761,8 +753,6 @@ get_dominated_by (cdi_direction dir, basic_block bb)
et_node *node = bb->dom[dir_index], *son = node->son;
vec<basic_block> bbs = vNULL;
- gcc_checking_assert (dom_computed[dir_index]);
-
if (!son)
return vNULL;
@@ -835,14 +825,14 @@ get_all_dominated_blocks (cdi_direction dir, basic_block bb)
/* Redirect all edges pointing to BB to TO. */
void
-redirect_immediate_dominators (cdi_direction dir, basic_block bb,
+redirect_immediate_dominators (function *fn, cdi_direction dir, basic_block bb,
basic_block to)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *bb_node = bb->dom[dir_index],
*to_node = to->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index]);
+ gcc_checking_assert (fn->cfg->x_dom_computed[dir_index]);
if (!bb_node->son)
return;
@@ -853,8 +843,8 @@ redirect_immediate_dominators (cdi_direction dir, basic_block bb,
et_set_father (son, to_node);
}
- if (dom_computed[dir_index] == DOM_OK)
- dom_computed[dir_index] = DOM_NO_FAST_QUERY;
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
+ fn->cfg->x_dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
/* Find first basic block in the tree dominating both BB1 and BB2. */
@@ -863,8 +853,6 @@ nearest_common_dominator (cdi_direction dir, basic_block bb1, basic_block bb2)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- gcc_checking_assert (dom_computed[dir_index]);
-
if (!bb1)
return bb2;
if (!bb2)
@@ -878,16 +866,17 @@ nearest_common_dominator (cdi_direction dir, basic_block bb1, basic_block bb2)
using dominance direction DIR. */
basic_block
-nearest_common_dominator_for_set (cdi_direction dir, bitmap blocks)
+nearest_common_dominator_for_set (function *fn, cdi_direction dir,
+ bitmap blocks)
{
unsigned i;
bitmap_iterator bi;
unsigned first = bitmap_first_set_bit (blocks);
- basic_block dom = BASIC_BLOCK_FOR_FN (cfun, first);
+ basic_block dom = BASIC_BLOCK_FOR_FN (fn, first);
EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
- if (dom != BASIC_BLOCK_FOR_FN (cfun, i))
- dom = nearest_common_dominator (dir, dom, BASIC_BLOCK_FOR_FN (cfun, i));
+ if (dom != BASIC_BLOCK_FOR_FN (fn, i))
+ dom = nearest_common_dominator (dir, dom, BASIC_BLOCK_FOR_FN (fn, i));
return dom;
}
@@ -969,14 +958,15 @@ nearest_common_dominator_for_set (cdi_direction dir, bitmap blocks)
/* Return TRUE in case BB1 is dominated by BB2. */
bool
-dominated_by_p (cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
+dominated_by_p (function *fn, cdi_direction dir, const_basic_block bb1,
+ const_basic_block bb2)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index]);
+ gcc_checking_assert (fn->cfg->x_dom_computed[dir_index]);
- if (dom_computed[dir_index] == DOM_OK)
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
return (n1->dfs_num_in >= n2->dfs_num_in
&& n1->dfs_num_out <= n2->dfs_num_out);
@@ -991,7 +981,6 @@ bb_dom_dfs_in (cdi_direction dir, basic_block bb)
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *n = bb->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
return n->dfs_num_in;
}
@@ -1003,25 +992,24 @@ bb_dom_dfs_out (cdi_direction dir, basic_block bb)
unsigned int dir_index = dom_convert_dir_to_idx (dir);
et_node *n = bb->dom[dir_index];
- gcc_checking_assert (dom_computed[dir_index] == DOM_OK);
return n->dfs_num_out;
}
/* Verify invariants of dominator structure. */
DEBUG_FUNCTION void
-verify_dominators (cdi_direction dir)
+verify_dominators (function *fn, cdi_direction dir)
{
bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
- gcc_assert (dom_info_available_p (dir));
+ gcc_assert (dom_info_available_p (fn, dir));
- dom_info di (cfun, dir);
+ dom_info di (fn, dir);
di.calc_dfs_tree (reverse);
di.calc_idoms (reverse);
bool err = false;
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fn)
{
basic_block imm_bb = get_immediate_dominator (dir, bb);
if (!imm_bb)
@@ -1048,20 +1036,17 @@ verify_dominators (cdi_direction dir)
reaches a fixed point. */
basic_block
-recompute_dominator (cdi_direction dir, basic_block bb)
+recompute_dominator (function *fn, cdi_direction dir, basic_block bb)
{
- unsigned int dir_index = dom_convert_dir_to_idx (dir);
basic_block dom_bb = NULL;
edge e;
edge_iterator ei;
- gcc_checking_assert (dom_computed[dir_index]);
-
if (dir == CDI_DOMINATORS)
{
FOR_EACH_EDGE (e, ei, bb->preds)
{
- if (!dominated_by_p (dir, e->src, bb))
+ if (!dominated_by_p (fn, dir, e->src, bb))
dom_bb = nearest_common_dominator (dir, dom_bb, e->src);
}
}
@@ -1069,7 +1054,7 @@ recompute_dominator (cdi_direction dir, basic_block bb)
{
FOR_EACH_EDGE (e, ei, bb->succs)
{
- if (!dominated_by_p (dir, e->dest, bb))
+ if (!dominated_by_p (fn, dir, e->dest, bb))
dom_bb = nearest_common_dominator (dir, dom_bb, e->dest);
}
}
@@ -1085,22 +1070,22 @@ recompute_dominator (cdi_direction dir, basic_block bb)
from BBS. */
static void
-prune_bbs_to_update_dominators (vec<basic_block> bbs, bool conservative)
+prune_bbs_to_update_dominators (function *fn, vec<basic_block> bbs,
+ bool conservative)
{
- unsigned i;
bool single;
basic_block bb, dom = NULL;
edge_iterator ei;
edge e;
- for (i = 0; bbs.iterate (i, &bb);)
+ for (unsigned i = 0; bbs.iterate (i, &bb);)
{
- if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
+ if (bb == ENTRY_BLOCK_PTR_FOR_FN (fn))
goto succeed;
if (single_pred_p (bb))
{
- set_immediate_dominator (CDI_DOMINATORS, bb, single_pred (bb));
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb, single_pred (bb));
goto succeed;
}
@@ -1111,7 +1096,7 @@ prune_bbs_to_update_dominators (vec<basic_block> bbs, bool conservative)
dom = NULL;
FOR_EACH_EDGE (e, ei, bb->preds)
{
- if (dominated_by_p (CDI_DOMINATORS, e->src, bb))
+ if (dominated_by_p (fn, CDI_DOMINATORS, e->src, bb))
continue;
if (!dom)
@@ -1127,7 +1112,7 @@ prune_bbs_to_update_dominators (vec<basic_block> bbs, bool conservative)
if (single
|| find_edge (dom, bb))
{
- set_immediate_dominator (CDI_DOMINATORS, bb, dom);
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb, dom);
goto succeed;
}
@@ -1155,8 +1140,8 @@ root_of_dom_tree (cdi_direction dir, basic_block bb)
blocks. */
static void
-determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
- int *brother)
+determine_dominators_for_sons (function *fn, graph *g, vec<basic_block> bbs,
+ int y, int *son, int *brother)
{
if (son[y] == -1)
return;
@@ -1165,8 +1150,8 @@ determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
{
/* Handle the common case Y has just one son specially. */
basic_block bb = bbs[son[y]];
- set_immediate_dominator (CDI_DOMINATORS, bb,
- recompute_dominator (CDI_DOMINATORS, bb));
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb,
+ recompute_dominator (fn, CDI_DOMINATORS, bb));
identify_vertices (g, y, son[y]);
return;
}
@@ -1184,7 +1169,7 @@ determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
basic_block ybb;
if (y == (int) bbs.length ())
- ybb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ ybb = ENTRY_BLOCK_PTR_FOR_FN (fn);
else
ybb = bbs[y];
@@ -1212,7 +1197,7 @@ determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
FOR_EACH_VEC_ELT (sccs[i], si, a)
{
basic_block bb = bbs[a];
- set_immediate_dominator (CDI_DOMINATORS, bb, dom);
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb, dom);
}
}
@@ -1232,7 +1217,7 @@ determine_dominators_for_sons (graph *g, vec<basic_block> bbs, int y, int *son,
a block of BBS in the current dominance tree dominate it. */
void
-iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
+iterate_fix_dominators (function *fn, cdi_direction dir, vec<basic_block> bbs,
bool conservative)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
@@ -1244,7 +1229,8 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
problems would be unused, untested, and almost surely buggy. We keep
the DIR argument for consistency with the rest of the dominator analysis
interface. */
- gcc_checking_assert (dir == CDI_DOMINATORS && dom_computed[dir_index]);
+ gcc_checking_assert (dir == CDI_DOMINATORS
+ && fn->cfg->x_dom_computed[dir_index]);
/* The algorithm we use takes inspiration from the following papers, although
the details are quite different from any of them:
@@ -1305,10 +1291,10 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
unsigned i;
basic_block bb;
FOR_EACH_VEC_ELT (bbs, i, bb)
- set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb, NULL);
}
- prune_bbs_to_update_dominators (bbs, conservative);
+ prune_bbs_to_update_dominators (fn, bbs, conservative);
int n = bbs.length ();
if (n == 0)
@@ -1317,8 +1303,8 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
if (n == 1)
{
basic_block bb = bbs[0];
- set_immediate_dominator (CDI_DOMINATORS, bb,
- recompute_dominator (CDI_DOMINATORS, bb));
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb,
+ recompute_dominator (fn, CDI_DOMINATORS, bb));
return;
}
@@ -1330,10 +1316,10 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
{
/* If the dominance tree is conservatively correct, split it now. */
if (conservative)
- set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
+ set_immediate_dominator (fn, CDI_DOMINATORS, bb, NULL);
map.put (bb, i);
}
- map.put (ENTRY_BLOCK_PTR_FOR_FN (cfun), n);
+ map.put (ENTRY_BLOCK_PTR_FOR_FN (fn), n);
graph *g = new_graph (n + 1);
for (int y = 0; y < g->n_vertices; y++)
@@ -1372,7 +1358,7 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
continue;
while (y != -1)
{
- determine_dominators_for_sons (g, bbs, y, son, brother);
+ determine_dominators_for_sons (fn, g, bbs, y, son, brother);
if (brother[y] != -1)
{
@@ -1392,33 +1378,34 @@ iterate_fix_dominators (cdi_direction dir, vec<basic_block> bbs,
}
void
-add_to_dominance_info (cdi_direction dir, basic_block bb)
+add_to_dominance_info (function *fn, cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- gcc_checking_assert (dom_computed[dir_index] && !bb->dom[dir_index]);
+ gcc_checking_assert (fn->cfg->x_dom_computed[dir_index]
+ && !bb->dom[dir_index]);
- n_bbs_in_dom_tree[dir_index]++;
+ fn->cfg->x_n_bbs_in_dom_tree[dir_index]++;
bb->dom[dir_index] = et_new_tree (bb);
- if (dom_computed[dir_index] == DOM_OK)
- dom_computed[dir_index] = DOM_NO_FAST_QUERY;
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
+ fn->cfg->x_dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
void
-delete_from_dominance_info (cdi_direction dir, basic_block bb)
+delete_from_dominance_info (function *fn, cdi_direction dir, basic_block bb)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- gcc_checking_assert (dom_computed[dir_index]);
+ gcc_checking_assert (fn->cfg->x_dom_computed[dir_index]);
et_free_tree (bb->dom[dir_index]);
bb->dom[dir_index] = NULL;
- n_bbs_in_dom_tree[dir_index]--;
+ fn->cfg->x_n_bbs_in_dom_tree[dir_index]--;
- if (dom_computed[dir_index] == DOM_OK)
- dom_computed[dir_index] = DOM_NO_FAST_QUERY;
+ if (fn->cfg->x_dom_computed[dir_index] == DOM_OK)
+ fn->cfg->x_dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
/* Returns the first son of BB in the dominator or postdominator tree
@@ -1457,20 +1444,14 @@ dom_info_state (function *fn, cdi_direction dir)
return fn->cfg->x_dom_computed[dir_index];
}
-dom_state
-dom_info_state (cdi_direction dir)
-{
- return dom_info_state (cfun, dir);
-}
-
/* Set the dominance availability for dominance info DIR to NEW_STATE. */
void
-set_dom_info_availability (cdi_direction dir, dom_state new_state)
+set_dom_info_availability (function *fn, cdi_direction dir, dom_state new_state)
{
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- dom_computed[dir_index] = new_state;
+ fn->cfg->x_dom_computed[dir_index] = new_state;
}
/* Returns true if dominance information for direction DIR is available. */
@@ -1481,17 +1462,11 @@ dom_info_available_p (function *fn, cdi_direction dir)
return dom_info_state (fn, dir) != DOM_NONE;
}
-bool
-dom_info_available_p (cdi_direction dir)
-{
- return dom_info_available_p (cfun, dir);
-}
-
DEBUG_FUNCTION void
-debug_dominance_info (cdi_direction dir)
+debug_dominance_info (function *fn, cdi_direction dir)
{
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fn)
if (basic_block bb2 = get_immediate_dominator (dir, bb))
fprintf (stderr, "%i %i\n", bb->index, bb2->index);
}
diff --git a/gcc/dominance.h b/gcc/dominance.h
index cc5be88..41ed936 100644
--- a/gcc/dominance.h
+++ b/gcc/dominance.h
@@ -35,11 +35,10 @@ enum dom_state
DOM_OK /* Everything is ok. */
};
-extern void calculate_dominance_info (cdi_direction);
+extern void calculate_dominance_info (function *, cdi_direction);
extern void free_dominance_info (function *, cdi_direction);
-extern void free_dominance_info (cdi_direction);
extern basic_block get_immediate_dominator (cdi_direction, basic_block);
-extern void set_immediate_dominator (cdi_direction, basic_block,
+extern void set_immediate_dominator (function *, cdi_direction, basic_block,
basic_block);
extern vec<basic_block> get_dominated_by (cdi_direction, basic_block);
extern vec<basic_block> get_dominated_by_region (cdi_direction, basic_block *,
@@ -47,26 +46,26 @@ extern vec<basic_block> get_dominated_by_region (cdi_direction, basic_block *,
extern vec<basic_block> get_dominated_to_depth (cdi_direction, basic_block,
int);
extern vec<basic_block> get_all_dominated_blocks (cdi_direction, basic_block);
-extern void redirect_immediate_dominators (cdi_direction, basic_block,
- basic_block);
+extern void redirect_immediate_dominators (function *, cdi_direction,
+ basic_block, basic_block);
extern basic_block nearest_common_dominator (cdi_direction,
basic_block, basic_block);
-extern basic_block nearest_common_dominator_for_set (cdi_direction, bitmap);
-extern bool dominated_by_p (cdi_direction, const_basic_block,
+extern basic_block nearest_common_dominator_for_set (function *, cdi_direction,
+ bitmap);
+extern bool dominated_by_p (function *fn, cdi_direction, const_basic_block,
const_basic_block);
unsigned bb_dom_dfs_in (cdi_direction, basic_block);
unsigned bb_dom_dfs_out (cdi_direction, basic_block);
-extern void verify_dominators (cdi_direction);
-basic_block recompute_dominator (cdi_direction, basic_block);
-extern void iterate_fix_dominators (cdi_direction, vec<basic_block> , bool);
-extern void add_to_dominance_info (cdi_direction, basic_block);
-extern void delete_from_dominance_info (cdi_direction, basic_block);
+extern void verify_dominators (function *, cdi_direction);
+basic_block recompute_dominator (function *, cdi_direction, basic_block);
+extern void iterate_fix_dominators (function *, cdi_direction,
+ vec<basic_block>, bool);
+extern void add_to_dominance_info (function *, cdi_direction, basic_block);
+extern void delete_from_dominance_info (function *, cdi_direction, basic_block);
extern basic_block first_dom_son (cdi_direction, basic_block);
extern basic_block next_dom_son (cdi_direction, basic_block);
extern dom_state dom_info_state (function *, cdi_direction);
-extern dom_state dom_info_state (cdi_direction);
-extern void set_dom_info_availability (cdi_direction, dom_state);
+extern void set_dom_info_availability (function *, cdi_direction, dom_state);
extern bool dom_info_available_p (function *, cdi_direction);
-extern bool dom_info_available_p (cdi_direction);
#endif /* GCC_DOMINANCE_H */
diff --git a/gcc/final.c b/gcc/final.c
index 5d91609..18f244f 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -802,7 +802,7 @@ compute_alignments (void)
}
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
return 0;
}
diff --git a/gcc/function.h b/gcc/function.h
index e92c17c..24c366c 100644
--- a/gcc/function.h
+++ b/gcc/function.h
@@ -452,8 +452,6 @@ set_loops_for_fn (struct function *fn, struct loops *loops)
#define current_function_funcdef_no (cfun->funcdef_no)
#define current_loops (cfun->x_current_loops)
-#define dom_computed (cfun->cfg->x_dom_computed)
-#define n_bbs_in_dom_tree (cfun->cfg->x_n_bbs_in_dom_tree)
#define VALUE_HISTOGRAMS(fun) (fun)->value_histograms
/* A pointer to a function to create target specific, per-function
diff --git a/gcc/fwprop.c b/gcc/fwprop.c
index 16c7981..bbddc39 100644
--- a/gcc/fwprop.c
+++ b/gcc/fwprop.c
@@ -739,7 +739,7 @@ use_killed_between (df_ref use, rtx_insn *def_insn, rtx_insn *target_insn)
cases and assume that DEF is not available. */
if (def_bb == target_bb
? DF_INSN_LUID (def_insn) >= DF_INSN_LUID (target_insn)
- : !dominated_by_p (CDI_DOMINATORS, target_bb, def_bb))
+ : !dominated_by_p (cfun, CDI_DOMINATORS, target_bb, def_bb))
return true;
/* Check if the reg in USE has only one definition. We already
@@ -1395,7 +1395,7 @@ static void
fwprop_init (void)
{
num_changes = 0;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* We do not always want to propagate into loops, so we have to find
loops and be careful about them. Avoid CFG modifications so that
@@ -1423,7 +1423,7 @@ fwprop_done (void)
sparseset_free (active_defs_check);
#endif
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
cleanup_cfg (0);
delete_trivially_dead_insns (get_insns (), max_reg_num ());
diff --git a/gcc/gcse.c b/gcc/gcse.c
index 4d95b48..fb181dd 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -2717,7 +2717,7 @@ free_code_hoist_mem (void)
sbitmap_vector_free (hoist_vbein);
sbitmap_vector_free (hoist_vbeout);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* Compute the very busy expressions at entry/exit from each block.
@@ -2787,7 +2787,7 @@ compute_code_hoist_data (void)
compute_local_properties (transp, comp, antloc, &expr_hash_table);
prune_expressions (false);
compute_code_hoist_vbeinout ();
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
if (dump_file)
fprintf (dump_file, "\n");
}
@@ -3231,7 +3231,8 @@ hoist_code (void)
{
basic_block lca;
- lca = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ lca = nearest_common_dominator_for_set (cfun,
+ CDI_DOMINATORS,
from_bbs);
if (lca != bb)
/* Punt, it's better to hoist these occurrences to
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index de64c05..8e5c02b 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -4346,9 +4346,9 @@ and_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
/* In simple cases we can look through PHI nodes,
but we have to be careful with loops.
See PR49073. */
- if (! dom_info_available_p (CDI_DOMINATORS)
+ if (! dom_info_available_p (cfun, CDI_DOMINATORS)
|| gimple_bb (def_stmt) == gimple_bb (stmt)
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (def_stmt),
gimple_bb (stmt)))
return NULL_TREE;
@@ -4810,9 +4810,9 @@ or_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
/* In simple cases we can look through PHI nodes,
but we have to be careful with loops.
See PR49073. */
- if (! dom_info_available_p (CDI_DOMINATORS)
+ if (! dom_info_available_p (cfun, CDI_DOMINATORS)
|| gimple_bb (def_stmt) == gimple_bb (stmt)
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (def_stmt),
gimple_bb (stmt)))
return NULL_TREE;
diff --git a/gcc/gimple-ssa-isolate-paths.c b/gcc/gimple-ssa-isolate-paths.c
index 6f84f85..3e75f64 100644
--- a/gcc/gimple-ssa-isolate-paths.c
+++ b/gcc/gimple-ssa-isolate-paths.c
@@ -452,10 +452,10 @@ find_explicit_erroneous_behaviour (void)
|| TREE_CODE (valbase) == PARM_DECL)
{
/* We only need it for this particular case. */
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
const char* msg;
bool always_executed = dominated_by_p
- (CDI_POST_DOMINATORS,
+ (cfun, CDI_POST_DOMINATORS,
single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)), bb);
if (always_executed)
msg = N_("function returns address of local variable");
@@ -530,10 +530,10 @@ gimple_ssa_isolate_erroneous_paths (void)
/* We scramble the CFG and loop structures a bit, clean up
appropriately. We really should incrementally update the
loop structures, in theory it shouldn't be that hard. */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
if (cfg_altered)
{
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
loops_state_set (LOOPS_NEED_FIXUP);
return TODO_cleanup_cfg | TODO_update_ssa;
}
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index b369ef5..3b38fcf 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -515,7 +515,7 @@ find_basis_for_base_expr (slsr_cand_t c, tree base_expr)
|| one_basis->cand_stmt == c->cand_stmt
|| !operand_equal_p (one_basis->stride, c->stride, 0)
|| !types_compatible_p (one_basis->cand_type, c->cand_type)
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (c->cand_stmt),
gimple_bb (one_basis->cand_stmt)))
continue;
@@ -555,7 +555,7 @@ find_basis_for_candidate (slsr_cand_t c)
basis_bb = gimple_bb (basis->cand_stmt);
if (phi_bb == basis_bb
- || !dominated_by_p (CDI_DOMINATORS, phi_bb, basis_bb))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, phi_bb, basis_bb))
{
basis = NULL;
c->basis = 0;
@@ -2361,7 +2361,8 @@ phi_add_costs (gimple phi, slsr_cand_t c, int one_add_cost)
slsr_cand_t basis = lookup_cand (c->basis);
basic_block basis_bb = gimple_bb (basis->cand_stmt);
- if (phi_bb == basis_bb || !dominated_by_p (CDI_DOMINATORS, phi_bb, basis_bb))
+ if (phi_bb == basis_bb
+ || !dominated_by_p (cfun, CDI_DOMINATORS, phi_bb, basis_bb))
return COST_INFINITE;
for (i = 0; i < gimple_phi_num_args (phi); i++)
@@ -2487,7 +2488,7 @@ record_increment (slsr_cand_t c, widest_int increment, bool is_phi_adjust)
dominate this candidate, it's not going to be useful to
us after all. */
if (incr_vec[i].initializer
- && !dominated_by_p (CDI_DOMINATORS,
+ && !dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (c->cand_stmt),
incr_vec[i].init_bb))
{
diff --git a/gcc/graphite-isl-ast-to-gimple.c b/gcc/graphite-isl-ast-to-gimple.c
index dfb012f..7ae55d0 100644
--- a/gcc/graphite-isl-ast-to-gimple.c
+++ b/gcc/graphite-isl-ast-to-gimple.c
@@ -581,7 +581,7 @@ translate_isl_ast_for_loop (loop_p context_loop,
next_e = translate_isl_ast (loop, for_body, to_body, ip);
isl_ast_node_free (for_body);
redirect_edge_succ_nodup (next_e, after);
- set_immediate_dominator (CDI_DOMINATORS, next_e->dest, next_e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, next_e->dest, next_e->src);
if (flag_loop_parallelize_all)
{
diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index fb7247e..d7dc641 100644
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -606,7 +606,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
/* If we do not dominate result.next, remove it. It's either
the exit block, or another bb dominates it and will
call the scop detection for this bb. */
- if (!dominated_by_p (CDI_DOMINATORS, result.next, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, result.next, bb))
result.next = NULL;
if (exit_e->src->loop_father != loop)
@@ -645,7 +645,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
- The loop dominates bbs, that are not exit destinations. */
FOR_EACH_VEC_ELT (exits, i, e)
if (e->src->loop_father == loop
- && dominated_by_p (CDI_DOMINATORS, e->dest, e->src))
+ && dominated_by_p (cfun, CDI_DOMINATORS, e->dest, e->src))
{
if (loop_outer (outermost_loop))
outermost_loop = loop_outer (outermost_loop);
@@ -718,7 +718,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
continue;
}
- if (!dominated_by_p (CDI_DOMINATORS, e->dest, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, e->dest, bb))
{
result.difficult = true;
continue;
@@ -752,7 +752,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
{
/* Only return a next pointer if we dominate this pointer.
Otherwise it will be handled by the bb dominating it. */
- if (dominated_by_p (CDI_DOMINATORS, last_exit, bb)
+ if (dominated_by_p (cfun, CDI_DOMINATORS, last_exit, bb)
&& last_exit != bb)
result.next = last_exit;
else
@@ -992,7 +992,7 @@ create_single_entry_edge (sd_region *region)
| 5 */
if (region->entry->loop_father->header != region->entry
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
loop_latch_edge (region->entry->loop_father)->src,
region->exit))
{
@@ -1128,7 +1128,7 @@ create_sese_edges (vec<sd_region> regions)
unmark_exit_edges (regions);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
fix_loop_structure (NULL);
#ifdef ENABLE_CHECKING
@@ -1441,7 +1441,7 @@ canonicalize_loop_closed_ssa (loop_p loop)
/* The code above does not properly handle changes in the post dominance
information (yet). */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
}
/* Converts the current loop closed SSA form to a canonical form
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index fdcc790..5d8c148 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -342,7 +342,7 @@ all_non_dominated_preds_marked_p (basic_block bb, sbitmap map)
FOR_EACH_EDGE (e, ei, bb->preds)
if (!bitmap_bit_p (map, e->src->index)
- && !dominated_by_p (CDI_DOMINATORS, e->src, bb))
+ && !dominated_by_p (cfun, CDI_DOMINATORS, e->src, bb))
return false;
return true;
@@ -2930,7 +2930,7 @@ dr_indices_valid_in_loop (tree ref ATTRIBUTE_UNUSED, tree *index, void *data)
if (!def_bb)
return true;
- return dominated_by_p (CDI_DOMINATORS, header, def_bb);
+ return dominated_by_p (cfun, CDI_DOMINATORS, header, def_bb);
}
/* When the result of a CLOSE_PHI is written to a memory location,
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index 0912606..a14dc76 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -8216,8 +8216,8 @@ sched_create_recovery_edges (basic_block first_bb, basic_block rec,
edge_flags = 0;
make_single_succ_edge (rec, second_bb, edge_flags);
- if (dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, rec, first_bb);
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
+ set_immediate_dominator (cfun, CDI_DOMINATORS, rec, first_bb);
}
/* This function creates recovery code for INSN. If MUTATE_P is nonzero,
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index a46efec..1e090bf 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -3548,7 +3548,7 @@ find_if_header (basic_block test_bb, int pass)
&& find_cond_trap (test_bb, then_edge, else_edge))
goto success;
- if (dom_info_state (CDI_POST_DOMINATORS) >= DOM_NO_FAST_QUERY
+ if (dom_info_state (cfun, CDI_POST_DOMINATORS) >= DOM_NO_FAST_QUERY
&& (reload_completed || !targetm.have_conditional_execution ()))
{
if (find_if_case_1 (test_bb, then_edge, else_edge))
@@ -4263,7 +4263,7 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
if (else_prob > then_prob)
;
else if (else_succ->dest->index < NUM_FIXED_BLOCKS
- || dominated_by_p (CDI_POST_DOMINATORS, then_bb,
+ || dominated_by_p (cfun, CDI_POST_DOMINATORS, then_bb,
else_succ->dest))
;
else
@@ -4652,10 +4652,10 @@ if_convert (bool after_combine)
loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
mark_loop_exit_edges ();
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
/* Compute postdominators. */
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
df_set_flags (DF_LR_RUN_DCE);
@@ -4696,7 +4696,7 @@ if_convert (bool after_combine)
fprintf (dump_file, "\n\n========== no more changes\n");
#endif
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
if (dump_file)
fflush (dump_file);
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 3a8f0ec..f8f0fa9 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -2501,7 +2501,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
if (opt_for_fn (node->decl, optimize))
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
if (!early)
loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
else
@@ -2858,7 +2858,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
loop_optimizer_finalize ();
else if (!ipa_edge_args_vector)
ipa_free_all_node_params ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
if (dump_file)
{
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index c862cff..adb4096 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -2296,7 +2296,7 @@ ipa_analyze_node (struct cgraph_node *node)
struct function *func = DECL_STRUCT_FUNCTION (node->decl);
push_cfun (func);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (func, CDI_DOMINATORS);
ipa_initialize_node_params (node);
ipa_analyze_controlled_uses (node);
@@ -2326,7 +2326,7 @@ ipa_analyze_node (struct cgraph_node *node)
FOR_EACH_VEC_ELT (fbi.bb_infos, i, bi)
free_ipa_bb_info (bi);
fbi.bb_infos.release ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (func, CDI_DOMINATORS);
pop_cfun ();
}
@@ -5281,7 +5281,7 @@ ipcp_transform_function (struct cgraph_node *node)
descriptors.safe_grow_cleared (param_count);
ipa_populate_param_decls (node, descriptors);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
ipcp_modif_dom_walker (&fbi, descriptors, aggval, &something_changed,
&cfg_changed).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
@@ -5290,7 +5290,7 @@ ipcp_transform_function (struct cgraph_node *node)
FOR_EACH_VEC_ELT (fbi.bb_infos, i, bi)
free_ipa_bb_info (bi);
fbi.bb_infos.release ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
(*ipcp_transformations)[node->uid].agg_values = NULL;
(*ipcp_transformations)[node->uid].alignments = NULL;
descriptors.release ();
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index 69f293f..3cea9a8 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -402,7 +402,7 @@ dominated_by_forbidden (basic_block bb)
EXECUTE_IF_SET_IN_BITMAP (forbidden_dominators, 1, dom_bb, bi)
{
- if (dominated_by_p (CDI_DOMINATORS, bb,
+ if (dominated_by_p (cfun, CDI_DOMINATORS, bb,
BASIC_BLOCK_FOR_FN (cfun, dom_bb)))
return true;
}
@@ -1668,8 +1668,8 @@ split_function (basic_block return_bb, struct split_point *split_point,
gsi_insert_after (&gsi, ret, GSI_NEW_STMT);
}
}
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
compute_inline_parameters (node, true);
}
@@ -1767,7 +1767,7 @@ execute_split_functions (void)
/* Initialize bitmap to track forbidden calls. */
forbidden_dominators = BITMAP_ALLOC (NULL);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* Compute local info about basic blocks and determine function size/time. */
bb_info_vec.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1);
diff --git a/gcc/ira.c b/gcc/ira.c
index 23ed1db..a49daff 100644
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -4397,7 +4397,7 @@ insn_dominated_by_p (rtx i1, rtx i2, int *uid_luid)
if (bb1 == bb2)
return uid_luid[INSN_UID (i2)] < uid_luid[INSN_UID (i1)];
- return dominated_by_p (CDI_DOMINATORS, bb1, bb2);
+ return dominated_by_p (cfun, CDI_DOMINATORS, bb1, bb2);
}
/* Record the range of register numbers added by find_moveable_pseudos. */
@@ -4458,7 +4458,7 @@ find_moveable_pseudos (void)
pseudo_replaced_reg.safe_grow_cleared (max_regs);
df_analyze ();
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
i = 0;
bitmap_initialize (&live, 0);
@@ -4774,7 +4774,7 @@ find_moveable_pseudos (void)
regstat_free_ri ();
regstat_init_n_sets_and_refs ();
regstat_compute_ri ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* If SET pattern SET is an assignment from a hard register to a pseudo which
@@ -4919,7 +4919,7 @@ split_live_ranges_for_shrink_wrap (void)
return false;
}
- call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, &need_new);
+ call_dom = nearest_common_dominator_for_set (cfun, CDI_DOMINATORS, &need_new);
bitmap_clear (&need_new);
if (call_dom == first)
return false;
@@ -4932,13 +4932,13 @@ split_live_ranges_for_shrink_wrap (void)
if (call_dom == first)
return false;
- calculate_dominance_info (CDI_POST_DOMINATORS);
- if (dominated_by_p (CDI_POST_DOMINATORS, first, call_dom))
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
+ if (dominated_by_p (cfun, CDI_POST_DOMINATORS, first, call_dom))
{
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
return false;
}
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
if (dump_file)
fprintf (dump_file, "Will split live ranges of parameters at BB %i\n",
@@ -4960,7 +4960,7 @@ split_live_ranges_for_shrink_wrap (void)
basic_block ubb = BLOCK_FOR_INSN (uin);
if (ubb == call_dom
- || dominated_by_p (CDI_DOMINATORS, ubb, call_dom))
+ || dominated_by_p (cfun, CDI_DOMINATORS, ubb, call_dom))
{
if (!newreg)
newreg = ira_create_new_reg (dest);
@@ -5163,12 +5163,12 @@ ira (FILE *f)
init_reg_equiv ();
if (ira_conflicts_p)
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
if (split_live_ranges_for_shrink_wrap ())
df_analyze ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
df_clear_flags (DF_NO_INSN_RESCAN);
@@ -5293,7 +5293,7 @@ ira (FILE *f)
change if new insns were generated? Can that be handled
by updating the loop tree incrementally? */
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
loop_optimizer_init (AVOID_CFG_MODIFICATIONS
| LOOPS_HAVE_RECORDED_EXITS);
@@ -5383,7 +5383,7 @@ do_reload (void)
if (current_loops != NULL)
{
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
FOR_ALL_BB_FN (bb, cfun)
bb->loop_father = NULL;
@@ -5430,7 +5430,7 @@ do_reload (void)
if (current_loops != NULL)
{
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
FOR_ALL_BB_FN (bb, cfun)
bb->loop_father = NULL;
diff --git a/gcc/loop-doloop.c b/gcc/loop-doloop.c
index 6554597..aa0ad99 100644
--- a/gcc/loop-doloop.c
+++ b/gcc/loop-doloop.c
@@ -505,7 +505,7 @@ doloop_modify (struct loop *loop, struct niter_desc *desc,
/* Expand the condition testing the assumptions and if it does not pass,
reset the count register to 0. */
redirect_edge_and_branch_force (single_succ_edge (preheader), new_preheader);
- set_immediate_dominator (CDI_DOMINATORS, new_preheader, preheader);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_preheader, preheader);
set_zero->count = 0;
set_zero->frequency = 0;
@@ -542,13 +542,13 @@ doloop_modify (struct loop *loop, struct niter_desc *desc,
end_sequence ();
emit_insn_after (sequence, BB_END (set_zero));
- set_immediate_dominator (CDI_DOMINATORS, set_zero,
- recompute_dominator (CDI_DOMINATORS,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, set_zero,
+ recompute_dominator (cfun, CDI_DOMINATORS,
set_zero));
}
- set_immediate_dominator (CDI_DOMINATORS, new_preheader,
- recompute_dominator (CDI_DOMINATORS,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_preheader,
+ recompute_dominator (cfun, CDI_DOMINATORS,
new_preheader));
}
diff --git a/gcc/loop-init.c b/gcc/loop-init.c
index a9a3d6fa..fba7198 100644
--- a/gcc/loop-init.c
+++ b/gcc/loop-init.c
@@ -102,7 +102,7 @@ loop_optimizer_init (unsigned flags)
gcc_assert (cfun->curr_properties & PROP_loops);
/* Ensure that the dominators are computed, like flow_loops_find does. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
#ifdef ENABLE_CHECKING
if (!needs_fixup)
@@ -211,7 +211,7 @@ fix_loop_structure (bitmap changed_bbs)
fprintf (dump_file, "fix_loop_structure: fixing up loops for function\n");
/* We need exact and fast dominance info to be available. */
- gcc_assert (dom_info_state (CDI_DOMINATORS) == DOM_OK);
+ gcc_assert (dom_info_state (cfun, CDI_DOMINATORS) == DOM_OK);
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
{
@@ -480,7 +480,7 @@ pass_rtl_loop_done::execute (function *fun)
/* No longer preserve loops, remove them now. */
fun->curr_properties &= ~PROP_loops;
loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
cleanup_cfg (0);
if (dump_file)
diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index 52c8ae8..4a106a3 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -288,7 +288,7 @@ invariant_for_use (df_ref use)
return NULL;
def_bb = DF_REF_BB (def);
- if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, bb, def_bb))
return NULL;
return invariant_table[DF_REF_ID (def)];
}
@@ -563,7 +563,7 @@ compute_always_reached (struct loop *loop, basic_block *body,
for (i = 0; i < loop->num_nodes; i++)
{
- if (dominated_by_p (CDI_DOMINATORS, loop->latch, body[i]))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, body[i]))
bitmap_set_bit (always_reached, i);
if (bitmap_bit_p (may_exit, i))
@@ -832,7 +832,7 @@ check_dependency (basic_block bb, df_ref use, bitmap depends_on)
dominates insn, because def has invariant_table[DF_REF_ID(def)]
defined and we process the insns in the basic block bb
sequentially. */
- if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, bb, def_bb))
return false;
bitmap_set_bit (depends_on, def_data->invno);
@@ -1542,7 +1542,7 @@ can_move_invariant_reg (struct loop *loop, struct invariant *inv, rtx reg)
/* Don't move if a use is not dominated by def in insn. */
if (use_bb == bb && DF_INSN_LUID (insn) >= DF_INSN_LUID (use_insn))
return false;
- if (!dominated_by_p (CDI_DOMINATORS, use_bb, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, use_bb, bb))
return false;
}
diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c
index 6e9cc8c..c7f2cad 100644
--- a/gcc/loop-iv.c
+++ b/gcc/loop-iv.c
@@ -372,7 +372,7 @@ iv_get_reaching_def (rtx_insn *insn, rtx reg, df_ref *def)
if (use_bb == def_bb)
dom_p = (DF_INSN_LUID (def_insn) < DF_INSN_LUID (insn));
else
- dom_p = dominated_by_p (CDI_DOMINATORS, use_bb, def_bb);
+ dom_p = dominated_by_p (cfun, CDI_DOMINATORS, use_bb, def_bb);
if (dom_p)
{
@@ -2901,7 +2901,7 @@ check_simple_exit (struct loop *loop, edge e, struct niter_desc *desc)
return;
/* It must be tested (at least) once during any iteration. */
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit_bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, exit_bb))
return;
/* It must end in a simple conditional jump. */
diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index 913bd3c..b7a3319 100644
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -314,7 +314,7 @@ unroll_loops (int flags)
if (changed)
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
fix_loop_structure (NULL);
}
@@ -978,7 +978,7 @@ unroll_loop_runtime_iterations (struct loop *loop)
gcc_assert (branch_code != NULL_RTX);
swtch = split_edge_and_insert (single_pred_edge (swtch), branch_code);
- set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, preheader, swtch);
single_pred_edge (swtch)->probability = REG_BR_PROB_BASE - p;
e = make_edge (swtch, preheader,
single_succ_edge (swtch)->flags & EDGE_IRREDUCIBLE_LOOP);
@@ -998,7 +998,7 @@ unroll_loop_runtime_iterations (struct loop *loop)
gcc_assert (branch_code != NULL_RTX);
swtch = split_edge_and_insert (single_succ_edge (swtch), branch_code);
- set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, preheader, swtch);
single_succ_edge (swtch)->probability = REG_BR_PROB_BASE - p;
e = make_edge (swtch, preheader,
single_succ_edge (swtch)->flags & EDGE_IRREDUCIBLE_LOOP);
@@ -1007,7 +1007,7 @@ unroll_loop_runtime_iterations (struct loop *loop)
}
/* Recount dominators for outer blocks. */
- iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, dom_bbs, false);
/* And unroll loop. */
@@ -1562,7 +1562,7 @@ analyze_insns_in_loop (struct loop *loop)
for (i = 0; i < loop->num_nodes; i++)
{
bb = body[i];
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
continue;
FOR_BB_INSNS (bb, insn)
diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c
index 2eb8051..d5172c4 100644
--- a/gcc/lto-streamer-in.c
+++ b/gcc/lto-streamer-in.c
@@ -1152,8 +1152,8 @@ input_function (tree fn_decl, struct data_in *data_in,
execute_all_ipa_stmt_fixups (node, stmts);
update_ssa (TODO_update_ssa_only_virtuals);
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
free (stmts);
pop_cfun ();
}
diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c
index d9596c3..1f92368 100644
--- a/gcc/modulo-sched.c
+++ b/gcc/modulo-sched.c
@@ -3386,7 +3386,7 @@ pass_sms::execute (function *fun ATTRIBUTE_UNUSED)
FOR_EACH_BB_FN (bb, fun)
if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun))
bb->aux = bb->next_bb;
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
cfg_layout_finalize ();
#endif /* INSN_SCHEDULING */
return 0;
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index c1dc919..106c5b5 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -4919,8 +4919,8 @@ expand_parallel_call (struct omp_region *region, basic_block bb,
then_bb = create_empty_bb (cond_bb);
else_bb = create_empty_bb (then_bb);
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
- set_immediate_dominator (CDI_DOMINATORS, else_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, then_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, else_bb, cond_bb);
stmt = gimple_build_cond_empty (cond);
gsi = gsi_start_bb (cond_bb);
@@ -5512,7 +5512,7 @@ expand_omp_taskreg (struct omp_region *region)
e2 = make_edge (e->src, BRANCH_EDGE (entry_bb)->dest, EDGE_ABNORMAL);
gcc_assert (e2->dest == region->exit);
remove_edge (BRANCH_EDGE (entry_bb));
- set_immediate_dominator (CDI_DOMINATORS, e2->dest, e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, e2->dest, e->src);
gsi = gsi_last_bb (region->exit);
gcc_assert (!gsi_end_p (gsi)
&& gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN);
@@ -5552,7 +5552,7 @@ expand_omp_taskreg (struct omp_region *region)
if (!exit_bb)
make_edge (new_bb, dest_bb, EDGE_FALLTHRU);
remove_edge (e2);
- set_immediate_dominator (CDI_DOMINATORS, dest_bb, new_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dest_bb, new_bb);
}
/* When the OMP expansion process cannot guarantee an up-to-date
loop tree arrange for the child function to fixup loops. */
@@ -5753,7 +5753,7 @@ expand_omp_for_init_counts (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
assign_stmt = gimple_build_assign (fd->loop.n2,
build_zero_cst (type));
gsi_insert_before (gsi, assign_stmt, GSI_SAME_STMT);
- set_immediate_dominator (CDI_DOMINATORS, zero_iter_bb,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, zero_iter_bb,
entry_bb);
}
ne = make_edge (entry_bb, zero_iter_bb, EDGE_FALSE_VALUE);
@@ -5952,7 +5952,7 @@ extract_omp_for_update_vars (struct omp_for_data *fd, basic_block cont_bb,
else
collapse_bb = bb;
- set_immediate_dominator (CDI_DOMINATORS, bb, last_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb, last_bb);
if (POINTER_TYPE_P (vtype))
t = fold_build_pointer_plus (fd->loops[i].v, fd->loops[i].step);
@@ -6177,7 +6177,7 @@ expand_omp_for_generic (struct omp_region *region,
entry_bb = e->dest;
make_edge (zero_iter_bb, entry_bb, EDGE_FALLTHRU);
gsi = gsi_last_bb (entry_bb);
- set_immediate_dominator (CDI_DOMINATORS, entry_bb,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, entry_bb,
get_immediate_dominator (CDI_DOMINATORS,
zero_iter_bb));
}
@@ -6443,14 +6443,14 @@ expand_omp_for_generic (struct omp_region *region,
}
make_edge (l2_bb, l0_bb, EDGE_TRUE_VALUE);
- set_immediate_dominator (CDI_DOMINATORS, l2_bb,
- recompute_dominator (CDI_DOMINATORS, l2_bb));
- set_immediate_dominator (CDI_DOMINATORS, l3_bb,
- recompute_dominator (CDI_DOMINATORS, l3_bb));
- set_immediate_dominator (CDI_DOMINATORS, l0_bb,
- recompute_dominator (CDI_DOMINATORS, l0_bb));
- set_immediate_dominator (CDI_DOMINATORS, l1_bb,
- recompute_dominator (CDI_DOMINATORS, l1_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l2_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, l2_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l3_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, l3_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l0_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, l0_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l1_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, l1_bb));
struct loop *outer_loop = alloc_loop ();
outer_loop->header = l0_bb;
@@ -6844,14 +6844,14 @@ expand_omp_for_static_nochunk (struct omp_region *region,
= ep ? EDGE_FALSE_VALUE : EDGE_FALLTHRU;
}
- set_immediate_dominator (CDI_DOMINATORS, second_bb, entry_bb);
- set_immediate_dominator (CDI_DOMINATORS, third_bb, entry_bb);
- set_immediate_dominator (CDI_DOMINATORS, seq_start_bb, third_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, second_bb, entry_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, third_bb, entry_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, seq_start_bb, third_bb);
- set_immediate_dominator (CDI_DOMINATORS, body_bb,
- recompute_dominator (CDI_DOMINATORS, body_bb));
- set_immediate_dominator (CDI_DOMINATORS, fin_bb,
- recompute_dominator (CDI_DOMINATORS, fin_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, body_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, body_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, fin_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, fin_bb));
struct loop *loop = body_bb->loop_father;
if (loop != entry_bb->loop_father)
@@ -7322,15 +7322,15 @@ expand_omp_for_static_chunk (struct omp_region *region,
}
if (!broken_loop)
- set_immediate_dominator (CDI_DOMINATORS, trip_update_bb, cont_bb);
- set_immediate_dominator (CDI_DOMINATORS, iter_part_bb,
- recompute_dominator (CDI_DOMINATORS, iter_part_bb));
- set_immediate_dominator (CDI_DOMINATORS, fin_bb,
- recompute_dominator (CDI_DOMINATORS, fin_bb));
- set_immediate_dominator (CDI_DOMINATORS, seq_start_bb,
- recompute_dominator (CDI_DOMINATORS, seq_start_bb));
- set_immediate_dominator (CDI_DOMINATORS, body_bb,
- recompute_dominator (CDI_DOMINATORS, body_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, trip_update_bb, cont_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, iter_part_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, iter_part_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, fin_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, fin_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, seq_start_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, seq_start_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, body_bb,
+ recompute_dominator (cfun, CDI_DOMINATORS, body_bb));
if (!broken_loop)
{
@@ -7503,9 +7503,9 @@ expand_cilk_for (struct omp_region *region, struct omp_for_data *fd)
e->probability = REG_BR_PROB_BASE * 7 / 8;
ne->probability = REG_BR_PROB_BASE / 8;
- set_immediate_dominator (CDI_DOMINATORS, l1_bb, entry_bb);
- set_immediate_dominator (CDI_DOMINATORS, l2_bb, l2_dom_bb);
- set_immediate_dominator (CDI_DOMINATORS, l0_bb, l1_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l1_bb, entry_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l2_bb, l2_dom_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l0_bb, l1_bb);
if (!broken_loop)
{
@@ -7803,9 +7803,9 @@ expand_omp_simd (struct omp_region *region, struct omp_for_data *fd)
e->probability = REG_BR_PROB_BASE * 7 / 8;
ne->probability = REG_BR_PROB_BASE / 8;
- set_immediate_dominator (CDI_DOMINATORS, l1_bb, entry_bb);
- set_immediate_dominator (CDI_DOMINATORS, l2_bb, l2_dom_bb);
- set_immediate_dominator (CDI_DOMINATORS, l0_bb, l1_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l1_bb, entry_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l2_bb, l2_dom_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, l0_bb, l1_bb);
if (!broken_loop)
{
@@ -8140,7 +8140,7 @@ expand_omp_sections (struct omp_region *region)
gsi_insert_after (&si, stmt, GSI_SAME_STMT);
gsi_remove (&si, true);
- set_immediate_dominator (CDI_DOMINATORS, default_bb, l0_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, default_bb, l0_bb);
}
@@ -9099,8 +9099,8 @@ expand_omp_target (struct omp_region *region)
then_bb = create_empty_bb (cond_bb);
else_bb = create_empty_bb (then_bb);
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
- set_immediate_dominator (CDI_DOMINATORS, else_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, then_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, else_bb, cond_bb);
stmt = gimple_build_cond_empty (cond);
gsi = gsi_last_bb (cond_bb);
@@ -9491,7 +9491,7 @@ static void
build_omp_regions (void)
{
gcc_assert (root_omp_region == NULL);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
build_omp_regions_1 (ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, false);
}
@@ -13578,7 +13578,7 @@ simd_clone_adjust (struct cgraph_node *node)
}
}
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
add_loop (loop, loop->header->loop_father);
update_ssa (TODO_update_ssa);
diff --git a/gcc/passes.c b/gcc/passes.c
index d8e9271..521811c 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -2383,8 +2383,8 @@ execute_pass_list (function *fn, opt_pass *pass)
execute_pass_list_1 (pass);
if (fn->cfg)
{
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fn, CDI_DOMINATORS);
+ free_dominance_info (fn, CDI_POST_DOMINATORS);
}
pop_cfun ();
}
diff --git a/gcc/predict.c b/gcc/predict.c
index 965d7cb..4f22714 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -2296,8 +2296,8 @@ tree_estimate_probability_bb (basic_block bb)
/* Look for block we are guarding (ie we dominate it,
but it doesn't postdominate us). */
if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun) && e->dest != bb
- && dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
- && !dominated_by_p (CDI_POST_DOMINATORS, e->src, e->dest))
+ && dominated_by_p (cfun, CDI_DOMINATORS, e->dest, e->src)
+ && !dominated_by_p (cfun, CDI_POST_DOMINATORS, e->src, e->dest))
{
gimple_stmt_iterator bi;
@@ -2337,7 +2337,7 @@ tree_estimate_probability (void)
/* We use loop_niter_by_eval, which requires that the loops have
preheaders. */
create_preheaders (CP_SIMPLE_PREHEADERS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
bb_predictions = new hash_map<const_basic_block, edge_prediction *>;
tree_bb_level_predictions ();
@@ -2359,7 +2359,7 @@ tree_estimate_probability (void)
bb_predictions = NULL;
estimate_bb_frequencies (false);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
remove_fake_exit_edges ();
}
\f
@@ -2380,7 +2380,7 @@ predict_paths_for_bb (basic_block cur, basic_block bb,
set of all blocks postdominated by BB. */
FOR_EACH_EDGE (e, ei, cur->preds)
if (e->src->index >= NUM_FIXED_BLOCKS
- && !dominated_by_p (CDI_POST_DOMINATORS, e->src, bb))
+ && !dominated_by_p (cfun, CDI_POST_DOMINATORS, e->src, bb))
{
edge e2;
edge_iterator ei2;
@@ -2389,14 +2389,15 @@ predict_paths_for_bb (basic_block cur, basic_block bb,
/* Ignore fake edges and eh, we predict them as not taken anyway. */
if (e->flags & (EDGE_EH | EDGE_FAKE))
continue;
- gcc_assert (bb == cur || dominated_by_p (CDI_POST_DOMINATORS, cur, bb));
+ gcc_assert (bb == cur
+ || dominated_by_p (cfun, CDI_POST_DOMINATORS, cur, bb));
/* See if there is an edge from e->src that is not abnormal
and does not lead to BB. */
FOR_EACH_EDGE (e2, ei2, e->src->succs)
if (e2 != e
&& !(e2->flags & (EDGE_EH | EDGE_FAKE))
- && !dominated_by_p (CDI_POST_DOMINATORS, e2->dest, bb))
+ && !dominated_by_p (cfun, CDI_POST_DOMINATORS, e2->dest, bb))
{
found = true;
break;
@@ -2446,7 +2447,7 @@ predict_paths_leading_to_edge (edge e, enum br_predictor pred,
FOR_EACH_EDGE (e2, ei, bb->succs)
if (e2->dest != e->src && e2->dest != e->dest
&& !(e->flags & (EDGE_EH | EDGE_FAKE))
- && !dominated_by_p (CDI_POST_DOMINATORS, e->src, e2->dest))
+ && !dominated_by_p (cfun, CDI_POST_DOMINATORS, e->src, e2->dest))
{
has_nonloop_edge = true;
break;
diff --git a/gcc/sanopt.c b/gcc/sanopt.c
index 269c11d..dcffeea 100644
--- a/gcc/sanopt.c
+++ b/gcc/sanopt.c
@@ -608,7 +608,7 @@ sanopt_optimize (function *fun)
/* We're going to do a dominator walk, so ensure that we have
dominance information. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* Recursively walk the dominator tree optimizing away
redundant checks. */
@@ -697,7 +697,7 @@ pass_sanopt::execute (function *fun)
switch (ifn)
{
case IFN_UBSAN_NULL:
- no_next = ubsan_expand_null_ifn (&gsi);
+ no_next = ubsan_expand_null_ifn (fun, &gsi);
break;
case IFN_UBSAN_BOUNDS:
no_next = ubsan_expand_bounds_ifn (&gsi);
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index ce2c172..73f7bd1 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -841,7 +841,7 @@ haifa_find_rgns (void)
{
/* Now verify that the block is dominated by the loop
header. */
- if (!dominated_by_p (CDI_DOMINATORS, jbb, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, jbb, bb))
break;
}
}
@@ -3146,7 +3146,7 @@ sched_rgn_init (bool single_blocks_p)
{
/* Compute the dominators and post dominators. */
if (!sel_sched_p ())
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* Find regions. */
find_rgns ();
@@ -3157,7 +3157,7 @@ sched_rgn_init (bool single_blocks_p)
/* For now. This will move as more and more of haifa is converted
to using the cfg code. */
if (!sel_sched_p ())
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
gcc_assert (0 < nr_regions && nr_regions <= n_basic_blocks_for_fn (cfun));
diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c
index 9988285..a095368 100644
--- a/gcc/sel-sched-ir.c
+++ b/gcc/sel-sched-ir.c
@@ -3803,7 +3803,7 @@ maybe_tidy_empty_bb (basic_block bb)
if (!dom_bbs.is_empty ())
{
dom_bbs.safe_push (succ_bb);
- iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, dom_bbs, false);
dom_bbs.release ();
}
@@ -3891,7 +3891,7 @@ tidy_control_flow (basic_block xbb, bool full_tidying)
#ifdef ENABLE_CHECKING
verify_backedges ();
- verify_dominators (CDI_DOMINATORS);
+ verify_dominators (cfun, CDI_DOMINATORS);
#endif
return changed;
@@ -5220,8 +5220,9 @@ sel_remove_bb (basic_block bb, bool remove_from_cfg_p)
{
basic_block succ = single_succ (bb);
delete_and_free_basic_block (bb);
- set_immediate_dominator (CDI_DOMINATORS, succ,
- recompute_dominator (CDI_DOMINATORS, succ));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, succ,
+ recompute_dominator (cfun, CDI_DOMINATORS,
+ succ));
}
rgn_setup_region (CONTAINING_RGN (idx));
@@ -5588,10 +5589,11 @@ sel_redirect_edge_and_branch_force (edge e, basic_block to)
if (jump)
sel_init_new_insn (jump, INSN_INIT_TODO_LUID | INSN_INIT_TODO_SIMPLEJUMP,
old_seqno);
- set_immediate_dominator (CDI_DOMINATORS, to,
- recompute_dominator (CDI_DOMINATORS, to));
- set_immediate_dominator (CDI_DOMINATORS, orig_dest,
- recompute_dominator (CDI_DOMINATORS, orig_dest));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, to,
+ recompute_dominator (cfun, CDI_DOMINATORS, to));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, orig_dest,
+ recompute_dominator (cfun, CDI_DOMINATORS,
+ orig_dest));
}
/* A wrapper for redirect_edge_and_branch. Return TRUE if blocks connected by
@@ -5647,10 +5649,11 @@ sel_redirect_edge_and_branch (edge e, basic_block to)
Otherwise we'll update in maybe_tidy_empty_bb. */
if (!maybe_unreachable)
{
- set_immediate_dominator (CDI_DOMINATORS, to,
- recompute_dominator (CDI_DOMINATORS, to));
- set_immediate_dominator (CDI_DOMINATORS, orig_dest,
- recompute_dominator (CDI_DOMINATORS, orig_dest));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, to,
+ recompute_dominator (cfun, CDI_DOMINATORS, to));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, orig_dest,
+ recompute_dominator (cfun, CDI_DOMINATORS,
+ orig_dest));
}
return recompute_toporder_p;
}
@@ -6401,9 +6404,10 @@ sel_remove_loop_preheader (void)
free_data_sets (prev_bb);
}
- set_immediate_dominator (CDI_DOMINATORS, next_bb,
- recompute_dominator (CDI_DOMINATORS,
- next_bb));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, next_bb,
+ recompute_dominator (cfun,
+ CDI_DOMINATORS,
+ next_bb));
}
}
vec_free (preheader_blocks);
diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index 1860444..e2d5f44 100644
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -4835,7 +4835,7 @@ remove_insns_that_need_bookkeeping (fence_t fence, av_set_t *av_ptr)
&& (!bookkeeping_p || VINSN_UNIQUE_P (EXPR_VINSN (expr)))
&& (EXPR_SPEC (expr)
|| !EXPR_ORIG_BB_INDEX (expr)
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
BASIC_BLOCK_FOR_FN (cfun,
EXPR_ORIG_BB_INDEX (expr)),
BLOCK_FOR_INSN (FENCE_INSN (fence)))))
@@ -7654,7 +7654,7 @@ sel_sched_region (int rgn)
static void
sel_global_init (void)
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
alloc_sched_pools ();
/* Setup the infos for sched_init. */
@@ -7696,7 +7696,7 @@ sel_global_finish (void)
sel_finish_pipelining ();
free_sched_pools ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* Return true when we need to skip selective scheduling. Used for debugging. */
diff --git a/gcc/sese.h b/gcc/sese.h
index 52aa868..e87029a 100644
--- a/gcc/sese.h
+++ b/gcc/sese.h
@@ -90,13 +90,13 @@ bb_in_region (basic_block bb, basic_block entry, basic_block exit)
/* Check that there are no edges coming in the region: all the
predecessors of EXIT are dominated by ENTRY. */
FOR_EACH_EDGE (e, ei, exit->preds)
- dominated_by_p (CDI_DOMINATORS, e->src, entry);
+ dominated_by_p (cfun, CDI_DOMINATORS, e->src, entry);
}
#endif
- return dominated_by_p (CDI_DOMINATORS, bb, entry)
- && !(dominated_by_p (CDI_DOMINATORS, bb, exit)
- && !dominated_by_p (CDI_DOMINATORS, entry, exit));
+ return dominated_by_p (cfun, CDI_DOMINATORS, bb, entry)
+ && !(dominated_by_p (cfun, CDI_DOMINATORS, bb, exit)
+ && !dominated_by_p (cfun, CDI_DOMINATORS, entry, exit));
}
/* Checks whether BB is contained in the region delimited by ENTRY and
@@ -255,8 +255,8 @@ static inline void
recompute_all_dominators (void)
{
mark_irreducible_loops ();
- free_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
}
typedef struct gimple_bb
diff --git a/gcc/tracer.c b/gcc/tracer.c
index cad7ab1..dc7f421 100644
--- a/gcc/tracer.c
+++ b/gcc/tracer.c
@@ -413,7 +413,7 @@ pass_tracer::execute (function *fun)
changed = tail_duplicate ();
if (changed)
{
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
/* If we changed the CFG schedule loops for fixup by cleanup_cfg. */
loops_state_set (LOOPS_NEED_FIXUP);
}
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index 891e638..37abc0c 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -1070,7 +1070,7 @@ transaction_invariant_address_p (const_tree mem, basic_block region_entry_block)
def_bb = gimple_bb (SSA_NAME_DEF_STMT (TREE_OPERAND (mem, 0)));
return def_bb != region_entry_block
- && dominated_by_p (CDI_DOMINATORS, region_entry_block, def_bb);
+ && dominated_by_p (cfun, CDI_DOMINATORS, region_entry_block, def_bb);
}
mem = strip_invariant_refs (mem);
@@ -1153,11 +1153,11 @@ tm_log_add (basic_block entry_block, tree addr, gimple stmt)
return;
/* We already have a store to the same address, higher up the
dominator tree. Nothing to do. */
- if (dominated_by_p (CDI_DOMINATORS,
+ if (dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (stmt), gimple_bb (oldstmt)))
return;
/* We should be processing blocks in dominator tree order. */
- gcc_assert (!dominated_by_p (CDI_DOMINATORS,
+ gcc_assert (!dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (oldstmt), gimple_bb (stmt)));
}
/* Store is on a different code path. */
@@ -1400,7 +1400,8 @@ thread_private_new_memory (basic_block entry_block, tree x)
/* If the malloc call is outside the transaction, this is
thread-local. */
if (retval != mem_thread_local
- && !dominated_by_p (CDI_DOMINATORS, gimple_bb (stmt), entry_block))
+ && !dominated_by_p (cfun, CDI_DOMINATORS,
+ gimple_bb (stmt), entry_block))
retval = mem_thread_local;
if (is_gimple_assign (stmt))
@@ -2027,7 +2028,7 @@ gate_tm_init (void)
if (!flag_tm)
return false;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
bitmap_obstack_initialize (&tm_obstack);
/* If the function is a TM_CLONE, then the entire function is the region. */
@@ -3026,7 +3027,7 @@ execute_tm_mark (void)
if (pending_edge_inserts_p)
gsi_commit_edge_inserts ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
return 0;
}
@@ -3236,7 +3237,7 @@ pass_tm_edges::execute (function *fun)
/* We've got to release the dominance info now, to indicate that it
must be rebuilt completely. Otherwise we'll crash trying to update
the SSA web in the TODO section following this pass. */
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
bitmap_obstack_release (&tm_obstack);
all_tm_regions = NULL;
@@ -4216,7 +4217,7 @@ ipa_tm_scan_calls_transaction (struct tm_ipa_cg_data *d,
// ??? In ipa_uninstrument_transaction we don't try to update dominators
// because copy_bbs doesn't return a VEC like iterate_fix_dominators expects.
// Instead, just release dominators here so update_ssa recomputes them.
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
// When building the uninstrumented code path, copy_bbs will have invoked
// create_new_def_for starting an "ssa update context". There is only one
@@ -4536,8 +4537,9 @@ ipa_tm_scan_irr_function (struct cgraph_node *node, bool for_clone)
|| DECL_STRUCT_FUNCTION (node->decl)->cfg == NULL)
return false;
- push_cfun (DECL_STRUCT_FUNCTION (node->decl));
- calculate_dominance_info (CDI_DOMINATORS);
+ function *fn = DECL_STRUCT_FUNCTION (node->decl);
+ push_cfun (fn);
+ calculate_dominance_info (fn, CDI_DOMINATORS);
d = get_cg_data (&node, true);
auto_vec<basic_block, 10> queue;
@@ -5266,8 +5268,9 @@ ipa_tm_transform_transaction (struct cgraph_node *node)
d = get_cg_data (&node, true);
- push_cfun (DECL_STRUCT_FUNCTION (node->decl));
- calculate_dominance_info (CDI_DOMINATORS);
+ function *fn = DECL_STRUCT_FUNCTION (node->decl);
+ push_cfun (fn);
+ calculate_dominance_info (fn, CDI_DOMINATORS);
for (region = d->all_tm_regions; region; region = region->next)
{
@@ -5309,8 +5312,9 @@ ipa_tm_transform_clone (struct cgraph_node *node)
if (!node->callees && !node->indirect_calls && !d->irrevocable_blocks_clone)
return;
- push_cfun (DECL_STRUCT_FUNCTION (d->clone->decl));
- calculate_dominance_info (CDI_DOMINATORS);
+ function *fn = DECL_STRUCT_FUNCTION (d->clone->decl);
+ push_cfun (fn);
+ calculate_dominance_info (fn, CDI_DOMINATORS);
need_ssa_rename =
ipa_tm_transform_calls (d->clone, NULL,
@@ -5368,8 +5372,9 @@ ipa_tm_execute (void)
continue;
}
- push_cfun (DECL_STRUCT_FUNCTION (node->decl));
- calculate_dominance_info (CDI_DOMINATORS);
+ function *fn = DECL_STRUCT_FUNCTION (node->decl);
+ push_cfun (fn);
+ calculate_dominance_info (fn, CDI_DOMINATORS);
tm_region_init (NULL);
if (all_tm_regions)
diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
index 6e9b14c..2527dcb 100644
--- a/gcc/tree-call-cdce.c
+++ b/gcc/tree-call-cdce.c
@@ -939,8 +939,8 @@ pass_call_cdce::execute (function *fun)
if (something_changed)
{
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
/* As we introduced new control-flow we need to insert PHI-nodes
for the call-clobbers of the remaining call. */
mark_virtual_operands_for_renaming (fun);
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 588ab69..026a44f 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -5411,8 +5411,8 @@ gimple_verify_flow_info (void)
}
}
- if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
- verify_dominators (CDI_DOMINATORS);
+ if (dom_info_state (cfun, CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
+ verify_dominators (cfun, CDI_DOMINATORS);
return err;
}
@@ -6040,12 +6040,12 @@ gimple_duplicate_sese_region (edge entry, edge exit,
{
copying_header = true;
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, exit->src))
return false;
for (i = 0; i < n_region; i++)
if (region[i] != exit->src
- && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
+ && dominated_by_p (cfun, CDI_DOMINATORS, region[i], exit->src))
return false;
}
@@ -6125,9 +6125,9 @@ gimple_duplicate_sese_region (edge entry, edge exit,
well. */
if (update_dominance)
{
- set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, entry->dest, entry->src);
doms.safe_push (get_bb_original (entry->dest));
- iterate_fix_dominators (CDI_DOMINATORS, doms, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, doms, false);
doms.release ();
}
@@ -6285,7 +6285,7 @@ gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNU
switch_bb = entry->src;
else
switch_bb = split_edge (entry);
- set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, nentry_bb, switch_bb);
gsi = gsi_last_bb (switch_bb);
cond_stmt = last_stmt (exit->src);
@@ -6333,7 +6333,7 @@ gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNU
/* Anything that is outside of the region, but was dominated by something
inside needs to update dominance info. */
- iterate_fix_dominators (CDI_DOMINATORS, doms, false);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, doms, false);
doms.release ();
/* Update the SSA web. */
update_ssa (TODO_update_ssa);
@@ -6659,7 +6659,7 @@ move_block_to_fn (struct function *dest_cfun, basic_block bb,
unsigned old_len, new_len;
/* Remove BB from dominance structures. */
- delete_from_dominance_info (CDI_DOMINATORS, bb);
+ delete_from_dominance_info (cfun, CDI_DOMINATORS, bb);
/* Move BB from its current loop to the copy in the new function. */
if (current_loops)
@@ -7040,7 +7040,7 @@ move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
region. */
gcc_assert (entry_bb != exit_bb
&& (!exit_bb
- || dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));
+ || dominated_by_p (cfun, CDI_DOMINATORS, exit_bb, entry_bb)));
/* Collect all the blocks in the region. Manually add ENTRY_BB
because it won't be added by dfs_enumerate_from. */
@@ -7280,9 +7280,9 @@ move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
e->probability = exit_prob[i];
}
- set_immediate_dominator (CDI_DOMINATORS, bb, dom_entry);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb, dom_entry);
FOR_EACH_VEC_ELT (dom_bbs, i, abb)
- set_immediate_dominator (CDI_DOMINATORS, abb, bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, abb, bb);
dom_bbs.release ();
if (exit_bb)
@@ -7899,7 +7899,7 @@ remove_edge_and_dominated_blocks (edge e)
&& e->src->loop_father == e->dest->loop_father)
loops_state_set (LOOPS_NEED_FIXUP);
- if (!dom_info_available_p (CDI_DOMINATORS))
+ if (!dom_info_available_p (cfun, CDI_DOMINATORS))
{
remove_edge (e);
return;
@@ -7926,7 +7926,7 @@ remove_edge_and_dominated_blocks (edge e)
if (f == e)
continue;
- if (!dominated_by_p (CDI_DOMINATORS, f->src, e->dest))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, f->src, e->dest))
{
none_removed = true;
break;
@@ -8000,7 +8000,7 @@ remove_edge_and_dominated_blocks (edge e)
bbs_to_fix_dom.safe_push (dbb);
}
- iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, bbs_to_fix_dom, true);
BITMAP_FREE (df);
BITMAP_FREE (df_idom);
@@ -8381,10 +8381,10 @@ insert_cond_bb (basic_block bb, gimple stmt, gimple cond)
fall->flags = EDGE_FALSE_VALUE;
/* Update dominance info. */
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
- set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
- set_immediate_dominator (CDI_DOMINATORS, fall->dest, bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bb, bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, fall->dest, bb);
}
/* Update loop info. */
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index f3da9c5..136555a 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -526,7 +526,7 @@ remove_forwarder_block (basic_block bb)
bitmap_set_bit (cfgcleanup_altered_bbs, dest->index);
/* Update the dominators. */
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
basic_block dom, dombb, domdest;
@@ -541,7 +541,7 @@ remove_forwarder_block (basic_block bb)
else
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
- set_immediate_dominator (CDI_DOMINATORS, dest, dom);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dest, dom);
}
/* Adjust latch infomation of BB's parent loop as otherwise
@@ -717,22 +717,22 @@ cleanup_tree_cfg_noloop (void)
If dominance information is available, there cannot be any unreachable
blocks. */
- if (!dom_info_available_p (CDI_DOMINATORS))
+ if (!dom_info_available_p (cfun, CDI_DOMINATORS))
{
changed = delete_unreachable_blocks ();
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
}
else
{
#ifdef ENABLE_CHECKING
- verify_dominators (CDI_DOMINATORS);
+ verify_dominators (cfun, CDI_DOMINATORS);
#endif
changed = false;
}
changed |= cleanup_tree_cfg_1 ();
- gcc_assert (dom_info_available_p (CDI_DOMINATORS));
+ gcc_assert (dom_info_available_p (cfun, CDI_DOMINATORS));
compact_blocks ();
#ifdef ENABLE_CHECKING
@@ -755,7 +755,7 @@ repair_loop_structures (void)
bitmap changed_bbs;
unsigned n_new_loops;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
timevar_push (TV_REPAIR_LOOPS);
changed_bbs = BITMAP_ALLOC (NULL);
@@ -905,7 +905,7 @@ remove_forwarder_block_with_phi (basic_block bb)
else
dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
- set_immediate_dominator (CDI_DOMINATORS, dest, dom);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dest, dom);
/* Adjust latch infomation of BB's parent loop as otherwise
the cfg hook has a hard time not to kill the loop. */
@@ -979,7 +979,7 @@ pass_merge_phi::execute (function *fun)
basic_block *current = worklist;
basic_block bb;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* Find all PHI nodes that we may be able to merge. */
FOR_EACH_BB_FN (bb, fun)
@@ -1000,7 +1000,7 @@ pass_merge_phi::execute (function *fun)
|| bb_has_abnormal_pred (bb))
continue;
- if (!dominated_by_p (CDI_DOMINATORS, dest, bb))
+ if (!dominated_by_p (fun, CDI_DOMINATORS, dest, bb))
{
/* If BB does not dominate DEST, then the PHI nodes at
DEST must be the only users of the results of the PHI
diff --git a/gcc/tree-chkp-opt.c b/gcc/tree-chkp-opt.c
index 66c99bd..5ed2077 100644
--- a/gcc/tree-chkp-opt.c
+++ b/gcc/tree-chkp-opt.c
@@ -1180,7 +1180,7 @@ chkp_reduce_bounds_lifetime (void)
continue;
if (dom_bb &&
- dominated_by_p (CDI_DOMINATORS,
+ dominated_by_p (cfun, CDI_DOMINATORS,
dom_bb, gimple_bb (use_stmt)))
{
dom_use = use_stmt;
@@ -1267,8 +1267,8 @@ chkp_opt_init (void)
{
check_infos.create (0);
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
/* With LTO constant bounds vars may be not initialized by now.
Get constant bounds vars to handle their assignments during
@@ -1283,7 +1283,7 @@ chkp_opt_fini (void)
{
chkp_fix_cfg ();
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
}
/* Checker optimization pass function. */
diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c
index 8c1b48c..a0832f5 100644
--- a/gcc/tree-chkp.c
+++ b/gcc/tree-chkp.c
@@ -4359,8 +4359,8 @@ chkp_init (void)
chkp_get_zero_bounds_var ();
chkp_get_none_bounds_var ();
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
bitmap_obstack_initialize (NULL);
}
@@ -4376,8 +4376,8 @@ chkp_fini (void)
delete chkp_reg_addr_bounds;
delete chkp_incomplete_bounds_map;
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
bitmap_obstack_release (NULL);
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index 193fc65..6056580 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -1170,10 +1170,10 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
/* Update dominance info. Note that bb_join's data was
updated by split_block. */
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
- set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
- set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb_true, bb_cond);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb_false, bb_cond);
}
rr = create_tmp_reg (inner_type);
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index c1ca468..33387e4 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -3353,8 +3353,8 @@ pass_lower_resx::execute (function *fun)
if (dominance_invalidated)
{
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
}
return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
@@ -4554,8 +4554,8 @@ execute_cleanup_eh_1 (void)
if (changed)
{
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
/* We delayed all basic block deletion, as we may have performed
cleanups on EH edges while non-EH edges were still present. */
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 291e602..2aa0929 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -432,7 +432,7 @@ add_to_predicate_list (struct loop *loop, basic_block bb, tree nc)
/* If dominance tells us this basic block is always executed,
don't record any predicates for it. */
- if (dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
return;
dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
@@ -497,7 +497,7 @@ add_to_dst_predicate_list (struct loop *loop, edge e,
cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
prev_cond, cond);
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, e->dest))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, e->dest))
add_to_predicate_list (loop, e->dest, cond);
}
@@ -1037,7 +1037,7 @@ if_convertible_bb_p (struct loop *loop, basic_block bb, basic_block exit_bb)
}
else if (bb == loop->latch
&& bb != exit_bb
- && !dominated_by_p (CDI_DOMINATORS, bb, exit_bb))
+ && !dominated_by_p (cfun, CDI_DOMINATORS, bb, exit_bb))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "latch is not dominated by exit_block\n");
@@ -1256,8 +1256,8 @@ if_convertible_loop_p_1 (struct loop *loop,
if (!res)
return false;
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
/* Allow statements that can be handled during if-conversion. */
ifc_bbs = get_loop_body_in_if_conv_order (loop);
@@ -1314,7 +1314,7 @@ if_convertible_loop_p_1 (struct loop *loop,
gimple_stmt_iterator itr;
/* Check the if-convertibility of statements in predicated BBs. */
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
for (itr = gsi_start_bb (bb); !gsi_end_p (itr); gsi_next (&itr))
if (!if_convertible_stmt_p (gsi_stmt (itr), *refs,
any_mask_load_store))
@@ -2232,7 +2232,7 @@ combine_blocks (struct loop *loop, bool any_mask_load_store)
{
/* Connect this node to loop header. */
make_edge (loop->header, exit_bb, EDGE_FALLTHRU);
- set_immediate_dominator (CDI_DOMINATORS, exit_bb, loop->header);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, exit_bb, loop->header);
}
/* Redirect non-exit edges to loop->latch. */
@@ -2241,13 +2241,13 @@ combine_blocks (struct loop *loop, bool any_mask_load_store)
if (!loop_exit_edge_p (loop, e))
redirect_edge_and_branch (e, loop->latch);
}
- set_immediate_dominator (CDI_DOMINATORS, loop->latch, exit_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, loop->latch, exit_bb);
}
else
{
/* If the loop does not have an exit, reconnect header and latch. */
make_edge (loop->header, loop->latch, EDGE_FALLTHRU);
- set_immediate_dominator (CDI_DOMINATORS, loop->latch, loop->header);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, loop->latch, loop->header);
}
merge_target_bb = loop->header;
@@ -2727,7 +2727,7 @@ tree_if_conversion (struct loop *loop)
free (ifc_bbs);
ifc_bbs = NULL;
}
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
return todo;
}
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index e1ceea4..3e360d4 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -4950,8 +4950,8 @@ optimize_inline_calls (tree fn)
push_gimplify_context ();
/* We make no attempts to keep dominance info up-to-date. */
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
/* Register specific gimple functions. */
gimple_register_cfg_hooks ();
@@ -5842,8 +5842,8 @@ tree_function_versioning (tree old_decl, tree new_decl,
delete id.decl_map;
if (id.debug_map)
delete id.debug_map;
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
fold_marked_statements (0, id.statements_to_fold);
delete id.statements_to_fold;
@@ -5852,7 +5852,7 @@ tree_function_versioning (tree old_decl, tree new_decl,
cgraph_edge::rebuild_references ();
if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
fix_loop_structure (NULL);
}
update_ssa (TODO_update_ssa);
@@ -5881,8 +5881,8 @@ tree_function_versioning (tree old_decl, tree new_decl,
}
}
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
gcc_assert (!id.debug_stmts.exists ());
pop_cfun ();
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index cc77618..178f963 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -556,7 +556,7 @@ set_livein_block (tree var, basic_block bb)
int def_block_index = bitmap_first_set_bit (db_p->def_blocks);
if (def_block_index == -1
- || ! dominated_by_p (CDI_DOMINATORS, bb,
+ || ! dominated_by_p (cfun, CDI_DOMINATORS, bb,
BASIC_BLOCK_FOR_FN (cfun, def_block_index)))
info->need_phi_state = NEED_PHI_STATE_MAYBE;
}
@@ -1274,7 +1274,7 @@ rewrite_debug_stmt_uses (gimple stmt)
;
/* If definition bb doesn't dominate the current bb,
it can't be used. */
- else if (def_bb && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
+ else if (def_bb && !dominated_by_p (cfun, CDI_DOMINATORS, bb, def_bb))
def = NULL;
/* If there is just one definition and dominates the current
bb, it is fine. */
@@ -2376,7 +2376,7 @@ pass_build_ssa::execute (function *fun)
bitmap_initialize (&dfs[bb->index], &bitmap_default_obstack);
/* 1- Compute dominance frontiers. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
compute_dominance_frontiers (dfs);
/* 2- Find and mark definition sites. */
@@ -3032,12 +3032,12 @@ insert_updated_phi_nodes_for (tree var, bitmap_head *dfs, bitmap blocks,
/* If doing regular SSA updates for GIMPLE registers, we are
only interested in IDF blocks dominated by the nearest
common dominator of all the definition blocks. */
- entry = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ entry = nearest_common_dominator_for_set (cfun, CDI_DOMINATORS,
db->def_blocks);
if (entry != ENTRY_BLOCK_PTR_FOR_FN (cfun))
EXECUTE_IF_SET_IN_BITMAP (idf, 0, i, bi)
if (BASIC_BLOCK_FOR_FN (cfun, i) != entry
- && dominated_by_p (CDI_DOMINATORS,
+ && dominated_by_p (cfun, CDI_DOMINATORS,
BASIC_BLOCK_FOR_FN (cfun, i), entry))
bitmap_set_bit (pruned_idf, i);
}
@@ -3242,7 +3242,7 @@ update_ssa (unsigned update_flags)
blocks_to_update = BITMAP_ALLOC (NULL);
/* Ensure that the dominance information is up-to-date. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
insert_phi_p = (update_flags != TODO_update_ssa_no_phi);
@@ -3309,7 +3309,7 @@ update_ssa (unsigned update_flags)
{
/* Otherwise, the entry block to the region is the nearest
common dominator for the blocks in BLOCKS. */
- start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ start_bb = nearest_common_dominator_for_set (cfun, CDI_DOMINATORS,
blocks_to_update);
}
@@ -3357,7 +3357,7 @@ update_ssa (unsigned update_flags)
We need to re-compute START_BB to include the newly added
blocks. */
if (start_bb != ENTRY_BLOCK_PTR_FOR_FN (cfun))
- start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ start_bb = nearest_common_dominator_for_set (cfun, CDI_DOMINATORS,
blocks_to_update);
}
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index 213793e..642bac9 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -919,8 +919,8 @@ destroy_loop (struct loop *loop)
}
free (bbs);
- set_immediate_dominator (CDI_DOMINATORS, dest,
- recompute_dominator (CDI_DOMINATORS, dest));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dest,
+ recompute_dominator (cfun, CDI_DOMINATORS, dest));
}
/* Generates code for PARTITION. */
@@ -1063,7 +1063,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
nb_iter = number_of_latch_executions (loop);
if (!nb_iter || nb_iter == chrec_dont_know)
return;
- if (dominated_by_p (CDI_DOMINATORS, single_exit (loop)->src,
+ if (dominated_by_p (cfun, CDI_DOMINATORS, single_exit (loop)->src,
gimple_bb (DR_STMT (single_store))))
plus_one = true;
@@ -1081,7 +1081,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
&& flow_bb_inside_loop_p (loop, gimple_bb (SSA_NAME_DEF_STMT (rhs))))
return;
if (!adjacent_dr_p (single_store)
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
loop->latch, gimple_bb (stmt)))
return;
partition->kind = PKIND_MEMSET;
@@ -1101,7 +1101,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
|| !adjacent_dr_p (single_load)
|| !operand_equal_p (DR_STEP (single_store),
DR_STEP (single_load), 0)
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
loop->latch, gimple_bb (store)))
return;
/* Now check that if there is a dependence this dependence is
@@ -1788,10 +1788,10 @@ out:
{
if (!cd)
{
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
cd = new control_dependences (create_edge_list ());
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
}
nb_generated_loops = distribute_loop (loop, work_list, cd,
&nb_generated_calls);
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index d017479..14a87e4 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -799,8 +799,8 @@ expr_invariant_in_region_p (edge entry, edge exit, tree expr)
{
def_bb = gimple_bb (SSA_NAME_DEF_STMT (expr));
if (def_bb
- && dominated_by_p (CDI_DOMINATORS, def_bb, entry_bb)
- && !dominated_by_p (CDI_DOMINATORS, def_bb, exit_bb))
+ && dominated_by_p (cfun, CDI_DOMINATORS, def_bb, entry_bb)
+ && !dominated_by_p (cfun, CDI_DOMINATORS, def_bb, exit_bb))
return false;
return true;
@@ -1740,8 +1740,8 @@ transform_to_exit_first_loop_alt (struct loop *loop,
loop->header = new_header;
/* Recalculate dominance info. */
- free_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
}
/* Tries to moves the exit condition of LOOP to the beginning of its header
@@ -2122,8 +2122,8 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
gsi_insert_after (&gsi, omp_return_stmt2, GSI_NEW_STMT);
/* After the above dom info is hosed. Re-compute it. */
- free_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
return paral_bb;
}
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index ea0d30c..9bdad7f 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -837,7 +837,7 @@ split_data_refs_to_components (struct loop *loop,
dataref->distance = 0;
dataref->always_accessed
- = dominated_by_p (CDI_DOMINATORS, last_always_executed,
+ = dominated_by_p (cfun, CDI_DOMINATORS, last_always_executed,
gimple_bb (dataref->stmt));
dataref->pos = comp->refs.length ();
comp->refs.quick_push (dataref);
@@ -879,7 +879,7 @@ suitable_component_p (struct loop *loop, struct component *comp)
if (!just_once_each_iteration_p (loop, ba))
return false;
- gcc_assert (dominated_by_p (CDI_DOMINATORS, ba, bp));
+ gcc_assert (dominated_by_p (cfun, CDI_DOMINATORS, ba, bp));
bp = ba;
if (DR_IS_WRITE (a->ref))
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index 4dcc58d..9bcb3cc 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -538,7 +538,8 @@ tree_profiling (void)
&& flag_test_coverage)
continue;
- push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+ function *fn = DECL_STRUCT_FUNCTION (node->decl);
+ push_cfun (fn);
/* Local pure-const may imply need to fixup the cfg. */
if (execute_fixup_cfg () & TODO_cleanup_cfg)
@@ -558,8 +559,8 @@ tree_profiling (void)
/* The above could hose dominator info. Currently there is
none coming in, this is a safety valve. It should be
easy to adjust it, if and when there is some. */
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fn, CDI_DOMINATORS);
+ free_dominance_info (fn, CDI_POST_DOMINATORS);
pop_cfun ();
}
diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
index 3219160..b3ad9ec 100644
--- a/gcc/tree-scalar-evolution.c
+++ b/gcc/tree-scalar-evolution.c
@@ -2295,7 +2295,7 @@ instantiate_scev_name (basic_block instantiate_below,
evolutions in outer loops), nothing to do. */
if (!def_bb
|| loop_depth (def_bb->loop_father) == 0
- || dominated_by_p (CDI_DOMINATORS, instantiate_below, def_bb))
+ || dominated_by_p (cfun, CDI_DOMINATORS, instantiate_below, def_bb))
return chrec;
/* We cache the value of instantiated variable to avoid exponential
@@ -2348,7 +2348,7 @@ instantiate_scev_name (basic_block instantiate_below,
inner_loop, res,
fold_conversions, size_expr);
}
- else if (!dominated_by_p (CDI_DOMINATORS, instantiate_below,
+ else if (!dominated_by_p (cfun, CDI_DOMINATORS, instantiate_below,
gimple_bb (SSA_NAME_DEF_STMT (res))))
res = chrec_dont_know;
}
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 818c290..44e1a58 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -4966,7 +4966,7 @@ modify_function (struct cgraph_node *node, ipa_parm_adjustment_vec adjustments)
bool cfg_changed;
cgraph_edge::rebuild_edges ();
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
pop_cfun ();
/* This must be done after rebuilding cgraph edges for node above.
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index e103220..d8fc9d0 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -2509,7 +2509,7 @@ get_continuation_for_phi_1 (gimple phi, tree arg0, tree arg1,
return arg0;
else if (gimple_nop_p (def0)
|| (!gimple_nop_p (def1)
- && dominated_by_p (CDI_DOMINATORS,
+ && dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (def1), gimple_bb (def0))))
{
if (maybe_skip_until (phi, arg0, ref, arg1, cnt,
@@ -2517,7 +2517,7 @@ get_continuation_for_phi_1 (gimple phi, tree arg0, tree arg1,
return arg0;
}
else if (gimple_nop_p (def1)
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (def0), gimple_bb (def1)))
{
if (maybe_skip_until (phi, arg1, ref, arg0, cnt,
@@ -2592,7 +2592,7 @@ get_continuation_for_phi (gimple phi, ao_ref *ref,
arg0 = arg1;
break;
}
- if (dominated_by_p (CDI_DOMINATORS,
+ if (dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (SSA_NAME_DEF_STMT (arg0)),
gimple_bb (SSA_NAME_DEF_STMT (arg1))))
arg0 = arg1;
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 398ddc1..716d27f 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1120,7 +1120,7 @@ ccp_visit_phi_node (gphi *phi)
&& new_val.lattice_val == CONSTANT
&& TREE_CODE (new_val.value) == SSA_NAME
&& ! SSA_NAME_IS_DEFAULT_DEF (new_val.value)
- && ! dominated_by_p (CDI_DOMINATORS, gimple_bb (phi),
+ && ! dominated_by_p (cfun, CDI_DOMINATORS, gimple_bb (phi),
gimple_bb (SSA_NAME_DEF_STMT (new_val.value))))
{
new_val.lattice_val = VARYING;
@@ -2405,12 +2405,12 @@ static unsigned int
do_ssa_ccp (void)
{
unsigned int todo = 0;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
ccp_initialize ();
ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
if (ccp_finalize ())
todo = (TODO_cleanup_cfg | TODO_update_ssa);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
return todo;
}
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 2d2edc8..30bb331 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -511,7 +511,7 @@ mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data)
unless we decide to compute stmt UIDs
(see PR58246). */
&& (basic_block) data != gimple_bb (def_stmt)
- && dominated_by_p (CDI_DOMINATORS, (basic_block) data,
+ && dominated_by_p (cfun, CDI_DOMINATORS, (basic_block) data,
gimple_bb (def_stmt))
&& operand_equal_p (ref->ref, lhs, 0))
return true;
@@ -1304,7 +1304,7 @@ eliminate_unnecessary_stmts (void)
# DEBUG a => y_1 + z_2 - b_4
as desired. */
- gcc_assert (dom_info_available_p (CDI_DOMINATORS));
+ gcc_assert (dom_info_available_p (cfun, CDI_DOMINATORS));
h = get_all_dominated_blocks (CDI_DOMINATORS,
single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
@@ -1608,7 +1608,7 @@ perform_tree_ssa_dce (bool aggressive)
{
bool something_changed = 0;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* Preheaders are needed for SCEV to work.
Simple lateches and recorded exits improve chances that loop will
@@ -1622,7 +1622,7 @@ perform_tree_ssa_dce (bool aggressive)
if (aggressive)
{
/* Compute control dependence. */
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
cd = new control_dependences (create_edge_list ());
visited_control_parents =
@@ -1649,13 +1649,13 @@ perform_tree_ssa_dce (bool aggressive)
something_changed |= cfg_altered;
/* We do not update postdominators, so free them unconditionally. */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
/* If we removed paths in the CFG, then we need to update
dominators as well. I haven't investigated the possibility
of incrementally updating dominators. */
if (cfg_altered)
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
statistics_counter_event (cfun, "Statements deleted", stats.removed);
statistics_counter_event (cfun, "PHI nodes deleted", stats.removed_phis);
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 3eb003c..4011294 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1172,7 +1172,7 @@ pass_dominator::execute (function *fun)
need_eh_cleanup = BITMAP_ALLOC (NULL);
need_noreturn_fixup.create (0);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
cfg_altered = false;
/* We need to know loop structures in order to avoid destroying them
@@ -1221,7 +1221,7 @@ pass_dominator::execute (function *fun)
cfg_altered |= thread_through_all_blocks (first_pass_instance);
if (cfg_altered)
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
/* Removal of statements may make some EH edges dead. Purge
such edges from the CFG as needed. */
@@ -1487,7 +1487,7 @@ record_temporary_equivalences (edge e)
handle PHIs then this should only consider use_stmts
in basic-blocks we have already visited. */
if (e->dest == gimple_bb (use_stmt)
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
e->dest, gimple_bb (use_stmt)))
continue;
tree lhs2 = gimple_get_lhs (use_stmt);
@@ -1625,7 +1625,7 @@ single_incoming_edge_ignoring_loop_edges (basic_block bb)
{
/* A loop back edge can be identified by the destination of
the edge dominating the source of the edge. */
- if (dominated_by_p (CDI_DOMINATORS, e->src, e->dest))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, e->src, e->dest))
continue;
/* If we have already seen a non-loop edge, then we must have
@@ -3150,7 +3150,7 @@ pass_phi_only_cprop::execute (function *fun)
interesting_names = BITMAP_ALLOC (NULL);
interesting_names1 = BITMAP_ALLOC (NULL);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
cfg_altered = false;
/* First phase. Eliminate degenerate PHIs via a dominator
@@ -3192,7 +3192,7 @@ pass_phi_only_cprop::execute (function *fun)
if (cfg_altered)
{
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
/* If we changed the CFG schedule loops for fixup by cfgcleanup. */
loops_state_set (LOOPS_NEED_FIXUP);
}
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 4ad19b3..db4c22d 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -139,11 +139,11 @@ dse_possible_dead_store_p (ao_ref *ref, gimple stmt, gimple *use_stmt)
if (temp
/* Make sure we are not in a loop latch block. */
|| gimple_bb (stmt) == gimple_bb (use_stmt)
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (stmt), gimple_bb (use_stmt))
/* We can look through PHIs to regions post-dominating
the DSE candidate stmt. */
- || !dominated_by_p (CDI_POST_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_POST_DOMINATORS,
gimple_bb (stmt), gimple_bb (use_stmt)))
{
fail = true;
@@ -153,7 +153,7 @@ dse_possible_dead_store_p (ao_ref *ref, gimple stmt, gimple *use_stmt)
stmt defining the virtual operand we are processing,
we have processed it already in this case. */
if (gimple_bb (defvar_def) != gimple_bb (use_stmt)
- && !dominated_by_p (CDI_DOMINATORS,
+ && !dominated_by_p (cfun, CDI_DOMINATORS,
gimple_bb (defvar_def),
gimple_bb (use_stmt)))
temp = use_stmt;
@@ -387,8 +387,8 @@ pass_dse::execute (function *fun)
can be [re]computed on an as-needed basis. Particularly since
this pass could be seen as an extension of DCE which needs post
dominators. */
- calculate_dominance_info (CDI_POST_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* Dead store elimination is fundamentally a walk of the post-dominator
tree and a backwards walk of statements within each block. */
@@ -405,7 +405,7 @@ pass_dse::execute (function *fun)
BITMAP_FREE (need_eh_cleanup);
/* For now, just wipe the post-dominator information. */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
return 0;
}
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index ccfde5f..740600d 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -1093,7 +1093,7 @@ simplify_gimple_switch_label_vec (gswitch *stmt, tree index_type)
{
remove_edge (e);
cfg_changed = true;
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
else
ei_next (&ei);
diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c
index ef3d16d..838a76f 100644
--- a/gcc/tree-ssa-ifcombine.c
+++ b/gcc/tree-ssa-ifcombine.c
@@ -748,7 +748,7 @@ pass_tree_ifcombine::execute (function *fun)
int i;
bbs = single_pred_before_succ_order ();
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* Search every basic block for COND_EXPR we may be able to optimize.
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index b85d9cb..5d31f8a 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -636,13 +636,13 @@ extract_true_false_args_from_phi (basic_block dom, gphi *phi,
if (tem == true_edge
|| (single_pred_p (true_edge->dest)
&& (tem->src == true_edge->dest
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
tem->src, true_edge->dest))))
arg0 = PHI_ARG_DEF (phi, tem->dest_idx);
else if (tem == false_edge
|| (single_pred_p (false_edge->dest)
&& (tem->src == false_edge->dest
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
tem->src, false_edge->dest))))
arg1 = PHI_ARG_DEF (phi, tem->dest_idx);
else
@@ -651,13 +651,13 @@ extract_true_false_args_from_phi (basic_block dom, gphi *phi,
if (tem == true_edge
|| (single_pred_p (true_edge->dest)
&& (tem->src == true_edge->dest
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
tem->src, true_edge->dest))))
arg0 = PHI_ARG_DEF (phi, tem->dest_idx);
else if (tem == false_edge
|| (single_pred_p (false_edge->dest)
&& (tem->src == false_edge->dest
- || dominated_by_p (CDI_DOMINATORS,
+ || dominated_by_p (cfun, CDI_DOMINATORS,
tem->src, false_edge->dest))))
arg1 = PHI_ARG_DEF (phi, tem->dest_idx);
else
@@ -1864,15 +1864,16 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag)
then_old_edge = make_edge (then_bb, old_dest,
EDGE_FALLTHRU | (irr ? EDGE_IRREDUCIBLE_LOOP : 0));
- set_immediate_dominator (CDI_DOMINATORS, then_bb, new_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, then_bb, new_bb);
if (prev_edges)
{
basic_block prevbb = prev_edges->last_cond_fallthru->src;
redirect_edge_succ (prev_edges->last_cond_fallthru, new_bb);
- set_immediate_dominator (CDI_DOMINATORS, new_bb, prevbb);
- set_immediate_dominator (CDI_DOMINATORS, old_dest,
- recompute_dominator (CDI_DOMINATORS, old_dest));
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_bb, prevbb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, old_dest,
+ recompute_dominator (cfun, CDI_DOMINATORS,
+ old_dest));
}
/* ?? Because stores may alias, they must happen in the exact
@@ -2359,7 +2360,7 @@ fill_always_executed_in_1 (struct loop *loop, sbitmap contains_call)
edge_iterator ei;
bb = bbs[i];
- if (dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
last = bb;
if (bitmap_bit_p (contains_call, bb->index))
@@ -2381,7 +2382,7 @@ fill_always_executed_in_1 (struct loop *loop, sbitmap contains_call)
if (bb->loop_father->header == bb)
{
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb))
break;
/* In a loop that is always entered we may proceed anyway.
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index eca70a9..5d0bbc5 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -237,7 +237,7 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru
for (i = 0; i < loop->num_nodes; i++)
{
if (edge_to_cancel && body[i] != edge_to_cancel->src
- && dominated_by_p (CDI_DOMINATORS, body[i], edge_to_cancel->src))
+ && dominated_by_p (cfun, CDI_DOMINATORS, body[i], edge_to_cancel->src))
after_exit = true;
else
after_exit = false;
@@ -639,7 +639,8 @@ unloop_loops (bitmap loop_closed_ssa_invalidated,
latch_edge->dest->loop_father = current_loops->tree_root;
latch_edge->dest->count = 0;
latch_edge->dest->frequency = 0;
- set_immediate_dominator (CDI_DOMINATORS, latch_edge->dest, latch_edge->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, latch_edge->dest,
+ latch_edge->src);
gsi = gsi_start_bb (latch_edge->dest);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 6bce3a1..8d21b3a 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -705,7 +705,7 @@ stmt_after_inc_pos (struct iv_cand *cand, gimple stmt, bool true_if_equal)
basic_block cand_bb = gimple_bb (cand->incremented_at);
basic_block stmt_bb = gimple_bb (stmt);
- if (!dominated_by_p (CDI_DOMINATORS, stmt_bb, cand_bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, stmt_bb, cand_bb))
return false;
if (stmt_bb != cand_bb)
@@ -2744,7 +2744,8 @@ add_autoinc_candidates (struct ivopts_data *data, tree base, tree step,
It must not be in an inner nested loop, or one side of an if
statement. */
if (use_bb->loop_father != data->current_loop
- || !dominated_by_p (CDI_DOMINATORS, data->current_loop->latch, use_bb)
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
+ data->current_loop->latch, use_bb)
|| stmt_could_throw_p (use->stmt)
|| !cst_and_fits_in_hwi (step))
return;
@@ -5012,7 +5013,7 @@ may_eliminate_iv (struct ivopts_data *data,
ex_bb = gimple_bb (use->stmt);
if (use->stmt != last_stmt (ex_bb)
|| gimple_code (use->stmt) != GIMPLE_COND
- || !dominated_by_p (CDI_DOMINATORS, loop->latch, ex_bb))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, ex_bb))
return false;
exit = EDGE_SUCC (ex_bb, 0);
diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c
index cb762df..191b9b9 100644
--- a/gcc/tree-ssa-loop-manip.c
+++ b/gcc/tree-ssa-loop-manip.c
@@ -253,7 +253,7 @@ compute_live_loop_exits (bitmap live_exits, bitmap use_blocks,
If BB dominates PRED, then we're probably looking at a loop.
We're only interested in looking up in the dominance tree
because DEF_BB dominates all the uses. */
- if (pred_visited || dominated_by_p (CDI_DOMINATORS, pred, bb))
+ if (pred_visited || dominated_by_p (cfun, CDI_DOMINATORS, pred, bb))
continue;
worklist.quick_push (pred);
@@ -559,7 +559,7 @@ replace_uses_in_dominated_bbs (tree old_val, tree new_val, basic_block bb)
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, old_val)
{
- if (!dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, gimple_bb (use_stmt), bb))
continue;
use_operand_p use_p;
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 633e3d1..7fcbdeb 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -1934,7 +1934,7 @@ number_of_iterations_exit (struct loop *loop, edge exit,
affine_iv iv0, iv1;
bool safe;
- safe = dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src);
+ safe = dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, exit->src);
if (every_iteration && !safe)
return false;
@@ -2631,7 +2631,7 @@ do_warn_aggressive_loop_optimizations (struct loop *loop,
known constant bound. */
|| wi::cmpu (i_bound, wi::to_widest (loop->nb_iterations)) >= 0
/* And undefined behavior happens unconditionally. */
- || !dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (stmt)))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, gimple_bb (stmt)))
return;
edge e = single_exit (loop);
@@ -2700,7 +2700,7 @@ record_estimate (struct loop *loop, tree bound, const widest_int &i_bound,
/* If statement is executed on every path to the loop latch, we can directly
infer the upper bound on the # of iterations of the loop. */
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (at_stmt)))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, gimple_bb (at_stmt)))
return;
/* Update the number of iteration estimates according to the bound.
@@ -2909,7 +2909,7 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
/* If access is not executed on every iteration, we must ensure that overlow may
not make the access valid later. */
- if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (data->stmt))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, gimple_bb (data->stmt))
&& scev_probably_wraps_p (initial_condition_in_loop_num (ev, loop->num),
step, data->stmt, loop, true))
reliable = false;
@@ -3096,7 +3096,7 @@ infer_loop_bounds_from_undefined (struct loop *loop)
use the operations in it to infer reliable upper bound on the
# of iterations of the loop. However, we can use it as a guess.
Reliable guesses come only from array bounds. */
- reliable = dominated_by_p (CDI_DOMINATORS, loop->latch, bb);
+ reliable = dominated_by_p (cfun, CDI_DOMINATORS, loop->latch, bb);
for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
@@ -3675,7 +3675,7 @@ stmt_dominates_stmt_p (gimple s1, gimple s2)
return false;
}
- return dominated_by_p (CDI_DOMINATORS, bb2, bb1);
+ return dominated_by_p (cfun, CDI_DOMINATORS, bb2, bb1);
}
/* Returns true when we can prove that the number of executions of
diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c
index 078b1d1..cdf9d70 100644
--- a/gcc/tree-ssa-loop.c
+++ b/gcc/tree-ssa-loop.c
@@ -73,11 +73,11 @@ public:
}; // class pass_fix_loops
unsigned int
-pass_fix_loops::execute (function *)
+pass_fix_loops::execute (function *fn)
{
if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fn, CDI_DOMINATORS);
fix_loop_structure (NULL);
}
return 0;
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index eae5358..30efdbc 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -328,7 +328,7 @@ compute_merit (struct occurrence *occ)
else
bb = dom;
- if (dominated_by_p (CDI_POST_DOMINATORS, bb, occ_child->bb))
+ if (dominated_by_p (cfun, CDI_POST_DOMINATORS, bb, occ_child->bb))
occ->num_divisions += occ_child->num_divisions;
}
}
@@ -551,8 +551,8 @@ pass_cse_reciprocals::execute (function *fun)
("dominators for recip", n_basic_blocks_for_fn (fun) / 3 + 1);
memset (&reciprocal_stats, 0, sizeof (reciprocal_stats));
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
#ifdef ENABLE_CHECKING
FOR_EACH_BB_FN (bb, fun)
@@ -676,8 +676,8 @@ pass_cse_reciprocals::execute (function *fun)
statistics_counter_event (fun, "reciprocal functions inserted",
reciprocal_stats.rfuncs_inserted);
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
delete occ_pool;
return 0;
}
@@ -703,10 +703,10 @@ maybe_record_sincos (vec<gimple> *stmts,
basic_block use_bb = gimple_bb (use_stmt);
if (*top_bb
&& (*top_bb == use_bb
- || dominated_by_p (CDI_DOMINATORS, use_bb, *top_bb)))
+ || dominated_by_p (cfun, CDI_DOMINATORS, use_bb, *top_bb)))
stmts->safe_push (use_stmt);
else if (!*top_bb
- || dominated_by_p (CDI_DOMINATORS, *top_bb, use_bb))
+ || dominated_by_p (cfun, CDI_DOMINATORS, *top_bb, use_bb))
{
stmts->safe_push (use_stmt);
*top_bb = use_bb;
@@ -1733,7 +1733,7 @@ pass_cse_sincos::execute (function *fun)
basic_block bb;
bool cfg_changed = false;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
memset (&sincos_stats, 0, sizeof (sincos_stats));
FOR_EACH_BB_FN (bb, fun)
@@ -1873,7 +1873,7 @@ pass_cse_sincos::execute (function *fun)
statistics_counter_event (fun, "sincos statements inserted",
sincos_stats.inserted);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
return cfg_changed ? TODO_cleanup_cfg : 0;
}
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index d46ba62..46a7085 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -1620,7 +1620,7 @@ get_non_trapping (void)
hash_set<tree> *nontrap = new hash_set<tree>;
/* We're going to do a dominator walk, so ensure that we have
dominance information. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
nontrapping_dom_walker (CDI_DOMINATORS, nontrap)
.walk (cfun->cfg->x_entry_block_ptr);
diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c
index d5d1f24..ac30c7c 100644
--- a/gcc/tree-ssa-phiprop.c
+++ b/gcc/tree-ssa-phiprop.c
@@ -120,7 +120,7 @@ phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
/* If BB does not dominate a VDEF, the value is invalid. */
if ((gimple_vdef (use_stmt) != NULL_TREE
|| gimple_code (use_stmt) == GIMPLE_PHI)
- && !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
+ && !dominated_by_p (cfun, CDI_DOMINATORS, gimple_bb (use_stmt), bb))
{
ok = false;
BREAK_FROM_IMM_USE_STMT (ui2);
@@ -306,7 +306,7 @@ propagate_with_phi (basic_block bb, gphi *phi, struct phiprop_d *phivn,
/* Only replace loads in blocks that post-dominate the PHI node. That
makes sure we don't end up speculating loads. */
- if (!dominated_by_p (CDI_POST_DOMINATORS,
+ if (!dominated_by_p (cfun, CDI_POST_DOMINATORS,
bb, gimple_bb (use_stmt)))
continue;
@@ -329,7 +329,7 @@ propagate_with_phi (basic_block bb, gphi *phi, struct phiprop_d *phivn,
def_stmt = SSA_NAME_DEF_STMT (vuse);
if (!SSA_NAME_IS_DEFAULT_DEF (vuse)
&& (gimple_bb (def_stmt) == bb
- || !dominated_by_p (CDI_DOMINATORS,
+ || !dominated_by_p (cfun, CDI_DOMINATORS,
bb, gimple_bb (def_stmt))))
goto next;
@@ -408,8 +408,8 @@ pass_phiprop::execute (function *fun)
unsigned i;
size_t n;
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
n = num_ssa_names;
phivn = XCNEWVEC (struct phiprop_d, n);
@@ -427,7 +427,7 @@ pass_phiprop::execute (function *fun)
bbs.release ();
free (phivn);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
return 0;
}
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 697958d..5362b91 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2056,7 +2056,7 @@ prune_clobbered_mems (bitmap_set_t set, basic_block block)
gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
if (!gimple_nop_p (def_stmt)
&& ((gimple_bb (def_stmt) != block
- && !dominated_by_p (CDI_DOMINATORS,
+ && !dominated_by_p (cfun, CDI_DOMINATORS,
block, gimple_bb (def_stmt)))
|| (gimple_bb (def_stmt) == block
&& value_dies_in_block_x (expr, block))))
@@ -4764,8 +4764,8 @@ init_pre (void)
alloc_aux_for_blocks (sizeof (struct bb_bitmap_sets));
- calculate_dominance_info (CDI_POST_DOMINATORS);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
bitmap_obstack_initialize (&grand_bitmap_obstack);
phi_translate_table = new hash_table<expr_pred_trans_d> (5110);
@@ -4799,7 +4799,7 @@ fini_pre ()
free_aux_for_blocks ();
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
}
namespace {
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index b7684e0..419f8b7 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -1063,7 +1063,7 @@ replace_phi_args_in (gphi *phi, ssa_prop_get_value_fn get_value)
get removed without replacing its uses. */
if (TREE_CODE (val) != SSA_NAME
&& bb->loop_father->header == bb
- && dominated_by_p (CDI_DOMINATORS, e->src, bb)
+ && dominated_by_p (cfun, CDI_DOMINATORS, e->src, bb)
&& is_gimple_assign (SSA_NAME_DEF_STMT (arg))
&& (gimple_assign_rhs_code (SSA_NAME_DEF_STMT (arg))
== ASSERT_EXPR))
@@ -1333,7 +1333,7 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn,
memset (&prop_stats, 0, sizeof (prop_stats));
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
substitute_and_fold_dom_walker walker(CDI_DOMINATORS,
get_value_fn, fold_fn, do_dce);
walker.walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index efb813c..b763522 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -1246,7 +1246,7 @@ reassoc_stmt_dominates_stmt_p (gimple s1, gimple s2)
return false;
}
- return dominated_by_p (CDI_DOMINATORS, bb2, bb1);
+ return dominated_by_p (cfun, CDI_DOMINATORS, bb2, bb1);
}
/* Insert STMT after INSERT_POINT. */
@@ -4920,8 +4920,8 @@ branch_fixup (void)
gsi = gsi_for_stmt (use_stmt);
gsi_remove (&gsi, true);
- set_immediate_dominator (CDI_DOMINATORS, merge_bb, cond_bb);
- set_immediate_dominator (CDI_POST_DOMINATORS, cond_bb, merge_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, merge_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_POST_DOMINATORS, cond_bb, merge_bb);
}
reassoc_branch_fixups.release ();
}
@@ -4998,7 +4998,7 @@ init_reassoc (void)
bb_rank[bbs[i]] = ++rank << 16;
free (bbs);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
plus_negates = vNULL;
}
@@ -5025,7 +5025,7 @@ fini_reassoc (void)
operand_entry_pool.release ();
free (bb_rank);
plus_negates.release ();
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
loop_optimizer_finalize ();
}
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index a72a920..2b7e646 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -4169,7 +4169,7 @@ init_scc_vn (void)
int j;
int *rpo_numbers_temp;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
mark_dfs_back_edges ();
sccstack.create (0);
@@ -4459,7 +4459,7 @@ sccvn_dom_walker::before_dom_children (basic_block bb)
reachable. */
bool reachable = bb == ENTRY_BLOCK_PTR_FOR_FN (cfun);
FOR_EACH_EDGE (e, ei, bb->preds)
- if (!dominated_by_p (CDI_DOMINATORS, e->src, bb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, e->src, bb))
reachable |= (e->flags & EDGE_EXECUTABLE);
/* If the block is not reachable all outgoing edges are not
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 8118f35..388c65d 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -394,7 +394,7 @@ statement_sink_location (gimple stmt, basic_block frombb,
bb = nearest_common_dominator (CDI_DOMINATORS, bb, commondom);
if (!found)
found = bb;
- else if (dominated_by_p (CDI_DOMINATORS, bb, found))
+ else if (dominated_by_p (cfun, CDI_DOMINATORS, bb, found))
found = bb;
/* If we can't improve, stop. */
if (found == commondom)
@@ -408,7 +408,7 @@ statement_sink_location (gimple stmt, basic_block frombb,
/* Our common dominator has to be dominated by frombb in order to be a
trivially safe place to put this statement, since it has multiple
uses. */
- if (!dominated_by_p (CDI_DOMINATORS, commondom, frombb))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, commondom, frombb))
return false;
commondom = select_best_block (frombb, commondom, stmt);
@@ -627,11 +627,11 @@ pass_sink_code::execute (function *fun)
split_critical_edges ();
connect_infinite_loops_to_exit ();
memset (&sink_stats, 0, sizeof (sink_stats));
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
sink_code_in_bb (EXIT_BLOCK_PTR_FOR_FN (fun));
statistics_counter_event (fun, "Sunk statements", sink_stats.sunk);
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
remove_fake_exit_edges ();
loop_optimizer_finalize ();
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index cfe4dd9..e8577f6 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -2171,7 +2171,7 @@ do_invalidate (basic_block dombb, gimple phi, bitmap visited, int *count)
if (bb == NULL
|| bb == dombb
|| !bitmap_set_bit (visited, bb->index)
- || !dominated_by_p (CDI_DOMINATORS, bb, dombb))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, bb, dombb))
continue;
while (1)
{
@@ -2197,7 +2197,7 @@ do_invalidate (basic_block dombb, gimple phi, bitmap visited, int *count)
if (bb == NULL
|| bb == dombb
|| !bitmap_set_bit (visited, bb->index)
- || !dominated_by_p (CDI_DOMINATORS, bb, dombb))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, bb, dombb))
break;
}
}
@@ -2357,7 +2357,7 @@ pass_strlen::execute (function *fun)
ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
max_stridx = 1;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* String length optimization is implemented as a walk of the dominator
tree and a forward walk of statements within each block. */
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index 88a3032..9c2dc9f 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -426,7 +426,7 @@ update_dep_bb (basic_block use_bb, tree val)
return;
if (BB_DEP_BB (use_bb) == NULL
- || dominated_by_p (CDI_DOMINATORS, dep_bb, BB_DEP_BB (use_bb)))
+ || dominated_by_p (cfun, CDI_DOMINATORS, dep_bb, BB_DEP_BB (use_bb)))
BB_DEP_BB (use_bb) = dep_bb;
}
@@ -946,7 +946,8 @@ update_rep_bb (bb_cluster c, basic_block bb)
BB_DEP_BB, which is really BB_LAST_DEP_BB.
The benefit of choosing the bb with last deps earlier, is that it can
potentially be used as replacement for more bbs. */
- if (dominated_by_p (CDI_DOMINATORS, BB_DEP_BB (c->rep_bb), BB_DEP_BB (bb)))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, BB_DEP_BB (c->rep_bb),
+ BB_DEP_BB (bb)))
c->rep_bb = bb;
}
@@ -1366,10 +1367,10 @@ deps_ok_for_redirect_from_bb_to_bb (basic_block from, basic_block to)
FOR_EACH_EDGE (e, ei, from->preds)
bitmap_set_bit (from_preds, e->src->index);
- cd = nearest_common_dominator_for_set (CDI_DOMINATORS, from_preds);
+ cd = nearest_common_dominator_for_set (cfun, CDI_DOMINATORS, from_preds);
BITMAP_FREE (from_preds);
- return dominated_by_p (CDI_DOMINATORS, dep_bb, cd);
+ return dominated_by_p (cfun, CDI_DOMINATORS, dep_bb, cd);
}
/* Returns true if replacing BB1 (or its replacement bb) by BB2 (or its
@@ -1600,7 +1601,7 @@ update_debug_stmt (gimple stmt)
gimple def_stmt = SSA_NAME_DEF_STMT (name);
basic_block bbdef = gimple_bb (def_stmt);
if (bbdef == NULL || bbuse == bbdef
- || dominated_by_p (CDI_DOMINATORS, bbuse, bbdef))
+ || dominated_by_p (cfun, CDI_DOMINATORS, bbuse, bbdef))
continue;
gimple_debug_bind_reset_value (stmt);
@@ -1652,11 +1653,11 @@ tail_merge_optimize (unsigned int todo)
timevar_push (TV_TREE_TAIL_MERGE);
- if (!dom_info_available_p (CDI_DOMINATORS))
+ if (!dom_info_available_p (cfun, CDI_DOMINATORS))
{
/* PRE can leave us with unreachable blocks, remove them now. */
delete_unreachable_blocks ();
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
}
init_worklist ();
@@ -1685,12 +1686,12 @@ tail_merge_optimize (unsigned int todo)
if (nr_bbs_removed == 0)
break;
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
if (iteration_nr == max_iterations)
break;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
update_worklist ();
}
@@ -1702,7 +1703,7 @@ tail_merge_optimize (unsigned int todo)
{
if (MAY_HAVE_DEBUG_STMTS)
{
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
update_debug_stmts ();
}
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 7164122..d0a5c1c 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -136,7 +136,7 @@ lhs_of_dominating_assert (tree op, basic_block bb, gimple stmt)
&& gimple_assign_single_p (use_stmt)
&& TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ASSERT_EXPR
&& TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == op
- && dominated_by_p (CDI_DOMINATORS, bb, gimple_bb (use_stmt)))
+ && dominated_by_p (cfun, CDI_DOMINATORS, bb, gimple_bb (use_stmt)))
{
return gimple_assign_lhs (use_stmt);
}
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index 5a5f8df..89f7247 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -1542,7 +1542,7 @@ thread_block_1 (basic_block bb, bool noloop_only, bool joiners)
}
/* We do not update dominance info. */
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
/* We know we only thread through the loop header to loop exits.
Let the basic block duplication hook know we are not creating
@@ -2595,7 +2595,7 @@ thread_through_all_blocks (bool may_peel_loop_headers)
if (duplicate_thread_path (entry, exit, region, len - 1, NULL))
{
/* We do not update dominance info. */
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
bitmap_set_bit (threaded_blocks, entry->src->index);
retval = true;
}
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 437f69d..404231e 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -438,7 +438,7 @@ single_incoming_edge_ignoring_loop_edges (basic_block bb)
{
/* A loop back edge can be identified by the destination of
the edge dominating the source of the edge. */
- if (dominated_by_p (CDI_DOMINATORS, e->src, e->dest))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, e->src, e->dest))
continue;
/* If we have already seen a non-loop edge, then we must have
@@ -527,7 +527,7 @@ pass_uncprop::execute (function *fun)
/* We're going to do a dominator walk, so ensure that we have
dominance information. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
/* Recursively walk the dominator tree undoing unprofitable
constant/copy propagations. */
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 3f007b5..bec0765 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -184,7 +184,7 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
FOR_EACH_BB_FN (bb, cfun)
{
- bool always_executed = dominated_by_p (CDI_POST_DOMINATORS,
+ bool always_executed = dominated_by_p (cfun, CDI_POST_DOMINATORS,
single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)), bb);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
@@ -360,7 +360,7 @@ find_dom (basic_block block)
static bool
is_non_loop_exit_postdominating (basic_block bb1, basic_block bb2)
{
- if (!dominated_by_p (CDI_POST_DOMINATORS, bb2, bb1))
+ if (!dominated_by_p (cfun, CDI_POST_DOMINATORS, bb2, bb1))
return false;
if (single_pred_p (bb1) && !single_succ_p (bb2))
@@ -383,7 +383,7 @@ find_control_equiv_block (basic_block bb)
if (!is_non_loop_exit_postdominating (pdom, bb))
return NULL;
- if (dominated_by_p (CDI_DOMINATORS, pdom, bb))
+ if (dominated_by_p (cfun, CDI_DOMINATORS, pdom, bb))
return pdom;
return NULL;
@@ -661,10 +661,11 @@ find_predicates (pred_chain_union *preds,
/* First find the closest bb that is control equivalent to PHI_BB
that also dominates USE_BB. */
cd_root = phi_bb;
- while (dominated_by_p (CDI_DOMINATORS, use_bb, cd_root))
+ while (dominated_by_p (cfun, CDI_DOMINATORS, use_bb, cd_root))
{
basic_block ctrl_eq_bb = find_control_equiv_block (cd_root);
- if (ctrl_eq_bb && dominated_by_p (CDI_DOMINATORS, use_bb, ctrl_eq_bb))
+ if (ctrl_eq_bb && dominated_by_p (cfun, CDI_DOMINATORS, use_bb,
+ ctrl_eq_bb))
cd_root = ctrl_eq_bb;
else
break;
@@ -718,8 +719,8 @@ collect_phi_def_edges (gphi *phi, basic_block cd_root,
gimple def = SSA_NAME_DEF_STMT (opnd);
if (gimple_code (def) == GIMPLE_PHI
- && dominated_by_p (CDI_DOMINATORS,
- gimple_bb (def), cd_root))
+ && dominated_by_p (cfun, CDI_DOMINATORS,
+ gimple_bb (def), cd_root))
collect_phi_def_edges (as_a <gphi *> (def), cd_root, edges,
visited_phis);
else if (!uninit_undefined_value_p (opnd))
@@ -2413,8 +2414,8 @@ pass_late_warn_uninitialized::execute (function *fun)
gphi_iterator gsi;
vec<gphi *> worklist = vNULL;
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_POST_DOMINATORS);
/* Re-do the plain uninitialized variable check, as optimization may have
straightened control flow. Do this first so that we don't accidentally
get a "may be" warning when we'd have seen an "is" warning later. */
@@ -2466,7 +2467,7 @@ pass_late_warn_uninitialized::execute (function *fun)
worklist.release ();
delete possibly_undefined_names;
possibly_undefined_names = NULL;
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
timevar_pop (TV_TREE_UNINIT);
return 0;
}
@@ -2488,14 +2489,14 @@ execute_early_warn_uninitialized (void)
optimization we want to warn about possible uninitialized as late
as possible, thus don't do it here. However, without
optimization we need to warn here about "may be uninitialized". */
- calculate_dominance_info (CDI_POST_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_POST_DOMINATORS);
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
/* Post-dominator information can not be reliably updated. Free it
after the use. */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (cfun, CDI_POST_DOMINATORS);
return 0;
}
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 9646466..ec8a65b 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -363,7 +363,7 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
{
bool no_value = false;
- if (!dom_info_available_p (CDI_DOMINATORS))
+ if (!dom_info_available_p (cfun, CDI_DOMINATORS))
{
struct walk_stmt_info wi;
@@ -760,7 +760,7 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
err = true;
}
else if (bb != def_bb
- && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
+ && !dominated_by_p (cfun, CDI_DOMINATORS, bb, def_bb))
{
error ("definition in block %i does not dominate use in block %i",
def_bb->index, bb->index);
@@ -918,7 +918,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
ssa_op_iter iter;
tree op;
- enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
+ enum dom_state orig_dom_state = dom_info_state (cfun, CDI_DOMINATORS);
bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
gcc_assert (!need_ssa_update_p (cfun));
@@ -947,7 +947,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
}
}
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* Now verify all the uses and make sure they agree with the definitions
found in the previous pass. */
@@ -1035,9 +1035,9 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
/* Restore the dominance information to its prior known state, so
that we do not perturb the compiler's subsequent behavior. */
if (orig_dom_state == DOM_NONE)
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
else
- set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
+ set_dom_info_availability (cfun, CDI_DOMINATORS, orig_dom_state);
BITMAP_FREE (names_defined_in_bb);
timevar_pop (TV_TREE_SSA_VERIFY);
diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c
index cd595a9..31c0afc 100644
--- a/gcc/tree-stdarg.c
+++ b/gcc/tree-stdarg.c
@@ -64,7 +64,7 @@ reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
if (va_arg_bb == va_start_bb)
return true;
- if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
+ if (! dominated_by_p (cfun, CDI_DOMINATORS, va_arg_bb, va_start_bb))
return false;
visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
@@ -792,7 +792,7 @@ optimize_va_list_gpr_fpr_size (function *fun)
if (va_list_simple_ptr)
fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (fun, CDI_DOMINATORS);
memset (&wi, 0, sizeof (wi));
wi.info = si.va_list_vars;
@@ -1093,7 +1093,7 @@ expand_ifn_va_arg_1 (function *fun)
if (!modified)
return;
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (fun, CDI_DOMINATORS);
update_ssa (TODO_update_ssa);
}
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index 3201912..909a9e8 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -122,8 +122,8 @@ hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
if (update_dominators)
{
if (dominated_e_true)
- set_immediate_dominator (CDI_DOMINATORS, e_true->dest, split_bb);
- set_immediate_dominator (CDI_DOMINATORS, e_false->dest, split_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, e_true->dest, split_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, e_false->dest, split_bb);
}
return new_bb;
@@ -285,7 +285,7 @@ emit_case_bit_tests (gswitch *swtch, tree index_expr,
basic_block switch_bb = gimple_bb (swtch);
basic_block default_bb, new_default_bb, new_bb;
edge default_edge;
- bool update_dom = dom_info_available_p (CDI_DOMINATORS);
+ bool update_dom = dom_info_available_p (cfun, CDI_DOMINATORS);
vec<basic_block> bbs_to_fix_dom = vNULL;
@@ -429,7 +429,7 @@ emit_case_bit_tests (gswitch *swtch, tree index_expr,
edge e = find_edge (new_bb, dom_son);
if (e && single_pred_p (e->dest))
continue;
- set_immediate_dominator (CDI_DOMINATORS, dom_son, switch_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, dom_son, switch_bb);
bbs_to_fix_dom.safe_push (dom_son);
}
dom_bbs.release ();
@@ -476,7 +476,7 @@ emit_case_bit_tests (gswitch *swtch, tree index_expr,
if (update_dom)
{
/* Fix up the dominator tree. */
- iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, bbs_to_fix_dom, true);
bbs_to_fix_dom.release ();
}
}
@@ -1311,15 +1311,15 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
fix_phi_nodes (e1f, e2f, bbf, info);
/* Fix the dominator tree, if it is available. */
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cfun, CDI_DOMINATORS))
{
vec<basic_block> bbs_to_fix_dom;
- set_immediate_dominator (CDI_DOMINATORS, bb1, bb0);
- set_immediate_dominator (CDI_DOMINATORS, bb2, bb0);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb1, bb0);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb2, bb0);
if (! get_immediate_dominator (CDI_DOMINATORS, bbf))
/* If bbD was the immediate dominator ... */
- set_immediate_dominator (CDI_DOMINATORS, bbf, bb0);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bbf, bb0);
bbs_to_fix_dom.create (4);
bbs_to_fix_dom.quick_push (bb0);
@@ -1327,7 +1327,7 @@ gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
bbs_to_fix_dom.quick_push (bb2);
bbs_to_fix_dom.quick_push (bbf);
- iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
+ iterate_fix_dominators (cfun, CDI_DOMINATORS, bbs_to_fix_dom, true);
bbs_to_fix_dom.release ();
}
}
@@ -1485,7 +1485,7 @@ pass_convert_switch::execute (function *fun)
/* Make no effort to update the post-dominator tree. It is actually not
that hard for the transformations we have performed, but it is not
supported by iterate_fix_dominators. */
- free_dominance_info (CDI_POST_DOMINATORS);
+ free_dominance_info (fun, CDI_POST_DOMINATORS);
}
else
{
diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index 7b723c2..a19261f 100644
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -1066,7 +1066,7 @@ tree_optimize_tail_calls_1 (bool opt_tailcalls)
{
/* We may have created new loops. Make them magically appear. */
loops_state_set (LOOPS_NEED_FIXUP);
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
}
/* Add phi nodes for the virtual operands defined in the function to the
diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
index efcc4bb..9613fbe 100644
--- a/gcc/tree-vect-loop-manip.c
+++ b/gcc/tree-vect-loop-manip.c
@@ -146,7 +146,7 @@ adjust_debug_stmts_now (adjust_info *ai)
gimple stmt;
basic_block bbdef = gimple_bb (SSA_NAME_DEF_STMT (orig_def));
- gcc_assert (dom_info_available_p (CDI_DOMINATORS));
+ gcc_assert (dom_info_available_p (cfun, CDI_DOMINATORS));
/* Adjust any debug stmts that held onto non-loop-closed
references. */
@@ -163,9 +163,9 @@ adjust_debug_stmts_now (adjust_info *ai)
bbuse = gimple_bb (stmt);
if ((bbuse == bbphi
- || dominated_by_p (CDI_DOMINATORS, bbuse, bbphi))
+ || dominated_by_p (cfun, CDI_DOMINATORS, bbuse, bbphi))
&& !(bbuse == bbdef
- || dominated_by_p (CDI_DOMINATORS, bbuse, bbdef)))
+ || dominated_by_p (cfun, CDI_DOMINATORS, bbuse, bbdef)))
{
if (new_def)
FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
@@ -847,16 +847,16 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
}
redirect_edge_and_branch_force (e, new_preheader);
flush_pending_stmts (e);
- set_immediate_dominator (CDI_DOMINATORS, new_preheader, e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_preheader, e->src);
if (was_imm_dom || duplicate_outer_loop)
- set_immediate_dominator (CDI_DOMINATORS, exit_dest, new_exit->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, exit_dest, new_exit->src);
/* And remove the non-necessary forwarder again. Keep the other
one so we have a proper pre-header for the loop at the exit edge. */
redirect_edge_pred (single_succ_edge (preheader),
single_pred (preheader));
delete_basic_block (preheader);
- set_immediate_dominator (CDI_DOMINATORS, scalar_loop->header,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, scalar_loop->header,
loop_preheader_edge (scalar_loop)->src);
}
else /* Add the copy at entry. */
@@ -867,7 +867,7 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
redirect_edge_pred (single_succ_edge (preheader),
single_pred (preheader));
delete_basic_block (preheader);
- set_immediate_dominator (CDI_DOMINATORS, scalar_loop->header,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, scalar_loop->header,
loop_preheader_edge (scalar_loop)->src);
preheader = split_edge (loop_preheader_edge (loop));
entry_e = single_pred_edge (preheader);
@@ -875,18 +875,18 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
redirect_edge_and_branch_force (entry_e, new_preheader);
flush_pending_stmts (entry_e);
- set_immediate_dominator (CDI_DOMINATORS, new_preheader, entry_e->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_preheader, entry_e->src);
redirect_edge_and_branch_force (new_exit, preheader);
flush_pending_stmts (new_exit);
- set_immediate_dominator (CDI_DOMINATORS, preheader, new_exit->src);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, preheader, new_exit->src);
/* And remove the non-necessary forwarder again. Keep the other
one so we have a proper pre-header for the loop at the exit edge. */
redirect_edge_pred (single_succ_edge (new_preheader),
single_pred (new_preheader));
delete_basic_block (new_preheader);
- set_immediate_dominator (CDI_DOMINATORS, new_loop->header,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, new_loop->header,
loop_preheader_edge (new_loop)->src);
}
@@ -920,7 +920,7 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
free (bbs);
#ifdef ENABLE_CHECKING
- verify_dominators (CDI_DOMINATORS);
+ verify_dominators (cfun, CDI_DOMINATORS);
#endif
return new_loop;
@@ -967,7 +967,7 @@ slpeel_add_loop_guard (basic_block guard_bb, tree cond,
new_e->count = apply_probability (enter_e->count, probability);
enter_e->count -= new_e->count;
enter_e->probability = inverse_probability (probability);
- set_immediate_dominator (CDI_DOMINATORS, exit_bb, dom_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, exit_bb, dom_bb);
return new_e;
}
@@ -1066,11 +1066,11 @@ set_prologue_iterations (basic_block bb_before_first_loop,
e = single_pred_edge (bb_before_first_loop);
then_bb = split_edge (e);
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, then_bb, cond_bb);
e_false = make_single_succ_edge (cond_bb, bb_before_first_loop,
EDGE_FALSE_VALUE);
- set_immediate_dominator (CDI_DOMINATORS, bb_before_first_loop, cond_bb);
+ set_immediate_dominator (cfun, CDI_DOMINATORS, bb_before_first_loop, cond_bb);
e_true = EDGE_PRED (then_bb, 0);
e_true->flags &= ~EDGE_FALLTHRU;
@@ -2389,11 +2389,11 @@ vect_loop_versioning (loop_vec_info loop_vinfo,
scalar_preheader);
redirect_edge_and_branch_force (scalar_e, preheader);
redirect_edge_and_branch_force (e, condition_bb);
- set_immediate_dominator (CDI_DOMINATORS, condition_bb,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, condition_bb,
single_pred (condition_bb));
- set_immediate_dominator (CDI_DOMINATORS, scalar_preheader,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, scalar_preheader,
single_pred (scalar_preheader));
- set_immediate_dominator (CDI_DOMINATORS, preheader,
+ set_immediate_dominator (cfun, CDI_DOMINATORS, preheader,
condition_bb);
}
else
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index bc3117d..1f74013 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -1908,7 +1908,7 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
{
basic_block bb = gimple_bb (SSA_NAME_DEF_STMT (oprnd1));
if (bb == NULL
- || !dominated_by_p (CDI_DOMINATORS, ext_def->dest, bb))
+ || !dominated_by_p (cfun, CDI_DOMINATORS, ext_def->dest, bb))
ext_def = NULL;
}
}
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 685eb72..2989b57 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -5037,7 +5037,7 @@ register_new_assert_for (tree name, tree expr,
the assertion up in the dominance tree by updating its
location information. */
if ((e == NULL || !EDGE_CRITICAL_P (e))
- && dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb))
+ && dominated_by_p (cfun, CDI_DOMINATORS, loc->bb, dest_bb))
{
loc->bb = dest_bb;
loc->e = e;
@@ -5300,7 +5300,8 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
continue;
/* Cut off to use-stmts that are dominating the predecessor. */
- if (!dominated_by_p (CDI_DOMINATORS, e->src, gimple_bb (use_stmt)))
+ if (!dominated_by_p (cfun, CDI_DOMINATORS, e->src,
+ gimple_bb (use_stmt)))
continue;
tree name2 = gimple_assign_lhs (use_stmt);
@@ -6460,7 +6461,7 @@ insert_range_assertions (void)
need_assert_for = BITMAP_ALLOC (NULL);
asserts_for = XCNEWVEC (assert_locus_t, num_ssa_names);
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
find_assert_locations ();
if (!bitmap_empty_p (need_assert_for))
@@ -10133,7 +10134,7 @@ identify_jump_threads (void)
/* Ugh. When substituting values earlier in this pass we can
wipe the dominance information. So rebuild the dominator
information as we need it within the jump threading code. */
- calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (cfun, CDI_DOMINATORS);
/* We do not allow VRP information to be used for jump threading
across a back edge in the CFG. Otherwise it becomes too
@@ -10406,7 +10407,7 @@ execute_vrp (void)
if (to_remove_edges.length () > 0)
{
- free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (cfun, CDI_DOMINATORS);
loops_state_set (LOOPS_NEED_FIXUP);
}
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index 7983c93..5af3d5c 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -741,7 +741,7 @@ ubsan_expand_bounds_ifn (gimple_stmt_iterator *gsi)
could be changed to any other pointer type. */
bool
-ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
+ubsan_expand_null_ifn (function *cur_fn, gimple_stmt_iterator *gsip)
{
gimple_stmt_iterator gsi = *gsip;
gimple stmt = gsi_stmt (gsi);
@@ -807,8 +807,8 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
/* Update dominance info for the newly created then_bb; note that
fallthru_bb's dominance info has already been updated by
split_block. */
- if (dom_info_available_p (CDI_DOMINATORS))
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
+ if (dom_info_available_p (cur_fn, CDI_DOMINATORS))
+ set_immediate_dominator (cur_fn, CDI_DOMINATORS, then_bb, cond_bb);
/* Put the ubsan builtin call into the newly created BB. */
if (flag_sanitize_undefined_trap_on_error)
@@ -874,10 +874,10 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
e->probability = REG_BR_PROB_BASE - PROB_VERY_UNLIKELY;
/* Update dominance info. */
- if (dom_info_available_p (CDI_DOMINATORS))
+ if (dom_info_available_p (cur_fn, CDI_DOMINATORS))
{
- set_immediate_dominator (CDI_DOMINATORS, fallthru_bb, cond1_bb);
- set_immediate_dominator (CDI_DOMINATORS, then_bb, cond1_bb);
+ set_immediate_dominator (cur_fn, CDI_DOMINATORS, fallthru_bb, cond1_bb);
+ set_immediate_dominator (cur_fn, CDI_DOMINATORS, then_bb, cond1_bb);
}
gsi2 = gsi_start_bb (cond2_bb);
diff --git a/gcc/ubsan.h b/gcc/ubsan.h
index 9f23a38..0ce912f 100644
--- a/gcc/ubsan.h
+++ b/gcc/ubsan.h
@@ -44,7 +44,7 @@ enum ubsan_print_style {
extern bool do_ubsan_in_current_function (void);
extern bool ubsan_expand_bounds_ifn (gimple_stmt_iterator *);
-extern bool ubsan_expand_null_ifn (gimple_stmt_iterator *);
+extern bool ubsan_expand_null_ifn (function *, gimple_stmt_iterator *);
extern bool ubsan_expand_objsize_ifn (gimple_stmt_iterator *);
extern bool ubsan_expand_vptr_ifn (gimple_stmt_iterator *);
extern bool ubsan_instrument_unreachable (gimple_stmt_iterator *);
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-14 1:05 [PATCH 1/2] C++-ify dominance.c Mikhail Maltsev
2015-08-14 1:25 ` [PATCH 2/2] Get rid of global state accesses in dominance.c Mikhail Maltsev
@ 2015-08-14 7:54 ` Richard Biener
2015-08-14 17:26 ` Jeff Law
2015-08-15 6:05 ` Mikhail Maltsev
2015-08-14 18:25 ` Jeff Law
2 siblings, 2 replies; 14+ messages in thread
From: Richard Biener @ 2015-08-14 7:54 UTC (permalink / raw)
To: Mikhail Maltsev; +Cc: gcc-patches, Jeff Law
On Fri, Aug 14, 2015 at 2:55 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
> Hi all.
>
> These two patches are refactoring of dominator-related code.
>
> The comment in dominance.c says: "We work in a poor-mans object oriented
> fashion, and carry an instance of this structure through all our 'methods'". So,
> the first patch converts the mentioned structure (dom_info) into a class with
> proper encapsulation. It also adds a new member - m_fn (the function currently
> being compiled) to this structure and replaces some uses of cfun with m_fn. It
> also contains some fixes, related to current coding standards: move variable
> declarations to place of first use, replace elaborated type specifiers (i.e.
> "struct/enum foo") by simple ones (i.e., just "foo") in function prototypes.
Putting in m_fn looks backwards to me - it looks like we only need to remember
the entry and exit BBs and the number of blocks. In fact initializing
dom_info from that would allow it to work on SESE regions as well?
+unsigned bb_dom_dfs_in (cdi_direction, basic_block);
+unsigned bb_dom_dfs_out (cdi_direction, basic_block);
+extern void verify_dominators (cdi_direction);
+basic_block recompute_dominator (cdi_direction, basic_block);
+extern void iterate_fix_dominators (cdi_direction, vec<basic_block> , bool);
+extern void add_to_dominance_info (cdi_direction, basic_block);
if you are here please fix the 'extern' vs. w/o 'extern' inconsistencies as well
(we prefer 'extern').
In general I'm biased and refactoring for the sake of refactoring
doesn't go well
with me ...
At least the above is a constructive comment, leaving the rest to Jeff.
Thanks,
Richard.
>
> Bootstrapped and regtested on x86_64-linux. Tested build of config-list.mk.
>
> gcc/ChangeLog:
>
> 2015-08-14 Mikhail Maltsev <maltsevm@gmail.com>
>
> * (ENABLE_CHECKING): Define as 0 by default.
> dominance.c (new_zero_array): Define.
> (dom_info): Define as class instead of struct.
> (dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
> allocations/deallocations. Pass function as parameter (instead of
> using cfun).
> (dom_info::get_idom): Define accessor method.
> (dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
> link_roots, calc_idoms): Redefine as class members. Use m_fn instead
> of cfun.
> (init_dom_info, free_dom_info): Remove (use dom_info ctor/dtor).
> (dom_convert_dir_to_idx): Fix prototype.
> (assign_dfs_numbers): Move variable declarations to their first uses.
> (calculate_dominance_info): Remove conditional compilation, move
> variables.
> (free_dominance_info, get_immediate_dominator, set_immediate_dominator,
> get_dominated_b, get_dominated_by_region, get_dominated_to_depth,
> redirect_immediate_dominators, nearest_common_dominator_for_set,
> dominated_by_p, bb_dom_dfs_in, bb_dom_dfs_out, verify_dominators,
> determine_dominators_for_sons, iterate_fix_dominators, first_dom_son,
> next_dom_son, debug_dominance_info, debug_dominance_tree_1): Adjust to
> use class dom_info. Move variable declarations to the place of first
> use. Fix prototypes (remove struct/enum).
> * dominance.h: Fix prototypes (remove struct/enum).
>
> --
> Regards,
> Mikhail Maltsev
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-14 1:25 ` [PATCH 2/2] Get rid of global state accesses in dominance.c Mikhail Maltsev
@ 2015-08-14 8:17 ` Richard Biener
2015-08-14 18:28 ` Jeff Law
2015-08-15 6:13 ` Mikhail Maltsev
0 siblings, 2 replies; 14+ messages in thread
From: Richard Biener @ 2015-08-14 8:17 UTC (permalink / raw)
To: Mikhail Maltsev; +Cc: gcc-patches, Jeff Law
On Fri, Aug 14, 2015 at 3:04 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
> The second part removes all global state accesses (i.e. accesses to cfun and
> it's members) from dominance.c. This requires to change lots of code, but I hope
> that this is a step in right direction (if my understanding of ongoing
> re-architecture w.r.t. to global state is correct).
>
> For now this second part lacks a changelog entry, but it's very "mechanical". I
> will, of course, write it if the patch gets approved.
So the last time I did similar refactoring I wondered if we can somehow avoid
the "noise" in non-IPA passes. Ideas I came up with are
a) Inherit gimple/rtl pass classes from a class which is initialized with the
function the pass operates on and provides methods like
bool dom_info_available_p (..) { return dom_info_available_p (fn, ...); }
thus wraps APIs working on a specific function.
b) Do sth similar but make it work with overloads and clever (no idea what!)
C++ that disables them if this_fn cannot be looked up
template <disable-me-if-this_fn-cannot_be_lookedup-at-instantiation-place>
bool dom_info_available_p (..., struct function *fn = this_fn);
all of the above would of course require that passes make all their
implementation
be methods of their pass class. So even more refactoring.
Note that we do not have any IPA pass which accesses dominators, so the
implicit 'cfun' use was ok. The cases I refactored were those where we had
to push/pop_cfun () in IPA passes (which can be expensive) because it
used APIs with implicit cfun.
Overall I'm not sure we want all APIs using 'cfun' to be refactored.
It is after
all useless noise to callers if all callers are effectively using 'cfun'.
Refactoring APIs that are used from IPA and make push/pop_cfun necessary
for them are another thing. (there are still plenty left I think)
Richard.
> --
> Regards,
> Mikhail Maltsev
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-14 7:54 ` [PATCH 1/2] C++-ify dominance.c Richard Biener
@ 2015-08-14 17:26 ` Jeff Law
2015-08-15 6:05 ` Mikhail Maltsev
1 sibling, 0 replies; 14+ messages in thread
From: Jeff Law @ 2015-08-14 17:26 UTC (permalink / raw)
To: Richard Biener, Mikhail Maltsev; +Cc: gcc-patches
On 08/14/2015 01:54 AM, Richard Biener wrote:
> On Fri, Aug 14, 2015 at 2:55 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
>> Hi all.
>>
>> These two patches are refactoring of dominator-related code.
>>
>> The comment in dominance.c says: "We work in a poor-mans object oriented
>> fashion, and carry an instance of this structure through all our 'methods'". So,
>> the first patch converts the mentioned structure (dom_info) into a class with
>> proper encapsulation. It also adds a new member - m_fn (the function currently
>> being compiled) to this structure and replaces some uses of cfun with m_fn. It
>> also contains some fixes, related to current coding standards: move variable
>> declarations to place of first use, replace elaborated type specifiers (i.e.
>> "struct/enum foo") by simple ones (i.e., just "foo") in function prototypes.
>
> Putting in m_fn looks backwards to me - it looks like we only need to remember
> the entry and exit BBs and the number of blocks. In fact initializing
> dom_info from that would allow it to work on SESE regions as well?
Or a SEME region. While I don't have an immediate use for dominators
regions in the CFG, I believe they'd be useful.
>
> +unsigned bb_dom_dfs_in (cdi_direction, basic_block);
> +unsigned bb_dom_dfs_out (cdi_direction, basic_block);
> +extern void verify_dominators (cdi_direction);
> +basic_block recompute_dominator (cdi_direction, basic_block);
> +extern void iterate_fix_dominators (cdi_direction, vec<basic_block> , bool);
> +extern void add_to_dominance_info (cdi_direction, basic_block);
>
> if you are here please fix the 'extern' vs. w/o 'extern' inconsistencies as well
> (we prefer 'extern').
Presumably we're not at a point where we can push these down as methods
in the class? ie, are we providing a class to query and manipulate
the dominator tree from outside dominance.c or are we doing it just for
internal stuff. I believe the former is more strategic, the latter may
have value as well, but I believe it's more limited.
>
> In general I'm biased and refactoring for the sake of refactoring
> doesn't go well with me ...
But if we're taking something that's essentially C++ implemented in C
and turn it into real C++ with encapsulation, that's a step in the right
direction to me.
jeff
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-14 1:05 [PATCH 1/2] C++-ify dominance.c Mikhail Maltsev
2015-08-14 1:25 ` [PATCH 2/2] Get rid of global state accesses in dominance.c Mikhail Maltsev
2015-08-14 7:54 ` [PATCH 1/2] C++-ify dominance.c Richard Biener
@ 2015-08-14 18:25 ` Jeff Law
2015-08-15 7:59 ` Richard Biener
2 siblings, 1 reply; 14+ messages in thread
From: Jeff Law @ 2015-08-14 18:25 UTC (permalink / raw)
To: Mikhail Maltsev, gcc-patches
On 08/13/2015 06:55 PM, Mikhail Maltsev wrote:
> Hi all.
>
> These two patches are refactoring of dominator-related code.
>
> The comment in dominance.c says: "We work in a poor-mans object oriented
> fashion, and carry an instance of this structure through all our 'methods'". So,
> the first patch converts the mentioned structure (dom_info) into a class with
> proper encapsulation. It also adds a new member - m_fn (the function currently
> being compiled) to this structure and replaces some uses of cfun with m_fn. It
> also contains some fixes, related to current coding standards: move variable
> declarations to place of first use, replace elaborated type specifiers (i.e.
> "struct/enum foo") by simple ones (i.e., just "foo") in function prototypes.
>
> Bootstrapped and regtested on x86_64-linux. Tested build of config-list.mk.
>
> gcc/ChangeLog:
>
> 2015-08-14 Mikhail Maltsev<maltsevm@gmail.com>
>
> * (ENABLE_CHECKING): Define as 0 by default.
> dominance.c (new_zero_array): Define.
> (dom_info): Define as class instead of struct.
> (dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
> allocations/deallocations. Pass function as parameter (instead of
> using cfun).
> (dom_info::get_idom): Define accessor method.
> (dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
> link_roots, calc_idoms): Redefine as class members. Use m_fn instead
> of cfun.
> (init_dom_info, free_dom_info): Remove (use dom_info ctor/dtor).
> (dom_convert_dir_to_idx): Fix prototype.
> (assign_dfs_numbers): Move variable declarations to their first uses.
> (calculate_dominance_info): Remove conditional compilation, move
> variables.
> (free_dominance_info, get_immediate_dominator, set_immediate_dominator,
> get_dominated_b, get_dominated_by_region, get_dominated_to_depth,
> redirect_immediate_dominators, nearest_common_dominator_for_set,
> dominated_by_p, bb_dom_dfs_in, bb_dom_dfs_out, verify_dominators,
> determine_dominators_for_sons, iterate_fix_dominators, first_dom_son,
> next_dom_son, debug_dominance_info, debug_dominance_tree_1): Adjust to
> use class dom_info. Move variable declarations to the place of first
> use. Fix prototypes (remove struct/enum).
> * dominance.h: Fix prototypes (remove struct/enum).
>
> -- Regards, Mikhail Maltsev
>
It looks like your patch is primarily concerned with converting all the
internal stuff into a C++ style and not exposing a class to the users of
dominance.h. Correct?
As a whole I don't see anything objectionable here, but I also don't see
that it really takes us forward in a real significant way. I guess
there's some value in having dominance.c brought up to current
standards, but my recollection was we weren't going to do through the
entire source base and do things like move variable declarations to
their initial use and more generally c++-ify the code base en-masse.
Similarly losing the elaborated type specifiers doesn't really gain us
anything, except perhaps one less token when people parse the code.
Again, not objectionable, but also not a big gain.
I could argue that those kind of changes are independent of turning
dom_info into a real class and if they're going to go forward, they
would have to stand alone on their merits and go in independently if
turning dom_info into a class (which AFIACT is the meat of this patch).
> refactor_dom1.patch
>
>
> diff --git a/gcc/dominance.c b/gcc/dominance.c
> index d8d87ca..3c4f228 100644
> --- a/gcc/dominance.c
> +++ b/gcc/dominance.c
> @@ -44,6 +44,10 @@
> #include "timevar.h"
> #include "graphds.h"
>
> +#ifndef ENABLE_CHECKING
> +# define ENABLE_CHECKING 0
> +#endif
Umm, isn't ENABLE_CHECKING defined in auto-host.h (as set up by
configure?) What's the reason for this change?
Is the issue that auto-host.h won't define checking at all for
--disable-checking?
I think that the ENABLE_CHECKING conversion from #ifdef testing to
testing for a value should probably be done separately. It also
probably has higher value than this refactoring.
> +
> + /* The function being processed. */
> + function *m_fn;
So presumably the idea here is to avoid explicitly hitting cfun which in
theory we could recompute the dominance tree for another function. But
is that really all that useful?
I'm a bit torn here. Richi mentioned the idea of stuffing away a
pointer to cfun looked backwards to him and he'd pretty stuffing away
the entry, exit & # blocks and perhaps take us a step towards the
ability to compute dominance on sub-graphs.
The problem I see with Richi's idea now that I think about it more is
keeping that information up-to-date. Ie, if we've stuffed away those
pointers, what happens if (for example) a block gets deleted from the
graph. What if that block happens to be the exit block we've recorded?
So I guess I'm starting to lean towards saving away the cfun like as is
done in this patch.
>> + int *son = new int[n + 1],
> + *brother = new int[n + 1],
> + *parent = new int[n + 1];
ICK. Don't do this. Make each initialization a separate statement.
There's nothing really to be gained by avoiding the "int" here.
So ultimately the question is whether or not we're gaining much with
this patch to justify the churn it creates. I think I'll hold off on
yes/no to the patch to give other folks an opportunity to chime in.
Jeff
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-14 8:17 ` Richard Biener
@ 2015-08-14 18:28 ` Jeff Law
2015-08-14 20:24 ` David Malcolm
2015-08-15 6:13 ` Mikhail Maltsev
1 sibling, 1 reply; 14+ messages in thread
From: Jeff Law @ 2015-08-14 18:28 UTC (permalink / raw)
To: Richard Biener, Mikhail Maltsev; +Cc: gcc-patches
On 08/14/2015 02:02 AM, Richard Biener wrote:
> On Fri, Aug 14, 2015 at 3:04 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
>> The second part removes all global state accesses (i.e. accesses to cfun and
>> it's members) from dominance.c. This requires to change lots of code, but I hope
>> that this is a step in right direction (if my understanding of ongoing
>> re-architecture w.r.t. to global state is correct).
>>
>> For now this second part lacks a changelog entry, but it's very "mechanical". I
>> will, of course, write it if the patch gets approved.
>
> So the last time I did similar refactoring I wondered if we can somehow avoid
> the "noise" in non-IPA passes. Ideas I came up with are
>
> a) Inherit gimple/rtl pass classes from a class which is initialized with the
> function the pass operates on and provides methods like
>
> bool dom_info_available_p (..) { return dom_info_available_p (fn, ...); }
>
> thus wraps APIs working on a specific function.
>
> b) Do sth similar but make it work with overloads and clever (no idea what!)
> C++ that disables them if this_fn cannot be looked up
>
> template <disable-me-if-this_fn-cannot_be_lookedup-at-instantiation-place>
> bool dom_info_available_p (..., struct function *fn = this_fn);
>
> all of the above would of course require that passes make all their
> implementation
> be methods of their pass class. So even more refactoring.
>
> Note that we do not have any IPA pass which accesses dominators, so the
> implicit 'cfun' use was ok. The cases I refactored were those where we had
> to push/pop_cfun () in IPA passes (which can be expensive) because it
> used APIs with implicit cfun.
>
> Overall I'm not sure we want all APIs using 'cfun' to be refactored.
> It is after
> all useless noise to callers if all callers are effectively using 'cfun'.
And since the main driver for eliminating global state is David's work
on the JIT, perhaps see if any of this helps David in a noticeable way
before giving it a yea/nea.
Jeff
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-14 18:28 ` Jeff Law
@ 2015-08-14 20:24 ` David Malcolm
0 siblings, 0 replies; 14+ messages in thread
From: David Malcolm @ 2015-08-14 20:24 UTC (permalink / raw)
To: Jeff Law; +Cc: Richard Biener, Mikhail Maltsev, gcc-patches
On Fri, 2015-08-14 at 12:25 -0600, Jeff Law wrote:
> On 08/14/2015 02:02 AM, Richard Biener wrote:
> > On Fri, Aug 14, 2015 at 3:04 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
> >> The second part removes all global state accesses (i.e. accesses to cfun and
> >> it's members) from dominance.c. This requires to change lots of code, but I hope
> >> that this is a step in right direction (if my understanding of ongoing
> >> re-architecture w.r.t. to global state is correct).
> >>
> >> For now this second part lacks a changelog entry, but it's very "mechanical". I
> >> will, of course, write it if the patch gets approved.
> >
> > So the last time I did similar refactoring I wondered if we can somehow avoid
> > the "noise" in non-IPA passes. Ideas I came up with are
> >
> > a) Inherit gimple/rtl pass classes from a class which is initialized with the
> > function the pass operates on and provides methods like
> >
> > bool dom_info_available_p (..) { return dom_info_available_p (fn, ...); }
> >
> > thus wraps APIs working on a specific function.
> >
> > b) Do sth similar but make it work with overloads and clever (no idea what!)
> > C++ that disables them if this_fn cannot be looked up
> >
> > template <disable-me-if-this_fn-cannot_be_lookedup-at-instantiation-place>
> > bool dom_info_available_p (..., struct function *fn = this_fn);
> >
> > all of the above would of course require that passes make all their
> > implementation
> > be methods of their pass class. So even more refactoring.
> >
> > Note that we do not have any IPA pass which accesses dominators, so the
> > implicit 'cfun' use was ok. The cases I refactored were those where we had
> > to push/pop_cfun () in IPA passes (which can be expensive) because it
> > used APIs with implicit cfun.
> >
> > Overall I'm not sure we want all APIs using 'cfun' to be refactored.
> > It is after
> > all useless noise to callers if all callers are effectively using 'cfun'.
> And since the main driver for eliminating global state is David's work
> on the JIT, perhaps see if any of this helps David in a noticeable way
> before giving it a yea/nea.
The JIT guards all access to GCC's state in a big mutex ("jit_mutex", in
gcc/jit/jit-playback.c).
For example, this includes everything to do with GC and GTY, since
there's implicitly a single set of GC roots and the GC code isn't thread
safe.
So in theory this patch might reduce the amount of things that need to
be guarded by the mutex, but sadly the mountain of work there is so
large that I'm not sure how helpful it is. (sigh)
I've been tackling things on an as-needed basis - for example, the
recent timevar global-state removal was motivated by wanting to expose a
profiling API to jit client code.
So if there are other benefits beyond merely eliminating accesses to
globals, then maybe it's good. Does the code become simpler, more easy
to understand? Does it eliminate the need to change "cfun" (IIRC that
can be expensive).
For example, the jit has some rather ugly code to purge global state
after each in-process invocation. If that can be simplified or made
less ugly, that's good.
Hope this is constructive.
Dave
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-14 7:54 ` [PATCH 1/2] C++-ify dominance.c Richard Biener
2015-08-14 17:26 ` Jeff Law
@ 2015-08-15 6:05 ` Mikhail Maltsev
2015-08-18 19:23 ` Jeff Law
1 sibling, 1 reply; 14+ messages in thread
From: Mikhail Maltsev @ 2015-08-15 6:05 UTC (permalink / raw)
To: Richard Biener; +Cc: gcc-patches, Jeff Law
[-- Attachment #1: Type: text/plain, Size: 4905 bytes --]
On 08/14/2015 10:54 AM, Richard Biener wrote:
> Putting in m_fn looks backwards to me - it looks like we only need to remember
> the entry and exit BBs and the number of blocks.
Fixed.
> In fact initializing
> dom_info from that would allow it to work on SESE regions as well?
Can't tell for sure. We would need a way to iterate through region's basic
blocks (I'm not familiar with that code, but it seems to me that they are not
contiguous: build_sese_loop_nests function iterates through the region by
iterating through all BBs and filtering out ones which are not in region). Also
we have a mapping from some global BB index to it's number in DFS-order walk,
i.e. we will either need to allocate enough space for it, or use a hash map
instead of an array. Never the less, initializing start/end blocks and "reverse"
flag in constructor makes the code look cleaner because we avoid repeating these
initializations.
> if you are here please fix the 'extern' vs. w/o 'extern' inconsistencies as well
> (we prefer 'extern').
Reverted (see later).
On 08/14/2015 09:20 PM, Jeff Law wrote:
> It looks like your patch is primarily concerned with converting all the internal
> stuff into a C++ style and not exposing a class to the users of dominance.h.
> Correct?
Well, sort of. But I think this class also provides some API (though it's used
internally in dominance.c): it computes some initial dominance tree and other
functions either query it or update incrementally. And, as Richard said, this
class could be modified to be used on SESE regions.
> I could argue that those kind of changes are independent of turning dom_info
> into a real class and if they're going to go forward, they would have to stand
> alone on their merits and go in independently if turning dom_info into a class
> (which AFIACT is the meat of this patch).
Actually I thought that putting all these non-functional changes into a single
patch would make the churn less (after all, it's a single commit). But I
understand this rather obvious cue, that these changes are, well, unlikely to be
accepted.
So, the updated patch contains only the dom_info-related changes.
> Umm, isn't ENABLE_CHECKING defined in auto-host.h (as set up by configure?)
> What's the reason for this change?
>
> Is the issue that auto-host.h won't define checking at all for --disable-checking?
Yes, it does not get defined even for --enable-checking=release.
>
> I think that the ENABLE_CHECKING conversion from #ifdef testing to testing for a
> value should probably be done separately. It also probably has higher value
> than this refactoring.
Well, I'll try to work on that. After all, it's the most frequently used
condition for conditional compilation in GCC. And removing part of #ifdef-s will
probably help to avoid some errors (e.g. warnings which only appear in "release"
builds).
>
>
>> +
>> + /* The function being processed. */
>> + function *m_fn;
> So presumably the idea here is to avoid explicitly hitting cfun which in theory
> we could recompute the dominance tree for another function. But is that really
> all that useful?
No, I was thinking more of moving toward having a self-contained compilation
context and being able to run compilation in multiple threads. I know that we
are far away from this goal but never the less. BTW, do we actually have such
goal or not? :)
>
> I'm a bit torn here. Richi mentioned the idea of stuffing away a pointer to
> cfun looked backwards to him and he'd pretty stuffing away the entry, exit & #
> blocks and perhaps take us a step towards the ability to compute dominance on
> sub-graphs.
>
> The problem I see with Richi's idea now that I think about it more is keeping
> that information up-to-date. Ie, if we've stuffed away those pointers, what
> happens if (for example) a block gets deleted from the graph. What if that
> block happens to be the exit block we've recorded?
All this information is discarded after we have the dominator tree computed. The
tree itself is stored in et_node-s (which are "attached" to basic blocks).
dom_info is not used for incremental updates.
gcc/ChangeLog:
2015-08-15 Mikhail Maltsev <maltsevm@gmail.com>
* dominance.c (new_zero_array): Define.
(dom_info): Redefine as class with proper encapsulation.
(dom_info::m_n_basic_blocks, m_reverse, m_start_block, m_end_block):
Add new members.
(dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
allocations/deallocations. Pass function as parameter (instead of
using cfun).
(dom_info::get_idom): Define accessor method.
(dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
link_roots, calc_idoms): Redefine as class members. Do not use cfun.
(calculate_dominance_info): Adjust to use dom_info class.
(verify_dominators): Likewise.
--
Regards,
Mikhail Maltsev
[-- Attachment #2: refactor_dom_fixed.patch --]
[-- Type: text/x-patch, Size: 27785 bytes --]
diff --git a/gcc/dominance.c b/gcc/dominance.c
index d8d87ca..e9b24ef 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -53,139 +53,173 @@
/* Type of Basic Block aka. TBB */
typedef unsigned int TBB;
-/* We work in a poor-mans object oriented fashion, and carry an instance of
- this structure through all our 'methods'. It holds various arrays
- reflecting the (sub)structure of the flowgraph. Most of them are of type
- TBB and are also indexed by TBB. */
+namespace {
-struct dom_info
+/* This class holds various arrays reflecting the (sub)structure of the
+ flowgraph. Most of them are of type TBB and are also indexed by TBB. */
+
+class dom_info
{
+public:
+ dom_info (function *, cdi_direction);
+ ~dom_info ();
+ void calc_dfs_tree ();
+ void calc_idoms ();
+
+ inline basic_block get_idom (basic_block);
+private:
+ void calc_dfs_tree_nonrec (basic_block);
+ void compress (TBB);
+ TBB eval (TBB);
+ void link_roots (TBB, TBB);
+
/* The parent of a node in the DFS tree. */
- TBB *dfs_parent;
- /* For a node x key[x] is roughly the node nearest to the root from which
+ TBB *m_dfs_parent;
+ /* For a node x m_key[x] is roughly the node nearest to the root from which
exists a way to x only over nodes behind x. Such a node is also called
semidominator. */
- TBB *key;
- /* The value in path_min[x] is the node y on the path from x to the root of
- the tree x is in with the smallest key[y]. */
- TBB *path_min;
- /* bucket[x] points to the first node of the set of nodes having x as key. */
- TBB *bucket;
- /* And next_bucket[x] points to the next node. */
- TBB *next_bucket;
- /* After the algorithm is done, dom[x] contains the immediate dominator
+ TBB *m_key;
+ /* The value in m_path_min[x] is the node y on the path from x to the root of
+ the tree x is in with the smallest m_key[y]. */
+ TBB *m_path_min;
+ /* m_bucket[x] points to the first node of the set of nodes having x as
+ key. */
+ TBB *m_bucket;
+ /* And m_next_bucket[x] points to the next node. */
+ TBB *m_next_bucket;
+ /* After the algorithm is done, m_dom[x] contains the immediate dominator
of x. */
- TBB *dom;
+ TBB *m_dom;
/* The following few fields implement the structures needed for disjoint
sets. */
- /* set_chain[x] is the next node on the path from x to the representative
- of the set containing x. If set_chain[x]==0 then x is a root. */
- TBB *set_chain;
- /* set_size[x] is the number of elements in the set named by x. */
- unsigned int *set_size;
- /* set_child[x] is used for balancing the tree representing a set. It can
+ /* m_set_chain[x] is the next node on the path from x to the representative
+ of the set containing x. If m_set_chain[x]==0 then x is a root. */
+ TBB *m_set_chain;
+ /* m_set_size[x] is the number of elements in the set named by x. */
+ unsigned int *m_set_size;
+ /* m_set_child[x] is used for balancing the tree representing a set. It can
be understood as the next sibling of x. */
- TBB *set_child;
+ TBB *m_set_child;
- /* If b is the number of a basic block (BB->index), dfs_order[b] is the
+ /* If b is the number of a basic block (BB->index), m_dfs_order[b] is the
number of that node in DFS order counted from 1. This is an index
into most of the other arrays in this structure. */
- TBB *dfs_order;
+ TBB *m_dfs_order;
+ /* Points to last element in m_dfs_order array. */
+ TBB *m_dfs_last;
/* If x is the DFS-index of a node which corresponds with a basic block,
- dfs_to_bb[x] is that basic block. Note, that in our structure there are
- more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
- is true for every basic block bb, but not the opposite. */
- basic_block *dfs_to_bb;
+ m_dfs_to_bb[x] is that basic block. Note, that in our structure there are
+ more nodes that basic blocks, so only
+ m_dfs_to_bb[m_dfs_order[bb->index]]==bb is true for every basic block bb,
+ but not the opposite. */
+ basic_block *m_dfs_to_bb;
/* This is the next free DFS number when creating the DFS tree. */
- unsigned int dfsnum;
- /* The number of nodes in the DFS tree (==dfsnum-1). */
- unsigned int nodes;
+ unsigned int m_dfsnum;
+ /* The number of nodes in the DFS tree (==m_dfsnum-1). */
+ unsigned int m_nodes;
/* Blocks with bits set here have a fake edge to EXIT. These are used
to turn a DFS forest into a proper tree. */
- bitmap fake_exit_edge;
+ bitmap m_fake_exit_edge;
+
+ /* Number of basic blocks in the function being compiled. */
+ size_t m_n_basic_blocks;
+
+ /* True, if we are computing postdominators (rather than dominators). */
+ bool m_reverse;
+
+ /* Start block (the entry block for forward problem, exit block for backward
+ problem). */
+ basic_block m_start_block;
+ /* Ending block. */
+ basic_block m_end_block;
};
-static void init_dom_info (struct dom_info *, enum cdi_direction);
-static void free_dom_info (struct dom_info *);
-static void calc_dfs_tree_nonrec (struct dom_info *, basic_block, bool);
-static void calc_dfs_tree (struct dom_info *, bool);
-static void compress (struct dom_info *, TBB);
-static TBB eval (struct dom_info *, TBB);
-static void link_roots (struct dom_info *, TBB, TBB);
-static void calc_idoms (struct dom_info *, bool);
-void debug_dominance_info (enum cdi_direction);
-void debug_dominance_tree (enum cdi_direction, basic_block);
-
-/* Helper macro for allocating and initializing an array,
- for aesthetic reasons. */
-#define init_ar(var, type, num, content) \
- do \
- { \
- unsigned int i = 1; /* Catch content == i. */ \
- if (! (content)) \
- (var) = XCNEWVEC (type, num); \
- else \
- { \
- (var) = XNEWVEC (type, (num)); \
- for (i = 0; i < num; i++) \
- (var)[i] = (content); \
- } \
- } \
- while (0)
-
-/* Allocate all needed memory in a pessimistic fashion (so we round up).
- This initializes the contents of DI, which already must be allocated. */
+} // anonymous namespace
-static void
-init_dom_info (struct dom_info *di, enum cdi_direction dir)
+void debug_dominance_info (cdi_direction);
+void debug_dominance_tree (cdi_direction, basic_block);
+
+/* Allocate and zero-initialize NUM elements of type T (T must be a
+ POD-type). Note: after transition to C++11 or later,
+ `x = new_zero_array <T> (num);' can be replaced with
+ `x = new T[num] {};'. */
+
+template<typename T>
+inline T *new_zero_array (size_t num)
+{
+ T *result = new T[num];
+ memset (result, 0, sizeof (T) * num);
+ return result;
+}
+
+/* Allocate all needed memory in a pessimistic fashion (so we round up). */
+
+dom_info::dom_info (function *fn, cdi_direction dir)
{
/* We need memory for n_basic_blocks nodes. */
- unsigned int num = n_basic_blocks_for_fn (cfun);
- init_ar (di->dfs_parent, TBB, num, 0);
- init_ar (di->path_min, TBB, num, i);
- init_ar (di->key, TBB, num, i);
- init_ar (di->dom, TBB, num, 0);
+ size_t num = m_n_basic_blocks = n_basic_blocks_for_fn (fn);
+ m_dfs_parent = new_zero_array <TBB> (num);
+ m_dom = new_zero_array <TBB> (num);
+
+ m_path_min = new TBB[num];
+ m_key = new TBB[num];
+ m_set_size = new unsigned int[num];
+ for (size_t i = 0; i < num; i++)
+ {
+ m_path_min[i] = m_key[i] = i;
+ m_set_size[i] = 1;
+ }
- init_ar (di->bucket, TBB, num, 0);
- init_ar (di->next_bucket, TBB, num, 0);
+ m_bucket = new_zero_array <TBB> (num);
+ m_next_bucket = new_zero_array <TBB> (num);
- init_ar (di->set_chain, TBB, num, 0);
- init_ar (di->set_size, unsigned int, num, 1);
- init_ar (di->set_child, TBB, num, 0);
+ m_set_chain = new_zero_array <TBB> (num);
+ m_set_child = new_zero_array <TBB> (num);
- init_ar (di->dfs_order, TBB,
- (unsigned int) last_basic_block_for_fn (cfun) + 1, 0);
- init_ar (di->dfs_to_bb, basic_block, num, 0);
+ unsigned last_bb_index = last_basic_block_for_fn (fn);
+ m_dfs_order = new_zero_array <TBB> (last_bb_index + 1);
+ m_dfs_last = &m_dfs_order[last_bb_index];
+ m_dfs_to_bb = new_zero_array <basic_block> (num);
- di->dfsnum = 1;
- di->nodes = 0;
+ m_dfsnum = 1;
+ m_nodes = 0;
switch (dir)
{
case CDI_DOMINATORS:
- di->fake_exit_edge = NULL;
+ m_reverse = false;
+ m_fake_exit_edge = NULL;
+ m_start_block = ENTRY_BLOCK_PTR_FOR_FN (fn);
+ m_end_block = EXIT_BLOCK_PTR_FOR_FN (fn);
break;
case CDI_POST_DOMINATORS:
- di->fake_exit_edge = BITMAP_ALLOC (NULL);
+ m_reverse = true;
+ m_fake_exit_edge = BITMAP_ALLOC (NULL);
+ m_start_block = EXIT_BLOCK_PTR_FOR_FN (fn);
+ m_end_block = ENTRY_BLOCK_PTR_FOR_FN (fn);
break;
default:
gcc_unreachable ();
- break;
}
}
-#undef init_ar
+inline basic_block
+dom_info::get_idom (basic_block bb)
+{
+ TBB d = m_dom[m_dfs_order[bb->index]];
+ return m_dfs_to_bb[d];
+}
/* Map dominance calculation type to array index used for various
dominance information arrays. This version is simple -- it will need
to be modified, obviously, if additional values are added to
cdi_direction. */
-static unsigned int
-dom_convert_dir_to_idx (enum cdi_direction dir)
+static inline unsigned int
+dom_convert_dir_to_idx (cdi_direction dir)
{
gcc_checking_assert (dir == CDI_DOMINATORS || dir == CDI_POST_DOMINATORS);
return dir - 1;
@@ -193,82 +227,60 @@ dom_convert_dir_to_idx (enum cdi_direction dir)
/* Free all allocated memory in DI, but not DI itself. */
-static void
-free_dom_info (struct dom_info *di)
+dom_info::~dom_info ()
{
- free (di->dfs_parent);
- free (di->path_min);
- free (di->key);
- free (di->dom);
- free (di->bucket);
- free (di->next_bucket);
- free (di->set_chain);
- free (di->set_size);
- free (di->set_child);
- free (di->dfs_order);
- free (di->dfs_to_bb);
- BITMAP_FREE (di->fake_exit_edge);
+ delete[] m_dfs_parent;
+ delete[] m_path_min;
+ delete[] m_key;
+ delete[] m_dom;
+ delete[] m_bucket;
+ delete[] m_next_bucket;
+ delete[] m_set_chain;
+ delete[] m_set_size;
+ delete[] m_set_child;
+ delete[] m_dfs_order;
+ delete[] m_dfs_to_bb;
+ BITMAP_FREE (m_fake_exit_edge);
}
-/* The nonrecursive variant of creating a DFS tree. DI is our working
- structure, BB the starting basic block for this tree and REVERSE
- is true, if predecessors should be visited instead of successors of a
- node. After this is done all nodes reachable from BB were visited, have
- assigned their dfs number and are linked together to form a tree. */
+/* The nonrecursive variant of creating a DFS tree. BB is the starting basic
+ block for this tree and m_reverse is true, if predecessors should be visited
+ instead of successors of a node. After this is done all nodes reachable
+ from BB were visited, have assigned their dfs number and are linked together
+ to form a tree. */
-static void
-calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
+void
+dom_info::calc_dfs_tree_nonrec (basic_block bb)
{
- /* We call this _only_ if bb is not already visited. */
- edge e;
- TBB child_i, my_i = 0;
- edge_iterator *stack;
- edge_iterator ei, einext;
- int sp;
- /* Start block (the entry block for forward problem, exit block for backward
- problem). */
- basic_block en_block;
- /* Ending block. */
- basic_block ex_block;
-
- stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
- sp = 0;
+ edge_iterator *stack = new edge_iterator[m_n_basic_blocks + 1];
+ int sp = 0;
- /* Initialize our border blocks, and the first edge. */
- if (reverse)
- {
- ei = ei_start (bb->preds);
- en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
- ex_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
- }
- else
- {
- ei = ei_start (bb->succs);
- en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
- ex_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
- }
+ /* Initialize the first edge. */
+ edge_iterator ei = m_reverse ? ei_start (bb->preds)
+ : ei_start (bb->succs);
/* When the stack is empty we break out of this loop. */
while (1)
{
basic_block bn;
+ edge_iterator einext;
/* This loop traverses edges e in depth first manner, and fills the
stack. */
while (!ei_end_p (ei))
{
- e = ei_edge (ei);
+ edge e = ei_edge (ei);
/* Deduce from E the current and the next block (BB and BN), and the
next edge. */
- if (reverse)
+ if (m_reverse)
{
bn = e->src;
/* If the next node BN is either already visited or a border
block the current edge is useless, and simply overwritten
with the next edge out of the current node. */
- if (bn == ex_block || di->dfs_order[bn->index])
+ if (bn == m_end_block || m_dfs_order[bn->index])
{
ei_next (&ei);
continue;
@@ -279,7 +291,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
else
{
bn = e->dest;
- if (bn == ex_block || di->dfs_order[bn->index])
+ if (bn == m_end_block || m_dfs_order[bn->index])
{
ei_next (&ei);
continue;
@@ -288,16 +300,17 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
einext = ei_start (bn->succs);
}
- gcc_assert (bn != en_block);
+ gcc_assert (bn != m_start_block);
/* Fill the DFS tree info calculatable _before_ recursing. */
- if (bb != en_block)
- my_i = di->dfs_order[bb->index];
+ TBB my_i;
+ if (bb != m_start_block)
+ my_i = m_dfs_order[bb->index];
else
- my_i = di->dfs_order[last_basic_block_for_fn (cfun)];
- child_i = di->dfs_order[bn->index] = di->dfsnum++;
- di->dfs_to_bb[child_i] = bn;
- di->dfs_parent[child_i] = my_i;
+ my_i = *m_dfs_last;
+ TBB child_i = m_dfs_order[bn->index] = m_dfsnum++;
+ m_dfs_to_bb[child_i] = bn;
+ m_dfs_parent[child_i] = my_i;
/* Save the current point in the CFG on the stack, and recurse. */
stack[sp++] = ei;
@@ -319,27 +332,24 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
descendants or the tree depth. */
ei_next (&ei);
}
- free (stack);
+ delete[] stack;
}
-/* The main entry for calculating the DFS tree or forest. DI is our working
- structure and REVERSE is true, if we are interested in the reverse flow
- graph. In that case the result is not necessarily a tree but a forest,
- because there may be nodes from which the EXIT_BLOCK is unreachable. */
+/* The main entry for calculating the DFS tree or forest. m_reverse is true,
+ if we are interested in the reverse flow graph. In that case the result is
+ not necessarily a tree but a forest, because there may be nodes from which
+ the EXIT_BLOCK is unreachable. */
-static void
-calc_dfs_tree (struct dom_info *di, bool reverse)
+void
+dom_info::calc_dfs_tree ()
{
- /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
- basic_block begin = (reverse
- ? EXIT_BLOCK_PTR_FOR_FN (cfun) : ENTRY_BLOCK_PTR_FOR_FN (cfun));
- di->dfs_order[last_basic_block_for_fn (cfun)] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = begin;
- di->dfsnum++;
+ *m_dfs_last = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = m_start_block;
+ m_dfsnum++;
- calc_dfs_tree_nonrec (di, begin, reverse);
+ calc_dfs_tree_nonrec (m_start_block);
- if (reverse)
+ if (m_reverse)
{
/* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
They are reverse-unreachable. In the dom-case we disallow such
@@ -354,48 +364,45 @@ calc_dfs_tree (struct dom_info *di, bool reverse)
basic_block b;
bool saw_unconnected = false;
- FOR_EACH_BB_REVERSE_FN (b, cfun)
+ FOR_BB_BETWEEN (b, m_start_block->prev_bb, m_end_block, prev_bb)
{
if (EDGE_COUNT (b->succs) > 0)
{
- if (di->dfs_order[b->index] == 0)
+ if (m_dfs_order[b->index] == 0)
saw_unconnected = true;
continue;
}
- bitmap_set_bit (di->fake_exit_edge, b->index);
- di->dfs_order[b->index] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = b;
- di->dfs_parent[di->dfsnum] =
- di->dfs_order[last_basic_block_for_fn (cfun)];
- di->dfsnum++;
- calc_dfs_tree_nonrec (di, b, reverse);
+ bitmap_set_bit (m_fake_exit_edge, b->index);
+ m_dfs_order[b->index] = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = b;
+ m_dfs_parent[m_dfsnum] = *m_dfs_last;
+ m_dfsnum++;
+ calc_dfs_tree_nonrec (b);
}
if (saw_unconnected)
{
- FOR_EACH_BB_REVERSE_FN (b, cfun)
+ FOR_BB_BETWEEN (b, m_start_block->prev_bb, m_end_block, prev_bb)
{
- basic_block b2;
- if (di->dfs_order[b->index])
+ if (m_dfs_order[b->index])
continue;
- b2 = dfs_find_deadend (b);
- gcc_checking_assert (di->dfs_order[b2->index] == 0);
- bitmap_set_bit (di->fake_exit_edge, b2->index);
- di->dfs_order[b2->index] = di->dfsnum;
- di->dfs_to_bb[di->dfsnum] = b2;
- di->dfs_parent[di->dfsnum] =
- di->dfs_order[last_basic_block_for_fn (cfun)];
- di->dfsnum++;
- calc_dfs_tree_nonrec (di, b2, reverse);
- gcc_checking_assert (di->dfs_order[b->index]);
+ basic_block b2 = dfs_find_deadend (b);
+ gcc_checking_assert (m_dfs_order[b2->index] == 0);
+ bitmap_set_bit (m_fake_exit_edge, b2->index);
+ m_dfs_order[b2->index] = m_dfsnum;
+ m_dfs_to_bb[m_dfsnum] = b2;
+ m_dfs_parent[m_dfsnum] = *m_dfs_last;
+ m_dfsnum++;
+ calc_dfs_tree_nonrec (b2);
+ gcc_checking_assert (m_dfs_order[b->index]);
}
}
}
- di->nodes = di->dfsnum - 1;
+ m_nodes = m_dfsnum - 1;
/* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
- gcc_assert (di->nodes == (unsigned int) n_basic_blocks_for_fn (cfun) - 1);
+ gcc_assert (m_nodes == (unsigned int) m_n_basic_blocks - 1);
}
/* Compress the path from V to the root of its set and update path_min at the
@@ -403,19 +410,19 @@ calc_dfs_tree (struct dom_info *di, bool reverse)
in and path_min[V] is the node with the smallest key[] value on the path
from V to that root. */
-static void
-compress (struct dom_info *di, TBB v)
+void
+dom_info::compress (TBB v)
{
/* Btw. It's not worth to unrecurse compress() as the depth is usually not
greater than 5 even for huge graphs (I've not seen call depth > 4).
Also performance wise compress() ranges _far_ behind eval(). */
- TBB parent = di->set_chain[v];
- if (di->set_chain[parent])
+ TBB parent = m_set_chain[v];
+ if (m_set_chain[parent])
{
- compress (di, parent);
- if (di->key[di->path_min[parent]] < di->key[di->path_min[v]])
- di->path_min[v] = di->path_min[parent];
- di->set_chain[v] = di->set_chain[parent];
+ compress (parent);
+ if (m_key[m_path_min[parent]] < m_key[m_path_min[v]])
+ m_path_min[v] = m_path_min[parent];
+ m_set_chain[v] = m_set_chain[parent];
}
}
@@ -423,28 +430,28 @@ compress (struct dom_info *di, TBB v)
changed since the last call). Returns the node with the smallest key[]
value on the path from V to the root. */
-static inline TBB
-eval (struct dom_info *di, TBB v)
+inline TBB
+dom_info::eval (TBB v)
{
/* The representative of the set V is in, also called root (as the set
representation is a tree). */
- TBB rep = di->set_chain[v];
+ TBB rep = m_set_chain[v];
/* V itself is the root. */
if (!rep)
- return di->path_min[v];
+ return m_path_min[v];
/* Compress only if necessary. */
- if (di->set_chain[rep])
+ if (m_set_chain[rep])
{
- compress (di, v);
- rep = di->set_chain[v];
+ compress (v);
+ rep = m_set_chain[v];
}
- if (di->key[di->path_min[rep]] >= di->key[di->path_min[v]])
- return di->path_min[v];
+ if (m_key[m_path_min[rep]] >= m_key[m_path_min[v]])
+ return m_path_min[v];
else
- return di->path_min[rep];
+ return m_path_min[rep];
}
/* This essentially merges the two sets of V and W, giving a single set with
@@ -452,72 +459,64 @@ eval (struct dom_info *di, TBB v)
balanced tree. Currently link(V,W) is only used with V being the parent
of W. */
-static void
-link_roots (struct dom_info *di, TBB v, TBB w)
+void
+dom_info::link_roots (TBB v, TBB w)
{
TBB s = w;
/* Rebalance the tree. */
- while (di->key[di->path_min[w]] < di->key[di->path_min[di->set_child[s]]])
+ while (m_key[m_path_min[w]] < m_key[m_path_min[m_set_child[s]]])
{
- if (di->set_size[s] + di->set_size[di->set_child[di->set_child[s]]]
- >= 2 * di->set_size[di->set_child[s]])
+ if (m_set_size[s] + m_set_size[m_set_child[m_set_child[s]]]
+ >= 2 * m_set_size[m_set_child[s]])
{
- di->set_chain[di->set_child[s]] = s;
- di->set_child[s] = di->set_child[di->set_child[s]];
+ m_set_chain[m_set_child[s]] = s;
+ m_set_child[s] = m_set_child[m_set_child[s]];
}
else
{
- di->set_size[di->set_child[s]] = di->set_size[s];
- s = di->set_chain[s] = di->set_child[s];
+ m_set_size[m_set_child[s]] = m_set_size[s];
+ s = m_set_chain[s] = m_set_child[s];
}
}
- di->path_min[s] = di->path_min[w];
- di->set_size[v] += di->set_size[w];
- if (di->set_size[v] < 2 * di->set_size[w])
- std::swap (di->set_child[v], s);
+ m_path_min[s] = m_path_min[w];
+ m_set_size[v] += m_set_size[w];
+ if (m_set_size[v] < 2 * m_set_size[w])
+ std::swap (m_set_child[v], s);
/* Merge all subtrees. */
while (s)
{
- di->set_chain[s] = v;
- s = di->set_child[s];
+ m_set_chain[s] = v;
+ s = m_set_child[s];
}
}
-/* This calculates the immediate dominators (or post-dominators if REVERSE is
- true). DI is our working structure and should hold the DFS forest.
- On return the immediate dominator to node V is in di->dom[V]. */
+/* This calculates the immediate dominators (or post-dominators). THIS is our
+ working structure and should hold the DFS forest.
+ On return the immediate dominator to node V is in m_dom[V]. */
-static void
-calc_idoms (struct dom_info *di, bool reverse)
+void
+dom_info::calc_idoms ()
{
- TBB v, w, k, par;
- basic_block en_block;
- edge_iterator ei, einext;
-
- if (reverse)
- en_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
- else
- en_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
-
/* Go backwards in DFS order, to first look at the leafs. */
- v = di->nodes;
- while (v > 1)
+ for (TBB v = m_nodes; v > 1; v--)
{
- basic_block bb = di->dfs_to_bb[v];
+ basic_block bb = m_dfs_to_bb[v];
edge e;
- par = di->dfs_parent[v];
- k = v;
+ TBB par = m_dfs_parent[v];
+ TBB k = v;
- ei = (reverse) ? ei_start (bb->succs) : ei_start (bb->preds);
+ edge_iterator ei = m_reverse ? ei_start (bb->succs)
+ : ei_start (bb->preds);
+ edge_iterator einext;
- if (reverse)
+ if (m_reverse)
{
/* If this block has a fake edge to exit, process that first. */
- if (bitmap_bit_p (di->fake_exit_edge, bb->index))
+ if (bitmap_bit_p (m_fake_exit_edge, bb->index))
{
einext = ei;
einext.index = 0;
@@ -531,56 +530,55 @@ calc_idoms (struct dom_info *di, bool reverse)
semidominator. */
while (!ei_end_p (ei))
{
- TBB k1;
basic_block b;
+ TBB k1;
e = ei_edge (ei);
- b = (reverse) ? e->dest : e->src;
+ b = m_reverse ? e->dest : e->src;
einext = ei;
ei_next (&einext);
- if (b == en_block)
+ if (b == m_start_block)
{
do_fake_exit_edge:
- k1 = di->dfs_order[last_basic_block_for_fn (cfun)];
+ k1 = *m_dfs_last;
}
else
- k1 = di->dfs_order[b->index];
+ k1 = m_dfs_order[b->index];
/* Call eval() only if really needed. If k1 is above V in DFS tree,
then we know, that eval(k1) == k1 and key[k1] == k1. */
if (k1 > v)
- k1 = di->key[eval (di, k1)];
+ k1 = m_key[eval (k1)];
if (k1 < k)
k = k1;
ei = einext;
}
- di->key[v] = k;
- link_roots (di, par, v);
- di->next_bucket[v] = di->bucket[k];
- di->bucket[k] = v;
+ m_key[v] = k;
+ link_roots (par, v);
+ m_next_bucket[v] = m_bucket[k];
+ m_bucket[k] = v;
/* Transform semidominators into dominators. */
- for (w = di->bucket[par]; w; w = di->next_bucket[w])
+ for (TBB w = m_bucket[par]; w; w = m_next_bucket[w])
{
- k = eval (di, w);
- if (di->key[k] < di->key[w])
- di->dom[w] = k;
+ k = eval (w);
+ if (m_key[k] < m_key[w])
+ m_dom[w] = k;
else
- di->dom[w] = par;
+ m_dom[w] = par;
}
/* We don't need to cleanup next_bucket[]. */
- di->bucket[par] = 0;
- v--;
+ m_bucket[par] = 0;
}
/* Explicitly define the dominators. */
- di->dom[1] = 0;
- for (v = 2; v <= di->nodes; v++)
- if (di->dom[v] != di->key[v])
- di->dom[v] = di->dom[di->dom[v]];
+ m_dom[1] = 0;
+ for (TBB v = 2; v <= m_nodes; v++)
+ if (m_dom[v] != m_key[v])
+ m_dom[v] = m_dom[m_dom[v]];
}
/* Assign dfs numbers starting from NUM to NODE and its sons. */
@@ -630,12 +628,9 @@ compute_dom_fast_query (enum cdi_direction dir)
we want to compute dominators or postdominators. */
void
-calculate_dominance_info (enum cdi_direction dir)
+calculate_dominance_info (cdi_direction dir)
{
- struct dom_info di;
- basic_block b;
unsigned int dir_index = dom_convert_dir_to_idx (dir);
- bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
if (dom_computed[dir_index] == DOM_OK)
{
@@ -650,25 +645,23 @@ calculate_dominance_info (enum cdi_direction dir)
{
gcc_assert (!n_bbs_in_dom_tree[dir_index]);
+ basic_block b;
FOR_ALL_BB_FN (b, cfun)
{
b->dom[dir_index] = et_new_tree (b);
}
n_bbs_in_dom_tree[dir_index] = n_basic_blocks_for_fn (cfun);
- init_dom_info (&di, dir);
- calc_dfs_tree (&di, reverse);
- calc_idoms (&di, reverse);
+ dom_info di (cfun, dir);
+ di.calc_dfs_tree ();
+ di.calc_idoms ();
FOR_EACH_BB_FN (b, cfun)
{
- TBB d = di.dom[di.dfs_order[b->index]];
-
- if (di.dfs_to_bb[d])
- et_set_father (b->dom[dir_index], di.dfs_to_bb[d]->dom[dir_index]);
+ if (basic_block d = di.get_idom (b))
+ et_set_father (b->dom[dir_index], d->dom[dir_index]);
}
- free_dom_info (&di);
dom_computed[dir_index] = DOM_NO_FAST_QUERY;
}
else
@@ -1022,38 +1015,34 @@ bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
/* Verify invariants of dominator structure. */
DEBUG_FUNCTION void
-verify_dominators (enum cdi_direction dir)
+verify_dominators (cdi_direction dir)
{
- int err = 0;
- basic_block bb, imm_bb, imm_bb_correct;
- struct dom_info di;
- bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
-
gcc_assert (dom_info_available_p (dir));
- init_dom_info (&di, dir);
- calc_dfs_tree (&di, reverse);
- calc_idoms (&di, reverse);
+ dom_info di (cfun, dir);
+ di.calc_dfs_tree ();
+ di.calc_idoms ();
+ bool err = false;
+ basic_block bb;
FOR_EACH_BB_FN (bb, cfun)
{
- imm_bb = get_immediate_dominator (dir, bb);
+ basic_block imm_bb = get_immediate_dominator (dir, bb);
if (!imm_bb)
{
error ("dominator of %d status unknown", bb->index);
- err = 1;
+ err = true;
}
- imm_bb_correct = di.dfs_to_bb[di.dom[di.dfs_order[bb->index]]];
+ basic_block imm_bb_correct = di.get_idom (bb);
if (imm_bb != imm_bb_correct)
{
error ("dominator of %d should be %d, not %d",
bb->index, imm_bb_correct->index, imm_bb->index);
- err = 1;
+ err = true;
}
}
- free_dom_info (&di);
gcc_assert (!err);
}
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-14 8:17 ` Richard Biener
2015-08-14 18:28 ` Jeff Law
@ 2015-08-15 6:13 ` Mikhail Maltsev
2015-08-18 10:13 ` Richard Biener
1 sibling, 1 reply; 14+ messages in thread
From: Mikhail Maltsev @ 2015-08-15 6:13 UTC (permalink / raw)
To: Richard Biener; +Cc: gcc-patches, Jeff Law, David Malcolm
[-- Attachment #1: Type: text/plain, Size: 3544 bytes --]
On 08/14/2015 11:02 AM, Richard Biener wrote:
> So the last time I did similar refactoring I wondered if we can somehow avoid
> the "noise" in non-IPA passes. Ideas I came up with are
>
> a) Inherit gimple/rtl pass classes from a class which is initialized with the
> function the pass operates on and provides methods like
>
> bool dom_info_available_p (..) { return dom_info_available_p (fn, ...); }
>
> thus wraps APIs working on a specific function.
>
> b) Do sth similar but make it work with overloads and clever (no idea what!)
> C++ that disables them if this_fn cannot be looked up
>
> template <disable-me-if-this_fn-cannot_be_lookedup-at-instantiation-place>
> bool dom_info_available_p (..., struct function *fn = this_fn);
>
I attached some sketch of what this "clever C++" could look like. It still
requires some changes in classes which would use this new base class, but they
are not very significant compared to converting pass functions into members of
these classes.
> all of the above would of course require that passes make all their
> implementation
> be methods of their pass class. So even more refactoring.
The good thing is that this can be done incrementally, i.e. changing one pass at
a time.
> Refactoring APIs that are used from IPA and make push/pop_cfun necessary
> for them are another thing. (there are still plenty left I think)
What I could find is:
1. ipa_analyze_node
2. some transactional memory-related stuff: ipa_tm_scan_irr_function,
ipa_tm_transform_transaction, ipa_tm_transform_clone, ipa_tm_execute.
3. tree_profiling
Presumably there are no more calculate_dominance_info/free_dominance_info call
sites with push_cfun/pop_cfun nearby (except for passes.c, but they are not
related to IPA). So now I need to figure out, what other global state (which is
set up by push_cfun) can these functions use? Could you give some advice about
that, in sense, what should I look for (e.g., push_cfun calls some target hooks,
but I did not try to look in detail, what kind of actions are performed by it)?
As for the API. I propose to, at least, remove uses of cfun from dominance.c
itself, but provide helper functions which will allow to leave the callers
unchanged, but make it possible to use all dominance-related API on functions
other than cfun.
Does such change sound reasonable to you?
On 08/14/2015 11:11 PM, David Malcolm wrote:
> The JIT guards all access to GCC's state in a big mutex ("jit_mutex", in
> gcc/jit/jit-playback.c).
Yeah, I know, I looked through JIT documentation briefly.
>
> For example, this includes everything to do with GC and GTY, since
> there's implicitly a single set of GC roots and the GC code isn't thread
> safe.
And GGC is a "stop-the-world" collector, which is just not designed for
multithreaded environment. (sigh)
As for the patch, I think reviewing this variant does not make much sense,
because of Richard suggestion on how to avoid changing the callers. But still
thanks for looking.
>
> I've been tackling things on an as-needed basis - for example, the
> recent timevar global-state removal was motivated by wanting to expose a
> profiling API to jit client code.
>
By the way, speaking of timevars. I wrote about my concerns w.r.t. them, but did
not get any feedback:
https://gcc.gnu.org/ml/gcc/2015-07/msg00165.html
Briefly speaking, I noticed that our timers introduce rather significant
measurement errors and proposed some ideas about reducing them. What do you think?
--
Regards,
Mikhail Maltsev
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: dom_demo.cc --]
[-- Type: text/x-c++src; name="dom_demo.cc", Size: 4079 bytes --]
#include <stdio.h>
//===- various headers - Existing GCC code --------------------------------===//
//
// No changes required
//===----------------------------------------------------------------------===//
enum cdi_direction {
CDI_DOMINATORS,
CDI_POSTDOMINATORS
};
struct basic_block_def { };
typedef basic_block_def *basic_block;
struct function
{
};
function *cfun;
class gimple_opt_pass
{
public:
virtual unsigned int execute(function *) = 0;
};
//===- dominance.h - Refactored version -----------------------------------===//
//
// Allow passing function as an additional parameter (with default value), so
// that dominaince.c does not directly use cfun any more.
//===----------------------------------------------------------------------===//
// We will need cfun to be in scope. Alternatively, we can put a 3-argument
// overload of domainted_by_p in another header, where cfun is available.
extern function *cfun;
bool
dominated_by_p(cdi_direction, basic_block, basic_block, function *fun = cfun)
{
(void)fun;
printf("\t4-argument overload\n");
return false;
}
//===- old_pass.c - This pass uses cfun -----------------------------------===//
//
// We don't need to change anything here
//===----------------------------------------------------------------------===//
class old_pass : public gimple_opt_pass
{
public:
virtual unsigned int execute(function *);
};
void old_pass_do_stuff()
{
basic_block bb1 = 0, bb2 = 0;
// ...
if (dominated_by_p(CDI_DOMINATORS, bb1, bb2)) {
// ...
}
}
unsigned int
old_pass::execute(function *fun)
{
printf("running old_pass::execute\n");
cfun = fun;
old_pass_do_stuff();
printf("finished old_pass::execute\n");
return 0;
}
//===- dom_info_mixin.h - Header file for the new API ---------------------===//
//
// dom_info_mixin template provides helper methods for manipulating
// dominance information of the function currently being compiled
//===----------------------------------------------------------------------===//
template<typename Pass>
class dom_info_mixin
{
protected:
bool dominated_by_p(cdi_direction dir, basic_block bb1, basic_block bb2) const
{
printf("\tdom_info_mixin: using m_this_fn ... -> ");
return ::dominated_by_p(dir, bb1, bb2, static_cast<const Pass *>(this)->m_this_fn);
}
};
// protection against unintended use of cfun (see new_pass_do_other_stuff)
bool dominated_by_p(cdi_direction dir, basic_block bb1, basic_block bb2);
//===- new_pass.cc - Example pass which uses the new API ------------------===//
//
// new_pass stores a pointer to current function in m_this_fn (so we get rid
// of the global shared state - at least some part of it) and uses small
// accessor methods, so we don't have to write "m_this_fn" every time.
//===----------------------------------------------------------------------===//
class new_pass : public gimple_opt_pass,
public dom_info_mixin<new_pass>
{
public:
friend class dom_info_mixin<new_pass>; // or just make m_this_fn public
virtual unsigned int execute(function *);
private:
void do_stuff();
function *m_this_fn;
};
static void new_pass_do_other_stuff();
unsigned int
new_pass::execute(function *fun)
{
printf("running new_pass::execute\n");
m_this_fn = fun;
do_stuff();
new_pass_do_other_stuff();
printf("finished new_pass::execute\n");
return 0;
}
void
new_pass::do_stuff()
{
basic_block bb1 = 0, bb2 = 0;
// ...
if (dominated_by_p(CDI_DOMINATORS, bb1, bb2)) {
// ...
}
}
static void
new_pass_do_other_stuff()
{
#if 0
basic_block bb1 = 0, bb2 = 0;
// ...
// error: call of overloaded ‘dominated_by_p(cdi_direction, basic_block_def*&, basic_block_def*&)’ is ambiguous
if (dominated_by_p(CDI_DOMINATORS, bb1, bb2)) {
// ...
}
#endif
}
int main()
{
function fun;
old_pass old_pass_instance;
old_pass_instance.execute(&fun);
new_pass new_pass_instance;
new_pass_instance.execute(&fun);
return 0;
}
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-14 18:25 ` Jeff Law
@ 2015-08-15 7:59 ` Richard Biener
0 siblings, 0 replies; 14+ messages in thread
From: Richard Biener @ 2015-08-15 7:59 UTC (permalink / raw)
To: Jeff Law, Mikhail Maltsev, gcc-patches
On August 14, 2015 8:20:18 PM GMT+02:00, Jeff Law <law@redhat.com> wrote:
>On 08/13/2015 06:55 PM, Mikhail Maltsev wrote:
>> Hi all.
>>
>> These two patches are refactoring of dominator-related code.
>>
>> The comment in dominance.c says: "We work in a poor-mans object
>oriented
>> fashion, and carry an instance of this structure through all our
>'methods'". So,
>> the first patch converts the mentioned structure (dom_info) into a
>class with
>> proper encapsulation. It also adds a new member - m_fn (the function
>currently
>> being compiled) to this structure and replaces some uses of cfun with
>m_fn. It
>> also contains some fixes, related to current coding standards: move
>variable
>> declarations to place of first use, replace elaborated type
>specifiers (i.e.
>> "struct/enum foo") by simple ones (i.e., just "foo") in function
>prototypes.
>>
>> Bootstrapped and regtested on x86_64-linux. Tested build of
>config-list.mk.
>>
>> gcc/ChangeLog:
>>
>> 2015-08-14 Mikhail Maltsev<maltsevm@gmail.com>
>>
>> * (ENABLE_CHECKING): Define as 0 by default.
>> dominance.c (new_zero_array): Define.
>> (dom_info): Define as class instead of struct.
>> (dom_info::dom_info, ~dom_info): Define. Use new/delete for
>memory
>> allocations/deallocations. Pass function as parameter
>(instead of
>> using cfun).
>> (dom_info::get_idom): Define accessor method.
>> (dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress,
>eval,
>> link_roots, calc_idoms): Redefine as class members. Use
>m_fn instead
>> of cfun.
>> (init_dom_info, free_dom_info): Remove (use dom_info
>ctor/dtor).
>> (dom_convert_dir_to_idx): Fix prototype.
>> (assign_dfs_numbers): Move variable declarations to their
>first uses.
>> (calculate_dominance_info): Remove conditional compilation,
>move
>> variables.
>> (free_dominance_info, get_immediate_dominator,
>set_immediate_dominator,
>> get_dominated_b, get_dominated_by_region,
>get_dominated_to_depth,
>> redirect_immediate_dominators,
>nearest_common_dominator_for_set,
>> dominated_by_p, bb_dom_dfs_in, bb_dom_dfs_out,
>verify_dominators,
>> determine_dominators_for_sons, iterate_fix_dominators,
>first_dom_son,
>> next_dom_son, debug_dominance_info, debug_dominance_tree_1):
>Adjust to
>> use class dom_info. Move variable declarations to the place
>of first
>> use. Fix prototypes (remove struct/enum).
>> * dominance.h: Fix prototypes (remove struct/enum).
>>
>> -- Regards, Mikhail Maltsev
>>
>It looks like your patch is primarily concerned with converting all the
>
>internal stuff into a C++ style and not exposing a class to the users
>of
>dominance.h. Correct?
>
>As a whole I don't see anything objectionable here, but I also don't
>see
>that it really takes us forward in a real significant way. I guess
>there's some value in having dominance.c brought up to current
>standards, but my recollection was we weren't going to do through the
>entire source base and do things like move variable declarations to
>their initial use and more generally c++-ify the code base en-masse.
>
>Similarly losing the elaborated type specifiers doesn't really gain us
>anything, except perhaps one less token when people parse the code.
>Again, not objectionable, but also not a big gain.
>
>I could argue that those kind of changes are independent of turning
>dom_info into a real class and if they're going to go forward, they
>would have to stand alone on their merits and go in independently if
>turning dom_info into a class (which AFIACT is the meat of this patch).
>
>
>
>> refactor_dom1.patch
>>
>>
>> diff --git a/gcc/dominance.c b/gcc/dominance.c
>> index d8d87ca..3c4f228 100644
>> --- a/gcc/dominance.c
>> +++ b/gcc/dominance.c
>> @@ -44,6 +44,10 @@
>> #include "timevar.h"
>> #include "graphds.h"
>>
>> +#ifndef ENABLE_CHECKING
>> +# define ENABLE_CHECKING 0
>> +#endif
>Umm, isn't ENABLE_CHECKING defined in auto-host.h (as set up by
>configure?) What's the reason for this change?
>
>Is the issue that auto-host.h won't define checking at all for
>--disable-checking?
>
>I think that the ENABLE_CHECKING conversion from #ifdef testing to
>testing for a value should probably be done separately. It also
>probably has higher value than this refactoring.
>
>
>> +
>> + /* The function being processed. */
>> + function *m_fn;
>So presumably the idea here is to avoid explicitly hitting cfun which
>in
>theory we could recompute the dominance tree for another function. But
>is that really all that useful?
>
>I'm a bit torn here. Richi mentioned the idea of stuffing away a
>pointer to cfun looked backwards to him and he'd pretty stuffing away
>the entry, exit & # blocks and perhaps take us a step towards the
>ability to compute dominance on sub-graphs.
>
>The problem I see with Richi's idea now that I think about it more is
>keeping that information up-to-date. Ie, if we've stuffed away those
>pointers, what happens if (for example) a block gets deleted from the
>graph. What if that block happens to be the exit block we've recorded?
Na, I was thinking of passes that need to update dominance info repeatedly for subgraphs. Those could use this facility and then indeed make sure to drop the whole function one after they are done.
Richard.
>So I guess I'm starting to lean towards saving away the cfun like as
>is
>done in this patch.
>
>
>>> + int *son = new int[n + 1],
>> + *brother = new int[n + 1],
>> + *parent = new int[n + 1];
>ICK. Don't do this. Make each initialization a separate statement.
>There's nothing really to be gained by avoiding the "int" here.
>
>So ultimately the question is whether or not we're gaining much with
>this patch to justify the churn it creates. I think I'll hold off on
>yes/no to the patch to give other folks an opportunity to chime in.
>
>
>Jeff
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 2/2] Get rid of global state accesses in dominance.c
2015-08-15 6:13 ` Mikhail Maltsev
@ 2015-08-18 10:13 ` Richard Biener
0 siblings, 0 replies; 14+ messages in thread
From: Richard Biener @ 2015-08-18 10:13 UTC (permalink / raw)
To: Mikhail Maltsev; +Cc: gcc-patches, Jeff Law, David Malcolm
On Sat, Aug 15, 2015 at 8:05 AM, Mikhail Maltsev <maltsevm@gmail.com> wrote:
> On 08/14/2015 11:02 AM, Richard Biener wrote:
>> So the last time I did similar refactoring I wondered if we can somehow avoid
>> the "noise" in non-IPA passes. Ideas I came up with are
>>
>> a) Inherit gimple/rtl pass classes from a class which is initialized with the
>> function the pass operates on and provides methods like
>>
>> bool dom_info_available_p (..) { return dom_info_available_p (fn, ...); }
>>
>> thus wraps APIs working on a specific function.
>>
>> b) Do sth similar but make it work with overloads and clever (no idea what!)
>> C++ that disables them if this_fn cannot be looked up
>>
>> template <disable-me-if-this_fn-cannot_be_lookedup-at-instantiation-place>
>> bool dom_info_available_p (..., struct function *fn = this_fn);
>>
> I attached some sketch of what this "clever C++" could look like. It still
> requires some changes in classes which would use this new base class, but they
> are not very significant compared to converting pass functions into members of
> these classes.
>
>> all of the above would of course require that passes make all their
>> implementation
>> be methods of their pass class. So even more refactoring.
> The good thing is that this can be done incrementally, i.e. changing one pass at
> a time.
True. I think we want a cfun.h header so that if cfun.h is not
included the overloads
with the default parameter don't work (uh, hopefully they'll still parse...).
Note that one of the unfortunate thing is this default arg stuff only
works on trailing
arguments and thus is inconsistend with other API having a function * argument.
It also makes it hard to apply to APIs that use default args themselves.
Not using default args but forwarder overloads like
dominated_by_p (cdi_direction, basic_block, basic_block)
{
return dominated_by_p (cfun, dir, bb1, bb2);
}
would avoid this. Of course then choosing one or the other becomes a pure
name-lookup issue, but I supose that's ok.
And of course with those available there isn't a good reason (apart from JIT
avoiding globals) to switch a pass over to the new scheme.
>> Refactoring APIs that are used from IPA and make push/pop_cfun necessary
>> for them are another thing. (there are still plenty left I think)
> What I could find is:
> 1. ipa_analyze_node
> 2. some transactional memory-related stuff: ipa_tm_scan_irr_function,
> ipa_tm_transform_transaction, ipa_tm_transform_clone, ipa_tm_execute.
> 3. tree_profiling
>
> Presumably there are no more calculate_dominance_info/free_dominance_info call
> sites with push_cfun/pop_cfun nearby (except for passes.c, but they are not
> related to IPA). So now I need to figure out, what other global state (which is
> set up by push_cfun) can these functions use? Could you give some advice about
> that, in sense, what should I look for (e.g., push_cfun calls some target hooks,
> but I did not try to look in detail, what kind of actions are performed by it)?
Actions can include computing register preferences and other expensive stuff
if a function has a target or optimize attribute different from the previously
active one. It's the push/pop_cfun calls from ipa-* that are expensive, but
more so that from tree-sra.c (that's in theory quadratic). Basically whenever
only very little is done inside a push/pop pair the it's best to avoid it.
Calling push/pop from non-IPA context is to be avoided even more so.
> As for the API. I propose to, at least, remove uses of cfun from dominance.c
> itself, but provide helper functions which will allow to leave the callers
> unchanged, but make it possible to use all dominance-related API on functions
> other than cfun.
> Does such change sound reasonable to you?
Like providing the overload I suggested above? Yes, that makes sense to me.
Thanks,
Richard.
>
> On 08/14/2015 11:11 PM, David Malcolm wrote:
>> The JIT guards all access to GCC's state in a big mutex ("jit_mutex", in
>> gcc/jit/jit-playback.c).
> Yeah, I know, I looked through JIT documentation briefly.
>>
>> For example, this includes everything to do with GC and GTY, since
>> there's implicitly a single set of GC roots and the GC code isn't thread
>> safe.
> And GGC is a "stop-the-world" collector, which is just not designed for
> multithreaded environment. (sigh)
>
> As for the patch, I think reviewing this variant does not make much sense,
> because of Richard suggestion on how to avoid changing the callers. But still
> thanks for looking.
>
>>
>> I've been tackling things on an as-needed basis - for example, the
>> recent timevar global-state removal was motivated by wanting to expose a
>> profiling API to jit client code.
>>
> By the way, speaking of timevars. I wrote about my concerns w.r.t. them, but did
> not get any feedback:
> https://gcc.gnu.org/ml/gcc/2015-07/msg00165.html
> Briefly speaking, I noticed that our timers introduce rather significant
> measurement errors and proposed some ideas about reducing them. What do you think?
>
> --
> Regards,
> Mikhail Maltsev
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-15 6:05 ` Mikhail Maltsev
@ 2015-08-18 19:23 ` Jeff Law
2015-08-22 7:01 ` Mikhail Maltsev
0 siblings, 1 reply; 14+ messages in thread
From: Jeff Law @ 2015-08-18 19:23 UTC (permalink / raw)
To: Mikhail Maltsev, Richard Biener; +Cc: gcc-patches
On 08/14/2015 10:02 PM, Mikhail Maltsev wrote:
> On 08/14/2015 10:54 AM, Richard Biener wrote:
>> In fact initializing
>> dom_info from that would allow it to work on SESE regions as well?
>
> Can't tell for sure. We would need a way to iterate through region's basic
> blocks (I'm not familiar with that code, but it seems to me that they are not
> contiguous: build_sese_loop_nests function iterates through the region by
> iterating through all BBs and filtering out ones which are not in region). Also
> we have a mapping from some global BB index to it's number in DFS-order walk,
> i.e. we will either need to allocate enough space for it, or use a hash map
> instead of an array. Never the less, initializing start/end blocks and "reverse"
> flag in constructor makes the code look cleaner because we avoid repeating these
> initializations.
I suspect that lots of code would need to be tweaked to start handling
regions. As you note, I don't think most of the walkers are
region-aware, they just start at a given block and walk
forward/backwards without any regard to whether or not they've left any
predefined region.
>
> On 08/14/2015 09:20 PM, Jeff Law wrote:
>> It looks like your patch is primarily concerned with converting all the internal
>> stuff into a C++ style and not exposing a class to the users of dominance.h.
>> Correct?
> Well, sort of. But I think this class also provides some API (though it's used
> internally in dominance.c): it computes some initial dominance tree and other
> functions either query it or update incrementally. And, as Richard said, this
> class could be modified to be used on SESE regions.
Just to be clear, I'm not objecting to what you've done, just noting
that it doesn't have as much utility as class-ifying other things.
>
>> I could argue that those kind of changes are independent of turning dom_info
>> into a real class and if they're going to go forward, they would have to stand
>> alone on their merits and go in independently if turning dom_info into a class
>> (which AFIACT is the meat of this patch).
> Actually I thought that putting all these non-functional changes into a single
> patch would make the churn less (after all, it's a single commit). But I
> understand this rather obvious cue, that these changes are, well, unlikely to be
> accepted.
> So, the updated patch contains only the dom_info-related changes.
I wouldn't say it's a cue that whey wouldn't be accepted, but they're in
the "danger zone". Particularly since there was a conscious decision
not to just change things to be C++-ish if there wasn't some kind of
benefit.
It's not always clear what kind of cleanups that don't affect
functionality are desirable. There's certainly been cleanups through
the years that I looked at and said to myself "why bother" at the time,
only to look back years later and say "in retrospect that was a good idea".
And there's others that I look at and say to myself, why don't we just
use commit-hooks to ensure certain things never get into the source tree
again (I'm thinking whitespace and formatting stuff that can be handled
by gnu-indent in particular).
It's also not clear where the line is between cleaning up obvious junk
while working in a hunk of code and separating those cleanups as their
own independent change. I personally tend to want to see these as their
own changes as it more easily allows me to focus on the meat of a
change. Others almost certainly draw the line in a different location.
So to summarize, I'm not trying to discourage this kind of work, but
make you aware of some of the issues/concerns for that class of changes.
>
>> Umm, isn't ENABLE_CHECKING defined in auto-host.h (as set up by configure?)
>> What's the reason for this change?
>>
>> Is the issue that auto-host.h won't define checking at all for --disable-checking?
> Yes, it does not get defined even for --enable-checking=release.
Just wanted to make sure. As you're aware, we're trying to move away
from the conditional compilation and your change does take us a step in
that direction, but I suspect tackling ENABLE_CHECKING is probably best
done as an independent change so that we don't have these fragments all
over the place to turn a defined/not-defined into something we can check
with if ().
>>
>> I think that the ENABLE_CHECKING conversion from #ifdef testing to testing for a
>> value should probably be done separately. It also probably has higher value
>> than this refactoring.
> Well, I'll try to work on that. After all, it's the most frequently used
> condition for conditional compilation in GCC. And removing part of #ifdef-s will
> probably help to avoid some errors (e.g. warnings which only appear in "release"
> builds).
That would be greatly appreciated.
>>> + /* The function being processed. */
>>> + function *m_fn;
>> So presumably the idea here is to avoid explicitly hitting cfun which in theory
>> we could recompute the dominance tree for another function. But is that really
>> all that useful?
> No, I was thinking more of moving toward having a self-contained compilation
> context and being able to run compilation in multiple threads. I know that we
> are far away from this goal but never the less. BTW, do we actually have such
> goal or not? :)
We do have such a goal via the JIT project and more generally
compile-servers. I sometimes hesitate to mention the latter as I've
seen so many compile server projects fail miserably after folks have
invested enormous amount of time/energy.
>
>>
>> I'm a bit torn here. Richi mentioned the idea of stuffing away a pointer to
>> cfun looked backwards to him and he'd pretty stuffing away the entry, exit & #
>> blocks and perhaps take us a step towards the ability to compute dominance on
>> sub-graphs.
>>
>> The problem I see with Richi's idea now that I think about it more is keeping
>> that information up-to-date. Ie, if we've stuffed away those pointers, what
>> happens if (for example) a block gets deleted from the graph. What if that
>> block happens to be the exit block we've recorded?
> All this information is discarded after we have the dominator tree computed. The
> tree itself is stored in et_node-s (which are "attached" to basic blocks).
> dom_info is not used for incremental updates.
Ah, in that case it shouldn't be a problem stuffing away those pointers
instead of the cfun.
>
>
> gcc/ChangeLog:
>
> 2015-08-15 Mikhail Maltsev <maltsevm@gmail.com>
>
> * dominance.c (new_zero_array): Define.
> (dom_info): Redefine as class with proper encapsulation.
> (dom_info::m_n_basic_blocks, m_reverse, m_start_block, m_end_block):
> Add new members.
> (dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
> allocations/deallocations. Pass function as parameter (instead of
> using cfun).
> (dom_info::get_idom): Define accessor method.
> (dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
> link_roots, calc_idoms): Redefine as class members. Do not use cfun.
> (calculate_dominance_info): Adjust to use dom_info class.
> (verify_dominators): Likewise.
>
OK for the trunk.
Thanks,
Jeff
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 1/2] C++-ify dominance.c
2015-08-18 19:23 ` Jeff Law
@ 2015-08-22 7:01 ` Mikhail Maltsev
0 siblings, 0 replies; 14+ messages in thread
From: Mikhail Maltsev @ 2015-08-22 7:01 UTC (permalink / raw)
To: Jeff Law, Richard Biener; +Cc: gcc-patches
On 08/18/2015 10:00 PM, Jeff Law wrote:
> On 08/14/2015 10:02 PM, Mikhail Maltsev wrote:
>>
>> gcc/ChangeLog:
>>
>> 2015-08-15 Mikhail Maltsev <maltsevm@gmail.com>
>>
>> * dominance.c (new_zero_array): Define.
>> (dom_info): Redefine as class with proper encapsulation.
>> (dom_info::m_n_basic_blocks, m_reverse, m_start_block, m_end_block):
>> Add new members.
>> (dom_info::dom_info, ~dom_info): Define. Use new/delete for memory
>> allocations/deallocations. Pass function as parameter (instead of
>> using cfun).
>> (dom_info::get_idom): Define accessor method.
>> (dom_info::calc_dfs_tree_nonrec, calc_dfs_tree, compress, eval,
>> link_roots, calc_idoms): Redefine as class members. Do not use cfun.
>> (calculate_dominance_info): Adjust to use dom_info class.
>> (verify_dominators): Likewise.
>>
> OK for the trunk.
>
> Thanks,
> Jeff
Committed as r227093.
--
Regards,
Mikhail Maltsev
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2015-08-22 3:23 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-08-14 1:05 [PATCH 1/2] C++-ify dominance.c Mikhail Maltsev
2015-08-14 1:25 ` [PATCH 2/2] Get rid of global state accesses in dominance.c Mikhail Maltsev
2015-08-14 8:17 ` Richard Biener
2015-08-14 18:28 ` Jeff Law
2015-08-14 20:24 ` David Malcolm
2015-08-15 6:13 ` Mikhail Maltsev
2015-08-18 10:13 ` Richard Biener
2015-08-14 7:54 ` [PATCH 1/2] C++-ify dominance.c Richard Biener
2015-08-14 17:26 ` Jeff Law
2015-08-15 6:05 ` Mikhail Maltsev
2015-08-18 19:23 ` Jeff Law
2015-08-22 7:01 ` Mikhail Maltsev
2015-08-14 18:25 ` Jeff Law
2015-08-15 7:59 ` Richard Biener
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).