Merge branch 'ddg_observ'

Author: oUaTEnCi

include/tsar/Analysis/PDG.h

@@ -17,6 +17,9 @@
 #include <map>
 #include <string>
 
+#include <llvm/Analysis/DDG.h>
+#include <llvm/Analysis/DDGPrinter.h>
+
 namespace tsar {
 
 template<typename CFGType, typename CFGNodeType>
@@ -137,6 +140,13 @@ class ControlDependenceGraph : public CDGBase<CFGType, CFGNodeType> {
 	CFGType *mCFG;
 };
 
+using SourceCDG=ControlDependenceGraph<SourceCFG, SourceCFGNode>;
+using IRCDGNode=CDGNode<llvm::Function, llvm::BasicBlock>;
+using DefaultIRCDGNode=DefaultCDGNode<llvm::Function, llvm::BasicBlock>;
+using EntryIRCDGNode=EntryCDGNode<llvm::Function, llvm::BasicBlock>;
+using IRCDGEdge=CDGEdge<llvm::Function, llvm::BasicBlock>;
+using IRCDG=ControlDependenceGraph<llvm::Function, llvm::BasicBlock>;
+
 }//namespace tsar
 
 namespace llvm {
@@ -281,4 +291,88 @@ using IRCDGPass=CDGPass<tsar::ControlDependenceGraph<Function, BasicBlock>>;
 
 };//namespace llvm
 
+namespace tsar {
+class ControlPDGEdge : public llvm::DDGEdge {
+public:
+	ControlPDGEdge(llvm::DDGNode &TargetNode) : llvm::DDGEdge(TargetNode, EdgeKind::Unknown) {}
+};
+
+class ProgramDependencyGraph  : public llvm::DataDependenceGraph {
+private:
+	using Base=llvm::DataDependenceGraph;
+	void construct(llvm::Function &F) {
+		//
+		for (auto INode : *this)
+			for (auto Edge : INode->getEdges())
+				assert(Edge->getKind()!=llvm::DDGEdge::EdgeKind::Unknown);
+		//
+		IRCDG *CDG=CDGBuilder<IRCDG>().populate(F);
+		std::map<llvm::Instruction*, llvm::DDGNode*> InstrMap;
+		for (auto INode : *this)
+			if (llvm::isa<llvm::SimpleDDGNode>(INode))
+				for (auto I : llvm::dyn_cast<llvm::SimpleDDGNode>(INode)->getInstructions())
+					InstrMap[I]=INode;
+		for (auto It : InstrMap)
+			if (It.first->isTerminator()) {
+				IRCDGNode *CDGNode=CDG->getNode(It.first->getParent());
+				for (auto CDGEdge : *CDGNode) {
+					//llvm::BasicBlock *TargetBB=(llvm::dyn_cast<DefaultIRCDGNode>(CDGEdge->getTargetNode())).getBlock();
+					llvm::BasicBlock *TargetBB=((DefaultIRCDGNode*)(&CDGEdge->getTargetNode()))->getBlock();
+					for (auto IIt=TargetBB->begin(); IIt!=TargetBB->end(); ++IIt)
+						connect(*InstrMap[It.first], *InstrMap[&(*IIt)], *(new ControlPDGEdge(*InstrMap[&(*IIt)])));
+				}
+			}
+		for (auto RootEdge : getRoot().getEdges())
+			delete RootEdge;
+		getRoot().clear();
+		for (auto CDGEdge : *(CDG->getEntryNode()))
+			//for (auto IIt=llvm::dyn_cast<DefaultIRCDGNode>(CDGEdge->getTargetNode()).getBlock()->begin();
+			for (auto IIt=((DefaultIRCDGNode*)(&CDGEdge->getTargetNode()))->getBlock()->begin();
+				//IIt!=llvm::dyn_cast<DefaultIRCDGNode>(&CDGEdge->getTargetNode())->getBlock()->end(); ++IIt)
+				IIt!=((DefaultIRCDGNode*)(&CDGEdge->getTargetNode()))->getBlock()->end(); ++IIt)
+				connect(getRoot(), *InstrMap[&(*IIt)], *(new ControlPDGEdge(*InstrMap[&(*IIt)])));
+		delete CDG;
+	}
+public:
+	ProgramDependencyGraph(llvm::Function &F, llvm::DependenceInfo &DI)
+			: Base(F, DI) {
+		construct(F);
+	}
+};
+}
+
+namespace llvm {
+template <>
+struct GraphTraits<tsar::ProgramDependencyGraph *> : public GraphTraits<DataDependenceGraph*> {};
+
+template <>
+struct GraphTraits<const tsar::ProgramDependencyGraph *> : public GraphTraits<const DataDependenceGraph*> {};
+
+template <>
+struct DOTGraphTraits<const tsar::ProgramDependencyGraph *> : public DOTGraphTraits<const DataDependenceGraph*> {
+private:
+	using GT=GraphTraits<const tsar::ProgramDependencyGraph *>;
+	using BaseDOTGT=DOTGraphTraits<const DataDependenceGraph*>;
+public:
+	DOTGraphTraits(bool isSimple=false) : BaseDOTGT(isSimple) {}
+
+	std::string getNodeLabel(const DDGNode *Node, const tsar::ProgramDependencyGraph *PDG) {
+		return BaseDOTGT::getNodeLabel(Node, PDG);
+	}
+
+	std::string getEdgeAttributes(const DDGNode *Node, typename GT::ChildIteratorType ChildNodeIt, const tsar::ProgramDependencyGraph *PDG) {
+		assert((*ChildNodeIt.getCurrent())->getKind()!=DDGEdge::EdgeKind::Rooted);
+		switch ((*ChildNodeIt.getCurrent())->getKind()) {
+			case DDGEdge::EdgeKind::Unknown:
+				return "style=\"dashed\"";
+			case DDGEdge::EdgeKind::RegisterDefUse:
+				return "style=\"solid\" color=\"blue\" "+BaseDOTGT::getEdgeAttributes(Node, ChildNodeIt, PDG);
+			case DDGEdge::EdgeKind::MemoryDependence:
+				return "style=\"solid\" color=\"green\" "+BaseDOTGT::getEdgeAttributes(Node, ChildNodeIt, PDG);
+		}
+	}
+};
+
+};
+
 #endif//TSAR_INCLUDE_BUILDPDG_H

