Index: llvm/trunk/include/llvm/InitializePasses.h =================================================================== --- llvm/trunk/include/llvm/InitializePasses.h +++ llvm/trunk/include/llvm/InitializePasses.h @@ -177,7 +177,7 @@ void initializeInlineCostAnalysisPass(PassRegistry&); void initializeInstCountPass(PassRegistry&); void initializeInstNamerPass(PassRegistry&); -void initializeInstSimplifierPass(PassRegistry&); +void initializeInstSimplifyLegacyPassPass(PassRegistry &); void initializeInstrProfilingLegacyPassPass(PassRegistry&); void initializeInstructionCombiningPassPass(PassRegistry&); void initializeInstructionSelectPass(PassRegistry&); Index: llvm/trunk/include/llvm/LinkAllPasses.h =================================================================== --- llvm/trunk/include/llvm/LinkAllPasses.h +++ llvm/trunk/include/llvm/LinkAllPasses.h @@ -49,6 +49,7 @@ #include "llvm/Transforms/ObjCARC.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar/GVN.h" +#include "llvm/Transforms/Scalar/InstSimplifyPass.h" #include "llvm/Transforms/Utils.h" #include "llvm/Transforms/Utils/SymbolRewriter.h" #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h" @@ -116,6 +117,7 @@ (void) llvm::createIPSCCPPass(); (void) llvm::createInductiveRangeCheckEliminationPass(); (void) llvm::createIndVarSimplifyPass(); + (void) llvm::createInstSimplifyLegacyPass(); (void) llvm::createInstructionCombiningPass(); (void) llvm::createInternalizePass(); (void) llvm::createLCSSAPass(); @@ -200,7 +202,6 @@ (void) llvm::createLowerAtomicPass(); (void) llvm::createCorrelatedValuePropagationPass(); (void) llvm::createMemDepPrinter(); - (void) llvm::createInstructionSimplifierPass(); (void) llvm::createLoopVectorizePass(); (void) llvm::createSLPVectorizerPass(); (void) llvm::createLoadStoreVectorizerPass(); Index: llvm/trunk/include/llvm/Transforms/Scalar/InstSimplifyPass.h =================================================================== --- llvm/trunk/include/llvm/Transforms/Scalar/InstSimplifyPass.h +++ llvm/trunk/include/llvm/Transforms/Scalar/InstSimplifyPass.h @@ -0,0 +1,46 @@ +//===- InstSimplifyPass.h ---------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// Defines passes for running instruction simplification across chunks of IR. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H +#define LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H + +#include "llvm/IR/PassManager.h" + +namespace llvm { + +class FunctionPass; + +/// Run instruction simplification across each instruction in the function. +/// +/// Instruction simplification has useful constraints in some contexts: +/// - It will never introduce *new* instructions. +/// - There is no need to iterate to a fixed point. +/// +/// Many passes use instruction simplification as a library facility, but it may +/// also be useful (in tests and other contexts) to have access to this very +/// restricted transform at a pass granularity. However, for a much more +/// powerful and comprehensive peephole optimization engine, see the +/// `instcombine` pass instead. +class InstSimplifyPass : public PassInfoMixin { +public: + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); +}; + +/// Create a legacy pass that does instruction simplification on each +/// instruction in a function. +FunctionPass *createInstSimplifyLegacyPass(); + +} // end namespace llvm + +#endif // LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H Index: llvm/trunk/include/llvm/Transforms/Utils.h =================================================================== --- llvm/trunk/include/llvm/Transforms/Utils.h +++ llvm/trunk/include/llvm/Transforms/Utils.h @@ -110,13 +110,6 @@ Pass *createLoopSimplifyPass(); extern char &LoopSimplifyID; -//===----------------------------------------------------------------------===// -// -// InstructionSimplifier - Remove redundant instructions. -// -FunctionPass *createInstructionSimplifierPass(); -extern char &InstructionSimplifierID; - /// This function returns a new pass that downgrades the debug info in the /// module to line tables only. ModulePass *createStripNonLineTableDebugInfoPass(); Index: llvm/trunk/include/llvm/Transforms/Utils/SimplifyInstructions.h =================================================================== --- llvm/trunk/include/llvm/Transforms/Utils/SimplifyInstructions.h +++ llvm/trunk/include/llvm/Transforms/Utils/SimplifyInstructions.h @@ -1,31 +0,0 @@ -//===- SimplifyInstructions.h - Remove redundant instructions ---*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This is a utility pass used for testing the InstructionSimplify analysis. -// The analysis is applied to every instruction, and if it simplifies then the -// instruction is replaced by the simplification. If you are looking for a pass -// that performs serious instruction folding, use the instcombine pass instead. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H -#define LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H - -#include "llvm/IR/PassManager.h" - -namespace llvm { - -/// This pass removes redundant instructions. -class InstSimplifierPass : public PassInfoMixin { -public: - PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); -}; -} // end namespace llvm - -#endif // LLVM_TRANSFORMS_UTILS_SIMPLIFYINSTRUCTIONS_H Index: llvm/trunk/lib/Passes/PassBuilder.cpp =================================================================== --- llvm/trunk/lib/Passes/PassBuilder.cpp +++ llvm/trunk/lib/Passes/PassBuilder.cpp @@ -61,7 +61,6 @@ #include "llvm/Support/Regex.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h" -#include "llvm/Transforms/Instrumentation/GCOVProfiler.h" #include "llvm/Transforms/IPO/AlwaysInliner.h" #include "llvm/Transforms/IPO/ArgumentPromotion.h" #include "llvm/Transforms/IPO/CalledValuePropagation.h" @@ -86,8 +85,9 @@ #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h" #include "llvm/Transforms/IPO/WholeProgramDevirt.h" #include "llvm/Transforms/InstCombine/InstCombine.h" -#include "llvm/Transforms/Instrumentation/InstrProfiling.h" #include "llvm/Transforms/Instrumentation/BoundsChecking.h" +#include "llvm/Transforms/Instrumentation/GCOVProfiler.h" +#include "llvm/Transforms/Instrumentation/InstrProfiling.h" #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h" #include "llvm/Transforms/Scalar/ADCE.h" #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h" @@ -105,6 +105,7 @@ #include "llvm/Transforms/Scalar/IVUsersPrinter.h" #include "llvm/Transforms/Scalar/IndVarSimplify.h" #include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h" +#include "llvm/Transforms/Scalar/InstSimplifyPass.h" #include "llvm/Transforms/Scalar/JumpThreading.h" #include "llvm/Transforms/Scalar/LICM.h" #include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h" @@ -148,7 +149,6 @@ #include "llvm/Transforms/Utils/LowerInvoke.h" #include "llvm/Transforms/Utils/Mem2Reg.h" #include "llvm/Transforms/Utils/NameAnonGlobals.h" -#include "llvm/Transforms/Utils/SimplifyInstructions.h" #include "llvm/Transforms/Utils/SymbolRewriter.h" #include "llvm/Transforms/Vectorize/LoopVectorize.h" #include "llvm/Transforms/Vectorize/SLPVectorizer.h" @@ -814,7 +814,7 @@ OptimizePM.addPass(LoopSinkPass()); // And finally clean up LCSSA form before generating code. - OptimizePM.addPass(InstSimplifierPass()); + OptimizePM.addPass(InstSimplifyPass()); // This hoists/decomposes div/rem ops. It should run after other sink/hoist // passes to avoid re-sinking, but before SimplifyCFG because it can allow Index: llvm/trunk/lib/Passes/PassRegistry.def =================================================================== --- llvm/trunk/lib/Passes/PassRegistry.def +++ llvm/trunk/lib/Passes/PassRegistry.def @@ -159,7 +159,7 @@ FUNCTION_PASS("post-inline-ee-instrument", EntryExitInstrumenterPass(/*PostInlining=*/true)) FUNCTION_PASS("gvn-hoist", GVNHoistPass()) FUNCTION_PASS("instcombine", InstCombinePass()) -FUNCTION_PASS("instsimplify", InstSimplifierPass()) +FUNCTION_PASS("instsimplify", InstSimplifyPass()) FUNCTION_PASS("invalidate", InvalidateAllAnalysesPass()) FUNCTION_PASS("float2int", Float2IntPass()) FUNCTION_PASS("no-op-function", NoOpFunctionPass()) Index: llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp =================================================================== --- llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp +++ llvm/trunk/lib/Transforms/IPO/PassManagerBuilder.cpp @@ -38,6 +38,7 @@ #include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar/GVN.h" +#include "llvm/Transforms/Scalar/InstSimplifyPass.h" #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h" #include "llvm/Transforms/Utils.h" #include "llvm/Transforms/Vectorize.h" @@ -703,7 +704,7 @@ // result too early. MPM.add(createLoopSinkPass()); // Get rid of LCSSA nodes. - MPM.add(createInstructionSimplifierPass()); + MPM.add(createInstSimplifyLegacyPass()); // This hoists/decomposes div/rem ops. It should run after other sink/hoist // passes to avoid re-sinking, but before SimplifyCFG because it can allow Index: llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt =================================================================== --- llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt +++ llvm/trunk/lib/Transforms/Scalar/CMakeLists.txt @@ -20,6 +20,7 @@ InductiveRangeCheckElimination.cpp IndVarSimplify.cpp InferAddressSpaces.cpp + InstSimplifyPass.cpp JumpThreading.cpp LICM.cpp LoopAccessAnalysisPrinter.cpp Index: llvm/trunk/lib/Transforms/Scalar/InstSimplifyPass.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/InstSimplifyPass.cpp +++ llvm/trunk/lib/Transforms/Scalar/InstSimplifyPass.cpp @@ -0,0 +1,144 @@ +//===- InstSimplifyPass.cpp -----------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/Scalar/InstSimplifyPass.h" +#include "llvm/ADT/DepthFirstIterator.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Analysis/AssumptionCache.h" +#include "llvm/Analysis/InstructionSimplify.h" +#include "llvm/Analysis/OptimizationRemarkEmitter.h" +#include "llvm/Analysis/TargetLibraryInfo.h" +#include "llvm/IR/DataLayout.h" +#include "llvm/IR/Dominators.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Type.h" +#include "llvm/Pass.h" +#include "llvm/Transforms/Utils.h" +#include "llvm/Transforms/Utils/Local.h" +using namespace llvm; + +#define DEBUG_TYPE "instsimplify" + +STATISTIC(NumSimplified, "Number of redundant instructions removed"); + +static bool runImpl(Function &F, const SimplifyQuery &SQ, + OptimizationRemarkEmitter *ORE) { + SmallPtrSet S1, S2, *ToSimplify = &S1, *Next = &S2; + bool Changed = false; + + do { + for (BasicBlock *BB : depth_first(&F.getEntryBlock())) { + // Here be subtlety: the iterator must be incremented before the loop + // body (not sure why), so a range-for loop won't work here. + for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) { + Instruction *I = &*BI++; + // The first time through the loop ToSimplify is empty and we try to + // simplify all instructions. On later iterations ToSimplify is not + // empty and we only bother simplifying instructions that are in it. + if (!ToSimplify->empty() && !ToSimplify->count(I)) + continue; + + // Don't waste time simplifying unused instructions. + if (!I->use_empty()) { + if (Value *V = SimplifyInstruction(I, SQ, ORE)) { + // Mark all uses for resimplification next time round the loop. + for (User *U : I->users()) + Next->insert(cast(U)); + I->replaceAllUsesWith(V); + ++NumSimplified; + Changed = true; + } + } + if (RecursivelyDeleteTriviallyDeadInstructions(I, SQ.TLI)) { + // RecursivelyDeleteTriviallyDeadInstruction can remove more than one + // instruction, so simply incrementing the iterator does not work. + // When instructions get deleted re-iterate instead. + BI = BB->begin(); + BE = BB->end(); + Changed = true; + } + } + } + + // Place the list of instructions to simplify on the next loop iteration + // into ToSimplify. + std::swap(ToSimplify, Next); + Next->clear(); + } while (!ToSimplify->empty()); + + return Changed; +} + +namespace { +struct InstSimplifyLegacyPass : public FunctionPass { + static char ID; // Pass identification, replacement for typeid + InstSimplifyLegacyPass() : FunctionPass(ID) { + initializeInstSimplifyLegacyPassPass(*PassRegistry::getPassRegistry()); + } + + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesCFG(); + AU.addRequired(); + AU.addRequired(); + AU.addRequired(); + AU.addRequired(); + } + + /// runOnFunction - Remove instructions that simplify. + bool runOnFunction(Function &F) override { + if (skipFunction(F)) + return false; + + const DominatorTree *DT = + &getAnalysis().getDomTree(); + const TargetLibraryInfo *TLI = + &getAnalysis().getTLI(); + AssumptionCache *AC = + &getAnalysis().getAssumptionCache(F); + OptimizationRemarkEmitter *ORE = + &getAnalysis().getORE(); + const DataLayout &DL = F.getParent()->getDataLayout(); + const SimplifyQuery SQ(DL, TLI, DT, AC); + return runImpl(F, SQ, ORE); + } +}; +} // namespace + +char InstSimplifyLegacyPass::ID = 0; +INITIALIZE_PASS_BEGIN(InstSimplifyLegacyPass, "instsimplify", + "Remove redundant instructions", false, false) +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) +INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) +INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) +INITIALIZE_PASS_END(InstSimplifyLegacyPass, "instsimplify", + "Remove redundant instructions", false, false) + +// Public interface to the simplify instructions pass. +FunctionPass *llvm::createInstSimplifyLegacyPass() { + return new InstSimplifyLegacyPass(); +} + +PreservedAnalyses InstSimplifyPass::run(Function &F, + FunctionAnalysisManager &AM) { + auto &DT = AM.getResult(F); + auto &TLI = AM.getResult(F); + auto &AC = AM.getResult(F); + auto &ORE = AM.getResult(F); + const DataLayout &DL = F.getParent()->getDataLayout(); + const SimplifyQuery SQ(DL, &TLI, &DT, &AC); + bool Changed = runImpl(F, SQ, &ORE); + if (!Changed) + return PreservedAnalyses::all(); + + PreservedAnalyses PA; + PA.preserveSet(); + return PA; +} Index: llvm/trunk/lib/Transforms/Scalar/Scalar.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/Scalar.cpp +++ llvm/trunk/lib/Transforms/Scalar/Scalar.cpp @@ -56,6 +56,7 @@ initializeIRCELegacyPassPass(Registry); initializeIndVarSimplifyLegacyPassPass(Registry); initializeInferAddressSpacesPass(Registry); + initializeInstSimplifyLegacyPassPass(Registry); initializeJumpThreadingPass(Registry); initializeLegacyLICMPassPass(Registry); initializeLegacyLoopSinkPassPass(Registry); Index: llvm/trunk/lib/Transforms/Utils/CMakeLists.txt =================================================================== --- llvm/trunk/lib/Transforms/Utils/CMakeLists.txt +++ llvm/trunk/lib/Transforms/Utils/CMakeLists.txt @@ -48,7 +48,6 @@ SanitizerStats.cpp SimplifyCFG.cpp SimplifyIndVar.cpp - SimplifyInstructions.cpp SimplifyLibCalls.cpp SplitModule.cpp StripNonLineTableDebugInfo.cpp Index: llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp +++ llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp @@ -1,152 +0,0 @@ -//===------ SimplifyInstructions.cpp - Remove redundant instructions ------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This is a utility pass used for testing the InstructionSimplify analysis. -// The analysis is applied to every instruction, and if it simplifies then the -// instruction is replaced by the simplification. If you are looking for a pass -// that performs serious instruction folding, use the instcombine pass instead. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Transforms/Utils/SimplifyInstructions.h" -#include "llvm/ADT/DepthFirstIterator.h" -#include "llvm/ADT/SmallPtrSet.h" -#include "llvm/ADT/Statistic.h" -#include "llvm/Analysis/AssumptionCache.h" -#include "llvm/Analysis/InstructionSimplify.h" -#include "llvm/Analysis/OptimizationRemarkEmitter.h" -#include "llvm/Analysis/TargetLibraryInfo.h" -#include "llvm/Transforms/Utils/Local.h" -#include "llvm/IR/DataLayout.h" -#include "llvm/IR/Dominators.h" -#include "llvm/IR/Function.h" -#include "llvm/IR/Type.h" -#include "llvm/Pass.h" -#include "llvm/Transforms/Utils.h" -using namespace llvm; - -#define DEBUG_TYPE "instsimplify" - -STATISTIC(NumSimplified, "Number of redundant instructions removed"); - -static bool runImpl(Function &F, const SimplifyQuery &SQ, - OptimizationRemarkEmitter *ORE) { - SmallPtrSet S1, S2, *ToSimplify = &S1, *Next = &S2; - bool Changed = false; - - do { - for (BasicBlock *BB : depth_first(&F.getEntryBlock())) { - // Here be subtlety: the iterator must be incremented before the loop - // body (not sure why), so a range-for loop won't work here. - for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) { - Instruction *I = &*BI++; - // The first time through the loop ToSimplify is empty and we try to - // simplify all instructions. On later iterations ToSimplify is not - // empty and we only bother simplifying instructions that are in it. - if (!ToSimplify->empty() && !ToSimplify->count(I)) - continue; - - // Don't waste time simplifying unused instructions. - if (!I->use_empty()) { - if (Value *V = SimplifyInstruction(I, SQ, ORE)) { - // Mark all uses for resimplification next time round the loop. - for (User *U : I->users()) - Next->insert(cast(U)); - I->replaceAllUsesWith(V); - ++NumSimplified; - Changed = true; - } - } - if (RecursivelyDeleteTriviallyDeadInstructions(I, SQ.TLI)) { - // RecursivelyDeleteTriviallyDeadInstruction can remove more than one - // instruction, so simply incrementing the iterator does not work. - // When instructions get deleted re-iterate instead. - BI = BB->begin(); - BE = BB->end(); - Changed = true; - } - } - } - - // Place the list of instructions to simplify on the next loop iteration - // into ToSimplify. - std::swap(ToSimplify, Next); - Next->clear(); - } while (!ToSimplify->empty()); - - return Changed; -} - -namespace { - struct InstSimplifier : public FunctionPass { - static char ID; // Pass identification, replacement for typeid - InstSimplifier() : FunctionPass(ID) { - initializeInstSimplifierPass(*PassRegistry::getPassRegistry()); - } - - void getAnalysisUsage(AnalysisUsage &AU) const override { - AU.setPreservesCFG(); - AU.addRequired(); - AU.addRequired(); - AU.addRequired(); - AU.addRequired(); - } - - /// runOnFunction - Remove instructions that simplify. - bool runOnFunction(Function &F) override { - if (skipFunction(F)) - return false; - - const DominatorTree *DT = - &getAnalysis().getDomTree(); - const TargetLibraryInfo *TLI = - &getAnalysis().getTLI(); - AssumptionCache *AC = - &getAnalysis().getAssumptionCache(F); - OptimizationRemarkEmitter *ORE = - &getAnalysis().getORE(); - const DataLayout &DL = F.getParent()->getDataLayout(); - const SimplifyQuery SQ(DL, TLI, DT, AC); - return runImpl(F, SQ, ORE); - } - }; -} - -char InstSimplifier::ID = 0; -INITIALIZE_PASS_BEGIN(InstSimplifier, "instsimplify", - "Remove redundant instructions", false, false) -INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) -INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) -INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass) -INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) -INITIALIZE_PASS_END(InstSimplifier, "instsimplify", - "Remove redundant instructions", false, false) -char &llvm::InstructionSimplifierID = InstSimplifier::ID; - -// Public interface to the simplify instructions pass. -FunctionPass *llvm::createInstructionSimplifierPass() { - return new InstSimplifier(); -} - -PreservedAnalyses InstSimplifierPass::run(Function &F, - FunctionAnalysisManager &AM) { - auto &DT = AM.getResult(F); - auto &TLI = AM.getResult(F); - auto &AC = AM.getResult(F); - auto &ORE = AM.getResult(F); - const DataLayout &DL = F.getParent()->getDataLayout(); - const SimplifyQuery SQ(DL, &TLI, &DT, &AC); - bool Changed = runImpl(F, SQ, &ORE); - if (!Changed) - return PreservedAnalyses::all(); - - PreservedAnalyses PA; - PA.preserveSet(); - return PA; -} Index: llvm/trunk/lib/Transforms/Utils/Utils.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/Utils.cpp +++ llvm/trunk/lib/Transforms/Utils/Utils.cpp @@ -36,7 +36,6 @@ initializePromoteLegacyPassPass(Registry); initializeStripNonLineTableDebugInfoPass(Registry); initializeUnifyFunctionExitNodesPass(Registry); - initializeInstSimplifierPass(Registry); initializeMetaRenamerPass(Registry); initializeStripGCRelocatesPass(Registry); initializePredicateInfoPrinterLegacyPassPass(Registry); Index: llvm/trunk/test/Other/new-pm-defaults.ll =================================================================== --- llvm/trunk/test/Other/new-pm-defaults.ll +++ llvm/trunk/test/Other/new-pm-defaults.ll @@ -241,7 +241,7 @@ ; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Running pass: AlignmentFromAssumptionsPass ; CHECK-O-NEXT: Running pass: LoopSinkPass -; CHECK-O-NEXT: Running pass: InstSimplifierPass +; CHECK-O-NEXT: Running pass: InstSimplifyPass ; CHECK-O-NEXT: Running pass: DivRemPairsPass ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: SpeculateAroundPHIsPass Index: llvm/trunk/test/Other/new-pm-thinlto-defaults.ll =================================================================== --- llvm/trunk/test/Other/new-pm-thinlto-defaults.ll +++ llvm/trunk/test/Other/new-pm-thinlto-defaults.ll @@ -219,7 +219,7 @@ ; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-POSTLINK-O-NEXT: Running pass: AlignmentFromAssumptionsPass ; CHECK-POSTLINK-O-NEXT: Running pass: LoopSinkPass -; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifierPass +; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifyPass ; CHECK-POSTLINK-O-NEXT: Running pass: DivRemPairsPass ; CHECK-POSTLINK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-POSTLINK-O-NEXT: Running pass: SpeculateAroundPHIsPass