diff --git a/llvm/include/llvm/Analysis/Delinearization.h b/llvm/include/llvm/Analysis/Delinearization.h
index 434cfb61699d6..0dafac9102247 100644
--- a/llvm/include/llvm/Analysis/Delinearization.h
+++ b/llvm/include/llvm/Analysis/Delinearization.h
@@ -112,6 +112,13 @@ void delinearize(ScalarEvolution &SE, const SCEV *Expr,
                  SmallVectorImpl<const SCEV *> &Subscripts,
                  SmallVectorImpl<const SCEV *> &Sizes, const SCEV *ElementSize);
 
+/// Same as delinearize.  TODO: only use delinearize() instead of other internal
+/// functions.
+bool delinearizeUsingArrayInfo(ScalarEvolution &SE, const SCEV *AccessFn,
+                               SmallVectorImpl<const SCEV *> &Subscripts,
+                               SmallVectorImpl<const SCEV *> &Sizes,
+                               const SCEV *ElementSize);
+
 /// Compute the dimensions of fixed size array from \Expr and save the results
 /// in \p Sizes.
 bool findFixedSizeArrayDimensions(ScalarEvolution &SE, const SCEV *Expr,
@@ -155,6 +162,17 @@ bool getIndexExpressionsFromGEP(ScalarEvolution &SE,
                                 SmallVectorImpl<const SCEV *> &Subscripts,
                                 SmallVectorImpl<int> &Sizes);
 
+/// Compute access functions for each subscript in a delinearized array access.
+void computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+                            SmallVectorImpl<const SCEV *> &Subscripts,
+                            SmallVectorImpl<const SCEV *> &Sizes,
+                            const SCEV *ElementSize);
+
+/// Backward compatibility wrapper for computeAccessFunctions.
+void computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+                            SmallVectorImpl<const SCEV *> &Subscripts,
+                            SmallVectorImpl<const SCEV *> &Sizes);
+
 /// Implementation of fixed size array delinearization. Try to delinearize
 /// access function for a fixed size multi-dimensional array, by deriving
 /// subscripts from GEP instructions. Returns true upon success and false
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 4064b25d9d4e7..e6fe97385c240 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -14,15 +14,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/Delinearization.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionDivision.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
@@ -38,6 +41,10 @@ static cl::opt<bool> UseFixedSizeArrayHeuristic(
     cl::desc("When printing analysis, use the heuristic for fixed-size arrays "
              "if the default delinearizetion fails."));
 
+static cl::opt<bool> UseGEPToDelinearize(
+    "use-gep-to-delinearize", cl::init(true), cl::Hidden,
+    cl::desc("validate both delinearization methods match."));
+
 // Return true when S contains at least an undef value.
 static inline bool containsUndefs(const SCEV *S) {
   return SCEVExprContains(S, [](const SCEV *S) {
@@ -345,7 +352,8 @@ void llvm::findArrayDimensions(ScalarEvolution &SE,
 
 void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
                                   SmallVectorImpl<const SCEV *> &Subscripts,
-                                  SmallVectorImpl<const SCEV *> &Sizes) {
+                                  SmallVectorImpl<const SCEV *> &Sizes,
+                                  const SCEV *ElementSize) {
   // Early exit in case this SCEV is not an affine multivariate function.
   if (Sizes.empty())
     return;
@@ -354,6 +362,9 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
     if (!AR->isAffine())
       return;
 
+  if (ElementSize->isZero())
+    return;
+
   LLVM_DEBUG(dbgs() << "\ncomputeAccessFunctions\n"
                     << "Memory Access Function: " << *Expr << "\n");
 
@@ -362,10 +373,11 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
 
   for (int i = Last; i >= 0; i--) {
     const SCEV *Size = Sizes[i];
-    const SCEV *Q, *R;
+    if (Size->isZero())
+      continue;
 
+    const SCEV *Q, *R;
     SCEVDivision::divide(SE, Res, Size, &Q, &R);
-
     LLVM_DEBUG({
       dbgs() << "Computing 'MemAccFn / Sizes[" << i << "]':\n";
       dbgs() << "  MemAccFn: " << *Res << "\n";
@@ -373,7 +385,6 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
       dbgs() << "  Quotient (Leftover): " << *Q << "\n";
       dbgs() << "  Remainder (Subscript Access Function): " << *R << "\n";
     });
-
     Res = Q;
 
     // Do not record the last subscript corresponding to the size of elements in
@@ -394,9 +405,15 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
     Subscripts.push_back(R);
   }
 
-  // Also push in last position the remainder of the last division: it will be
-  // the access function of the innermost dimension.
-  Subscripts.push_back(Res);
+  // Also push in last position the quotient "Res = Q" of the last division: it
+  // will be the access function of the outermost array dimension.
+  if (!Res->isZero()) {
+    // This is only needed when the outermost array size is not known.  Res = 0
+    // when the outermost array dimension is known, as for example when reading
+    // array sizes from a local or global declaration.
+    Subscripts.push_back(Res);
+    LLVM_DEBUG(dbgs() << "Subscripts push_back Res: " << *Res << "\n");
+  }
 
   std::reverse(Subscripts.begin(), Subscripts.end());
 
@@ -408,6 +425,145 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
   });
 }
 
+/// Backward compatibility wrapper for the old 4-parameter version.
+void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+                                  SmallVectorImpl<const SCEV *> &Subscripts,
+                                  SmallVectorImpl<const SCEV *> &Sizes) {
+  if (Sizes.empty()) {
+    Subscripts.clear();
+    return;
+  }
+  // Use the element size from the last element in Sizes array (legacy behavior)
+  const SCEV *ElementSize = Sizes.back();
+  computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
+}
+
+/// Extract array dimensions from alloca or global variable declarations.
+/// Returns true if array dimensions were successfully extracted.
+static bool
+extractArrayInfoFromAllocaOrGlobal(ScalarEvolution &SE, Value *BasePtr,
+                                   SmallVectorImpl<const SCEV *> &Sizes,
+                                   const SCEV *ElementSize) {
+  // Clear output vector.
+  Sizes.clear();
+
+  LLVM_DEBUG(
+      dbgs() << "extractArrayInfoFromAllocaOrGlobal called with BasePtr: "
+             << *BasePtr << "\n");
+
+  // Distinguish between simple array accesses and complex pointer arithmetic.
+  // Only apply array_info extraction to direct array accesses to avoid
+  // incorrect delinearization of complex pointer arithmetic patterns.
+  if (auto *GEP = dyn_cast<GetElementPtrInst>(BasePtr)) {
+    // Check if this is a simple array access pattern: GEP [N x T]* @array, 0,
+    // idx This represents direct indexing like array[i], which should use array
+    // dimensions.
+    if (GEP->getNumIndices() == 2) {
+      auto *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
+      if (FirstIdx && FirstIdx->isZero()) {
+        // Simple array access: extract dimensions from the underlying array
+        // type
+        Value *Source = GEP->getPointerOperand()->stripPointerCasts();
+        return extractArrayInfoFromAllocaOrGlobal(SE, Source, Sizes,
+                                                  ElementSize);
+      }
+    }
+    // Complex GEPs like (&array[offset])[index] represent pointer arithmetic,
+    // not simple array indexing. These should be handled by parametric
+    // delinearization to preserve the linearized byte-offset semantics rather
+    // than treating them as multidimensional array accesses.
+    return false;
+  }
+
+  // Check if BasePtr is from an alloca instruction.
+  Type *ElementType = nullptr;
+  if (auto *AI = dyn_cast<AllocaInst>(BasePtr)) {
+    ElementType = AI->getAllocatedType();
+    LLVM_DEBUG(dbgs() << "Found alloca with type: " << *ElementType << "\n");
+  } else if (auto *GV = dyn_cast<GlobalVariable>(BasePtr)) {
+    ElementType = GV->getValueType();
+    LLVM_DEBUG(dbgs() << "Found global variable with type: " << *ElementType
+                      << "\n");
+  } else {
+    LLVM_DEBUG(dbgs() << "No alloca or global found for base pointer\n");
+    return false;
+  }
+
+  // Extract dimensions from nested array types.
+  Type *I64Ty = Type::getInt64Ty(SE.getContext());
+
+  while (auto *ArrayTy = dyn_cast<ArrayType>(ElementType)) {
+    uint64_t Size = ArrayTy->getNumElements();
+    const SCEV *SizeSCEV = SE.getConstant(I64Ty, Size);
+    Sizes.push_back(SizeSCEV);
+    ElementType = ArrayTy->getElementType();
+    LLVM_DEBUG(dbgs() << "  Found array dimension: " << Size << "\n");
+  }
+
+  if (Sizes.empty()) {
+    LLVM_DEBUG(dbgs() << "No array dimensions found in type\n");
+    return false;
+  }
+
+  // Add element size as the last element for computeAccessFunctions algorithm.
+  Sizes.push_back(ElementSize);
+
+  LLVM_DEBUG({
+    dbgs() << "Extracted array info from alloca/global for base pointer "
+           << *BasePtr << "\n";
+    dbgs() << "Dimensions: ";
+    for (const SCEV *Size : Sizes)
+      dbgs() << *Size << " ";
+    dbgs() << "\n";
+  });
+
+  return true;
+}
+
+bool llvm::delinearizeUsingArrayInfo(ScalarEvolution &SE, const SCEV *AccessFn,
+                                     SmallVectorImpl<const SCEV *> &Subscripts,
+                                     SmallVectorImpl<const SCEV *> &Sizes,
+                                     const SCEV *ElementSize) {
+  // Clear output vectors.
+  Subscripts.clear();
+  Sizes.clear();
+
+  const SCEVUnknown *BasePointer =
+      dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFn));
+  if (!BasePointer) {
+    LLVM_DEBUG(dbgs() << "no BasePointer for AccessFn: " << *AccessFn << "\n");
+    return false;
+  }
+
+  Value *BasePtr = BasePointer->getValue();
+
+  // Extract array dimensions from alloca or global declarations.
+  if (!extractArrayInfoFromAllocaOrGlobal(SE, BasePtr, Sizes, ElementSize))
+    return false;
+
+  // Get the full SCEV expression and subtract the base pointer to get
+  // offset-only expression.
+  const SCEV *Expr = SE.getMinusSCEV(AccessFn, BasePointer);
+
+  computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
+  if (Sizes.empty() || Subscripts.empty())
+    return false;
+
+  // Validate dimension consistency: subscripts should match array dimensions
+  // (Sizes includes element size as last element, so array dimensions =
+  // Sizes.size() - 1)
+  unsigned ArrayDims = Sizes.size() - 1;
+  if (Subscripts.size() != ArrayDims) {
+    LLVM_DEBUG(
+        dbgs() << "delinearizeUsingArrayInfo: Dimension mismatch - "
+               << Subscripts.size() << " subscripts for " << ArrayDims
+               << " array dimensions. Falling back to parametric method.\n");
+    return false;
+  }
+
+  return true;
+}
+
 /// Splits the SCEV into two vectors of SCEVs representing the subscripts and
 /// sizes of an array access. Returns the remainder of the delinearization that
 /// is the offset start of the array.  The SCEV->delinearize algorithm computes
@@ -461,21 +617,30 @@ void llvm::delinearize(ScalarEvolution &SE, const SCEV *Expr,
                        SmallVectorImpl<const SCEV *> &Subscripts,
                        SmallVectorImpl<const SCEV *> &Sizes,
                        const SCEV *ElementSize) {
-  // First step: collect parametric terms.
+  // Try array_info extraction.
+  if (delinearizeUsingArrayInfo(SE, Expr, Subscripts, Sizes, ElementSize))
+    return;
+  LLVM_DEBUG(dbgs() << "delinearize falling back to parametric method\n");
+
+  // Fall back to parametric delinearization.
+  if (const SCEVUnknown *BasePointer =
+          dyn_cast<SCEVUnknown>(SE.getPointerBase(Expr)))
+    Expr = SE.getMinusSCEV(Expr, BasePointer);
+
   SmallVector<const SCEV *, 4> Terms;
   collectParametricTerms(SE, Expr, Terms);
 
   if (Terms.empty())
     return;
 
-  // Second step: find subscript sizes.
+  // Find subscript sizes.
   findArrayDimensions(SE, Terms, Sizes, ElementSize);
 
   if (Sizes.empty())
     return;
 
-  // Third step: compute the access functions for each subscript.
-  computeAccessFunctions(SE, Expr, Subscripts, Sizes);
+  // Compute the access functions for each subscript.
+  computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
 }
 
 static std::optional<APInt> tryIntoAPInt(const SCEV *S) {
@@ -484,6 +649,21 @@ static std::optional<APInt> tryIntoAPInt(const SCEV *S) {
   return std::nullopt;
 }
 
+/// Convert cached SCEV sizes to int sizes for compatibility.
+/// TODO: Remove this after we remove GEP delinearization.
+static void convertSCEVSizesToIntSizes(ArrayRef<const SCEV *> SCEVSizes,
+                                       SmallVectorImpl<int> &Sizes) {
+  for (const SCEV *S : SCEVSizes) {
+    if (auto *Const = dyn_cast<SCEVConstant>(S)) {
+      const APInt &APVal = Const->getAPInt();
+      if (APVal.isSignedIntN(32)) {
+        int intValue = APVal.getSExtValue();
+        Sizes.push_back(intValue);
+      }
+    }
+  }
+}
+
 /// Collects the absolute values of constant steps for all induction variables.
 /// Returns true if we can prove that all step recurrences are constants and \p
 /// Expr is divisible by \p ElementSize. Each step recurrence is stored in \p
@@ -651,7 +831,7 @@ bool llvm::delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
     Sizes.push_back(SE.getConstant(Expr->getType(), Size));
 
   // Second step: compute the access functions for each subscript.
-  computeAccessFunctions(SE, Expr, Subscripts, Sizes);
+  computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
 
   return !Subscripts.empty();
 }
@@ -714,7 +894,128 @@ bool llvm::tryDelinearizeFixedSizeImpl(
   if (!SrcGEP)
     return false;
 
-  getIndexExpressionsFromGEP(*SE, SrcGEP, Subscripts, Sizes);
+  // When flag UseGEPToDelinearize is false, delinearize only using array_info.
+  if (!UseGEPToDelinearize) {
+    SmallVector<const SCEV *, 4> SCEVSizes;
+    const SCEV *ElementSize = SE->getElementSize(Inst);
+    if (!delinearizeUsingArrayInfo(*SE, AccessFn, Subscripts, SCEVSizes,
+                                   ElementSize))
+      return false;
+
+    // TODO: Remove the following code. Convert SCEV sizes to int sizes. This
+    // conversion is only needed as long as getIndexExpressionsFromGEP is still
+    // around. Remove this code and change the interface of
+    // tryDelinearizeFixedSizeImpl to take a SmallVectorImpl<const SCEV *>
+    // &Sizes.
+    convertSCEVSizesToIntSizes(SCEVSizes, Sizes);
+    return true;
+  }
+
+  // TODO: Remove all the following code once we are satisfied with array_info.
+  // Run both methods when UseGEPToDelinearize is true: validation is enabled.
+
+  // Store results from both methods.
+  SmallVector<const SCEV *, 4> GEPSubscripts, ArrayInfoSubscripts;
+  SmallVector<int, 4> GEPSizes, ArrayInfoSizes;
+
+  // GEP-based delinearization.
+  bool GEPSuccess =
+      getIndexExpressionsFromGEP(*SE, SrcGEP, GEPSubscripts, GEPSizes);
+
+  // Array_info delinearization.
+  SmallVector<const SCEV *, 4> SCEVSizes;
+  const SCEV *ElementSize = SE->getElementSize(Inst);
+  bool ArrayInfoSuccess = delinearizeUsingArrayInfo(
+      *SE, AccessFn, ArrayInfoSubscripts, SCEVSizes, ElementSize);
+
+  // TODO: Remove the following code. Convert SCEV sizes to int sizes. This
+  // conversion is only needed as long as getIndexExpressionsFromGEP is still
+  // around. Remove this code and change the interface of
+  // tryDelinearizeFixedSizeImpl to take a SmallVectorImpl<const SCEV *> &Sizes.
+  if (ArrayInfoSuccess)
+    convertSCEVSizesToIntSizes(SCEVSizes, ArrayInfoSizes);
+
+  // Validate consistency between methods.
+  LLVM_DEBUG({
+    if (GEPSuccess && ArrayInfoSuccess) {
+      // If both methods succeeded, validate they produce the same results.
+      // Compare sizes arrays.
+      if (GEPSizes.size() + 2 != ArrayInfoSizes.size()) {
+        dbgs() << "WARN: Size arrays have different lengths!\n";
+        dbgs() << "GEP sizes count: " << GEPSizes.size() << "\n"
+               << "ArrayInfo sizes count: " << ArrayInfoSizes.size() << "\n";
+      }
+
+      for (size_t I : seq<size_t>(GEPSizes.size())) {
+        if (GEPSizes[I] != ArrayInfoSizes[I + 1]) {
+          dbgs() << "WARN: Size arrays differ at index " << I << "!\n";
+          dbgs() << "GEP size[" << I << "]: " << GEPSizes[I] << "\n"
+                 << "ArrayInfo size[" << I + 1 << "]: " << ArrayInfoSizes[I + 1]
+                 << "\n";
+        }
+      }
+
+      // Compare subscripts arrays.
+      if (GEPSubscripts.size() != ArrayInfoSubscripts.size()) {
+        dbgs() << "WARN: Subscript arrays have different lengths!\n";
+        dbgs() << "  GEP subscripts count: " << GEPSubscripts.size() << "\n"
+               << "  ArrayInfo subscripts count: " << ArrayInfoSubscripts.size()
+               << "\n";
+
+        dbgs() << "  GEP subscripts:\n";
+        for (size_t I : seq<size_t>(GEPSubscripts.size()))
+          dbgs() << "    subscript[" << I << "]: " << *GEPSubscripts[I] << "\n";
+
+        dbgs() << "  ArrayInfo subscripts:\n";
+        for (size_t I : seq<size_t>(ArrayInfoSubscripts.size()))
+          dbgs() << "    subscript[" << I << "]: " << *ArrayInfoSubscripts[I]
+                 << "\n";
+      }
+
+      for (size_t I : seq<size_t>(GEPSubscripts.size())) {
+        const SCEV *GEPS = GEPSubscripts[I];
+        const SCEV *AIS = ArrayInfoSubscripts[I];
+        // FIXME: there's no good way to compare two scevs: don't abort, warn.
+        if (GEPS != AIS || !SE->getMinusSCEV(GEPS, AIS)->isZero()) {
+          dbgs() << "WARN: Subscript arrays differ at index " << I << "!\n";
+          dbgs() << "  GEP subscript[" << I << "]: " << *GEPSubscripts[I]
+                 << "\n"
+                 << "  ArrayInfo subscript[" << I
+                 << "]: " << *ArrayInfoSubscripts[I] << "\n";
+        }
+      }
+
+      dbgs() << "SUCCESS: Both delinearization methods produced "
+                "identical results\n";
+    } else if (GEPSuccess && !ArrayInfoSuccess) {
+      dbgs() << "WARNING: array_info failed and GEP analysis succeeded.\n";
+      dbgs() << "  Instruction: " << *Inst << "\n";
+      dbgs() << "  Using GEP analysis results despite array_info failure\n";
+    } else if (!GEPSuccess && ArrayInfoSuccess) {
+      dbgs() << "WARNING: GEP failed and array_info analysis succeeded.\n";
+      dbgs() << "  Instruction: " << *Inst << "\n";
+      dbgs() << "  Using array_info analysis results despite GEP failure\n";
+    } else if (!GEPSuccess && !ArrayInfoSuccess) {
+      dbgs() << "WARNING: both GEP and array_info analysis failed.\n";
+      dbgs() << "  Instruction: " << *Inst << "\n";
+    }
+  });
+
+  // Choose which result to use.
+  // Prefer array_info when available.
+  if (ArrayInfoSuccess) {
+    Subscripts = std::move(ArrayInfoSubscripts);
+    Sizes = std::move(ArrayInfoSizes);
+    return true;
+  }
+
+  // Both failed.
+  if (!GEPSuccess)
+    return false;
+
+  // Return GEP-based delinearization.
+  Subscripts = std::move(GEPSubscripts);
+  Sizes = std::move(GEPSizes);
 
   // Check that the two size arrays are non-empty and equal in length and
   // value.
@@ -759,51 +1060,63 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
     // Do not analyze memory accesses outside loops.
     if (!L)
       continue;
-
     const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
 
-    const SCEVUnknown *BasePointer =
-        dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
-    // Do not delinearize if we cannot find the base pointer.
-    if (!BasePointer)
-      break;
-    AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
-
     O << "\n";
     O << "Inst:" << Inst << "\n";
     O << "AccessFunction: " << *AccessFn << "\n";
 
     SmallVector<const SCEV *, 3> Subscripts, Sizes;
-
     auto IsDelinearizationFailed = [&]() {
-      return Subscripts.size() == 0 || Sizes.size() == 0 ||
-             Subscripts.size() != Sizes.size();
+      return Subscripts.empty() || Sizes.empty();
     };
 
-    delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
+    const SCEV *ElementSize = SE->getElementSize(&Inst);
+    delinearize(*SE, AccessFn, Subscripts, Sizes, ElementSize);
     if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
       Subscripts.clear();
       Sizes.clear();
+
+      const SCEVUnknown *BasePointer =
+          dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
+      // Fail to delinearize if we cannot find the base pointer.
+      if (!BasePointer)
+        continue;
+      AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
+
       delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
                                 SE->getElementSize(&Inst));
     }
 
