[PM] Port LCSSA to the new PM

[eraman]

Summary

The new pass does not preserve the same set as the legacy pass and I've added FIXMEs to indicate what is missing.

[davide]

lib/Transforms/Utils/LCSSA.cpp

30

mhm,did you forget LCSSA.h maybe? This doesn't build.

[eraman]

Update the patch to include missing header file

[davide]

Some comments (waiting for the header).

lib/Transforms/Utils/LCSSA.cpp

342

else after return

348

I'd put the comment just before the declaration of PA

test/Transforms/LCSSA/2006-06-12-MultipleExitsSameBlock.ll

5–9

This should really use FileCheck and not grep. Feel free to commit the change to the existing code separately.

test/Transforms/LCSSA/basictest.ll

3

Ditto.

[eraman]

Address Davide's comments and rebase.

[davide]

lib/Transforms/Utils/LCSSA.cpp

345

This is a sore point. I think mustPreserveAnalysisID(LCSSAID) should become an assert in the new PM which verifies that the IR mutation didn't destroy LCSSA.
In other words, mustPreserveAnalysisID(LCSSAID) might need to go away.

[eraman]

lib/Transforms/Utils/LCSSA.cpp

345

Could you elaborate on this a bit more? The current state is that loop transformation passes call mustPreserveAnalysisID(LCSSAID) to determine if LCSSA is available and ensures that the transformation preserves LCSSA by calling addPreserved. How will this look in the new PM?

Incidentally, LoopSimplify (and a few others) do not actually call addPreservedID(LCSSAID). Isn't this a bug?

test/Transforms/LCSSA/2006-06-12-MultipleExitsSameBlock.ll

5–9

I committed r272065 that made the original tests use FileCheck

[mzolotukhin]

lib/Transforms/Utils/LCSSA.cpp

345

The fact that LoopSimplify doesn't do addPreservedID(LCSSAID) looks like a bug to me (which I'm trying to address in D21112 btw). What are the other passes that do the same?

[davide]

lib/Transforms/Utils/LCSSA.cpp

345

Sure.

1. My understanding is that LCSSA isn't really referential transparent/pure (in an haskell'y meaning of the word), and it's fairly easy to forge cases where it mutates the IR. Therefore, in the new (caching-based) PM, it's very hard to model the caching of LCSSA.

What I think (and what I gathered from Chandler) is that in this case instead of caching we should just add a verifier pass which asserts LCSSA is maintained.

