Index: polly/trunk/include/polly/LinkAllPasses.h =================================================================== --- polly/trunk/include/polly/LinkAllPasses.h +++ polly/trunk/include/polly/LinkAllPasses.h @@ -37,7 +37,7 @@ llvm::Pass *createJSONImporterPass(); llvm::Pass *createPollyCanonicalizePass(); llvm::Pass *createScopDetectionPass(); -llvm::Pass *createScopInfoPass(); +llvm::Pass *createScopInfoRegionPassPass(); llvm::Pass *createIslAstInfoPass(); llvm::Pass *createCodeGenerationPass(); llvm::Pass *createIslScheduleOptimizerPass(); @@ -65,7 +65,7 @@ polly::createJSONExporterPass(); polly::createJSONImporterPass(); polly::createScopDetectionPass(); - polly::createScopInfoPass(); + polly::createScopInfoRegionPassPass(); polly::createPollyCanonicalizePass(); polly::createIslAstInfoPass(); polly::createCodeGenerationPass(); Index: polly/trunk/include/polly/ScopInfo.h =================================================================== --- polly/trunk/include/polly/ScopInfo.h +++ polly/trunk/include/polly/ScopInfo.h @@ -2247,28 +2247,28 @@ } /// @brief Build the Polly IR (Scop and ScopStmt) on a Region. -class ScopInfo : public RegionPass { +class ScopInfo { //===-------------------------------------------------------------------===// ScopInfo(const ScopInfo &) = delete; const ScopInfo &operator=(const ScopInfo &) = delete; /// @brief The AliasAnalysis to build AliasSetTracker. - AliasAnalysis *AA; + AliasAnalysis &AA; /// @brief Target data for element size computing. - const DataLayout *DL; + const DataLayout &DL; /// @brief DominatorTree to reason about guaranteed execution. - DominatorTree *DT; + DominatorTree &DT; /// @brief LoopInfo for information about loops - LoopInfo *LI; + LoopInfo &LI; /// @biref Valid Regions for Scop - ScopDetection *SD; + ScopDetection &SD; /// @brief The ScalarEvolution to help building Scop. - ScalarEvolution *SE; + ScalarEvolution &SE; /// @brief Set of instructions that might read any memory location. SmallVector GlobalReads; @@ -2468,9 +2468,10 @@ void addPHIReadAccess(PHINode *PHI); public: - static char ID; - explicit ScopInfo(); - ~ScopInfo(); + explicit ScopInfo(Region *R, AssumptionCache &AC, AliasAnalysis &AA, + const DataLayout &DL, DominatorTree &DT, LoopInfo &LI, + ScopDetection &SD, ScalarEvolution &SE); + ~ScopInfo() {} /// @brief Try to build the Polly IR of static control part on the current /// SESE-Region. @@ -2480,21 +2481,52 @@ /// return null otherwise. Scop *getScop() { return scop.get(); } const Scop *getScop() const { return scop.get(); } +}; - /// @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; - //@} +/// @brief The legacy pass manager's analysis pass to compute scop information +/// for a region. +class ScopInfoRegionPass : public RegionPass { + /// @brief The ScopInfo pointer which is used to construct a Scop. + std::unique_ptr SI; + +public: + static char ID; // Pass identification, replacement for typeid + + ScopInfoRegionPass() : RegionPass(ID) {} + ~ScopInfoRegionPass() {} + + /// @brief Build ScopInfo object, which constructs Polly IR of static control + /// part for the current SESE-Region. + /// + /// @return Return Scop for the current Region. + Scop *getScop() { + if (SI) + return SI.get()->getScop(); + else + return nullptr; + } + const Scop *getScop() const { + if (SI) + return SI.get()->getScop(); + else + return nullptr; + } + + /// @brief Calculate the polyhedral scop information for a given Region. + bool runOnRegion(Region *R, RGPassManager &RGM) override; + + void releaseMemory() override { SI.reset(); } + + void print(raw_ostream &O, const Module *M = nullptr) const override; + + void getAnalysisUsage(AnalysisUsage &AU) const override; }; } // end namespace polly namespace llvm { class PassRegistry; -void initializeScopInfoPass(llvm::PassRegistry &); +void initializeScopInfoRegionPassPass(llvm::PassRegistry &); } #endif Index: polly/trunk/lib/Analysis/DependenceInfo.cpp =================================================================== --- polly/trunk/lib/Analysis/DependenceInfo.cpp +++ polly/trunk/lib/Analysis/DependenceInfo.cpp @@ -791,7 +791,7 @@ } void DependenceInfo::getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredTransitive(); + AU.addRequiredTransitive(); AU.setPreservesAll(); } @@ -801,6 +801,6 @@ INITIALIZE_PASS_BEGIN(DependenceInfo, "polly-dependences", "Polly - Calculate dependences", false, false); -INITIALIZE_PASS_DEPENDENCY(ScopInfo); +INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass); INITIALIZE_PASS_END(DependenceInfo, "polly-dependences", "Polly - Calculate dependences", false, false) Index: polly/trunk/lib/Analysis/ScopInfo.cpp =================================================================== --- polly/trunk/lib/Analysis/ScopInfo.cpp +++ polly/trunk/lib/Analysis/ScopInfo.cpp @@ -4247,8 +4247,8 @@ // 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. // In this case we model the operands but not the PHI itself. - auto *Scope = LI->getLoopFor(PHI->getParent()); - if (!IsExitBlock && canSynthesize(PHI, *scop, LI, SE, Scope)) + auto *Scope = LI.getLoopFor(PHI->getParent()); + if (!IsExitBlock && canSynthesize(PHI, *scop, &LI, &SE, Scope)) return; // PHI nodes are modeled as if they had been demoted prior to the SCoP @@ -4311,9 +4311,9 @@ Value *Val = Inst.getValueOperand(); Type *ElementType = Val->getType(); Value *Address = Inst.getPointerOperand(); - const SCEV *AccessFunction = SE->getSCEVAtScope(Address, L); + const SCEV *AccessFunction = SE.getSCEVAtScope(Address, L); const SCEVUnknown *BasePointer = - dyn_cast(SE->getPointerBase(AccessFunction)); + dyn_cast(SE.getPointerBase(AccessFunction)); enum MemoryAccess::AccessType AccType = isa(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE; @@ -4327,8 +4327,8 @@ return false; } if (SrcTy->isPointerTy() && DstTy->isPointerTy() && - DL->getTypeAllocSize(SrcTy->getPointerElementType()) == - DL->getTypeAllocSize(DstTy->getPointerElementType())) + DL.getTypeAllocSize(SrcTy->getPointerElementType()) == + DL.getTypeAllocSize(DstTy->getPointerElementType())) Address = Src; } @@ -4338,7 +4338,7 @@ std::vector Subscripts; std::vector Sizes; - std::tie(Subscripts, Sizes) = getIndexExpressionsFromGEP(GEP, *SE); + std::tie(Subscripts, Sizes) = getIndexExpressionsFromGEP(GEP, SE); auto *BasePtr = GEP->getOperand(0); if (auto *BasePtrCast = dyn_cast(BasePtr)) @@ -4354,7 +4354,7 @@ const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads(); for (auto *Subscript : Subscripts) { InvariantLoadsSetTy AccessILS; - if (!isAffineExpr(&scop->getRegion(), L, Subscript, *SE, &AccessILS)) + if (!isAffineExpr(&scop->getRegion(), L, Subscript, SE, &AccessILS)) return false; for (LoadInst *LInst : AccessILS) @@ -4366,7 +4366,7 @@ return false; for (auto V : Sizes) - SizesSCEV.push_back(SE->getSCEV( + SizesSCEV.push_back(SE.getSCEV( ConstantInt::get(IntegerType::getInt64Ty(BasePtr->getContext()), V))); addArrayAccess(Inst, AccType, BasePointer->getValue(), ElementType, true, @@ -4381,13 +4381,13 @@ Value *Address = Inst.getPointerOperand(); Value *Val = Inst.getValueOperand(); Type *ElementType = Val->getType(); - unsigned ElementSize = DL->getTypeAllocSize(ElementType); + unsigned ElementSize = DL.getTypeAllocSize(ElementType); enum MemoryAccess::AccessType AccType = isa(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE; - const SCEV *AccessFunction = SE->getSCEVAtScope(Address, L); + const SCEV *AccessFunction = SE.getSCEVAtScope(Address, L); const SCEVUnknown *BasePointer = - dyn_cast(SE->getPointerBase(AccessFunction)); + dyn_cast(SE.getPointerBase(AccessFunction)); assert(BasePointer && "Could not find base pointer"); @@ -4422,14 +4422,14 @@ if (MemIntr == nullptr) return false; - auto *LengthVal = SE->getSCEVAtScope(MemIntr->getLength(), L); + auto *LengthVal = SE.getSCEVAtScope(MemIntr->getLength(), L); assert(LengthVal); // Check if the length val is actually affine or if we overapproximate it InvariantLoadsSetTy AccessILS; const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads(); bool LengthIsAffine = - isAffineExpr(&scop->getRegion(), L, LengthVal, *SE, &AccessILS); + isAffineExpr(&scop->getRegion(), L, LengthVal, SE, &AccessILS); for (LoadInst *LInst : AccessILS) if (!ScopRIL.count(LInst)) LengthIsAffine = false; @@ -4439,7 +4439,7 @@ auto *DestPtrVal = MemIntr->getDest(); assert(DestPtrVal); - auto *DestAccFunc = SE->getSCEVAtScope(DestPtrVal, L); + auto *DestAccFunc = SE.getSCEVAtScope(DestPtrVal, L); assert(DestAccFunc); // Ignore accesses to "NULL". // TODO: We could use this to optimize the region further, e.g., intersect @@ -4449,9 +4449,9 @@ if (DestAccFunc->isZero()) return true; - auto *DestPtrSCEV = dyn_cast(SE->getPointerBase(DestAccFunc)); + auto *DestPtrSCEV = dyn_cast(SE.getPointerBase(DestAccFunc)); assert(DestPtrSCEV); - DestAccFunc = SE->getMinusSCEV(DestAccFunc, DestPtrSCEV); + DestAccFunc = SE.getMinusSCEV(DestAccFunc, DestPtrSCEV); addArrayAccess(Inst, MemoryAccess::MUST_WRITE, DestPtrSCEV->getValue(), IntegerType::getInt8Ty(DestPtrVal->getContext()), false, {DestAccFunc, LengthVal}, {}, Inst.getValueOperand()); @@ -4463,16 +4463,16 @@ auto *SrcPtrVal = MemTrans->getSource(); assert(SrcPtrVal); - auto *SrcAccFunc = SE->getSCEVAtScope(SrcPtrVal, L); + auto *SrcAccFunc = SE.getSCEVAtScope(SrcPtrVal, L); assert(SrcAccFunc); // Ignore accesses to "NULL". // TODO: See above TODO if (SrcAccFunc->isZero()) return true; - auto *SrcPtrSCEV = dyn_cast(SE->getPointerBase(SrcAccFunc)); + auto *SrcPtrSCEV = dyn_cast(SE.getPointerBase(SrcAccFunc)); assert(SrcPtrSCEV); - SrcAccFunc = SE->getMinusSCEV(SrcAccFunc, SrcPtrSCEV); + SrcAccFunc = SE.getMinusSCEV(SrcAccFunc, SrcPtrSCEV); addArrayAccess(Inst, MemoryAccess::READ, SrcPtrSCEV->getValue(), IntegerType::getInt8Ty(SrcPtrVal->getContext()), false, {SrcAccFunc, LengthVal}, {}, Inst.getValueOperand()); @@ -4490,9 +4490,9 @@ return true; bool ReadOnly = false; - auto *AF = SE->getConstant(IntegerType::getInt64Ty(CI->getContext()), 0); + auto *AF = SE.getConstant(IntegerType::getInt64Ty(CI->getContext()), 0); auto *CalledFunction = CI->getCalledFunction(); - switch (AA->getModRefBehavior(CalledFunction)) { + switch (AA.getModRefBehavior(CalledFunction)) { case llvm::FMRB_UnknownModRefBehavior: llvm_unreachable("Unknown mod ref behaviour cannot be represented."); case llvm::FMRB_DoesNotAccessMemory: @@ -4509,11 +4509,11 @@ if (!Arg->getType()->isPointerTy()) continue; - auto *ArgSCEV = SE->getSCEVAtScope(Arg, L); + auto *ArgSCEV = SE.getSCEVAtScope(Arg, L); if (ArgSCEV->isZero()) continue; - auto *ArgBasePtr = cast(SE->getPointerBase(ArgSCEV)); + auto *ArgBasePtr = cast(SE.getPointerBase(ArgSCEV)); addArrayAccess(Inst, AccType, ArgBasePtr->getValue(), ArgBasePtr->getType(), false, {AF}, {}, CI); } @@ -4530,12 +4530,12 @@ enum MemoryAccess::AccessType AccType = isa(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE; - const SCEV *AccessFunction = SE->getSCEVAtScope(Address, L); + const SCEV *AccessFunction = SE.getSCEVAtScope(Address, L); const SCEVUnknown *BasePointer = - dyn_cast(SE->getPointerBase(AccessFunction)); + dyn_cast(SE.getPointerBase(AccessFunction)); assert(BasePointer && "Could not find base pointer"); - AccessFunction = SE->getMinusSCEV(AccessFunction, BasePointer); + AccessFunction = SE.getMinusSCEV(AccessFunction, BasePointer); // Check if the access depends on a loop contained in a non-affine subregion. bool isVariantInNonAffineLoop = false; @@ -4549,7 +4549,7 @@ InvariantLoadsSetTy AccessILS; bool IsAffine = !isVariantInNonAffineLoop && - isAffineExpr(&scop->getRegion(), L, AccessFunction, *SE, &AccessILS); + isAffineExpr(&scop->getRegion(), L, AccessFunction, SE, &AccessILS); const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads(); for (LoadInst *LInst : AccessILS) @@ -4613,10 +4613,10 @@ bool IsExitBlock) { // We do not build access functions for error blocks, as they may contain // instructions we can not model. - if (isErrorBlock(BB, scop->getRegion(), *LI, *DT) && !IsExitBlock) + if (isErrorBlock(BB, scop->getRegion(), LI, DT) && !IsExitBlock) return; - Loop *L = LI->getLoopFor(&BB); + Loop *L = LI.getLoopFor(&BB); for (Instruction &Inst : BB) { PHINode *PHI = dyn_cast(&Inst); @@ -4674,7 +4674,7 @@ // executed. In non-affine regions there may exist MK_Values that do not // dominate the exit. MK_Values will always dominate the exit and MK_PHIs // only if there is at most one PHI_WRITE in the non-affine region. - if (DT->dominates(BB, Stmt->getRegion()->getExit())) + if (DT.dominates(BB, Stmt->getRegion()->getExit())) isKnownMustAccess = true; } @@ -4730,8 +4730,8 @@ // If the instruction can be synthesized and the user is in the region we do // not need to add a value dependences. - auto *Scope = LI->getLoopFor(UserBB); - if (canSynthesize(V, *scop, LI, SE, Scope)) + auto *Scope = LI.getLoopFor(UserBB); + if (canSynthesize(V, *scop, &LI, &SE, Scope)) return; // Do not build scalar dependences for required invariant loads as we will @@ -4819,7 +4819,7 @@ } void ScopInfo::buildScop(Region &R, AssumptionCache &AC) { - scop.reset(new Scop(R, *SE, *LI, *SD->getDetectionContext(&R))); + scop.reset(new Scop(R, SE, LI, *SD.getDetectionContext(&R))); buildStmts(R); buildAccessFunctions(R); @@ -4836,55 +4836,21 @@ /* IsExitBlock */ true); // Create memory accesses for global reads since all arrays are now known. - auto *AF = SE->getConstant(IntegerType::getInt64Ty(SE->getContext()), 0); + auto *AF = SE.getConstant(IntegerType::getInt64Ty(SE.getContext()), 0); for (auto *GlobalRead : GlobalReads) for (auto *BP : ArrayBasePointers) addArrayAccess(MemAccInst(GlobalRead), MemoryAccess::READ, BP, BP->getType(), false, {AF}, {}, GlobalRead); - scop->init(*AA, AC, *DT, *LI); + scop->init(AA, AC, DT, LI); } -void ScopInfo::print(raw_ostream &OS, const Module *) const { - if (!scop) { - OS << "Invalid Scop!\n"; - return; - } - - scop->print(OS); -} - -void ScopInfo::clear() { scop.reset(); } - -//===----------------------------------------------------------------------===// -ScopInfo::ScopInfo() : RegionPass(ID) {} - -ScopInfo::~ScopInfo() { clear(); } - -void ScopInfo::getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(); - AU.addRequired(); - AU.addRequired(); - AU.addRequiredTransitive(); - AU.addRequiredTransitive(); - AU.addRequired(); - AU.addRequired(); - AU.setPreservesAll(); -} - -bool ScopInfo::runOnRegion(Region *R, RGPassManager &RGM) { - SD = &getAnalysis(); - - if (!SD->isMaxRegionInScop(*R)) - return false; +ScopInfo::ScopInfo(Region *R, AssumptionCache &AC, AliasAnalysis &AA, + const DataLayout &DL, DominatorTree &DT, LoopInfo &LI, + ScopDetection &SD, ScalarEvolution &SE) + : AA(AA), DL(DL), DT(DT), LI(LI), SD(SD), SE(SE) { Function *F = R->getEntry()->getParent(); - SE = &getAnalysis().getSE(); - LI = &getAnalysis().getLoopInfo(); - AA = &getAnalysis().getAAResults(); - DL = &F->getParent()->getDataLayout(); - DT = &getAnalysis().getDomTree(); - auto &AC = getAnalysis().getAssumptionCache(*F); DebugLoc Beg, End; getDebugLocations(getBBPairForRegion(R), Beg, End); @@ -4906,15 +4872,56 @@ } emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F, End, Msg); +} +void ScopInfo::clear() { scop.reset(); } + +//===----------------------------------------------------------------------===// +void ScopInfoRegionPass::getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired(); + AU.addRequired(); + AU.addRequired(); + AU.addRequiredTransitive(); + AU.addRequiredTransitive(); + AU.addRequired(); + AU.addRequired(); + AU.setPreservesAll(); +} + +bool ScopInfoRegionPass::runOnRegion(Region *R, RGPassManager &RGM) { + auto &SD = getAnalysis(); + + if (!SD.isMaxRegionInScop(*R)) + return false; + + Function *F = R->getEntry()->getParent(); + auto &SE = getAnalysis().getSE(); + auto &LI = getAnalysis().getLoopInfo(); + auto &AA = getAnalysis().getAAResults(); + auto const &DL = F->getParent()->getDataLayout(); + auto &DT = getAnalysis().getDomTree(); + auto &AC = getAnalysis().getAssumptionCache(*F); + + SI.reset(new ScopInfo(R, AC, AA, DL, DT, LI, SD, SE)); return false; } -char ScopInfo::ID = 0; +void ScopInfoRegionPass::print(raw_ostream &OS, const Module *) const { + Scop *scop; + if (SI) { + if ((scop = SI->getScop())) { + scop->print(OS); + return; + } + } + OS << "Invalid Scop!\n"; +} + +char ScopInfoRegionPass::ID = 0; -Pass *polly::createScopInfoPass() { return new ScopInfo(); } +Pass *polly::createScopInfoRegionPassPass() { return new ScopInfoRegionPass(); } -INITIALIZE_PASS_BEGIN(ScopInfo, "polly-scops", +INITIALIZE_PASS_BEGIN(ScopInfoRegionPass, "polly-scops", "Polly - Create polyhedral description of Scops", false, false); INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass); @@ -4924,6 +4931,6 @@ INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScopDetection); INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass); -INITIALIZE_PASS_END(ScopInfo, "polly-scops", +INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops", "Polly - Create polyhedral description of Scops", false, false) Index: polly/trunk/lib/Analysis/ScopPass.cpp =================================================================== --- polly/trunk/lib/Analysis/ScopPass.cpp +++ polly/trunk/lib/Analysis/ScopPass.cpp @@ -20,7 +20,7 @@ bool ScopPass::runOnRegion(Region *R, RGPassManager &RGM) { S = nullptr; - if ((S = getAnalysis().getScop())) + if ((S = getAnalysis().getScop())) return runOnScop(*S); return false; @@ -32,6 +32,6 @@ } void ScopPass::getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(); + AU.addRequired(); AU.setPreservesAll(); } Index: polly/trunk/lib/CodeGen/CodeGeneration.cpp =================================================================== --- polly/trunk/lib/CodeGen/CodeGeneration.cpp +++ polly/trunk/lib/CodeGen/CodeGeneration.cpp @@ -227,7 +227,7 @@ AU.addRequired(); AU.addRequired(); AU.addRequired(); - AU.addRequired(); + AU.addRequired(); AU.addRequired(); AU.addPreserved(); @@ -246,7 +246,7 @@ // FIXME: We do not yet add regions for the newly generated code to the // region tree. AU.addPreserved(); - AU.addPreserved(); + AU.addPreserved(); } }; } Index: polly/trunk/lib/CodeGen/IslAst.cpp =================================================================== --- polly/trunk/lib/CodeGen/IslAst.cpp +++ polly/trunk/lib/CodeGen/IslAst.cpp @@ -617,7 +617,7 @@ void IslAstInfo::getAnalysisUsage(AnalysisUsage &AU) const { // Get the Common analysis usage of ScopPasses. ScopPass::getAnalysisUsage(AU); - AU.addRequired(); + AU.addRequired(); AU.addRequired(); } @@ -628,7 +628,7 @@ INITIALIZE_PASS_BEGIN(IslAstInfo, "polly-ast", "Polly - Generate an AST of the SCoP (isl)", false, false); -INITIALIZE_PASS_DEPENDENCY(ScopInfo); +INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass); INITIALIZE_PASS_DEPENDENCY(DependenceInfo); INITIALIZE_PASS_END(IslAstInfo, "polly-ast", "Polly - Generate an AST from the SCoP (isl)", false, false) Index: polly/trunk/lib/Exchange/JSONExporter.cpp =================================================================== --- polly/trunk/lib/Exchange/JSONExporter.cpp +++ polly/trunk/lib/Exchange/JSONExporter.cpp @@ -171,7 +171,7 @@ void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); - AU.addRequired(); + AU.addRequired(); } Pass *polly::createJSONExporterPass() { return new JSONExporter(); } Index: polly/trunk/lib/Support/RegisterPasses.cpp =================================================================== --- polly/trunk/lib/Support/RegisterPasses.cpp +++ polly/trunk/lib/Support/RegisterPasses.cpp @@ -154,7 +154,7 @@ initializeIslScheduleOptimizerPass(Registry); initializePollyCanonicalizePass(Registry); initializeScopDetectionPass(Registry); - initializeScopInfoPass(Registry); + initializeScopInfoRegionPassPass(Registry); initializeCodegenCleanupPass(Registry); } @@ -199,7 +199,7 @@ if (PollyOnlyPrinter) PM.add(polly::createDOTOnlyPrinterPass()); - PM.add(polly::createScopInfoPass()); + PM.add(polly::createScopInfoRegionPassPass()); if (ImportJScop) PM.add(polly::createJSONImporterPass()); Index: polly/trunk/lib/Transform/DeadCodeElimination.cpp =================================================================== --- polly/trunk/lib/Transform/DeadCodeElimination.cpp +++ polly/trunk/lib/Transform/DeadCodeElimination.cpp @@ -177,6 +177,6 @@ INITIALIZE_PASS_BEGIN(DeadCodeElim, "polly-dce", "Polly - Remove dead iterations", false, false) INITIALIZE_PASS_DEPENDENCY(DependenceInfo) -INITIALIZE_PASS_DEPENDENCY(ScopInfo) +INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass) INITIALIZE_PASS_END(DeadCodeElim, "polly-dce", "Polly - Remove dead iterations", false, false) Index: polly/trunk/lib/Transform/ScheduleOptimizer.cpp =================================================================== --- polly/trunk/lib/Transform/ScheduleOptimizer.cpp +++ polly/trunk/lib/Transform/ScheduleOptimizer.cpp @@ -750,6 +750,6 @@ INITIALIZE_PASS_BEGIN(IslScheduleOptimizer, "polly-opt-isl", "Polly - Optimize schedule of SCoP", false, false); INITIALIZE_PASS_DEPENDENCY(DependenceInfo); -INITIALIZE_PASS_DEPENDENCY(ScopInfo); +INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass); INITIALIZE_PASS_END(IslScheduleOptimizer, "polly-opt-isl", "Polly - Optimize schedule of SCoP", false, false)