[TSAR, Dep, Clang] Extract all induction variables from the IR-level representation of the analysis results.

Update interface of a Clang-level analysis to provide list of emitted diagnostics.

Author: kaniandr

include/tsar/Analysis/Clang/ASTDependenceAnalysis.h

@@ -28,6 +28,7 @@
 
 #include "tsar/Analysis/Clang/VariableCollector.h"
 #include "tsar/Analysis/Memory/DIMemoryTrait.h"
+#include "tsar/Support/Diagnostic.h"
 #include "tsar/Support/GlobalOptions.h"
 #include <bcl/tagged.h>
 #include <bcl/utility.h>
@@ -46,6 +47,17 @@ class ClangDependenceAnalyzer {
   using SortedVarListT = VariableCollector::SortedVarListT;
   using SortedVarMultiListT = VariableCollector::SortedVarMultiListT;
 
+private:
+  using DiagnosticId = decltype(tsar::diag::PADDING_BUILTIN_TSAR_DIAGNOSTIC);
+  struct DiagnosticT {
+    DiagnosticT(DiagnosticId Id) : Id(Id) {}
+    SortedVarMultiListT Source;
+    DiagnosticId Id;
+    bool IsPresent = false;
+  };
+  using DiagnosticListT = llvm::SmallVector<DiagnosticT, 8>;
+public:
+
   /// List of dependence distances.
   using DistanceInfo = bcl::tagged_tuple<
       bcl::tagged<trait::DIDependence::DistanceVector, trait::Flow>,
@@ -62,11 +74,13 @@ class ClangDependenceAnalyzer {
 
   /// Description of an induction variable and its bounds.
   using InductionInfo =
-      bcl::tagged_tuple<bcl::tagged<VariableT, trait::Induction>,
-                        bcl::tagged<trait::DIInduction::Constant, Begin>,
+      bcl::tagged_tuple<bcl::tagged<trait::DIInduction::Constant, Begin>,
                         bcl::tagged<trait::DIInduction::Constant, End>,
                         bcl::tagged<trait::DIInduction::Constant, Step>>;
 
+  /// List of induction variables.
+  using InductionVarListT = std::map<VariableT, InductionInfo, VariableLess>;
+
   /// List of traits.
   using ASTRegionTraitInfo =
       bcl::tagged_tuple<bcl::tagged<SortedVarListT, trait::Local>,
@@ -77,7 +91,7 @@ class ClangDependenceAnalyzer {
                         bcl::tagged<SortedVarListT, trait::WriteOccurred>,
                         bcl::tagged<ReductionVarListT, trait::Reduction>,
                         bcl::tagged<SortedVarDistanceT, trait::Dependence>,
-                        bcl::tagged<InductionInfo, trait::Induction>>;
+                        bcl::tagged<InductionVarListT, trait::Induction>>;
 
   ClangDependenceAnalyzer(clang::Stmt *Region, const GlobalOptions &GO,
       clang::DiagnosticsEngine &Diags, DIAliasTree &DIAT,
@@ -87,17 +101,23 @@ class ClangDependenceAnalyzer {
       mDIDepSet(DIDepSet), mDIMemoryMatcher(DIMemoryMatcher),
       mASTToClient(ASTToClient) {
     assert(Region && "Source-level region must not be null!");
-    mDependenceInfo.get<trait::Induction>().get<trait::Induction>() = {nullptr,
-                                                                       nullptr};
   }
 
-  bool evaluateDependency();
-  bool evaluateDefUse(SortedVarMultiListT *Errors = nullptr);
+  bool evaluateDependency(bool EmitDiags = true);
+  bool evaluateDefUse(bool EmitDiags = true);
 
   const ASTRegionTraitInfo & getDependenceInfo() const noexcept {
     return mDependenceInfo;
   }
 
+  const SortedVarMultiListT * hasDiagnostic(DiagnosticId Id) const {
+    auto I{llvm::find_if(mDiagList,
+                         [Id](auto &Diag) { return Diag.Id == Id; })};
+    if (I == mDiagList.end() || !I->IsPresent)
+      return nullptr;
+    return &I->Source;
+  }
+
   clang::DiagnosticsEngine &getDiagnostics() const noexcept {
     return mDiags;
   }
@@ -106,6 +126,14 @@ class ClangDependenceAnalyzer {
   const clang::Stmt *getRegion() const noexcept { return mRegion; }
 
 private:
+  unsigned findOrCreateDiagnosticInfo(DiagnosticId Id) {
+    auto I{llvm::find_if(mDiagList,
+                         [Id](auto &Diag) { return Diag.Id == Id; })};
+    if (I != mDiagList.end())
+      return std::distance(mDiagList.begin(), I);
+    mDiagList.emplace_back(Id);
+    return mDiagList.size() - 1;
+  }
   clang::Stmt *mRegion;
   const GlobalOptions &mGlobalOpts;
   clang::DiagnosticsEngine &mDiags;
@@ -118,6 +146,7 @@ class ClangDependenceAnalyzer {
   VariableCollector mASTVars;
   llvm::SmallVector<DIAliasTrait *, 32> mInToLocalize;
   llvm::SmallVector<DIAliasTrait *, 32> mOutToLocalize;
+  DiagnosticListT mDiagList;
 };
 }
 #endif//TSAR_CLANG_DEPENDENCE_ANALYZER_H

include/tsar/Transform/Clang/DVMHDirecitves.h

@@ -65,7 +65,11 @@ using ShadowVarListT =
                                           trait::DIDependence::DistanceVector>,
                               bcl::tagged<bool, Corner>>,
              ClangDependenceAnalyzer::VariableLess>;
-using InductionInfo = ClangDependenceAnalyzer::InductionInfo;
+using InductionInfo =
+    bcl::tagged_tuple<bcl::tagged<VariableT, trait::Induction>,
+                      bcl::tagged<trait::DIInduction::Constant, Begin>,
+                      bcl::tagged<trait::DIInduction::Constant, End>,
+                      bcl::tagged<trait::DIInduction::Constant, Step>>;
 
 class Template {
 public:

lib/APC/LoopInfo.cpp

@@ -352,32 +352,41 @@ void APCLoopInfoBasePass::runOnLoop(Loop &L, apc::LoopGraph &APCLoop) {
     ClangDependenceAnalyzer RegionAnalysis(
         const_cast<clang::ForStmt *>(ForStmt), *mGlobalOpts, Diags, DIAT,
         DIDepSet, *DIMemoryMatcher, ASTToClient);
-    if (RegionAnalysis.evaluateDependency()) {
+    if (RegionAnalysis.evaluateDependency() &&
+        RegionAnalysis.getDependenceInfo().get<trait::Induction>().size() ==
+            1) {
       auto &DepInfo{RegionAnalysis.getDependenceInfo()};
-      APCLoop.loopSymbol = DepInfo.get<trait::Induction>()
-                               .get<trait::Induction>()
-                               .get<AST>()
-                               ->getName()
-                               .str();
+      dvmh::InductionInfo BaseInduct;
+      BaseInduct.get<trait::Induction>() =
+          DepInfo.get<trait::Induction>().begin()->first;
+      BaseInduct.get<tsar::Begin>() =
+          DepInfo.get<trait::Induction>().begin()->second.get<tsar::Begin>();
+      BaseInduct.get<tsar::End>() =
+          DepInfo.get<trait::Induction>().begin()->second.get<tsar::End>();
+      BaseInduct.get<tsar::Step>() =
+          DepInfo.get<trait::Induction>().begin()->second.get<tsar::Step>();
+      APCLoop.loopSymbol =
+          BaseInduct.get<trait::Induction>().get<AST>()->getName().str();
       APCLoop.hasUnknownScalarDep = false;
       APCLoop.hasUnknownArrayDep = false;
-      auto *S{new apc::LoopStatement{F, LoopID, &APCLoop,
-                                     DepInfo.get<trait::Induction>()}};
+      auto *S{new apc::LoopStatement{F, LoopID, &APCLoop, BaseInduct}};
       APCLoop.loop = S;
       mAPCContext->addStatement(S);
       S->getTraits().get<trait::Private>() = DepInfo.get<trait::Private>();
       S->getTraits().get<trait::Local>() = DepInfo.get<trait::Local>();
       S->getTraits().get<trait::Reduction>() = DepInfo.get<trait::Reduction>();
-      dvmh::SortedVarMultiListT NotLocalized;
-      auto Localized{RegionAnalysis.evaluateDefUse(&NotLocalized)};
+      auto Localized{RegionAnalysis.evaluateDefUse()};
       S->setIsHostOnly(!Localized || ParallelInfoItr->second.isHostOnly());
       S->getTraits().get<trait::WriteOccurred>() =
           DepInfo.get<trait::WriteOccurred>();
       S->getTraits().get<trait::ReadOccurred>() =
           DepInfo.get<trait::ReadOccurred>();
       if (!Localized) {
-        S->getTraits().get<trait::WriteOccurred>().insert(NotLocalized.begin(),
-                                                          NotLocalized.end());
+        auto *NotLocalized{RegionAnalysis.hasDiagnostic(
+            tsar::diag::note_parallel_localize_inout_unable)};
+        assert(NotLocalized && "Source of a diagnostic must be available!");
+        S->getTraits().get<trait::WriteOccurred>().insert(NotLocalized->begin(),
+                                                          NotLocalized->end());
         S->getTraits().get<trait::ReadOccurred>() =
             S->getTraits().get<trait::WriteOccurred>();
       }