220 changes: 220 additions & 0 deletions llvm/include/llvm/Analysis/DominanceFrontierImpl.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,220 @@
//===- llvm/Analysis/DominanceFrontier.h - Dominator Frontiers --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This is the generic implementation of the DominanceFrontier class, which
// calculate and holds the dominance frontier for a function for.
//
// This should be considered deprecated, don't add any more uses of this data
// structure.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ANALYSIS_DOMINANCEFRONTIER_IMPL_H
#define LLVM_ANALYSIS_DOMINANCEFRONTIER_IMPL_H

#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h"

namespace llvm {

namespace {
template <class BlockT>
class DFCalculateWorkObject {
public:
typedef DomTreeNodeBase<BlockT> DomTreeNodeT;

DFCalculateWorkObject(BlockT *B, BlockT *P, const DomTreeNodeT *N,
const DomTreeNodeT *PN)
: currentBB(B), parentBB(P), Node(N), parentNode(PN) {}
BlockT *currentBB;
BlockT *parentBB;
const DomTreeNodeT *Node;
const DomTreeNodeT *parentNode;
};
}

template <class BlockT>
void DominanceFrontierBase<BlockT>::removeBlock(BlockT *BB) {
assert(find(BB) != end() && "Block is not in DominanceFrontier!");
for (iterator I = begin(), E = end(); I != E; ++I)
I->second.erase(BB);
Frontiers.erase(BB);
}

template <class BlockT>
void DominanceFrontierBase<BlockT>::removeFromFrontier(iterator I,
BlockT *Node) {
assert(I != end() && "BB is not in DominanceFrontier!");
assert(I->second.count(Node) && "Node is not in DominanceFrontier of BB");
I->second.erase(Node);
}

template <class BlockT>
bool DominanceFrontierBase<BlockT>::compareDomSet(DomSetType &DS1,
const DomSetType &DS2) const {
std::set<BlockT *> tmpSet;
for (BlockT *BB : DS2)
tmpSet.insert(BB);

for (typename DomSetType::const_iterator I = DS1.begin(), E = DS1.end();
I != E;) {
BlockT *Node = *I++;

if (tmpSet.erase(Node) == 0)
// Node is in DS1 but tnot in DS2.
return true;
}

if (!tmpSet.empty()) {
// There are nodes that are in DS2 but not in DS1.
return true;
}

// DS1 and DS2 matches.
return false;
}

template <class BlockT>
bool DominanceFrontierBase<BlockT>::compare(
DominanceFrontierBase<BlockT> &Other) const {
DomSetMapType tmpFrontiers;
for (typename DomSetMapType::const_iterator I = Other.begin(),
E = Other.end();
I != E; ++I)
tmpFrontiers.insert(std::make_pair(I->first, I->second));

for (typename DomSetMapType::iterator I = tmpFrontiers.begin(),
E = tmpFrontiers.end();
I != E;) {
BlockT *Node = I->first;
const_iterator DFI = find(Node);
if (DFI == end())
return true;

if (compareDomSet(I->second, DFI->second))
return true;

++I;
tmpFrontiers.erase(Node);
}

if (!tmpFrontiers.empty())
return true;

return false;
}

template <class BlockT>
void DominanceFrontierBase<BlockT>::print(raw_ostream &OS) const {
for (const_iterator I = begin(), E = end(); I != E; ++I) {
OS << " DomFrontier for BB ";
if (I->first)
I->first->printAsOperand(OS, false);
else
OS << " <<exit node>>";
OS << " is:\t";

const std::set<BlockT *> &BBs = I->second;

for (const BlockT *BB : BBs) {
OS << ' ';
if (BB)
BB->printAsOperand(OS, false);
else
OS << "<<exit node>>";
}
OS << '\n';
}
}

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
template <class BlockT>
void DominanceFrontierBase<BlockT>::dump() const {
print(dbgs());
}
#endif

template <class BlockT>
const typename ForwardDominanceFrontierBase<BlockT>::DomSetType &
ForwardDominanceFrontierBase<BlockT>::calculate(const DomTreeT &DT,
const DomTreeNodeT *Node) {
BlockT *BB = Node->getBlock();
DomSetType *Result = nullptr;

std::vector<DFCalculateWorkObject<BlockT>> workList;
SmallPtrSet<BlockT *, 32> visited;

workList.push_back(DFCalculateWorkObject<BlockT>(BB, nullptr, Node, nullptr));
do {
DFCalculateWorkObject<BlockT> *currentW = &workList.back();
assert(currentW && "Missing work object.");

BlockT *currentBB = currentW->currentBB;
BlockT *parentBB = currentW->parentBB;
const DomTreeNodeT *currentNode = currentW->Node;
const DomTreeNodeT *parentNode = currentW->parentNode;
assert(currentBB && "Invalid work object. Missing current Basic Block");
assert(currentNode && "Invalid work object. Missing current Node");
DomSetType &S = this->Frontiers[currentBB];

// Visit each block only once.
if (visited.count(currentBB) == 0) {
visited.insert(currentBB);

// Loop over CFG successors to calculate DFlocal[currentNode]
for (auto SI = BlockTraits::child_begin(currentBB),
SE = BlockTraits::child_end(currentBB);
SI != SE; ++SI) {
// Does Node immediately dominate this successor?
if (DT[*SI]->getIDom() != currentNode)
S.insert(*SI);
}
}

// At this point, S is DFlocal. Now we union in DFup's of our children...
// Loop through and visit the nodes that Node immediately dominates (Node's
// children in the IDomTree)
bool visitChild = false;
for (typename DomTreeNodeT::const_iterator NI = currentNode->begin(),
NE = currentNode->end();
NI != NE; ++NI) {
DomTreeNodeT *IDominee = *NI;
BlockT *childBB = IDominee->getBlock();
if (visited.count(childBB) == 0) {
workList.push_back(DFCalculateWorkObject<BlockT>(
childBB, currentBB, IDominee, currentNode));
visitChild = true;
}
}

// If all children are visited or there is any child then pop this block
// from the workList.
if (!visitChild) {
if (!parentBB) {
Result = &S;
break;
}

typename DomSetType::const_iterator CDFI = S.begin(), CDFE = S.end();
DomSetType &parentSet = this->Frontiers[parentBB];
for (; CDFI != CDFE; ++CDFI) {
if (!DT.properlyDominates(parentNode, DT[*CDFI]))
parentSet.insert(*CDFI);
}
workList.pop_back();
}

} while (!workList.empty());

return *Result;
}

} // End llvm namespace

