[ScopInfo] Do not use LLVM names to identify statements

[grosser]

Summary

LLVM-IR names are commonly available in debug builds, but often not in release
builds. Hence, using LLVM-IR names to identify statements or memory reference
results makes the behavior of Polly depend on the compile mode. This is
undesirable. Hence, we now just number the statements instead of using LLVM-IR
names to identify them (this issue has previously been brought up by Zino
Benaissa).

However, as LLVM-IR names help in making test cases more readable, we add an
option '-polly-use-llvmir-names' to still use LLVM-IR names. This flag
is by default set in the polly tests to make test cases more readable.

This change reduces the time in ScopInfo from 32 seconds to 2 seconds for the
following test case provided by Eli Friedman <[e-mail]> (already
used in one of the previous commits):

struct X { int x; };
void a();
#define SIG (int x, X **y, X **z)
typedef void (*fn)SIG;
#define FN { for (int i = 0; i < x; ++i) { (*y)[i].x += (*z)[i].x; } a(); }
#define FN5 FN FN FN FN FN
#define FN25 FN5 FN5 FN5 FN5
#define FN125 FN25 FN25 FN25 FN25 FN25
#define FN250 FN125 FN125
#define FN1250 FN250 FN250 FN250 FN250 FN250
void x SIG { FN1250 }

For a larger benchmark I have on-hand (10000 loops), this reduces the time for
running -polly-scops from 5 minutes to 4 minutes, a reduction by 20%.

The reason for this large speedup is that our previous use of printAsOperand
had a quadratic cost, as for each printed and unnamed operand the full function
was scanned to find the instruction number that identifies the operand.

We do not need to adjust the way memory reference ids are constructured, as
they do not use LLVM values.

[efriedma]

This looks very similar to a change we made internally (down to the name; we call it -polly-use-llvm-names). We originally did it because we were having trouble with differences in generated code between Release and Release+Asserts builds, but the performance improvement is a nice side-effect.

Should polly-use-llvmir-names control the behavior of Scop::createParameterId?

[grosser]

• Rename option to -polly-use-llvm-names, this is sounds better and even matches

the qualcomm internal option.

• Also guard createParameterId. While this is not necessary to obtain the speedup we see, it is needed to make Polly deterministic independently if instructions are named or not.

[grosser]

Drop redundant "use namespace llvm" declaration

[efriedma]

LGTM.

[Meinersbur]

Some post-commit remarks.

polly/trunk/include/polly/ScopInfo.h

1714 ↗