lib/Analysis/PDG.cpp

@@ -10,6 +10,12 @@
 #include <set>
 #include <string>
 
+//
+#include "tsar/Analysis/Memory/DependenceAnalysis.h"
+#include <llvm/InitializePasses.h>
+//
+#include <llvm/Support/CommandLine.h>
+
 using namespace tsar;
 using namespace llvm;
 using namespace clang;
@@ -183,20 +189,40 @@ template<> char IRCDGPass::ID=0;
 
 INITIALIZE_PASS_BEGIN(IRCDGPass, "llvm-ir-cdg",
 	"Control Dependence Graph from IR", false, true)
+INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
 INITIALIZE_PASS_END(IRCDGPass, "llvm-ir-cdg",
 	"Control Dependence Graph from IR", false, true)
 
 FunctionPass *createIRCDGPass() { return new IRCDGPass; }
 
 template<>
 void IRCDGPass::getAnalysisUsage(AnalysisUsage &AU) const {
+	AU.addRequired<DependenceAnalysisWrapperPass>();
 	AU.setPreservesAll();    
 }
 
 template<>
 bool IRCDGPass::runOnFunction(Function &F) {
 	releaseMemory();
 	mCDG=mCDGBuilder.populate(F);
+	{
+		auto &DIPass=getAnalysis<DependenceAnalysisWrapperPass>();
+		/*May be useful*/
+		StringMap<cl::Option*> &OpMap=cl::getRegisteredOptions();
+		bool OldDDGSimplifyOpt=((cl::opt<bool>*)OpMap["ddg-simplify"])->getValue(),
+			OldDDGPiBlocksOpt=((cl::opt<bool>*)OpMap["ddg-pi-blocks"])->getValue();
+		((cl::opt<bool>*)OpMap["ddg-simplify"])->setValue(false);
+		((cl::opt<bool>*)OpMap["ddg-pi-blocks"])->setValue(false);
+		ProgramDependencyGraph PDG(F, DIPass.getDI());
+		dumpDotGraphToFile((const ProgramDependencyGraph*)&PDG, "pdg.dot", "program dependency graph");
+		DataDependenceGraph DDG(F, DIPass.getDI());
+		dumpDotGraphToFile((const DataDependenceGraph*)&DDG, "data-dependence-graph.dot", "data dependence graph", false);
+		((cl::opt<bool>*)OpMap["ddg-simplify"])->setValue(OldDDGSimplifyOpt);
+		((cl::opt<bool>*)OpMap["ddg-pi-blocks"])->setValue(OldDDGPiBlocksOpt);
+		DOTFuncInfo DOTCFGInfo(&F);
+		dumpDotGraphToFile(&DOTCFGInfo, "ircfg.dot", "control flow graph");
+	}
+	/**/
 	return false;
 }