[PM] port Rewrite Statepoints For GC to the new pass manager.

[fedor.sergeev]

Summary

The port is nearly straightforward.
The only complication is related to the analyses handling,
since one of the analyses used in this module pass is domtree,
which is a function analysis. That requires asking for the results
of each function and disallows a single interface for run-on-module
pass action.

Decided to copy-paste the main body of this pass.
Most of its code is requesting analyses anyway, so not that much
of a copy-paste.

The rest of the code movement is to transform all the implementation
helper functions like stripNonValidData into non-member statics.

Extended all the related LLVM tests with new-pass-manager use.
No failures.

[anna]

comments inline. Changes look almost good to go.

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

2519 ↗

(On Diff #126700)

we should assert instead of checking these now. Both versions of runOnModule (old pass and new pass manager versions of RS4GC) check these before calling runOnFunction.

2524 ↗

(On Diff #126700)

Pls move these to the runOnModule versions and assert here. We don't want to unnecessarily get the analyses for functions that shouldn't rewrite statepoints.

This is the same behaviour we have before this change. We get the analyses (DT, TTI) after checking for the policy choice above.

[fedor.sergeev]

addressing @anna's comments

[fedor.sergeev]

now fully updated

[anna]

lgtm modulo nit

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

186 ↗

(On Diff #127042)

fix indentation?

llvm/trunk/include/llvm/InitializePasses.h

 void initializeRegionOnlyPrinterPass(PassRegistry&);
 void initializeRegionOnlyViewerPass(PassRegistry&);
 void initializeRegionPrinterPass(PassRegistry&);
 void initializeRegionViewerPass(PassRegistry&);
 void initializeRegisterCoalescerPass(PassRegistry&);
 void initializeRenameIndependentSubregsPass(PassRegistry&);
 void initializeResetMachineFunctionPass(PassRegistry&);
 void initializeReversePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
-void initializeRewriteStatepointsForGCPass(PassRegistry&);
+void initializeRewriteStatepointsForGCLegacyPassPass(PassRegistry &);
 void initializeRewriteSymbolsLegacyPassPass(PassRegistry&);
 void initializeSafepointIRVerifierPass(PassRegistry&);
 void initializeSCCPLegacyPassPass(PassRegistry&);
 void initializeSCEVAAWrapperPassPass(PassRegistry&);
 void initializeSLPVectorizerPass(PassRegistry&);
 void initializeSROALegacyPassPass(PassRegistry&);
 void initializeSafeStackLegacyPassPass(PassRegistry&);
 void initializeSampleProfileLoaderLegacyPassPass(PassRegistry&);

llvm/trunk/include/llvm/Transforms/Scalar.h

 //
 FunctionPass *createPlaceSafepointsPass();
 
 //===----------------------------------------------------------------------===//
 //
 // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have
 // explicit relocations to include explicit relocations.
 //
-ModulePass *createRewriteStatepointsForGCPass();
+ModulePass *createRewriteStatepointsForGCLegacyPass();
 
 //===----------------------------------------------------------------------===//
 //
 // StripGCRelocates - Remove GC relocates that have been inserted by
 // RewriteStatepointsForGC. The resulting IR is incorrect, but this is useful
 // for manual inspection.
 FunctionPass *createStripGCRelocatesPass();
 

llvm/trunk/include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h

+//===- RewriteStatepointsForGC.h - ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides interface to "Rewrite Statepoints for GC" pass.
+//
+// This passe rewrites call/invoke instructions so as to make potential
+// relocations performed by the garbage collector explicit in the IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_REWRITE_STATEPOINTS_FOR_GC_H
+#define LLVM_TRANSFORMS_SCALAR_REWRITE_STATEPOINTS_FOR_GC_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class DominatorTree;
+class Function;
+class Module;
+class TargetTransformInfo;
+class TargetLibraryInfo;
+
+struct RewriteStatepointsForGC : public PassInfoMixin<RewriteStatepointsForGC> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+  bool runOnFunction(Function &F, DominatorTree &, TargetTransformInfo &,
+                     const TargetLibraryInfo &);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_REWRITE_STATEPOINTS_FOR_GC_H

llvm/trunk/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
 #include "llvm/Transforms/Scalar/NaryReassociate.h"
 #include "llvm/Transforms/Scalar/NewGVN.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
 #include "llvm/Transforms/Scalar/Reassociate.h"
+#include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/Sink.h"
 #include "llvm/Transforms/Scalar/SpeculateAroundPHIs.h"
 #include "llvm/Transforms/Scalar/SpeculativeExecution.h"
 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"

llvm/trunk/lib/Passes/PassRegistry.def

 MODULE_PASS("pgo-instr-gen", PGOInstrumentationGen())
 MODULE_PASS("pgo-instr-use", PGOInstrumentationUse())
 MODULE_PASS("pre-isel-intrinsic-lowering", PreISelIntrinsicLoweringPass())
 MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs()))
 MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs()))
 MODULE_PASS("print", PrintModulePass(dbgs()))
 MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
 MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs()))
+MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC())
 MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
 MODULE_PASS("rpo-functionattrs", ReversePostOrderFunctionAttrsPass())
 MODULE_PASS("sample-profile", SampleProfileLoaderPass())
 MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
 MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass())
 MODULE_PASS("verify", VerifierPass())
 #undef MODULE_PASS
 

llvm/trunk/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 //===- RewriteStatepointsForGC.cpp - Make GC relocations explicit ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Rewrite call/invoke instructions so as to make potential relocations
 // performed by the garbage collector explicit in the IR.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
+
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"

 static cl::opt<bool, true> ClobberNonLiveOverride("rs4gc-clobber-non-live",
                                                   cl::location(ClobberNonLive),
                                                   cl::Hidden);
 
 static cl::opt<bool>
     AllowStatepointWithNoDeoptInfo("rs4gc-allow-statepoint-with-no-deopt-info",
                                    cl::Hidden, cl::init(true));
 
+/// The IR fed into RewriteStatepointsForGC may have had attributes and
+/// metadata implying dereferenceability that are no longer valid/correct after
+/// RewriteStatepointsForGC has run. This is because semantically, after
+/// RewriteStatepointsForGC runs, all calls to gc.statepoint "free" the entire
+/// heap. stripNonValidData (conservatively) restores
+/// correctness by erasing all attributes in the module that externally imply
+/// dereferenceability. Similar reasoning also applies to the noalias
+/// attributes and metadata. gc.statepoint can touch the entire heap including
+/// noalias objects.
+/// Apart from attributes and metadata, we also remove instructions that imply
+/// constant physical memory: llvm.invariant.start.
+static void stripNonValidData(Module &M);
+
+static bool shouldRewriteStatepointsIn(Function &F);
+
+PreservedAnalyses RewriteStatepointsForGC::run(Module &M,
+                                               ModuleAnalysisManager &AM) {
+  bool Changed = false;
+  auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
+  for (Function &F : M) {
+    // Nothing to do for declarations.
+    if (F.isDeclaration() || F.empty())
+      continue;
+
+    // Policy choice says not to rewrite - the most common reason is that we're
+    // compiling code without a GCStrategy.
+    if (!shouldRewriteStatepointsIn(F))
+      continue;
+
+    auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
+    auto &TTI = FAM.getResult<TargetIRAnalysis>(F);
+    auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);
+    Changed |= runOnFunction(F, DT, TTI, TLI);
+  }
+  if (!Changed)
+    return PreservedAnalyses::all();
+
+  // stripNonValidData asserts that shouldRewriteStatepointsIn
+  // returns true for at least one function in the module.  Since at least
+  // one function changed, we know that the precondition is satisfied.
+  stripNonValidData(M);
+
+  PreservedAnalyses PA;
+  PA.preserve<TargetIRAnalysis>();
+  PA.preserve<TargetLibraryAnalysis>();
+  return PA;
+}
+
 namespace {
 
-struct RewriteStatepointsForGC : public ModulePass {
+class RewriteStatepointsForGCLegacyPass : public ModulePass {
+  RewriteStatepointsForGC Impl;
+
+public:
   static char ID; // Pass identification, replacement for typeid
 
-  RewriteStatepointsForGC() : ModulePass(ID) {
-    initializeRewriteStatepointsForGCPass(*PassRegistry::getPassRegistry());
+  RewriteStatepointsForGCLegacyPass() : ModulePass(ID), Impl() {
+    initializeRewriteStatepointsForGCLegacyPassPass(
+        *PassRegistry::getPassRegistry());
   }
 
-  bool runOnFunction(Function &F);
-
   bool runOnModule(Module &M) override {
     bool Changed = false;
-    for (Function &F : M)
-      Changed |= runOnFunction(F);
+    const TargetLibraryInfo &TLI =
+        getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
+    for (Function &F : M) {
+      // Nothing to do for declarations.
+      if (F.isDeclaration() || F.empty())
+        continue;
+
+      // Policy choice says not to rewrite - the most common reason is that
+      // we're compiling code without a GCStrategy.
+      if (!shouldRewriteStatepointsIn(F))
+        continue;
+
+      TargetTransformInfo &TTI =
+          getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
+      auto &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
+
+      Changed |= Impl.runOnFunction(F, DT, TTI, TLI);
+    }
+
+    if (!Changed)
+      return false;
 
-    if (Changed) {
-      // stripNonValidData asserts that shouldRewriteStatepointsIn
-      // returns true for at least one function in the module.  Since at least
-      // one function changed, we know that the precondition is satisfied.
-      stripNonValidData(M);
-    }
-
-    return Changed;
+    return true;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     // We add and rewrite a bunch of instructions, but don't really do much
     // else.  We could in theory preserve a lot more analyses here.
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
-
-  /// The IR fed into RewriteStatepointsForGC may have had attributes and
-  /// metadata implying dereferenceability that are no longer valid/correct after
-  /// RewriteStatepointsForGC has run. This is because semantically, after
-  /// RewriteStatepointsForGC runs, all calls to gc.statepoint "free" the entire
-  /// heap. stripNonValidData (conservatively) restores
-  /// correctness by erasing all attributes in the module that externally imply
-  /// dereferenceability. Similar reasoning also applies to the noalias
-  /// attributes and metadata. gc.statepoint can touch the entire heap including
-  /// noalias objects.
-  /// Apart from attributes and metadata, we also remove instructions that imply
-  /// constant physical memory: llvm.invariant.start.
-  void stripNonValidData(Module &M);
-
-  // Helpers for stripNonValidData
-  void stripNonValidDataFromBody(Function &F);
-  void stripNonValidAttributesFromPrototype(Function &F);
-
-  // Certain metadata on instructions are invalid after running RS4GC.
-  // Optimizations that run after RS4GC can incorrectly use this metadata to
-  // optimize functions. We drop such metadata on the instruction.
-  void stripInvalidMetadataFromInstruction(Instruction &I);
 };
 
 } // end anonymous namespace
 
-char RewriteStatepointsForGC::ID = 0;
+char RewriteStatepointsForGCLegacyPass::ID = 0;
 
-ModulePass *llvm::createRewriteStatepointsForGCPass() {
-  return new RewriteStatepointsForGC();
+ModulePass *llvm::createRewriteStatepointsForGCLegacyPass() {
+  return new RewriteStatepointsForGCLegacyPass();
 }
 
-INITIALIZE_PASS_BEGIN(RewriteStatepointsForGC, "rewrite-statepoints-for-gc",
+INITIALIZE_PASS_BEGIN(RewriteStatepointsForGCLegacyPass,
+                      "rewrite-statepoints-for-gc",
                       "Make relocations explicit at statepoints", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
-INITIALIZE_PASS_END(RewriteStatepointsForGC, "rewrite-statepoints-for-gc",
+INITIALIZE_PASS_END(RewriteStatepointsForGCLegacyPass,
+                    "rewrite-statepoints-for-gc",
                     "Make relocations explicit at statepoints", false, false)
 
 namespace {
 
 struct GCPtrLivenessData {
   /// Values defined in this block.
   MapVector<BasicBlock *, SetVector<Value *>> KillSet;
 
R.addAttribute(Attribute::get(Ctx, Attribute::DereferenceableOrNull,
                                   AH.getDereferenceableOrNullBytes(Index)));
   if (AH.getAttributes().hasAttribute(Index, Attribute::NoAlias))
     R.addAttribute(Attribute::NoAlias);
 
   if (!R.empty())
     AH.setAttributes(AH.getAttributes().removeAttributes(Ctx, Index, R));
 }
 
-void
-RewriteStatepointsForGC::stripNonValidAttributesFromPrototype(Function &F) {
+static void stripNonValidAttributesFromPrototype(Function &F) {
   LLVMContext &Ctx = F.getContext();
 
   for (Argument &A : F.args())
     if (isa<PointerType>(A.getType()))
       RemoveNonValidAttrAtIndex(Ctx, F,
                                 A.getArgNo() + AttributeList::FirstArgIndex);
 
   if (isa<PointerType>(F.getReturnType()))
     RemoveNonValidAttrAtIndex(Ctx, F, AttributeList::ReturnIndex);
 }
 
-void RewriteStatepointsForGC::stripInvalidMetadataFromInstruction(Instruction &I) {
+/// Certain metadata on instructions are invalid after running RS4GC.
+/// Optimizations that run after RS4GC can incorrectly use this metadata to
+/// optimize functions. We drop such metadata on the instruction.
+static void stripInvalidMetadataFromInstruction(Instruction &I) {
   if (!isa<LoadInst>(I) && !isa<StoreInst>(I))
     return;
   // These are the attributes that are still valid on loads and stores after
   // RS4GC.
   // The metadata implying dereferenceability and noalias are (conservatively)
   // dropped.  This is because semantically, after RewriteStatepointsForGC runs,
   // all calls to gc.statepoint "free" the entire heap. Also, gc.statepoint can
   // touch the entire heap including noalias objects. Note: The reasoning is
unsigned ValidMetadataAfterRS4GC[] = {LLVMContext::MD_tbaa,
                          LLVMContext::MD_nonnull,
                          LLVMContext::MD_align,
                          LLVMContext::MD_type};
 
   // Drops all metadata on the instruction other than ValidMetadataAfterRS4GC.
   I.dropUnknownNonDebugMetadata(ValidMetadataAfterRS4GC);
 }
 
-void RewriteStatepointsForGC::stripNonValidDataFromBody(Function &F) {
+static void stripNonValidDataFromBody(Function &F) {
   if (F.empty())
     return;
 
   LLVMContext &Ctx = F.getContext();
   MDBuilder Builder(Ctx);
 
   // Set of invariantstart instructions that we need to remove.
   // Use this to avoid invalidating the instruction iterator.
if (F.hasGC()) {
     const StringRef StatepointExampleName("statepoint-example");
     const StringRef CoreCLRName("coreclr");
     return (StatepointExampleName == FunctionGCName) ||
            (CoreCLRName == FunctionGCName);
   } else
     return false;
 }
 
-void RewriteStatepointsForGC::stripNonValidData(Module &M) {
+static void stripNonValidData(Module &M) {
 #ifndef NDEBUG
   assert(llvm::any_of(M, shouldRewriteStatepointsIn) && "precondition!");
 #endif
 
   for (Function &F : M)
     stripNonValidAttributesFromPrototype(F);
 
   for (Function &F : M)
     stripNonValidDataFromBody(F);
 }
 
-bool RewriteStatepointsForGC::runOnFunction(Function &F) {
-  // Nothing to do for declarations.
-  if (F.isDeclaration() || F.empty())
-    return false;
-
-  // Policy choice says not to rewrite - the most common reason is that we're
-  // compiling code without a GCStrategy.
-  if (!shouldRewriteStatepointsIn(F))
-    return false;
-
-  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
-  TargetTransformInfo &TTI =
-      getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
-  const TargetLibraryInfo &TLI =
-      getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
+bool RewriteStatepointsForGC::runOnFunction(Function &F, DominatorTree &DT,
+                                            TargetTransformInfo &TTI,
+                                            const TargetLibraryInfo &TLI) {
+  assert(!F.isDeclaration() && !F.empty() &&
+         "need function body to rewrite statepoints in");
+  assert(shouldRewriteStatepointsIn(F) && "mismatch in rewrite decision");
 
   auto NeedsRewrite = [&TLI](Instruction &I) {
     if (ImmutableCallSite CS = ImmutableCallSite(&I))
       return !callsGCLeafFunction(CS, TLI) && !isStatepoint(CS);
     return false;
   };
 
   // Gather all the statepoints which need rewritten.  Be careful to only

llvm/trunk/lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeLowerGuardIntrinsicLegacyPassPass(Registry);
   initializeMemCpyOptLegacyPassPass(Registry);
   initializeMergeICmpsPass(Registry);
   initializeMergedLoadStoreMotionLegacyPassPass(Registry);
   initializeNaryReassociateLegacyPassPass(Registry);
   initializePartiallyInlineLibCallsLegacyPassPass(Registry);
   initializeReassociateLegacyPassPass(Registry);
   initializeRegToMemPass(Registry);
-  initializeRewriteStatepointsForGCPass(Registry);
+  initializeRewriteStatepointsForGCLegacyPassPass(Registry);
   initializeSCCPLegacyPassPass(Registry);
   initializeIPSCCPLegacyPassPass(Registry);
   initializeSROALegacyPassPass(Registry);
   initializeCFGSimplifyPassPass(Registry);
   initializeStructurizeCFGPass(Registry);
   initializeSimpleLoopUnswitchLegacyPassPass(Registry);
   initializeSinkingLegacyPassPass(Registry);
   initializeTailCallElimPass(Registry);

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
 declare void @site_for_call_safpeoint()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
 entry:
   br i1 %runtime_condition, label %here, label %there

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 
 declare i1 @runtime_value() "gc-leaf-function"
 
 declare void @do_safepoint()
 
 define void @select_of_phi(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y) gc "statepoint-example" {
 entry:

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers  -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers  -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next base %base_obj
 
 declare void @do_safepoint()
 
 define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 entry:
   %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %select base null
 
 @global = external addrspace(1) global i8
 
 define i8 @test(i1 %cond) gc "statepoint-example" {
   %derived1 = getelementptr i8, i8 addrspace(1)* @global, i64 1
   %derived2 = getelementptr i8, i8 addrspace(1)* @global, i64 2

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %derived base null
 
 @global = external addrspace(1) global i8
 
 define i8 @test(i64 %offset) gc "statepoint-example" {
   %derived = getelementptr i8, i8 addrspace(1)* @global, i64 %offset
   call void @extern()

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %base_obj
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" {
 entry:
   br i1 %runtime_condition, label %merge, label %there
 
 there:                                            ; preds = %entry

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next.i64 base %base_obj
 
 define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 entry:
   %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
   br label %loop
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %obj_to_consume base %obj_to_consume.base
 
 declare void @foo()
 
 declare i64 addrspace(1)* @generate_obj()
 
 declare void @consume_obj(i64 addrspace(1)*)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
 declare void @foo()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
 entry:
   br i1 %runtime_condition, label %here, label %there

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
 declare void @site_for_call_safpeoint()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
 entry:
   br i1 %runtime_condition_x, label %here, label %there

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %merged_value base %merged_value.base
 
 declare void @site_for_call_safpeoint()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
 entry:
   br i1 %runtime_condition_x, label %here, label %there

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 | FileCheck %s
 
 ; CHECK: derived %next_element_ptr base %array_obj
 
 define i32 @null_in_array(i64 addrspace(1)* %array_obj) gc "statepoint-example" {
 entry:
   %array_len_pointer.i64 = getelementptr i64, i64 addrspace(1)* %array_obj, i32 1
   %array_len_pointer.i32 = bitcast i64 addrspace(1)* %array_len_pointer.i64 to i32 addrspace(1)*
   %array_len = load i32, i32 addrspace(1)* %array_len_pointer.i32

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S  2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-print-base-pointers -S  2>&1 | FileCheck %s
 
 ; CHECK: derived %next base %base_obj
 
 declare i1 @runtime_value() "gc-leaf-function"
 
 define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 entry:
   br label %loop

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
 ; The rewriting needs to make %obj loop variant by inserting a phi 
 ; of the original value and it's relocation.
 
 declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
 
 declare void @use_obj(i64 addrspace(1)*) "gc-leaf-function"
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-vector.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
 
 define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
 ; CHECK-LABEL: @test
 ; CHECK: extractelement
 ; CHECK: extractelement
 ; CHECK: statepoint
 ; CHECK: gc.relocate

llvm/trunk/test/Transforms/RewriteStatepointsForGC/basic.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 declare void @g()
 declare i32 @h()
 
 define i32 addrspace(1)* @f0(i32 addrspace(1)* %arg) gc "statepoint-example" {
 ; CHECK-LABEL: @f0(
  entry:
 ; CHECK: [[TOKEN_0:%[^ ]+]] = call token {{[^@]*}} @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @g, i32 0, i32 0, i32 0, i32 1, i32 100, i32 addrspace(1)* %arg)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/basics.ll

 ; This is a collection of really basic tests for gc.statepoint rewriting.
 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 
 ; Trivial relocation over a single call
 
 declare void @foo()
 
 define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 entry:

llvm/trunk/test/Transforms/RewriteStatepointsForGC/call-gc-result.ll

 ;; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
+;; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 ;; This test is to verify that gc_result from a call statepoint
 ;; can have preceding phis in its parent basic block. Unlike
 ;; invoke statepoint, call statepoint does not terminate the
 ;; block, and thus its gc_result is in the same block with the
 ;; call statepoint.
 
 declare i32 @foo()

llvm/trunk/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; A null test of a single value
 
 define i1 @test(i8 addrspace(1)* %p, i1 %rare) gc "statepoint-example" {
 ; CHECK-LABEL: @test
 entry:
   %cond = icmp eq i8 addrspace(1)* %p, null
   br i1 %rare, label %safepoint, label %continue, !prof !0

llvm/trunk/test/Transforms/RewriteStatepointsForGC/constants.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; constants don't get relocated.
 @G = addrspace(1) global i8 5
 
 declare void @foo()
 
 define i8 @test() gc "statepoint-example" {
 ; CHECK-LABEL: @test

llvm/trunk/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic-cconv.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare cc42 double @llvm.experimental.deoptimize.f64(...)
 
 define double @caller_3() gc "statepoint-example" {
 ; CHECK-LABELL @caller_3(
 ; CHECK: call cc42 token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint
 ; CHECK:  unreachable
 
 entry:
   %val = call cc42 double(...) @llvm.experimental.deoptimize.f64() [ "deopt"() ]
   ret double %val
 }

llvm/trunk/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare i32 @llvm.experimental.deoptimize.i32(...)
 declare void @llvm.experimental.deoptimize.isVoid(...)
 
 define i32 @caller_0(i32 addrspace(1)* %ptr) gc "statepoint-example" {

llvm/trunk/test/Transforms/RewriteStatepointsForGC/deopt-lowering-attrs.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; Check that the "deopt-lowering" function attribute gets transcoded into
 ; flags on the resulting statepoint
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @foo()
 declare void @bar() "deopt-lowering"="live-in"

llvm/trunk/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; CHECK: declare i8 addrspace(1)* @some_function_ret_deref()
 ; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
 ; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
 ; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
 
 declare void @foo()
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; This test checks that metadata that's invalid after RS4GC is dropped. 
 ; We can miscompile if optimizations scheduled after RS4GC uses the
 ; metadata that's infact invalid.
 
 declare void @bar()
 
 declare void @baz(i32)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 ; This test is to verify gc.relocate can handle pointer to vector of
 ; pointers (<2 x i32 addrspace(1)*> addrspace(1)* in this case).
 ; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)*> addrspace(1)*
 ; type will fail because llvm does not support mangling vector of pointers.
 ; The new scheme will create all gc.relocate to i8 addrspace(1)* type and
 ; then bitcast to the correct type.
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/invokes.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
+; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
 declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
 declare i32 @personality_function()
 
 define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke

llvm/trunk/test/Transforms/RewriteStatepointsForGC/leaf-function.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
+; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
 declare void @foo() "gc-leaf-function"
 declare void @bar()
 
 ; Calls of functions with the "gc-leaf-function" attribute shouldn't be turned
 ; into a safepoint.  An entry safepoint should get inserted, though.
 define void @test_leaf_function() gc "statepoint-example" {
 ; CHECK-LABEL: test_leaf_function

llvm/trunk/test/Transforms/RewriteStatepointsForGC/libcall.ll

 ; A call to a libcall function is not a statepoint.
 ; This test verifies that calls to libcalls functions do not get converted to
 ; statepoint calls.
 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 declare double @ldexp(double %x, i32 %n) nounwind readnone
 
 define double @test_libcall(double %x) gc "statepoint-example" {
 ; CHECK-LABEL: test_libcall
 ; CHECK-NEXT: %res = call double @ldexp(double %x, i32 5)
 ; CHECK-NEXT: ret double %res
   %res = call double @ldexp(double %x, i32 5) nounwind readnone
   ret double %res
 }

llvm/trunk/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll

 ; Test that we can correctly handle vectors of pointers in statepoint 
 ; rewriting.  
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
 ; A non-vector relocation for comparison
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: test
 ; CHECK: gc.statepoint
 ; CHECK-NEXT: gc.relocate
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: ret i64 addrspace(1)*

llvm/trunk/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll

 ; A collection of liveness test cases to ensure we're reporting the
 ; correct live values at statepoints
 ; RUN: opt -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
 
 ; Tests to make sure we consider %obj live in both the taken and untaken 
 ; predeccessor of merge.
 
 define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 entry:
   br i1 %cmp, label %taken, label %untaken

llvm/trunk/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 declare void @f()
 declare i32 @personality_function()
 
 define void @test_id() gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: @test_id(
 entry:
 ; CHECK-LABEL: entry:

llvm/trunk/test/Transforms/RewriteStatepointsForGC/preprocess.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Test to make sure we destroy LCSSA's single entry phi nodes before
 ; running liveness
 
 declare void @consume(...) "gc-leaf-function"
 
 define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test6

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll

 
 ;; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
+;; RUN: opt -passes=rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 ;; This test is to verify that RewriteStatepointsForGC correctly relocates values
 ;; defined by invoke instruction results. 
 
 declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function"
 
 declare void @gc_call()
 
 declare i32* @fake_personality_function()

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocation.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 
 
 declare void @foo()
 
 declare void @use(...) "gc-leaf-function"
 
 define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test1

llvm/trunk/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 
 declare void @use_obj16(i16 addrspace(1)*) "gc-leaf-function"
 declare void @use_obj32(i32 addrspace(1)*) "gc-leaf-function"
 declare void @use_obj64(i64 addrspace(1)*) "gc-leaf-function"
 
 declare void @do_safepoint()
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll

 ; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 
 declare i8 addrspace(1)* @gc_call()
 
 declare i32* @fake_personality_function()
 
 define i8 addrspace(1)* @test(i1 %c) gc "statepoint-example" personality i32* ()* @fake_personality_function {
 ; CHECK-LABEL: @test(
 entry:

llvm/trunk/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 ; Ensure statepoints copy (valid) attributes from callsites.
 
 declare void @f(i8 addrspace(1)* %obj)
 
 ; copy over norecurse noimplicitfloat to statepoint call
 define void @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
 ; CHECK-LABEL: test1(
 ; CHECK: call token (i64, i32, void (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8f(i64 2882400000, i32 0, void (i8 addrspace(1)*)* @f, i32 1, i32 0, i8 addrspace(1)* %arg, i32 0, i32 0, i8 addrspace(1)* %arg) #1
 
  call void @f(i8 addrspace(1)* %arg) #1
  ret void
 }
 
 
 attributes #1 = { norecurse noimplicitfloat }

llvm/trunk/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate carry over
 ; the right calling conventions.
 
 define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke coldcc token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0

llvm/trunk/test/Transforms/RewriteStatepointsForGC/statepoint-coreclr.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
+; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
 ; Basic test to make sure that safepoints are placed
 ; for CoreCLR GC
 
 declare void @foo()
 
 define void @test_simple_call() gc "coreclr" {
 ; CHECK-LABEL: test_simple_call

llvm/trunk/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
+; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate have the
 ; set of arguments we expect it to have.
 
 define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0, i64 addrspace(1)* %obj1, i64 addrspace(1)* %obj)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 declare void @some_call(i64 addrspace(1)*)
 
 declare i32 @dummy_personality_function()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
   gc "statepoint-example"
   personality i32 ()* @dummy_personality_function {

llvm/trunk/test/Transforms/RewriteStatepointsForGC/vector-bitcast.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 ;
 ; A test to make sure that we can look through bitcasts of
 ; vector types when a base pointer is contained in a vector.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: uwtable