-      if (IsDelinearizationFailed()) {
-        O << "failed to delinearize\n";
-        continue;
-      }
+    if (IsDelinearizationFailed()) {
+      O << "failed to delinearize\n";
+      continue;
+    }
 
-      O << "Base offset: " << *BasePointer << "\n";
-      O << "ArrayDecl[UnknownSize]";
-      int Size = Subscripts.size();
-      for (int i = 0; i < Size - 1; i++)
-        O << "[" << *Sizes[i] << "]";
-      O << " with elements of " << *Sizes[Size - 1] << " bytes.\n";
-
-      O << "ArrayRef";
-      for (int i = 0; i < Size; i++)
-        O << "[" << *Subscripts[i] << "]";
-      O << "\n";
+    O << "ArrayDecl";
+    // Print [Unknown] when the outermost dimension of the array is not known.
+    // Sizes[NumSizes - 1] is the array element size.
+    int NumSubscripts = Subscripts.size();
+    int NumSizes = Sizes.size();
+    if (NumSizes == NumSubscripts)
+      O << "[UnknownSize]";
+
+    // Handle different size relationships between Subscripts and Sizes.
+    if (NumSizes > 0) {
+      // Print array dimensions (all but the last, which is element size).
+      for (const SCEV *Size : ArrayRef(Sizes).drop_back())
+        O << "[" << *Size << "]";
+
+      // Print element size (last element in Sizes array).
+      O << " with elements of " << *Sizes[NumSizes - 1] << " bytes.\n";
+    } else {
+      O << " unknown sizes.\n";
+    }
+
+    O << "ArrayRef";
+    for (int i = 0; i < NumSubscripts; i++)
+      O << "[" << *Subscripts[i] << "]";
+    O << "\n";
   }
 }
 
diff --git a/llvm/lib/Analysis/LoopCacheAnalysis.cpp b/llvm/lib/Analysis/LoopCacheAnalysis.cpp
index 050c32707596a..13d2e56f27410 100644
--- a/llvm/lib/Analysis/LoopCacheAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopCacheAnalysis.cpp
@@ -405,9 +405,6 @@ bool IndexedReference::delinearize(const LoopInfo &LI) {
                                   << "', AccessFn: " << *AccessFn << "\n");
     }
 
-    AccessFn = SE.getMinusSCEV(AccessFn, BasePointer);
-
-    // Try to delinearize parametric-size arrays.
     if (!IsFixedSize) {
       LLVM_DEBUG(dbgs().indent(2) << "In Loop '" << L->getName()
                                   << "', AccessFn: " << *AccessFn << "\n");
@@ -415,6 +412,8 @@ bool IndexedReference::delinearize(const LoopInfo &LI) {
                         SE.getElementSize(&StoreOrLoadInst));
     }
 
+    AccessFn = SE.getMinusSCEV(AccessFn, BasePointer);
+
     if (Subscripts.empty() || Sizes.empty() ||
         Subscripts.size() != Sizes.size()) {
       // Attempt to determine whether we have a single dimensional array access.
diff --git a/llvm/test/Analysis/Delinearization/a.ll b/llvm/test/Analysis/Delinearization/a.ll
index 1830a3da77857..eee67b8ab4a2b 100644
--- a/llvm/test/Analysis/Delinearization/a.ll
+++ b/llvm/test/Analysis/Delinearization/a.ll
@@ -11,8 +11,7 @@
 define void @foo(i64 %n, i64 %m, i64 %o, ptr nocapture %A) #0 {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %arrayidx11.us.us, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll b/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll
new file mode 100644
index 0000000000000..df81378738141
--- /dev/null
+++ b/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll
@@ -0,0 +1,208 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
+; RUN: opt < %s -passes="print<delinearization>" -disable-output 2>&1 | FileCheck %s
+
+define void @test_alloca_2d() {
+; CHECK-LABEL: 'test_alloca_2d'
+; CHECK-NEXT:  Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {%arr,+,8}<nw><%for.cond>
+; CHECK-NEXT:  ArrayDecl[2500] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.cond>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: store double %mul, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {%arr,+,8}<nw><%for.cond>
+; CHECK-NEXT:  ArrayDecl[2500] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.cond>]
+;
+entry:
+  %arr = alloca [2500 x double], align 8
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %i.0 = phi i64 [ 0, %entry ], [ %inc, %for.inc ]
+  %cmp = icmp ult i64 %i.0, 2500
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %arrayidx = getelementptr inbounds [2500 x double], ptr %arr, i64 0, i64 %i.0
+  %0 = load double, ptr %arrayidx, align 8
+  %mul = fmul double %0, 2.000000e+00
+  store double %mul, ptr %arrayidx, align 8
+  br label %for.inc
+
+for.inc:                                          ; preds = %for.body
+  %inc = add nuw nsw i64 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret void
+}
+
+define void @test_alloca_3d() {
+; CHECK-LABEL: 'test_alloca_3d'
+; CHECK-NEXT:  Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%arr,+,4800}<nw><%for.i>,+,240}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT:  ArrayDecl[10][20][30] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: store double %mul, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%arr,+,4800}<nw><%for.i>,+,240}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT:  ArrayDecl[10][20][30] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
+entry:
+  %arr = alloca [10 x [20 x [30 x double]]], align 8
+  br label %for.i
+
+for.i:                                            ; preds = %for.i.inc, %entry
+  %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+  %i.cmp = icmp ult i64 %i.0, 10
+  br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j:                                            ; preds = %for.j.inc, %for.i
+  %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+  %j.cmp = icmp ult i64 %j.0, 20
+  br i1 %j.cmp, label %for.k, label %for.j.end
+
+for.k:                                            ; preds = %for.k.inc, %for.j
+  %k.0 = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
+  %k.cmp = icmp ult i64 %k.0, 30
+  br i1 %k.cmp, label %for.body, label %for.k.end
+
+for.body:                                         ; preds = %for.k
+  %arrayidx = getelementptr inbounds [10 x [20 x [30 x double]]], ptr %arr, i64 0, i64 %i.0, i64 %j.0, i64 %k.0
+  %0 = load double, ptr %arrayidx, align 8
+  %mul = fmul double %0, 2.000000e+00
+  store double %mul, ptr %arrayidx, align 8
+  br label %for.k.inc
+
+for.k.inc:                                        ; preds = %for.body
+  %k.inc = add nuw nsw i64 %k.0, 1
+  br label %for.k
+
+for.k.end:                                        ; preds = %for.k
+  br label %for.j.inc
+
+for.j.inc:                                        ; preds = %for.k.end
+  %j.inc = add nuw nsw i64 %j.0, 1
+  br label %for.j
+
+for.j.end:                                        ; preds = %for.j
+  br label %for.i.inc
+
+for.i.inc:                                        ; preds = %for.j.end
+  %i.inc = add nuw nsw i64 %i.0, 1
+  br label %for.i
+
+for.i.end:                                        ; preds = %for.i
+  ret void
+}
+
+; Global 3D array similar to what flang generates.
+@global_3d_array = local_unnamed_addr global [54 x [54 x [54 x double]]] zeroinitializer
+
+define void @test_global_3d() {
+; CHECK-LABEL: 'test_global_3d'
+; CHECK-NEXT:  Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}@global_3d_array,+,23328}<nw><%for.i>,+,432}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT:  ArrayDecl[54][54][54] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: store double %mul, ptr %arrayidx, align 8
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}@global_3d_array,+,23328}<nw><%for.i>,+,432}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT:  ArrayDecl[54][54][54] with elements of 8 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
+entry:
+  br label %for.i
+
+for.i:                                            ; preds = %for.i.inc, %entry
+  %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+  %i.cmp = icmp ult i64 %i.0, 54
+  br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j:                                            ; preds = %for.j.inc, %for.i
+  %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+  %j.cmp = icmp ult i64 %j.0, 54
+  br i1 %j.cmp, label %for.k, label %for.j.end
+
+for.k:                                            ; preds = %for.k.inc, %for.j
+  %k.0 = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
+  %k.cmp = icmp ult i64 %k.0, 54
+  br i1 %k.cmp, label %for.body, label %for.k.end
+
+for.body:                                         ; preds = %for.k
+  %arrayidx = getelementptr inbounds [54 x [54 x [54 x double]]], ptr @global_3d_array, i64 0, i64 %i.0, i64 %j.0, i64 %k.0
+  %0 = load double, ptr %arrayidx, align 8
+  %mul = fmul double %0, 3.000000e+00
+  store double %mul, ptr %arrayidx, align 8
+  br label %for.k.inc
+
+for.k.inc:                                        ; preds = %for.body
+  %k.inc = add nuw nsw i64 %k.0, 1
+  br label %for.k
+
+for.k.end:                                        ; preds = %for.k
+  br label %for.j.inc
+
+for.j.inc:                                        ; preds = %for.k.end
+  %j.inc = add nuw nsw i64 %j.0, 1
+  br label %for.j
+
+for.j.end:                                        ; preds = %for.j
+  br label %for.i.inc
+
+for.i.inc:                                        ; preds = %for.j.end
+  %i.inc = add nuw nsw i64 %i.0, 1
+  br label %for.i
+
+for.i.end:                                        ; preds = %for.i
+  ret void
+}
+
+define void @test_0() {
+; CHECK-LABEL: 'test_0'
+; CHECK-NEXT:  Inst: %0 = load i32, ptr %arrayidx, align 4
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%matrix,+,200}<nw><%for.i>,+,4}<nw><%for.j>
+; CHECK-NEXT:  ArrayDecl[100][50] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: store i32 %add, ptr %arrayidx, align 4
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%matrix,+,200}<nw><%for.i>,+,4}<nw><%for.j>
+; CHECK-NEXT:  ArrayDecl[100][50] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+;
+entry:
+  %matrix = alloca [100 x [50 x i32]], align 4
+  br label %for.i
+
+for.i:                                            ; preds = %for.i.inc, %entry
+  %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+  %i.cmp = icmp ult i64 %i.0, 100
+  br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j:                                            ; preds = %for.j.inc, %for.i
+  %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+  %j.cmp = icmp ult i64 %j.0, 50
+  br i1 %j.cmp, label %for.body, label %for.j.end
+
+for.body:                                         ; preds = %for.j
+  %arrayidx = getelementptr inbounds [100 x [50 x i32]], ptr %matrix, i64 0, i64 %i.0, i64 %j.0
+  %0 = load i32, ptr %arrayidx, align 4
+  %add = add nsw i32 %0, 1
+  store i32 %add, ptr %arrayidx, align 4
+  br label %for.j.inc
+
+for.j.inc:                                        ; preds = %for.body
+  %j.inc = add nuw nsw i64 %j.0, 1
+  br label %for.j
+
+for.j.end:                                        ; preds = %for.j
+  br label %for.i.inc
+
+for.i.inc:                                        ; preds = %for.j.end
+  %i.inc = add nuw nsw i64 %i.0, 1
+  br label %for.i
+
+for.i.end:                                        ; preds = %for.i
+  ret void
+}
diff --git a/llvm/test/Analysis/Delinearization/array_info_delinearization.ll b/llvm/test/Analysis/Delinearization/array_info_delinearization.ll
new file mode 100644
index 0000000000000..9d5fca396e1b3
--- /dev/null
+++ b/llvm/test/Analysis/Delinearization/array_info_delinearization.ll
@@ -0,0 +1,44 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
+
+@test_array_10x20 = global [10 x [20 x i32]] zeroinitializer
+
+; Function that accesses a 2D array with dimensions [10][20].
+define void @test_2d_array(i64 %i, i64 %j) {
+; CHECK-LABEL: 'test_2d_array'
+; CHECK-NEXT:  Inst: %val = load i32, ptr %ptr, align 4
+; CHECK-NEXT:  AccessFunction: {{\{\{}}@test_array_10x20,+,80}<nw><%for.i>,+,4}<%for.j>
+; CHECK-NEXT:  ArrayDecl[10][20] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+;
+entry:
+  %arr = getelementptr inbounds [10 x [20 x i32]], ptr @test_array_10x20, i32 0, i32 0
+  br label %for.i
+
+for.i:                                            ; preds = %for.j.end, %entry
+  %i.cur = phi i64 [ 0, %entry ], [ %i.next, %for.j.end ]
+  %i.cmp = icmp slt i64 %i.cur, 10
+  br i1 %i.cmp, label %for.j, label %exit
+
+for.j:                                            ; preds = %for.j, %for.i
+  %j.cur = phi i64 [ 0, %for.i ], [ %j.next, %for.j ]
+
+  ; Compute linear access: arr[i][j] = arr + i*20 + j
+  %i.mul = mul i64 %i.cur, 20
+  %idx = add i64 %i.mul, %j.cur
+  %ptr = getelementptr inbounds i32, ptr %arr, i64 %idx
+
+  ; Load from the computed address
+  %val = load i32, ptr %ptr, align 4
+
+  %j.next = add i64 %j.cur, 1
+  %j.cmp = icmp slt i64 %j.next, 20
+  br i1 %j.cmp, label %for.j, label %for.j.end
+
+for.j.end:                                        ; preds = %for.j
+  %i.next = add i64 %i.cur, 1
+  br label %for.i
+
+exit:                                             ; preds = %for.i
+  ret void
+}
diff --git a/llvm/test/Analysis/Delinearization/byte_offset.ll b/llvm/test/Analysis/Delinearization/byte_offset.ll
index 743dcfcca6400..b17082dd3e31a 100644
--- a/llvm/test/Analysis/Delinearization/byte_offset.ll
+++ b/llvm/test/Analysis/Delinearization/byte_offset.ll
@@ -13,7 +13,7 @@
 define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store float 0.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT:  AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
+; CHECK-NEXT:  AccessFunction: ({%A,+,%i2}<%outer.loop> + %unknown)
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
diff --git a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
index 0c0fb4170b148..a3e4165d72c2f 100644
--- a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
+++ b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
@@ -7,14 +7,12 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 define void @mat_mul(ptr %C, ptr %A, ptr %B, i64 %N) #0 !kernel_arg_addr_space !2 !kernel_arg_access_qual !3 !kernel_arg_type !4 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
 ; CHECK-LABEL: 'mat_mul'
 ; CHECK-NEXT:  Inst: %tmp = load float, ptr %arrayidx, align 4
-; CHECK-NEXT:  AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {((4 * %N * %call) + %A),+,4}<%for.inc>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %tmp5 = load float, ptr %arrayidx4, align 4
-; CHECK-NEXT:  AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
-; CHECK-NEXT:  Base offset: %B
+; CHECK-NEXT:  AccessFunction: {((4 * %call1) + %B),+,(4 * %N)}<%for.inc>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
 ;
diff --git a/llvm/test/Analysis/Delinearization/divide_by_one.ll b/llvm/test/Analysis/Delinearization/divide_by_one.ll
index e812e65ba7fd7..e01fd56beff95 100644
--- a/llvm/test/Analysis/Delinearization/divide_by_one.ll
+++ b/llvm/test/Analysis/Delinearization/divide_by_one.ll
@@ -14,14 +14,12 @@ target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
 define void @test(ptr nocapture %dst, i32 %stride, i32 %bs) {
 ; CHECK-LABEL: 'test'
 ; CHECK-NEXT:  Inst: %0 = load i8, ptr %arrayidx, align 1
-; CHECK-NEXT:  AccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK-NEXT:  Base offset: %dst
+; CHECK-NEXT:  AccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride) + %dst),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
 ; CHECK-NEXT:  ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i8 %0, ptr %arrayidx7, align 1
-; CHECK-NEXT:  AccessFunction: {{\{\{}}(%stride * %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nsw><%for.body3>
-; CHECK-NEXT:  Base offset: %dst
+; CHECK-NEXT:  AccessFunction: {{\{\{}}((%stride * %bs) + %dst),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
 ; CHECK-NEXT:  ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/fixed_size_array.ll b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
index cecd1eacb1437..0c10706a3295d 100644
--- a/llvm/test/Analysis/Delinearization/fixed_size_array.ll
+++ b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
@@ -11,8 +11,7 @@
 define void @a_i_j_k(ptr %a) {
 ; CHECK-LABEL: 'a_i_j_k'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
 ;
@@ -59,8 +58,7 @@ exit:
 define void @a_i_nj_k(ptr %a) {
 ; CHECK-LABEL: 'a_i_nj_k'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}896,+,1024}<nuw><nsw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(896 + %a),+,1024}<nw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{7,+,-1}<nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
 ;
@@ -114,14 +112,12 @@ exit:
 define void @a_ijk_b_i2jk(ptr %a, ptr %b) {
 ; CHECK-LABEL: 'a_ijk_b_i2jk'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %a.idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 1, ptr %b.idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %b
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%b,+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
 ;
@@ -176,8 +172,7 @@ exit:
 define void @a_i_2j1_k(ptr %a) {
 ; CHECK-LABEL: 'a_i_2j1_k'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}128,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(128 + %a),+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><%for.j.header>][{32,+,1}<nw><%for.k>]
 ;
@@ -229,7 +224,7 @@ exit:
 define void @a_i_3j_k(ptr %a) {
 ; CHECK-LABEL: 'a_i_3j_k'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
@@ -280,8 +275,7 @@ exit:
 define void @a_i_j_3k(ptr %a) {
 ; CHECK-LABEL: 'a_i_j_3k'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,3}<nuw><nsw><%for.k>]
 ;
@@ -331,7 +325,7 @@ exit:
 define void @a_i_j2k_i(ptr %a) {
 ; CHECK-LABEL: 'a_i_j2k_i'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
@@ -382,8 +376,7 @@ exit:
 define void @a_i_i_jk(ptr %a) {
 ; CHECK-LABEL: 'a_i_i_jk'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][288] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k>]
 ;
@@ -432,8 +425,7 @@ exit:
 define void @a_i_jk_l(ptr %a) {
 ; CHECK-LABEL: 'a_i_jk_l'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,128}<nw><%for.k.header>,+,4}<nw><%for.l>
-; CHECK-NEXT:  Base offset: %a
+; CHECK-NEXT:  AccessFunction: {{\{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,128}<nw><%for.k.header>,+,4}<nw><%for.l>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k.header>][{0,+,1}<nuw><nsw><%for.l>]
 ;
@@ -492,7 +484,7 @@ exit:
 define void @non_divisible_by_element_size(ptr %a) {
 ; CHECK-LABEL: 'non_divisible_by_element_size'
 ; CHECK-NEXT:  Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%a,+,256}<nw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
diff --git a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
index a5af30011f487..74f4d29a2383b 100644
--- a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
+++ b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
@@ -29,115 +29,115 @@
 define i32 @fn2() {
 ; CHECK-LABEL: 'fn2'
 ; CHECK-NEXT:  Inst: store i32 %storemerge.i, ptr @a, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @a
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %9 = load i8, ptr %arrayidx.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %10 = load i8, ptr %arrayidx.1.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.1.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.1.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %11 = load i8, ptr %arrayidx.2.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.2.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.2.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %12 = load i8, ptr %arrayidx.3.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.3.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.3.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %13 = load i8, ptr %arrayidx.4.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.4.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.4.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %14 = load i8, ptr %arrayidx.5.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.5.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.5.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %15 = load i8, ptr %arrayidx.6.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.6.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.6.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %16 = load i8, ptr %arrayidx.7.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.7.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.7.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %21 = load i8, ptr %arrayidx.ur.i, align 1
-; CHECK-NEXT:  AccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64)
+; CHECK-NEXT:  AccessFunction: ((sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64) + %3)
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %conv.ur.i, ptr @c, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @c
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i32 %inc.ur.i, ptr @b, align 4
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: @b
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
diff --git a/llvm/test/Analysis/Delinearization/himeno_1.ll b/llvm/test/Analysis/Delinearization/himeno_1.ll
index 5ae5d04505b8c..8163b8b7fdb59 100644
--- a/llvm/test/Analysis/Delinearization/himeno_1.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_1.ll
@@ -32,8 +32,7 @@
 define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
 ; CHECK-LABEL: 'jacobi'
 ; CHECK-NEXT:  Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
-; CHECK-NEXT:  Base offset: %a.base
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/himeno_2.ll b/llvm/test/Analysis/Delinearization/himeno_2.ll
index 75e4f027c4c6c..06931f2ff397d 100644
--- a/llvm/test/Analysis/Delinearization/himeno_2.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_2.ll
@@ -32,8 +32,7 @@
 define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
 ; CHECK-LABEL: 'jacobi'
 ; CHECK-NEXT:  Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
-; CHECK-NEXT:  Base offset: %a.base
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
index fc0a6c4e8b952..dd909ee17a9be 100644
--- a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
+++ b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
@@ -12,8 +12,7 @@
 define void @foo(i64 %n, i64 %m, i64 %b, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}(8 * %m * %b),+,(16 * %m)}<%for.i>,+,16}<%for.j>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}((8 * %m * %b) + %A),+,(16 * %m)}<%for.i>,+,16}<%for.j>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{%b,+,2}<nsw><%for.i>][{0,+,2}<nuw><%for.j>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
index 0493a93dfee9d..a17798b2503c0 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
@@ -12,8 +12,7 @@
 define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{3,+,1}<nuw><%for.i>][{-4,+,1}<nsw><%for.j>][{7,+,1}<nuw><nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
index 2e9c3d77f3281..22d5dd9aa6a33 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
@@ -12,8 +12,7 @@
 define void @foo(i64 %n, i64 %m, i64 %o, i64 %p, ptr nocapture %A) nounwind uwtable {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * (%o + %p))),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * (%o + %p)) + %A),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][(%o + %p)] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{3,+,1}<nuw><%for.cond4.preheader.lr.ph.us>][{-4,+,1}<nw><%for.body6.lr.ph.us.us>][{7,+,1}<nw><%for.body6.us.us>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
index a31192ef72f04..7e53c60ca43d9 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
@@ -12,8 +12,7 @@
 define void @foo(i64 %n, i64 %m, i64 %o, ptr %A, i64 %p, i64 %q, i64 %r) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(8 * ((((%m * %p) + %q) * %o) + %r)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{%p,+,1}<nw><%for.i>][{%q,+,1}<nsw><%for.j>][{%r,+,1}<nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
index 432f7af7e0698..c0ff77ba88984 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
@@ -12,14 +12,12 @@
 define void @foo(i64 %n, i64 %m, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: %val = load double, ptr %arrayidx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store double %val, ptr %arrayidx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
index c7a2a89e3183d..7392ed8086816 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
@@ -18,7 +18,7 @@
 define void @foo(i64 %a, i64 %b) nounwind uwtable {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%vla.us,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
index 966a8222d8a15..ef2ff2911aca5 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
@@ -12,8 +12,7 @@
 define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
index da40825984663..b5fa802807ce0 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
@@ -14,8 +14,7 @@ target triple = "x86_64-unknown-linux-gnu"
 define void @foo(i32 %n, i32 %m, i32 %o, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{\{}}0,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))<nuw><nsw>}<%for.j>,+,8}<%for.k>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}%A,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))<nuw><nsw>}<%for.j>,+,8}<%for.k>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][(zext i32 %m to i64)][(zext i32 %o to i64)] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
