[Polly] Add early exits for SCoPs we did not optimize

[jdoerfert]

Summary

All test cases have been ported and use the --polly-no-early-exit flag to keep the coverage up.

[jdoerfert]

LNT results, 4 runs on my notebook.

http://picload.org/view/ciogcgg/lnt.png.html

[grosser]

Hi Johannes,

as discussed before, I really like the idea. I added some minor comments inline.

Regarding the performance numbers, it is very nice to see that your patch reduces compile time for several of the TSVC benchmarks.I also see two compile and execution time regressions of around 50% with your patch. The compile time regression is possibly noise, but the execution time regression is surprising. Did you had a chance to see what we changed in Misc/flops to get the nice speedup that with you patch applied is lost again?

Cheers,
Tobias

lib/Analysis/ScopInfo.cpp

698–699

Why did you drop the tuple name that identifies the 'scattering'? This seems unrelated to the patch and causes a large number of seemingly unrelated test case changes. Was this intended?

1513–1514

Again, this seems unrelated?

lib/CodeGen/IslAst.cpp

373

Nice. It may even be worth outlining this cost estimation into its own function to clarify that we plan to extend/improve it.

lib/Transform/ScheduleOptimizer.cpp

581

Maybe put this code into its own function?

599

It seems here you check if the new schedule is a subset of the old schedule. This is a very simple heuristic and probably does not fire in a lot of cases (which is fine for me, as we can refine it later).

Instead of looping over all Stmts, you could possibly implement this by calling S.getSchedule() and comparing the result with ScheduleMap.

An alternative to the approach you are taking would be to assume we did not do anything, but just mark the scop as optimized if we clearly did something useful. This could e.g. be that we were able to perform tiling. I kind of like this idea, as it would make Polly be more conservative in terms of not changing existing code only if it is clear we can clearly improve performance.

[jdoerfert]

For me the compile time regressions seem like jitter (all < 0.001 sec) but the improvemeents don't (a lot > 0.01 sec). I don't know about the runtime effects, but except 2, all of the regressions seem like jittter too (again < 0.001 sec). I will look into flops or just run it 15 times in isolation to get more confidence in the results.

lib/Analysis/ScopInfo.cpp

698–699

It would have made my "isIdentitySchedule" check more complicated if we keep it but I'm fine with keeping it in the end (even though I do not see any benefit of the word "scattering" in the early representation of the scattering as we loose it after isl optimization anyway)

1513–1514

This was implied by the decision to remove it (see above)

lib/CodeGen/IslAst.cpp

373

That's true.

lib/Transform/ScheduleOptimizer.cpp

581

We should try to come up with a better way to check this. I believe this doesn't catch all the cases and it should be unnecessary to iterate over the statements (maybe we can traverse the schedule map).

599

I'm open for suggestions here and think we can improve this step by step. (I put the TODO above to make it clear I know this is not really a good way to check this).

[grosser]

lib/Analysis/ScopInfo.cpp

698–699

Dropping 'scattering' as a tuple name may indeed be a good idea. If you could commit this part separately, the test case noise would not obscure this patch.

lib/Transform/ScheduleOptimizer.cpp

581

This identify check is indeed a very rough heuristic. Improving it by deriving the set of performed transformations by looking at the resulting schedules seems incredibly hard.

I see two alternative approaches:

• We compute properties (# of stride-one-accesses, ...)
• We keep track of optimizations we have successfully performed (tiling)

both require some thoughts and may not be needed for the initial version.

As said earlier, the current code that looks for subset schedules can be simplified by using S.getSchedule() and comparing the result with ScheduleMap.

599

Maybe you can actually state in your todo what we do today and what could be done later.

To understand if the schedule has been optimized we check if the schedule has
changed at all.
TODO: We can improve this by tracking if any necessarily beneficial
transformations have been performed. This can e.g. be tiling, loop interchange,
or ...) We can track this either at the place where the transformation has been
performed or, in case of automatic ILP based optimizations, by comparing
(yet to be defined) performance metrics before/after the scheduling optimizer
(e.g. number of stride-one accesses)

Also, I think it would be good to get a test case for our heursitic here, similar to how the loop vectorizer has test cases for its performance model:

Transforms/LoopVectorize/X86/uint64_to_fp64-cost-model.ll

For us a simple optimized/non-optimized is probably a good start,

[jdoerfert]

Updated test cases, modified according to comments, checked lnt (runtime regression was noise)

[jdoerfert]

I agree that we should improve our heuristic but:

1. This should be done later
2. I have a group of students working on a heurisitc for parallel execution, we can use some of their infrastructure and save us the trouble :)

