Loop Distribution

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.4.3)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-project(TSAR VERSION 0.0.0 LANGUAGES CXX)
+project(TSAR VERSION 0.0.0 LANGUAGES C CXX)
 
 if(SAPFOR_VERSION)
   set(TSAR_VERSION ${SAPFOR_VERSION})
@@ -97,18 +97,21 @@ cmake_dependent_option(BUILD_LLC "Build LLVM IR static compiler" OFF
   "NOT PACKAGE_LLVM" OFF)
 cmake_dependent_option(BUILD_LINK "Build LLVM bitcode linker" OFF
   "NOT PACKAGE_LLVM" OFF)
-cmake_dependent_option(BUILD_FLANG "Build LLVM native Fortran compiler Flang" OFF UNIX OFF)
+cmake_dependent_option(BUILD_FLANG "Build LLVM native Fortran compiler Flang" OFF
+  "NOT PACKAGE_LLVM" OFF)
 
 option(TSAR_ENABLE_LLVM_DUMP "Enable use of dump() method for LLVM types" ON)
 
 set(LLVM_SOURCE_DIR "${LLVM_PROJECT_DIR}/llvm")
 set(CLANG_SOURCE_DIR "${LLVM_PROJECT_DIR}/clang")
 set(FLANG_SOURCE_DIR "${LLVM_PROJECT_DIR}/flang")
+set(MLIR_SOURCE_DIR "${LLVM_PROJECT_DIR}/mlir")
 set(COMPILER_RT_SOURCE_DIR "${LLVM_PROJECT_DIR}/compiler-rt")
 
 set(LLVM_BINARY_DIR "${CMAKE_BINARY_DIR}/llvm-build")
 set(CLANG_BINARY_DIR "${LLVM_BINARY_DIR}/tools/clang")
 set(FLANG_BINARY_DIR "${LLVM_BINARY_DIR}/tools/flang")
+set(MLIR_BINARY_DIR "${LLVM_BINARY_DIR}/tools/mlir")
 
 set(FLANG_FOUND OFF)
 
@@ -117,6 +120,7 @@ if(PACKAGE_LLVM)
   set(LLVM_SOURCE_DIR "${LLVM_BINARY_DIR}/include/llvm")
   set(CLANG_SOURCE_DIR "${LLVM_BINARY_DIR}/include/clang")
   set(FLANG_SOURCE_DIR "${LLVM_BINARY_DIR}/include/flang")
+  set(MLIR_SOURCE_DIR "${LLVM_BINARY_DIR}/include/mlir")
   set(CLANG_INCLUDE_DIR "${LLVM_BINARY_DIR}/lib/clang/${LLVM_VERSION}/include")
   set(CLANG_EXECUTABLE "${LLVM_BINARY_DIR}/bin/clang${CMAKE_EXECUTABLE_SUFFIX}")
   if (EXISTS ${FLANG_SOURCE_DIR})
@@ -144,14 +148,17 @@ else()
   if (BUILD_FLANG AND NOT EXISTS ${FLANG_SOURCE_DIR})
     message(FATAL_ERROR "FLANG_SOURCE_DIR '${FLANG_SOURCE_DIR}' does not exist")
   endif()
+  if (BUILD_FLANG AND NOT EXISTS ${MLIR_SOURCE_DIR})
+    message(FATAL_ERROR "MLIR_SOURCE_DIR '${MLIR_SOURCE_DIR}' does not exist")
+  endif()
   if (BUILD_PROFILE AND NOT EXISTS ${COMPILER_RT_SOURCE_DIR})
     message(FATAL_ERROR "COMPILER_RT_SOURCE_DIR '${COMPILER_RT_SOURCE_DIR}' does not exist")
   endif()
   set(LLVM_STATUS "Configuring LLVM project")
   message(STATUS ${LLVM_STATUS})
   set(LLVM_PROJECTS clang)
   if (BUILD_FLANG)
-    set(LLVM_PROJECTS ${LLVM_PROJECTS} flang)
+    set(LLVM_PROJECTS ${LLVM_PROJECTS} flang mlir)
   endif()
   if (BUILD_PROFILE)
     set(LLVM_PROJECTS ${LLVM_PROJECTS} compiler-rt)