#endif
109 changes: 109 additions & 0 deletions llvm/include/llvm/CodeGen/MachineDominanceFrontier.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,109 @@
//===- llvm/CodeGen/MachineDominanceFrontier.h ------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CODEGEN_MACHINEDOMINANCEFRONTIER_H
#define LLVM_CODEGEN_MACHINEDOMINANCEFRONTIER_H

#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunctionPass.h"


namespace llvm {

class MachineDominanceFrontier : public MachineFunctionPass {
ForwardDominanceFrontierBase<MachineBasicBlock> Base;
public:
typedef DominatorTreeBase<MachineBasicBlock> DomTreeT;
typedef DomTreeNodeBase<MachineBasicBlock> DomTreeNodeT;
typedef typename DominanceFrontierBase<MachineBasicBlock>::DomSetType DomSetType;
typedef DominanceFrontierBase<MachineBasicBlock>::iterator iterator;
typedef DominanceFrontierBase<MachineBasicBlock>::const_iterator const_iterator;

void operator=(const MachineDominanceFrontier &) LLVM_DELETED_FUNCTION;
MachineDominanceFrontier(const MachineDominanceFrontier &) LLVM_DELETED_FUNCTION;

static char ID;

MachineDominanceFrontier();

DominanceFrontierBase<MachineBasicBlock> &getBase() {
return Base;
}

inline const std::vector<MachineBasicBlock*> &getRoots() const {
return Base.getRoots();
}

MachineBasicBlock *getRoot() const {
return Base.getRoot();
}

bool isPostDominator() const {
return Base.isPostDominator();
}

iterator begin() {
return Base.begin();
}

const_iterator begin() const {
return Base.begin();
}

iterator end() {
return Base.end();
}

const_iterator end() const {
return Base.end();
}

iterator find(MachineBasicBlock *B) {
return Base.find(B);
}

const_iterator find(MachineBasicBlock *B) const {
return Base.find(B);
}

iterator addBasicBlock(MachineBasicBlock *BB, const DomSetType &frontier) {
return Base.addBasicBlock(BB, frontier);
}

void removeBlock(MachineBasicBlock *BB) {
return Base.removeBlock(BB);
}

void addToFrontier(iterator I, MachineBasicBlock *Node) {
return Base.addToFrontier(I, Node);
}

void removeFromFrontier(iterator I, MachineBasicBlock *Node) {
return Base.removeFromFrontier(I, Node);
}

bool compareDomSet(DomSetType &DS1, const DomSetType &DS2) const {
return Base.compareDomSet(DS1, DS2);
}

bool compare(DominanceFrontierBase<MachineBasicBlock> &Other) const {
return Base.compare(Other);
}

bool runOnMachineFunction(MachineFunction &F) override;

void releaseMemory() override;

void getAnalysisUsage(AnalysisUsage &AU) const override;
};

}

