Merge TempScopInfo into ScopInfo

[Meinersbur]

Summary

The TempScopInfo (-polly-analyze-ir) pass is removed and its work taken over by
ScopInfo (-polly-scops). Several tests depend on -polly-analyze-ir and use
-polly-scops instead which for the moment simplly prints the output of both
passes. This again is not expected by some other passes which have been adapted.

[llvm-commits]

LGTM

• msg-22298-559.dat219 BDownload
• msg-22298-560.txt162 BDownload

[Meinersbur]

Rebase to r247142

[Meinersbur]

Committed as r247288

include/polly/LinkAllPasses.h

 llvm::Pass *createJSONExporterPass();
 llvm::Pass *createJSONImporterPass();
 llvm::Pass *createPollyCanonicalizePass();
 llvm::Pass *createScopDetectionPass();
 llvm::Pass *createScopInfoPass();
 llvm::Pass *createIslAstInfoPass();
 llvm::Pass *createCodeGenerationPass();
 llvm::Pass *createIslScheduleOptimizerPass();
-llvm::Pass *createTempScopInfoPass();
 
 extern char &IndependentBlocksID;
 extern char &CodePreparationID;
 }
 
 namespace {
 struct PollyForcePassLinking {
   PollyForcePassLinking() {
PollyForcePassLinking() {
     polly::createJSONExporterPass();
     polly::createJSONImporterPass();
     polly::createScopDetectionPass();
     polly::createScopInfoPass();
     polly::createPollyCanonicalizePass();
     polly::createIslAstInfoPass();
     polly::createCodeGenerationPass();
     polly::createIslScheduleOptimizerPass();
-    polly::createTempScopInfoPass();
   }
 } PollyForcePassLinking; // Force link by creating a global definition.
 }
 
 namespace llvm {
 class PassRegistry;
 void initializeCodePreparationPass(llvm::PassRegistry &);
 void initializeDeadCodeElimPass(llvm::PassRegistry &);

include/polly/ScopInfo.h

 /// this Scop, and others context.
 class TempScop {
   // The Region.
   Region &R;
 
   // Access function of bbs.
   AccFuncMapType &AccFuncMap;
 
-  friend class TempScopInfo;
+  friend class ScopInfo;
 
   explicit TempScop(Region &r, AccFuncMapType &accFuncMap)
       : R(r), AccFuncMap(accFuncMap) {}
 
 public:
   ~TempScop();
 
   /// @brief Get the maximum Region contained by this Scop.
public:
   /// @param OS The output stream the access functions is printed to.
   /// @param SE The ScalarEvolution that help printing the access functions.
   /// @param LI The LoopInfo that help printing the access functions.
   void printDetail(raw_ostream &OS, ScalarEvolution *SE, LoopInfo *LI,
                    const Region *Reg, unsigned ind) const;
 };
 
 typedef std::map<const Region *, TempScop *> TempScopMapType;
-//===----------------------------------------------------------------------===//
-/// @brief The Function Pass to extract temporary information for Static control
-///        part in llvm function.
+
+///===---------------------------------------------------------------------===//
+/// @brief Build the Polly IR (Scop and ScopStmt) on a Region.
 ///
-class TempScopInfo : public RegionPass {
+class ScopInfo : public RegionPass {
   //===-------------------------------------------------------------------===//
-  TempScopInfo(const TempScopInfo &) = delete;
-  const TempScopInfo &operator=(const TempScopInfo &) = delete;
+  ScopInfo(const ScopInfo &) = delete;
+  const ScopInfo &operator=(const ScopInfo &) = delete;
 
   // The ScalarEvolution to help building Scop.
   ScalarEvolution *SE;
 
   // LoopInfo for information about loops
   LoopInfo *LI;
 
   // The AliasAnalysis to build AliasSetTracker.
class ScopInfo : public RegionPass {
 
   // Pre-created zero for the scalar accesses, with it we do not need create a
   // zero scev every time when we need it.
   const SCEV *ZeroOffset;
 
   // The TempScop for this region.
   TempScop *TempScopOfRegion;
 
+  // The Scop
+  Scop *scop;
+  isl_ctx *ctx;
+
   // Clear the context.
   void clear();
 
   // Build the temprory information of Region R, where R must be a valid part
   // of Scop.
   TempScop *buildTempScop(Region &R);
 
   /// @brief Build an instance of IRAccess from the Load/Store instruction.
class ScopInfo : public RegionPass {
   /// @param NonAffineSubRegion The non affine sub-region @p BB is in.
   /// @param IsExitBlock        Flag to indicate that @p BB is in the exit BB.
   void buildAccessFunctions(Region &R, BasicBlock &BB,
                             Region *NonAffineSubRegion = nullptr,
                             bool IsExitBlock = false);
 
 public:
   static char ID;
-  explicit TempScopInfo() : RegionPass(ID), TempScopOfRegion(nullptr) {}
-  ~TempScopInfo();
+  explicit ScopInfo();
+  ~ScopInfo();
 
   /// @brief Get the temporay Scop information in LLVM IR for this region.
   ///
   /// @return The Scop information in LLVM IR represent.
   TempScop *getTempScop() const;
 
-  /// @name RegionPass interface
-  //@{
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-  virtual void releaseMemory() { clear(); }
-  virtual bool runOnRegion(Region *R, RGPassManager &RGM);
-  virtual void print(raw_ostream &OS, const Module *) const;
-  //@}
-};
-
-///===---------------------------------------------------------------------===//
-/// @brief Build the Polly IR (Scop and ScopStmt) on a Region.
-///
-class ScopInfo : public RegionPass {
-  //===-------------------------------------------------------------------===//
-  ScopInfo(const ScopInfo &) = delete;
-  const ScopInfo &operator=(const ScopInfo &) = delete;
-
-  // The Scop
-  Scop *scop;
-  isl_ctx *ctx;
-
-  void clear() {
-    if (scop) {
-      delete scop;
-      scop = 0;
-    }
-  }
-
-public:
-  static char ID;
-  explicit ScopInfo();
-  ~ScopInfo();
-
   /// @brief Try to build the Polly IR of static control part on the current
   ///        SESE-Region.
   ///
   /// @return If the current region is a valid for a static control part,
   ///         return the Polly IR representing this static control part,
   ///         return null otherwise.
   Scop *getScop() { return scop; }
   const Scop *getScop() const { return scop; }
 
   /// @name RegionPass interface
   //@{
   virtual bool runOnRegion(Region *R, RGPassManager &RGM);
   virtual void getAnalysisUsage(AnalysisUsage &AU) const;
   virtual void releaseMemory() { clear(); }
-  virtual void print(raw_ostream &OS, const Module *) const {
-    if (scop)
-      scop->print(OS);
-    else
-      OS << "Invalid Scop!\n";
-  }
+  virtual void print(raw_ostream &OS, const Module *) const;
   //@}
 };
 
 } // end namespace polly
 
 namespace llvm {
 class PassRegistry;
-void initializeTempScopInfoPass(llvm::PassRegistry &);
 void initializeScopInfoPass(llvm::PassRegistry &);
 }
 
 #endif

lib/Analysis/ScopInfo.cpp

 int Scop::getRelativeLoopDepth(const Loop *L) const {
   Loop *OuterLoop =
       L ? R.outermostLoopInRegion(const_cast<Loop *>(L)) : nullptr;
   if (!OuterLoop)
     return -1;
   return L->getLoopDepth() - OuterLoop->getLoopDepth();
 }
 
-void TempScopInfo::buildPHIAccesses(PHINode *PHI, Region &R,
-                                    AccFuncSetType &Functions,
-                                    Region *NonAffineSubRegion,
-                                    bool IsExitBlock) {
+void ScopInfo::buildPHIAccesses(PHINode *PHI, Region &R,
+                                Region *NonAffineSubRegion, bool IsExitBlock) {
 
   // PHI nodes that are in the exit block of the region, hence if IsExitBlock is
   // true, are not modeled as ordinary PHI nodes as they are not part of the
   // region. However, we model the operands in the predecessor blocks that are
   // part of the region as regular scalar accesses.
 
   // If we can synthesize a PHI we can skip it, however only if it is in
   // the region. If it is not it can only be in the exit block of the region.
void ScopInfo::buildPHIAccesses(PHINode *PHI, Region &R,
 
   if (!OnlyNonAffineSubRegionOperands) {
     IRAccess ScalarAccess(IRAccess::READ, PHI, ZeroOffset, 1, true, PHI,
                           /* IsPHI */ !IsExitBlock);
     Functions.push_back(std::make_pair(ScalarAccess, PHI));
   }
 }
 
-bool TempScopInfo::buildScalarDependences(Instruction *Inst, Region *R,
-                                          Region *NonAffineSubRegion) {
+bool ScopInfo::buildScalarDependences(Instruction *Inst, Region *R,
   bool canSynthesizeInst = canSynthesize(Inst, LI, SE, R);
   if (isIgnoredIntrinsic(Inst))
     return false;
 
   bool AnyCrossStmtUse = false;
   BasicBlock *ParentBB = Inst->getParent();
 
   for (User *U : Inst->users()) {
bool ScopInfo::buildScalarDependences(Instruction *Inst, Region *R,
   }
 
   return AnyCrossStmtUse;
 }
 
 extern MapInsnToMemAcc InsnToMemAcc;
 
 IRAccess
-TempScopInfo::buildIRAccess(Instruction *Inst, Loop *L, Region *R,
-                            const ScopDetection::BoxedLoopsSetTy *BoxedLoops) {
+ScopInfo::buildIRAccess(Instruction *Inst, Loop *L, Region *R,
   unsigned Size;
   Type *SizeType;
   Value *Val;
   enum IRAccess::TypeKind Type;
 
   if (LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
     SizeType = Load->getType();
     Size = TD->getTypeStoreSize(SizeType);
ScopInfo::buildIRAccess(Instruction *Inst, Loop *L, Region *R,
 
   if (!IsAffine && Type == IRAccess::MUST_WRITE)
     Type = IRAccess::MAY_WRITE;
 
   return IRAccess(Type, BasePointer->getValue(), AccessFunction, Size, IsAffine,
                   Subscripts, Sizes, Val);
 }
 
-void TempScopInfo::buildAccessFunctions(Region &R, Region &SR) {
+void ScopInfo::buildAccessFunctions(Region &R, Region &SR) {
 
   if (SD->isNonAffineSubRegion(&SR, &R)) {
     for (BasicBlock *BB : SR.blocks())
       buildAccessFunctions(R, *BB, &SR);
     return;
   }
 
   for (auto I = SR.element_begin(), E = SR.element_end(); I != E; ++I)
     if (I->isSubRegion())
       buildAccessFunctions(R, *I->getNodeAs<Region>());
     else
       buildAccessFunctions(R, *I->getNodeAs<BasicBlock>());
 }
 
-void TempScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB,
-                                        Region *NonAffineSubRegion,
-                                        bool IsExitBlock) {
+void ScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB,
   AccFuncSetType Functions;
   Loop *L = LI->getLoopFor(&BB);
 
   // The set of loops contained in non-affine subregions that are part of R.
   const ScopDetection::BoxedLoopsSetTy *BoxedLoops = SD->getBoxedLoops(&R);
 
   for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I) {
     Instruction *Inst = I;
void ScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB,
 
   if (Functions.empty())
     return;
 
   AccFuncSetType &Accs = AccFuncMap[&BB];
   Accs.insert(Accs.end(), Functions.begin(), Functions.end());
 }
 
-TempScop *TempScopInfo::buildTempScop(Region &R) {
+TempScop *ScopInfo::buildTempScop(Region &R) {
   TempScop *TScop = new TempScop(R, AccFuncMap);
 
   buildAccessFunctions(R, R);
 
   // In case the region does not have an exiting block we will later (during
   // code generation) split the exit block. This will move potential PHI nodes
   // from the current exit block into the new region exiting block. Hence, PHI
   // nodes that are at this point not part of the region will be.
   // To handle these PHI nodes later we will now model their operands as scalar
   // accesses. Note that we do not model anything in the exit block if we have
   // an exiting block in the region, as there will not be any splitting later.
   if (!R.getExitingBlock())
     buildAccessFunctions(R, *R.getExit(), nullptr, /* IsExitBlock */ true);
 
   return TScop;
 }
 
-TempScop *TempScopInfo::getTempScop() const { return TempScopOfRegion; }
+TempScop *ScopInfo::getTempScop() const { return TempScopOfRegion; }
 
-void TempScopInfo::print(raw_ostream &OS, const Module *) const {
+void ScopInfo::print(raw_ostream &OS, const Module *) const {
   if (TempScopOfRegion)
     TempScopOfRegion->print(OS, SE, LI);
-}
-
-bool TempScopInfo::runOnRegion(Region *R, RGPassManager &RGM) {
-  SD = &getAnalysis<ScopDetection>();
-
-  if (!SD->isMaxRegionInScop(*R))
-    return false;
-
-  Function *F = R->getEntry()->getParent();
-  SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
-  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
-  AA = &getAnalysis<AliasAnalysis>();
-  TD = &F->getParent()->getDataLayout();
-  ZeroOffset = SE->getConstant(TD->getIntPtrType(F->getContext()), 0);
-
-  assert(!TempScopOfRegion && "Build the TempScop only once");
-  TempScopOfRegion = buildTempScop(*R);
-
-  return false;
-}
 
-void TempScopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequiredTransitive<LoopInfoWrapperPass>();
-  AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
-  AU.addRequiredTransitive<ScopDetection>();
-  AU.addRequiredID(IndependentBlocksID);
-  AU.addRequired<AliasAnalysis>();
-  AU.setPreservesAll();
+  if (scop)
+    scop->print(OS);
+  else
+    OS << "Invalid Scop!\n";
 }
 
-TempScopInfo::~TempScopInfo() { clear(); }
-
-void TempScopInfo::clear() {
+void ScopInfo::clear() {
   AccFuncMap.clear();
   if (TempScopOfRegion)
     delete TempScopOfRegion;
   TempScopOfRegion = nullptr;
-}
-
-//===----------------------------------------------------------------------===//
-// TempScop information extraction pass implement
-char TempScopInfo::ID = 0;
-
-Pass *polly::createTempScopInfoPass() { return new TempScopInfo(); }
 
-INITIALIZE_PASS_BEGIN(TempScopInfo, "polly-analyze-ir",
-                      "Polly - Analyse the LLVM-IR in the detected regions",
-                      false, false);
-INITIALIZE_AG_DEPENDENCY(AliasAnalysis);
-INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
-INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
-INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
-INITIALIZE_PASS_END(TempScopInfo, "polly-analyze-ir",
-                    "Polly - Analyse the LLVM-IR in the detected regions",
-                    false, false)
+  if (scop) {
+    delete scop;
+    scop = 0;
+  }
+}
 
 //===----------------------------------------------------------------------===//
-ScopInfo::ScopInfo() : RegionPass(ID), scop(0) {
+ScopInfo::ScopInfo() : RegionPass(ID), TempScopOfRegion(nullptr), scop(0) {
   ctx = isl_ctx_alloc();
   isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
 }
 
 ScopInfo::~ScopInfo() {
   clear();
   isl_ctx_free(ctx);
 }
 
 void ScopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequiredID(IndependentBlocksID);
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
-  AU.addRequired<ScalarEvolutionWrapperPass>();
-  AU.addRequired<ScopDetection>();
-  AU.addRequired<TempScopInfo>();
+  AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
+  AU.addRequiredTransitive<ScopDetection>();
   AU.addRequired<AliasAnalysis>();
   AU.setPreservesAll();
 }
 
 bool ScopInfo::runOnRegion(Region *R, RGPassManager &RGM) {
-  LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
-  AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
-  ScopDetection &SD = getAnalysis<ScopDetection>();
-  ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
+  SD = &getAnalysis<ScopDetection>();
+
+  if (!SD->isMaxRegionInScop(*R))
+    return false;
+
+  Function *F = R->getEntry()->getParent();
+  SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
+  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
+  AA = &getAnalysis<AliasAnalysis>();
+  TD = &F->getParent()->getDataLayout();
   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  ZeroOffset = SE->getConstant(TD->getIntPtrType(F->getContext()), 0);
 
-  TempScop *tempScop = getAnalysis<TempScopInfo>().getTempScop();
+  assert(!TempScopOfRegion && "Build the TempScop only once");
+  TempScopOfRegion = buildTempScop(*R);
 
   // This region is no Scop.
-  if (!tempScop) {
+  if (!TempScopOfRegion) {
     scop = nullptr;
     return false;
   }
 
-  scop = Scop::createFromTempScop(*tempScop, LI, SE, SD, AA, DT, ctx);
+  scop =
+      Scop::createFromTempScop(*TempScopOfRegion, *LI, *SE, *SD, *AA, DT, ctx);
 
   DEBUG(scop->print(dbgs()));
 
   if (!scop->hasFeasibleRuntimeContext()) {
     delete scop;
     scop = nullptr;
     return false;
   }

 INITIALIZE_PASS_BEGIN(ScopInfo, "polly-scops",
                       "Polly - Create polyhedral description of Scops", false,
                       false);
 INITIALIZE_AG_DEPENDENCY(AliasAnalysis);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetection);
-INITIALIZE_PASS_DEPENDENCY(TempScopInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_END(ScopInfo, "polly-scops",
                     "Polly - Create polyhedral description of Scops", false,
                     false)

lib/CodeGen/CodeGeneration.cpp

void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addPreserved<PostDominatorTree>();
     AU.addPreserved<IslAstInfo>();
     AU.addPreserved<ScopDetection>();
     AU.addPreserved<ScalarEvolutionWrapperPass>();
 
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
     AU.addPreserved<RegionInfoPass>();
-    AU.addPreserved<TempScopInfo>();
     AU.addPreserved<ScopInfo>();
     AU.addPreservedID(IndependentBlocksID);
   }
 };
 }
 
 char CodeGeneration::ID = 1;
 

lib/Support/RegisterPasses.cpp

void initializePollyPasses(PassRegistry &Registry) {
   initializeIndependentBlocksPass(Registry);
   initializeJSONExporterPass(Registry);
   initializeJSONImporterPass(Registry);
   initializeIslAstInfoPass(Registry);
   initializeIslScheduleOptimizerPass(Registry);
   initializePollyCanonicalizePass(Registry);
   initializeScopDetectionPass(Registry);
   initializeScopInfoPass(Registry);
-  initializeTempScopInfoPass(Registry);
 }
 
 /// @brief Register Polly passes such that they form a polyhedral optimizer.
 ///
 /// The individual Polly passes are registered in the pass manager such that
 /// they form a full polyhedral optimizer. The flow of the optimizer starts with
 /// a set of preparing transformations that canonicalize the LLVM-IR such that
 /// the LLVM-IR is easier for us to understand and to optimizes. On the

test/ScopInfo/Alias-0.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
 ; REQUIRES: asserts
 
 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"
 
 define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
 bb.nph:
   %0 = tail call i32 (...) @rnd() nounwind       ; <i32> [#uses=1]
   %1 = icmp eq i32 %0, 0                          ; <i1> [#uses=1]

test/ScopInfo/Alias-1.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
 ; REQUIRES: asserts
 
 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"
 
 define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
 bb.nph:
   %0 = tail call i32 (...) @rnd() nounwind       ; <i32> [#uses=1]
   %1 = icmp eq i32 %0, 0                          ; <i1> [#uses=1]

test/ScopInfo/Alias-2.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
 ; REQUIRES: asserts
 
 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"
 
 define void @f(i32** nocapture %ptrs, i64 %p0, i64 %p1, i64 %p2) nounwind {
 bb.nph:
   %0 = getelementptr inbounds i32*, i32** %ptrs, i64 %p0 ; <i32**> [#uses=1]
   %1 = load i32*, i32** %0, align 8                     ; <i32*> [#uses=1]

test/ScopInfo/Alias-3.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
 ; REQUIRES: asserts
 
 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"
 
 define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
 bb.nph:
   br label %bb
 

test/ScopInfo/Alias-4.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
 ; REQUIRES: asserts
 
 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"
 
 define void @f(i32* noalias nocapture %a, i32* noalias nocapture %b) nounwind {
 bb.nph:
   br label %bb
 

test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8
 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7
 ;
 ; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
 ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
 ;
-; MAX8:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
-; MAX8-NEXT:  Function: jd
+; MAX8-LABEL:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
+; MAX8:  Function: jd
 
-; MAX7:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
-; MAX7-NEXT:  Invalid Scop!
+; MAX7-LABEL:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
+; MAX7:  Invalid Scop!
 ;
 ;    void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5,
 ;            long p6, long p7, long p8, long p9, long p10) {
 ;      for (int i = 0; i < 1024; i++)
 ;        A[i] = B[p1] - B[p2] + B[-p3] - B[p4] + B[p5] - B[-p6] + B[p7] - C[p3] +
 ;               C[-p4] - C[p5] + C[p6] - C[-p7] + C[p8] - C[p9] + C[-p10];
 ;    }
 ;

test/ScopInfo/bug_2010_10_22.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir < %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops < %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"
 
 define fastcc void @_Z8wavModelR5Mixer() {
 entry:
   br label %bb230
 
 bb230:                                            ; preds = %bb233, %bb.nph433

test/ScopInfo/bug_2011_1_5.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir -analyze < %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s
 
 ; Bug description: Alias Analysis thinks IntToPtrInst aliases with alloca instructions created by IndependentBlocks Pass.
 ;                  This will trigger the assertion when we are verifying the SCoP after IndependentBlocks.
 
 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"
 
 %struct.precisionType = type { i16, i16, i16, i8, [1 x i16] }
 

test/ScopInfo/cond_in_loop.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir  -analyze < %s | not FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
 
 ;void f(long a[], long N, long M) {
 ;  long i, j, k;
 ;  for (j = 0; j < M; ++j)
 ;    if (N > j)
 ;      a[j] = j;
 ;    else {
 ;      a[j] = M;
bb3:                                              ; preds = %bb2, %bb1
   %3 = add nsw i64 %1, 1                          ; <i64> [#uses=2]
   %exitcond = icmp eq i64 %3, %M                  ; <i1> [#uses=1]
   br i1 %exitcond, label %return, label %bb
 
 return:                                           ; preds = %bb3, %entry
   ret void
 }
 
-; CHECK: Scop!
+; CHECK-LABEL: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'bb => return' in function 'f':
+; CHECK-NEXT:  Scop: bb => return

test/TempScop/inter_bb_scalar_dep.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir  -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
 
 ; void f(long A[], int N, int *init_ptr) {
 ;   long i, j;
 ;
 ;   for (i = 0; i < N; ++i) {
 ;     init = *init_ptr;
 ;     for (i = 0; i < N; ++i) {
 ;       A[i] = init + 2;

test/TempScop/intra_and_inter_bb_scalar_dep.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
 
 ; void f(long A[], int N, int *init_ptr) {
 ;   long i, j;
 ;
 ;   for (i = 0; i < N; ++i) {
 ;     init = *init_ptr;
 ;     for (i = 0; i < N; ++i) {
 ;       init2 = *init_ptr;

test/TempScop/intra_bb_scalar_dep.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir  -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
 
 ; void f(long A[], int N, int *init_ptr) {
 ;   long i, j;
 ;
 ;   for (i = 0; i < N; ++i) {
 ;     for (i = 0; i < N; ++i) {
 ;       init = *init_ptr;
 ;       A[i] = init + 2;

test/TempScop/not-a-reduction.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir -analyze < %s 2>&1 | not FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s 2>&1 | not FileCheck %s
 
 ;#define TYPE float
 ;#define NUM 4
 ;
 ;TYPE A[NUM];
 ;TYPE B[NUM];
 ;TYPE C[NUM];
 ;

 bb7:                                              ; preds = %bb4
   %indvar.next = add i64 %indvar, 1
   br label %bb3
 
 bb8:                                              ; preds = %bb3
   ret void
 }
 
-; CHECK:     Reduction
+; Match any reduction type except "[Reduction Type: NONE]"
+; CHECK:     [Reduction Type: {{[^N].*}}]

test/TempScop/scalar_to_array.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | 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
 
 ; CHECK: empty
 ; Function Attrs: nounwind

test/TempScop/tempscop-printing.ll

-; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s -check-prefix=SCALARACCESS
+; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s -check-prefix=SCALARACCESS
 
 ; void f(long A[], int N, int *init_ptr) {
 ;   long i, j;
 ;
 ;   for (i = 0; i < N; ++i) {
 ;     init = *init_ptr;
 ;     for (i = 0; i < N; ++i) {
 ;       A[i] = init + 2;