[TSAR, Transform] Remove the declaration of a function that does not have an implementation.

Author: yukatan1701

include/tsar/ADT/DataFlow.h

@@ -521,17 +521,17 @@ class SmallDFNode : private bcl::Uncopyable {
   void removeSuccessor(NodeTy *Node) { removeAdjacentNode(Node, SUCC); }
 
   /// Returns number of adjacent nodes in the specified direction.
-  size_type numberOfAdjacentNodes(Direction Dir) {
+  size_type numberOfAdjacentNodes(Direction Dir) const {
     assert(FIRST_DIRECTION <= Dir && Dir <= LAST_DIRECTION &&
       "Direction is out of range!");
     return mAdjacentNodes[Dir].size();
   }
 
   /// Returns number of successors for the specified node.
-  size_type numberOfSuccessors() { return numberOfAdjacentNodes(SUCC); }
+  size_type numberOfSuccessors() const { return numberOfAdjacentNodes(SUCC); }
 
   /// Returns number of predecessors for the specified node.
-  size_type numberOfPredecessors() { return numberOfAdjacentNodes(PRED); }
+  size_type numberOfPredecessors() const { return numberOfAdjacentNodes(PRED); }
 
 private:
   llvm::SmallVector<NodeTy *, N> mAdjacentNodes[NUMBER_DIRECTION];

include/tsar/ADT/ItemRegister.h

@@ -31,7 +31,6 @@
 #include <bcl/tagged.h>
 #include <bcl/utility.h>
 #include <llvm/ADT/DenseMap.h>
-#include <llvm/IR/Type.h>
 #include <type_traits>
 
 namespace tsar {

include/tsar/Analysis/AnalysisServer.h

@@ -96,7 +96,8 @@ class AnalysisServer : public ModulePass, private bcl::Uncopyable {
 
   /// Run server.
   bool runOnModule(Module &M) override {
-    auto &Socket = getAnalysis<AnalysisSocketImmutableWrapper>().get();
+    auto &SocketInfo = getAnalysis<AnalysisSocketImmutableWrapper>().get();
+    auto &Socket = SocketInfo.emplace(getPassID(), true).first->second;
     bcl::IntrusiveConnection::connect(
         &Socket, tsar::AnalysisSocket::Delimiter,
         [this, &M](bcl::IntrusiveConnection C) {

include/tsar/Analysis/AnalysisSocket.h

@@ -236,6 +236,82 @@ class AnalysisSocket final : public bcl::Socket<std::string> {
   mutable MessageKind mResponseKind;
   mutable std::vector<void *> mAnalysis;
 };
+
+/// This is a container to store sockets.
+class AnalysisSocketInfo {
+public:
+  using ServerToSocket = std::pair<llvm::AnalysisID, AnalysisSocket>;
+  using iterator = llvm::SmallVectorImpl<ServerToSocket>::iterator;
+  using const_iterator = llvm::SmallVectorImpl<ServerToSocket>::const_iterator;
+
+  /// Add new socket, return true on success and false if there is a socket
+  /// for a specified `ServerID` in the list.
+  std::pair<iterator, bool> emplace(llvm::AnalysisID ServerID, bool IsActive) {
+    auto Itr = find(ServerID);
+    if (Itr != end()) {
+      if (IsActive)
+        mActiveIdx = std::distance(mAnalysis.begin(), Itr) + 1;
+      return std::make_pair(Itr, false);
+    }
+    mAnalysis.emplace_back();
+    mAnalysis.back().first = ServerID;
+    if (IsActive)
+      mActiveIdx = size();
+    return std::make_pair(end() - 1, true);
+  }
+
+  iterator begin() { return mAnalysis.begin(); }
+  iterator end() { return mAnalysis.end(); }
+
+  const_iterator begin() const { return mAnalysis.begin(); }
+  const_iterator end() const { return mAnalysis.end(); }
+
+  /// Return socket to access a specified server.
+  iterator find(llvm::AnalysisID ServerID) {
+    return llvm::find_if(mAnalysis, [ServerID](const ServerToSocket &Info) {
+      return Info.first == ServerID;
+    });
+  }
+
+  /// Return socket to access a specified server.
+  const_iterator find(llvm::AnalysisID ServerID) const {
+    return llvm::find_if(mAnalysis, [ServerID](const ServerToSocket &Info) {
+      return Info.first == ServerID;
+    });
+  }
+
+  unsigned size() const { return mAnalysis.size(); }
+  bool empty() const { return mAnalysis.empty(); }
+  operator bool() const { return !empty(); }
+
+  /// Return socket to access a specified server, create a new socket if it is
+  /// not exist.
+  AnalysisSocket & operator[](llvm::AnalysisID ServerID) {
+    return emplace(ServerID, false).first->second;
+  }
+
+  iterator getActive() { return mAnalysis.begin() + mActiveIdx - 1; }
+  const_iterator getActive() const { return mAnalysis.begin() + mActiveIdx - 1; }
+
+  bool setActive(llvm::AnalysisID ServerID) {
+    auto Itr = find(ServerID);
+    if (Itr == end())
+      return false;
+    mActiveIdx = std::distance(mAnalysis.begin(), Itr) + 1;
+  }
+
+  AnalysisSocket * getActiveSocket() {
+    return getActive() == end() ? nullptr : &getActive()->second;
+  }
+
+  const AnalysisSocket * getActiveSocket() const {
+    return getActive() == end() ? nullptr : &getActive()->second;
+  }
+
+private:
+  llvm::SmallVector<ServerToSocket, 2> mAnalysis;
+  unsigned mActiveIdx = 0;
+};
 }
 
 namespace json {
@@ -328,7 +404,7 @@ JSON_DEFAULT_TRAITS(tsar::, AnalysisResponse)
 namespace llvm {
 /// Wrapper to allow client passes access analysis socket.
 using AnalysisSocketImmutableWrapper =
-  AnalysisWrapperPass<tsar::AnalysisSocket>;
+    AnalysisWrapperPass<tsar::AnalysisSocketInfo>;
 
 /// Wrapper to allow server passes access analysis connection.
 ///

include/tsar/Analysis/Clang/ASTDependenceAnalysis.h

@@ -0,0 +1,91 @@
+//===-- ASTDependenceAnalysis.h - Dependence Analyzer -- (Clang) -*- C++ -*===//
+//
+//                       Traits Static Analyzer (SAPFOR)
+//
+// Copyright 2020 DVM System Group
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements classes pass to perform source-level dependence
+// analysis.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAR_CLANG_DEPENDENCE_ANALYZER_H
+#define TSAR_CLANG_DEPENDENCE_ANALYZER_H
+
+#include "tsar/Analysis/Clang/VariableCollector.h"
+#include "tsar/Analysis/Memory/DIMemoryTrait.h"
+#include "tsar/Support/GlobalOptions.h"
+#include <bcl/tagged.h>
+#include <bcl/utility.h>
+#include <llvm/Pass.h>
+#include <array>
+#include <set>
+
+namespace tsar {
+class ClangDependenceAnalyzer {
+public:
+  using ClangDIMemoryMatcher = llvm::ClangDIMemoryMatcherPass::DIMemoryMatcher;
+
+  /// Sorted list of variables (to print their in algoristic order).
+  using SortedVarListT = std::set<std::string, std::less<std::string>>;
+
+  /// Lists of reduction variables.
+  using ReductionVarListT =
+      std::array<SortedVarListT, trait::DIReduction::RK_NumberOf>;
+
+  /// List of traits.
+  using ASTRegionTraitInfo =
+      bcl::tagged_tuple<bcl::tagged<SortedVarListT, trait::Private>,
+                        bcl::tagged<SortedVarListT, trait::FirstPrivate>,
+                        bcl::tagged<SortedVarListT, trait::LastPrivate>,
+                        bcl::tagged<SortedVarListT, trait::ReadOccurred>,
+                        bcl::tagged<SortedVarListT, trait::WriteOccurred>,
+                        bcl::tagged<ReductionVarListT, trait::Reduction>>;
+
+  ClangDependenceAnalyzer(clang::Stmt *Region, const GlobalOptions &GO,
+      clang::DiagnosticsEngine &Diags, DIAliasTree &DIAT,
+      DIDependenceSet &DIDepSet, ClonedDIMemoryMatcher &DIMemoryMatcher,
+      const ClangDIMemoryMatcher &ASTToClient)
+    : mRegion(Region), mGlobalOpts(GO), mDiags(Diags), mDIAT(DIAT),
+      mDIDepSet(DIDepSet), mDIMemoryMatcher(DIMemoryMatcher),
+      mASTToClient(ASTToClient) {
+    assert(Region && "Source-level region must not be null!");
+  }
+
+  bool evaluateDependency();
+  bool evaluateDefUse();
+
+  const ASTRegionTraitInfo & getDependenceInfo() const noexcept {
+    return mDependenceInfo;
+  }
+
+private:
+  clang::Stmt *mRegion;
+  const GlobalOptions &mGlobalOpts;
+  clang::DiagnosticsEngine &mDiags;
+  DIAliasTree &mDIAT;
+  DIDependenceSet &mDIDepSet;
+  ClonedDIMemoryMatcher &mDIMemoryMatcher;
+  const ClangDIMemoryMatcher &mASTToClient;
+  ASTRegionTraitInfo mDependenceInfo;
+
+  VariableCollector mASTVars;
+  llvm::SmallVector<DIAliasTrait *, 32> mInToLocalize;
+  llvm::SmallVector<DIAliasTrait *, 32> mOutToLocalize;
+};
+}
+#endif//TSAR_CLANG_DEPENDENCE_ANALYZER_H

include/tsar/Analysis/Clang/ControlFlowTraits.h

@@ -316,7 +316,7 @@ class RegionCFInfoBase {
   /// exist.
   std::pair<iterator, bool> insert_call(const FuncT &F, CFTraits &&T) {
     auto Info = mTraits.insert(std::move(T));
-    if (Info.second) {
+    if (F && Info.second) {
       auto &Calls = mCalls.try_emplace(F).first->second;
       Calls.emplace_back(Info.first);
     }

include/tsar/Analysis/Clang/Passes.h

@@ -109,5 +109,11 @@ void initializeClangCFTraitsPassPass(PassRegistry &Registry);
 /// Create an AST-level pass which collects control-flow traits
 /// for function and its loops.
 FunctionPass * createClangCFTraitsPass();
+
+// Initialize a pass to collect '#pragma spf region' directives.
+void initializeClangRegionCollectorPass(PassRegistry &Registry);
+
+// Create a pass to collect '#pragma spf region' directives.
+ModulePass * createClangRegionCollector();
 }
 #endif//TSAR_CLANG_ANALYSIS_PASSES_H