[Coroutines] Remove all legacy test command

[lxfind]

Summary

With new pm becomes the default, the old-style test command becomes exactly the same as the new test command, i.e. the two commands are now redundant.
We should just delete the old command. (unless someone wants to add enable-new-pm=0 to all old commands.

[ChuanqiXu]

Thanks for working on this!
If the two commands behaves the same, I prefer the old styles since it looks simpler.

[lxfind]

In D104895#2840172, @ChuanqiXu wrote:

Thanks for working on this!
If the two commands behaves the same, I prefer the old styles since it looks simpler.

I believe the plan is to have all tests to be in -passes style with new pm (I.e -passes is the preferred style)

[aeubanks]

yes, at some point when we've deprecated the legacy PM for the optimziation pipeline I will switch all tests to use -passes=

[lxfind]

rebase

llvm/test/Transforms/Coroutines/ArgAddr.ll

 ; Need to move users of allocas that were moved into the coroutine frame after
 ; coro.begin.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define nonnull i8* @f(i32 %n) "coroutine.presplit"="1" {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*))
 ; CHECK-NEXT:    [[N_ADDR:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 [[N:%.*]], i32* [[N_ADDR]], align 4

llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll

 ; Check that we can handle the case when both alloc function and
 ; the user body consume the same argument.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 ; using copy of this (as it would happen under -O0)
 define i8* @f_copy(i64 %this_arg) "coroutine.presplit"="1" {
 entry:
   %this.addr = alloca i64
   store i64 %this_arg, i64* %this.addr
   %this = load i64, i64* %this.addr

llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll

 ; Check that we can handle the case when both alloc function and
 ; the user body consume the same argument.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 ; using this directly (as it would happen under -O2)
 define i8* @f_direct(i64 %this) "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @myAlloc(i64 %this, i32 %size)

llvm/test/Transforms/Coroutines/coro-alloca-01.ll

 ; Tests that CoroSplit can succesfully determine allocas should live on the frame
 ; if their aliases are used across suspension points through PHINode.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %n) "coroutine.presplit"="1" {
 entry:
   %x = alloca i64
   %y = alloca i64
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()

llvm/test/Transforms/Coroutines/coro-alloca-02.ll

 ; Tests that if an alloca is escaped through storing the address,
 ; the alloac will be put on the frame.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %x = alloca i64
   %y = alloca i32*
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()

llvm/test/Transforms/Coroutines/coro-alloca-03.ll

 ; Tests that allocas escaped through function calls will live on the frame.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %x = alloca i64
   %y = alloca i64
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()

llvm/test/Transforms/Coroutines/coro-alloca-04.ll

 ; Tests that CoroSplit can succesfully determine allocas should live on the frame
 ; if their aliases are used across suspension points through PHINode.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %n) "coroutine.presplit"="1" {
 entry:
   %x = alloca i64
   br i1 %n, label %flag_true, label %flag_false
 
 flag_true:

llvm/test/Transforms/Coroutines/coro-alloca-05.ll

 ; Tests that allocas after coro.begin are properly that do not need to
 ; live on the frame are properly moved to the .resume function.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/coro-alloca-06.ll

 ; Test that in some simple cases allocas will not live on the frame even
 ; though their pointers are stored.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %handle = type { i8* }
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %0 = alloca %"handle", align 8
   %1 = alloca %"handle"*, align 8

llvm/test/Transforms/Coroutines/coro-alloca-07.ll

 ; Tests that CoroSplit can succesfully determine allocas should live on the frame
 ; if their aliases are used across suspension points through PHINode.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %n) "coroutine.presplit"="1" {
 entry:
   %x = alloca i64
   %y = alloca i64
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()

llvm/test/Transforms/Coroutines/coro-alloca-08.ll

-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i8* @malloc(i64)
 

llvm/test/Transforms/Coroutines/coro-async-unreachable.ll

-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck --check-prefixes=CHECK %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck --check-prefixes=CHECK %s
 
 target datalayout = "p:64:64:64"
 
 %async.task = type { i64 }
 %async.actor = type { i64 }
 %async.fp = type <{ i32, i32 }>
 

llvm/test/Transforms/Coroutines/coro-async.ll

-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck --check-prefixes=CHECK %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck --check-prefixes=CHECK %s
 
 target datalayout = "p:64:64:64"
 
 %async.task = type { i64 }
 %async.actor = type { i64 }
 %async.fp = type <{ i32, i32 }>
 

llvm/test/Transforms/Coroutines/coro-catchswitch-cleanuppad.ll

 ; Tests the PHI nodes in cleanuppads for catchswitch instructions are correctly
 ; split up.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 declare i32 @__CxxFrameHandler3(...)
 define i8* @f2(i1 %val) "coroutine.presplit"="1" personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %valueA = call i32 @f();
   %valueB = call i32 @f();

llvm/test/Transforms/Coroutines/coro-catchswitch.ll

 ; Verifies that we can insert the spill for a PHI preceding the catchswitch
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc"
 
 ; CHECK-LABEL: define void @f(
 define void @f(i1 %cond) "coroutine.presplit"="1" personality i32 0 {
 entry:

llvm/test/Transforms/Coroutines/coro-cleanup.ll

 ; Make sure that all library helper coro intrinsics are lowered.
-; RUN: opt < %s -O0 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -passes='default<O0>' -enable-coroutines -S | FileCheck %s
 
 ; CHECK-LABEL: @uses_library_support_coro_intrinsics(
 ; CHECK-NOT:     @llvm.coro
 ; CHECK:         ret void
 define void @uses_library_support_coro_intrinsics(i8* %hdl) {
 entry:
   call void @llvm.coro.resume(i8* %hdl)

llvm/test/Transforms/Coroutines/coro-debug-O2.ll

-; RUN: opt < %s -coro-early -coro-split -reuse-storage-in-coroutine-frame -coro-split -sroa -S | FileCheck %s
+; RUN: opt < %s -passes='function(coro-early),cgscc(coro-split,coro-split),function(sroa)' --reuse-storage-in-coroutine-frame -S | FileCheck %s
 
 ; Checks whether the dbg.declare for `__promise` remains valid under O2.
 
 ; CHECK-LABEL: define internal fastcc void @f.resume({{.*}})
 ; CHECK:       entry.resume:
 ; CHECK:        call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ;
 ; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise"

llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll

-; RUN: opt < %s -coro-early -coro-split -coro-split -S | FileCheck %s
+; RUN: opt < %s -passes='function(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 
 ; Checks whether the dbg.declare for `__coro_frame` are created.
 
 ; CHECK-LABEL: define void @f(
 ; CHECK:       coro.init:
 ; CHECK:        %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin(
 ; CHECK:        %[[FramePtr:.*]] = bitcast i8* %[[begin]] to
 ; CHECK:        call void @llvm.dbg.declare(metadata %f.Frame* %[[FramePtr]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression())

llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll

 ; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame.
-; RUN: opt < %s -coro-early -coro-split -coro-split -S | FileCheck %s
+; RUN: opt < %s -passes='function(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 ;
 ; This file is based on coro-debug-frame-variable.ll.
 ; CHECK:  define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
 ; CHECK:       await.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata i32 undef, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ; CHECK:         call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ;
 ; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"

llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll

 ; Tests whether resume function would remain dbg.value infomation.
-; RUN: opt < %s -coro-early -coro-split -coro-split -S | FileCheck %s
+; RUN: opt < %s -passes='function(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 ;
 ; This file is based on coro-debug-frame-variable.ll.
 ; CHECK:  define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
 ; CHECK:       init.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
 ; CHECK:       await.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[SPILL_RESUME:[0-9]+]]
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(

llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll

-; RUN: opt < %s -O0 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -passes='default<O0>' -enable-coroutines -S | FileCheck %s
 
 ; Define a function 'f' that resembles the Clang frontend's output for the
 ; following C++ coroutine:
 ;
 ;   void foo() {
 ;     int i = 0;
 ;     ++i;

llvm/test/Transforms/Coroutines/coro-debug.ll

 ; Tests that debug information is sane after coro-split
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 source_filename = "simple-repro.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: noinline nounwind
 define i8* @f(i32 %x) #0 !dbg !6 {

llvm/test/Transforms/Coroutines/coro-early.ll

 ; Tests that CoroEarly pass correctly lowers coro.resume, coro.destroy
 ; and other intrinsics managed by this pass.
-; RUN: opt < %s -S -coro-early | FileCheck %s
 ; RUN: opt < %s -S -passes=coro-early | FileCheck %s
 
 ; CHECK: %NoopCoro.Frame = type { void (%NoopCoro.Frame*)*, void (%NoopCoro.Frame*)* }
 ; CHECK: @NoopCoro.Frame.Const = private constant %NoopCoro.Frame { void (%NoopCoro.Frame*)* @NoopCoro.ResumeDestroy, void (%NoopCoro.Frame*)* @NoopCoro.ResumeDestroy }
 
 ; CHECK-LABEL: @callResume(
 define void @callResume(i8* %hdl) {
 ; CHECK-NEXT: entry

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll

 ; Check that we can handle edge splits leading into a landingpad
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: define internal fastcc void @f.resume(
 define void @f(i1 %cond) "coroutine.presplit"="1" personality i32 0 {
 entry:

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll

 ; Check that we can handle edge splits leading into a landingpad
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: define internal fastcc void @g.resume(
 define void @g(i1 %cond, i32 %x, i32 %y) "coroutine.presplit"="1" personality i32 0 {
 entry:

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll

 ; Check that we can handle edge splits leading into a landingpad
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: define internal fastcc void @h.resume(
 define void @h(i1 %cond, i32 %x, i32 %y) "coroutine.presplit"="1" personality i32 0 {
 entry:

llvm/test/Transforms/Coroutines/coro-elide-musttail.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Only run with new pass manager since old pass manager's alias analysis isn't
 ; powerful enough to tell that the tailcall's arguments don't alias the frame.
 ;
-; RUN: opt < %s -coro-elide -S | FileCheck %s
-; RUN: opt < %s -disable-basic-aa -coro-elide -S | FileCheck %s -check-prefix=NOAA
 ; RUN: opt < %s -passes='coro-elide' -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline= -passes='coro-elide' -S | FileCheck %s -check-prefix=NOAA
 
 %"bar.Frame" = type { void (%"bar.Frame"*)*, void (%"bar.Frame"*)*, %"struct.coroutine<false, int>::promise_type", i1 }
 %"struct.coroutine<false, int>::promise_type" = type { i32 }
 %"foo.Frame" = type { void (%"foo.Frame"*)*, void (%"foo.Frame"*)*, %"struct.coroutine<true, int>::promise_type", i1, %"struct.coroutine<true, int>::promise_type::final_awaitable" }
 %"struct.coroutine<true, int>::promise_type" = type { i32 }
 %"struct.coroutine<true, int>::promise_type::final_awaitable" = type { i8 }

llvm/test/Transforms/Coroutines/coro-elide.ll

 ; Tests that the coro.destroy and coro.resume are devirtualized where possible,
 ; SCC pipeline restarts and inlines the direct calls.
-; RUN: opt < %s -S -inline -coro-elide -dce -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -S \
 ; RUN:   -passes='cgscc(repeat<2>(inline,function(coro-elide,dce)))' \
 ; RUN:   | FileCheck %s
 
 declare void @print(i32) nounwind
 
 ; resume part of the coroutine
 define fastcc void @f.resume(i8*) {

llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll

 ; Check that we can handle spills of array allocas
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 declare void @consume.double.ptr(double*)
 declare void @consume.i32.ptr(i32*)
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %prefix = alloca double

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-00.ll

 ; Check that we can handle spills of array allocas
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 
 %struct.big_structure = type { [500 x i8] }
 declare void @consume(%struct.big_structure*)
 
 ; Function Attrs: noinline optnone uwtable
 define i8* @f(i1 %cond) "coroutine.presplit"="1" {
 entry:

 declare i8* @llvm.coro.begin(token, i8*)
 declare i1 @llvm.coro.end(i8*, i1)
 
 declare noalias i8* @malloc(i32)
 declare double @print(double)
 declare void @free(i8*)
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-01.ll

 ; Tests that variables in a Corotuine whose lifetime range is not overlapping each other
 ; re-use the same slot in Coroutine frame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 define void @a(i1 zeroext %cond) "coroutine.presplit"="1" {
 entry:

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll

 ; Tests that variables of different type in a Corotuine whose lifetime range is not overlapping each other
 ; re-use the same slot in Coroutine frame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [300 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-03.ll

 ; Check that we should not reuse alloca sotrage in O0.
-; RUN: opt < %s -coro-split  -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %struct.big_structure = type { [500 x i8] }
 declare void @consume(%struct.big_structure*)
 
 ; Function Attrs: noinline optnone uwtable
 define i8* @f(i1 %cond) "coroutine.presplit"="1" {
 entry:

 declare i8* @llvm.coro.begin(token, i8*)
 declare i1 @llvm.coro.end(i8*, i1)
 
 declare noalias i8* @malloc(i32)
 declare double @print(double)
 declare void @free(i8*)
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll

 ; Tests that variables of different type with incompatible alignment in a Corotuine whose lifetime 
 ; range is not overlapping each other should not re-use the same slot in Coroutine frame. 
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [300 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll

 ; Tests that variables of different type with incompatible alignment in a Corotuine whose 
 ; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [400 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)

llvm/test/Transforms/Coroutines/coro-frame-unreachable.ll

 ; Check that coro-split doesn't choke on intrinsics in unreachable blocks
-; RUN: opt < %s -coro-split -S
 ; RUN: opt < %s -passes=coro-split -S
 
 define i8* @f(i1 %arg) "coroutine.presplit"="1" personality i32 0 {
 entry:
   %arg.addr = alloca i1
   store i1 %arg, i1* %arg.addr
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()

llvm/test/Transforms/Coroutines/coro-frame.ll

 ; Check that we can handle spills of the result of the invoke instruction
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i64 %this) "coroutine.presplit"="1" personality i32 0 {
 entry:
   %this.addr = alloca i64
   store i64 %this, i64* %this.addr
   %this1 = load i64, i64* %this.addr
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)

llvm/test/Transforms/Coroutines/coro-heap-elide.ll

 ; Tests that the dynamic allocation and deallocation of the coroutine frame is
 ; elided and any tail calls referencing the coroutine frame has the tail 
 ; call attribute removed.
-; RUN: opt < %s -S -inline -coro-elide -instsimplify -simplifycfg -simplifycfg-require-and-preserve-domtree=1 | FileCheck %s
 ; RUN: opt < %s -S \
 ; RUN:   -passes='cgscc(inline,function(coro-elide,instsimplify,simplify-cfg))' \
 ; RUN:   -aa-pipeline='basic-aa' | FileCheck %s
 
 declare void @print(i32) nounwind
 
 %f.frame = type {i32}
 

llvm/test/Transforms/Coroutines/coro-inline.ll

-; RUN: opt < %s -always-inline -barrier -coro-split -S -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='always-inline,cgscc(coro-split)' -S | FileCheck %s
-; RUN: opt < %s -sample-profile-file=%S/Inputs/sample.text.prof -pgo-kind=pgo-sample-use-pipeline -sample-profile -coro-split -disable-inlining=true -S | FileCheck %s
 ; RUN: opt < %s -sample-profile-file=%S/Inputs/sample.text.prof -pgo-kind=pgo-sample-use-pipeline -passes='sample-profile,cgscc(coro-split)' -disable-inlining=true -S | FileCheck %s
 
 ; Function Attrs: alwaysinline ssp uwtable
 define void @ff() #0 {
 entry:
   %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
   %begin = call i8* @llvm.coro.begin(token %id, i8* null)
   ret void

 attributes #0 = { alwaysinline ssp uwtable "coroutine.presplit"="1" "use-sample-profile" }
 
 !llvm.dbg.cu = !{}
 !llvm.module.flags = !{!1, !2, !3, !4}
 
 !1 = !{i32 7, !"Dwarf Version", i32 4}
 !2 = !{i32 2, !"Debug Info Version", i32 3}
 !3 = !{i32 1, !"wchar_size", i32 4}
-!4 = !{i32 7, !"PIC Level", i32 2}
+!4 = !{i32 7, !"PIC Level", i32 2}
 

llvm/test/Transforms/Coroutines/coro-materialize.ll

 ; Verifies that we materialize instruction across suspend points
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i32 %n) "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/coro-padding.ll

 ; Check that we will insert the correct padding if natural alignment of the
 ; spilled data does not match the alignment specified in alloca instruction.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %PackedStruct = type <{ i64 }>
 
 declare void @consume(%PackedStruct*)
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:

llvm/test/Transforms/Coroutines/coro-param-copy.ll

 ; Check that we create copy the data from the alloca into the coroutine
 ; frame slot if it was written to.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %a.addr = alloca i64 ; read-only before coro.begin
   %a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy
 
   %x.addr = alloca i64

llvm/test/Transforms/Coroutines/coro-retcon-alloca.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
 
 target datalayout = "p:64:64:64"
 
 declare {i8*, i8*, i32} @prototype_f(i8*, i1)
 define {i8*, i8*, i32} @f(i8* %buffer, i32 %n) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/Coroutines/coro-retcon-frame.ll

-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 target datalayout = "p:64:64:64"
 
 declare void @prototype_f(i8*, i1)
 
 declare noalias i8* @allocate(i32 %size)
 declare void @deallocate(i8* %ptr)

llvm/test/Transforms/Coroutines/coro-retcon-once-value.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 define {i8*, i32} @f(i8* %buffer, i32* %array) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/Coroutines/coro-retcon-once-value2.ll

-; RUN: opt < %s -coro-split -coro-cleanup -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),function(coro-cleanup)' -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 define {i8*, i32*} @f(i8* %buffer, i32* %ptr) "coroutine.presplit"="1" {
 entry:
   %temp = alloca i32, align 4
   %id = call token @llvm.coro.id.retcon.once(i32 8, i32 8, i8* %buffer, i8* bitcast (void (i8*, i1)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -aa-pipeline=default -S | FileCheck %s
 
 define i8* @f(i8* %buffer, i32 %n) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
 ; CHECK-NEXT:    store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
 ; CHECK-NEXT:    ret i8* bitcast (i8* (i8*, i32, i1)* @f.resume.0 to i8*)

llvm/test/Transforms/Coroutines/coro-retcon-resume-values2.ll

-; RUN: opt < %s -coro-split -coro-cleanup -S | FileCheck %s
 ; RUN: opt < %s -passes='coro-split,coro-cleanup' -S | FileCheck %s
 
 define i8* @f(i8* %buffer, i32 %n) "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   %value0 = call i32 (...) @llvm.coro.suspend.retcon.i32()
   %sum0 = call i32 @add(i32 %n, i32 %value0)

llvm/test/Transforms/Coroutines/coro-retcon-unreachable.ll

-; RUN: opt < %s -coro-early -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes='function(coro-early),cgscc(coro-split)' -S | FileCheck %s
 target datalayout = "E-p:64:64"
 
 %swift.type = type { i64 }
 %swift.opaque = type opaque
 %T4red215EmptyCollectionV = type opaque
 %TSi = type <{ i64 }>
 

llvm/test/Transforms/Coroutines/coro-retcon-value.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; First example from Doc/Coroutines.rst (two block loop) converted to retcon
-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
 
 define {i8*, i32} @f(i8* %buffer, i32 %n) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
 ; CHECK-NEXT:    store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
 ; CHECK-NEXT:    [[TMP0:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i8)* @f.resume.0 to i8*), i32 undef }, i32 [[N]], 1

llvm/test/Transforms/Coroutines/coro-retcon.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; First example from Doc/Coroutines.rst (two block loop) converted to retcon
-; RUN: opt < %s -enable-coroutines -O2 -S -enable-new-pm=0 | FileCheck --check-prefixes=ALL,OLDPM %s
 ; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck --check-prefixes=ALL,NEWPM %s
 
 define i8* @f(i8* %buffer, i32 %n) {
 ; ALL-LABEL: @f(
 ; ALL-NEXT:  entry:
 ; ALL-NEXT:    [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
 ; ALL-NEXT:    store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
 ; ALL-NEXT:    tail call void @print(i32 [[N]])

llvm/test/Transforms/Coroutines/coro-spill-after-phi.ll

 ; Verifies that we insert spills of PHI instruction _after) all PHI Nodes
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %n) "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll

 ; Check that we can spills coro.begin from an inlined inner coroutine.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %g.Frame = type { void (%g.Frame*)*, void (%g.Frame*)*, i32, i1, i32 }
 
 @g.resumers = private constant [3 x void (%g.Frame*)*] [void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy]
 
 declare void @g.dummy(%g.Frame*)
 

llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll

 ; Verifies that phi and invoke definitions before CoroBegin are spilled properly.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %n) "coroutine.presplit"="1" personality i32 0 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %flag = call i1 @check(i8* %alloc)

llvm/test/Transforms/Coroutines/coro-spill-promise.ll

 ; Check that promise object is reloaded from the correct index of the coro frame.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"class.task::promise_type" = type { [64 x i8] }
 
 declare void @consume(i32*)
 declare void @consume2(%"class.task::promise_type"*)
 
 define i8* @f() "coroutine.presplit"="1" {

llvm/test/Transforms/Coroutines/coro-split-00.ll

 ; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f() "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %need.alloc = call i1 @llvm.coro.alloc(token %id)
   br i1 %need.alloc, label %dyn.alloc, label %begin
 

llvm/test/Transforms/Coroutines/coro-split-01.ll

 ; Tests that a coroutine is split, inlined into the caller and devirtualized.
-; RUN: opt < %s -S -enable-coroutines -O2 | FileCheck %s
 ; RUN: opt < %s -S -enable-coroutines -passes='default<O2>' | FileCheck %s
 
 define i8* @f() {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
   br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
 dyn.alloc:

llvm/test/Transforms/Coroutines/coro-split-02.ll

 ; Tests that coro-split can handle the case when a code after coro.suspend uses
 ; a value produces between coro.save and coro.suspend (%Result.i19)
 ; and checks whether stray coro.saves are properly removed
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i8* @malloc(i64)
 declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-split-alloc.ll

 ; Tests that coro-split passes initialized values to coroutine frame allocator.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i32 %argument) "coroutine.presplit"="1" {
 entry:
   %argument.addr = alloca i32, align 4
   %incremented = add i32 %argument, 1
   store i32 %incremented, i32* %argument.addr, align 4
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)

llvm/test/Transforms/Coroutines/coro-split-dbg.ll

 ; Make sure that coro-split correctly deals with debug information.
 ; The test here is simply that it does not result in bad IR that will crash opt.
-; RUN: opt < %s -coro-split -disable-output
 ; RUN: opt < %s -passes=coro-split -disable-output
 source_filename = "coro.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 

llvm/test/Transforms/Coroutines/coro-split-eh-00.ll

 ; Tests that coro-split removes cleanup code after coro.end in resume functions
 ; and retains it in the start function.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f(i1 %val) "coroutine.presplit"="1" personality i32 3 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   call void @print(i32 0)
   br i1 %val, label %resume, label %susp

llvm/test/Transforms/Coroutines/coro-split-eh-01.ll

 ; Tests that coro-split removes cleanup code after coro.end in resume functions
 ; and retains it in the start function.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define i8* @f2(i1 %val) "coroutine.presplit"="1" personality i32 4 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
   call void @print(i32 0)
   br i1 %val, label %resume, label %susp

llvm/test/Transforms/Coroutines/coro-split-hidden.ll

 ; Tests that coro-split can convert functions with hidden visibility.
 ; These may be generated by a frontend such as Clang, when inlining with
 ; '-fvisibility-inlines-hidden'.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define hidden i8* @f() "coroutine.presplit"="1" {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %need.alloc = call i1 @llvm.coro.alloc(token %id)
   br i1 %need.alloc, label %dyn.alloc, label %begin
 

llvm/test/Transforms/Coroutines/coro-split-musttail.ll

 ; Tests that coro-split will convert coro.resume followed by a suspend to a
 ; musttail call.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define void @f() #0 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %alloc = call i8* @malloc(i64 16) #3
   %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
 

llvm/test/Transforms/Coroutines/coro-split-musttail1.ll

 ; Tests that coro-split will convert coro.resume followed by a suspend to a
 ; musttail call.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define void @f() #0 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %alloc = call i8* @malloc(i64 16) #3
   %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
 

llvm/test/Transforms/Coroutines/coro-split-musttail2.ll

 ; Tests that coro-split will convert coro.resume followed by a suspend to a
 ; musttail call.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define void @fakeresume1(i8*)  {
 entry:
   ret void;
 }
 
 define void @fakeresume2(i64* align 8)  {

llvm/test/Transforms/Coroutines/coro-split-musttail3.ll

 ; Tests that coro-split will convert coro.resume followed by a suspend to a
 ; musttail call.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 define void @f() #0 {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %alloc = call i8* @malloc(i64 16) #3
   %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
 

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll

 ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
 ; sink them to the places after the suspend block.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i8* @malloc(i64)
 declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-02.ll

 ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
 ; sink them to the places after the suspend block.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i1 @getcond()
 declare i8* @malloc(i64)

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll

 ; Corresponding to coro-split-sink-lifetime-01.ll. This file tests that whether the CoroFrame
 ; pass knows the operand of lifetime.start intrinsic may be GEP as well.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i8* @malloc(i64)
 declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll

 ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
 ; sink them to the places after the suspend block.
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 %"struct.std::coroutine_handle" = type { i8* }
 %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
 %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
 
 declare i8* @malloc(i64)
 declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-swifterror.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
+; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
 target datalayout = "E-p:32:32"
 
 define i8* @f(i8* %buffer, i32 %n, i8** swifterror %errorslot) {
 ; CHECK-LABEL: @f(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
 ; CHECK-NEXT:    store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
 ; CHECK-NEXT:    tail call void @print(i32 [[N]])

llvm/test/Transforms/Coroutines/ex0.ll

 ; First example from Doc/Coroutines.rst (two block loop)
-; RUN: opt < %s -enable-coroutines -O2 -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 ; RUN: opt < %s -enable-coroutines -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/ex1.ll

 ; First example from Doc/Coroutines.rst (one block loop)
-; RUN: opt < %s -O2 -enable-coroutines -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -enable-coroutines -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/ex2.ll

 ; Second example from Doc/Coroutines.rst (custom alloc and free functions)
-; RUN: opt < %s -O2 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -passes='default<O2>' -enable-coroutines -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
   br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
 dyn.alloc:

llvm/test/Transforms/Coroutines/ex3.ll

 ; Third example from Doc/Coroutines.rst (two suspend points)
-; RUN: opt < %s -O2 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -enable-coroutines -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
   br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin

llvm/test/Transforms/Coroutines/ex4.ll

 ; Fourth example from Doc/Coroutines.rst (coroutine promise)
-; RUN: opt < %s -O2 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -passes='default<O2>' -enable-coroutines -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %promise = alloca i32
   %pv = bitcast i32* %promise to i8*
   %id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null)
   %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)

llvm/test/Transforms/Coroutines/ex5.ll

 ; Fifth example from Doc/Coroutines.rst (final suspend)
-; RUN: opt < %s -O2 -enable-coroutines -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -enable-coroutines -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/no-suspend.ll

 ; Test no suspend coroutines
-; RUN: opt < %s -coro-split -S | FileCheck %s
 ; RUN: opt < %s -passes=coro-split -S | FileCheck %s
 
 ; Coroutine with no-suspends will turn into:
 ;
 ; CHECK-LABEL: define void @no_suspends(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    alloca
 ; CHECK-NEXT:    bitcast

llvm/test/Transforms/Coroutines/phi-coro-end.ll

 ; Verify that we correctly handle suspend when the coro.end block contains phi
-; RUN: opt < %s -O2 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -enable-coroutines -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
   %alloc = call i8* @malloc(i32 %size)
   %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)

llvm/test/Transforms/Coroutines/restart-trigger.ll

-; Verifies that the restart trigger that is used by legacy coroutine passes
-; forces the legacy pass manager to restart IPO pipelines, thereby causing the
-; same coroutine to be looked at by CoroSplit pass twice.
 ; REQUIRES: asserts
-; RUN: opt < %s -S -O0 -enable-coroutines -debug-only=coro-split 2>&1 | FileCheck %s
-; RUN: opt < %s -S -O1 -enable-coroutines -debug-only=coro-split 2>&1 | FileCheck %s
 ; The following tests use the new pass manager, and verify that the coroutine
 ; passes re-run the CGSCC pipeline.
 ; RUN: opt < %s -S -passes='default<O0>' -enable-coroutines -debug-only=coro-split 2>&1 | FileCheck %s
 ; RUN: opt < %s -S -passes='default<O1>' -enable-coroutines -debug-only=coro-split 2>&1 | FileCheck %s
 
 ; CHECK:      CoroSplit: Processing coroutine 'f' state: 0
 ; CHECK-NEXT: CoroSplit: Processing coroutine 'f' state: 1
 

llvm/test/Transforms/Coroutines/smoketest.ll

 ; Test that all coroutine passes run in the correct order at all optimization
 ; levels and -enable-coroutines adds coroutine passes to the pipeline.
 ;
-; Legacy pass manager:
-; RUN: opt < %s -disable-output -enable-coroutines -debug-pass=Arguments -O0 -enable-new-pm=0 2>&1 | FileCheck %s
-; RUN: opt < %s -disable-output -enable-coroutines -debug-pass=Arguments -O1 -enable-new-pm=0 2>&1 | FileCheck %s
-; RUN: opt < %s -disable-output -enable-coroutines -debug-pass=Arguments -O2 -enable-new-pm=0 2>&1 | FileCheck %s
-; RUN: opt < %s -disable-output -enable-coroutines -debug-pass=Arguments -O3 -enable-new-pm=0 2>&1 | FileCheck %s
-; RUN: opt < %s -disable-output -enable-coroutines -debug-pass=Arguments \
-; RUN:     -coro-early -coro-split -coro-elide -coro-cleanup -enable-new-pm=0 2>&1 | FileCheck %s
-; RUN: opt < %s -disable-output -debug-pass=Arguments -enable-new-pm=0 2>&1 \
-; RUN:     | FileCheck %s -check-prefix=NOCORO
-; New pass manager:
 ; RUN: opt < %s -disable-output -passes='default<O0>' -enable-coroutines \
-; RUN:     -debug-pass-manager 2>&1 | FileCheck %s -check-prefix=NEWPM
+; RUN:     -debug-pass-manager 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output -passes='default<O1>' -enable-coroutines \
-; RUN:     -debug-pass-manager 2>&1 | FileCheck %s -check-prefix=NEWPM
+; RUN:     -debug-pass-manager 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output -passes='default<O2>' -enable-coroutines \
-; RUN:     -debug-pass-manager 2>&1 | FileCheck %s -check-prefix=NEWPM
+; RUN:     -debug-pass-manager 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output -passes='default<O3>' -enable-coroutines \
-; RUN:     -debug-pass-manager 2>&1 | FileCheck %s -check-prefix=NEWPM
+; RUN:     -debug-pass-manager 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output -debug-pass-manager \
 ; RUN:     -passes='function(coro-early),cgscc(coro-split),function(coro-elide,coro-cleanup)' 2>&1 \
-; RUN:     | FileCheck %s -check-prefix=NEWPM
+; RUN:     | FileCheck %s
 
-; CHECK: coro-early
-; CHECK: coro-split
-; CHECK: coro-elide
-; CHECK: coro-cleanup
-
-; NOCORO-NOT: coro-early
-; NOCORO-NOT: coro-split
-; NOCORO-NOT: coro-elide
-; NOCORO-NOT: coro-cleanup
-
-; NEWPM: CoroEarlyPass
-; NEWPM: CoroSplitPass
-; NEWPM: CoroElidePass
-; NEWPM: CoroCleanupPass
+; CHECK: CoroEarlyPass
+; CHECK: CoroSplitPass
+; CHECK: CoroElidePass
+; CHECK: CoroCleanupPass
 
 define void @foo() {
   ret void
 }