@@ -205,7 +212,7 @@ message(STATUS ${LLVM_STATUS})
 set(LLVM_COMPONENTS
   analysis asmparser bitreader core instrumentation irreader scalaropts support
   tablegen target transformutils coverage mcparser option debuginfodwarf
-  frontendopenacc)
+  frontendopenacc lto windowsdriver)
 
 llvm_map_components_to_libnames(LLVM_LIBS ${LLVM_COMPONENTS})
 
@@ -226,7 +233,28 @@ set(CLANG_LIBS
 
 if(FLANG_FOUND)
   set(FLANG_LIBS
-    FortranSemantics FortranEvaluate FortranParser FortranDecimal FortranCommon)
+    flangFrontend FortranLower FortranSemantics FortranEvaluate FortranParser
+    FortranDecimal FortranCommon FIRCodeGen FIRTransforms FIRBuilder
+    FIRDialect FIRSupport MLIROpenMPToLLVM MLIROpenMPToLLVMIRTranslation
+    MLIRLLVMToLLVMIRTranslation MLIROpenACCDialect MLIROpenMPDialect
+    MLIRSCFToControlFlow MLIRFuncToLLVM MLIRArithmeticToLLVM MLIRControlFlowToLLVM
+    MLIRTargetLLVMIRExport MLIRDLTIDialect MLIRLLVMIRTransforms MLIRMemRefToLLVM
+    MLIRParser MLIRSCFDialect MLIRBufferizationDialect MLIRAffineDialect
+    MLIRVectorDialect MLIRMemRefDialect MLIRVectorInterfaces MLIRLLVMCommonConversion
+    MLIRTransforms MLIRLLVMDialect MLIRFuncDialect MLIRControlFlowDialect
+    MLIRTensorDialect MLIRArithmeticUtils MLIRComplexDialect
+    MLIRArithmeticDialect MLIRDialectUtils MLIRTransformUtils MLIRRewrite
+    MLIRPDLToPDLInterp MLIRPDLInterpDialect MLIRPDLDialect MLIRPass MLIRAnalysis
+    MLIRCallInterfaces MLIRControlFlowInterfaces MLIRInferTypeOpInterface
+    MLIRSideEffectInterfaces MLIRDataLayoutInterfaces MLIRViewLikeInterface
+    MLIRInferIntRangeInterface MLIRIR MLIRSupport)
+  include(TestBigEndian)
+  test_big_endian(IS_BIGENDIAN)
+  if (IS_BIGENDIAN)
+    add_compile_definitions(FLANG_BIG_ENDIAN=1)
+  else()
+    add_compile_definitions(FLANG_LITTLE_ENDIAN=1)
+  endif()
 endif()
 
 if(NOT PACKAGE_LLVM)
