// Copyright (c) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include "source/cfa.h" #include "source/opt/dominator_tree.h" #include "source/opt/ir_context.h" // Calculates the dominator or postdominator tree for a given function. // 1 - Compute the successors and predecessors for each BasicBlock. We add a // dummy node for the start node or for postdominators the exit. This node will // point to all entry or all exit nodes. // 2 - Using the CFA::DepthFirstTraversal get a depth first postordered list of // all BasicBlocks. Using the successors (or for postdominator, predecessors) // calculated in step 1 to traverse the tree. // 3 - Pass the list calculated in step 2 to the CFA::CalculateDominators using // the predecessors list (or for postdominator, successors). This will give us a // vector of BB pairs. Each BB and its immediate dominator. // 4 - Using the list from 3 use those edges to build a tree of // DominatorTreeNodes. Each node containing a link to the parent dominator and // children which are dominated. // 5 - Using the tree from 4, perform a depth first traversal to calculate the // preorder and postorder index of each node. We use these indexes to compare // nodes against each other for domination checks. namespace spvtools { namespace opt { namespace { // Wrapper around CFA::DepthFirstTraversal to provide an interface to perform // depth first search on generic BasicBlock types. Will call post and pre order // user defined functions during traversal // // BBType - BasicBlock type. Will either be BasicBlock or DominatorTreeNode // SuccessorLambda - Lamdba matching the signature of 'const // std::vector*(const BBType *A)'. Will return a vector of the nodes // succeding BasicBlock A. // PostLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed AFTER their children. // PreLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed BEFORE their children. template static void DepthFirstSearch(const BBType* bb, SuccessorLambda successors, PreLambda pre, PostLambda post) { // Ignore backedge operation. auto nop_backedge = [](const BBType*, const BBType*) {}; CFA::DepthFirstTraversal(bb, successors, pre, post, nop_backedge); } // Wrapper around CFA::DepthFirstTraversal to provide an interface to perform // depth first search on generic BasicBlock types. This overload is for only // performing user defined post order. // // BBType - BasicBlock type. Will either be BasicBlock or DominatorTreeNode // SuccessorLambda - Lamdba matching the signature of 'const // std::vector*(const BBType *A)'. Will return a vector of the nodes // succeding BasicBlock A. // PostLambda - Lamdba matching the signature of 'void (const BBType*)' will be // called on each node traversed after their children. template static void DepthFirstSearchPostOrder(const BBType* bb, SuccessorLambda successors, PostLambda post) { // Ignore preorder operation. auto nop_preorder = [](const BBType*) {}; DepthFirstSearch(bb, successors, nop_preorder, post); } // Small type trait to get the function class type. template struct GetFunctionClass { using FunctionType = Function; }; // Helper class to compute predecessors and successors for each Basic Block in a // function. Through GetPredFunctor and GetSuccessorFunctor it provides an // interface to get the successor and predecessor lists for each basic // block. This is required by the DepthFirstTraversal and ComputeDominator // functions which take as parameter an std::function returning the successors // and predecessors respectively. // // When computing the post-dominator tree, all edges are inverted. So successors // returned by this class will be predecessors in the original CFG. template class BasicBlockSuccessorHelper { // This should eventually become const BasicBlock. using BasicBlock = BBType; using Function = typename GetFunctionClass::FunctionType; using BasicBlockListTy = std::vector; using BasicBlockMapTy = std::map; public: // For compliance with the dominance tree computation, entry nodes are // connected to a single dummy node. BasicBlockSuccessorHelper(Function& func, const BasicBlock* dummy_start_node, bool post); // CFA::CalculateDominators requires std::vector. using GetBlocksFunction = std::function*(const BasicBlock*)>; // Returns the list of predecessor functions. GetBlocksFunction GetPredFunctor() { return [this](const BasicBlock* bb) { BasicBlockListTy* v = &this->predecessors_[bb]; return v; }; } // Returns a vector of the list of successor nodes from a given node. GetBlocksFunction GetSuccessorFunctor() { return [this](const BasicBlock* bb) { BasicBlockListTy* v = &this->successors_[bb]; return v; }; } private: bool invert_graph_; BasicBlockMapTy successors_; BasicBlockMapTy predecessors_; // Build the successors and predecessors map for each basic blocks |f|. // If |invert_graph_| is true, all edges are reversed (successors becomes // predecessors and vice versa). // For convenience, the start of the graph is |dummy_start_node|. // The dominator tree construction requires a unique entry node, which cannot // be guaranteed for the postdominator graph. The |dummy_start_node| BB is // here to gather all entry nodes. void CreateSuccessorMap(Function& f, const BasicBlock* dummy_start_node); }; template BasicBlockSuccessorHelper::BasicBlockSuccessorHelper( Function& func, const BasicBlock* dummy_start_node, bool invert) : invert_graph_(invert) { CreateSuccessorMap(func, dummy_start_node); } template void BasicBlockSuccessorHelper::CreateSuccessorMap( Function& f, const BasicBlock* dummy_start_node) { std::map id_to_BB_map; auto GetSuccessorBasicBlock = [&f, &id_to_BB_map](uint32_t successor_id) { BasicBlock*& Succ = id_to_BB_map[successor_id]; if (!Succ) { for (BasicBlock& BBIt : f) { if (successor_id == BBIt.id()) { Succ = &BBIt; break; } } } return Succ; }; if (invert_graph_) { // For the post dominator tree, we see the inverted graph. // successors_ in the inverted graph are the predecessors in the CFG. // The tree construction requires 1 entry point, so we add a dummy node // that is connected to all function exiting basic blocks. // An exiting basic block is a block with an OpKill, OpUnreachable, // OpReturn or OpReturnValue as terminator instruction. for (BasicBlock& bb : f) { if (bb.hasSuccessor()) { BasicBlockListTy& pred_list = predecessors_[&bb]; const auto& const_bb = bb; const_bb.ForEachSuccessorLabel( [this, &pred_list, &bb, &GetSuccessorBasicBlock](const uint32_t successor_id) { BasicBlock* succ = GetSuccessorBasicBlock(successor_id); // Inverted graph: our successors in the CFG // are our predecessors in the inverted graph. this->successors_[succ].push_back(&bb); pred_list.push_back(succ); }); } else { successors_[dummy_start_node].push_back(&bb); predecessors_[&bb].push_back(const_cast(dummy_start_node)); } } } else { successors_[dummy_start_node].push_back(f.entry().get()); predecessors_[f.entry().get()].push_back( const_cast(dummy_start_node)); for (BasicBlock& bb : f) { BasicBlockListTy& succ_list = successors_[&bb]; const auto& const_bb = bb; const_bb.ForEachSuccessorLabel([&](const uint32_t successor_id) { BasicBlock* succ = GetSuccessorBasicBlock(successor_id); succ_list.push_back(succ); predecessors_[succ].push_back(&bb); }); } } } } // namespace bool DominatorTree::StrictlyDominates(uint32_t a, uint32_t b) const { if (a == b) return false; return Dominates(a, b); } bool DominatorTree::StrictlyDominates(const BasicBlock* a, const BasicBlock* b) const { return DominatorTree::StrictlyDominates(a->id(), b->id()); } bool DominatorTree::StrictlyDominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const { if (a == b) return false; return Dominates(a, b); } bool DominatorTree::Dominates(uint32_t a, uint32_t b) const { // Check that both of the inputs are actual nodes. const DominatorTreeNode* a_node = GetTreeNode(a); const DominatorTreeNode* b_node = GetTreeNode(b); if (!a_node || !b_node) return false; return Dominates(a_node, b_node); } bool DominatorTree::Dominates(const DominatorTreeNode* a, const DominatorTreeNode* b) const { if (!a || !b) return false; // Node A dominates node B if they are the same. if (a == b) return true; return a->dfs_num_pre_ < b->dfs_num_pre_ && a->dfs_num_post_ > b->dfs_num_post_; } bool DominatorTree::Dominates(const BasicBlock* A, const BasicBlock* B) const { return Dominates(A->id(), B->id()); } BasicBlock* DominatorTree::ImmediateDominator(const BasicBlock* A) const { return ImmediateDominator(A->id()); } BasicBlock* DominatorTree::ImmediateDominator(uint32_t a) const { // Check that A is a valid node in the tree. auto a_itr = nodes_.find(a); if (a_itr == nodes_.end()) return nullptr; const DominatorTreeNode* node = &a_itr->second; if (node->parent_ == nullptr) { return nullptr; } return node->parent_->bb_; } DominatorTreeNode* DominatorTree::GetOrInsertNode(BasicBlock* bb) { DominatorTreeNode* dtn = nullptr; std::map::iterator node_iter = nodes_.find(bb->id()); if (node_iter == nodes_.end()) { dtn = &nodes_.emplace(std::make_pair(bb->id(), DominatorTreeNode{bb})) .first->second; } else { dtn = &node_iter->second; } return dtn; } void DominatorTree::GetDominatorEdges( const Function* f, const BasicBlock* dummy_start_node, std::vector>* edges) { // Each time the depth first traversal calls the postorder callback // std::function we push that node into the postorder vector to create our // postorder list. std::vector postorder; auto postorder_function = [&](const BasicBlock* b) { postorder.push_back(b); }; // CFA::CalculateDominators requires std::vector // BB are derived from F, so we need to const cast it at some point // no modification is made on F. BasicBlockSuccessorHelper helper{ *const_cast(f), dummy_start_node, postdominator_}; // The successor function tells DepthFirstTraversal how to move to successive // nodes by providing an interface to get a list of successor nodes from any // given node. auto successor_functor = helper.GetSuccessorFunctor(); // The predecessor functor does the same as the successor functor // but for all nodes preceding a given node. auto predecessor_functor = helper.GetPredFunctor(); // If we're building a post dominator tree we traverse the tree in reverse // using the predecessor function in place of the successor function and vice // versa. DepthFirstSearchPostOrder(dummy_start_node, successor_functor, postorder_function); *edges = CFA::CalculateDominators(postorder, predecessor_functor); } void DominatorTree::InitializeTree(const CFG& cfg, const Function* f) { ClearTree(); // Skip over empty functions. if (f->cbegin() == f->cend()) { return; } const BasicBlock* dummy_start_node = postdominator_ ? cfg.pseudo_exit_block() : cfg.pseudo_entry_block(); // Get the immediate dominator for each node. std::vector> edges; GetDominatorEdges(f, dummy_start_node, &edges); // Transform the vector into the tree structure which we can use to // efficiently query dominance. for (auto edge : edges) { DominatorTreeNode* first = GetOrInsertNode(edge.first); if (edge.first == edge.second) { if (std::find(roots_.begin(), roots_.end(), first) == roots_.end()) roots_.push_back(first); continue; } DominatorTreeNode* second = GetOrInsertNode(edge.second); first->parent_ = second; second->children_.push_back(first); } ResetDFNumbering(); } void DominatorTree::ResetDFNumbering() { int index = 0; auto preFunc = [&index](const DominatorTreeNode* node) { const_cast(node)->dfs_num_pre_ = ++index; }; auto postFunc = [&index](const DominatorTreeNode* node) { const_cast(node)->dfs_num_post_ = ++index; }; auto getSucc = [](const DominatorTreeNode* node) { return &node->children_; }; for (auto root : roots_) DepthFirstSearch(root, getSucc, preFunc, postFunc); } void DominatorTree::DumpTreeAsDot(std::ostream& out_stream) const { out_stream << "digraph {\n"; Visit([&out_stream](const DominatorTreeNode* node) { // Print the node. if (node->bb_) { out_stream << node->bb_->id() << "[label=\"" << node->bb_->id() << "\"];\n"; } // Print the arrow from the parent to this node. Entry nodes will not have // parents so draw them as children from the dummy node. if (node->parent_) { out_stream << node->parent_->bb_->id() << " -> " << node->bb_->id() << ";\n"; } // Return true to continue the traversal. return true; }); out_stream << "}\n"; } } // namespace opt } // namespace spvtools