[grosser]

Hi Johannes,

thanks. This patch looks very nice now.
As mentioned in my previous review I agree that "[improvements to the heuristic] require some thoughts and may not be needed for the initial version.".

One comment from my last review, where I would be still interested on your opinion is the following one:

Also, I think it would be good to get a test case for our heuristic here, similar to how the loop vectorizer has test cases for its performance model:

Transforms/LoopVectorize/X86/uint64_to_fp64-cost-model.ll

Cheers,
Tobias

include/polly/ScopInfo.h

787

optimized

790

if the (missing space)

lib/Transform/ScheduleOptimizer.cpp

568

(e.g., number of stride-one accesses).

578

This is now very nice and concise (It still it may be worth to be outlined into a separate function).

test/Isl/CodeGen/MemAccess/codegen_constant_offset.ll

1

You add the flag twice.

[jdoerfert]

Commited at some point.

include/polly/ScopInfo.h

private:
   Scop(const Scop &) LLVM_DELETED_FUNCTION;
   const Scop &operator=(const Scop &) LLVM_DELETED_FUNCTION;
 
   ScalarEvolution *SE;
 
   /// The underlying Region.
   Region &R;
 
+  /// Flag to indicate that the scheduler actually optimized the SCoP.
+  bool IsOptimized;
+
   /// Max loop depth.
   unsigned MaxLoopDepth;
 
   typedef std::vector<ScopStmt *> StmtSet;
   /// The statements in this Scop.
   StmtSet Stmts;
 
   /// Parameters of this Scop
inline unsigned getScatterDim() const {
     unsigned maxScatterDim = 0;
 
     for (const_iterator SI = begin(), SE = end(); SI != SE; ++SI)
       maxScatterDim = std::max(maxScatterDim, (*SI)->getNumScattering());
 
     return maxScatterDim;
   }
 
+  /// @brief Mark the SCoP as optmized by the scheduler.
+  void markAsOptimized() { IsOptimized = true; }
+
+  /// @brief Check ifthe SCoP has been optimized by the scheduler.
+  bool isOptimized() const { return IsOptimized; }
+
   /// @brief Get the name of this Scop.
   std::string getNameStr() const;
 
   /// @brief Get the constraint on parameter of this Scop.
   ///
   /// @return The constraint on parameter of this Scop.
   __isl_give isl_set *getContext() const;
   __isl_give isl_space *getParamSpace() const;

lib/Analysis/ScopInfo.cpp

void ScopStmt::setScattering(isl_map *NewScattering) {
   isl_map_free(Scattering);
   Scattering = NewScattering;
 }
 
 void ScopStmt::buildScattering(SmallVectorImpl<unsigned> &Scatter) {
   unsigned NbIterators = getNumIterators();
   unsigned NbScatteringDims = Parent.getMaxLoopDepth() * 2 + 1;
 
   isl_space *Space = isl_space_set_alloc(getIslCtx(), 0, NbScatteringDims);
 
   Scattering = isl_map_from_domain_and_range(isl_set_universe(getDomainSpace()),
                                              isl_set_universe(Space));
 
   // Loop dimensions.
   for (unsigned i = 0; i < NbIterators; ++i)
     Scattering =
         isl_map_equate(Scattering, isl_dim_out, 2 * i + 1, isl_dim_in, i);
 
if (i % 2 == 0) {
           isl_set_plain_get_val_if_fixed(ScheduleSpace, isl_dim_set, i);
       if (isl_val_is_int(FixedVal)) {
         DropDimMap =
             isl_map_project_out(DropDimMap, isl_dim_out, i - NumDimsDropped, 1);
         NumDimsDropped++;
       }
       isl_val_free(FixedVal);
     }
 
   for (auto *S : *this) {
     isl_map *Schedule = S->getScattering();
     Schedule = isl_map_apply_range(Schedule, isl_map_copy(DropDimMap));
     S->setScattering(Schedule);
   }
   isl_set_free(ScheduleSpace);
   isl_map_free(DropDimMap);
 }
 
 Scop::Scop(TempScop &tempScop, LoopInfo &LI, ScalarEvolution &ScalarEvolution,
            isl_ctx *Context)
