[TSAR, Transform] Fix client-server initialization error.

Author: yukatan1701

lib/Transform/Clang/LoopSwapping.cpp

@@ -81,6 +81,7 @@ using ClangLoopSwappingServerResponse = AnalysisResponsePass<
     GlobalsAAWrapperPass, DIMemoryTraitPoolWrapper, DIMemoryEnvironmentWrapper,
     ClangLoopSwappingServerProvider>;
 
+
 /// This provider access to function-level analysis results on client.
 using ClangLoopSwappingProvider =
   FunctionPassAAProvider<AnalysisSocketImmutableWrapper>;
@@ -235,16 +236,16 @@ class LoopVisitor : public RecursiveASTVisitor<LoopVisitor> {
   }
 
   void PrintLocations() {
-    outs() << "'for' loop locations:\n";
+    LLVM_DEBUG(dbgs() << "'for' loop locations:\n");
     for (auto locs: mRangePairs) {
       for (auto location : locs) {
         SourceLocation begin = location.getBegin();
         SourceLocation end = location.getEnd();
-        outs() << "Begin: ";
-        begin.print(outs(), mSrcMgr);
-        outs() << "; End: ";
-        end.print(outs(), mSrcMgr);
-        outs() << '\n';
+        LLVM_DEBUG(dbgs() << "Begin: ");
+        begin.print(dbgs(), mSrcMgr);
+        LLVM_DEBUG(dbgs() << "; End: ");
+        end.print(dbgs(), mSrcMgr);
+        LLVM_DEBUG(dbgs() << '\n');
       }
     }
   }
@@ -327,7 +328,6 @@ void ClangLoopSwapping::initializeProviderOnServer() {
       [DIMTraitPoolServer](DIMemoryTraitPoolWrapper &Wrapper) {
         Wrapper.set(**DIMTraitPoolServer);
       });