(On Diff #97721)

long is 32 bits on 32 bit system and any Windows system. If you really think 32 bits are not enough, could you consider using long long or int64_t?

2634 ↗

(On Diff #97721)

This method has a getter-function name, but has side-effects.

Did you consider passing the ArrayIdx to ScopArrayInfo's ctor instead?

polly/trunk/lib/Support/GICHelper.cpp

218 ↗

(On Diff #97721)

Isn't making it also dependent on Val->hasName() a breaking/unrelated change? Before, the number was derived by LLVM taking all Value's into account. Now the id is derived from the order the unnamed value is encountered by Polly.

I wouldn't consider it a compile-time improvement either because LLVM still looks for duplicate name if it has a name. If UseInstructionNames is enabled, I'd expect names to be derived consistently by LLVM. It is also not consistent with the other overload and the function's description, which says it's only dependent on UseInstructionNames.

219 ↗

(On Diff #97721)

ValStr = std::string("_") + Val->getName() should suffice.

include/polly/ScopInfo.h

private:
 
   /// Mapping from invariant loads to the representing invariant load of
   ///        their equivalence class.
   ValueToValueMap InvEquivClassVMap;
 
   /// List of invariant accesses.
   InvariantEquivClassesTy InvariantEquivClasses;
 
+  /// The smallest array index not yet assigned.
+  long ArrayIdx = 0;
+
+  /// The smallest statement index not yet assigned.
+  long StmtIdx = 0;
+
   /// Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
        ScopDetection::DetectionContext &DC);
 
   //@}
 
   /// Initialize this ScopBuilder.
   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
public:
   static bool containsExtensionNode(__isl_keep isl_schedule *Schedule);
 
   /// Simplify the SCoP representation.
   ///
   /// @param AfterHoisting Whether it is called after invariant load hoisting.
   ///                      When true, also removes statements without
   ///                      side-effects.
   void simplifySCoP(bool AfterHoisting);
+
+  /// Get the next free array index.
+  ///
+  /// This function returns a unique index which can be used to identify an
+  /// array.
+  long getNextArrayIdx() { return ArrayIdx++; }
+
+  /// Get the next free statement index.
+  ///
+  /// This function returns a unique index which can be used to identify a
+  /// statement.
+  long getNextStmtIdx() { return StmtIdx++; }
 };
 
 /// Print Scop scop to raw_ostream O.
 static inline raw_ostream &operator<<(raw_ostream &O, const Scop &scop) {
   scop.print(O);
   return O;
 }
 

include/polly/Support/GICHelper.h

 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_space *Space) {
   OS << polly::stringFromIslObj(Space);
   return OS;
 }
 
-/// Return @p Prefix + @p Val->getName() + @p Suffix but Isl compatible.
+/// Combine Prefix, Val (or Number) and Suffix to an isl-compatible name.
+///
+/// In case -polly-use-llvmir-names is set, this function returns:
+///
+/// @p Prefix + "_" + @p Val->getName() + @p Suffix
+///
+/// otherwise
+///
+/// @p Prefix + to_string(Number) + @p Suffix
+///
+/// We ignore the value names by default, as they may change between release
+/// and debug mode and can consequently not be used when aiming for reproducible
+/// builds. However, for debugging named statements are often helpful, hence
+/// we allow their optional use.
+std::string getIslCompatibleName(const std::string &Prefix,
+                                 const llvm::Value *Val, long Number,
+                                 const std::string &Suffix);
+
+/// Combine Prefix, Name (or Number) and Suffix to an isl-compatible name.
+///
+/// In case -polly-use-llvmir-names is set, this function returns:
+///
+/// @p Prefix + "_" + Name + @p Suffix
+///
+/// otherwise
+///
+/// @p Prefix + to_string(Number) + @p Suffix
+///
+/// We ignore @p Name by default, as they may change between release
+/// and debug mode and can consequently not be used when aiming for reproducible
+/// builds. However, for debugging named statements are often helpful, hence
+/// we allow their optional use.
 std::string getIslCompatibleName(const std::string &Prefix,
-                                 const llvm::Value *Val,
+                                 const std::string &Middle, long Number,
                                  const std::string &Suffix);
 
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const std::string &Middle,
                                  const std::string &Suffix);
 
 // Make isl::give available in polly namespace. We do this as there was
 // previously a function polly::give() which did the very same thing and we

