???

Author: yukatan1701

include/tsar/Analysis/Memory/MemoryLocationRange.h

@@ -224,10 +224,14 @@ struct MemoryLocationRange {
       return *this;
     assert(UpperBound.hasValue() && "UpperBound must have a value!");
     auto FullSize = UpperBound.getValue();;
-    for (std::size_t I = 1; I < DimList.size(); ++I)
+    for (std::size_t I = 0; I < DimList.size(); ++I)
       FullSize *= DimList[I].DimSize;
+    if (FullSize == 0)
+      return *this;
     return MemoryLocationRange(Ptr, 0, LocationSize(FullSize), AATags);
   }
+  
+  void delinearize(const MemoryLocationRange &From);
 };
 
 /// \brief Finds an intersection between memory locations LHS and RHS.

include/tsar/Transform/IR/Passes.h

@@ -114,5 +114,11 @@ void initializeRedundantEdgeEliminationPassPass(PassRegistry &Registry);
 /// Create a pass that replaces the always true conditional branch
 /// instructions with an unconditional branch instruction.
 FunctionPass *createRedundantEdgeEliminationPass();
+
+/// TODO
+void initializeArrayIndexExtenderPassPass(PassRegistry &Registry);
+
+/// TODO
+Pass *createArrayIndexExtenderPass();
 }
 #endif//TSAR_IR_TRANSFORM_PASSES_H

lib/Analysis/Memory/DefinedMemory.cpp

@@ -278,7 +278,7 @@ std::pair<MemoryLocationRange, bool> aggregate(
   auto ArrayPtr = LocInfo.first;
   if (!ArrayPtr || !ArrayPtr->isDelinearized() || !LocInfo.second->isValid()) {
     //LLVM_DEBUG(dbgs() << "[AGGREGATE] Failed to delinearize location.\n");
-    /*LLVM_DEBUG(
+    LLVM_DEBUG(
       dbgs() << "[AGGREGATE] Failed to delinearize location: ";
       printLocationSource(dbgs(), Loc);
       dbgs() << ". Reason: ";
@@ -289,7 +289,54 @@ std::pair<MemoryLocationRange, bool> aggregate(
       else
         dbgs() << "!LocInfo.second->isValid()";
       dbgs() << "\n";
-    );*/
+    );
+    
+    // for cases like: <lhs, 240, 248> (Default)
+    // lhs[13][3][5][5]
+    /*if (!ArrayPtr) {
+      ArrayPtr = Fwk->getDelinearizeInfo()->findArray(Loc.Ptr, false);
+    }
+    auto Lower = Loc.LowerBound;
+    auto Upper = Loc.UpperBound;
+    if (ArrayPtr && Lower.hasValue() && Upper.hasValue()) {
+      LLVM_DEBUG(dbgs() << "Check plain location: "; printLocationSource(dbgs(), Loc); dbgs() << "\n";);
+      auto ArrayType{getPointerElementType(*ArrayPtr->getBase())};
+      auto ArraySizeInfo = arraySize(ArrayType);
+      if (ArraySizeInfo != std::make_tuple(0, 1, ArrayType)) {
+        LLVM_DEBUG(dbgs() << "Here.1\n");
+        auto LV = Lower.getValue();
+        auto UV = Upper.getValue();
+        auto ElemSize = Fwk->getDataLayout().getTypeStoreSize(
+            std::get<2>(ArraySizeInfo)).getFixedSize();
+        MemoryLocationRange FakeCollapsed;
+        FakeCollapsed.Ptr = nullptr;
+        FakeCollapsed.LowerBound = 0;
+        FakeCollapsed.UpperBound = ElemSize;
+        FakeCollapsed.SE = SE;
+        FakeCollapsed.Kind = LocKind::Collapsed;
+        auto DimN = ArrayPtr->getNumberOfDims();
+        FakeCollapsed.DimList.resize(DimN);
+        bool AreAllKnown = true;
+        for (size_t I = 0; I < DimN; ++I) {
+          auto DimSizeSCEV = ArrayPtr->getDimSize(I);
+          if (ArrayPtr->isKnownDimSize(I) && isa<SCEVConstant>(DimSizeSCEV)) {
+            auto &Dim = FakeCollapsed.DimList[I];
+            Dim.DimSize = cast<SCEVConstant>(DimSizeSCEV)->getAPInt().getZExtValue();
+            Dim.Start = Dim.End = Dim.Step = SE->getConstant(Type::getInt64Ty(SE->getContext()), 1);
+          } else {
+            AreAllKnown = false;
+            break;
+          }
+        }
+        if (AreAllKnown) {
+          LLVM_DEBUG(dbgs() << "Here.2\n");
+          ResLoc.delinearize(FakeCollapsed);
+          LLVM_DEBUG(dbgs() << "After collapsing: "; printLocationSource(dbgs(), ResLoc); dbgs() << "\n";);
+          return std::make_pair(ResLoc, true);
+        }
+      }
+      LLVM_DEBUG(dbgs() << "Here.3\n");
+    }*/
     ResLoc.Kind = LocKind::Default;
     return std::make_pair(ResLoc, true);
   }