@@ -235,7 +263,21 @@ if(NOT PACKAGE_LLVM)
 endif()
 if(NOT PACKAGE_LLVM AND FLANG_FOUND)
   list(APPEND LLVM_INCLUDE_DIRS
-    ${FLANG_SOURCE_DIR}/include ${FLANG_BINARY_DIR}/include)
+    ${FLANG_SOURCE_DIR}/include ${FLANG_BINARY_DIR}/include
+    ${MLIR_SOURCE_DIR}/include ${MLIR_BINARY_DIR}/include)
+# TODO: LLVM specify include directories relative to build path, however
+# in case of SAPFOR build path is not a build path for LLVM.
+# Hence we manually add correct include directories for Flang libraries.
+  target_include_directories(obj.FIRBuilder SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FIRCodeGen SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FIRDialect SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FIRSupport SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FIRTransforms SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.flangFrontend SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.flangFrontendTool SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FortranLower SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(obj.FortranEvaluate SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
+  target_include_directories(flang-new SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
 endif()
 include_directories(${LLVM_INCLUDE_DIRS})
 
@@ -284,6 +326,9 @@ if (MSVC)
       add_compile_options("/MD")
     endif()
   endif()
+  if (MSVC_VERSION GREATER_EQUAL 1920)
+    add_compile_options("/Zc:__cplusplus")
+  endif()
 endif()
 
 foreach(C ${CMAKE_CONFIGURATION_TYPES})

cmake/llvm-utility.cmake

@@ -42,7 +42,7 @@ macro(sapfor_install_llvm)
   endif()
 
   if(BUILD_FLANG)
-    add_external_tool(FLANG_BUILD flang)
+    add_external_tool(FLANG_BUILD flang-new)
   endif()
 
   if(BUILD_PROFILE)

include/tsar/ADT/PersistentIterator.h

@@ -31,7 +31,7 @@
 #include <type_traits>
 
 namespace llvm {
-template<class T> struct DenseMapInfo;
+template<typename T, typename Enable> struct DenseMapInfo;
 }
 
 namespace tsar {
@@ -119,7 +119,7 @@ class NotPersistentIterator {
 template<class PersistentT, class MapT>
 class PersistentIteratorC {
   friend struct PersistentValueWrapper<PersistentT, MapT>;
-  friend struct llvm::DenseMapInfo<PersistentIteratorC>;
+  friend struct llvm::DenseMapInfo<PersistentIteratorC, void>;
   using NotPersistentIteratorC = NotPersistentIterator<true, PersistentT, MapT>;
 protected:
   using PersistentBucket = typename MapT::value_type;

include/tsar/Analysis/AST/Matcher.h

@@ -0,0 +1,155 @@
+//===-- Matcher.h --------- High and Low Level Matcher ----------*- C++ -*-===//
+//
+//                       Traits Static Analyzer (SAPFOR)
+//
+// Copyright 2022 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 defines general classes and functions to match some entities
+// (loops, variables, etc.) in a source high-level code and appropriate entities
+// (loops, allocas, etc.) in low-level LLVM IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAR_MATCHER_H
+#define TSAR_MATCHER_H
+
+#include "tsar/ADT/Bimap.h"
+#include "tsar/Support/DILocationMapInfo.h"
+#include "tsar/Support/Tags.h"
+#include "tsar/Support/MetadataUtils.h"
+#include <llvm/ADT/DenseMap.h>
+#include <llvm/ADT/SmallString.h>
+#include <llvm/ADT/Statistic.h>
+#include <llvm/ADT/TinyPtrVector.h>
+#include <llvm/IR/DebugInfoMetadata.h>
+
+namespace tsar {
+/// This is a base class which is inherited to match different entities (loops,
+/// variables, etc.).
+///
+/// The ImplTy class must inherit this class and implement following methods:
+/// - typename LocToIRMap::iterator findItrForLocation(ASTLocationTy Loc);
+/// - PresumedLocationTy getPresumedLocation(RawLocationTy Loc);
+/// Note, that tsar::PresumedLocationInfo<...> template must be specialized for
+/// the PresumedLocationTy type.
+template<typename ImplTy, typename IRItemTy, typename ASTItemTy,
+  typename ASTLocationTy,
+  typename IRLocationTy = llvm::DILocation *,
+  typename IRLocationMapInfo = DILocationMapInfo,
+  typename RawLocationTy = std::size_t,
+  typename RawLocationMapInfo = llvm::DenseMapInfo<RawLocationTy>,
+  typename MatcherTy = Bimap<
+    bcl::tagged<ASTItemTy, AST>, bcl::tagged<IRItemTy, IR>>,
+  typename UnmatchedASTSetTy = llvm::DenseSet<ASTItemTy>>
+class MatchASTBase {
+public:
+  using Matcher = MatcherTy;
+
+  using UnmatchedASTSet = UnmatchedASTSetTy;
+
+  /// This is a map from entity location to a queue of IR entities.
+  using LocToIRMap =
+      llvm::DenseMap<IRLocationTy,
+                     std::conditional_t<std::is_pointer_v<IRItemTy>,
+                                        llvm::TinyPtrVector<IRItemTy>,
+                                        llvm::SmallVector<IRItemTy, 1>>,
+                     IRLocationMapInfo>;
+
+  /// This is a map from location in a source file to an queue of AST
+  /// entities, which are associated with this location.
+  ///
+  /// The key in this map is a raw encoding for location.
+  using LocToASTMap =
+      llvm::DenseMap<RawLocationTy,
+                     std::conditional_t<std::is_pointer_v<ASTItemTy>,
+                                        llvm::TinyPtrVector<ASTItemTy>,
+                                        llvm::SmallVector<ASTItemTy, 1>>,
+                     RawLocationMapInfo>;
+
+  /// \brief Constructor.
+  ///
+  /// \param[in, out] M Representation of match.
+  /// \param[in, out] UM Storage for unmatched ast entities.
+  /// \param[in, out] LocToIR Map from entity location to a queue
+  /// of IR entities.
+  /// \param[in, out] LocToMacro A map form entity expansion location to a queue
+  /// of AST entities. All entities explicitly (not implicit loops) defined in
+  /// macros is going to store in this map. The key in this map is a raw
+  /// encoding for expansion location.
+  MatchASTBase(Matcher &M, UnmatchedASTSet &UM,
+    LocToIRMap &LocToIR, LocToASTMap &LocToMacro) :
+    mMatcher(&M), mUnmatchedAST(&UM),
+    mLocToIR(&LocToIR), mLocToMacro(&LocToMacro) {}
+
+  /// Finds low-level representation of an entity at the specified location.
+  ///
+  /// \return LLVM IR for an entity or `nullptr`.
+  IRItemTy findIRForLocation(ASTLocationTy Loc) {
+    auto LocItr = static_cast<ImplTy *>(this)->findItrForLocation(Loc);
+    if (LocItr == mLocToIR->end())
+      return nullptr;
+    auto Res = LocItr->second.back();
+    LocItr->second.pop_back();
+    return Res;
+  }
+
+  /// Evaluates entities located in macros.
+  ///
+  /// This matches entities from mLocToMacro and mLocToIR. It is recommended
+  /// to evaluate at first all entities outside macros and then consider macros
+  /// separately.
+  ///
+  /// \param [in] Strict If it is true, macros, containing exactly a single
+  /// item, are processed.
+  void matchInMacro(llvm::Statistic &NumMatch, llvm::Statistic &NumNonMatchAST,
+      llvm::Statistic &NumNonMatchIR, bool Strict = false) {
+    for (auto &InMacro : *mLocToMacro) {
+      auto PLoc{static_cast<ImplTy *>(this)->getPresumedLoc(InMacro.first)};
+      auto IREntityItr = mLocToIR->find_as(PLoc);
+      // If sizes of queues of AST and IR entities are not equal this is mean
+      // that there are implicit entities (for example, implicit loops) in
+      // a macro. Such entities are not going to be evaluated due to necessity
+      // of additional analysis of AST.
+      if (IREntityItr == mLocToIR->end() ||
+          IREntityItr->second.size() != InMacro.second.size() ||
+          Strict && InMacro.second.size() > 1) {
+        NumNonMatchAST += InMacro.second.size();
+        while (!InMacro.second.empty()) {
+          mUnmatchedAST->insert(InMacro.second.back());
+          InMacro.second.pop_back();
+        }
+      } else {
+        NumMatch += InMacro.second.size();
+        NumNonMatchIR -= InMacro.second.size();
+        while (!InMacro.second.empty()) {
+          mMatcher->emplace(InMacro.second.back(), IREntityItr->second.back());
+          InMacro.second.pop_back();
+          IREntityItr->second.pop_back();
+        }
+      }
+    }
+  }
+
+protected:
+  Matcher *mMatcher;
+  UnmatchedASTSet *mUnmatchedAST;
+  LocToIRMap *mLocToIR;
+  LocToASTMap *mLocToMacro;
+};
+}
+#endif//TSAR_MATCHER_H

include/tsar/Analysis/AnalysisServer.h

@@ -260,7 +260,7 @@ class AnalysisResponsePass : public ModulePass, private bcl::Uncopyable {
         WaitForRequest = false;
         return { tsar::AnalysisSocket::Notify };
       }
-      json::Parser<tsar::AnalysisRequest> Parser(Request);
+      ::json::Parser<tsar::AnalysisRequest> Parser(Request);
       tsar::AnalysisRequest R;
       if (!Parser.parse(R)) {
         llvm_unreachable("Unknown request: listen for analysis request!");
@@ -332,7 +332,7 @@ class AnalysisResponsePass : public ModulePass, private bcl::Uncopyable {
         }
       }
       return tsar::AnalysisSocket::Data +
-             json::Parser<tsar::AnalysisResponse>::unparseAsObject(Response);
+             ::json::Parser<tsar::AnalysisResponse>::unparseAsObject(Response);
     }))
       ;
     return false;

include/tsar/Analysis/AnalysisSocket.h

@@ -84,7 +84,7 @@ class AnalysisSocket final : public SMStringSocketBase<AnalysisSocket> {
   /// analysis pass. A `nullptr` could be encoded with empty string.
   void processResponse(const std::string &Response) const {
     llvm::StringRef Json(Response.data() + 1, Response.size() - 2);
-    json::Parser<AnalysisResponse> Parser(Json.str());
+    ::json::Parser<AnalysisResponse> Parser(Json.str());
     AnalysisResponse R;
     if (!Parser.parse(R))
       mAnalysis.clear();
@@ -103,7 +103,7 @@ class AnalysisSocket final : public SMStringSocketBase<AnalysisSocket> {
     R[AnalysisRequest::Function] = nullptr;
     bcl::TypeList<AnalysisType...>::for_each_type(PushBackAnalysisID{R});
     auto Request =
-        json::Parser<AnalysisRequest>::unparseAsObject(R) + Delimiter;
+        ::json::Parser<AnalysisRequest>::unparseAsObject(R) + Delimiter;
     for (auto &Callback : mReceiveCallbacks)
       Callback(Request);
     // Note, that callback run send() in client, so mAnalysisPass is already
@@ -130,7 +130,7 @@ class AnalysisSocket final : public SMStringSocketBase<AnalysisSocket> {
     R[AnalysisRequest::Function] = &F;
     bcl::TypeList<AnalysisType...>::for_each_type(PushBackAnalysisID{R});
     auto Request =
-        json::Parser<AnalysisRequest>::unparseAsObject(R) + Delimiter;
+        ::json::Parser<AnalysisRequest>::unparseAsObject(R) + Delimiter;
     for (auto &Callback : mReceiveCallbacks)
       Callback(Request);
     // Note, that callback run send() in client, so mAnalysisPass is already

include/tsar/Analysis/Clang/ExpressionMatcher.h

@@ -33,8 +33,8 @@
 #include <llvm/ADT/DenseSet.h>
 #include <llvm/Pass.h>
 
-#ifndef TSAR_EXPRESSION_MATCHER_H
-#define TSAR_EXPRESSION_MATCHER_H
+#ifndef TSAR_CLANG_EXPRESSION_MATCHER_H
+#define TSAR_CLANG_EXPRESSION_MATCHER_H
 
 namespace tsar {
 class ClangTransformationContext;
@@ -88,4 +88,4 @@ class ClangExprMatcherPass :
 
 }
 
-#endif//TSAR_EXPRESSION_MATCHER_H
+#endif//TSAR_CLANG_EXPRESSION_MATCHER_H

include/tsar/Analysis/Clang/IncludeTree.h

@@ -71,7 +71,7 @@ class FileNode {
     iterator() = default;
     iterator(ChildrenT::iterator I)
       : iterator_adaptor_base(std::move(I)) {}
-    ChildT &operator*() { return this->I->first; }
+    ChildT &operator*() const { return this->I->first; }
   };
 
   using iterator_range = llvm::iterator_range<iterator>;
@@ -211,10 +211,10 @@ class FileTree {
   public:
     iterator_impl() = default;
 
-    FileNode::ChildT & operator*() {
+    FileNode::ChildT & operator*() const {
       return FileNode::isDecl(*mRootItr) ? *mRootItr : **mChildItr;
     }
-    FileNode::ChildT * operator->() { return &operator*(); }
+    FileNode::ChildT * operator->() const { return &operator*(); }
 
     iterator &operator++() {
       if (FileNode::isDecl(*mRootItr)) {