This is an archive of the discontinued LLVM Phabricator instance.

Differential D88760

[Coroutines][NewPM] Fix coroutine tests under new pass manager
ClosedPublic

Authored by aeubanks on Oct 2 2020, 3:42 PM.

Details

Reviewers
rjmccall
asbirlea
ychen
Commits
rG37010d4ddf47: [Coroutines][NewPM] Fix coroutine tests under new pass manager
Summary

Some new function parameter attributes are derived under NPM.

Diff Detail

Event Timeline

aeubanks created this revision.Oct 2 2020, 3:42 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 2 2020, 3:42 PM
Herald added subscribers: llvm-commits, modocache. · View Herald Transcript
aeubanks requested review of this revision.Oct 2 2020, 3:42 PM
aeubanks retitled this revision from [Coroutines][NewPM] Fix coroutines under new pass manager to [Coroutines][NewPM] Fix coroutine tests under new pass manager.Oct 2 2020, 3:46 PM
Harbormaster completed remote builds in B73842: Diff 295922.Oct 2 2020, 4:08 PM
rjmccall accepted this revision.Oct 3 2020, 12:03 AM

LGTM

This revision is now accepted and ready to land.Oct 3 2020, 12:03 AM
This revision was landed with ongoing or failed builds.Oct 4 2020, 2:20 PM
Closed by commit rG37010d4ddf47: [Coroutines][NewPM] Fix coroutine tests under new pass manager (authored by aeubanks). · Explain Why
This revision was automatically updated to reflect the committed changes.
aeubanks added a commit: rG37010d4ddf47: [Coroutines][NewPM] Fix coroutine tests under new pass manager.

Revision Contents

Diff 296079

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

; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s ; 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" target datalayout = "p:64:64:64"
declare {i8*, i8*, i32} @prototype_f(i8*, i1) declare {i8*, i8*, i32} @prototype_f(i8*, i1)
define {i8*, i8*, i32} @f(i8* %buffer, i32 %n) { define {i8*, i8*, i32} @f(i8* %buffer, i32 %n) {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 1024, i32 8, i8* %buffer, i8* bitcast ({i8*, i8*, i32} (i8*, i1)* @prototype_f to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 1024, i32 8, i8* %buffer, i8* bitcast ({i8*, i8*, i32} (i8*, i1)* @prototype_f 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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
Show All 24 Lines
; CHECK-NEXT: [[ALLOC:%.*]] = tail call i8* @allocate(i32 %n) ; CHECK-NEXT: [[ALLOC:%.*]] = tail call i8* @allocate(i32 %n)
; CHECK-NEXT: [[T1:%.*]] = bitcast i8* %buffer to i8** ; CHECK-NEXT: [[T1:%.*]] = bitcast i8* %buffer to i8**
; CHECK-NEXT: store i8* [[ALLOC]], i8** [[T1]], align 8 ; CHECK-NEXT: store i8* [[ALLOC]], i8** [[T1]], align 8
; CHECK-NEXT: [[T0:%.*]] = insertvalue { i8*, i8*, i32 } { i8* bitcast ({ i8*, i8*, i32 } (i8*, i1)* @f.resume.0 to i8*), i8* undef, i32 undef }, i8* [[ALLOC]], 1 ; CHECK-NEXT: [[T0:%.*]] = insertvalue { i8*, i8*, i32 } { i8* bitcast ({ i8*, i8*, i32 } (i8*, i1)* @f.resume.0 to i8*), i8* undef, i32 undef }, i8* [[ALLOC]], 1
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i8*, i32 } [[T0]], i32 %n, 2 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i8*, i32 } [[T0]], i32 %n, 2
; CHECK-NEXT: ret { i8*, i8*, i32 } [[RET]] ; CHECK-NEXT: ret { i8*, i8*, i32 } [[RET]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal { i8*, i8*, i32 } @f.resume.0(i8* noalias nonnull align 8 dereferenceable(1024) %0, i1 %1) ; CHECK-LABEL: define internal { i8*, i8*, i32 } @f.resume.0(i8* {{.*}} %0, i1 %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: [[T1:%.*]] = bitcast i8* %0 to i8** ; CHECK-NEXT: [[T1:%.*]] = bitcast i8* %0 to i8**
; CHECK-NEXT: [[ALLOC:%.*]] = load i8*, i8** [[T1]], align 8 ; CHECK-NEXT: [[ALLOC:%.*]] = load i8*, i8** [[T1]], align 8
; CHECK-NEXT: tail call void @deallocate(i8* [[ALLOC]]) ; CHECK-NEXT: tail call void @deallocate(i8* [[ALLOC]])
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
declare {i8*, i32} @prototype_g(i8*, i1) declare {i8*, i32} @prototype_g(i8*, i1)
define {i8*, i32} @g(i8* %buffer, i32 %n) { define {i8*, i32} @g(i8* %buffer, i32 %n) {
Show All 26 Lines
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: [[T0:%.*]] = zext i32 %n to i64 ; CHECK-NEXT: [[T0:%.*]] = zext i32 %n to i64
; CHECK-NEXT: [[ALLOC:%.*]] = alloca i8, i64 [[T0]], align 8 ; CHECK-NEXT: [[ALLOC:%.*]] = alloca i8, i64 [[T0]], align 8
; CHECK-NEXT: call void @use(i8* nonnull [[ALLOC]]) ; CHECK-NEXT: call void @use(i8* nonnull [[ALLOC]])
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i1)* @g.resume.0 to i8*), i32 undef }, i32 %n, 1 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i1)* @g.resume.0 to i8*), i32 undef }, i32 %n, 1
; CHECK-NEXT: ret { i8*, i32 } [[RET]] ; CHECK-NEXT: ret { i8*, i32 } [[RET]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal { i8*, i32 } @g.resume.0(i8* noalias nonnull align 8 dereferenceable(1024) %0, i1 %1) ; CHECK-LABEL: define internal { i8*, i32 } @g.resume.0(i8* {{.*}} %0, i1 %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 8 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 8
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 8 ; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 8
; CHECK-NEXT: [[T0:%.*]] = zext i32 %inc to i64 ; CHECK-NEXT: [[T0:%.*]] = zext i32 %inc to i64
Show All 32 Lines
; CHECK-LABEL: define { i8*, i32 } @h(i8* %buffer, i32 %n) ; CHECK-LABEL: define { i8*, i32 } @h(i8* %buffer, i32 %n)
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32*
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i1)* @h.resume.0 to i8*), i32 undef }, i32 %n, 1 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i1)* @h.resume.0 to i8*), i32 undef }, i32 %n, 1
; CHECK-NEXT: ret { i8*, i32 } [[RET]] ; CHECK-NEXT: ret { i8*, i32 } [[RET]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal { i8*, i32 } @h.resume.0(i8* noalias nonnull align 8 dereferenceable(1024) %0, i1 %1) ; CHECK-LABEL: define internal { i8*, i32 } @h.resume.0(i8* {{.*}} %0, i1 %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[NSLOT:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[NSLOT:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[NSLOT]], align 8 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[NSLOT]], align 8
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: [[T0:%.*]] = zext i32 %inc to i64 ; CHECK-NEXT: [[T0:%.*]] = zext i32 %inc to i64
; CHECK-NEXT: [[ALLOC:%.*]] = alloca i8, i64 [[T0]], align 8 ; CHECK-NEXT: [[ALLOC:%.*]] = alloca i8, i64 [[T0]], align 8
Show All 31 Lines
; CHECK-LABEL: define { i8*, i32 } @i(i8* %buffer, i32 %n) ; CHECK-LABEL: define { i8*, i32 } @i(i8* %buffer, i32 %n)
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32*
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*)* @i.resume.0 to i8*), i32 undef }, i32 %n, 1 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*)* @i.resume.0 to i8*), i32 undef }, i32 %n, 1
; CHECK-NEXT: ret { i8*, i32 } [[RET]] ; CHECK-NEXT: ret { i8*, i32 } [[RET]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal { i8*, i32 } @i.resume.0(i8* noalias nonnull align 8 dereferenceable(1024) %0) ; CHECK-LABEL: define internal { i8*, i32 } @i.resume.0(i8* {{.*}} %0)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: [[NSLOT:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[NSLOT:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[NSLOT]], align 8 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[NSLOT]], align 8
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: br label %loop2 ; CHECK-NEXT: br label %loop2
; CHECK: : ; CHECK: :
; CHECK-NEXT: store i32 %k, i32* [[NSLOT]], align 8 ; CHECK-NEXT: store i32 %k, i32* [[NSLOT]], align 8
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*)* @i.resume.0 to i8*), i32 undef }, i32 %k, 1 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*)* @i.resume.0 to i8*), i32 undef }, i32 %k, 1
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s ; 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 datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
define {i8*, i32} @f(i8* %buffer, i32* %array) { define {i8*, i32} @f(i8* %buffer, i32* %array) {
entry: entry:
%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*)) %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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%load = load i32, i32* %array %load = load i32, i32* %array
Show All 30 Lines
; CHECK-NEXT: [[CONT:%.*]] = select i1 %load.pos, void (i8*, i1)* @f.resume.0, void (i8*, i1)* @f.resume.1 ; CHECK-NEXT: [[CONT:%.*]] = select i1 %load.pos, void (i8*, i1)* @f.resume.0, void (i8*, i1)* @f.resume.1
; CHECK-NEXT: [[VAL:%.*]] = select i1 %load.pos, i32 %load, i32 0 ; CHECK-NEXT: [[VAL:%.*]] = select i1 %load.pos, i32 %load, i32 0
; CHECK-NEXT: [[CONT_CAST:%.*]] = bitcast void (i8*, i1)* [[CONT]] to i8* ; CHECK-NEXT: [[CONT_CAST:%.*]] = bitcast void (i8*, i1)* [[CONT]] to i8*
; CHECK-NEXT: [[T0:%.*]] = insertvalue { i8*, i32 } undef, i8* [[CONT_CAST]], 0 ; CHECK-NEXT: [[T0:%.*]] = insertvalue { i8*, i32 } undef, i8* [[CONT_CAST]], 0
; CHECK-NEXT: [[T1:%.*]] = insertvalue { i8*, i32 } [[T0]], i32 [[VAL]], 1 ; CHECK-NEXT: [[T1:%.*]] = insertvalue { i8*, i32 } [[T0]], i32 [[VAL]], 1
; CHECK-NEXT: ret { i8*, i32 } [[T1]] ; CHECK-NEXT: ret { i8*, i32 } [[T1]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal void @f.resume.0(i8* noalias nonnull align 8 dereferenceable(8) %0, i1 zeroext %1) ; CHECK-LABEL: define internal void @f.resume.0(i8* {{.*}} %0, i1 zeroext %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32** ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32**
; CHECK-NEXT: [[RELOAD:%.*]] = load i32*, i32** [[T0]], align 8 ; CHECK-NEXT: [[RELOAD:%.*]] = load i32*, i32** [[T0]], align 8
; CHECK-NEXT: store i32 0, i32* [[RELOAD]], align 4 ; CHECK-NEXT: store i32 0, i32* [[RELOAD]], align 4
; CHECK-NEXT: br label ; CHECK-NEXT: br label
; CHECK: : ; CHECK: :
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal void @f.resume.1(i8* noalias nonnull align 8 dereferenceable(8) %0, i1 zeroext %1) ; CHECK-LABEL: define internal void @f.resume.1(i8* {{.*}} %0, i1 zeroext %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32** ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32**
; CHECK-NEXT: [[RELOAD:%.*]] = load i32*, i32** [[T0]], align 8 ; CHECK-NEXT: [[RELOAD:%.*]] = load i32*, i32** [[T0]], align 8
; CHECK-NEXT: store i32 10, i32* [[RELOAD]], align 4 ; CHECK-NEXT: store i32 10, i32* [[RELOAD]], align 4
; CHECK-NEXT: br label ; CHECK-NEXT: br label
; CHECK: : ; CHECK: :
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s ; RUN: opt < %s -enable-coroutines -O2 -S | FileCheck %s
; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
define i8* @f(i8* %buffer, i32 %n) { define i8* @f(i8* %buffer, i32 %n) {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32, i1)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32, 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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
br label %loop br label %loop
loop: loop:
Show All 15 Lines
; CHECK-LABEL: define i8* @f(i8* %buffer, i32 %n) ; CHECK-LABEL: define i8* @f(i8* %buffer, i32 %n)
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32*
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i32, i1)* @f.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i32, i1)* @f.resume.0 to i8*)
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal i8* @f.resume.0(i8* noalias nonnull align 4 dereferenceable(8) %0, i32 %1, i1 zeroext %2) ; CHECK-LABEL: define internal i8* @f.resume.0(i8* {{.*}} %0, i32 %1, i1 zeroext %2)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4
; CHECK-NEXT: br i1 %2, ; CHECK-NEXT: br i1 %2,
; CHECK: : ; CHECK: :
; CHECK-NEXT: %sum = add i32 [[T1]], %1 ; CHECK-NEXT: %sum = add i32 [[T1]], %1
; CHECK-NEXT: store i32 %sum, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %sum, i32* [[T0]], align 4
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i32, i1)* @f.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i32, i1)* @f.resume.0 to i8*)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; First example from Doc/Coroutines.rst (two block loop) converted to retcon ; 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 -O2 -S | FileCheck %s
; RUN: opt < %s -enable-coroutines -passes='default<O2>' -S | FileCheck %s
define {i8*, i32} @f(i8* %buffer, i32 %n) { define {i8*, i32} @f(i8* %buffer, i32 %n) {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({i8*, i32} (i8*, i8)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({i8*, i32} (i8*, i8)* @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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
br label %loop br label %loop
loop: loop:
Show All 14 Lines
; CHECK-LABEL: define { i8*, i32 } @f(i8* %buffer, i32 %n) ; CHECK-LABEL: define { i8*, i32 } @f(i8* %buffer, i32 %n)
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32*
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i8)* @f.resume.0 to i8*), i32 undef }, i32 %n, 1 ; CHECK-NEXT: [[RET:%.*]] = insertvalue { i8*, i32 } { i8* bitcast ({ i8*, i32 } (i8*, i8)* @f.resume.0 to i8*), i32 undef }, i32 %n, 1
; CHECK-NEXT: ret { i8*, i32 } [[RET]] ; CHECK-NEXT: ret { i8*, i32 } [[RET]]
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal { i8*, i32 } @f.resume.0(i8* noalias nonnull align 4 dereferenceable(8) %0, i8 zeroext %1) ; CHECK-LABEL: define internal { i8*, i32 } @f.resume.0(i8* {{.*}} %0, i8 zeroext %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: [[T0:%.*]] = icmp eq i8 %1, 0 ; CHECK-NEXT: [[T0:%.*]] = icmp eq i8 %1, 0
; CHECK-NEXT: br i1 [[T0]], ; CHECK-NEXT: br i1 [[T0]],
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; First example from Doc/Coroutines.rst (two block loop) converted to retcon ; 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 -O2 -S | FileCheck %s
; RUN: opt < %s -enable-coroutines -aa-pipeline=basic-aa -passes='default<O2>' -S | FileCheck %s
define i8* @f(i8* %buffer, i32 %n) { define i8* @f(i8* %buffer, i32 %n) {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i1)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
br label %loop br label %loop
loop: loop:
Show All 14 Lines
; CHECK-LABEL: define i8* @f(i8* %buffer, i32 %n) ; CHECK-LABEL: define i8* @f(i8* %buffer, i32 %n)
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %buffer to i32*
; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %n, i32* [[T0]], align 4
; CHECK-NEXT: call void @print(i32 %n) ; CHECK-NEXT: call void @print(i32 %n)
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @f.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @f.resume.0 to i8*)
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal i8* @f.resume.0(i8* noalias nonnull align 4 dereferenceable(8) %0, i1 zeroext %1) ; CHECK-LABEL: define internal i8* @f.resume.0(i8* {{.*}} %0, i1 zeroext %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4
; CHECK-NEXT: call void @print(i32 %inc) ; CHECK-NEXT: call void @print(i32 %inc)
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

Show All 34 Lines
; CHECK-NEXT: store i8* null, i8** %errorslot ; CHECK-NEXT: store i8* null, i8** %errorslot
; CHECK-NEXT: call void @maybeThrow(i8** nonnull swifterror %errorslot) ; CHECK-NEXT: call void @maybeThrow(i8** nonnull swifterror %errorslot)
; CHECK-NEXT: [[T1:%.*]] = load i8*, i8** %errorslot ; CHECK-NEXT: [[T1:%.*]] = load i8*, i8** %errorslot
; CHECK-NEXT: call void @logError(i8* [[T1]]) ; CHECK-NEXT: call void @logError(i8* [[T1]])
; CHECK-NEXT: store i8* [[T1]], i8** %errorslot ; CHECK-NEXT: store i8* [[T1]], i8** %errorslot
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1, i8**)* @f.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1, i8**)* @f.resume.0 to i8*)
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal i8* @f.resume.0(i8* noalias nonnull align 4 dereferenceable(8) %0, i1 zeroext %1, i8** swifterror %2) ; CHECK-LABEL: define internal i8* @f.resume.0(i8* {{.*}} %0, i1 zeroext %1, i8** swifterror %2)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[ERROR:%.*]] = load i8*, i8** %2, align 4 ; CHECK-NEXT: [[ERROR:%.*]] = load i8*, i8** %2, align 4
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4 ; CHECK-NEXT: store i32 %inc, i32* [[T0]], align 4
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[ERRORSLOT]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[ERRORSLOT]], align 4
; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* %buffer, i32 4 ; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* %buffer, i32 4
; CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8** ; CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8**
; CHECK-NEXT: store i8* [[T1]], i8** [[T3]], align 4 ; CHECK-NEXT: store i8* [[T1]], i8** [[T3]], align 4
; CHECK-NEXT: call void @logError(i8* [[T1]]) ; CHECK-NEXT: call void @logError(i8* [[T1]])
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @g.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @g.resume.0 to i8*)
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-LABEL: define internal i8* @g.resume.0(i8* noalias nonnull align 4 dereferenceable(8) %0, i1 zeroext %1) ; CHECK-LABEL: define internal i8* @g.resume.0(i8* {{.*}} %0, i1 zeroext %1)
; CHECK-NEXT: : ; CHECK-NEXT: :
; CHECK-NEXT: [[ERRORSLOT:%.*]] = alloca swifterror i8*, align 4 ; CHECK-NEXT: [[ERRORSLOT:%.*]] = alloca swifterror i8*, align 4
; CHECK-NEXT: br i1 %1, ; CHECK-NEXT: br i1 %1,
; CHECK: : ; CHECK: :
; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32* ; CHECK-NEXT: [[T0:%.*]] = bitcast i8* %0 to i32*
; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4 ; CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[T0]], align 4
; CHECK-NEXT: %inc = add i32 [[T1]], 1 ; CHECK-NEXT: %inc = add i32 [[T1]], 1
; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* %0, i32 4 ; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* %0, i32 4
Show All 30 Lines