lib/Analysis/Memory/MemoryLocationRange.cpp

@@ -183,9 +183,11 @@ void printSolutionInfo(llvm::raw_ostream &OS,
   }
 }
 #endif
+}
 
-void delinearize(const MemoryLocationRange &From, MemoryLocationRange &What) {
+void MemoryLocationRange::delinearize(const MemoryLocationRange &From) {
   typedef MemoryLocationRange::LocKind LocKind;
+  auto &What = *this;
   assert(!(What.Kind & LocKind::Collapsed) &&
       "It is forbidden to delinearize collapsed location!");
   if (What.Kind & LocKind::NonCollapsable || !(From.Kind & LocKind::Collapsed))
@@ -258,6 +260,7 @@ void delinearize(const MemoryLocationRange &From, MemoryLocationRange &What) {
   What.AM = From.AM;
 }
 
+namespace {
 llvm::Optional<MemoryLocationRange> intersectScalar(
     MemoryLocationRange LHS,
     MemoryLocationRange RHS,
@@ -1392,11 +1395,11 @@ llvm::Optional<MemoryLocationRange> intersect(
   if (!(LHS.Kind & LocKind::Collapsed) &&
       !(LHS.Kind & LocKind::NonCollapsable) &&
        (RHS.Kind & LocKind::Collapsed))
-    delinearize(RHS, LHS);
+    LHS.delinearize(RHS);
   if (!(RHS.Kind & LocKind::Collapsed) &&
       !(RHS.Kind & LocKind::NonCollapsable) &&
        (LHS.Kind & LocKind::Collapsed))
-    delinearize(LHS, RHS);
+    RHS.delinearize(LHS);
   if (!(LHS.Kind & LocKind::Collapsed) && !(RHS.Kind & LocKind::Collapsed))
     return intersectScalar(LHS, RHS, LC, RC);
   if (!(LHS.Kind & LocKind::Collapsed) || !(RHS.Kind & LocKind::Collapsed))
@@ -1407,8 +1410,9 @@ llvm::Optional<MemoryLocationRange> intersect(
       LHS.DimList == RHS.DimList)
     return LHS;
   MemoryLocationRange Int(LHS);
-  assert(LHS.SE && RHS.SE && LHS.SE == RHS.SE &&
-         "ScalarEvolution must be specified!");
+  assert(LHS.SE && RHS.SE && "ScalarEvolution must be specified!");
+  if (LHS.SE != RHS.SE)
+    return MemoryLocationRange();
   auto SE = LHS.SE;
   for (std::size_t I = 0; I < LHS.DimList.size(); ++I) {
     auto &Left = LHS.DimList[I];

lib/Core/Query.cpp

@@ -223,6 +223,7 @@ void addAfterLoopRotateAnalysis(legacy::PassManager &Passes) {
   Passes.add(createCallExtractorPass());
   Passes.add(createRedundantEdgeEliminationPass());
   Passes.add(createUnreachableBlockEliminationPass());
+  Passes.add(createArrayIndexExtenderPass());
   Passes.add(createGlobalDefinedMemoryPass());
   Passes.add(createGlobalLiveMemoryPass());
   Passes.add(createFunctionMemoryAttrsAnalysis());

lib/Core/Tool.cpp

@@ -178,6 +178,9 @@ struct Options : private bcl::Uncopyable {
   llvm::cl::OptionCategory TransformCategory;
   llvm::cl::opt<bool> NoFormat;
   llvm::cl::opt<std::string> OutputSuffix;
+  llvm::cl::opt<bool> ExtendArrayIndex;
+  llvm::cl::opt<bool> NoExtendArrayIndex;
+
 private:
   /// Default constructor.
   ///
@@ -338,6 +341,10 @@ Options::Options() :
   TransformCategory("Transformation options"),
   NoFormat("no-format", cl::cat(TransformCategory),
     cl::desc("Disable format of transformed sources")),
+  ExtendArrayIndex("fextend-array-index", cl::cat(TransformCategory),
+    cl::desc("Convert array indices to int64_t type")),
+  NoExtendArrayIndex("fno-extend-array-index", cl::cat(TransformCategory),
+    cl::desc("Do not convert array indices to int64_t type")),
   OutputSuffix("output-suffix", cl::cat(TransformCategory), cl::value_desc("suffix"),
     cl::desc("Filename suffix (between name and extension) for transformed sources")) {
   StringMap<cl::Option*> &Opts = cl::getRegisteredOptions();

lib/Transform/IR/CMakeLists.txt

@@ -1,6 +1,7 @@
 set(TRANSFORM_SOURCES Passes.cpp DeadCodeElimination.cpp InterprocAttr.cpp
   MetadataUtils.cpp Utils.cpp CallExtractor.cpp DependenceInliner.cpp
-  NoCaptureAnalysis.cpp PointerScalarizer.cpp RedundantEdgeElimination.cpp)
+  NoCaptureAnalysis.cpp PointerScalarizer.cpp RedundantEdgeElimination.cpp
+  ArrayIndexExtender.cpp)
 
 if(MSVC_IDE)
   file(GLOB_RECURSE TRANSFORM_HEADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}