#endif
3 changes: 3 additions & 0 deletions llvm/include/llvm/CodeGen/Passes.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -381,6 +381,9 @@ namespace llvm {
/// MachineDominators - This pass is a machine dominators analysis pass.
extern char &MachineDominatorsID;

/// MachineDominanaceFrontier - This pass is a machine dominators analysis pass.
extern char &MachineDominanceFrontierID;

/// EdgeBundles analysis - Bundle machine CFG edges.
extern char &EdgeBundlesID;

Expand Down
1 change: 1 addition & 0 deletions llvm/include/llvm/InitializePasses.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -184,6 +184,7 @@ void initializeMachineBlockPlacementStatsPass(PassRegistry&);
void initializeMachineBranchProbabilityInfoPass(PassRegistry&);
void initializeMachineCSEPass(PassRegistry&);
void initializeMachineDominatorTreePass(PassRegistry&);
void initializeMachineDominanceFrontierPass(PassRegistry&);
void initializeMachinePostDominatorTreePass(PassRegistry&);
void initializeMachineLICMPass(PassRegistry&);
void initializeMachineLoopInfoPass(PassRegistry&);
Expand Down
135 changes: 26 additions & 109 deletions llvm/lib/Analysis/DominanceFrontier.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,133 +8,50 @@
//===----------------------------------------------------------------------===//

#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Analysis/DominanceFrontierImpl.h"

using namespace llvm;

namespace llvm {
template class DominanceFrontierBase<BasicBlock>;
template class ForwardDominanceFrontierBase<BasicBlock>;
}

char DominanceFrontier::ID = 0;

INITIALIZE_PASS_BEGIN(DominanceFrontier, "domfrontier",
"Dominance Frontier Construction", true, true)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_END(DominanceFrontier, "domfrontier",
"Dominance Frontier Construction", true, true)

namespace {
class DFCalculateWorkObject {
public:
DFCalculateWorkObject(BasicBlock *B, BasicBlock *P,
const DomTreeNode *N,
const DomTreeNode *PN)
: currentBB(B), parentBB(P), Node(N), parentNode(PN) {}
BasicBlock *currentBB;
BasicBlock *parentBB;
const DomTreeNode *Node;
const DomTreeNode *parentNode;
};
DominanceFrontier::DominanceFrontier()
: FunctionPass(ID),
Base() {
initializeDominanceFrontierPass(*PassRegistry::getPassRegistry());
}

void DominanceFrontier::anchor() { }

const DominanceFrontier::DomSetType &
DominanceFrontier::calculate(const DominatorTree &DT,
const DomTreeNode *Node) {
BasicBlock *BB = Node->getBlock();
DomSetType *Result = nullptr;

std::vector<DFCalculateWorkObject> workList;
SmallPtrSet<BasicBlock *, 32> visited;

workList.push_back(DFCalculateWorkObject(BB, nullptr, Node, nullptr));
do {
DFCalculateWorkObject *currentW = &workList.back();
assert (currentW && "Missing work object.");

BasicBlock *currentBB = currentW->currentBB;
BasicBlock *parentBB = currentW->parentBB;
const DomTreeNode *currentNode = currentW->Node;
const DomTreeNode *parentNode = currentW->parentNode;
assert (currentBB && "Invalid work object. Missing current Basic Block");
assert (currentNode && "Invalid work object. Missing current Node");
DomSetType &S = Frontiers[currentBB];

// Visit each block only once.
if (visited.count(currentBB) == 0) {
visited.insert(currentBB);

// Loop over CFG successors to calculate DFlocal[currentNode]
for (succ_iterator SI = succ_begin(currentBB), SE = succ_end(currentBB);
SI != SE; ++SI) {
// Does Node immediately dominate this successor?
if (DT[*SI]->getIDom() != currentNode)
S.insert(*SI);
}
}

// At this point, S is DFlocal. Now we union in DFup's of our children...
// Loop through and visit the nodes that Node immediately dominates (Node's
// children in the IDomTree)
bool visitChild = false;
for (DomTreeNode::const_iterator NI = currentNode->begin(),
NE = currentNode->end(); NI != NE; ++NI) {
DomTreeNode *IDominee = *NI;
BasicBlock *childBB = IDominee->getBlock();
if (visited.count(childBB) == 0) {
workList.push_back(DFCalculateWorkObject(childBB, currentBB,
IDominee, currentNode));
visitChild = true;
}
}

// If all children are visited or there is any child then pop this block
// from the workList.
if (!visitChild) {

if (!parentBB) {
Result = &S;
break;
}

DomSetType::const_iterator CDFI = S.begin(), CDFE = S.end();
DomSetType &parentSet = Frontiers[parentBB];
for (; CDFI != CDFE; ++CDFI) {
if (!DT.properlyDominates(parentNode, DT[*CDFI]))
parentSet.insert(*CDFI);
}
workList.pop_back();
}
void DominanceFrontier::releaseMemory() {
Base.releaseMemory();
}

} while (!workList.empty());
bool DominanceFrontier::runOnFunction(Function &) {
releaseMemory();
Base.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
return false;
}

return *Result;
void DominanceFrontier::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<DominatorTreeWrapperPass>();
}

void DominanceFrontierBase::print(raw_ostream &OS, const Module* ) const {
for (const_iterator I = begin(), E = end(); I != E; ++I) {
OS << " DomFrontier for BB ";
if (I->first)
I->first->printAsOperand(OS, false);
else
OS << " <<exit node>>";
OS << " is:\t";

const std::set<BasicBlock*> &BBs = I->second;

for (std::set<BasicBlock*>::const_iterator I = BBs.begin(), E = BBs.end();
I != E; ++I) {
OS << ' ';
if (*I)
(*I)->printAsOperand(OS, false);
else
OS << "<<exit node>>";
}
OS << "\n";
}
void DominanceFrontier::print(raw_ostream &OS, const Module *) const {
Base.print(OS);
}

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void DominanceFrontierBase::dump() const {
void DominanceFrontier::dump() const {
print(dbgs());
}
#endif

1 change: 1 addition & 0 deletions llvm/lib/CodeGen/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,6 +51,7 @@ add_llvm_library(LLVMCodeGen
MachineCodeEmitter.cpp
MachineCopyPropagation.cpp
MachineDominators.cpp
MachineDominanceFrontier.cpp
MachineFunction.cpp
MachineFunctionAnalysis.cpp
MachineFunctionPass.cpp
Expand Down
54 changes: 54 additions & 0 deletions llvm/lib/CodeGen/MachineDominanceFrontier.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,54 @@
//===- MachineDominanceFrontier.cpp ---------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "llvm/CodeGen/MachineDominanceFrontier.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/Analysis/DominanceFrontierImpl.h"
#include "llvm/CodeGen/Passes.h"


using namespace llvm;

namespace llvm {
template class DominanceFrontierBase<MachineBasicBlock>;
template class ForwardDominanceFrontierBase<MachineBasicBlock>;
}


char MachineDominanceFrontier::ID = 0;

INITIALIZE_PASS_BEGIN(MachineDominanceFrontier, "machine-domfrontier",
"Machine Dominance Frontier Construction", true, true)
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
INITIALIZE_PASS_END(MachineDominanceFrontier, "machine-domfrontier",
"Machine Dominance Frontier Construction", true, true)

MachineDominanceFrontier::MachineDominanceFrontier()
: MachineFunctionPass(ID),
Base() {
initializeMachineDominanceFrontierPass(*PassRegistry::getPassRegistry());
}

char &llvm::MachineDominanceFrontierID = MachineDominanceFrontier::ID;

bool MachineDominanceFrontier::runOnMachineFunction(MachineFunction &) {
releaseMemory();
Base.analyze(getAnalysis<MachineDominatorTree>().getBase());
return false;
}

void MachineDominanceFrontier::releaseMemory() {
Base.releaseMemory();
}

void MachineDominanceFrontier::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<MachineDominatorTree>();
MachineFunctionPass::getAnalysisUsage(AU);
}