2. I think LoopSimplify should maintain LCSSA, and probably other passes in the LoopPM (which maybe don't today)

[davide]

lib/Transforms/Utils/LCSSA.cpp

345

To be clear: when I say LCSSA is not pure I mean the LCSSA pass in LLVM, not the canonical form per-se.

Thanks!

[chandlerc]

I'm good with the patch with the FIXME below removed, but you should circle back with Davide before landing.

lib/Transforms/Utils/LCSSA.cpp

345

Sorry for not chiming in earlier, just now catching up on email.

I feel like some of this discussion would be helped by re-reading the design discussion around the new pass manager. There is a fundamental difference regarding the new pass manager and the old pass manager when it comes to LCSSA and LoopSimplify. I'll try to summarize that here:

The old pass manager uses the analysis preserved / requires machinery to *automatically* schedule the *transformation* passes LCSSA and LoopSimplify. This is incredibly magical and brittle. It breaks constantly and has proven nearly impossible to support.

The new pass manager consequentially has *zero support for this*. The intent is that LCSSA and LoopSimplify will be canonicalizing transformation passes for loops. They'll be scheduled explicitly, and loop passes should detect and gracefully degrade behavior when loops are not simplified or not in LCSSA form. Transformations should still work to not *break* LCSSA because that is the desired form for loops.

I understand that this result will be painful, but I think it is by far the less painful alternative to the current design. We spend much too much time fixing crashers that are hard to even test for because of the requires / preserves nonsense.

I think the only realistic way to make LCSSA *required* (which seems desirable considering the cost of checking for it) is to make it *verifier required* which requires making Loops part of the IR the way Dominators are, etc, etc, etc. That's a huge project, and I don't think we want to try to do that right now.

So ultimately, I don't think there is any FIXME needed here.

[davide]

LGTM if Chandler is happy with it.

[eraman]

lib/Transforms/Utils/LCSSA.cpp

345

LoopInterchange and PPCLoopPreIncPrep.cpp call mustPreserveAnalysisID(LCSSAID) but do not preserve LCSSA.

345

Thanks for the summary. I have a better understanding now. Will submit with the FIXMEs removed.

include/llvm/InitializePasses.h

 void initializeInstructionCombiningPassPass(PassRegistry&);
 void initializeInstCountPass(PassRegistry&);
 void initializeInstNamerPass(PassRegistry&);
 void initializeInterleavedAccessPass(PassRegistry &);
 void initializeInternalizeLegacyPassPass(PassRegistry&);
 void initializeIntervalPartitionPass(PassRegistry&);
 void initializeIRTranslatorPass(PassRegistry &);
 void initializeJumpThreadingPass(PassRegistry&);
-void initializeLCSSAPass(PassRegistry&);
+void initializeLCSSAWrapperPassPass(PassRegistry &);
 void initializeLICMPass(PassRegistry&);
 void initializeLazyValueInfoPass(PassRegistry&);
 void initializeLintPass(PassRegistry&);
 void initializeLiveDebugVariablesPass(PassRegistry&);
 void initializeLiveIntervalsPass(PassRegistry&);
 void initializeLiveRegMatrixPass(PassRegistry&);
 void initializeLiveStacksPass(PassRegistry&);
 void initializeLiveVariablesPass(PassRegistry&);

include/llvm/Transforms/Utils/LCSSA.h

+//===- LCSSA.h - Loop-closed SSA transform Pass -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass transforms loops by placing phi nodes at the end of the loops for
+// all values that are live across the loop boundary.  For example, it turns
+// the left into the right code:
+//
+// for (...)                for (...)
+//   if (c)                   if (c)
+//     X1 = ...                 X1 = ...
+//   else                     else
+//     X2 = ...                 X2 = ...
+//   X3 = phi(X1, X2)         X3 = phi(X1, X2)
+// ... = X3 + 4             X4 = phi(X3)
+//                          ... = X4 + 4
+//
+// This is still valid LLVM; the extra phi nodes are purely redundant, and will
+// be trivially eliminated by InstCombine.  The major benefit of this
+// transformation is that it makes many other loop optimizations, such as
+// LoopUnswitching, simpler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_LCSSA_H
+#define LLVM_TRANSFORMS_UTILS_LCSSA_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// Converts loops into loop-closed SSA form.
+class LCSSAPass: public PassInfoMixin<LCSSAPass> {
+public:
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_LCSSA_H

lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/LowerAtomic.h"
 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
 #include "llvm/Transforms/Scalar/Reassociate.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/Sink.h"
+#include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/MemorySSA.h"
 #include <type_traits>
 
 using namespace llvm;
 
 static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");
 
 namespace {

lib/Passes/PassRegistry.def

 FUNCTION_PASS("instcombine", InstCombinePass())
 FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 FUNCTION_PASS("no-op-function", NoOpFunctionPass())
 FUNCTION_PASS("loweratomic", LowerAtomicPass())
 FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
 FUNCTION_PASS("guard-widening", GuardWideningPass())
 FUNCTION_PASS("gvn", GVN())
 FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass())
+FUNCTION_PASS("lcssa", LCSSAPass())
 FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<block-freq>", BlockFrequencyPrinterPass(dbgs()))
 FUNCTION_PASS("print<branch-prob>", BranchProbabilityPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<demanded-bits>", DemandedBitsPrinterPass(dbgs()))
 FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))

lib/Transforms/Scalar/LoopInterchange.cpp

 char LoopInterchange::ID = 0;
 INITIALIZE_PASS_BEGIN(LoopInterchange, "loop-interchange",
                       "Interchanges loops for cache reuse", false, false)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
-INITIALIZE_PASS_DEPENDENCY(LCSSA)
+INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 
 INITIALIZE_PASS_END(LoopInterchange, "loop-interchange",
                     "Interchanges loops for cache reuse", false, false)
 
 Pass *llvm::createLoopInterchangePass() { return new LoopInterchange(); }

lib/Transforms/Scalar/LoopVersioningLICM.cpp

 }
 
 char LoopVersioningLICM::ID = 0;
 INITIALIZE_PASS_BEGIN(LoopVersioningLICM, "loop-versioning-licm",
                       "Loop Versioning For LICM", false, false)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(LCSSA)
+INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopAccessAnalysis)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(LoopVersioningLICM, "loop-versioning-licm",
                     "Loop Versioning For LICM", false, false)
 
 Pass *llvm::createLoopVersioningLICMPass() { return new LoopVersioningLICM(); }

lib/Transforms/Utils/LCSSA.cpp

 //
 // This is still valid LLVM; the extra phi nodes are purely redundant, and will
 // be trivially eliminated by InstCombine.  The major benefit of this 
 // transformation is that it makes many other loop optimizations, such as 
 // LoopUnswitching, simpler.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/PredIteratorCache.h"
 #include "llvm/Pass.h"
+#include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/SSAUpdater.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "lcssa"
 
 STATISTIC(NumLCSSA, "Number of live out of a loop variables");
 
bool llvm::formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
   // Recurse depth-first through inner loops.
   for (Loop *SubLoop : L.getSubLoops())
     Changed |= formLCSSARecursively(*SubLoop, DT, LI, SE);
 
   Changed |= formLCSSA(L, DT, LI, SE);
   return Changed;
 }
 
+/// Process all loops in the function, inner-most out.
+static bool formLCSSAOnAllLoops(LoopInfo *LI, DominatorTree &DT,
+                                ScalarEvolution *SE) {
+  bool Changed = false;
+  for (auto &L : *LI)
+    Changed |= formLCSSARecursively(*L, DT, LI, SE);
+  return Changed;
+}
+
 namespace {
-struct LCSSA : public FunctionPass {
+struct LCSSAWrapperPass : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
-  LCSSA() : FunctionPass(ID) {
-    initializeLCSSAPass(*PassRegistry::getPassRegistry());
+  LCSSAWrapperPass() : FunctionPass(ID) {
+    initializeLCSSAWrapperPassPass(*PassRegistry::getPassRegistry());
   }
 
   // Cached analysis information for the current function.
   DominatorTree *DT;
   LoopInfo *LI;
   ScalarEvolution *SE;
 
   bool runOnFunction(Function &F) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addPreserved<BasicAAWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
     AU.addPreserved<ScalarEvolutionWrapperPass>();
     AU.addPreserved<SCEVAAWrapperPass>();
   }
 };
 }
 