lib/Analysis/ScopInfo.cpp

 
 ScopArrayInfo::ScopArrayInfo(Value *BasePtr, Type *ElementType, isl_ctx *Ctx,
                              ArrayRef<const SCEV *> Sizes, MemoryKind Kind,
                              const DataLayout &DL, Scop *S,
                              const char *BaseName)
     : BasePtr(BasePtr), ElementType(ElementType), Kind(Kind), DL(DL), S(*S) {
   std::string BasePtrName =
       BaseName ? BaseName
-               : getIslCompatibleName("MemRef_", BasePtr,
+               : getIslCompatibleName("MemRef", BasePtr, S->getNextArrayIdx(),
                                       Kind == MemoryKind::PHI ? "__phi" : "");
   Id = isl_id_alloc(Ctx, BasePtrName.c_str(), this);
 
   updateSizes(Sizes);
 
   if (!BasePtr || Kind != MemoryKind::Array) {
     BasePtrOriginSAI = nullptr;
     return;
for (unsigned u = 0, e = isl_set_n_dim(Domain); u < e; u++) {
     isl_id_free(DimId);
   }
 }
 
 ScopStmt::ScopStmt(Scop &parent, Region &R, Loop *SurroundingLoop)
     : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), BB(nullptr),
       R(&R), Build(nullptr), SurroundingLoop(SurroundingLoop) {
 
-  BaseName = getIslCompatibleName("Stmt_", R.getNameStr(), "");
+  BaseName =
+      getIslCompatibleName("Stmt", R.getNameStr(), parent.getNextStmtIdx(), "");
 }
 
 ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb, Loop *SurroundingLoop)
     : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), BB(&bb),
       R(nullptr), Build(nullptr), SurroundingLoop(SurroundingLoop) {
 
-  BaseName = getIslCompatibleName("Stmt_", &bb, "");
+  BaseName = getIslCompatibleName("Stmt", &bb, parent.getNextStmtIdx(), "");
 }
 
 ScopStmt::ScopStmt(Scop &parent, __isl_take isl_map *SourceRel,
                    __isl_take isl_map *TargetRel, __isl_take isl_set *NewDomain)
     : Parent(parent), InvalidDomain(nullptr), Domain(NewDomain), BB(nullptr),
       R(nullptr), Build(nullptr) {
   BaseName = getIslCompatibleName("CopyStmt_", "",
                                   std::to_string(parent.getCopyStmtsNum()));

lib/Support/GICHelper.cpp

 //===- GmpConv.cpp - Recreate LLVM IR from the Scop.  ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Functions for converting between gmp objects and apint.
 //
 //===----------------------------------------------------------------------===//
 #include "polly/Support/GICHelper.h"
+#include "polly/Options.h"
 #include "llvm/IR/Value.h"
 #include "isl/aff.h"
 #include "isl/map.h"
 #include "isl/schedule.h"
 #include "isl/set.h"
 #include "isl/space.h"
 #include "isl/union_map.h"
 #include "isl/union_set.h"
 #include "isl/val.h"
 
 #include <climits>
 
 using namespace llvm;
 
+static cl::opt<bool> UseInstructionNames(
+    "polly-use-llvmir-names",
+    cl::desc("Use LLVM-IR names when deriving statement names"), cl::Hidden,
+    cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+
+using namespace llvm;
+
 __isl_give isl_val *polly::isl_valFromAPInt(isl_ctx *Ctx, const APInt Int,
                                             bool IsSigned) {
   APInt Abs;
   isl_val *v;
 
   // As isl is interpreting the input always as unsigned value, we need some
   // additional pre and post processing to import signed values. The approach
   // we take is to first obtain the absolute value of Int and then negate the
std::string polly::getIslCompatibleName(const std::string &Prefix,
                                         const std::string &Middle,
                                         const std::string &Suffix) {
   std::string S = Prefix + Middle + Suffix;
   makeIslCompatible(S);
   return S;
 }
 
 std::string polly::getIslCompatibleName(const std::string &Prefix,
-                                        const Value *Val,
+                                        const std::string &Name, long Number,
+                                        const std::string &Suffix) {
+  std::string S = Prefix;
+
+  if (UseInstructionNames)
+    S += std::string("_") + Name;
+  else
+    S += std::to_string(Number);
+
+  S += Suffix;
+
+  makeIslCompatible(S);
+  return S;
+}
+
+std::string polly::getIslCompatibleName(const std::string &Prefix,
+                                        const Value *Val, long Number,
                                         const std::string &Suffix) {
   std::string ValStr;
-  raw_string_ostream OS(ValStr);
-  Val->printAsOperand(OS, false);
-  ValStr = OS.str();
-  // Remove the leading %
-  ValStr.erase(0, 1);
+
+  if (UseInstructionNames && Val->hasName())
+    ValStr = std::string("_") + std::string(Val->getName());
+  else
+    ValStr = std::to_string(Number);
+
   return getIslCompatibleName(Prefix, ValStr, Suffix);
 }

test/ScopInfo/unnamed_nonaffine.ll

+; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \
+; RUN:     -polly-use-llvmir-names=true | FileCheck %s
+;
+; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \
+; RUN:     -polly-use-llvmir-names=false | FileCheck %s -check-prefix=UNNAMED
+;
+; Verify only the incoming scalar x is modeled as a read in the non-affine
+; region.
+;
+;    void f(int *A, int b) {
+;      int x;
+;      for (int i = 0; i < 1024; i++) {
+;        if (b > i)
+;          x = 0;
+;        else if (b < 2 * i)
+;          x = 3;
+;        else
+;          x = b;
+;
+;        if (A[x])
+;          A[x] = 0;
+;      }
+;    }
+;
+; CHECK:      Statements {
+; CHECK-NEXT:     Stmt_bb3
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [b] -> { Stmt_bb3[i0] : 0 <= i0 <= 1023 and i0 < b };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [b] -> { Stmt_bb3[i0] -> [i0, 2] };
+; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
+; CHECK-NEXT:             [b] -> { Stmt_bb3[i0] -> MemRef_x_1__phi[] };
+; CHECK-NEXT:     Stmt_bb7
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [b] -> { Stmt_bb7[i0] : i0 >= b and 0 <= i0 <= 1023 and 2i0 > b };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [b] -> { Stmt_bb7[i0] -> [i0, 1] };
+; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
+; CHECK-NEXT:             [b] -> { Stmt_bb7[i0] -> MemRef_x_1__phi[] };
+; CHECK-NEXT:     Stmt_bb8
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [b] -> { Stmt_bb8[0] : b = 0 };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [b] -> { Stmt_bb8[i0] -> [0, 0] };
+; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
+; CHECK-NEXT:             [b] -> { Stmt_bb8[i0] -> MemRef_x_1__phi[] };
+; CHECK-NEXT:     Stmt_bb10__TO__bb18
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] -> [i0, 3] }
+; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
+; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_x_1__phi[] };
+; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_A[o0] };
+; CHECK-NEXT:         MayWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_A[o0] };
+; CHECK-NEXT: }
+
+; UNNAMED:          Arrays {
+; UNNAMED-NEXT:         i32 MemRef0__phi; // Element size 4
+; UNNAMED-NEXT:         i32 MemRef1[*]; // Element size 4
+; UNNAMED-NEXT:     }
+
+; UNNAMED:          Statements {
+; UNNAMED-NEXT:       Stmt2
+; UNNAMED-NEXT:             Domain :=
+; UNNAMED-NEXT:                 [b] -> { Stmt2[i0] : 0 <= i0 <= 1023 and i0 < b };
+; UNNAMED-NEXT:             Schedule :=
+; UNNAMED-NEXT:                 [b] -> { Stmt2[i0] -> [i0, 2] };
+; UNNAMED-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
+; UNNAMED-NEXT:                 [b] -> { Stmt2[i0] -> MemRef0__phi[] };
+; UNNAMED-NEXT:       Stmt4
+; UNNAMED-NEXT:             Domain :=
+; UNNAMED-NEXT:                 [b] -> { Stmt4[i0] : i0 >= b and 0 <= i0 <= 1023 and 2i0 > b };
+; UNNAMED-NEXT:             Schedule :=
+; UNNAMED-NEXT:                 [b] -> { Stmt4[i0] -> [i0, 1] };
+; UNNAMED-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
+; UNNAMED-NEXT:                 [b] -> { Stmt4[i0] -> MemRef0__phi[] };
+; UNNAMED-NEXT:       Stmt5
+; UNNAMED-NEXT:             Domain :=
+; UNNAMED-NEXT:                 [b] -> { Stmt5[0] : b = 0 };
+; UNNAMED-NEXT:             Schedule :=
+; UNNAMED-NEXT:                 [b] -> { Stmt5[i0] -> [0, 0] };
+; UNNAMED-NEXT:             MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
+; UNNAMED-NEXT:                 [b] -> { Stmt5[i0] -> MemRef0__phi[] };
+; UNNAMED-NEXT:       Stmt6
+; UNNAMED-NEXT:             Domain :=
+; UNNAMED-NEXT:                 [b] -> { Stmt6[i0] : 0 <= i0 <= 1023 };
+; UNNAMED-NEXT:             Schedule :=
+; UNNAMED-NEXT:                 [b] -> { Stmt6[i0] -> [i0, 3] };
+; UNNAMED-NEXT:             ReadAccess := [Reduction Type: NONE] [Scalar: 1]
+; UNNAMED-NEXT:                 [b] -> { Stmt6[i0] -> MemRef0__phi[] };
+; UNNAMED-NEXT:             ReadAccess := [Reduction Type: NONE] [Scalar: 0]
+; UNNAMED-NEXT:                 [b] -> { Stmt6[i0] -> MemRef1[o0] };
+; UNNAMED-NEXT:             MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
+; UNNAMED-NEXT:                 [b] -> { Stmt6[i0] -> MemRef1[o0] };
+; UNNAMED-NEXT:     }
+
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @f(i32* %A, i32 %b) {
+bb:
+  br label %bb1
+
+bb1:                                              ; preds = %bb19, %bb
+  %i.0 = phi i32 [ 0, %bb ], [ %tmp20, %bb19 ]
+  %exitcond = icmp ne i32 %i.0, 1024
+  br i1 %exitcond, label %bb2, label %bb21
+
+bb2:                                              ; preds = %bb1
+  %tmp = icmp slt i32 %i.0, %b
+  br i1 %tmp, label %bb3, label %bb4
+
+bb3:                                              ; preds = %bb2
+  br label %bb10
+
+bb4:                                              ; preds = %bb2
+  %tmp5 = mul nsw i32 %i.0, 2
+  %tmp6 = icmp sgt i32 %tmp5, %b
+  br i1 %tmp6, label %bb7, label %bb8
+
+bb7:                                              ; preds = %bb4
+  br label %bb10
+
+bb8:                                              ; preds = %bb4
+  br label %bb10
+
+bb10:                                             ; preds = %bb9, %bb3
+  %x.1 = phi i32 [ 0, %bb3 ], [ 3, %bb7 ], [ %b, %bb8 ]
+  %tmp11 = sext i32 %x.1 to i64
+  %tmp12 = getelementptr inbounds i32, i32* %A, i64 %tmp11
+  %tmp13 = load i32,  i32* %tmp12, align 4
+  %tmp14 = icmp eq i32 %tmp13, 0
+  br i1 %tmp14, label %bb18, label %bb15
+
+bb15:                                             ; preds = %bb10
+  %tmp16 = sext i32 %x.1 to i64
+  %tmp17 = getelementptr inbounds i32, i32* %A, i64 %tmp16
+  store i32 0, i32* %tmp17, align 4
+  br label %bb18
+
+bb18:                                             ; preds = %bb10, %bb15
+  br label %bb19
+
+bb19:                                             ; preds = %bb18
+  %tmp20 = add nuw nsw i32 %i.0, 1
+  br label %bb1
+
+bb21:                                             ; preds = %bb1
+  ret void
+}