-    : SE(&ScalarEvolution), R(tempScop.getMaxRegion()),
+    : SE(&ScalarEvolution), R(tempScop.getMaxRegion()), IsOptimized(false),
       MaxLoopDepth(getMaxLoopDepthInRegion(tempScop.getMaxRegion(), LI)) {
   IslCtx = Context;
   buildContext();
 
   SmallVector<Loop *, 8> NestLoops;
   SmallVector<unsigned, 8> Scatter;
 
   Scatter.assign(MaxLoopDepth + 1, 0);

lib/CodeGen/IslAst.cpp

static cl::opt<bool> UseContext("polly-ast-use-context",
                                 cl::init(false), cl::ZeroOrMore,
                                 cl::cat(PollyCategory));
 
 static cl::opt<bool> DetectParallel("polly-ast-detect-parallel",
                                     cl::desc("Detect parallelism"), cl::Hidden,
                                     cl::init(false), cl::ZeroOrMore,
                                     cl::cat(PollyCategory));
 
+static cl::opt<bool> NoEarlyExit(
+    "polly-no-early-exit",
+    cl::desc("Do not exit early if no benefit of the Polly version was found."),
+    cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+
 namespace polly {
 class IslAst {
 public:
   IslAst(Scop *Scop, Dependences &D);
 
   ~IslAst();
 
   /// Print a source code representation of the program.
for (auto AccIt0 = MinMaxAccesses->begin(); AccIt0 != AccEnd; ++AccIt0) {
         NonAliasGroup =
             isl_ast_expr_or(NonAliasGroup, isl_ast_expr_le(MaxExpr, MinExpr));
         RunCondition = isl_ast_expr_and(RunCondition, NonAliasGroup);
       }
     }
   }
 }
 
-IslAst::IslAst(Scop *Scop, Dependences &D) : S(Scop) {
+/// @brief Simple cost analysis for a given SCoP
+///
+/// TODO: Improve this analysis and extract it to make it usable in other
+///       places too.
+///       In order to improve the cost model we could either keep track of
+///       performed optimizations (e.g., tiling) or compute properties on the
+///       original as well as optimized SCoP (e.g., #stride-one-accesses).
+static bool benefitsFromPolly(Scop *Scop, bool PerformParallelTest) {
+
+  // First check the user choice.
+  if (NoEarlyExit)
+    return true;
+
+  // Check if nothing interesting happened.
+  if (!PerformParallelTest && !Scop->isOptimized() &&
+      Scop->getAliasGroups().empty())
+    return false;
+
+  // The default assumption is that Polly improves the code.
+  return true;
+}
+
+IslAst::IslAst(Scop *Scop, Dependences &D)
+    : S(Scop), Root(nullptr), RunCondition(nullptr) {
+
+  bool PerformParallelTest = PollyParallel || DetectParallel ||
+                             PollyVectorizerChoice != VECTORIZER_NONE;
+
+  // Skip AST and code generation if there was no benefit achieved.
+  if (!benefitsFromPolly(Scop, PerformParallelTest))
+    return;
+
   isl_ctx *Ctx = S->getIslCtx();
   isl_options_set_ast_build_atomic_upper_bound(Ctx, true);
   isl_ast_build *Build;
   AstBuildUserInfo BuildInfo;
 
   if (UseContext)
     Build = isl_ast_build_from_context(S->getContext());
   else
     Build = isl_ast_build_from_context(isl_set_universe(S->getParamSpace()));
 
   Build = isl_ast_build_set_at_each_domain(Build, AtEachDomain, nullptr);
 
   isl_union_map *Schedule =
       isl_union_map_intersect_domain(S->getSchedule(), S->getDomains());
 
-  if (PollyParallel || DetectParallel ||
-      PollyVectorizerChoice != VECTORIZER_NONE) {
+  if (PerformParallelTest) {
     BuildInfo.Deps = &D;
     BuildInfo.InParallelFor = 0;
 
     Build = isl_ast_build_set_before_each_for(Build, &astBuildBeforeFor,
                                               &BuildInfo);
     Build =
         isl_ast_build_set_after_each_for(Build, &astBuildAfterFor, &BuildInfo);
   }

 isl_ast_build *IslAstInfo::getBuild(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? Payload->Build : nullptr;
 }
 
 void IslAstInfo::printScop(raw_ostream &OS) const {
   isl_ast_print_options *Options;
   isl_ast_node *RootNode = getAst();
+  Scop &S = getCurScop();
+  Function *F = S.getRegion().getEntry()->getParent();
+
+  OS << ":: isl ast :: " << F->getName() << " :: " << S.getRegion().getNameStr()
+     << "\n";
+
+  if (!RootNode) {
+    OS << ":: isl ast generation and code generation was skipped!\n\n";
+    return;
+  }
+
   isl_ast_expr *RunCondition = getRunCondition();
   char *RtCStr, *AstStr;
 
-  Scop &S = getCurScop();
   Options = isl_ast_print_options_alloc(S.getIslCtx());
   Options = isl_ast_print_options_set_print_for(Options, cbPrintFor, nullptr);
 
   isl_printer *P = isl_printer_to_str(S.getIslCtx());
   P = isl_printer_print_ast_expr(P, RunCondition);
   RtCStr = isl_printer_get_str(P);
   P = isl_printer_flush(P);
   P = isl_printer_indent(P, 4);
   P = isl_printer_set_output_format(P, ISL_FORMAT_C);
   P = isl_ast_node_print(RootNode, P, Options);
   AstStr = isl_printer_get_str(P);
 
-  Function *F = S.getRegion().getEntry()->getParent();
   isl_union_map *Schedule =
       isl_union_map_intersect_domain(S.getSchedule(), S.getDomains());
 
-  OS << ":: isl ast :: " << F->getName() << " :: " << S.getRegion().getNameStr()
-     << "\n";
   DEBUG({
     dbgs() << S.getContextStr() << "\n";
     dbgs() << stringFromIslObj(Schedule);
   });
   OS << "\nif (" << RtCStr << ")\n\n";
   OS << AstStr << "\n";
   OS << "else\n";
   OS << "    {  /* original code */ }\n\n";

lib/CodeGen/IslCodeGeneration.cpp

Value *buildRTC(PollyIRBuilder &Builder, IslExprBuilder &ExprBuilder) {
     Builder.SetInsertPoint(Builder.GetInsertBlock()->getTerminator());
     Value *RTC = ExprBuilder.create(AI->getRunCondition());
     if (!RTC->getType()->isIntegerTy(1))
       RTC = Builder.CreateIsNotNull(RTC);
     return RTC;
   }
 
   bool runOnScop(Scop &S) {
-    LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     AI = &getAnalysis<IslAstInfo>();
+
+    // Check if we created an isl_ast root node, otherwise exit.
+    isl_ast_node *AstRoot = AI->getAst();
+    if (!AstRoot)
+      return false;
+
+    LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     SE = &getAnalysis<ScalarEvolution>();
     DL = &getAnalysis<DataLayoutPass>().getDataLayout();
 
     assert(!S.getRegion().isTopLevelRegion() &&
            "Top level regions are not supported");
 
     // Build the alias scopes for annotations first.
     if (PollyAnnotateAliasScopes)
       Annotator.buildAliasScopes(S);
 
     BasicBlock *EnteringBB = simplifyRegion(&S, this);
     PollyIRBuilder Builder = createPollyIRBuilder(EnteringBB, Annotator);
 
     IslNodeBuilder NodeBuilder(Builder, Annotator, this, *DL, *LI, *SE, *DT, S);
     NodeBuilder.addParameters(S.getContext());
 
     Value *RTC = buildRTC(Builder, NodeBuilder.getExprBuilder());
     BasicBlock *StartBlock = executeScopConditionally(S, this, RTC);
     Builder.SetInsertPoint(StartBlock->begin());
 
-    NodeBuilder.create(AI->getAst());
+    NodeBuilder.create(AstRoot);
     return true;
   }
 
   virtual void printScop(raw_ostream &OS) const {}
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
     AU.addRequired<DataLayoutPass>();
     AU.addRequired<DominatorTreeWrapperPass>();

lib/Transform/ScheduleOptimizer.cpp

bool IslScheduleOptimizer::runOnScop(Scop &S) {
 
   // In cases the scheduler is not able to optimize the code, we just do not
   // touch the schedule.
   if (!Schedule)
     return false;
 
   DEBUG(dbgs() << "Schedule := " << stringFromIslObj(Schedule) << ";\n");
 
-  isl_union_map *ScheduleMap = getScheduleMap(Schedule);
+  isl_union_map *OldSchedule = S.getSchedule();
+  isl_union_map *NewSchedule = getScheduleMap(Schedule);
+
+  // To understand if the schedule has been optimized we check if the schedule
+  // has changed at all.
+  // TODO: We can improve this by tracking if any necessarily beneficial
+  // transformations have been performed. This can e.g. be tiling, loop
+  // interchange, or ...) We can track this either at the place where the
+  // transformation has been performed or, in case of automatic ILP based
+  // optimizations, by comparing (yet to be defined) performance metrics
+  // before/after the scheduling optimizer
+  // (e.g. number of stride-one accesses)
+  bool changed = !isl_union_map_is_equal(OldSchedule, NewSchedule);
+  isl_union_map_free(OldSchedule);
+
+  if (changed)
+    S.markAsOptimized();
+  else {
+    isl_schedule_free(Schedule);
+    isl_union_map_free(NewSchedule);
+    return false;
+  }
 
   for (ScopStmt *Stmt : S) {
     isl_map *StmtSchedule;
     isl_set *Domain = Stmt->getDomain();
     isl_union_map *StmtBand;
-    StmtBand = isl_union_map_intersect_domain(isl_union_map_copy(ScheduleMap),
+    StmtBand = isl_union_map_intersect_domain(isl_union_map_copy(NewSchedule),
                                               isl_union_set_from_set(Domain));
     if (isl_union_map_is_empty(StmtBand)) {
       StmtSchedule = isl_map_from_domain(isl_set_empty(Stmt->getDomainSpace()));
       isl_union_map_free(StmtBand);
     } else {
       assert(isl_union_map_n_map(StmtBand) == 1);
       StmtSchedule = isl_map_from_union_map(StmtBand);
     }
 
     Stmt->setScattering(StmtSchedule);
   }
 
-  isl_union_map_free(ScheduleMap);
+  isl_union_map_free(NewSchedule);
   LastSchedule = Schedule;
 
   unsigned MaxScatDims = 0;
 
   for (ScopStmt *Stmt : S)
     MaxScatDims = std::max(Stmt->getNumScattering(), MaxScatDims);
 
   extendScattering(S, MaxScatDims);
   return false;
 }

test/DeadCodeElimination/chained_iterations.ll

-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
 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"
 target triple = "x86_64-pc-linux-gnu"
 ;
 ; for(i = 0; i < 200; i++ )
 ;   A[i] = 2;
 ;
 ; for (i = 0; i < 200; i++ )
 ;   A[i]  = 5;

test/DeadCodeElimination/chained_iterations_2.ll

-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
 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"
 target triple = "x86_64-pc-linux-gnu"
 ;
 ; for(i = 0; i < 200; i++ )
 ;   A[i] = 2;
 ;
 ; for (i = 0; i < 200; i++ )
 ;   B[i] = A[i];

test/DeadCodeElimination/computeout.ll

-; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
+; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
+; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 ;     for(i = 0; i < 100; i++ )
 ; S1:   A[i] = 2;
 ;
 ;     for (i = 0; i < 10; i++ )
 ; S2:   A[i]  = 5;

test/DeadCodeElimination/dead_iteration_elimination.ll

-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK
 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"
 target triple = "x86_64-pc-linux-gnu"
 ;
 ; for(i = 0; i < 200; i++ )
 ;   A[i] = 2;
 ;
 ; for (i = 0; i < 50; i++ )
 ;   A[i]  = 5;

test/DeadCodeElimination/non-affine-affine-mix.ll

-; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
 ;
 ;    void f(int *A) {
 ;      for (int i = 0; i < 1024; i++)
 ; S1:    A[i % 2] = i;
 ;      for (int i = 0; i < 1024; i++)
 ; S2:    A[i2] = i;
 ;    }
 

test/DeadCodeElimination/non-affine.ll

-; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
 ;
 ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
 ;
 ;    void f(int *A) {
 ;      for (int i = 0; i < 1024; i++)
 ;        A[i % 2] = i;
 ;    }
 ;

test/DeadCodeElimination/null_schedule.ll

-; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE
+; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
 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"
 target triple = "x86_64-pc-linux-gnu"
 ; A[0] = 1;
 ;
 ; for(i = 0; i < 100; i++ )
 ;   A[i+1] = A[i] * 2;
 ;
 ; for (i = 0; i < 200; i++ )

test/Isl/Ast/alias_simple_1.ll

-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -basicaa < %s | FileCheck %s --check-prefix=BASI
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -scev-aa < %s | FileCheck %s --check-prefix=SCEV
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
 ;
 ;    int A[1024];
 ;
 ;
 ;    void jd(float *B, int N) {
 ;      for (int i = 0; i < N; i++)
 ;        A[i] = B[i];
 ;    }

test/Isl/Ast/alias_simple_2.ll

-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -basicaa < %s | FileCheck %s --check-prefix=BASI
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -scev-aa < %s | FileCheck %s --check-prefix=SCEV
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
 ;
 ;    int A[1024], B[1024];
 ;
 ;
 ;    void jd(int N) {
 ;      for (int i = 0; i < N; i++)
 ;        A[i] = B[i];
 ;    }

test/Isl/Ast/alias_simple_3.ll

-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -basicaa < %s | FileCheck %s --check-prefix=BASI
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -scev-aa < %s | FileCheck %s --check-prefix=SCEV
-; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
+; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
 ;
 ;    int A[1024];
 ;    float B[1024];
 ;
 ;    void jd(int N) {
 ;      for (int i = 0; i < N; i++)
 ;        A[i] = B[i];
 ;    }

test/Isl/Ast/run-time-condition.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
 
 ; for (i = 0; i < 1024; i++)
 ;   A[i] = B[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-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @run-time-condition(i16* noalias %A, i16* noalias %B) {

test/Isl/Ast/simple-run-time-condition.ll

-; RUN: opt %loadPolly -polly-ast -analyze -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -analyze -polly-no-early-exit -polly-delinearize < %s | FileCheck %s
 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-unknown-linux-gnu"
 
 ; void foo(long n, long m, int o, double A[n][m], long p, long q) {
 ;
 ; if (o >= 0)
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)

test/Isl/Ast/single_loop_strip_mine.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-import-jscop-dir=%S -basicaa -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s -check-prefix=CHECK-VECTOR
+; RUN: opt %loadPolly -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-import-jscop-dir=%S -basicaa -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-VECTOR
 
 ; for (i = 0; i < 1024; i++)
 ;   A[i] = B[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-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @single_loop_strip_mine(i16* noalias %A, i16* noalias %B) {

test/Isl/CodeGen/20120316-InvalidCast.ll

-; RUN: opt %loadPolly -S -polly-detect-scops-in-functions-without-loops -polly-detect-scops-in-regions-without-loops -polly-codegen-isl < %s | FileCheck %s
+; RUN: opt %loadPolly -S -polly-detect-scops-in-functions-without-loops -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -polly-no-early-exit < %s | FileCheck %s
 
 ; CHECK: polly.start
 
 target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
 
 define void @fixup_gotos(i32* %A, i32* %data) nounwind {
 entry:
   br label %if

test/Isl/CodeGen/MemAccess/codegen_constant_offset.ll

-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
 
 ;int A[100];
 ;
 ;int codegen_constant_offset() {
 ;  for (int i = 0; i < 12; i++)
 ;    A[13] = A[i] + A[i-1];
 ;
 ;  return 0;

test/Isl/CodeGen/MemAccess/codegen_simple.ll

-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
 
 ;int A[100];
 ;
 ;int codegen_simple () {
 ;  for (int i = 0; i < 12; i++)
 ;    A[13] = A[i] + A[i-1];
 ;
 ;  return 0;

test/Isl/CodeGen/MemAccess/codegen_simple_float.ll

-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
 ;
 ;float A[100];
 ;
 ;int codegen_simple () {
 ;  for (int i = 0; i < 12; i++)
 ;    A[13] = A[i] + A[i-1];
 ;
 ;  return 0;

test/Isl/CodeGen/MemAccess/codegen_simple_md.ll

-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
 
 ;int A[1040];
 ;
 ;int codegen_simple_md() {
 ;  for (int i = 0; i < 32; ++i)
 ;    for (int j = 0; j < 32; ++j)
 ;      A[32*i+j] = 100;
 ;

test/Isl/CodeGen/MemAccess/codegen_simple_md_float.ll

-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
-;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
 ;
 ;float A[1040];
 ;
 ;int codegen_simple_md() {
 ;  for (int i = 0; i < 32; ++i)
 ;    for (int j = 0; j < 32; ++j)
 ;      A[32*i+j] = 100;
 ;}

test/Isl/CodeGen/alignment.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
 ;
 ; Check that the special alignment information is kept
 ;
 ; CHECK: align 8
 ; CHECK: align 8
 ;
 ;    void jd(int *A) {
 ;      for (int i = 0; i < 1024; i += 2)

test/Isl/CodeGen/constant_condition.ll

-;RUN: opt %loadPolly -polly-prepare -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-ast -analyze < %s | FileCheck %s
+;RUN: opt %loadPolly -polly-no-early-exit -polly-prepare -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;int A[1];
 ;
 ;void constant_condition () {
 ;  int a = 0;
 ;  int b = 0;
 ;

test/Isl/CodeGen/create-conditional-scop.ll

-; RUN: opt %loadPolly -basicaa -polly-codegen-isl -verify-loop-info < %s -S | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -verify-loop-info < %s -S | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
 target triple = "hexagon-unknown-linux-gnu"
 
 ; This test case used to fail, because we did not add the newly generated basic
 ; block %polly.start as a basic block to the surrounding loop.
 define void @foo() nounwind {
 entry:

test/Isl/CodeGen/debug-intrinsics.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
 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 @foo(float* %A, i64 %N) #0 {
 entry:
   br label %entry.split
 

test/Isl/CodeGen/loop_with_condition.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;#define N 1024
 ;int A[N];
 ;int B[N];
 ;
 ;void loop_with_condition() {
 ;  int i;

test/Isl/CodeGen/loop_with_condition_ineq.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;#define N 1024
 ;int A[N];
 ;int B[N];
 ;
 ;void loop_with_condition_ineq() {
 ;  int i;

test/Isl/CodeGen/loop_with_condition_nested.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -basicaa -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
 
 
 ;#include <string.h>
 ;#define N 1024
 ;int A[N];
 ;int B[N];
 ;
 ;void loop_with_condition() {

test/Isl/CodeGen/loop_with_conditional_entry_edge_splited_hard_case.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
 ;
 ; Test case to trigger the hard way of creating a unique entering
 ; edge for the SCoP. It is triggered because the entering edge
 ; here: %while.begin --> %if is __not__ critical.
 ;
 ;    int f(void);
 ;    void jd(int b, int *A) {
 ;      while (f()) {

test/Isl/CodeGen/multidim_2d_parametric_array_static_loop_bounds.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
 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-unknown-linux-gnu"
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, double A[n][m]) {
 ;   for (long i = 0; i < 100; i++)
 ;     for (long j = 0; j < 150; j++)

test/Isl/CodeGen/pointer-type-expressions.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
 
 ; void f(int a[], int N, float *P) {
 ;   int i;
 ;   for (i = 0; i < N; ++i)
 ;     if (P != 0)
 ;       a[i] = i;
 ; }
 

test/Isl/CodeGen/pointer-type-pointer-type-comparison.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
 ;
 ;    void f(int a[], int N, float *P, float *Q) {
 ;      int i;
 ;      for (i = 0; i < N; ++i)
 ;        if (P != Q)
 ;          a[i] = i;
 ;    }
 ;

test/Isl/CodeGen/reduction_2.ll

-; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;#include <stdio.h>
 ;#define N 1021
 ;
 ;int main () {
 ;  int i;
 ;  int A[N];

test/Isl/CodeGen/run-time-condition-with-scev-parameters.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
 
 ; CHECK: %1 = zext i32 %n to i64
 ; CHECK: %2 = icmp sge i64 %1, 1
 ; CHECK: %3 = select i1 %2, i64 1, i64 0
 ; CHECK: %4 = icmp ne i64 %3, 0
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"

test/Isl/CodeGen/run-time-condition.ll

-; RUN: opt %loadPolly -basicaa -polly-codegen-isl -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -S < %s | FileCheck %s
 
 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-unknown-linux-gnu"
 
 define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
 entry:
   br label %for.cond
 

test/Isl/CodeGen/scalar-references-used-in-scop-compute.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
 
 ; Test the code generation in the presence of a scalar out-of-scop value being
 ; used from within the SCoP.
 
 ; CHECH-LABEL: @scalar-function-argument
 ; CHECK: polly.split_new_and_old
 
 

test/Isl/CodeGen/scop_never_executed_runtime_check_location.ll

-; RUN: opt %loadPolly -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
 
 ; Verify that we generate the runtime check code after the conditional branch
 ; in the SCoP region entering block (here %entry).
 ;
 ; CHECK: entry:
 ; CHECK: zext i32 %n to i64
 ; CHECK: br i1 false
 ;

test/Isl/CodeGen/sequential_loops.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;#define N 1024
 ;
 ;int A[N];
 ;
 ;void sequential_loops() {
 ;  int i;

test/Isl/CodeGen/simple_loop_non_single_exit.ll

-; RUN: opt %loadPolly -polly-codegen-isl -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
 
 ; void f(long A[], long N) {
 ;   long i;
 ;   if (true)
 ;     for (i = 0; i < N; ++i)
 ;       A[i] = i;
 ; }
 

test/Isl/CodeGen/simple_loop_non_single_exit_2.ll

-; RUN: opt %loadPolly -polly-codegen-isl -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
 
 ; void f(long A[], long N) {
 ;   long i;
 ;   if (true)
 ;     if (true)
 ;       for (i = 0; i < N; ++i)
 ;         A[i] = i;
 ; }

test/Isl/CodeGen/simple_non_single_entry.ll

-; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
+; RUN: opt %loadPolly -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
 
 ; void f(long A[], long N) {
 ;   long i;
 ;
 ;  if (true){
 ;    i = 0;
 ;    goto next;
 ;  }else{

test/Isl/CodeGen/simple_nonaffine_loop.ll

-; RUN: opt %loadPolly -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s
 
 ;#include <stdio.h>
 ;#include <stdlib.h>
 ;#include <math.h>
 ;
 ;int main()
 ;{
 ; int A[1024*1024];

test/Isl/CodeGen/single_do_loop_int_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -analyze  -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze  -S < %s | FileCheck %s
 
 ;#define N 20
 ;#include "limits.h"
 ;#include <stdio.h>
 ;int A[N];
 ;
 ;void single_do_loop_int_max_iterations() {
 ;  int i;

test/Isl/CodeGen/single_do_loop_ll_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -analyze  -S < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl < %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze  -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl < %s
 
 ;#define N 20
 ;#include "limits.h"
 ;long long A[N];
 ;
 ;int main () {
 ;  long long i;
 ;

test/Isl/CodeGen/single_do_loop_scev_replace.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
 
 ;#define N 20
 ;#include "limits.h"
 ;#include <stdio.h>
 ;int A[2 * N];
 ;
 ;void single_do_loop_scev_replace() {
 ;  int i;

test/Isl/CodeGen/single_loop.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
 
 ;#include <string.h>
 ;#define N 1024
 ;
 ;int main () {
 ;  int i;
 ;  int A[N];
 ;

test/Isl/CodeGen/single_loop_int_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -analyze  -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze  -S < %s | FileCheck %s
 
 ;#define N 20
 ;#include "limits.h"
 ;
 ;int main () {
 ;  int i;
 ;  int A[N];
 ;

test/Isl/CodeGen/single_loop_ll_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -analyze  -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze  -S < %s | FileCheck %s
 
 ;#include "limits.h"
 ;#define N 20
 ;
 ;int main () {
 ;  long long i;
 ;  long long A[N];
 ;

test/Isl/CodeGen/single_loop_one_iteration.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
 
 ;#define N 20
 ;
 ;int main () {
 ;  int i;
 ;  int A[N];
 ;
 ;  A[0] = 0;

test/Isl/CodeGen/single_loop_param.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 @A = common global [1024 x i32] zeroinitializer, align 16 ; <[1024 x i32]*> [#uses=3]
 
 define void @bar(i64 %n) nounwind {
 bb:
   fence seq_cst

test/Isl/CodeGen/split_edges.ll

-; RUN: opt %loadPolly -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 define void @loop_with_condition() nounwind {
 bb0:
   fence seq_cst
   br label %bb1
 

test/Isl/CodeGen/split_edges_2.ll

-; RUN: opt %loadPolly -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
 
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 define void @loop_with_condition() nounwind {
 bb0:
   fence seq_cst
   br label %bb1

test/Isl/CodeGen/two-scops-in-row.ll

-; RUN: opt %loadPolly -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s 
-; RUN: opt %loadPolly -polly-codegen-isl -polly-ignore-aliasing < %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s 
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -polly-ignore-aliasing < %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: if (1)
 ; CHECK:     {
 ; CHECK:       for (int c0 = 0; c0 <= -Scalar0.val.loadoutside + 99; c0 += 1)
 ; CHECK:         Stmt_for_1(c0);
 ; CHECK:       if (Scalar0.val.loadoutside >= 100)

test/Isl/single_loop_param_less_equal.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl  -S < %s | FileCheck %s -check-prefix=CODEGEN
-; RUN: opt %loadPolly -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl  -S < %s | FileCheck %s -check-prefix=CODEGEN
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 @A = common global [1024 x i32] zeroinitializer
 
 define void @bar(i64 %n) {
 start:
   %n_plus_one = add i64 %n, 1

test/Isl/single_loop_param_less_than.ll

-; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-codegen-isl  -S < %s | FileCheck %s -check-prefix=CODEGEN
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl  -S < %s | FileCheck %s -check-prefix=CODEGEN
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 @A = common global [1024 x i32] zeroinitializer
 
 define void @bar(i64 %n) {
 start:
   fence seq_cst

test/Isl/single_loop_uint_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -S -analyze  < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -S -analyze  < %s | FileCheck %s
 ; XFAIL: *
 
 ;#include "limits.h"
 ;#define N 20
 ;
 ;int main () {
 ;  unsigned int i;
 ;  unsigned int A[N];

test/Isl/single_loop_ull_max_iterations.ll

-; RUN: opt %loadPolly -polly-ast -S -analyze  < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -S -analyze  < %s | FileCheck %s
 ; XFAIL: *
 
 ;#include "limits.h"
 ;#define N 20
 ;
 ;int main () {
 ;  unsigned long long i;
 ;  unsigned long long A[N];

test/ScheduleOptimizer/computeout.ll

-; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze < %s | FileCheck %s 
-; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
+; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s 
+; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
 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"
 target triple = "x86_64-pc-linux-gnu"
 
 ;     for(i = 0; i < 100; i++ )
 ; S1:   A[i] = 2;
 ;
 ;     for (i = 0; i < 10; i++ )
 ; S2:   A[i]  = 5;