-      
   auto &GlobalsAAServer = R->value<GlobalsAAWrapperPass *>()->getResult();
   ClangLoopSwappingServerProvider::initialize<GlobalsAAResultImmutableWrapper>(
       [&GlobalsAAServer](GlobalsAAResultImmutableWrapper &Wrapper) {
@@ -348,7 +348,7 @@ void ClangLoopSwapping::releaseMemory() {
 
 bool ClangLoopSwapping::IsNoLoopID(MDNode *LoopID) {
   if (!LoopID || !(LoopID = getLoopID(LoopID))) {
-    LLVM_DEBUG(dbgs() << "[LOOP SWAPPING]: ignore loop without ID.");
+    dbgs() << "[LOOP SWAPPING]: ignore loop without ID.";
     return true;
   }
   return false;
@@ -359,30 +359,45 @@ std::vector<DIAliasNode *> ClangLoopSwapping::GetLoopNodes(MDNode *LoopID) {
   assert(DepItr != DIDepInfo->end() && "Loop must be analyzed!");
   auto &DIDepSet = DepItr->get<DIDependenceSet>();
   DenseSet<const DIAliasNode *> Coverage;
-  accessCoverage<bcl::SimpleInserter>(DIDepSet, *DIAT, Coverage,
-                                      mGlobalOpts->IgnoreRedundantMemory);
+  auto tmp = mGlobalOpts->IgnoreRedundantMemory;
+  auto &tmp2 = *DIAT;
+  dbgs() << "Here1\n";
+  accessCoverage<bcl::SimpleInserter>(DIDepSet, tmp2, Coverage,
+                                      tmp);
+  dbgs() << "Here2\n";                                    
   std::vector<DIAliasNode *> nodes;
   for (auto &TS : DIDepSet) {
     auto node = TS.getNode();
+    //TS.print(dbgs() << "[LOOP SWAPPING]: current node is: ");
     if (!Coverage.count(node))
       continue;
-    if (TS.is<trait::Readonly>()) {
-      outs() << "[LOOP SWAPPING]: readonly node found (" << TS.getNode() << ")\n";
+    MemoryDescriptor Dptr = TS;
+    if (Dptr.is<trait::Readonly>()) {
+      dbgs() << "[LOOP SWAPPING]: readonly node found (" << TS.getNode() << ")\n";
       continue;
     }
-    if (TS.is<trait::Reduction>()) {
-      outs() << "[LOOP SWAPPING]: reduction node found (" << TS.getNode() << ")\n";
+    if (Dptr.is<trait::Reduction>()) {
+      dbgs() << "[LOOP SWAPPING]: reduction node found (" << TS.getNode() << "); type: ";
+      auto I = TS.begin(), EI = TS.end();
+      auto *Red = (**I).get<trait::Reduction>();
+      auto Kind = Red->getKind();
+      if (!Red || Kind == trait::DIReduction::RK_NoReduction) {
+        dbgs() << "No Reduction\n";
+      } else if (Kind == trait::DIReduction::RK_Add) {
+        dbgs() << "Add\n";
+      } else if (Kind == trait::DIReduction::RK_Mult) {
+        dbgs() << "Mult\n";
+      }
       continue;
     }
-    if (TS.is<trait::Shared>()) {
-      outs() << "[LOOP SWAPPING]: shared node found (" << TS.getNode() << ")\n";
+    if (Dptr.is<trait::Shared>()) {
+      dbgs() << "[LOOP SWAPPING]: shared node found (" << TS.getNode() << ")\n";
       continue;
     }
-    /*
     if (TS.is<trait::Induction>()) {
-      outs() << "[LOOP SWAPPING]: induction node found (" << TS.getNode() << ")\n";
+      dbgs() << "[LOOP SWAPPING]: induction node found (" << TS.getNode() << ")\n";
       continue;
-    }*/
+    }
     nodes.push_back(const_cast<DIAliasNode *>(node));
   }
   return nodes;
@@ -395,15 +410,14 @@ bool ClangLoopSwapping::IsSwappingAvailable(std::vector<Loop *> loops) {
   auto *Loop0_ID = loop0->getLoopID();
   auto *Loop1_ID = loop1->getLoopID();
 
+
   if (IsNoLoopID(Loop0_ID) || IsNoLoopID(Loop1_ID)) {
-    outs() << "[LOOP SWAPPING]: No loop ID.\n";
+    dbgs() << "[LOOP SWAPPING]: No loop ID.\n";
     return false;
   }
-  
   std::vector<DIAliasNode *> nodes0 = GetLoopNodes(Loop0_ID);
   std::vector<DIAliasNode *> nodes1 = GetLoopNodes(Loop1_ID);
   SpanningTreeRelation<DIAliasTree *> STR(DIAT);
-  
   for (auto *node0: nodes0) {
     for (auto *node1: nodes1) {
       if (!STR.isUnreachable(node0, node1))
@@ -422,13 +436,12 @@ void ClangLoopSwapping::SwapLoops(const std::vector<std::vector<SourceRange>> &m
     std::vector<Loop *> loops = mLoopPairs[i];
 
     if (ranges.size() < 2) {
-      outs() << "[LOOP SWAPPING]: Too few loops for swap. Ignore.\n";
+      dbgs() << "[LOOP SWAPPING]: Too few loops for swap. Ignore.\n";
       continue;
     }
     if (ranges.size() > 2) {
-      outs() << "[LOOP SWAPPING]: Too many loops for swap. Ignore additional loops.\n";
+      dbgs() << "[LOOP SWAPPING]: Too many loops for swap. Ignore additional loops.\n";
     }
-    
     if (IsSwappingAvailable(loops)) {
       SourceRange first = ranges[0];
       SourceRange second = ranges[1];
@@ -437,7 +450,7 @@ void ClangLoopSwapping::SwapLoops(const std::vector<std::vector<SourceRange>> &m
       mRewriter.ReplaceText(first, second_loop);
       mRewriter.ReplaceText(second, first_loop);
     } else {
-      outs() << "[LOOP SWAPPING]: Failed to swap loops: shared memory\n";
+      dbgs() << "[LOOP SWAPPING]: Failed to swap loops: shared memory\n";
     }
   }
 }
@@ -459,7 +472,7 @@ bool ClangLoopSwapping::LoadDependenceAnalysisInfo(Function &F) {
     }
   }
   if (!DIAT || !DIDepInfo) {
-    LLVM_DEBUG(dbgs() << "[LOOP SWAPPING]: analysis server is not available\n");
+    dbgs() << "[LOOP SWAPPING]: analysis server is not available\n";
     if (auto *P = getAnalysisIfAvailable<DIEstimateMemoryPass>())
       DIAT = &P->getAliasTree();
     else
@@ -468,14 +481,13 @@ bool ClangLoopSwapping::LoadDependenceAnalysisInfo(Function &F) {
       DIDepInfo = &P->getDependencies();
     else
       return false;
-    LLVM_DEBUG(
-        dbgs() << "[LOOP SWAPPING]: use dependence analysis from client\n");
+    dbgs() << "[LOOP SWAPPING]: use dependence analysis from client\n";
   }
   return true;
 }
 
 bool ClangLoopSwapping::runOnFunction(Function &F) {
-  outs() << "test\n";
+  dbgs() << "test\n";
   auto *M = F.getParent();
   mTfmCtx = getAnalysis<TransformationEnginePass>().getContext(*M);
   if (!mTfmCtx || !mTfmCtx->hasInstance()) {
@@ -487,28 +499,23 @@ bool ClangLoopSwapping::runOnFunction(Function &F) {
   if (!FuncDecl)
     return false;
 
-  auto amSocket = &getAnalysis<AnalysisSocketImmutableWrapper>().get();
-  auto amMemoryMatcher = &getAnalysis<MemoryMatcherImmutableWrapper>().get();
-  auto amGlobalsAA = &getAnalysis<GlobalsAAWrapperPass>().getResult();
+  mSocket = &getAnalysis<AnalysisSocketImmutableWrapper>().get();
+  mMemoryMatcher = &getAnalysis<MemoryMatcherImmutableWrapper>().get();
+  mGlobalOpts = &getAnalysis<GlobalOptionsImmutableWrapper>().getOptions();
+  mGlobalsAA = &getAnalysis<GlobalsAAWrapperPass>().getResult();
   initializeProviderOnClient(*M);
   initializeProviderOnServer();
-  return false;
-
   if (!LoadDependenceAnalysisInfo(F))
     return false;
-  
-  mGlobalOpts = &getAnalysis<GlobalOptionsImmutableWrapper>().getOptions();
 
   auto &mLoopInfo = getAnalysis<LoopMatcherPass>().getMatcher();
   LoopVisitor lv(mTfmCtx->getRewriter(), mLoopInfo);
   lv.TraverseDecl(FuncDecl);
   lv.PrintLocations();
-
   std::vector<std::vector<SourceRange>> mRangePairs = lv.getRangePairs();
   std::vector<std::vector<Loop *>> mLoopPairs = lv.getLoopPairs();
 
-  auto &Provider = getAnalysis<ClangLoopSwappingProvider>(F);
-
+  //auto &Provider = getAnalysis<ClangLoopSwappingProvider>(F);
   SwapLoops(mRangePairs, mLoopPairs);
   return false;
 }
@@ -524,6 +531,8 @@ void ClangLoopSwapping::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<GlobalOptionsImmutableWrapper>();
   AU.addRequired<DIEstimateMemoryPass>();
   AU.addRequired<GlobalsAAWrapperPass>();
+  AU.addRequired<DIMemoryEnvironmentWrapper>();
+  AU.addRequired<DIMemoryTraitPoolWrapper>();
   AU.setPreservesAll();
 }
 
@@ -542,6 +551,7 @@ INITIALIZE_PASS(ClangLoopSwappingServerResponse, "clang-loop-swapping-response",
 char ClangLoopSwappingServer::ID = 0;
 INITIALIZE_PASS(ClangLoopSwappingServer, "clang-loop-swapping-server",
                 "Loop Swapping (Clang, Server)", false, false)
+                
 
 INITIALIZE_PROVIDER(ClangLoopSwappingProvider,
                     "clang-loop-swapping-provider",
@@ -561,6 +571,9 @@ INITIALIZE_PASS_DEPENDENCY(DIMemoryEnvironmentWrapper);
 INITIALIZE_PASS_DEPENDENCY(DIMemoryTraitPoolWrapper);
 INITIALIZE_PASS_DEPENDENCY(MemoryMatcherImmutableWrapper)
 INITIALIZE_PASS_DEPENDENCY(ClangLoopSwappingProvider);
+INITIALIZE_PASS_DEPENDENCY(AnalysisSocketImmutableWrapper);
+INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass);
+INITIALIZE_PASS_DEPENDENCY(GlobalsAAResultImmutableWrapper);
 INITIALIZE_PASS_DEPENDENCY(ClangLoopSwappingServerProvider);
 INITIALIZE_PASS_DEPENDENCY(ClangLoopSwappingServerResponse);
 INITIALIZE_PASS_IN_GROUP_END(ClangLoopSwapping,"clang-l-swap",