test/ScopInfo/unnamed_stmts.ll

+; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
+
+; This test case verifies that we generate numbered statement names in case
+; no LLVM-IR names are used in the test case. We also verify, that we
+; distinguish statements named with a number and unnamed statements that happen
+; to have an index identical to a number used in a statement name.
+
+; CHECK: Arrays {
+; CHECK-NEXT:     float MemRef0[*][%n]; // Element size 4
+; CHECK-NEXT:     float MemRef1[*][%n]; // Element size 4
+; CHECK-NEXT: }
+; CHECK-NEXT: Arrays (Bounds as pw_affs) {
+; CHECK-NEXT:     float MemRef0[*][ [n] -> { [] -> [(n)] } ]; // Element size 4
+; CHECK-NEXT:     float MemRef1[*][ [n] -> { [] -> [(n)] } ]; // Element size 4
+; CHECK-NEXT: }
+
+; CHECK: Statements {
+; CHECK-NEXT:   Stmt2
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [n] -> { Stmt2[i0, i1] : 0 <= i0 < n and 0 <= i1 < n };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [n] -> { Stmt2[i0, i1] -> [0, i0, i1, 0] };
+; CHECK-NEXT:         ReadAccess := [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt2[i0, i1] -> MemRef0[i0, i1] };
+; CHECK-NEXT:         ReadAccess := [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt2[i0, i1] -> MemRef1[i0, i1] };
+; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt2[i0, i1] -> MemRef1[i0, i1] };
+; CHECK-NEXT:   Stmt10
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [n] -> { Stmt10[i0, i1] : 0 <= i0 < n and 0 <= i1 < n };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [n] -> { Stmt10[i0, i1] -> [1, i0, i1, 0] };
+; CHECK-NEXT:         ReadAccess := [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt10[i0, i1] -> MemRef1[i0, i1] };
+; CHECK-NEXT:         ReadAccess := [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt10[i0, i1] -> MemRef0[i0, i1] };
+; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt10[i0, i1] -> MemRef0[i0, i1] };
+; CHECK-NEXT:   Stmt_2
+; CHECK-NEXT:         Domain :=
+; CHECK-NEXT:             [n] -> { Stmt_2[i0, i1] : 0 <= i0 < n and 0 <= i1 < n };
+; CHECK-NEXT:         Schedule :=
+; CHECK-NEXT:             [n] -> { Stmt_2[i0, i1] -> [1, i0, i1, 1] };
+; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
+; CHECK-NEXT:             [n] -> { Stmt_2[i0, i1] -> MemRef0[i0, i1]
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+; Function Attrs: nounwind uwtable
+define void @vec3(i64 %n, float*, float*) #0 {
+  br label %.split
+
+.split:                                           ; preds = %0
+  br label %.preheader2.lr.ph
+
+.preheader2.lr.ph:                                ; preds = %.split
+  br label %.preheader2
+
+.preheader2:                                      ; preds = %.preheader2.lr.ph, %15
+  %i.010 = phi i64 [ 0, %.preheader2.lr.ph ], [ %16, %15 ]
+  br label %.lr.ph8
+
+.lr.ph8:                                          ; preds = %.preheader2
+  br label %4
+
+..preheader1_crit_edge:                           ; preds = %15
+  br label %.preheader1
+
+.preheader1:                                      ; preds = %..preheader1_crit_edge, %.split
+  %3 = icmp sgt i64 %n, 0
+  br i1 %3, label %.preheader.lr.ph, label %"name"
+
+.preheader.lr.ph:                                 ; preds = %.preheader1
+  br label %.preheader
+
+; <label>:4:                                      ; preds = %.lr.ph8, %4
+  %j.07 = phi i64 [ 0, %.lr.ph8 ], [ %14, %4 ]
+  %5 = mul nsw i64 %i.010, %n
+  %6 = getelementptr inbounds float, float* %1, i64 %5
+  %7 = getelementptr inbounds float, float* %6, i64 %j.07
+  %8 = load float, float* %7, align 4
+  %9 = mul nsw i64 %i.010, %n
+  %10 = getelementptr inbounds float, float* %0, i64 %9
+  %11 = getelementptr inbounds float, float* %10, i64 %j.07
+  %12 = load float, float* %11, align 4
+  %13 = fadd float %8, %12
+  store float %13, float* %11, align 4
+  %14 = add nuw nsw i64 %j.07, 1
+  %exitcond13 = icmp ne i64 %14, %n
+  br i1 %exitcond13, label %4, label %._crit_edge9
+
+._crit_edge9:                                     ; preds = %4
+  br label %15
+
+; <label>:15:                                     ; preds = %._crit_edge9, %.preheader2
+  %16 = add nuw nsw i64 %i.010, 1
+  %exitcond14 = icmp ne i64 %16, %n
+  br i1 %exitcond14, label %.preheader2, label %..preheader1_crit_edge
+
+.preheader:                                       ; preds = %.preheader.lr.ph, %29
+  %i1.04 = phi i64 [ 0, %.preheader.lr.ph ], [ %30, %29 ]
+  %17 = icmp sgt i64 %n, 0
+  br i1 %17, label %.lr.ph, label %29
+
+.lr.ph:                                           ; preds = %.preheader
+  br label %18
+
+; <label>:18:                                     ; preds = %.lr.ph, %18
+  %j2.03 = phi i64 [ 0, %.lr.ph ], [ %28, %"2" ]
+  %19 = mul nsw i64 %i1.04, %n
+  %20 = getelementptr inbounds float, float* %0, i64 %19
+  %21 = getelementptr inbounds float, float* %20, i64 %j2.03
+  %22 = load float, float* %21, align 4
+  %23 = mul nsw i64 %i1.04, %n
+  %24 = getelementptr inbounds float, float* %1, i64 %23
+  %25 = getelementptr inbounds float, float* %24, i64 %j2.03
+  %26 = load float, float* %25, align 4
+  %27 = fadd float %22, %26
+  store float %27, float* %25, align 4
+  br label %"2"
+
+"2":
+  store float 42.0, float* %25
+  %28 = add nuw nsw i64 %j2.03, 1
+  %exitcond = icmp ne i64 %28, %n
+  br i1 %exitcond, label %18, label %._crit_edge
+
+._crit_edge:                                      ; preds = %18
+  br label %29
+
+; <label>:29:                                     ; preds = %._crit_edge, %.preheader
+  %30 = add nuw nsw i64 %i1.04, 1
+  %exitcond12 = icmp ne i64 %30, %n
+  br i1 %exitcond12, label %.preheader, label %._crit_edge6
+
+._crit_edge6:                                     ; preds = %29
+  br label %"name"
+
+"name":
+  ret void
+}
+
+attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.ident = !{!0}
+
+!0 = !{!"Ubuntu clang version 3.7.1-3ubuntu4 (tags/RELEASE_371/final) (based on LLVM 3.7.1)"}

test/lit.site.cfg.in

if config.link_polly_into_tools == '' or \
    config.link_polly_into_tools.lower() == 'off' or \
    config.link_polly_into_tools.lower() == 'false' or \
    config.link_polly_into_tools.lower() == 'notfound' or \
    config.link_polly_into_tools.lower() == 'link_polly_into_tools-notfound':
     config.substitutions.append(('%loadPolly', '-load '
                                  + config.polly_lib_dir + '/LLVMPolly@LLVM_SHLIBEXT@'
                                  + ' -polly-process-unprofitable '
                                  + ' -polly-remarks-minimal '
+                                 + ' -polly-use-llvmir-names '
                                  ))
 else:
     config.substitutions.append(('%loadPolly', ''
                                  + ' -polly-process-unprofitable '
                                  + ' -polly-remarks-minimal '
+                                 + ' -polly-use-llvmir-names '
                                  ))
 
 if config.enable_gpgpu_codegen == 'TRUE' :
     config.available_features.add('pollyacc')
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@POLLY_SOURCE_DIR@/test/lit.cfg")