-char LCSSA::ID = 0;
-INITIALIZE_PASS_BEGIN(LCSSA, "lcssa", "Loop-Closed SSA Form Pass", false, false)
+char LCSSAWrapperPass::ID = 0;
+INITIALIZE_PASS_BEGIN(LCSSAWrapperPass, "lcssa", "Loop-Closed SSA Form Pass",
+                      false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
-INITIALIZE_PASS_END(LCSSA, "lcssa", "Loop-Closed SSA Form Pass", false, false)
+INITIALIZE_PASS_END(LCSSAWrapperPass, "lcssa", "Loop-Closed SSA Form Pass",
+                    false, false)
 
-Pass *llvm::createLCSSAPass() { return new LCSSA(); }
-char &llvm::LCSSAID = LCSSA::ID;
+Pass *llvm::createLCSSAPass() { return new LCSSAWrapperPass(); }
+char &llvm::LCSSAID = LCSSAWrapperPass::ID;
 
-
-/// Process all loops in the function, inner-most out.
-bool LCSSA::runOnFunction(Function &F) {
-  bool Changed = false;
+/// Transform \p F into loop-closed SSA form.
+bool LCSSAWrapperPass::runOnFunction(Function &F) {
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto *SEWP = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>();
   SE = SEWP ? &SEWP->getSE() : nullptr;
 
-  // Simplify each loop nest in the function.
-  for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
-    Changed |= formLCSSARecursively(**I, *DT, LI, SE);
-
-  return Changed;
+  return formLCSSAOnAllLoops(LI, *DT, SE);
 }
 
+PreservedAnalyses LCSSAPass::run(Function &F, AnalysisManager<Function> &AM) {
+  auto &LI = AM.getResult<LoopAnalysis>(F);
+  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
+  auto *SE = AM.getCachedResult<ScalarEvolutionAnalysis>(F);
+  if (!formLCSSAOnAllLoops(&LI, DT, SE))
+    return PreservedAnalyses::all();
+  else {
+    PreservedAnalyses PA;
+    PA.preserve<BasicAA>();
+    PA.preserve<GlobalsAA>();
+    PA.preserve<SCEVAA>();
+    PA.preserve<ScalarEvolutionAnalysis>();
+    // FIXME: The legacy pass preserves LoopSimplify pass. That pass is not yet
+    // ported to the new PM and the legacy LoopSimplify pass has a call to
+    // mustPreserveAnalysisID(LCSSAID) in its runOnFunction method. So, for now,
+    // we are not preserving LoopSimplify.
+    // FIXME: There is no setPreservesCFG in the new PM. When that becomes
+    // available, it should be used here.
+    return PA;
+  }
+}

lib/Transforms/Utils/LoopUtils.cpp

 ///
 ///   INITIALIZE_PASS_DEPENDENCY(LoopPass)
 ///
 /// As-if "LoopPass" were a pass.
 void llvm::initializeLoopPassPass(PassRegistry &Registry) {
   INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
-  INITIALIZE_PASS_DEPENDENCY(LCSSA)
+  INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(SCEVAAWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
 }
 
 /// \brief Find string metadata for loop

lib/Transforms/Utils/Utils.cpp

 using namespace llvm;
 
 /// initializeTransformUtils - Initialize all passes in the TransformUtils
 /// library.
 void llvm::initializeTransformUtils(PassRegistry &Registry) {
   initializeAddDiscriminatorsPass(Registry);
   initializeBreakCriticalEdgesPass(Registry);
   initializeInstNamerPass(Registry);
-  initializeLCSSAPass(Registry);
+  initializeLCSSAWrapperPassPass(Registry);
   initializeLoopSimplifyPass(Registry);
   initializeLowerInvokePass(Registry);
   initializeLowerSwitchPass(Registry);
   initializeNameAnonFunctionPass(Registry);
   initializePromotePassPass(Registry);
   initializeUnifyFunctionExitNodesPass(Registry);
   initializeInstSimplifierPass(Registry);
   initializeMetaRenamerPass(Registry);
   initializeMemorySSAWrapperPassPass(Registry);
 }
 
 /// LLVMInitializeTransformUtils - C binding for initializeTransformUtilsPasses.
 void LLVMInitializeTransformUtils(LLVMPassRegistryRef R) {
   initializeTransformUtils(*unwrap(R));
 }

lib/Transforms/Vectorize/LoopVectorize.cpp

 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(LCSSA)
+INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
 INITIALIZE_PASS_DEPENDENCY(LoopAccessAnalysis)
 INITIALIZE_PASS_DEPENDENCY(DemandedBitsWrapperPass)
 INITIALIZE_PASS_END(LoopVectorize, LV_NAME, lv_name, false, false)
 
 namespace llvm {
 Pass *createLoopVectorizePass(bool NoUnrolling, bool AlwaysVectorize) {

test/Transforms/LCSSA/2006-06-12-MultipleExitsSameBlock.ll

 ; RUN: opt < %s -lcssa -S | \
 ; RUN:    grep "%X.1.lcssa"
 ; RUN: opt < %s -lcssa -S | \
 ; RUN:    not grep "%X.1.lcssa1"
-
+; Using the new PM version of the pass
+; RUN: opt < %s -passes=lcssa -S | \
+; RUN:    grep "%X.1.lcssa"
+; RUN: opt < %s -passes=lcssa -S | \
+; RUN:    not grep "%X.1.lcssa1"
 declare i1 @c1()
 
 declare i1 @c2()
 
 define i32 @foo() {
 entry:
   br label %loop_begin
 loop_begin:   ; preds = %loop_body.2, %entry

test/Transforms/LCSSA/2006-07-09-NoDominator.ll

 ; RUN: opt < %s -lcssa
+; RUN: opt < %s -passes=lcssa
 
   %struct.SetJmpMapEntry = type { i8*, i32, %struct.SetJmpMapEntry* }
 
 define void @__llvm_sjljeh_try_catching_longjmp_exception() {
 entry:
   br label %loopentry
 loopentry:    ; preds = %endif, %entry
   %SJE.0 = phi %struct.SetJmpMapEntry* [ null, %entry ], [ %tmp.25, %endif ]  ; <%struct.SetJmpMapEntry*> [#uses=1]

test/Transforms/LCSSA/2006-10-31-UnreachableBlock.ll

 ; RUN: opt < %s -lcssa -disable-output
+; RUN: opt < %s -passes=lcssa -disable-output
 ; PR977
 ; END.
 
 define void @process_backlog() {
 entry:
   br label %loopentry.preheader
 loopentry.preheader:    ; preds = %dead_block_after_break, %entry
   %work.0.ph = phi i32 [ %inc, %dead_block_after_break ], [ 0, %entry ]    ; <i32> [#uses=0]

test/Transforms/LCSSA/basictest.ll

 ; RUN: opt < %s -lcssa -S | \
 ; RUN:   grep "X3.lcssa = phi i32"
+; RUN: opt < %s -passes=lcssa -S | \
+; RUN:   grep "X3.lcssa = phi i32"
 ; RUN: opt < %s -lcssa -S | \
 ; RUN:   grep "X4 = add i32 3, %X3.lcssa"
+; RUN: opt < %s -passes=lcssa -S | \
+; RUN:   grep "X4 = add i32 3, %X3.lcssa"
 
 define void @lcssa(i1 %S2) {
 entry:
   br label %loop.interior
 loop.interior:    ; preds = %post.if, %entry
   br i1 %S2, label %if.true, label %if.false
 if.true:    ; preds = %loop.interior
   %X1 = add i32 0, 0    ; <i32> [#uses=1]

test/Transforms/LCSSA/invoke-dest.ll

 ; RUN: opt < %s -lcssa
+; RUN: opt < %s -passes=lcssa
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
 
 @.str12 = external constant [3 x i8], align 1    ; <[3 x i8]*> [#uses=1]
 @.str17175 = external constant [4 x i8], align 1    ; <[4 x i8]*> [#uses=1]
 @.str21179 = external constant [12 x i8], align 1    ; <[12 x i8]*> [#uses=1]
 @.str25183 = external constant [10 x i8], align 1    ; <[10 x i8]*> [#uses=1]
 @.str32190 = external constant [92 x i8], align 1    ; <[92 x i8]*> [#uses=1]

test/Transforms/LCSSA/mixed-catch.ll

 ; RUN: opt -lcssa -S < %s | FileCheck %s
+; RUN: opt -passes=lcssa -S < %s | FileCheck %s
 
 ; This test is based on the following C++ code:
 ;
 ; void f()
 ; {
 ;   for (int i=0; i<12; i++) {
 ;     try {
 ;       if (i==3)

test/Transforms/LCSSA/unused-phis.ll

 ; RUN: opt < %s -lcssa -S | FileCheck %s
+; RUN: opt < %s -passes=lcssa -S | FileCheck %s
 ; CHECK: exit1:
 ; CHECK: .lcssa =
 ; CHECK: exit2:
 ; CHECK: .lcssa1 =
 ; CHECK: exit3:
 ; CHECK-NOT: .lcssa
 
 ; Test to ensure that when there are multiple exit blocks, PHI nodes are