index da77cd37fede5..28a9906b5fa4c 100644
--- a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
@@ -15,14 +15,12 @@ target triple = "x86_64-unknown-linux-gnu"
 define void @foo(i64 %n, i64 %m, ptr %A) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store double 1.000000e+00, ptr %arrayidx1, align 8
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,8}<%for.i>,+,(8 * %n)}<%for.j>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,8}<%for.i>,+,(8 * %n)}<%for.j>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%n] with elements of 8 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.i>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
index 49eeee3bd2119..79631ff73fdc3 100644
--- a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
+++ b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
@@ -11,18 +11,16 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 define void @foo(ptr %A, ptr %p) {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: %pval = load i64, ptr %p, align 8
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: %p
 ; CHECK-NEXT:  failed to delinearize
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: %tmp11 = load float, ptr %tmp10, align 4
-; CHECK-NEXT:  AccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: ((4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw> + %A)
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store float %tmp12, ptr %tmp10, align 4
-; CHECK-NEXT:  AccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: ((4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw> + %A)
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
index 5b0465f7fb75e..c8e53f40e1b77 100644
--- a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
+++ b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
@@ -9,14 +9,12 @@
 define void @foo(i32 %m, i32 %n, ptr nocapture %A) #0 {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Inst: %4 = load i8, ptr %arrayidx.us, align 1
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,(sext i32 %n to i64)}<nw><%for.body3.lr.ph.us>,+,1}<nw><%for.body3.us>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  Inst: store i8 %add4.us, ptr %arrayidx.us, align 1
-; CHECK-NEXT:  AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
-; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  AccessFunction: {{\{\{}}%A,+,(sext i32 %n to i64)}<nw><%for.body3.lr.ph.us>,+,1}<nw><%for.body3.us>
 ; CHECK-NEXT:  ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
 ; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
 ;
diff --git a/llvm/test/Analysis/Delinearization/type_mismatch.ll b/llvm/test/Analysis/Delinearization/type_mismatch.ll
index 6d344975daf92..db55263dd6c1e 100644
--- a/llvm/test/Analysis/Delinearization/type_mismatch.ll
+++ b/llvm/test/Analysis/Delinearization/type_mismatch.ll
@@ -12,7 +12,7 @@ target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"
 define fastcc void @test(i1 %arg, ptr %x) {
 ; CHECK-LABEL: 'test'
 ; CHECK-NEXT:  Inst: store i8 42, ptr %arrayidx.phi, align 1
-; CHECK-NEXT:  AccessFunction: 0
+; CHECK-NEXT:  AccessFunction: %arrayidx.phi
 ; CHECK-NEXT:  failed to delinearize
 ;
 entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/Coupled.ll b/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
index 1d4513429a83c..230ad416aed40 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
@@ -5,12 +5,13 @@
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
+@A.global = global [100 x [100 x i32]] zeroinitializer
 
 ;;  for (long int i = 0; i < 50; i++) {
 ;;    A[i][i] = i;
 ;;    *B++ = A[i + 10][i + 9];
 
-define void @couple0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple0(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'couple0'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
 ; CHECK-NEXT:    da analyze - none!
@@ -26,6 +27,7 @@ define void @couple0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
@@ -495,16 +497,15 @@ for.end:                                          ; preds = %for.body
 
 
 ;;  for (long int i = 0; i <= 15; i++) {
-;;    A[3*i - 18][18 - i] = i;
+;;    A[3*i + 18][18 - i] = i;
 ;;    *B++ = A[i][i];
 
-define void @couple11(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple11(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'couple11'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
 ; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
-; CHECK-NEXT:    da analyze - flow [0|<] splitable!
-; CHECK-NEXT:    da analyze - split level = 1, iteration = 9!
+; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
 ; CHECK-NEXT:    da analyze - confused!
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
@@ -515,6 +516,7 @@ define void @couple11(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
@@ -523,7 +525,7 @@ for.body:                                         ; preds = %entry, %for.body
   %conv = trunc i64 %i.02 to i32
   %sub = sub nsw i64 18, %i.02
   %mul = mul nsw i64 %i.02, 3
-  %sub1 = add nsw i64 %mul, -18
+  %sub1 = add nsw i64 %mul, 18
   %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
   store i32 %conv, ptr %arrayidx2, align 4
   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -540,16 +542,15 @@ for.end:                                          ; preds = %for.body
 
 
 ;;  for (long int i = 0; i <= 12; i++) {
-;;    A[3*i - 18][22 - i] = i;
+;;    A[3*i + 18][22 - i] = i;
 ;;    *B++ = A[i][i];
 
-define void @couple12(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple12(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'couple12'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
 ; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
-; CHECK-NEXT:    da analyze - flow [<] splitable!
-; CHECK-NEXT:    da analyze - split level = 1, iteration = 11!
+; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
 ; CHECK-NEXT:    da analyze - confused!
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
@@ -560,6 +561,7 @@ define void @couple12(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
@@ -568,7 +570,7 @@ for.body:                                         ; preds = %entry, %for.body
   %conv = trunc i64 %i.02 to i32
   %sub = sub nsw i64 22, %i.02
   %mul = mul nsw i64 %i.02, 3
-  %sub1 = add nsw i64 %mul, -18
+  %sub1 = add nsw i64 %mul, 18
   %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
   store i32 %conv, ptr %arrayidx2, align 4
   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -585,7 +587,7 @@ for.end:                                          ; preds = %for.body
 
 
 ;;  for (long int i = 0; i < 12; i++) {
-;;    A[3*i - 18][22 - i] = i;
+;;    A[3*i + 18][22 - i] = i;
 ;;    *B++ = A[i][i];
 
 define void @couple13(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -612,7 +614,7 @@ for.body:                                         ; preds = %entry, %for.body
   %conv = trunc i64 %i.02 to i32
   %sub = sub nsw i64 22, %i.02
   %mul = mul nsw i64 %i.02, 3
-  %sub1 = add nsw i64 %mul, -18
+  %sub1 = add nsw i64 %mul, 18
   %arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
   store i32 %conv, ptr %arrayidx2, align 4
   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -628,7 +630,7 @@ for.end:                                          ; preds = %for.body
 }
 
 ;;  for (long int i = 0; i < 100; i++) {
-;;    A[3*i - 18][18 - i][i] = i;
+;;    A[3*i + 18][18 - i][i] = i;
 ;;    *B++ = A[i][i][i];
 
 define void @couple14(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -636,7 +638,7 @@ define void @couple14(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
 ; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
-; CHECK-NEXT:    da analyze - flow [0|<]!
+; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
 ; CHECK-NEXT:    da analyze - confused!
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
@@ -655,7 +657,7 @@ for.body:                                         ; preds = %entry, %for.body
   %conv = trunc i64 %i.02 to i32
   %sub = sub nsw i64 18, %i.02
   %mul = mul nsw i64 %i.02, 3
-  %sub1 = add nsw i64 %mul, -18
+  %sub1 = add nsw i64 %mul, 18
   %arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
   store i32 %conv, ptr %arrayidx3, align 4
   %arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
@@ -672,7 +674,7 @@ for.end:                                          ; preds = %for.body
 
 
 ;;  for (long int i = 0; i < 100; i++) {
-;;    A[3*i - 18][22 - i][i] = i;
+;;    A[3*i + 18][22 - i][i] = i;
 ;;    *B++ = A[i][i][i];
 
 define void @couple15(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -699,7 +701,7 @@ for.body:                                         ; preds = %entry, %for.body
   %conv = trunc i64 %i.02 to i32
   %sub = sub nsw i64 22, %i.02
   %mul = mul nsw i64 %i.02, 3
-  %sub1 = add nsw i64 %mul, -18
+  %sub1 = add nsw i64 %mul, 18
   %arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
   store i32 %conv, ptr %arrayidx3, align 4
   %arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
diff --git a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
index 8f94a455d3724..03193cb5359e2 100644
--- a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
@@ -139,7 +139,7 @@ for.cond.cleanup:                                 ; preds = %for.cond.cleanup3,
 
 ;;  for (int i = 0; i < n; i++)
 ;;   for (int j = 0; j < m; j++)
-;;    for (int k = 0; k < o; k++)
+;;    for (int k = 1; k < o; k++)
 ;;      = A[i*m*o + j*o + k]
 ;;     A[i*m*o + j*o + k - 1] =
 define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
@@ -147,9 +147,9 @@ define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4
 ; CHECK-NEXT:    da analyze - none!
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
-; CHECK-NEXT:    da analyze - anti [* * *|<]!
+; CHECK-NEXT:    da analyze - consistent anti [0 0 1]!
 ; CHECK-NEXT:  Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
-; CHECK-NEXT:    da analyze - output [* * *]!
+; CHECK-NEXT:    da analyze - none!
 ;
 entry:
   %cmp49 = icmp sgt i32 %n, 0
@@ -178,7 +178,7 @@ for.body8.lr.ph:                                  ; preds = %for.cond5.preheader
   br label %for.body8
 
 for.body8:                                        ; preds = %for.body8, %for.body8.lr.ph
-  %k.046 = phi i32 [ 0, %for.body8.lr.ph ], [ %inc, %for.body8 ]
+  %k.046 = phi i32 [ 1, %for.body8.lr.ph ], [ %inc, %for.body8 ]
   %add11 = add nsw i32 %k.046, %add
   %arrayidx = getelementptr inbounds i32, ptr %A, i32 %add11
   %0 = load i32, ptr %arrayidx, align 4
@@ -275,7 +275,7 @@ for.cond.cleanup:                                 ; preds = %for.cond.cleanup3,
 ;;   for (int j = 0; j < m; j++)
 ;;    for (int k = 0; k < o; k++)
 ;;      = A[i*m*o + j*o + k]
-;;     A[i*m*o + j*o + k - o] =
+;;     A[i*m*o + j*o + k + o] =
 define void @t5(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
 ; CHECK-LABEL: 't5'
 ; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4
@@ -317,7 +317,7 @@ for.body8:                                        ; preds = %for.body8, %for.bod
   %arrayidx = getelementptr inbounds i32, ptr %A, i32 %add11
   %0 = load i32, ptr %arrayidx, align 4
   %add12 = add nsw i32 %0, 1
-  %add111 = sub nsw i32 %add11, %o
+  %add111 = add nsw i32 %add11, %o
   %arrayidx2 = getelementptr inbounds i32, ptr %A, i32 %add111
   store i32 %add12, ptr %arrayidx2, align 4
   %inc = add nuw nsw i32 %k.046, 1
diff --git a/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll b/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
index bf2268b746a6f..5599c318534d8 100644
--- a/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
@@ -2,6 +2,8 @@
 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
 
+@test_array_100x42x42 = global [100 x [42 x [42 x i32]]] zeroinitializer
+
 ; Check that dependence analysis correctly handles flip-flop of base addresses.
 ; Bug 41488 - https://github.com/llvm/llvm-project/issues/41488
 
@@ -219,12 +221,13 @@ exit:
 ; Same as the above case, there are loop-carried dependencies between the
 ; store.
 
-define void @non_invariant_baseptr_with_identical_obj2(ptr %A) {
+define void @non_invariant_baseptr_with_identical_obj2() {
 ; CHECK-LABEL: 'non_invariant_baseptr_with_identical_obj2'
 ; CHECK-NEXT:  Src: store i32 1, ptr %idx, align 4 --> Dst: store i32 1, ptr %idx, align 4
 ; CHECK-NEXT:    da analyze - confused!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [42 x [42 x i32]]], ptr @test_array_100x42x42, i32 0, i32 0
   br label %loop.i.header
 
 loop.i.header:
diff --git a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
index 1d8c51e475ae8..2707bee1567af 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
@@ -2,6 +2,8 @@
 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
 
+@test_array_40x40 = global [40 x [40 x float]] zeroinitializer
+
 ; Test for a bug, which caused an assert when an invalid
 ; SCEVAddRecExpr is created in addToCoefficient.
 
@@ -16,7 +18,7 @@
 ;   return res;
 ; }
 
-define float @foo(float %g, ptr %rr) nounwind {
+define float @foo(float %g) nounwind {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Src: %0 = load float, ptr %arrayidx4, align 4 --> Dst: %0 = load float, ptr %arrayidx4, align 4
 ; CHECK-NEXT:    da analyze - consistent input [S 0]!
@@ -26,6 +28,7 @@ define float @foo(float %g, ptr %rr) nounwind {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %rr = getelementptr inbounds [40 x [40 x float]], ptr @test_array_40x40, i32 0, i32 0
   br label %for.cond1.preheader
 
 for.cond1.preheader:
diff --git a/llvm/test/Analysis/DependenceAnalysis/PR51512.ll b/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
index 9bee38c6c00ef..2d1638d145ffe 100644
--- a/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
@@ -10,7 +10,7 @@ define void @foo() {
 ; CHECK-NEXT:  Src: store i32 42, ptr %getelementptr, align 1 --> Dst: store i32 42, ptr %getelementptr, align 1
 ; CHECK-NEXT:    da analyze - consistent output [0 S]!
 ; CHECK-NEXT:  Src: store i32 42, ptr %getelementptr, align 1 --> Dst: store i32 0, ptr %getelementptr5, align 1
-; CHECK-NEXT:    da analyze - output [0 *|<]!
+; CHECK-NEXT:    da analyze - output [0 <=|<]!
 ; CHECK-NEXT:  Src: store i32 0, ptr %getelementptr5, align 1 --> Dst: store i32 0, ptr %getelementptr5, align 1
 ; CHECK-NEXT:    da analyze - none!
 ;
diff --git a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
index e67cae7d39a75..cda588609010f 100644
--- a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
@@ -7,6 +7,8 @@
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
+@test_array_100x100x100 = global [100 x [100 x [100 x i64]]] zeroinitializer
+
 ;;  for (long int i = 0; i < n; i++) {
 ;;    for (long int j = 0; j < n; j++) {
 ;;      for (long int k = 0; k < n; k++) {
@@ -15,7 +17,7 @@ target triple = "x86_64-apple-macosx10.6.0"
 ;;      for (long int k = 0; k < n; k++) {
 ;;        *B++ = A[i + 3][j + 2][k + 1];
 
-define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
+define void @p2(i64 %n, ptr %B) nounwind uwtable ssp {
 ; CHECK-LABEL: 'p2'
 ; CHECK-NEXT:  Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %i.011, ptr %arrayidx8, align 8
 ; CHECK-NEXT:    da analyze - none!
@@ -45,6 +47,7 @@ define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
 ; LIN-NEXT:    da analyze - confused!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x [100 x i64]]], ptr @test_array_100x100x100, i32 0, i32 0
   %cmp10 = icmp sgt i64 %n, 0
   br i1 %cmp10, label %for.cond1.preheader.preheader, label %for.end26
 
diff --git a/llvm/test/Analysis/DependenceAnalysis/Separability.ll b/llvm/test/Analysis/DependenceAnalysis/Separability.ll
index 2ed9cca4d1fc0..173b969b37720 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Separability.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Separability.ll
@@ -5,6 +5,8 @@
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
+@test_array_100x100x100 = global [100 x [100 x [100 x i32]]] zeroinitializer
+@test_array_100x100x100x100 = global [100 x [100 x [100 x [100 x i32]]]] zeroinitializer
 
 ;;  for (long int i = 0; i < 50; i++)
 ;;    for (long int j = 0; j < 50; j++)
@@ -13,7 +15,7 @@ target triple = "x86_64-apple-macosx10.6.0"
 ;;          A[n][i][j + k] = i;
 ;;          *B++ = A[10][i + 10][2*j - l];
 
-define void @sep0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep0(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'sep0'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx11, align 4 --> Dst: store i32 %conv, ptr %arrayidx11, align 4
 ; CHECK-NEXT:    da analyze - output [0 * * S]!
@@ -29,6 +31,7 @@ define void @sep0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x [100 x i32]]], ptr @test_array_100x100x100, i32 0, i32 0
   br label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %entry, %for.inc22
@@ -95,7 +98,7 @@ for.end24:                                        ; preds = %for.inc22
 ;;          A[i][i][j + k] = i;
 ;;          *B++ = A[10][i + 10][2*j - l];
 
-define void @sep1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep1(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'sep1'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx11, align 4 --> Dst: store i32 %conv, ptr %arrayidx11, align 4
 ; CHECK-NEXT:    da analyze - output [0 * * S]!
@@ -111,6 +114,7 @@ define void @sep1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x [100 x i32]]], ptr @test_array_100x100x100, i32 0, i32 0
   br label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %entry, %for.inc22
@@ -177,7 +181,7 @@ for.end24:                                        ; preds = %for.inc22
 ;;          A[i][i][i + k][l] = i;
 ;;          *B++ = A[10][i + 10][j + k][l + 10];
 
-define void @sep2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep2(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'sep2'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx12, align 4 --> Dst: store i32 %conv, ptr %arrayidx12, align 4
 ; CHECK-NEXT:    da analyze - consistent output [0 S 0 0]!
@@ -193,6 +197,7 @@ define void @sep2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x [100 x [100 x i32]]]], ptr @test_array_100x100x100x100, i32 0, i32 0
   br label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %entry, %for.inc26
@@ -259,7 +264,7 @@ for.end28:                                        ; preds = %for.inc26
 ;;          A[i][i][i + k][l + k] = i;
 ;;          *B++ = A[10][i + 10][j + k][l + 10];
 
-define void @sep3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep3(ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-LABEL: 'sep3'
 ; CHECK-NEXT:  Src: store i32 %conv, ptr %arrayidx13, align 4 --> Dst: store i32 %conv, ptr %arrayidx13, align 4
 ; CHECK-NEXT:    da analyze - consistent output [0 S 0 0]!
@@ -275,6 +280,7 @@ define void @sep3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %A = getelementptr inbounds [100 x [100 x [100 x [100 x i32]]]], ptr @test_array_100x100x100x100, i32 0, i32 0
   br label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %entry, %for.inc27
diff --git a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
index 2638bb045de3d..6c1ead519885e 100644
--- a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
@@ -1,5 +1,14 @@
 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
-; RUN: opt < %s -disable-output -passes="print<da>" 2>&1 | FileCheck %s
+; RUN: opt < %s -disable-output -passes="print<da>" -da-disable-delinearization-checks 2>&1 | FileCheck %s
+
+; FIXME: Remove -da-disable-delinearization-checks once SCEV's BTC gets better.
+; For the moment we are failing to bound simple SCEVs against constant number of iterations:
+; Check failed: !isKnownLessThan(S, Range)
+; +  S: {0,+,1}<nuw><nsw><%for.body4>
+; +  Range: 1024
+
+@test_array_1024x2048 = global [1024 x [2048 x i32]] zeroinitializer
+@test_array_1024x1024x1024x2048 = global [1024 x [1024 x [1024 x [1024 x [2048 x i32]]]]] zeroinitializer
 
 ; Note: exact results can be achieved even if
 ; "-da-disable-delinearization-checks" is not used
@@ -13,7 +22,7 @@
 ;; }
 ;;
 ;; Note that there is a getelementptr with index 0, make sure we can analyze this case.
-define void @t1(ptr %a) {
+define void @t1() {
 ; CHECK-LABEL: 't1'
 ; CHECK-NEXT:  Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: %2 = load i32, ptr %arrayidx6, align 4
 ; CHECK-NEXT:    da analyze - none!
@@ -23,6 +32,7 @@ define void @t1(ptr %a) {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %a = getelementptr inbounds [1024 x [2048 x i32]], ptr @test_array_1024x2048, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.inc11
@@ -53,7 +63,7 @@ for.end13:                                        ; preds = %for.inc11
 ;; Similar to @t1 but includes a call with a "returned" arg, make sure we can analyze
 ;; this case.
 
-define void @t2(ptr %a) {
+define void @t2() {
 ; CHECK-LABEL: 't2'
 ; CHECK-NEXT:  Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: %2 = load i32, ptr %arrayidx6, align 4
 ; CHECK-NEXT:    da analyze - none!
@@ -69,6 +79,7 @@ define void @t2(ptr %a) {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %a = getelementptr inbounds [1024 x [2048 x i32]], ptr @test_array_1024x2048, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.inc11
@@ -110,7 +121,7 @@ declare ptr @func_with_returned_arg(ptr returned %arg)
 ;;             a[i1][i2][i3][i4][i5] = a[i1+1][i2-2][i3][i4-3][i5+2];
 ;; }
 
-define void @t3(ptr %a) {
+define void @t3() {
 ; CHECK-LABEL: 't3'
 ; CHECK-NEXT:  Src: %4 = load i32, ptr %arrayidx26, align 4 --> Dst: %4 = load i32, ptr %arrayidx26, align 4
 ; CHECK-NEXT:    da analyze - none!
@@ -120,6 +131,7 @@ define void @t3(ptr %a) {
 ; CHECK-NEXT:    da analyze - none!
 ;
 entry:
+  %a = getelementptr inbounds [1024 x [1024 x [1024 x [2048 x i32]]]], ptr @test_array_1024x1024x1024x2048, i32 0, i32 0
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.inc46
diff --git a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
index 3086224c58204..d68833a7f5712 100644
--- a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
+++ b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
@@ -1,9 +1,16 @@
 ; RUN: opt <  %s  -cache-line-size=64 -passes='print<loop-cache-cost>' -disable-output 2>&1 | FileCheck  %s
 
-;; This test checks the effect of rounding cache cost to 1 when it is 
+; Global arrays to replace array_info operand bundles
+@test_array_A_2x3 = global [2 x [3 x i32]] zeroinitializer
+@test_array_B_2 = global [2 x i32] zeroinitializer
+@test_array_C_2 = global [2 x i32] zeroinitializer
+@test_array_D_2 = global [2 x i32] zeroinitializer
+@test_array_E_2 = global [2 x i32] zeroinitializer
+
+;; This test checks the effect of rounding cache cost to 1 when it is
 ;; evaluated to 0 because at least 1 cache line is accessed by the loopnest.
 ;; It does not make sense to output that zero cache lines are used.
-;; The cost of reference group for B[j], C[j], D[j] and E[j] were 
+;; The cost of reference group for B[j], C[j], D[j] and E[j] were
 ;; calculted 0 before but now they are 1 which makes each loop cost more reasonable.
 ;
 ; void test(int n, int m, int o, int A[2][3], int B[2], int C[2], int D[2], int E[2]) {
@@ -19,9 +26,14 @@
 ; CHECK: Loop 'for.j' has cost = 18
 ; CHECK-NEXT: Loop 'for.i' has cost = 10
 
-define void @test(ptr %A, ptr %B, ptr %C, ptr %D, ptr %E) {
+define void @test() {
 
 entry:
+  %A = getelementptr inbounds [2 x [3 x i32]], ptr @test_array_A_2x3, i32 0, i32 0
+  %B = getelementptr inbounds [2 x i32], ptr @test_array_B_2, i32 0, i32 0
+  %C = getelementptr inbounds [2 x i32], ptr @test_array_C_2, i32 0, i32 0
+  %D = getelementptr inbounds [2 x i32], ptr @test_array_D_2, i32 0, i32 0
+  %E = getelementptr inbounds [2 x i32], ptr @test_array_E_2, i32 0, i32 0
   br label %for.i.preheader.split
 
 for.i.preheader.split:                            ; preds = %for.i.preheader
diff --git a/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll b/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
index 90813593b8500..63c915da29927 100644
--- a/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
+++ b/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
@@ -39,6 +39,7 @@
 ; PROFIT-VEC-NEXT: ...
 define void @f() {
 entry:
+
   br label %for.i.header
 
 for.i.header:
diff --git a/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll b/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
index b95bbddf11d65..1e5baadfb0a34 100644
--- a/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
+++ b/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
@@ -1,8 +1,6 @@
 ; RUN: opt -da-disable-delinearization-checks -passes=loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
 ; RUN: opt -da-disable-delinearization-checks -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
 
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-
 ; CHECK-LABEL: sub_sub_less
 ; CHECK: %j = phi
 ; CHECK-NOT: %j.1 = phi
diff --git a/polly/include/polly/ScopInfo.h b/polly/include/polly/ScopInfo.h
index f700144165d53..b9eddc1c38336 100644
--- a/polly/include/polly/ScopInfo.h
+++ b/polly/include/polly/ScopInfo.h
@@ -318,6 +318,16 @@ class ScopArrayInfo final {
   /// Return the isl id for the base pointer.
   isl::id getBasePtrId() const;
 
+  /// Mark this array as delinearized using array_info extraction.
+  void setUsedArrayInfoDelinearization(bool Used = true) {
+    UsedArrayInfoDelinearization = Used;
+  }
+
+  /// Check if this array was delinearized using array_info extraction.
+  bool usedArrayInfoDelinearization() const {
+    return UsedArrayInfoDelinearization;
+  }
+
   /// Return what kind of memory this represents.
   MemoryKind getKind() const { return Kind; }
 
@@ -425,6 +435,9 @@ class ScopArrayInfo final {
 
   /// The scop this SAI object belongs to.
   Scop &S;
+
+  /// True if this array was delinearized using array_info extraction.
+  bool UsedArrayInfoDelinearization = false;
 };
 
 /// Represent memory accesses in statements.
diff --git a/polly/lib/Analysis/ScopBuilder.cpp b/polly/lib/Analysis/ScopBuilder.cpp
index 67a4c43455809..d07090b222d3d 100644
--- a/polly/lib/Analysis/ScopBuilder.cpp
+++ b/polly/lib/Analysis/ScopBuilder.cpp
@@ -1449,34 +1449,15 @@ bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
   Value *Address = Inst.getPointerOperand();
   const SCEV *AccessFunction =
       SE.getSCEVAtScope(Address, LI.getLoopFor(Inst->getParent()));
-  const SCEVUnknown *BasePointer =
-      dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
   enum MemoryAccess::AccessType AccType =
       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
 
-  if (auto *BitCast = dyn_cast<BitCastInst>(Address))
-    Address = BitCast->getOperand(0);
-
-  auto *GEP = dyn_cast<GetElementPtrInst>(Address);
-  if (!GEP || DL.getTypeAllocSize(GEP->getResultElementType()) !=
-                  DL.getTypeAllocSize(ElementType))
-    return false;
-
   SmallVector<const SCEV *, 4> Subscripts;
-  SmallVector<int, 4> Sizes;
-  getIndexExpressionsFromGEP(SE, GEP, Subscripts, Sizes);
-  auto *BasePtr = GEP->getOperand(0);
-
-  if (auto *BasePtrCast = dyn_cast<BitCastInst>(BasePtr))
-    BasePtr = BasePtrCast->getOperand(0);
-
-  // Check for identical base pointers to ensure that we do not miss index
-  // offsets that have been added before this GEP is applied.
-  if (BasePtr != BasePointer->getValue())
+  SmallVector<const SCEV *, 4> Sizes;
+  if (!delinearizeUsingArrayInfo(SE, AccessFunction, Subscripts, Sizes,
+                                 SE.getElementSize(&*Inst)))
     return false;
 
-  std::vector<const SCEV *> SizesSCEV;
-
   const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads();
 
   Loop *SurroundingLoop = Stmt->getSurroundingLoop();
@@ -1491,17 +1472,39 @@ bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
         return false;
   }
 
-  if (Sizes.empty())
-    return false;
-
-  SizesSCEV.push_back(nullptr);
+  // Remove the element size. This information is already provided by the
+  // ElementSize parameter.
+  Sizes.pop_back();
+  const SCEVUnknown *BasePointer =
+      dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
 
-  for (auto V : Sizes)
-    SizesSCEV.push_back(SE.getSCEV(
-        ConstantInt::get(IntegerType::getInt64Ty(BasePtr->getContext()), V)));
+  // Get or create the ScopArrayInfo and mark it as using array_info
+  // delinearization.
+  LLVM_DEBUG(dbgs() << "buildAccessMultiDimFixed: BasePointer="
+                    << *BasePointer->getValue() << "\n");
+  auto *SAI = scop->getOrCreateScopArrayInfo(
+      BasePointer->getValue(), ElementType, Sizes, MemoryKind::Array);
+  SAI->setUsedArrayInfoDelinearization(true);
+
+  LLVM_DEBUG({
+    dbgs() << "buildAccessMultiDimFixed for "
+           << BasePointer->getValue()->getName() << ": Subscripts=[";
+    for (unsigned i = 0; i < Subscripts.size(); i++) {
+      if (i > 0)
+        dbgs() << ", ";
+      dbgs() << *Subscripts[i];
+    }
+    dbgs() << "], Sizes=[";
+    for (unsigned i = 0; i < Sizes.size(); i++) {
+      if (i > 0)
+        dbgs() << ", ";
+      dbgs() << *Sizes[i];
+    }
+    dbgs() << "]\n";
+  });
 
   addArrayAccess(Stmt, Inst, AccType, BasePointer->getValue(), ElementType,
-                 true, Subscripts, SizesSCEV, Val);
+                 true, Subscripts, Sizes, Val);
   return true;
 }
 
@@ -2306,6 +2309,13 @@ void ScopBuilder::updateAccessDimensionality() {
 
       if (Array->getNumberOfDimensions() != 1)
         continue;
+
+      // Skip divisibility optimization for arrays delinearized using
+      // array_info, as they produce proper array indices rather than byte
+      // offsets.
+      if (Array->usedArrayInfoDelinearization())
+        continue;
+
       unsigned DivisibleSize = Array->getElemSizeInBytes();
       const SCEV *Subscript = Access->getSubscript(0);
       while (!isDivisible(Subscript, DivisibleSize, SE))
@@ -2576,11 +2586,31 @@ bool checkCandidatePairAccesses(MemoryAccess *LoadMA, MemoryAccess *StoreMA,
   }
 
   if (Valid) {
-    // Finally, check if they are no other instructions accessing this memory
+    // Finally, check if they are no other instructions accessing this memory.
+    // For multidimensional arrays with known bounds, be less strict about
+    // overlaps to preserve reduction detection for legitimate array reduction
+    // patterns.
     isl::map AllAccsRel = LoadAccs.unite(StoreAccs);
     AllAccsRel = AllAccsRel.intersect_domain(Domain);
     isl::set AllAccs = AllAccsRel.range();
-    Valid = !hasIntersectingAccesses(AllAccs, LoadMA, StoreMA, Domain, MemAccs);
+
+    bool hasOtherAccesses =
+        hasIntersectingAccesses(AllAccs, LoadMA, StoreMA, Domain, MemAccs);
+
+    // For arrays delinearized with array_info (multidimensional with known
+    // bounds), allow reductions even if there might be overlapping accesses
+    // from other reductions in the same statement, as these represent
+    // legitimate reduction patterns.
+    auto *SAI = LoadMA->getScopArrayInfo();
+    if (hasOtherAccesses && SAI->usedArrayInfoDelinearization() &&
+        SAI->getNumberOfDimensions() > 1) {
+      POLLY_DEBUG(dbgs() << " == Allowing potential overlap for "
+                            "multidimensional array reduction\n");
+      Valid = true;
+    } else {
+      Valid = !hasOtherAccesses;
+    }
+
     POLLY_DEBUG(dbgs() << " == The accessed memory is " << (Valid ? "not " : "")
                        << "accessed by other instructions!\n");
   }
diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index 8c6a2360a249b..92edf858e17c2 100644
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -447,9 +447,21 @@ void MemoryAccess::updateDimensionality() {
 
   unsigned DimsArray = unsignedFromIslSize(ArraySpace.dim(isl::dim::set));
   unsigned DimsAccess = unsignedFromIslSize(AccessSpace.dim(isl::dim::set));
-  assert(DimsArray >= DimsAccess);
+
+  LLVM_DEBUG(dbgs() << "updateDimensionality: DimsArray=" << DimsArray
+                    << ", DimsAccess=" << DimsAccess << " for array "
+                    << SAI->getName() << "\n");
+
+  if (DimsArray < DimsAccess) {
+    LLVM_DEBUG(
+        dbgs() << "ERROR: DimsArray < DimsAccess - assertion would fail!\n");
+    return; // Graceful failure instead of assertion
+  }
   unsigned DimsMissing = DimsArray - DimsAccess;
 
+  LLVM_DEBUG(dbgs() << "updateDimensionality: Computing DimsMissing="
+                    << DimsMissing << "\n");
+
   auto *BB = getStatement()->getEntryBlock();
   auto &DL = BB->getModule()->getDataLayout();
   unsigned ArrayElemSize = SAI->getElemSizeInBytes();
@@ -476,7 +488,10 @@ void MemoryAccess::updateDimensionality() {
   // obvious again. If the base pointer was accessed with offsets not divisible
   // by the accesses element size, we will have chosen a smaller ArrayElemSize
   // that divides the offsets of all accesses to this base pointer.
-  if (DimsAccess == 1) {
+  //
+  // Skip this division for arrays that used array_info delinearization,
+  // as they already produce proper array indices rather than byte offsets.
+  if (DimsAccess == 1 && !SAI->usedArrayInfoDelinearization()) {
     isl::val V = isl::val(Ctx, ArrayElemSize);
     AccessRelation = AccessRelation.floordiv_val(V);
   }
@@ -498,9 +513,19 @@ void MemoryAccess::updateDimensionality() {
   // An access ((float *)A)[i] to an array char *A is modeled as
   // {[i] -> A[o] : 4 i <= o <= 4 i + 3
   if (ElemBytes > ArrayElemSize) {
-    assert(ElemBytes % ArrayElemSize == 0 &&
-           "Loaded element size should be multiple of canonical element size");
-    assert(DimsArray >= 1);
+    LLVM_DEBUG(dbgs() << "updateDimensionality: ElemBytes=" << ElemBytes
+                      << " > ArrayElemSize=" << ArrayElemSize << "\n");
+
+    if (ElemBytes % ArrayElemSize != 0) {
+      LLVM_DEBUG(dbgs() << "ERROR: Loaded element size not multiple of "
+                           "canonical element size!\n");
+      return; // Graceful failure instead of assertion
+    }
+
+    if (DimsArray < 1) {
+      LLVM_DEBUG(dbgs() << "ERROR: DimsArray < 1!\n");
+      return; // Graceful failure instead of assertion
+    }
     isl::map Map = isl::map::from_domain_and_range(
         isl::set::universe(ArraySpace), isl::set::universe(ArraySpace));
     for (auto i : seq<unsigned>(0, DimsArray - 1))
@@ -525,6 +550,9 @@ void MemoryAccess::updateDimensionality() {
     Map = Map.add_constraint(C);
     AccessRelation = AccessRelation.apply_range(Map);
   }
+
+  LLVM_DEBUG(dbgs() << "updateDimensionality: Completed successfully for array "
+                    << SAI->getName() << "\n");
 }
 
 std::string
@@ -846,7 +874,11 @@ void MemoryAccess::buildAccessRelation(const ScopArrayInfo *SAI) {
   isl::space Space = isl::space(Ctx, 0, Statement->getNumIterators(), 0);
   AccessRelation = isl::map::universe(Space);
 
+  LLVM_DEBUG(dbgs() << "buildAccessRelation for " << BaseAddr->getName()
+                    << ": Processing " << Subscripts.size() << " subscripts\n");
   for (int i = 0, Size = Subscripts.size(); i < Size; ++i) {
+    LLVM_DEBUG(dbgs() << "  Subscripts[" << i << "] = " << *Subscripts[i]
+                      << "\n");
     isl::pw_aff Affine = getPwAff(Subscripts[i]);
     isl::map SubscriptMap = isl::map::from_pw_aff(Affine);
     AccessRelation = AccessRelation.flat_range_product(SubscriptMap);
diff --git a/polly/test/CodeGen/MemAccess/create_arrays.ll b/polly/test/CodeGen/MemAccess/create_arrays.ll
index 40ae8d6efa95f..88ba0c0864204 100644
--- a/polly/test/CodeGen/MemAccess/create_arrays.ll
+++ b/polly/test/CodeGen/MemAccess/create_arrays.ll
@@ -8,16 +8,16 @@
 ;
 ;
 ; CHECK:    Arrays {
-; CHECK:        double MemRef_B[*][1024]; // Element size 8
+; CHECK:        double MemRef_B[20][1024]; // Element size 8
 ; CHECK:        double MemRef_beta; // Element size 8
-; CHECK:        double MemRef_A[*][1056]; // Element size 8
+; CHECK:        double MemRef_A[10][1056]; // Element size 8
 ; CHECK:        double D[270336]; // Element size 8
 ; CHECK:        double E[270336][200000]; // Element size 8
 ; CHECK:        i64 F[270336]; // Element size 8
 ;
 ; CHECK:New access function '{ Stmt_bb12[i0, i1, i2] -> E[i2, i0] }' detected in JSCOP file
 ;
-; CODEGEN:define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+; CODEGEN:define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %arg7) #0 {
 ; CODEGEN:bb:
 ; CODEGEN:  %beta.s2a = alloca double
 ; CODEGEN:  %D = alloca [270336 x double]
@@ -25,11 +25,11 @@
 ; CODEGEN:  %F = alloca [270336 x i64]
 ; CODEGEN:  br label %bb8
 ;
-; CODEGEN:  %beta.s2a.reload = load double, ptr %beta.s2a
-; CODEGEN:  %polly.access.mul.E = mul nsw i64 %polly.indvar31, 200000
+; CODEGEN:  %beta.s2a.reload = load double, ptr %beta.s2a, align 8
+; CODEGEN:  %polly.access.mul.E = mul nsw i64 %polly.indvar10, 200000
 ; CODEGEN:  %polly.access.add.E = add nsw i64 %polly.access.mul.E, %polly.indvar
 ; CODEGEN:  {{%.*}} = load double, ptr %polly.access.E, align 8, !alias.scope !4, !noalias !7
-; CODEGEN:  store double {{%.*}}, ptr %scevgep34, align 8, !alias.scope !12, !noalias !13
+; CODEGEN:  store double {{%.*}}, ptr %scevgep13, align 8
 ;
 ; CODEGEN: !0 = distinct !{!0, !1}
 ; CODEGEN: !1 = !{!"llvm.loop.vectorize.enable", i32 0}
@@ -46,11 +46,11 @@
 ; CODEGEN: !12 = !{!9}
 ; CODEGEN: !13 = !{!8, !10, !5, !11}
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-; Function Attrs: nounwind uwtable
-define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+@A = common global [10 x [1056 x double]] zeroinitializer
+@B = common global [20 x [1024 x double]] zeroinitializer
+
+define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %arg7) {
 bb:
   br label %bb8
 
@@ -67,10 +67,10 @@ bb10:                                             ; preds = %bb20, %bb9
 
 bb12:                                             ; preds = %bb12, %bb10
   %tmp13 = phi i64 [ 0, %bb10 ], [ %tmp18, %bb12 ]
-  %tmp14 = getelementptr inbounds [1024 x double], ptr %B, i64 %tmp, i64 %tmp13
+  %tmp14 = getelementptr inbounds [1024 x double], ptr @B, i64 %tmp, i64 %tmp13
   %tmp15 = load double, ptr %tmp14, align 8
   %tmp16 = fmul double %tmp15, %beta
-  %tmp17 = getelementptr inbounds [1056 x double], ptr %A, i64 %tmp, i64 %tmp11
+  %tmp17 = getelementptr inbounds [1056 x double], ptr @A, i64 %tmp, i64 %tmp11
   store double %tmp16, ptr %tmp17, align 8
   %tmp18 = add nuw nsw i64 %tmp13, 1
   %tmp19 = icmp ne i64 %tmp18, 1024
@@ -89,5 +89,3 @@ bb23:                                             ; preds = %bb20
 bb26:                                             ; preds = %bb23
   ret void
 }
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/CodeGen/MemAccess/create_arrays_heap.ll b/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
index 1202d21998c94..94db0900bda4c 100644
--- a/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
+++ b/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
@@ -5,7 +5,8 @@
 ; #define Nj 1056
 ; #define Nk 1024
 ;
-; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
+; double A[Ni][Nk], B[Ni][Nj];
+; void create_arrays_heap(double beta) {
 ;   int i,j,k;
 ;
 ;   for (i = 0; i < Ni; i++) {
@@ -19,9 +20,9 @@
 ;
 ; Check if the info from the JSON file has been analysed without errors.
 ; CHECK: Arrays {
-; CHECK: double MemRef_A[*][1024]; // Element size 8
+; CHECK: double MemRef_A[1056][1024]; // Element size 8
 ; CHECK: double MemRef_beta; // Element size 8
-; CHECK: double MemRef_B[*][1056]; // Element size 8
+; CHECK: double MemRef_B[1056][1056]; // Element size 8
 ; CHECK: double D[270336]; // Element size 8
 ; CHECK: double E[270336][200000]; // Element size 8
 ; CHECK: i64 F[270336]; // Element size 8
@@ -47,13 +48,11 @@
 ; CODEGEN: %polly.access.add.{{.*}} = add nsw i64 %polly.access.mul.{{.*}}, %
 ; CODEGEN: %polly.access.{{.*}} = getelementptr double, ptr %E, i64 %polly.access.add.{{.*}}
 ;
-; ModuleID = 'create_arrays_heap.ll'
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-; Function Attrs: nounwind uwtable
-define void @create_arrays_heap(double %beta, ptr nocapture readonly %A, ptr nocapture %B) local_unnamed_addr {
+@A = common global [1056 x [1024 x double]] zeroinitializer
+@B = common global [1056 x [1056 x double]] zeroinitializer
+
+define void @create_arrays_heap(double %beta) local_unnamed_addr {
 entry:
   br label %for.cond1.preheader
 
@@ -63,27 +62,27 @@ for.cond1.preheader:                              ; preds = %for.inc16, %entry
 
 for.cond4.preheader:                              ; preds = %for.inc13, %for.cond1.preheader
   %indvars.iv32 = phi i64 [ 0, %for.cond1.preheader ], [ %indvars.iv.next33, %for.inc13 ]
-  %arrayidx12 = getelementptr inbounds [1056 x double], ptr %B, i64 %indvars.iv35, i64 %indvars.iv32
+  %arrayidx12 = getelementptr inbounds [1056 x double], ptr @B, i64 %indvars.iv35, i64 %indvars.iv32
   br label %for.body6
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next.3, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv
   %0 = load double, ptr %arrayidx8, align 8
   %mul = fmul double %0, %beta
   store double %mul, ptr %arrayidx12, align 8
   %indvars.iv.next = or disjoint i64 %indvars.iv, 1
-  %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next
+  %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next
   %1 = load double, ptr %arrayidx8.1, align 8
   %mul.1 = fmul double %1, %beta
   store double %mul.1, ptr %arrayidx12, align 8
   %indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
-  %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.1
+  %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.1
   %2 = load double, ptr %arrayidx8.2, align 8
   %mul.2 = fmul double %2, %beta
   store double %mul.2, ptr %arrayidx12, align 8
   %indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
-  %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.2
+  %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.2
   %3 = load double, ptr %arrayidx8.3, align 8
   %mul.3 = fmul double %3, %beta
   store double %mul.3, ptr %arrayidx12, align 8
diff --git a/polly/test/CodeGen/OpenMP/matmul-parallel.ll b/polly/test/CodeGen/OpenMP/matmul-parallel.ll
index 43326b29f7ef1..9b3afc9b78655 100644
--- a/polly/test/CodeGen/OpenMP/matmul-parallel.ll
+++ b/polly/test/CodeGen/OpenMP/matmul-parallel.ll
@@ -3,12 +3,11 @@
 ; REQUIRES: asserts
 
 ; Parallelization of detected matrix-multiplication.
-; Currently, this is not supported. Due to Packed_A/Packed_B not private
-; per-thread the outer loops cannot be parallelized and a
-; '#pragma omp parallel for' on an inner loop may impose too much overhead.
+; The outer loop should be parallelized.
+; AST: // 1st level tiling - Tiles
+; AST-NEXT: #pragma omp parallel for
 
-target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc19.16.27034"
+; CODEGEN: polly.parallel.for
 
 define i32 @foo(ptr nocapture readonly %A, ptr nocapture readonly %B, ptr nocapture %C) {
 entry:
@@ -53,8 +52,3 @@ for.body8:
   %exitcond = icmp eq i64 %indvars.iv.next, 1536
   br i1 %exitcond, label %for.cond.cleanup7, label %for.body8
 }
-
-
-; AST-NOT: parallel
-
-; CODEGEN-NOT: subfunc
diff --git a/polly/test/CodeGen/invariant-load-dimension.ll b/polly/test/CodeGen/invariant-load-dimension.ll
index 21e53055c56b0..ae74cb207d841 100644
--- a/polly/test/CodeGen/invariant-load-dimension.ll
+++ b/polly/test/CodeGen/invariant-load-dimension.ll
@@ -1,8 +1,6 @@
 ; RUN: opt %loadNPMPolly -polly-process-unprofitable -polly-invariant-load-hoisting '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s -check-prefix=SCOPS
 ; RUN: opt %loadNPMPolly -S < %s -passes=polly-codegen -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN
 
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
-
 %S = type { i32, i32, [12 x %L] }
 %L = type { i32, i32, double, i32, i32, i32, i32, i32 }
 
@@ -13,11 +11,11 @@ define void @test(ptr %cpi, i1 %b) {
 ; SCOPS-NEXT:                [l2, l1] -> { Stmt_for_body_i[i0] -> MemRef_cpi[0, 0] };
 ; SCOPS-NEXT:            Execution Context: [l2, l1] -> {  :  }
 ; SCOPS-NEXT:            ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
-; SCOPS-NEXT:                [l2, l1] -> { Stmt_for_body_lr_ph_i[] -> MemRef_cpi[0, 1] };
+; SCOPS-NEXT:                [l2, l1] -> { Stmt_for_body_lr_ph_i[] -> MemRef_cpi[0, 0] };
 ; SCOPS-NEXT:            Execution Context: [l2, l1] -> {  : l2 > 0 }
 ; SCOPS-NEXT:    }
 ; SCOPS:         Arrays {
-; SCOPS-NEXT:        i32 MemRef_cpi[*][(10 * %l1)]; // Element size 4
+; SCOPS-NEXT:        i32 MemRef_cpi[*][(10 * (sext i32 %l1 to i64))<nsw>]; // Element size 4
 ; SCOPS-NEXT:    }
 
 ; FIXME: Figure out how to actually generate code for this loop.
diff --git a/polly/test/DeLICM/load-in-cond-inf-loop.ll b/polly/test/DeLICM/load-in-cond-inf-loop.ll
index a78a4691bb0d5..9649f5583bab1 100644
--- a/polly/test/DeLICM/load-in-cond-inf-loop.ll
+++ b/polly/test/DeLICM/load-in-cond-inf-loop.ll
@@ -10,8 +10,6 @@
 ;
 ; Test case reduced from llvm.org/PR48445.
 
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-
 @arr_18 = external dso_local local_unnamed_addr global [0 x i16], align 2
 
 define void @func(i64 %b, ptr %c) {
@@ -60,11 +58,11 @@ for.cond.cleanup:
 ; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:                 [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef_c[b] };
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:                 [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef1[] };
+; CHECK-NEXT:                 [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef2[] };
 ; CHECK-NEXT:            new: [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef_arr_18[i0] : i0 < b; Stmt_for_body13[0, i1, i2] -> MemRef_arr_18[0] : b < 0 };
 ; CHECK-NEXT:     Stmt_for_cond_cleanup6
 ; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:                 [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef1[] };
+; CHECK-NEXT:                 [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef2[] };
 ; CHECK-NEXT:            new: [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef_arr_18[i0] : i0 < b; Stmt_for_cond_cleanup6[0] -> MemRef_arr_18[0] : b < 0 };
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:                 [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef_arr_18[i0] };
diff --git a/polly/test/ForwardOpTree/atax.ll b/polly/test/ForwardOpTree/atax.ll
index 496e8315b068b..9f341cfbb6e6b 100644
--- a/polly/test/ForwardOpTree/atax.ll
+++ b/polly/test/ForwardOpTree/atax.ll
@@ -1,8 +1,8 @@
 ; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true '-passes=print<polly-optree>' -disable-output < %s | FileCheck %s -match-full-lines
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@A = common global [100 x [2100 x double]] zeroinitializer
 
-define internal fastcc void @kernel_atax(ptr nocapture readonly %A, ptr nocapture readonly %x, ptr nocapture %y, ptr nocapture %tmp) unnamed_addr #0 {
+define internal fastcc void @kernel_atax(ptr nocapture readonly %x, ptr nocapture %y, ptr nocapture %tmp) {
 entry:
   br label %entry.split
 
@@ -19,7 +19,7 @@ for.body3:                                        ; preds = %for.inc40, %entry.s
 for.body8:                                        ; preds = %for.body8, %for.body3
   %0 = phi double [ 0.000000e+00, %for.body3 ], [ %add, %for.body8 ]
   %indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body8 ]
-  %arrayidx14 = getelementptr inbounds [2100 x double], ptr %A, i64 %indvars.iv8, i64 %indvars.iv
+  %arrayidx14 = getelementptr inbounds [2100 x double], ptr @A, i64 %indvars.iv8, i64 %indvars.iv
   %1 = load double, ptr %arrayidx14, align 8, !tbaa !6
   %arrayidx16 = getelementptr inbounds double, ptr %x, i64 %indvars.iv
   %2 = load double, ptr %arrayidx16, align 8, !tbaa !6
@@ -38,7 +38,7 @@ for.body24:                                       ; preds = %for.body24.for.body
   %indvars.iv5 = phi i64 [ 0, %for.end21 ], [ %indvars.iv.next6, %for.body24.for.body24_crit_edge ]
   %arrayidx26 = getelementptr inbounds double, ptr %y, i64 %indvars.iv5
   %4 = load double, ptr %arrayidx26, align 8, !tbaa !6
-  %arrayidx30 = getelementptr inbounds [2100 x double], ptr %A, i64 %indvars.iv8, i64 %indvars.iv5
+  %arrayidx30 = getelementptr inbounds [2100 x double], ptr @A, i64 %indvars.iv8, i64 %indvars.iv5
   %5 = load double, ptr %arrayidx30, align 8, !tbaa !6
   %mul33 = fmul double %5, %3
   %add34 = fadd double %4, %mul33
@@ -61,10 +61,7 @@ for.end42:                                        ; preds = %for.inc40
 }
 
 ; Function Attrs: argmemonly nounwind
-declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1) #1
-
-attributes #0 = { noinline norecurse nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
-attributes #1 = { argmemonly nounwind }
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1)
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
@@ -89,15 +86,15 @@ attributes #1 = { argmemonly nounwind }
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:                 { Stmt_for_body3[i0] -> MemRef_tmp[i0] };
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:                 { Stmt_for_body3[i0] -> MemRef1__phi[] };
+; CHECK-NEXT:                 { Stmt_for_body3[i0] -> MemRef2__phi[] };
 ; CHECK-NEXT:             Instructions {
 ; CHECK-NEXT:                   store double 0.000000e+00, ptr %arrayidx5, align 8, !tbaa !2
 ; CHECK-NEXT:             }
 ; CHECK-NEXT:     Stmt_for_body8
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:                 { Stmt_for_body8[i0, i1] -> MemRef1__phi[] };
+; CHECK-NEXT:                 { Stmt_for_body8[i0, i1] -> MemRef2__phi[] };
 ; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:                 { Stmt_for_body8[i0, i1] -> MemRef1__phi[] };
+; CHECK-NEXT:                 { Stmt_for_body8[i0, i1] -> MemRef2__phi[] };
 ; CHECK-NEXT:            new: { Stmt_for_body8[i0, i1] -> MemRef_tmp[i0] };
 ; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:                 { Stmt_for_body8[i0, i1] -> MemRef_A[i0, i1] };
diff --git a/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll b/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
index 6e13a5e413d76..0e07daf86e834 100644
--- a/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
+++ b/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
@@ -1,4 +1,4 @@
-  ; RUN: not --crash opt %loadNPMPolly -passes=polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
+; RUN: not --crash opt %loadNPMPolly -passes=polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; CHECK: Array has not a valid type.
 ;
@@ -11,11 +11,10 @@
 ;
 ;
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
+@A = common global [1056 x [1056 x double]] zeroinitializer
+@B = common global [1056 x [1024 x double]] zeroinitializer
 
-; Function Attrs: nounwind uwtable
-define internal void @ia4(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+define internal void @ia4(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) {
 bb:
   br label %bb8
 
@@ -32,10 +31,10 @@ bb10:                                             ; preds = %bb20, %bb9
 
 bb12:                                             ; preds = %bb12, %bb10
   %tmp13 = phi i64 [ 0, %bb10 ], [ %tmp18, %bb12 ]
-  %tmp14 = getelementptr inbounds [1024 x double], ptr %B, i64 %tmp, i64 %tmp13
+  %tmp14 = getelementptr inbounds [1024 x double], ptr @B, i64 %tmp, i64 %tmp13
   %tmp15 = load double, ptr %tmp14, align 8
   %tmp16 = fmul double %tmp15, %beta
-  %tmp17 = getelementptr inbounds [1056 x double], ptr %A, i64 %tmp, i64 %tmp11
+  %tmp17 = getelementptr inbounds [1056 x double], ptr @A, i64 %tmp, i64 %tmp11
   store double %tmp16, ptr %tmp17, align 8
   %tmp18 = add nuw nsw i64 %tmp13, 1
   %tmp19 = icmp ne i64 %tmp18, 1024
@@ -54,5 +53,3 @@ bb23:                                             ; preds = %bb20
 bb26:                                             ; preds = %bb23
   ret void
 }
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll b/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
index 7f6578776e0bd..f4c99658ceda1 100644
--- a/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
+++ b/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
@@ -4,7 +4,8 @@
 ; #define Nj 1056
 ; #define Nk 1024
 ;
-; void ImportArray_Negative_size(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
+; double A[Ni][Nk], B[Ni][Nj];
+; void ImportArray_Negative_size(double beta) {
 ;   int i,j,k;
 ;
 ;   for (i = 0; i < Ni; i++) {
@@ -19,12 +20,11 @@
 ; Verify if the JSONImporter checks if the size of the new array is positive.
 ; CHECK: The size at index 0 is =< 0.
 ;
-; ModuleID = 'ImportArrays-Negative-size.ll'
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-; Function Attrs: nounwind uwtable
-define void @ImportArrays_Negative_Size(double %beta, ptr nocapture readonly %A, ptr nocapture %B) local_unnamed_addr {
+@A = common global [1056 x [1024 x double]] zeroinitializer
+@B = common global [1056 x [1056 x double]] zeroinitializer
+
+define void @ImportArrays_Negative_Size(double %beta) local_unnamed_addr {
 entry:
   br label %for.cond1.preheader
 
@@ -34,27 +34,27 @@ for.cond1.preheader:                              ; preds = %for.inc16, %entry
 
 for.cond4.preheader:                              ; preds = %for.inc13, %for.cond1.preheader
   %indvars.iv32 = phi i64 [ 0, %for.cond1.preheader ], [ %indvars.iv.next33, %for.inc13 ]
-  %arrayidx12 = getelementptr inbounds [1056 x double], ptr %B, i64 %indvars.iv35, i64 %indvars.iv32
+  %arrayidx12 = getelementptr inbounds [1056 x double], ptr @B, i64 %indvars.iv35, i64 %indvars.iv32
   br label %for.body6
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next.3, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv
   %0 = load double, ptr %arrayidx8, align 8
   %mul = fmul double %0, %beta
   store double %mul, ptr %arrayidx12, align 8
   %indvars.iv.next = or disjoint i64 %indvars.iv, 1
-  %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next
+  %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next
   %1 = load double, ptr %arrayidx8.1, align 8
   %mul.1 = fmul double %1, %beta
   store double %mul.1, ptr %arrayidx12, align 8
   %indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
-  %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.1
+  %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.1
   %2 = load double, ptr %arrayidx8.2, align 8
   %mul.2 = fmul double %2, %beta
   store double %mul.2, ptr %arrayidx12, align 8
   %indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
-  %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.2
+  %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.2
   %3 = load double, ptr %arrayidx8.3, align 8
   %mul.3 = fmul double %3, %beta
   store double %mul.3, ptr %arrayidx12, align 8
diff --git a/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed b/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
index 066294b3d13ff..9e440e060aa83 100644
--- a/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
+++ b/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
@@ -2,12 +2,12 @@
    "arrays" : [
        {
          "name" : "MemRef_B",
-         "sizes" : [ "*", "1024" ],
+         "sizes" : [ "1056", "1024" ],
 	 "type" : "doble"
       },
       {
          "name" : "MemRef_A",
-         "sizes" : [ "*", "1056" ],
+         "sizes" : [ "1056", "1056" ],
          "type" : "double"
       },
       {
diff --git a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
index 5e4ce8225a236..be3ead379e7a7 100644
--- a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
+++ b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
@@ -1,7 +1,9 @@
 ; RUN: opt %loadNPMPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
 ; RUN: opt %loadNPMPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
 
-define void @func(i32 %n, ptr  noalias nonnull %A,  ptr  noalias nonnull %B) {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @func(i32 %n) {
 entry:
   br label %outer.for1
 
@@ -16,7 +18,7 @@ outer.for1:
     br i1 %j1.cmp, label %body1, label %exit1
 
       body1:
-        %arrayidx1 = getelementptr inbounds [1024 x double], ptr %A, i32 %k1, i32 %j1
+        %arrayidx1 = getelementptr inbounds [1024 x double], ptr @A, i32 %k1, i32 %j1
         store double 21.0, ptr %arrayidx1
         br label %inc1
 
@@ -45,7 +47,7 @@ outer.for2:
     br i1 %j2.cmp, label %body2, label %exit2
 
       body2:
-        %arrayidx2 = getelementptr inbounds [1024 x double], ptr %A, i32 %k2, i32 %j2
+        %arrayidx2 = getelementptr inbounds [1024 x double], ptr @A, i32 %k2, i32 %j2
         store double 42.0, ptr %arrayidx2
         br label %inc2
 
diff --git a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
index a449a2fda9ba3..f4a95e7f7edcc 100644
--- a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
+++ b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
@@ -1,7 +1,9 @@
 ; RUN: opt %loadNPMPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
 ; RUN: opt %loadNPMPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
 
-define void @func(i32 %n, ptr noalias nonnull %A) {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @func(i32 %n) {
 entry:
   br label %outer.for
 
@@ -16,7 +18,7 @@ outer.for:
     br i1 %j1.cmp, label %body1, label %exit1
 
       body1:
-        %arrayidx1 = getelementptr inbounds  [1024 x double], ptr %A, i32 %k, i32 %j1
+        %arrayidx1 = getelementptr inbounds  [1024 x double], ptr @A, i32 %k, i32 %j1
         store double 21.0, ptr %arrayidx1
         br label %inc1
 
@@ -33,7 +35,7 @@ outer.for:
     br i1 %j2.cmp, label %body2, label %exit2
 
       body2:
-        %arrayidx2 = getelementptr inbounds  [1024 x double], ptr %A, i32 %k, i32 %j2
+        %arrayidx2 = getelementptr inbounds  [1024 x double], ptr @A, i32 %k, i32 %j2
         store double 42.0, ptr %arrayidx2
         br label %inc2
 
diff --git a/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll b/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
index 928ee858ae6d2..d0fd3202bc93a 100644
--- a/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
+++ b/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
@@ -169,9 +169,12 @@
 ; CHECK-NEXT:              }
 ; CHECK-NEXT:            }
 ; CHECK-NEXT:          }
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
-define void @f(ptr %A, ptr %B, ptr %C) {
+@A = common global [3000 x [3000 x i32]] zeroinitializer
+@B = common global [3000 x [3000 x i32]] zeroinitializer
+@C = common global [3000 x [3000 x i32]] zeroinitializer
+
+define void @f() {
 entry:
   br label %for.cond
 
@@ -189,7 +192,7 @@ for.cond1:                                        ; preds = %for.inc21, %for.bod
   br i1 %exitcond3, label %for.body3, label %for.end23
 
 for.body3:                                        ; preds = %for.cond1
-  %arrayidx5 = getelementptr inbounds [3000 x i32], ptr %A, i64 %indvars.iv4, i64 %indvars.iv1
+  %arrayidx5 = getelementptr inbounds [3000 x i32], ptr @A, i64 %indvars.iv4, i64 %indvars.iv1
   store i32 0, ptr %arrayidx5, align 4
   br label %for.cond6
 
@@ -199,12 +202,12 @@ for.cond6:                                        ; preds = %for.inc, %for.body3
   br i1 %exitcond, label %for.body8, label %for.end
 
 for.body8:                                        ; preds = %for.cond6
-  %arrayidx12 = getelementptr inbounds [3000 x i32], ptr %B, i64 %indvars.iv4, i64 %indvars.iv
+  %arrayidx12 = getelementptr inbounds [3000 x i32], ptr @B, i64 %indvars.iv4, i64 %indvars.iv
   %tmp = load i32, ptr %arrayidx12, align 4
-  %arrayidx16 = getelementptr inbounds [3000 x i32], ptr %C, i64 %indvars.iv, i64 %indvars.iv1
+  %arrayidx16 = getelementptr inbounds [3000 x i32], ptr @C, i64 %indvars.iv, i64 %indvars.iv1
   %tmp7 = load i32, ptr %arrayidx16, align 4
   %mul = mul nsw i32 %tmp, %tmp7
-  %arrayidx20 = getelementptr inbounds [3000 x i32], ptr %A, i64 %indvars.iv4, i64 %indvars.iv1
+  %arrayidx20 = getelementptr inbounds [3000 x i32], ptr @A, i64 %indvars.iv4, i64 %indvars.iv1
   %tmp8 = load i32, ptr %arrayidx20, align 4
   %add = add nsw i32 %tmp8, %mul
   store i32 %add, ptr %arrayidx20, align 4
diff --git a/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll b/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
index 3dd579ed736f7..5d284bf372a89 100644
--- a/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
+++ b/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
@@ -26,8 +26,11 @@
 ; CHECK-NEXT:          }
 ; CHECK-NEXT:        }
 
-; Function Attrs: nounwind uwtable
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   %cmp.27 = icmp sgt i32 %ni, 0
   br i1 %cmp.27, label %for.cond.1.preheader.lr.ph, label %for.end.22
@@ -53,12 +56,12 @@ for.body.6.lr.ph:                                 ; preds = %for.cond.4.preheade
 
 for.body.6:                                       ; preds = %for.body.6.lr.ph, %for.body.6
   %indvars.iv = phi i64 [ 0, %for.body.6.lr.ph ], [ %indvars.iv.next, %for.body.6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv33, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv33, i64 %indvars.iv
   %0 = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv29
+  %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv29
   %1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %0, %1
-  %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv33, i64 %indvars.iv29
+  %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv33, i64 %indvars.iv29
   %2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %2, %mul
   store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed b/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
index 1b0e4de06c7d7..27ec159fc65a9 100644
--- a/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
+++ b/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
@@ -1,23 +1,23 @@
 {
    "arrays" : [
-      {
-         "name" : "MemRef_C1",
-         "sizes" : [ "*" ],
-         "type" : "double"
-      },
       {
          "name" : "MemRef_A",
-         "sizes" : [ "*", "1024" ],
+         "sizes" : [ "1024", "1024" ],
          "type" : "double"
       },
       {
          "name" : "MemRef_B",
-         "sizes" : [ "*", "1024" ],
+         "sizes" : [ "1024", "1024" ],
          "type" : "double"
       },
       {
          "name" : "MemRef_C",
-         "sizes" : [ "*", "1024" ],
+         "sizes" : [ "1024", "1024" ],
+         "type" : "double"
+      },
+      {
+         "name" : "MemRef_C1",
+         "sizes" : [ "*" ],
          "type" : "double"
       }
    ],
diff --git a/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll b/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
index de1c815f92350..c3dccd5222f45 100644
--- a/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
+++ b/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
@@ -83,10 +83,12 @@
 ; CHECK-NEXT:      }
 ; CHECK-NEXT:    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+@arg5 = common global [100 x [1056 x double]] zeroinitializer
+@arg6 = common global [100 x [1023 x double]] zeroinitializer
+@arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
 bb:
   br label %bb8
 
@@ -96,7 +98,7 @@ bb8:                                              ; preds = %bb29, %bb
 
 bb9:                                              ; preds = %bb26, %bb8
   %tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
-  %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+  %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
   %tmp12 = load double, ptr %tmp11, align 8
   %tmp13 = fmul double %tmp12, %arg4
   store double %tmp13, ptr %tmp11, align 8
@@ -104,10 +106,10 @@ bb9:                                              ; preds = %bb26, %bb8
 
 Copy_0:                                             ; preds = %Copy_0, %bb9
   %tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
-  %tmp16 = getelementptr inbounds [1023 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+  %tmp16 = getelementptr inbounds [1023 x double], ptr @arg6, i64 %tmp, i64 %tmp15
   %tmp17 = load double, ptr %tmp16, align 8
   %tmp18 = fmul double %tmp17, %arg3
-  %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+  %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
   %tmp20 = load double, ptr %tmp19, align 8
   %tmp21 = fmul double %tmp18, %tmp20
   %tmp22 = load double, ptr %tmp11, align 8
@@ -130,5 +132,3 @@ bb29:                                             ; preds = %bb26
 bb32:                                             ; preds = %bb29
   ret void
 }
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
index 6e9ade869ec6c..ab8ca27b0304b 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
@@ -43,11 +43,12 @@
 ; CHECK: The matrix multiplication pattern was detected
 ;
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
+@A = common global [1600 x [2200 x double]] zeroinitializer
+@B = common global [2200 x [1800 x double]] zeroinitializer
+@tmp = common global [1600 x [1800 x double]] zeroinitializer
 
-; Function Attrs: norecurse nounwind uwtable
-define void @kernel_2mm(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta, ptr nocapture %tmp, ptr nocapture readonly %A, ptr nocapture readonly %B, ptr nocapture readnone %C, ptr nocapture readnone %D) local_unnamed_addr #0 {
+
+define void @kernel_2mm(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -60,17 +61,17 @@ for.body:                                         ; preds = %for.inc25, %entry.s
 
 for.body3:                                        ; preds = %for.inc22, %for.body
   %indvars.iv46 = phi i64 [ 0, %for.body ], [ %indvars.iv.next47, %for.inc22 ]
-  %arrayidx5 = getelementptr inbounds [1800 x double], ptr %tmp, i64 %indvars.iv50, i64 %indvars.iv46
+  %arrayidx5 = getelementptr inbounds [1800 x double], ptr @tmp, i64 %indvars.iv50, i64 %indvars.iv46
   store double 0.000000e+00, ptr %arrayidx5, align 8, !tbaa !2
   br label %for.body8
 
 for.body8:                                        ; preds = %for.body8, %for.body3
   %0 = phi double [ 0.000000e+00, %for.body3 ], [ %add, %for.body8 ]
   %indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body8 ]
-  %arrayidx12 = getelementptr inbounds [2200 x double], ptr %A, i64 %indvars.iv50, i64 %indvars.iv
+  %arrayidx12 = getelementptr inbounds [2200 x double], ptr @A, i64 %indvars.iv50, i64 %indvars.iv
   %1 = load double, ptr %arrayidx12, align 8, !tbaa !2
   %mul = fmul double %1, %alpha
-  %arrayidx16 = getelementptr inbounds [1800 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv46
+  %arrayidx16 = getelementptr inbounds [1800 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv46
   %2 = load double, ptr %arrayidx16, align 8, !tbaa !2
   %mul17 = fmul double %mul, %2
   %add = fadd double %0, %mul17
@@ -93,8 +94,6 @@ for.end27:                                        ; preds = %for.inc25
   ret void
 }
 
-attributes #0 = { norecurse nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="haswell" "target-features"="+aes,+avx,+avx2,+bmi,+bmi2,+cmov,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+rdrnd,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt,-adx,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vl,-avx512vpopcntdq,-clflushopt,-clwb,-clzero,-fma4,-lwp,-mwaitx,-pku,-prefetchwt1,-prfchw,-rdseed,-rtm,-sgx,-sha,-sse4a,-tbm,-xop,-xsavec,-xsaves" "unsafe-fp-math"="false" "use-soft-float"="false" }
-
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
index 4ef0605a0ba75..291085f5feba1 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
@@ -34,11 +34,12 @@
 ;               C[i][j][k][w] += A[i][l][j][q] * B[q][w][l][k];
 ;
 ; CHECK: The tensor contraction pattern was detected
-;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal fastcc void @kernel_tc(ptr nocapture %C, ptr nocapture readonly %A, ptr nocapture readonly %B) {
+@A = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+@B = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+@C = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+
+define internal fastcc void @kernel_tc() {
 entry:
   br label %for.cond1.preheader
 
@@ -60,16 +61,16 @@ for.cond10.preheader:                             ; preds = %for.inc41, %for.con
 
 for.cond13.preheader:                             ; preds = %for.inc38, %for.cond10.preheader
   %indvars.iv7 = phi i64 [ 0, %for.cond10.preheader ], [ %indvars.iv.next8, %for.inc38 ]
-  %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %C, i64 %indvars.iv19, i64 %indvars.iv16, i64 %indvars.iv13, i64 %indvars.iv7
+  %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @C, i64 %indvars.iv19, i64 %indvars.iv16, i64 %indvars.iv13, i64 %indvars.iv7
   %.pre = load double, ptr %arrayidx37, align 8
   br label %for.body15
 
 for.body15:                                       ; preds = %for.body15, %for.cond13.preheader
   %i = phi double [ %.pre, %for.cond13.preheader ], [ %add, %for.body15 ]
   %indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
-  %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %A, i64 %indvars.iv19, i64 %indvars.iv10, i64 %indvars.iv16, i64 %indvars.iv
+  %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @A, i64 %indvars.iv19, i64 %indvars.iv10, i64 %indvars.iv16, i64 %indvars.iv
   %i1 = load double, ptr %arrayidx21, align 8
-  %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %B, i64 %indvars.iv, i64 %indvars.iv7, i64 %indvars.iv10, i64 %indvars.iv13
+  %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @B, i64 %indvars.iv, i64 %indvars.iv7, i64 %indvars.iv10, i64 %indvars.iv13
   %i2 = load double, ptr %arrayidx29, align 8
   %mul = fmul fast double %i2, %i1
   %add = fadd fast double %i, %mul
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
index 09118e252233b..f7f0201739b18 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
@@ -21,10 +21,12 @@
 ; PARALLEL-AST-NOT: #pragma known-parallel
 ; STATS:  1 polly-opt-isl    - Number of matrix multiplication patterns detected and optimized
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+@arg5 = common global [100 x [1056 x double]] zeroinitializer
+@arg6 = common global [100 x [1024 x double]] zeroinitializer
+@arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
 bb:
   br label %bb8
 
@@ -34,7 +36,7 @@ bb8:                                              ; preds = %bb29, %bb
 
 bb9:                                              ; preds = %bb26, %bb8
   %tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
-  %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+  %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
   %tmp12 = load double, ptr %tmp11, align 8
   %tmp13 = fmul double %tmp12, %arg4
   store double %tmp13, ptr %tmp11, align 8
@@ -42,10 +44,10 @@ bb9:                                              ; preds = %bb26, %bb8
 
 Copy_0:                                             ; preds = %Copy_0, %bb9
   %tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
-  %tmp16 = getelementptr inbounds [1024 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+  %tmp16 = getelementptr inbounds [1024 x double], ptr @arg6, i64 %tmp, i64 %tmp15
   %tmp17 = load double, ptr %tmp16, align 8
   %tmp18 = fmul double %tmp17, %arg3
-  %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+  %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
   %tmp20 = load double, ptr %tmp19, align 8
   %tmp21 = fmul double %tmp18, %tmp20
   %tmp22 = load double, ptr %tmp11, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
index b771d1f87537e..b8199bbf48692 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
@@ -20,10 +20,11 @@
 ; CHECK: The tensor contraction pattern was detected
 ; CHECK: The matrix multiplication pattern was detected
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %A, ptr %B, ptr %C) {
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %A) {
 entry:
   br label %entry.split
 
@@ -40,10 +41,10 @@ for.cond4.preheader:                              ; preds = %for.inc13, %for.con
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv32
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv32
   %tmp = load double, ptr %arrayidx8, align 8
   %mul = fmul double %tmp, %A
-  %arrayidx12 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv35, i64 %indvars.iv32
+  %arrayidx12 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv35, i64 %indvars.iv32
   %tmp1 = load double, ptr %arrayidx12, align 8
   %add = fadd double %tmp1, %mul
   store double %add, ptr %arrayidx12, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
index 0e4540eb7ba3c..c1e8f9871cd60 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
@@ -82,11 +82,12 @@
 ; CHECK-NEXT:                }
 ; CHECK-NEXT:              }
 ; CHECK-NEXT:            }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [3000 x [2000 x double]] zeroinitializer
+@B = common global [3000 x [2000 x double]] zeroinitializer
+@C = common global [3000 x [2000 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -103,12 +104,12 @@ for.body3:                                        ; preds = %for.inc17, %for.bod
 
 for.body6:                                        ; preds = %for.body6, %for.body3
   %indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [2000 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [2000 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
   %tmp = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [2000 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+  %arrayidx12 = getelementptr inbounds [2000 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
   %tmp1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %tmp, %tmp1
-  %arrayidx16 = getelementptr inbounds [2000 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+  %arrayidx16 = getelementptr inbounds [2000 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
   %tmp2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp2, %mul
   store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
index 9678ad83ff048..847f4dd3903e2 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
@@ -12,11 +12,12 @@
 ; Check that we disable the Loop Vectorizer.
 ;
 ; CHECK: !{!"llvm.loop.vectorize.enable", i1 false}
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, ptr %A, ptr %B, ptr %C, ptr %C1) {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, ptr %C1) {
 entry:
   br label %entry.split
 
@@ -34,13 +35,13 @@ for.body3:                                        ; preds = %for.inc19, %for.bod
 for.body6:                                        ; preds = %for.body6, %for.body3
   %indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body6 ]
   %tmp = load double, ptr %C1, align 8
-  %arrayidx9 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv43, i64 %indvars.iv
+  %arrayidx9 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv43, i64 %indvars.iv
   %tmp1 = load double, ptr %arrayidx9, align 8
-  %arrayidx13 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv40
+  %arrayidx13 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv40
   %tmp2 = load double, ptr %arrayidx13, align 8
   %mul = fmul double %tmp1, %tmp2
   %add = fadd double %tmp, %mul
-  %arrayidx17 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+  %arrayidx17 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
   %tmp3 = load double, ptr %arrayidx17, align 8
   %add18 = fadd double %tmp3, %add
   store double %add18, ptr %arrayidx17, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
index 9c99a090b69e7..74bc347271d41 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
@@ -10,10 +10,12 @@
 ;
 ; CHECK: The tensor contraction pattern was detected
 ;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [1024 x [64 x [64 x double]]] zeroinitializer
+@B = common global [64 x [1024 x [64 x double]]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
 entry:
   br label %for.cond1.preheader
 
@@ -31,12 +33,12 @@ for.cond7.preheader:                              ; preds = %for.inc24, %for.con
 
 for.body9:                                        ; preds = %for.body9, %for.cond7.preheader
   %indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
-  %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+  %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
   %i = load double, ptr %arrayidx13, align 8
-  %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr %B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
+  %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr @B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
   %i1 = load double, ptr %arrayidx19, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx23 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+  %arrayidx23 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
   %i2 = load double, ptr %arrayidx23, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
index 8e14035ce8629..db18ef773a520 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
@@ -10,10 +10,12 @@
 ;
 ; CHECK: The tensor contraction pattern was detected
 ;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [32 x [32 x [1024 x double]]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [32 x [1024 x [32 x double]]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta) {
 entry:
   br label %for.cond1.preheader
 
@@ -31,12 +33,12 @@ for.cond7.preheader:                              ; preds = %for.inc24, %for.con
 
 for.body9:                                        ; preds = %for.body9, %for.cond7.preheader
   %indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
-  %arrayidx13 = getelementptr inbounds [32 x [1024 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+  %arrayidx13 = getelementptr inbounds [32 x [1024 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
   %i = load double, ptr %arrayidx13, align 8
-  %arrayidx17 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv40
+  %arrayidx17 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv40
   %i1 = load double, ptr %arrayidx17, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx23 = getelementptr inbounds [1024 x [32 x double]], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40, i64 %indvars.iv37
+  %arrayidx23 = getelementptr inbounds [1024 x [32 x double]], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40, i64 %indvars.iv37
   %i2 = load double, ptr %arrayidx23, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
index 4f562c306f96a..038b81702e614 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
@@ -12,10 +12,13 @@
 ;
 ; CHECK: The tensor contraction pattern was detected
 ;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+@B = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+@C = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
 entry:
   br label %for.cond1.preheader
 
@@ -41,12 +44,12 @@ for.cond13.preheader:                             ; preds = %for.inc38, %for.con
 
 for.body15:                                       ; preds = %for.body15, %for.cond13.preheader
   %indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
-  %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %A, i64 %indvars.iv71, i64 %indvars.iv62, i64 %indvars.iv68, i64 %indvars.iv
+  %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @A, i64 %indvars.iv71, i64 %indvars.iv62, i64 %indvars.iv68, i64 %indvars.iv
   %i = load double, ptr %arrayidx21, align 8
-  %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %B, i64 %indvars.iv, i64 %indvars.iv59, i64 %indvars.iv62, i64 %indvars.iv65
+  %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @B, i64 %indvars.iv, i64 %indvars.iv59, i64 %indvars.iv62, i64 %indvars.iv65
   %i1 = load double, ptr %arrayidx29, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59
+  %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59
   %i2 = load double, ptr %arrayidx37, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx37, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
index 32ded897d4ff9..f47ea04e317e8 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
@@ -12,10 +12,12 @@
 ;
 ; CHECK: The tensor contraction pattern was detected
 ;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(ptr %C, ptr %A, ptr %B) {
+@A = common global [4 x [4 x [8 x [1024 x [8 x double]]]]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [8 x [8 x [4 x [1024 x [4 x double]]]]] zeroinitializer
+
+define internal void @kernel_tc() {
 entry:
   br label %for.cond1.preheader
 
@@ -41,12 +43,12 @@ for.cond13.preheader:                             ; preds = %for.inc38, %for.con
 
 for.body15:                                       ; preds = %for.body15, %for.cond13.preheader
   %indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
-  %arrayidx23 = getelementptr inbounds [4 x [8 x [1024 x [8 x double]]]], ptr %A, i64 %indvars.iv, i64 %indvars.iv65, i64 %indvars.iv68, i64 %indvars.iv62, i64 %indvars.iv71
+  %arrayidx23 = getelementptr inbounds [4 x [8 x [1024 x [8 x double]]]], ptr @A, i64 %indvars.iv, i64 %indvars.iv65, i64 %indvars.iv68, i64 %indvars.iv62, i64 %indvars.iv71
   %i = load double, ptr %arrayidx23, align 8
-  %arrayidx27 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv62, i64 %indvars.iv59
+  %arrayidx27 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv62, i64 %indvars.iv59
   %i1 = load double, ptr %arrayidx27, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx37 = getelementptr inbounds [8 x [4 x [1024 x [4 x double]]]], ptr %C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59, i64 %indvars.iv
+  %arrayidx37 = getelementptr inbounds [8 x [4 x [1024 x [4 x double]]]], ptr @C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59, i64 %indvars.iv
   %i2 = load double, ptr %arrayidx37, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx37, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
index 155177bdfade0..2c4c434815901 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
@@ -12,11 +12,12 @@
 ;                 C[i][j][k][w][q][x] += A[l][x][j][k] * B[w][q][l][i];
 ;
 ; CHECK: The tensor contraction pattern was detected
-;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(ptr %C, ptr %A, ptr %B) {
+@A = common global [1024 x [8 x [16 x [8 x double]]]] zeroinitializer
+@B = common global [8 x [8 x [1024 x [16 x double]]]] zeroinitializer
+@C = common global [16 x [16 x [8 x [8 x [8 x [8 x double]]]]]] zeroinitializer
+
+define internal void @kernel_tc() {
 entry:
   br label %for.cond1.preheader
 
@@ -46,12 +47,12 @@ for.cond16.preheader:                             ; preds = %for.inc45, %for.con
 
 for.body18:                                       ; preds = %for.body18, %for.cond16.preheader
   %indvars.iv = phi i64 [ 0, %for.cond16.preheader ], [ %indvars.iv.next, %for.body18 ]
-  %arrayidx24 = getelementptr inbounds [8 x [16 x [8 x double]]], ptr %A, i64 %indvars.iv76, i64 %indvars.iv, i64 %indvars.iv82, i64 %indvars.iv79
+  %arrayidx24 = getelementptr inbounds [8 x [16 x [8 x double]]], ptr @A, i64 %indvars.iv76, i64 %indvars.iv, i64 %indvars.iv82, i64 %indvars.iv79
   %i = load double, ptr %arrayidx24, align 8
-  %arrayidx32 = getelementptr inbounds [8 x [1024 x [16 x double]]], ptr %B, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv76, i64 %indvars.iv85
+  %arrayidx32 = getelementptr inbounds [8 x [1024 x [16 x double]]], ptr @B, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv76, i64 %indvars.iv85
   %i1 = load double, ptr %arrayidx32, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx44 = getelementptr inbounds [16 x [8 x [8 x [8 x [8 x double]]]]], ptr %C, i64 %indvars.iv85, i64 %indvars.iv82, i64 %indvars.iv79, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv
+  %arrayidx44 = getelementptr inbounds [16 x [8 x [8 x [8 x [8 x double]]]]], ptr @C, i64 %indvars.iv85, i64 %indvars.iv82, i64 %indvars.iv79, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv
   %i2 = load double, ptr %arrayidx44, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx44, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
index bfe5c5249a3a8..40eb5e9d522c5 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
@@ -11,10 +11,12 @@
 ;
 ; CHECK: The tensor contraction pattern was detected
 ;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
 
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [1024 x [64 x [64 x double]]] zeroinitializer
+@B = common global [64 x [1024 x [64 x double]]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
 entry:
   br label %for.cond1.preheader
 
@@ -32,12 +34,12 @@ for.cond7.preheader:                              ; preds = %for.inc24, %for.con
 
 for.body9:                                        ; preds = %for.body9, %for.cond7.preheader
   %indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
-  %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+  %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
   %i = load double, ptr %arrayidx13, align 8
-  %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr %B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
+  %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr @B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
   %i1 = load double, ptr %arrayidx19, align 8
   %mul = fmul fast double %i1, %i
-  %arrayidx23 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+  %arrayidx23 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
   %i2 = load double, ptr %arrayidx23, align 8
   %add = fadd fast double %i2, %mul
   store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
index 9844d377e609d..649a1fd6bc89b 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
@@ -140,11 +140,12 @@
 ; EXTRACTION-OF-MACRO-KERNEL-NEXT:        }
 ; EXTRACTION-OF-MACRO-KERNEL-NEXT:      }
 ; EXTRACTION-OF-MACRO-KERNEL-NEXT:    }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+@arg5 = common global [100 x [1056 x double]] zeroinitializer
+@arg6 = common global [100 x [1024 x double]] zeroinitializer
+@arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
 bb:
   br label %bb8
 
@@ -154,7 +155,7 @@ bb8:                                              ; preds = %bb29, %bb
 
 bb9:                                              ; preds = %bb26, %bb8
   %tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
-  %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+  %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
   %tmp12 = load double, ptr %tmp11, align 8
   %tmp13 = fmul double %tmp12, %arg4
   store double %tmp13, ptr %tmp11, align 8
@@ -162,10 +163,10 @@ bb9:                                              ; preds = %bb26, %bb8
 
 Copy_0:                                             ; preds = %Copy_0, %bb9
   %tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
-  %tmp16 = getelementptr inbounds [1024 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+  %tmp16 = getelementptr inbounds [1024 x double], ptr @arg6, i64 %tmp, i64 %tmp15
   %tmp17 = load double, ptr %tmp16, align 8
   %tmp18 = fmul double %tmp17, %arg3
-  %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+  %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
   %tmp20 = load double, ptr %tmp19, align 8
   %tmp21 = fmul double %tmp18, %tmp20
   %tmp22 = load double, ptr %tmp11, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
index 250641d57bac5..d7aa4979ad02f 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
@@ -77,11 +77,12 @@
 ; PATTERN-MATCHING-OPTS-NEXT:            }
 ; PATTERN-MATCHING-OPTS-NEXT:      }
 ; PATTERN-MATCHING-OPTS-NEXT:    }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -98,12 +99,12 @@ for.cond4.preheader:                              ; preds = %for.inc17, %for.con
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv38
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv38
   %tmp = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv38, i64 %indvars.iv
+  %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv38, i64 %indvars.iv
   %tmp1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %tmp, %tmp1
-  %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv
+  %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv
   %tmp2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp2, %mul
   store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
index ad2c195ba1e8e..3787f71d0af83 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
@@ -429,10 +429,12 @@
 ; AUTO-VECTORIZATION:    2 licm             - Number of load insts hoisted or sunk
 ; AUTO-VECTORIZATION:   32 licm             - Number of memory locations promoted to registers
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -461,12 +463,12 @@ for.body6.lr.ph:                                  ; preds = %for.cond4.preheader
 
 for.body6:                                        ; preds = %for.body6, %for.body6.lr.ph
   %indvars.iv = phi i64 [ 0, %for.body6.lr.ph ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv45, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv45, i64 %indvars.iv
   %tmp = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv41
+  %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv41
   %tmp1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %tmp, %tmp1
-  %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv45, i64 %indvars.iv41
+  %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv45, i64 %indvars.iv41
   %tmp2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp2, %mul
   store double %add, ptr %arrayidx16, align 8
@@ -499,5 +501,3 @@ for.cond.for.end22_crit_edge:                     ; preds = %for.inc20
 for.end22:                                        ; preds = %for.cond.for.end22_crit_edge, %entry.split
   ret void
 }
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
index 1d3cdbdbfdd85..ad8874b3c19df 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
@@ -124,11 +124,12 @@
 ; AUTO-VECTORIZATION: 146 licm             - Number of instructions hoisted out of loop
 ; AUTO-VECTORIZATION: 1 licm             - Number of load insts hoisted or sunk
 ; AUTO-VECTORIZATION: 32 licm             - Number of memory locations promoted to registers
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+@A = common global [1024 x [1020 x double]] zeroinitializer
+@B = common global [1024 x [1020 x double]] zeroinitializer
+@C = common global [1024 x [1020 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -145,12 +146,12 @@ for.cond4.preheader:                              ; preds = %for.inc17, %for.con
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1020 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1020 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
   %tmp = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [1020 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+  %arrayidx12 = getelementptr inbounds [1020 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
   %tmp1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %tmp, %tmp1
-  %arrayidx16 = getelementptr inbounds [1020 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+  %arrayidx16 = getelementptr inbounds [1020 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
   %tmp2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp2, %mul
   store double %add, ptr %arrayidx16, align 8
@@ -171,5 +172,3 @@ for.inc20:                                        ; preds = %for.inc17
 for.end22:                                        ; preds = %for.inc20
   ret void
 }
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
index 59eaa4a0928e9..5e3f5697b4012 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
@@ -108,11 +108,12 @@
 ; CHECK-NEXT:      }
 ; CHECK-NEXT:    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-; Function Attrs: noinline nounwind uwtable
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, float %alpha, float %beta, ptr %C, ptr %A, ptr %B) #0 {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, float %alpha, float %beta) {
 entry:
   br label %entry.split
 
@@ -129,12 +130,12 @@ for.cond4.preheader:                              ; preds = %for.inc17, %for.con
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x float], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x float], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
   %tmp = load float, ptr %arrayidx8, align 4
-  %arrayidx12 = getelementptr inbounds [1024 x float], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+  %arrayidx12 = getelementptr inbounds [1024 x float], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
   %tmp1 = load float, ptr %arrayidx12, align 4
   %mul = fmul float %tmp, %tmp1
-  %arrayidx16 = getelementptr inbounds [1024 x float], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+  %arrayidx16 = getelementptr inbounds [1024 x float], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
   %tmp2 = load float, ptr %arrayidx16, align 4
   %add = fadd float %tmp2, %mul
   store float %add, ptr %arrayidx16, align 4
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
index 2544d502a2dc5..4e81c4def4248 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
@@ -76,12 +76,12 @@
 ; CHECK-NEXT:            }
 ; CHECK-NEXT:      }
 ; CHECK-NEXT:    }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
 
-; Function Attrs: noinline nounwind uwtable
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
 entry:
   br label %entry.split
 
@@ -98,13 +98,13 @@ for.cond4.preheader:                              ; preds = %for.inc17, %for.con
 
 for.body6:                                        ; preds = %for.body6, %for.cond4.preheader
   %indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [1024 x float], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+  %arrayidx8 = getelementptr inbounds [1024 x float], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
   %tmp = load float, ptr %arrayidx8, align 4
   %conv = fpext float %tmp to double
-  %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+  %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
   %tmp1 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %conv, %tmp1
-  %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+  %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
   %tmp2 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp2, %mul
   store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll b/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
index 64285891a16c7..7c399ddeb0f87 100644
--- a/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
+++ b/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
@@ -12,11 +12,12 @@
 ; when the AccMap cannot be reduced to a single disjunct.
 ;
 ; CHECK: The matrix multiplication pattern was detected
-;
-; ModuleID = 'pattern_matching_based_opts_splitmap.ll'
-;
-; Function Attrs: noinline nounwind uwtable
-define void @pattern_matching_based_opts_splitmap(ptr noalias dereferenceable(32) %C, ptr noalias dereferenceable(12544) %A, ptr noalias dereferenceable(12544) %B) {
+
+@A = common global [2 x [784 x double]] zeroinitializer
+@B = common global [784 x [2 x double]] zeroinitializer
+@C = common global [2 x [2 x double]] zeroinitializer
+
+define void @pattern_matching_based_opts_splitmap() {
 entry:
   br label %for.body
 
@@ -30,12 +31,12 @@ for.body3:                                        ; preds = %for.body, %for.inc1
 
 for.body6:                                        ; preds = %for.body3, %for.body6
   %k = phi i64 [ 0, %for.body3 ], [ %add17, %for.body6 ]
-  %arrayidx8 = getelementptr inbounds [784 x double], ptr %A, i64 %i, i64 %k
+  %arrayidx8 = getelementptr inbounds [784 x double], ptr @A, i64 %i, i64 %k
   %tmp6 = load double, ptr %arrayidx8, align 8
-  %arrayidx12 = getelementptr inbounds [2 x double], ptr %B, i64 %k, i64 %j
+  %arrayidx12 = getelementptr inbounds [2 x double], ptr @B, i64 %k, i64 %j
   %tmp10 = load double, ptr %arrayidx12, align 8
   %mul = fmul double %tmp6, %tmp10
-  %arrayidx16 = getelementptr inbounds [2 x double], ptr %C, i64 %i, i64 %j
+  %arrayidx16 = getelementptr inbounds [2 x double], ptr @C, i64 %i, i64 %j
   %tmp14 = load double, ptr %arrayidx16, align 8
   %add = fadd double %tmp14, %mul
   store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScopInfo/assume_gep_bounds.ll b/polly/test/ScopInfo/assume_gep_bounds.ll
index bd14e3868d525..5a9047a58f7c8 100644
--- a/polly/test/ScopInfo/assume_gep_bounds.ll
+++ b/polly/test/ScopInfo/assume_gep_bounds.ll
@@ -1,7 +1,7 @@
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-;    void foo(float A[][20][30], long n, long m, long p) {
+;    float A[10][20][30];
+;    void foo(long n, long m, long p) {
 ;      for (long i = 0; i < n; i++)
 ;        for (long j = 0; j < m; j++)
 ;          for (long k = 0; k < p; k++)
@@ -23,9 +23,9 @@
 ; CHECK-DAG:                    m <= 20
 ; CHECK:                   }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@A = local_unnamed_addr global [10 x [20 x [30 x float]]] zeroinitializer
 
-define void @foo(ptr %A, i64 %n, i64 %m, i64 %p) {
+define void @foo(i64 %n, i64 %m, i64 %p) {
 entry:
   br label %for.cond
 
@@ -54,7 +54,7 @@ for.body6:                                        ; preds = %for.cond4
   %add = add nsw i64 %i.0, %j.0
   %add7 = add nsw i64 %add, %k.0
   %conv = sitofp i64 %add7 to float
-  %arrayidx9 = getelementptr inbounds [20 x [30 x float]], ptr %A, i64 %i.0, i64 %j.0, i64 %k.0
+  %arrayidx9 = getelementptr inbounds [20 x [30 x float]], ptr @A, i64 %i.0, i64 %j.0, i64 %k.0
   store float %conv, ptr %arrayidx9, align 4
   br label %for.inc
 
diff --git a/polly/test/ScopInfo/assume_gep_bounds_2.ll b/polly/test/ScopInfo/assume_gep_bounds_2.ll
index 7a8c1870abe25..948727886ff88 100644
--- a/polly/test/ScopInfo/assume_gep_bounds_2.ll
+++ b/polly/test/ScopInfo/assume_gep_bounds_2.ll
@@ -1,8 +1,8 @@
 ; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 \
 ; RUN:  -polly-precise-inbounds | FileCheck %s
 ;
-;    void foo(float A[restrict][20], float B[restrict][20], long n, long m,
-;             long p) {
+;    float A[10][20], B[10][20];
+;    void foo(long n, long m, long p) {
 ;      for (long i = 0; i < n; i++)
 ;        for (long j = 0; j < m; j++)
 ;          A[i][j] = i + j;
@@ -19,9 +19,10 @@
 ; CHECK:      Assumed Context:
 ; CHECK-NEXT: [n, m, p] -> {  : p <= 20 and (n <= 0 or (n > 0 and m <= 20)) }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@A = common global [10 x [20 x float]] zeroinitializer
+@B = common global [10 x [20 x float]] zeroinitializer
 
-define void @foo(ptr noalias %A, ptr noalias %B, i64 %n, i64 %m, i64 %p) {
+define void @foo(i64 %n, i64 %m, i64 %p) {
 entry:
   br label %for.cond
 
@@ -41,7 +42,7 @@ for.cond1:                                        ; preds = %for.inc, %for.body
 for.body3:                                        ; preds = %for.cond1
   %add = add nsw i64 %i.0, %j.0
   %conv = sitofp i64 %add to float
-  %arrayidx4 = getelementptr inbounds [20 x float], ptr %A, i64 %i.0, i64 %j.0
+  %arrayidx4 = getelementptr inbounds [20 x float], ptr @A, i64 %i.0, i64 %j.0
   store float %conv, ptr %arrayidx4, align 4
   br label %for.inc
 
@@ -75,7 +76,7 @@ for.cond14:                                       ; preds = %for.inc22, %for.bod
 for.body17:                                       ; preds = %for.cond14
   %add18 = add nsw i64 %i8.0, %j13.0
   %conv19 = sitofp i64 %add18 to float
-  %arrayidx21 = getelementptr inbounds [20 x float], ptr %B, i64 %i8.0, i64 %j13.0
+  %arrayidx21 = getelementptr inbounds [20 x float], ptr @B, i64 %i8.0, i64 %j13.0
   store float %conv19, ptr %arrayidx21, align 4
   br label %for.inc22
 
diff --git a/polly/test/ScopInfo/loop_affine_bound_0.ll b/polly/test/ScopInfo/loop_affine_bound_0.ll
index 918d4099740ce..e8c4e1ddaa024 100644
--- a/polly/test/ScopInfo/loop_affine_bound_0.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_0.ll
@@ -1,16 +1,16 @@
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-; void f(long a[][128], long N, long M) {
+; long a[10][128];
+; void f(long N, long M) {
 ;   long i, j;
 ;   for (j = 0; j < (4*N + 7*M +3); ++j)
 ;     for (i = 0; i < (5*N + 2); ++i)
 ;       a[j][i] = 0
 ;   }
 
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
+@a = local_unnamed_addr global [10 x [128 x i64]] zeroinitializer
 
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
 entry:
   %0 = shl i64 %N, 2                              ; <i64> [#uses=2]
   %1 = mul i64 %M, 7                              ; <i64> [#uses=2]
@@ -21,7 +21,7 @@ entry:
 
 bb1:                                              ; preds = %bb2.preheader, %bb1
   %i.06 = phi i64 [ 0, %bb2.preheader ], [ %5, %bb1 ] ; <i64> [#uses=2]
-  %scevgep = getelementptr [128 x i64], ptr %a, i64 %i.06, i64 %10 ; <ptr> [#uses=1]
+  %scevgep = getelementptr [128 x i64], ptr @a, i64 %i.06, i64 %10 ; <ptr> [#uses=1]
   store i64 0, ptr %scevgep, align 8
   %5 = add nsw i64 %i.06, 1                       ; <i64> [#uses=2]
   %exitcond = icmp eq i64 %5, %8                  ; <i1> [#uses=1]
diff --git a/polly/test/ScopInfo/loop_affine_bound_1.ll b/polly/test/ScopInfo/loop_affine_bound_1.ll
index 8f7a87f1c5ac4..0e5bf0e067a20 100644
--- a/polly/test/ScopInfo/loop_affine_bound_1.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_1.ll
@@ -1,16 +1,17 @@
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output< %s 2>&1 | FileCheck %s
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-;void f(long a[][128], long N, long M) {
+;
+; long a[10][128];
+; void f(long N, long M) {
 ;  long i, j;
 ;  for (j = 0; j < (4*N + 7*M +3); ++j)
 ;    for (i = j; i < (5*N + 2); ++i)
 ;        ...
 ;}
 
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
+@a = local_unnamed_addr global [10 x [128 x i64]] zeroinitializer
 
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
 entry:
   %0 = shl i64 %N, 2                              ; <i64> [#uses=2]
   %1 = mul i64 %M, 7                              ; <i64> [#uses=2]
@@ -21,7 +22,7 @@ entry:
 
 bb1:                                              ; preds = %bb2.preheader, %bb1
   %indvar = phi i64 [ 0, %bb2.preheader ], [ %indvar.next, %bb1 ] ; <i64> [#uses=2]
-  %scevgep = getelementptr [128 x i64], ptr %a, i64 %indvar, i64 %tmp10 ; <ptr> [#uses=1]
+  %scevgep = getelementptr [128 x i64], ptr @a, i64 %indvar, i64 %tmp10 ; <ptr> [#uses=1]
   store i64 0, ptr %scevgep, align 8
   %indvar.next = add i64 %indvar, 1               ; <i64> [#uses=2]
   %exitcond = icmp sge i64 %indvar.next, %tmp9     ; <i1> [#uses=1]
@@ -61,5 +62,5 @@ return:                                           ; preds = %bb3, %entry
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] : i0 <= 2 + 4N + 7M; Stmt_bb1[0, i1] -> [0, i1] : 7M <= -3 - 4N };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, 129i0] };
+; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i0 + i1, i0] };
 ; CHECK-NEXT: }
diff --git a/polly/test/ScopInfo/loop_affine_bound_2.ll b/polly/test/ScopInfo/loop_affine_bound_2.ll
index 2d9f997a0767f..8b1efc1372eac 100644
--- a/polly/test/ScopInfo/loop_affine_bound_2.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_2.ll
@@ -1,16 +1,16 @@
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-; void f(long a[][128], long N, long M) {
+; long a[100][128];
+; void f(long N, long M) {
 ;   long i, j;
 ;   for (j = 0; j < (4*N + 7*M +3); ++j)
 ;     for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i)
 ;         a[i][j] = 0;
 ; }
 
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
+@a = local_unnamed_addr global [100 x [128 x i64]] zeroinitializer
 
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
 entry:
   %0 = shl i64 %N, 2
   %1 = mul i64 %M, 7
@@ -46,7 +46,7 @@ bb:                                               ; preds = %bb3, %bb.nph8
 bb1:                                              ; preds = %bb1, %bb
   %indvar = phi i64 [ 0, %bb ], [ %indvar.next, %bb1 ]
   %tmp16 = add i64 %indvar, %tmp15
-  %scevgep = getelementptr [128 x i64], ptr %a, i64 %tmp16, i64 %tmp17
+  %scevgep = getelementptr [128 x i64], ptr @a, i64 %tmp16, i64 %tmp17
   store i64 0, ptr %scevgep
   %indvar.next = add i64 %indvar, 1
   %exitcond = icmp eq i64 %indvar.next, %tmp13
@@ -72,5 +72,5 @@ return:                                           ; preds = %bb3, %entry
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + i1, 897i0] };
+; CHECK-NEXT:             [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + 7i0 + i1, i0] };
 ; CHECK-NEXT: }
diff --git a/polly/test/ScopInfo/many-scalar-dependences.ll b/polly/test/ScopInfo/many-scalar-dependences.ll
index 5b003325ef0fb..0ec9eb547ed23 100644
--- a/polly/test/ScopInfo/many-scalar-dependences.ll
+++ b/polly/test/ScopInfo/many-scalar-dependences.ll
@@ -1,6 +1,6 @@
 ; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-;
-;    void f(float a[100][100]) {
+;    float a[100][100];
+;    void f() {
 ;      float x;
 ;
 ;      for (int i = 0; i < 100; i++) {
@@ -147,7 +147,9 @@
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-define void @f(ptr %a) {
+@a = common global [100 x [100 x float]] zeroinitializer
+
+define void @f() {
 bb:
   br label %bb5
 
@@ -184,7 +186,7 @@ bb11:                                             ; preds = %bb10
 
 bb12:                                             ; preds = %bb11, %bb10
   %x.3 = phi float [ 4.200000e+01, %bb11 ], [ %x.2, %bb10 ]
-  %tmp13 = getelementptr inbounds [100 x float], ptr %a, i64 %indvars.iv2, i64 %indvars.iv
+  %tmp13 = getelementptr inbounds [100 x float], ptr @a, i64 %indvars.iv2, i64 %indvars.iv
   %tmp14 = load float, ptr %tmp13, align 4
   %tmp15 = fadd float %tmp14, %x.3
   store float %tmp15, ptr %tmp13, align 4
diff --git a/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll b/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
index 4a1ee3b1af51d..a7dab38705131 100644
--- a/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
+++ b/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
@@ -1,8 +1,8 @@
 ; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ;    #define N 400
-;
-;    void first_higher_dimensional(float A[][N]) {
+;    float A[N][N], B[N][N];
+;    void first_higher_dimensional() {
 ;      for (long i = 0; i < N; i++)
 ;        for (long j = 0; j < N; j++)
 ;          A[i][j] += i + j;
@@ -14,7 +14,7 @@
 ;          A[i][j] += i + j;
 ;    }
 
-;    void first_lower_dimensional(float A[][N], float B[][N]) {
+;    void first_lower_dimensional() {
 ;      for (long i = 0; i < N; i++)
 ;        for (long j = 0; j < N; j++)
 ;          B[i][j] += i + j;
@@ -90,9 +90,10 @@
 ; CHECK-NEXT:             { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
 ; CHECK-NEXT: }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@A = common global [400 x [400 x float]] zeroinitializer
+@B = common global [400 x [400 x float]] zeroinitializer
 
-define void @first_higher_dimensional(ptr %A) {
+define void @first_higher_dimensional() {
 bb:
   br label %bb4
 
@@ -112,7 +113,7 @@ bb6:                                              ; preds = %bb12, %bb5
 bb7:                                              ; preds = %bb6
   %tmp = add nuw nsw i64 %i.0, %j.0
   %tmp8 = sitofp i64 %tmp to float
-  %tmp9 = getelementptr inbounds [400 x float], ptr %A, i64 %i.0, i64 %j.0
+  %tmp9 = getelementptr inbounds [400 x float], ptr @A, i64 %i.0, i64 %j.0
   %tmp10 = load float, ptr %tmp9, align 4
   %tmp11 = fadd float %tmp10, %tmp8
   store float %tmp11, ptr %tmp9, align 4
@@ -130,11 +131,11 @@ bb15:                                             ; preds = %bb14
   br label %bb4
 
 bb17:                                             ; preds = %bb4
-  %tmp18 = getelementptr inbounds [400 x float], ptr %A, i64 100, i64 100
+  %tmp18 = getelementptr inbounds [400 x float], ptr @A, i64 100, i64 100
   %tmp19 = load float, ptr %tmp18, align 4
-  %tmp21 = load float, ptr %A, align 4
+  %tmp21 = load float, ptr @A, align 4
   %tmp22 = fadd float %tmp21, %tmp19
-  store float %tmp22, ptr %A, align 4
+  store float %tmp22, ptr @A, align 4
   br label %bb23
 
 bb23:                                             ; preds = %bb35, %bb17
@@ -153,7 +154,7 @@ bb25:                                             ; preds = %bb32, %bb24
 bb26:                                             ; preds = %bb25
   %tmp27 = add nuw nsw i64 %i1.0, %j2.0
   %tmp28 = sitofp i64 %tmp27 to float
-  %tmp29 = getelementptr inbounds [400 x float], ptr %A, i64 %i1.0, i64 %j2.0
+  %tmp29 = getelementptr inbounds [400 x float], ptr @A, i64 %i1.0, i64 %j2.0
   %tmp30 = load float, ptr %tmp29, align 4
   %tmp31 = fadd float %tmp30, %tmp28
   store float %tmp31, ptr %tmp29, align 4
@@ -174,7 +175,7 @@ bb37:                                             ; preds = %bb23
   ret void
 }
 
-define void @first_lower_dimensional(ptr %A, ptr %B) {
+define void @first_lower_dimensional() {
 bb:
   br label %bb4
 
@@ -194,7 +195,7 @@ bb6:                                              ; preds = %bb12, %bb5
 bb7:                                              ; preds = %bb6
   %tmp = add nuw nsw i64 %i.0, %j.0
   %tmp8 = sitofp i64 %tmp to float
-  %tmp9 = getelementptr inbounds [400 x float], ptr %B, i64 %i.0, i64 %j.0
+  %tmp9 = getelementptr inbounds [400 x float], ptr @B, i64 %i.0, i64 %j.0
   %tmp10 = load float, ptr %tmp9, align 4
   %tmp11 = fadd float %tmp10, %tmp8
   store float %tmp11, ptr %tmp9, align 4
@@ -212,11 +213,11 @@ bb15:                                             ; preds = %bb14
   br label %bb4
 
 bb17:                                             ; preds = %bb4
-  %tmp18 = getelementptr inbounds [400 x float], ptr %B, i64 100, i64 100
+  %tmp18 = getelementptr inbounds [400 x float], ptr @B, i64 100, i64 100
   %tmp19 = load float, ptr %tmp18, align 4
-  %tmp21 = load float, ptr %A, align 4
+  %tmp21 = load float, ptr @A, align 4
   %tmp22 = fadd float %tmp21, %tmp19
-  store float %tmp22, ptr %A, align 4
+  store float %tmp22, ptr @A, align 4
   br label %bb23
 
 bb23:                                             ; preds = %bb35, %bb17
@@ -235,7 +236,7 @@ bb25:                                             ; preds = %bb32, %bb24
 bb26:                                             ; preds = %bb25
   %tmp27 = add nuw nsw i64 %i1.0, %j2.0
   %tmp28 = sitofp i64 %tmp27 to float
-  %tmp29 = getelementptr inbounds [400 x float], ptr %A, i64 %i1.0, i64 %j2.0
+  %tmp29 = getelementptr inbounds [400 x float], ptr @A, i64 %i1.0, i64 %j2.0
   %tmp30 = load float, ptr %tmp29, align 4
   %tmp31 = fadd float %tmp30, %tmp28
   store float %tmp31, ptr %tmp29, align 4
diff --git a/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll b/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
index 9a6d8fbe12755..d445194907bc1 100644
--- a/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
+++ b/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
@@ -21,8 +21,8 @@
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: +] [Scalar: 0]
 ; CHECK-NEXT:             { Stmt_for_body[i0] -> MemRef_A[1 + i0, 0] };
 ; CHECK-NEXT: }
-;
-;    void f(int A[][2]) {
+;    int A[100][2];
+;    void f() {
 ;      int(*B)[2] = &A[0][0];
 ;      int(*C)[2] = &A[1][0];
 ;      for (int i = 0; i < 100; i++) {
@@ -34,11 +34,12 @@
 ; Verify that the additional offset to A by accessing it through C is taken into
 ; account.
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-define void @f(ptr %A) {
+@A = common global [100 x [2 x i32]] zeroinitializer, align 4
+
+define void @f() {
 entry:
-  %arrayidx3 = getelementptr inbounds [2 x i32], ptr %A, i64 1, i64 0
+  %arrayidx3 = getelementptr inbounds [2 x i32], ptr @A, i64 1, i64 0
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
@@ -47,7 +48,7 @@ for.cond:                                         ; preds = %for.inc, %entry
   br i1 %exitcond, label %for.body, label %for.end
 
 for.body:                                         ; preds = %for.cond
-  %arrayidx5 = getelementptr inbounds [2 x i32], ptr %A, i64 %indvars.iv, i64 0
+  %arrayidx5 = getelementptr inbounds [2 x i32], ptr @A, i64 %indvars.iv, i64 0
   %tmp1 = load i32, ptr %arrayidx5, align 4
   %inc = add nsw i32 %tmp1, 1
   store i32 %inc, ptr %arrayidx5, align 4
diff --git a/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll b/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
index 5778126ad8f17..bb4339a12d33d 100644
--- a/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
+++ b/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
@@ -9,14 +9,14 @@
 ; invalidated due to the zero size dimension.
 
 ; CHECK: Assumed Context:
-; CHECK-NEXT: {  : false }
+; CHECK-NEXT: {  :  }
 ; CHECK-NEXT: Invalid Context:
 ; CHECK-NEXT: {  : false }
 ; CHECK:      Arrays {
-; CHECK-NEXT:     i8 MemRef_arg[*][0]; // Element size 1
+; CHECK-NEXT:     i8 MemRef_arg[*]; // Element size 1
 ; CHECK-NEXT: }
 ; CHECK-NEXT: Arrays (Bounds as pw_affs) {
-; CHECK-NEXT:     i8 MemRef_arg[*][ { [] -> [(0)] } ]; // Element size 1
+; CHECK-NEXT:     i8 MemRef_arg[*]; // Element size 1
 ; CHECK-NEXT: }
 ; CHECK-NEXT: Alias Groups (0):
 ; CHECK-NEXT:     n/a
@@ -27,16 +27,16 @@
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             { Stmt_bb2[] -> [] };
 ; CHECK-NEXT:         MustWriteAccess :=	[Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             { Stmt_bb2[] -> MemRef_arg[0, 0] };
+; CHECK-NEXT:             { Stmt_bb2[] -> MemRef_arg[0] };
 ; CHECK-NEXT:         MustWriteAccess :=	[Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             { Stmt_bb2[] -> MemRef_arg[o0, o1] : false };
+; CHECK-NEXT:             { Stmt_bb2[] -> MemRef_arg[o0] : false };
 ; CHECK-NEXT: }
 
-target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
-
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) #0
 
-define void @hoge([0 x [0 x i8]]* noalias %arg) {
+@arg = common global [0 x [0 x i8]] zeroinitializer
+
+define void @hoge() {
 bb:
   br label %bb1
 
@@ -44,9 +44,9 @@ bb1:                                              ; preds = %bb5, %bb
   br i1 false, label %bb5, label %bb2
 
 bb2:                                              ; preds = %bb1
-  %tmp = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* %arg, i64 0, i64 0, i64 0
+  %tmp = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* @arg, i64 0, i64 0, i64 0
   store i8 32, i8* %tmp, align 1
-  %tmp3 = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* %arg, i64 0, i64 0, i64 0
+  %tmp3 = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* @arg, i64 0, i64 0, i64 0
   %tmp4 = getelementptr i8, i8* %tmp3, i64 1
   tail call void @llvm.memset.p0i8.i64(i8* %tmp4, i8 32, i64 0, i32 1, i1 false)
   br label %bb5
diff --git a/polly/test/ScopInfo/multidim_with_bitcast.ll b/polly/test/ScopInfo/multidim_with_bitcast.ll
index 0ab9c2d93ff46..7fbad537538c7 100644
--- a/polly/test/ScopInfo/multidim_with_bitcast.ll
+++ b/polly/test/ScopInfo/multidim_with_bitcast.ll
@@ -1,7 +1,5 @@
 ; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 ; Verify that we can look through a bitcast when delinearizing multi-dimensional
 ; arrays.
 
@@ -9,7 +7,9 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 ; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
 ; CHECK: Stmt_bb17[i0] -> MemRef_B[i0, 100]
 
-define void @kernel(ptr %A, ptr %B, ptr %C, ptr %D) {
+@B = local_unnamed_addr global [10 x [101 x float]] zeroinitializer
+
+define void @kernel(ptr %A, ptr %C, ptr %D) {
 bb:
   br label %bb4
 
@@ -29,14 +29,14 @@ bb6:                                              ; preds = %bb16, %bb5
 bb7:                                              ; preds = %bb6
   %tmp = getelementptr inbounds float, ptr %D, i64 %indvars.iv
   %tmp8 = load float, ptr %tmp, align 4
-  %tmp9 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 %indvars.iv
+  %tmp9 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 %indvars.iv
   %tmp10 = load float, ptr %tmp9, align 4
   %tmp11 = fmul float %tmp8, %tmp10
   %tmp12 = getelementptr inbounds [101 x float], ptr %C, i64 %indvars.iv1, i64 %indvars.iv
   store float %tmp11, ptr %tmp12, align 4
   %tmp13 = getelementptr inbounds float, ptr %A, i64 %indvars.iv
   %tmp141 = load i32, ptr %tmp13, align 4
-  %tmp15 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 %indvars.iv
+  %tmp15 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 %indvars.iv
   store i32 %tmp141, ptr %tmp15, align 4
   br label %bb16
 
@@ -47,7 +47,7 @@ bb16:                                             ; preds = %bb7
 bb17:                                             ; preds = %bb6
   %tmp18 = trunc i64 %indvars.iv1 to i32
   %tmp19 = sitofp i32 %tmp18 to float
-  %tmp20 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 100
+  %tmp20 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 100
   store float %tmp19, ptr %tmp20, align 4
   br label %bb21
 
diff --git a/polly/test/ScopInfo/non-precise-inv-load-1.ll b/polly/test/ScopInfo/non-precise-inv-load-1.ll
index d55344b355f13..84d20e800ae96 100644
--- a/polly/test/ScopInfo/non-precise-inv-load-1.ll
+++ b/polly/test/ScopInfo/non-precise-inv-load-1.ll
@@ -20,7 +20,6 @@
 ;        A[i] += I[(signed char)(c + (unsigned char)1)];
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @GI = common global [256 x i32] zeroinitializer, align 16
 
diff --git a/polly/test/ScopInfo/process_added_dimensions.ll b/polly/test/ScopInfo/process_added_dimensions.ll
index 2d06f4b995976..19bef778d4099 100644
--- a/polly/test/ScopInfo/process_added_dimensions.ll
+++ b/polly/test/ScopInfo/process_added_dimensions.ll
@@ -13,21 +13,18 @@
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             { Stmt_for_cond40_preheader_4[i0] -> [i0, 0] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             { Stmt_for_cond40_preheader_4[i0] -> MemRef_call[5, 5, 0] };
+; CHECK-NEXT:             { Stmt_for_cond40_preheader_4[i0] -> MemRef_call[2240] };
 ; CHECK-NEXT:     Stmt_for_cond40_preheader_5
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             { Stmt_for_cond40_preheader_5[i0] : 0 <= i0 <= 1 };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             { Stmt_for_cond40_preheader_5[i0] -> [i0, 1] };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             { Stmt_for_cond40_preheader_5[i0] -> MemRef_call[5, 5, 0] };
+; CHECK-NEXT:             { Stmt_for_cond40_preheader_5[i0] -> MemRef_call[2240] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             { Stmt_for_cond40_preheader_5[i0] -> MemRef__pre160[] };
 ; CHECK-NEXT: }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
 declare noalias ptr @malloc()
 
 define i32 @main() {
diff --git a/polly/test/ScopInfo/remarks.ll b/polly/test/ScopInfo/remarks.ll
index 2c173a31c46e9..df27c7dcf9eda 100644
--- a/polly/test/ScopInfo/remarks.ll
+++ b/polly/test/ScopInfo/remarks.ll
@@ -15,8 +15,8 @@
 ; CHECK: remark: test/ScopInfo/remarks.c:22:16: SCoP ends here but was dismissed.
 ;
 ;    #include <stdio.h>
-;
-;    void valid(int *A, int *B, int N, int M, int C[100][100], int Debug) {
+;    int C[100][100];
+;    void valid(int *A, int *B, int N, int M, int Debug) {
 ;      if (N + M == -1)
 ;        C[0][0] = 0;
 ;
@@ -37,17 +37,17 @@
 ;            A[0] = 0;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @.str = private unnamed_addr constant [8 x i8] c"Printf!\00", align 1
+@C = local_unnamed_addr global [100 x [100 x i32]] zeroinitializer
 
-define void @valid(ptr %A, ptr %B, i32 %N, i32 %M, ptr %C, i32 %Debug) #0 !dbg !4 {
+define void @valid(ptr %A, ptr %B, i32 %N, i32 %M, i32 %Debug) #0 !dbg !4 {
 entry:
   call void @llvm.dbg.value(metadata ptr %A, i64 0, metadata !23, metadata !24), !dbg !25
   call void @llvm.dbg.value(metadata ptr %B, i64 0, metadata !26, metadata !24), !dbg !27
   call void @llvm.dbg.value(metadata i32 %N, i64 0, metadata !28, metadata !24), !dbg !29
   call void @llvm.dbg.value(metadata i32 %M, i64 0, metadata !30, metadata !24), !dbg !31
-  call void @llvm.dbg.value(metadata ptr %C, i64 0, metadata !32, metadata !24), !dbg !33
+  call void @llvm.dbg.value(metadata ptr @C, i64 0, metadata !32, metadata !24), !dbg !33
   call void @llvm.dbg.value(metadata i32 %Debug, i64 0, metadata !34, metadata !24), !dbg !35
   br label %entry.split
 
@@ -57,7 +57,7 @@ entry.split:
   br i1 %cmp, label %if.then, label %if.end, !dbg !39
 
 if.then:                                          ; preds = %entry
-  store i32 0, ptr %C, align 4, !dbg !41
+  store i32 0, ptr @C, align 4, !dbg !41
   br label %if.end, !dbg !40
 
 if.end:                                           ; preds = %if.then, %entry
@@ -89,7 +89,7 @@ for.body.5:                                       ; preds = %for.cond.3
   %arrayidx10 = getelementptr inbounds i32, ptr %B, i64 %tmp11, !dbg !64
   %tmp12 = load i32, ptr %arrayidx10, align 4, !dbg !64
   %add11 = add i32 %tmp10, %tmp12, !dbg !65
-  %arrayidx15 = getelementptr inbounds [100 x i32], ptr %C, i64 %indvars.iv3, i64 %indvars.iv, !dbg !66
+  %arrayidx15 = getelementptr inbounds [100 x i32], ptr @C, i64 %indvars.iv3, i64 %indvars.iv, !dbg !66
   %tmp13 = load i32, ptr %arrayidx15, align 4, !dbg !67
   %add16 = add i32 %tmp13, %add11, !dbg !67
   store i32 %add16, ptr %arrayidx15, align 4, !dbg !67
diff --git a/polly/test/ScopInfo/scalar_to_array.ll b/polly/test/ScopInfo/scalar_to_array.ll
index 3f61d0d723046..24ca5f7232185 100644
--- a/polly/test/ScopInfo/scalar_to_array.ll
+++ b/polly/test/ScopInfo/scalar_to_array.ll
@@ -1,9 +1,6 @@
 ; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 ; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
 
-; ModuleID = 'scalar_to_array.ll'
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
-
 @A = common global [1024 x float] zeroinitializer, align 8
 
 ; Terminating loops without side-effects will be optimized away, hence
diff --git a/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll b/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
index ba4801d9a0006..1393ec520bcb9 100644
--- a/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
+++ b/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
@@ -8,8 +8,6 @@
 ; should have been removed. We use -polly-delicm to trigger such an
 ; iteration of an already deleted MemoryAccess.
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 @ATH = external dso_local unnamed_addr constant [88 x float], align 16
 
 define void @setup_tone_curves() {
@@ -84,7 +82,7 @@ for.inc.1:                                        ; preds = %if.then.1, %if.else
 ; CHECK-NEXT:     Stmt_if_else_1_last
 ; CHECK-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:                 [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_min_1_1__phi[] };
-; CHECK-NEXT:            new: [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_ath[i0] : p_0 <= 576460752303423487 };
+; CHECK-NEXT:            new: [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_ath[i0]
 ; CHECK-NEXT:     Stmt_for_inc_1
 ; CHECK-NEXT:             ReadAccess :=       [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:                 [p_0] -> { Stmt_for_inc_1[i0] -> MemRef_min_1_1__phi[] };
diff --git a/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll b/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
index 3e7883db48fcb..ab56da654c7a0 100644
--- a/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
+++ b/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
@@ -5,8 +5,8 @@
 ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [i, N, M] -> {  : N <= i or (N > i and N >= 0) }
 ; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption:    [i, N, M] -> {  : N <= i or (N > i and M <= 100) }
 ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
-;
-;    void f(int *restrict A, int *restrict B, int i, int N, int M, int C[100][100]) {
+;    int C[100][100];
+;    void f(int *restrict A, int *restrict B, int i, int N, int M) {
 ;      for (; i < N; i++) {
 ;        __builtin_assume(N >= 0);
 ;        for (int j = 0; j != M; j++) {
@@ -52,8 +52,9 @@
 ; YAML: ...
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@C = local_unnamed_addr global [100 x [100 x i32]] zeroinitializer
 
-define void @f(ptr noalias %A, ptr noalias %B, i32 %i, i32 %N, i32 %M, ptr %C) {
+define void @f(ptr noalias %A, ptr noalias %B, i32 %i, i32 %N, i32 %M) {
 entry:
   %tmp = zext i32 %M to i64
   %tmp6 = sext i32 %i to i64
@@ -85,7 +86,7 @@ for.body.4:                                       ; preds = %for.cond.2
   %arrayidx8 = getelementptr inbounds i32, ptr %B, i64 %tmp12
   %tmp13 = load i32, ptr %arrayidx8, align 4
   %add9 = add nsw i32 %tmp11, %tmp13
-  %arrayidx13 = getelementptr inbounds [100 x i32], ptr %C, i64 %indvars.iv3, i64 %indvars.iv
+  %arrayidx13 = getelementptr inbounds [100 x i32], ptr @C, i64 %indvars.iv3, i64 %indvars.iv
   %tmp14 = load i32, ptr %arrayidx13, align 4
   %add14 = add nsw i32 %tmp14, %add9
   store i32 %add14, ptr %arrayidx13, align 4
diff --git a/polly/test/Simplify/gemm.ll b/polly/test/Simplify/gemm.ll
index 5120de2db7677..3c8d576ae1894 100644
--- a/polly/test/Simplify/gemm.ll
+++ b/polly/test/Simplify/gemm.ll
@@ -24,10 +24,11 @@
 ; CHECK-NEXT:            new: { Stmt_bb13[i0, i1, i2] -> MemRef_C[i0, i1] };
 ; CHECK-NEXT: }
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-linux-gnu"
+@A = common global [1024 x [1024 x double]] zeroinitializer
+@B = common global [1024 x [1024 x double]] zeroinitializer
+@C = common global [1024 x [1024 x double]] zeroinitializer
 
-define void @gemm(ptr %A, ptr %B, ptr %C) {
+define void @gemm() {
 bb:
   br label %bb3
 
@@ -51,7 +52,7 @@ bb7:                                              ; preds = %bb6
   br label %bb25
 
 bb8:                                              ; preds = %bb6
-  %tmp = getelementptr inbounds [1024 x float], ptr %C, i64 %i.0, i64 %j.0
+  %tmp = getelementptr inbounds [1024 x float], ptr @C, i64 %i.0, i64 %j.0
   %tmp9 = load float, ptr %tmp, align 4, !tbaa !1
   br label %bb10
 
@@ -69,9 +70,9 @@ bb12:                                             ; preds = %bb10
   br label %bb13
 
 bb13:                                             ; preds = %bb12
-  %tmp14 = getelementptr inbounds [1024 x float], ptr %A, i64 %i.0, i64 %k.0
+  %tmp14 = getelementptr inbounds [1024 x float], ptr @A, i64 %i.0, i64 %k.0
   %tmp15 = load float, ptr %tmp14, align 4, !tbaa !1
-  %tmp16 = getelementptr inbounds [1024 x float], ptr %B, i64 %k.0, i64 %j.0
+  %tmp16 = getelementptr inbounds [1024 x float], ptr @B, i64 %k.0, i64 %j.0
   %tmp17 = load float, ptr %tmp16, align 4, !tbaa !1
   %tmp18 = fmul float %tmp15, %tmp17
   %tmp19 = fadd float %tmp.0, %tmp18
@@ -79,7 +80,7 @@ bb13:                                             ; preds = %bb12
   br label %bb10
 
 bb21:                                             ; preds = %bb11
-  %tmp22 = getelementptr inbounds [1024 x float], ptr %C, i64 %i.0, i64 %j.0
+  %tmp22 = getelementptr inbounds [1024 x float], ptr @C, i64 %i.0, i64 %j.0
   store float %tmp.0.lcssa, ptr %tmp22, align 4, !tbaa !1
   br label %bb23
 
diff --git a/polly/test/Simplify/pr33323.ll b/polly/test/Simplify/pr33323.ll
index 22921d5fba509..5104874d4cb47 100644
--- a/polly/test/Simplify/pr33323.ll
+++ b/polly/test/Simplify/pr33323.ll
@@ -5,9 +5,10 @@
 ; Do not remove the pair (store double %add119, read %add119) as redundant
 ; because the are in the wrong order.
 
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+@data = common global [10 x [1000 x double]] zeroinitializer
+@symmat = common global [10 x [1000 x double]] zeroinitializer
 
-define fastcc void @pr33323(ptr nocapture %data, ptr nocapture %symmat) {
+define fastcc void @pr33323() {
 entry:
   br label %for.body98
 
@@ -20,14 +21,14 @@ for.body98:
 
 for.body105:
   %indvars.iv = phi i64 [ 0, %for.body98 ], [ %indvars.iv.next, %for.body105 ]
-  %arrayidx109 = getelementptr inbounds [1000 x double], ptr %data, i64 %indvars.iv, i64 0
+  %arrayidx109 = getelementptr inbounds [1000 x double], ptr @data, i64 %indvars.iv, i64 0
   %add119 = fadd double undef, undef
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
   %exitcond = icmp eq i64 %indvars.iv.next, 1000
   br i1 %exitcond, label %for.end122, label %for.body105
 
 for.end122:
-  %arrayidx130 = getelementptr inbounds [1000 x double], ptr %symmat, i64 %indvars.iv13, i64 0
+  %arrayidx130 = getelementptr inbounds [1000 x double], ptr @symmat, i64 %indvars.iv13, i64 0
   store double %add119, ptr %arrayidx130
   %indvars.iv.next14 = add nuw nsw i64 %indvars.iv13, 1
   %exitcond15 = icmp eq i64 %indvars.iv.next14, 1000