This is an archive of the discontinued LLVM Phabricator instance.

Differential D127471

[Coroutines] Convert coroutine.presplit to enum attr
ClosedPublic

Authored by ChuanqiXu on Jun 9 2022, 8:49 PM.

Details

Reviewers
nikic
rjmccall
ezhulenev
Commits
rG735e6c40b5e9: [Coroutines] Convert coroutine.presplit to enum attr
Summary

This is required by @nikic in https://reviews.llvm.org/D127383 and this fixes a FIXME too.

@rjmccall I'm not sure if swift have emitted "coroutine.presplit" in the frontend. If it haven't do so, it should be fine.

@ezhulenev I'm not sure if the changes in mlir part calls the right API. Although it passes the tests, I haven't run mlir actually.

Diff Detail

Event Timeline

ChuanqiXu created this revision.Jun 9 2022, 8:49 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2022, 8:49 PM
Herald added subscribers: Peiming, bzcheeseman, sdasgup3 and 24 others. · View Herald Transcript
ChuanqiXu requested review of this revision.Jun 9 2022, 8:49 PM
Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald TranscriptJun 9 2022, 8:49 PM
Herald added subscribers: llvm-commits, cfe-commits, stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B168999: Diff 435786.Jun 9 2022, 9:46 PM
ChuanqiXu added a child revision: D127383: Don't treat readnone call in presplit coroutine as not access memory.Jun 9 2022, 9:52 PM
nikic added a comment.Jun 10 2022, 12:44 AM

You probably want to add this to llvm::UpgradeAttributes as well, to maintain support for old bitcode.

ChuanqiXu added a comment.Jun 10 2022, 1:42 AM
In D127471#3572616, @nikic wrote:

You probably want to add this to llvm::UpgradeAttributes as well, to maintain support for old bitcode.

Oh, I feel like it is not so meaningful to keep backward compatibility. We've done some break changes before. Since the primary users of LLVM Coroutines are frontends, it shouldn't be hard for them to update.

ezhulenev accepted this revision.Jun 10 2022, 12:05 PM

Yes, that's the correct MLIR way of passing attributes to LLVM.

This revision is now accepted and ready to land.Jun 10 2022, 12:05 PM
ChuanqiXu added a comment.Jun 12 2022, 7:53 PM

@rjmccall Does this look good to you? I am afraid to break swift's codes.

rjmccall accepted this revision.Jun 13 2022, 9:34 AM

LGTM. Don't worry about Swift, we'll handle it.

This revision was landed with ongoing or failed builds.Jun 13 2022, 11:24 PM
Closed by commit rG735e6c40b5e9: [Coroutines] Convert coroutine.presplit to enum attr (authored by ChuanqiXu). · Explain Why
This revision was automatically updated to reflect the committed changes.
ChuanqiXu added a commit: rG735e6c40b5e9: [Coroutines] Convert coroutine.presplit to enum attr.
akuegel added a subscriber: akuegel.Jun 13 2022, 11:37 PM

It seems this change triggers a warning:

https://buildkite.com/llvm-project/upstream-bazel/builds/31190#018160e2-0b96-4254-8986-f039b7f2e0a1

llvm-project/llvm/lib/Transforms/Utils/CodeExtractor.cpp:901:15: error: enumeration value 'PresplitCoroutine' not handled in switch [-Werror,-Wswitch]

switch (Attr.getKindAsEnum()) {
ChuanqiXu added a comment.Jun 13 2022, 11:39 PM
In D127471#3580581, @akuegel wrote:

It seems this change triggers a warning:

https://buildkite.com/llvm-project/upstream-bazel/builds/31190#018160e2-0b96-4254-8986-f039b7f2e0a1

llvm-project/llvm/lib/Transforms/Utils/CodeExtractor.cpp:901:15: error: enumeration value 'PresplitCoroutine' not handled in switch [-Werror,-Wswitch]

switch (Attr.getKindAsEnum()) {

Thanks for reporting! I am trying to fix it.

Revision Contents

PathSize
clang/
lib/
CodeGen/
5 lines
test/
CodeGenCoroutines/
2 lines
llvm/
docs/
8 lines
include/
llvm/
Bitcode/
1 line
IR/
3 lines
7 lines
lib/
Bitcode/
Reader/
2 lines
Writer/
2 lines
Transforms/
Coroutines/
3 lines
6 lines
9 lines
4 lines
test/
Transforms/
Coroutines/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
16 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
16 lines
2 lines
FunctionAttrs/
2 lines
Inline/
ML/
2 lines
mlir/
lib/
Dialect/
Async/
Transforms/
8 lines
test/
mlir-opt/
6 lines

Diff 436663

clang/lib/CodeGen/CGCoroutine.cpp

Show First 20 Lines • Show All 648 Lines • ▼ Show 20 Linesvoid CodeGenFunction::EmitCoroutineBody(const CoroutineBodyStmt &S) {
if (Stmt *Ret = S.getReturnStmt()) { if (Stmt *Ret = S.getReturnStmt()) {
// Since we already emitted the return value above, so we shouldn't // Since we already emitted the return value above, so we shouldn't
// emit it again here. // emit it again here.
cast<ReturnStmt>(Ret)->setRetValue(nullptr); cast<ReturnStmt>(Ret)->setRetValue(nullptr);
EmitStmt(Ret); EmitStmt(Ret);
} }
// LLVM require the frontend to add the function attribute. See // LLVM require the frontend to mark the coroutine.
// Coroutines.rst. CurFn->setPresplitCoroutine();
CurFn->addFnAttr("coroutine.presplit", "0");
} }
// Emit coroutine intrinsic and patch up arguments of the token type. // Emit coroutine intrinsic and patch up arguments of the token type.
RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E, RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E,
unsigned int IID) { unsigned int IID) {
SmallVector<llvm::Value *, 8> Args; SmallVector<llvm::Value *, 8> Args;
switch (IID) { switch (IID) {
default: default:
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang/test/CodeGenCoroutines/coro-attributes.cpp

// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -disable-llvm-passes -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -disable-llvm-passes -emit-llvm %s -o - | FileCheck %s
#include "Inputs/coroutine.h" #include "Inputs/coroutine.h"
using namespace std; using namespace std;
struct coro { struct coro {
struct promise_type { struct promise_type {
coro get_return_object(); coro get_return_object();
suspend_never initial_suspend(); suspend_never initial_suspend();
suspend_never final_suspend() noexcept; suspend_never final_suspend() noexcept;
void return_void(); void return_void();
static void unhandled_exception(); static void unhandled_exception();
}; };
}; };
// CHECK: void @_Z3foov() #[[FOO_ATTR_NUM:[0-9]+]] // CHECK: void @_Z3foov() #[[FOO_ATTR_NUM:[0-9]+]]
// CHECK: attributes #[[FOO_ATTR_NUM]] = { {{.*}} "coroutine.presplit"="0" // CHECK: attributes #[[FOO_ATTR_NUM]] = { {{.*}} presplitcoroutine
coro foo() { coro foo() {
co_await suspend_always{}; co_await suspend_always{};
} }

llvm/docs/Coroutines.rst

Show First 20 Lines • Show All 1,195 Lines • ▼ Show 20 Lines
The purpose of this intrinsic is to tie together `coro.id`, `coro.alloc` and The purpose of this intrinsic is to tie together `coro.id`, `coro.alloc` and
`coro.begin` belonging to the same coroutine to prevent optimization passes from `coro.begin` belonging to the same coroutine to prevent optimization passes from
duplicating any of these instructions unless entire body of the coroutine is duplicating any of these instructions unless entire body of the coroutine is
duplicated. duplicated.
A frontend should emit exactly one `coro.id` intrinsic per coroutine. A frontend should emit exactly one `coro.id` intrinsic per coroutine.
A frontend should emit function attribute `"coroutine.presplit"` for the coroutine. A frontend should emit function attribute `presplitcoroutine` for the coroutine.
.. _coro.id.async: .. _coro.id.async:
'llvm.coro.id.async' Intrinsic 'llvm.coro.id.async' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
:: ::
declare token @llvm.coro.id.async(i32 <context size>, i32 <align>, declare token @llvm.coro.id.async(i32 <context size>, i32 <align>,
Show All 24 Lines
the first argument of this intrinsic. the first argument of this intrinsic.
Semantics: Semantics:
"""""""""" """"""""""
A frontend should emit exactly one `coro.id.async` intrinsic per coroutine. A frontend should emit exactly one `coro.id.async` intrinsic per coroutine.
A frontend should emit function attribute `"coroutine.presplit"` for the coroutine. A frontend should emit function attribute `presplitcoroutine` for the coroutine.
.. _coro.id.retcon: .. _coro.id.retcon:
'llvm.coro.id.retcon' Intrinsic 'llvm.coro.id.retcon' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
:: ::
declare token @llvm.coro.id.retcon(i32 <size>, i32 <align>, i8* <buffer>, declare token @llvm.coro.id.retcon(i32 <size>, i32 <align>, i8* <buffer>,
Show All 40 Lines
or throwing an exception. It must take an integer and return a pointer. or throwing an exception. It must take an integer and return a pointer.
The sixth argument must be a reference to a global function that will The sixth argument must be a reference to a global function that will
be used to deallocate memory. It must take a pointer and return ``void``. be used to deallocate memory. It must take a pointer and return ``void``.
Semantics: Semantics:
"""""""""" """"""""""
A frontend should emit function attribute `"coroutine.presplit"` for the coroutine. A frontend should emit function attribute `presplitcoroutine` for the coroutine.
'llvm.coro.id.retcon.once' Intrinsic 'llvm.coro.id.retcon.once' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
:: ::
declare token @llvm.coro.id.retcon.once(i32 <size>, i32 <align>, i8* <buffer>, declare token @llvm.coro.id.retcon.once(i32 <size>, i32 <align>, i8* <buffer>,
i8* <prototype>, i8* <prototype>,
i8* <alloc>, i8* <dealloc>) i8* <alloc>, i8* <dealloc>)
Show All 9 Lines
As for ``llvm.core.id.retcon``, except that the return type of the As for ``llvm.core.id.retcon``, except that the return type of the
continuation prototype must be `void` instead of matching the continuation prototype must be `void` instead of matching the
coroutine's return type. coroutine's return type.
Semantics: Semantics:
"""""""""" """"""""""
A frontend should emit function attribute `"coroutine.presplit"` for the coroutine. A frontend should emit function attribute `presplitcoroutine` for the coroutine.
.. _coro.end: .. _coro.end:
'llvm.coro.end' Intrinsic 'llvm.coro.end' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
:: ::
declare i1 @llvm.coro.end(i8* <handle>, i1 <unwind>) declare i1 @llvm.coro.end(i8* <handle>, i1 <unwind>)
▲ Show 20 Lines • Show All 416 Lines • Show Last 20 Lines

llvm/include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 679 Lines • ▼ Show 20 Linesenum AttributeKindCodes {
ATTR_KIND_SWIFT_ASYNC = 75, ATTR_KIND_SWIFT_ASYNC = 75,
ATTR_KIND_NO_SANITIZE_COVERAGE = 76, ATTR_KIND_NO_SANITIZE_COVERAGE = 76,
ATTR_KIND_ELEMENTTYPE = 77, ATTR_KIND_ELEMENTTYPE = 77,
ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION = 78, ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION = 78,
ATTR_KIND_NO_SANITIZE_BOUNDS = 79, ATTR_KIND_NO_SANITIZE_BOUNDS = 79,
ATTR_KIND_ALLOC_ALIGN = 80, ATTR_KIND_ALLOC_ALIGN = 80,
ATTR_KIND_ALLOCATED_POINTER = 81, ATTR_KIND_ALLOCATED_POINTER = 81,
ATTR_KIND_ALLOC_KIND = 82, ATTR_KIND_ALLOC_KIND = 82,
ATTR_KIND_PRESPLIT_COROUTINE = 83,
}; };
enum ComdatSelectionKindCodes { enum ComdatSelectionKindCodes {
COMDAT_SELECTION_KIND_ANY = 1, COMDAT_SELECTION_KIND_ANY = 1,
COMDAT_SELECTION_KIND_EXACT_MATCH = 2, COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
COMDAT_SELECTION_KIND_LARGEST = 3, COMDAT_SELECTION_KIND_LARGEST = 3,
COMDAT_SELECTION_KIND_NO_DUPLICATES = 4, COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
COMDAT_SELECTION_KIND_SAME_SIZE = 5, COMDAT_SELECTION_KIND_SAME_SIZE = 5,
Show All 14 Lines

llvm/include/llvm/IR/Attributes.td

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines
def WriteOnly : EnumAttr<"writeonly", [FnAttr, ParamAttr]>; def WriteOnly : EnumAttr<"writeonly", [FnAttr, ParamAttr]>;
/// Zero extended before/after call. /// Zero extended before/after call.
def ZExt : EnumAttr<"zeroext", [ParamAttr, RetAttr]>; def ZExt : EnumAttr<"zeroext", [ParamAttr, RetAttr]>;
/// Function is required to make Forward Progress. /// Function is required to make Forward Progress.
def MustProgress : EnumAttr<"mustprogress", [FnAttr]>; def MustProgress : EnumAttr<"mustprogress", [FnAttr]>;
/// Function is a presplit coroutine.
def PresplitCoroutine : EnumAttr<"presplitcoroutine", [FnAttr]>;
/// Target-independent string attributes. /// Target-independent string attributes.
def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">; def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">;
def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">; def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">;
def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">; def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">;
def ApproxFuncFPMath : StrBoolAttr<"approx-func-fp-math">; def ApproxFuncFPMath : StrBoolAttr<"approx-func-fp-math">;
def NoSignedZerosFPMath : StrBoolAttr<"no-signed-zeros-fp-math">; def NoSignedZerosFPMath : StrBoolAttr<"no-signed-zeros-fp-math">;
def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">; def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">;
def NoJumpTables : StrBoolAttr<"no-jump-tables">; def NoJumpTables : StrBoolAttr<"no-jump-tables">;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/include/llvm/IR/Function.h

Show First 20 Lines • Show All 478 Lines • ▼ Show 20 Linespublic:
/// Extract the number of dereferenceable_or_null bytes for a /// Extract the number of dereferenceable_or_null bytes for a
/// parameter. /// parameter.
/// @param ArgNo AttributeList ArgNo, referring to an argument. /// @param ArgNo AttributeList ArgNo, referring to an argument.
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const { uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo); return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
} }
/// A function will have the "coroutine.presplit" attribute if it's /// Determine if the function is presplit coroutine.
/// a coroutine and has not gone through full CoroSplit pass.
bool isPresplitCoroutine() const { bool isPresplitCoroutine() const {
return hasFnAttribute("coroutine.presplit"); return hasFnAttribute(Attribute::PresplitCoroutine);
} }
void setPresplitCoroutine() { addFnAttr(Attribute::PresplitCoroutine); }
void setSplittedCoroutine() { removeFnAttr(Attribute::PresplitCoroutine); }
/// Determine if the function does not access memory. /// Determine if the function does not access memory.
bool doesNotAccessMemory() const { bool doesNotAccessMemory() const {
return hasFnAttribute(Attribute::ReadNone); return hasFnAttribute(Attribute::ReadNone);
} }
void setDoesNotAccessMemory() { void setDoesNotAccessMemory() {
addFnAttr(Attribute::ReadNone); addFnAttr(Attribute::ReadNone);
} }
▲ Show 20 Lines • Show All 420 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,628 Lines • ▼ Show 20 Linesstatic Attribute::AttrKind getAttrFromCode(uint64_t Code) {
case bitc::ATTR_KIND_NOUNDEF: case bitc::ATTR_KIND_NOUNDEF:
return Attribute::NoUndef; return Attribute::NoUndef;
case bitc::ATTR_KIND_BYREF: case bitc::ATTR_KIND_BYREF:
return Attribute::ByRef; return Attribute::ByRef;
case bitc::ATTR_KIND_MUSTPROGRESS: case bitc::ATTR_KIND_MUSTPROGRESS:
return Attribute::MustProgress; return Attribute::MustProgress;
case bitc::ATTR_KIND_HOT: case bitc::ATTR_KIND_HOT:
return Attribute::Hot; return Attribute::Hot;
case bitc::ATTR_KIND_PRESPLIT_COROUTINE:
return Attribute::PresplitCoroutine;
} }
} }
Error BitcodeReader::parseAlignmentValue(uint64_t Exponent, Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,
MaybeAlign &Alignment) { MaybeAlign &Alignment) {
// Note: Alignment in bitcode files is incremented by 1, so that zero // Note: Alignment in bitcode files is incremented by 1, so that zero
// can be used for default alignment. // can be used for default alignment.
if (Exponent > Value::MaxAlignmentExponent + 1) if (Exponent > Value::MaxAlignmentExponent + 1)
▲ Show 20 Lines • Show All 5,971 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 768 Lines • ▼ Show 20 Linesstatic uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
case Attribute::Preallocated: case Attribute::Preallocated:
return bitc::ATTR_KIND_PREALLOCATED; return bitc::ATTR_KIND_PREALLOCATED;
case Attribute::NoUndef: case Attribute::NoUndef:
return bitc::ATTR_KIND_NOUNDEF; return bitc::ATTR_KIND_NOUNDEF;
case Attribute::ByRef: case Attribute::ByRef:
return bitc::ATTR_KIND_BYREF; return bitc::ATTR_KIND_BYREF;
case Attribute::MustProgress: case Attribute::MustProgress:
return bitc::ATTR_KIND_MUSTPROGRESS; return bitc::ATTR_KIND_MUSTPROGRESS;
case Attribute::PresplitCoroutine:
return bitc::ATTR_KIND_PRESPLIT_COROUTINE;
case Attribute::EndAttrKinds: case Attribute::EndAttrKinds:
llvm_unreachable("Can not encode end-attribute kinds marker."); llvm_unreachable("Can not encode end-attribute kinds marker.");
case Attribute::None: case Attribute::None:
llvm_unreachable("Can not encode none-attribute."); llvm_unreachable("Can not encode none-attribute.");
case Attribute::EmptyKey: case Attribute::EmptyKey:
case Attribute::TombstoneKey: case Attribute::TombstoneKey:
llvm_unreachable("Trying to encode EmptyKey/TombstoneKey"); llvm_unreachable("Trying to encode EmptyKey/TombstoneKey");
} }
▲ Show 20 Lines • Show All 4,262 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroCleanup.cpp

Show All 39 Linesstatic void lowerSubFn(IRBuilder<> &Builder, CoroSubFnInst *SubFn) {
auto *FramePtr = Builder.CreateBitCast(FrameRaw, FramePtrTy); auto *FramePtr = Builder.CreateBitCast(FrameRaw, FramePtrTy);
auto *Gep = Builder.CreateConstInBoundsGEP2_32(FrameTy, FramePtr, 0, Index); auto *Gep = Builder.CreateConstInBoundsGEP2_32(FrameTy, FramePtr, 0, Index);
auto *Load = Builder.CreateLoad(FrameTy->getElementType(Index), Gep); auto *Load = Builder.CreateLoad(FrameTy->getElementType(Index), Gep);
SubFn->replaceAllUsesWith(Load); SubFn->replaceAllUsesWith(Load);
} }
bool Lowerer::lower(Function &F) { bool Lowerer::lower(Function &F) {
bool IsPrivateAndUnprocessed = bool IsPrivateAndUnprocessed = F.isPresplitCoroutine() && F.hasLocalLinkage();
F.hasFnAttribute(CORO_PRESPLIT_ATTR) && F.hasLocalLinkage();
bool Changed = false; bool Changed = false;
for (Instruction &I : llvm::make_early_inc_range(instructions(F))) { for (Instruction &I : llvm::make_early_inc_range(instructions(F))) {
if (auto *II = dyn_cast<IntrinsicInst>(&I)) { if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
default: default:
continue; continue;
case Intrinsic::coro_begin: case Intrinsic::coro_begin:
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroEarly.cpp

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Lines switch (CB->getIntrinsicID()) {
CB->setCannotDuplicate(); CB->setCannotDuplicate();
break; break;
case Intrinsic::coro_noop: case Intrinsic::coro_noop:
lowerCoroNoop(cast<IntrinsicInst>(&I)); lowerCoroNoop(cast<IntrinsicInst>(&I));
break; break;
case Intrinsic::coro_id: case Intrinsic::coro_id:
if (auto *CII = cast<CoroIdInst>(&I)) { if (auto *CII = cast<CoroIdInst>(&I)) {
if (CII->getInfo().isPreSplit()) { if (CII->getInfo().isPreSplit()) {
assert(F.hasFnAttribute(CORO_PRESPLIT_ATTR) && assert(F.isPresplitCoroutine() &&
"The frontend uses Swtich-Resumed ABI should emit " "The frontend uses Swtich-Resumed ABI should emit "
"\"coroutine.presplit\" attribute for the coroutine."); "\"coroutine.presplit\" attribute for the coroutine.");
setCannotDuplicate(CII); setCannotDuplicate(CII);
CII->setCoroutineSelf(); CII->setCoroutineSelf();
CoroId = cast<CoroIdInst>(&I); CoroId = cast<CoroIdInst>(&I);
} }
} }
break; break;
case Intrinsic::coro_id_retcon: case Intrinsic::coro_id_retcon:
case Intrinsic::coro_id_retcon_once: case Intrinsic::coro_id_retcon_once:
case Intrinsic::coro_id_async: case Intrinsic::coro_id_async:
// TODO: Remove the line once we support it in the corresponding F.setPresplitCoroutine();
// frontend.
F.addFnAttr(CORO_PRESPLIT_ATTR);
break; break;
case Intrinsic::coro_resume: case Intrinsic::coro_resume:
lowerResumeOrDestroy(*CB, CoroSubFnInst::ResumeIndex); lowerResumeOrDestroy(*CB, CoroSubFnInst::ResumeIndex);
break; break;
case Intrinsic::coro_destroy: case Intrinsic::coro_destroy:
lowerResumeOrDestroy(*CB, CoroSubFnInst::DestroyIndex); lowerResumeOrDestroy(*CB, CoroSubFnInst::DestroyIndex);
break; break;
case Intrinsic::coro_promise: case Intrinsic::coro_promise:
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroInternal.h

Show All 14 Lines
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
namespace llvm { namespace llvm {
class CallGraph; class CallGraph;
class CallGraphSCC; class CallGraphSCC;
class PassRegistry; class PassRegistry;
// CoroEarly pass marks every function that has coro.begin with a string
// attribute "coroutine.presplit". CoroSplit pass would processes the
// function marked as "coroutine.presplit" only.
//
// FIXME: Refactor these attributes as LLVM attributes instead of string
// attributes since these attributes are already used outside LLVM's
// coroutine module.
#define CORO_PRESPLIT_ATTR "coroutine.presplit"
namespace coro { namespace coro {
bool declaresAnyIntrinsic(const Module &M); bool declaresAnyIntrinsic(const Module &M);
bool declaresIntrinsics(const Module &M, bool declaresIntrinsics(const Module &M,
const std::initializer_list<StringRef>); const std::initializer_list<StringRef>);
void replaceCoroFree(CoroIdInst *CoroId, bool Elide); void replaceCoroFree(CoroIdInst *CoroId, bool Elide);
/// Recover a dbg.declare prepared by the frontend and emit an alloca /// Recover a dbg.declare prepared by the frontend and emit an alloca
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

Show First 20 Lines • Show All 2,058 Lines • ▼ Show 20 LinesPreservedAnalyses CoroSplitPass::run(LazyCallGraph::SCC &C,
// Check for uses of llvm.coro.prepare.retcon/async. // Check for uses of llvm.coro.prepare.retcon/async.
SmallVector<Function *, 2> PrepareFns; SmallVector<Function *, 2> PrepareFns;
addPrepareFunction(M, PrepareFns, "llvm.coro.prepare.retcon"); addPrepareFunction(M, PrepareFns, "llvm.coro.prepare.retcon");
addPrepareFunction(M, PrepareFns, "llvm.coro.prepare.async"); addPrepareFunction(M, PrepareFns, "llvm.coro.prepare.async");
// Find coroutines for processing. // Find coroutines for processing.
SmallVector<LazyCallGraph::Node *> Coroutines; SmallVector<LazyCallGraph::Node *> Coroutines;
for (LazyCallGraph::Node &N : C) for (LazyCallGraph::Node &N : C)
if (N.getFunction().hasFnAttribute(CORO_PRESPLIT_ATTR)) if (N.getFunction().isPresplitCoroutine())
Coroutines.push_back(&N); Coroutines.push_back(&N);
if (Coroutines.empty() && PrepareFns.empty()) if (Coroutines.empty() && PrepareFns.empty())
return PreservedAnalyses::all(); return PreservedAnalyses::all();
if (Coroutines.empty()) { if (Coroutines.empty()) {
for (auto *PrepareFn : PrepareFns) { for (auto *PrepareFn : PrepareFns) {
replaceAllPrepares(PrepareFn, CG, C); replaceAllPrepares(PrepareFn, CG, C);
} }
} }
// Split all the coroutines. // Split all the coroutines.
for (LazyCallGraph::Node *N : Coroutines) { for (LazyCallGraph::Node *N : Coroutines) {
Function &F = N->getFunction(); Function &F = N->getFunction();
LLVM_DEBUG(dbgs() << "CoroSplit: Processing coroutine '" << F.getName() LLVM_DEBUG(dbgs() << "CoroSplit: Processing coroutine '" << F.getName()
<< "\n"); << "\n");
F.removeFnAttr(CORO_PRESPLIT_ATTR); F.setSplittedCoroutine();
SmallVector<Function *, 4> Clones; SmallVector<Function *, 4> Clones;
const coro::Shape Shape = splitCoroutine(F, Clones, OptimizeFrame); const coro::Shape Shape = splitCoroutine(F, Clones, OptimizeFrame);
updateCallGraphAfterCoroutineSplit(*N, Shape, Clones, C, CG, AM, UR, FAM); updateCallGraphAfterCoroutineSplit(*N, Shape, Clones, C, CG, AM, UR, FAM);
if (!Shape.CoroSuspends.empty()) { if (!Shape.CoroSuspends.empty()) {
// Run the CGSCC pipeline on the original and newly split functions. // Run the CGSCC pipeline on the original and newly split functions.
UR.CWorklist.insert(&C); UR.CWorklist.insert(&C);
Show All 13 Lines

llvm/test/Transforms/Coroutines/ArgAddr.ll

; Need to move users of allocas that were moved into the coroutine frame after ; Need to move users of allocas that were moved into the coroutine frame after
; coro.begin. ; coro.begin.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define nonnull i8* @f(i32 %n) "coroutine.presplit"="1" { define nonnull i8* @f(i32 %n) presplitcoroutine {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; 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: [[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: [[N_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_ADDR]], align 4 ; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_ADDR]], align 4
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @malloc(i32 24) ; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @malloc(i32 24)
; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[CALL]]) ; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[CALL]])
; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[TMP0]] to %f.Frame* ; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[TMP0]] to %f.Frame*
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64, align 16 %x = alloca i64, align 16
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
%alloc = call i8* @aligned_alloc(i32 %align, i32 %size) %alloc = call i8* @aligned_alloc(i32 %align, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64, align 16 %x = alloca i64, align 16
%y = alloca i32, align 32 %y = alloca i32, align 32
%z = alloca i32, align 16 %z = alloca i32, align 16
%alpha = alloca i1, align 8 %alpha = alloca i1, align 8
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i1, align 64 %x = alloca i1, align 64
%y = alloca i64, align 32 %y = alloca i64, align 32
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
%alloc = call i8* @aligned_alloc(i32 %align, i32 %size) %alloc = call i8* @aligned_alloc(i32 %align, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i1, align 64 %x = alloca i1, align 64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
%alloc = call i8* @aligned_alloc(i32 %align, i32 %size) %alloc = call i8* @aligned_alloc(i32 %align, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
%alloc = call i8* @aligned_alloc(i32 %align, i32 %size) %alloc = call i8* @aligned_alloc(i32 %align, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false) %sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume switch i8 %sp1, label %suspend [i8 0, label %resume
Show All 34 Lines

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

; Tests that the coro.align intrinsic could be lowered to correct alignment ; Tests that the coro.align intrinsic could be lowered to correct alignment
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%align = call i32 @llvm.coro.align.i32() %align = call i32 @llvm.coro.align.i32()
%alloc = call i8* @aligned_alloc(i32 %align, i32 %size) %alloc = call i8* @aligned_alloc(i32 %align, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; Check that we can handle the case when both alloc function and ; Check that we can handle the case when both alloc function and
; the user body consume the same argument. ; the user body consume the same argument.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using copy of this (as it would happen under -O0) ; using copy of this (as it would happen under -O0)
define i8* @f_copy(i64 %this_arg) "coroutine.presplit"="1" { define i8* @f_copy(i64 %this_arg) presplitcoroutine {
entry: entry:
%this.addr = alloca i64 %this.addr = alloca i64
store i64 %this_arg, i64* %this.addr store i64 %this_arg, i64* %this.addr
%this = load i64, i64* %this.addr %this = load i64, i64* %this.addr
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @myAlloc(i64 %this, i32 %size) %alloc = call i8* @myAlloc(i64 %this, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; Check that we can handle the case when both alloc function and ; Check that we can handle the case when both alloc function and
; the user body consume the same argument. ; the user body consume the same argument.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using this directly (as it would happen under -O2) ; using this directly (as it would happen under -O2)
define i8* @f_direct(i64 %this) "coroutine.presplit"="1" { define i8* @f_direct(i64 %this) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @myAlloc(i64 %this, i32 %size) %alloc = call i8* @myAlloc(i64 %this, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%0 = call i8 @llvm.coro.suspend(token none, i1 false) %0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup] i8 1, label %cleanup]
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) "coroutine.presplit"="1" { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br i1 %n, label %flag_true, label %flag_false br i1 %n, label %flag_true, label %flag_false
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

; Tests that if an alloca is escaped through storing the address, ; Tests that if an alloca is escaped through storing the address,
; the alloac will be put on the frame. ; the alloac will be put on the frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i32* %y = alloca i32*
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%x.alias = bitcast i64* %x to i32* %x.alias = bitcast i64* %x to i32*
Show All 40 Lines

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

; Tests that allocas escaped through function calls will live on the frame. ; Tests that allocas escaped through function calls will live on the frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%x.alias = bitcast i64* %x to i32* %x.alias = bitcast i64* %x to i32*
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) "coroutine.presplit"="1" { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
br i1 %n, label %flag_true, label %flag_false br i1 %n, label %flag_true, label %flag_false
flag_true: flag_true:
%x.alias1 = bitcast i64* %x to i32* %x.alias1 = bitcast i64* %x to i32*
br label %merge br label %merge
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

; Tests that allocas after coro.begin are properly that do not need to ; Tests that allocas after coro.begin are properly that do not need to
; live on the frame are properly moved to the .resume function. ; live on the frame are properly moved to the .resume function.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%x = alloca i32 %x = alloca i32
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false) %sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume switch i8 %sp1, label %suspend [i8 0, label %resume
Show All 39 Lines

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

; Test that in some simple cases allocas will not live on the frame even ; Test that in some simple cases allocas will not live on the frame even
; though their pointers are stored. ; though their pointers are stored.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%handle = type { i8* } %handle = type { i8* }
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%0 = alloca %"handle", align 8 %0 = alloca %"handle", align 8
%1 = alloca %"handle"*, align 8 %1 = alloca %"handle"*, align 8
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br label %tricky br label %tricky
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) "coroutine.presplit"="1" { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br i1 %n, label %flag_true, label %flag_false br i1 %n, label %flag_true, label %flag_false
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
%i8.array = type { [100 x i8] } %i8.array = type { [100 x i8] }
declare void @consume.i8.array(%i8.array*) declare void @consume.i8.array(%i8.array*)
; The lifetime of testval starts and ends before coro.suspend. Even though consume.i8.array ; The lifetime of testval starts and ends before coro.suspend. Even though consume.i8.array
; might capture it, we can safely say it won't live across suspension. ; might capture it, we can safely say it won't live across suspension.
define void @foo() "coroutine.presplit"="1" { define void @foo() presplitcoroutine {
entry: entry:
%testval = alloca %i8.array %testval = alloca %i8.array
%cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0 %cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
call void @llvm.lifetime.start.p0i8(i64 100, i8* %cast) call void @llvm.lifetime.start.p0i8(i64 100, i8* %cast)
Show All 11 Linesawait.ready:
br label %exit br label %exit
exit: exit:
call i1 @llvm.coro.end(i8* null, i1 false) call i1 @llvm.coro.end(i8* null, i1 false)
ret void ret void
} }
; The lifetime of testval starts after coro.suspend. So it will never live across suspension ; The lifetime of testval starts after coro.suspend. So it will never live across suspension
; points. ; points.
define void @bar() "coroutine.presplit"="1" { define void @bar() presplitcoroutine {
entry: entry:
%testval = alloca %i8.array %testval = alloca %i8.array
%cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0 %cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
%save = call token @llvm.coro.save(i8* null) %save = call token @llvm.coro.save(i8* null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false) %suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
Show All 32 Lines

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

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
%i8.array = type { [100 x i8] } %i8.array = type { [100 x i8] }
declare void @consume.i8(i8*) declare void @consume.i8(i8*)
; The testval lives across suspend point so that it should be put on the frame. ; The testval lives across suspend point so that it should be put on the frame.
; However, part of testval has lifetime marker which indicates the part ; However, part of testval has lifetime marker which indicates the part
; wouldn't live across suspend point. ; wouldn't live across suspend point.
; This test whether or not %testval would be put on the frame by ignoring the ; This test whether or not %testval would be put on the frame by ignoring the
; partial lifetime markers. ; partial lifetime markers.
define void @foo(%i8.array** %to_store) "coroutine.presplit"="1" { define void @foo(%i8.array** %to_store) presplitcoroutine {
entry: entry:
%testval = alloca %i8.array %testval = alloca %i8.array
%subrange = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 50 %subrange = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 50
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
call void @llvm.lifetime.start.p0i8(i64 50, i8* %subrange) call void @llvm.lifetime.start.p0i8(i64 50, i8* %subrange)
Show All 32 Lines

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

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
; CHECK: [[T5:%.*]] = getelementptr inbounds %my_async_function.Frame, %my_async_function.Frame* %FramePtr, i32 0, i32 0 ; CHECK: [[T5:%.*]] = getelementptr inbounds %my_async_function.Frame, %my_async_function.Frame* %FramePtr, i32 0, i32 0
; CHECK: [[T6:%.*]] = ptrtoint i64* [[T5]] to i64 ; CHECK: [[T6:%.*]] = ptrtoint i64* [[T5]] to i64
; CHECK: [[T7:%.*]] = add i64 [[T6]], 63 ; CHECK: [[T7:%.*]] = add i64 [[T6]], 63
; CHECK: [[T8:%.*]] = and i64 [[T7]], -64 ; CHECK: [[T8:%.*]] = and i64 [[T7]], -64
; CHECK: [[T9:%.*]] = inttoptr i64 [[T8]] to i64* ; CHECK: [[T9:%.*]] = inttoptr i64 [[T8]] to i64*
; CHECK: store i64 2, i64* [[T4]] ; CHECK: store i64 2, i64* [[T4]]
; CHECK: store i64 3, i64* [[T9]] ; CHECK: store i64 3, i64* [[T9]]
define swiftcc void @my_async_function(i8* swiftasync %async.ctxt) "coroutine.presplit"="1" { define swiftcc void @my_async_function(i8* swiftasync %async.ctxt) presplitcoroutine {
entry: entry:
%tmp = alloca i64, align 8 %tmp = alloca i64, align 8
%tmp2 = alloca i64, align 16 %tmp2 = alloca i64, align 16
%tmp3 = alloca i64, align 32 %tmp3 = alloca i64, align 32
%tmp4 = alloca i64, align 64 %tmp4 = alloca i64, align 64
%id = call token @llvm.coro.id.async(i32 32, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 32, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @my_async_function_fp to i8*)) i8* bitcast (<{i32, i32}>* @my_async_function_fp to i8*))
Show All 29 Lines

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
define i8* @resume_context_projection(i8* %ctxt) { define i8* @resume_context_projection(i8* %ctxt) {
entry: entry:
%resume_ctxt_addr = bitcast i8* %ctxt to i8** %resume_ctxt_addr = bitcast i8* %ctxt to i8**
%resume_ctxt = load i8*, i8** %resume_ctxt_addr, align 8 %resume_ctxt = load i8*, i8** %resume_ctxt_addr, align 8
ret i8* %resume_ctxt ret i8* %resume_ctxt
} }
define swiftcc void @my_async_function(i8* swiftasync %async.ctxt, %async.task* %task, %async.actor* %actor) "coroutine.presplit"="1" !dbg !1 { define swiftcc void @my_async_function(i8* swiftasync %async.ctxt, %async.task* %task, %async.actor* %actor) presplitcoroutine !dbg !1 {
entry: entry:
%tmp = alloca { i64, i64 }, align 8 %tmp = alloca { i64, i64 }, align 8
%vector = alloca <4 x double>, align 16 %vector = alloca <4 x double>, align 16
%proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0 %proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0
%proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1 %proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @my_async_function_fp to i8*)) i8* bitcast (<{i32, i32}>* @my_async_function_fp to i8*))
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines <{ i32 trunc ( ; Relative pointer to async function
i64 sub ( i64 sub (
i64 ptrtoint (void (%async.task*, %async.actor*, i8*)* @my_async_function2 to i64), i64 ptrtoint (void (%async.task*, %async.actor*, i8*)* @my_async_function2 to i64),
i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @my_async_function2_fp, i32 0, i32 1) to i64) i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @my_async_function2_fp, i32 0, i32 1) to i64)
) )
to i32), to i32),
i32 128 ; Initial async context size without space for frame i32 128 ; Initial async context size without space for frame
}> }>
define swiftcc void @my_async_function2(%async.task* %task, %async.actor* %actor, i8* %async.ctxt) "coroutine.presplit"="1" "frame-pointer"="all" !dbg !6 { define swiftcc void @my_async_function2(%async.task* %task, %async.actor* %actor, i8* %async.ctxt) presplitcoroutine "frame-pointer"="all" !dbg !6 {
entry: entry:
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 2, i8* bitcast (<{i32, i32}>* @my_async_function2_fp to i8*)) %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 2, i8* bitcast (<{i32, i32}>* @my_async_function2_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
; setup callee context ; setup callee context
%arg0 = bitcast %async.task* %task to i8* %arg0 = bitcast %async.task* %task to i8*
%arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8* %arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8*
%callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1) %callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1)
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Linesis_null:
ret void ret void
is_not_null: is_not_null:
%callee = bitcast i8* %fnPtr to void(i8*, %async.task*, %async.actor*)* %callee = bitcast i8* %fnPtr to void(i8*, %async.task*, %async.actor*)*
tail call swiftcc void %callee(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) tail call swiftcc void %callee(i8* %async.ctxt, %async.task* %task, %async.actor* %actor)
ret void ret void
} }
define swiftcc void @dont_crash_on_cf(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) "coroutine.presplit"="1" { define swiftcc void @dont_crash_on_cf(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @dont_crash_on_cf_fp to i8*)) i8* bitcast (<{i32, i32}>* @dont_crash_on_cf_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%arg0 = bitcast %async.task* %task to i8* %arg0 = bitcast %async.task* %task to i8*
%arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8* %arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8*
%callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1) %callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1)
%callee_context.0 = bitcast i8* %callee_context to %async.ctxt* %callee_context.0 = bitcast i8* %callee_context to %async.ctxt*
Show All 29 Lines <{ i32 trunc ( ; Relative pointer to async function
i32 128 ; Initial async context size without space for frame i32 128 ; Initial async context size without space for frame
}> }>
define swiftcc void @must_tail_call_return(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) { define swiftcc void @must_tail_call_return(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) {
musttail call swiftcc void @asyncReturn(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) musttail call swiftcc void @asyncReturn(i8* %async.ctxt, %async.task* %task, %async.actor* %actor)
ret void ret void
} }
define swiftcc void @multiple_coro_end_async(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) "coroutine.presplit"="1" { define swiftcc void @multiple_coro_end_async(i8* %async.ctxt, %async.task* %task, %async.actor* %actor) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @dont_crash_on_cf_fp to i8*)) i8* bitcast (<{i32, i32}>* @dont_crash_on_cf_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%arg0 = bitcast %async.task* %task to i8* %arg0 = bitcast %async.task* %task to i8*
%arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8* %arg1 = bitcast <{ i32, i32}>* @my_other_async_function_fp to i8*
%callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1) %callee_context = call i8* @llvm.coro.async.context.alloc(i8* %arg0, i8* %arg1)
%callee_context.0 = bitcast i8* %callee_context to %async.ctxt* %callee_context.0 = bitcast i8* %callee_context to %async.ctxt*
Show All 39 Lines <{ i32 trunc ( ; Relative pointer to async function
i64 sub ( i64 sub (
i64 ptrtoint (void (i8*, %async.task*, %async.actor*)* @polymorphic_suspend_return to i64), i64 ptrtoint (void (i8*, %async.task*, %async.actor*)* @polymorphic_suspend_return to i64),
i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @polymorphic_suspend_return_fp, i32 0, i32 1) to i64) i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @polymorphic_suspend_return_fp, i32 0, i32 1) to i64)
) )
to i32), to i32),
i32 64 ; Initial async context size without space for frame i32 64 ; Initial async context size without space for frame
}> }>
define swiftcc void @polymorphic_suspend_return(i8* swiftasync %async.ctxt, %async.task* %task, %async.actor* %actor) "coroutine.presplit"="1" { define swiftcc void @polymorphic_suspend_return(i8* swiftasync %async.ctxt, %async.task* %task, %async.actor* %actor) presplitcoroutine {
entry: entry:
%tmp = alloca { i64, i64 }, align 8 %tmp = alloca { i64, i64 }, align 8
%proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0 %proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0
%proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1 %proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @polymorphic_suspend_return_fp to i8*)) i8* bitcast (<{i32, i32}>* @polymorphic_suspend_return_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines <{ i32 trunc ( ; Relative pointer to async function
i64 sub ( i64 sub (
i64 ptrtoint (void (i8*)* @no_coro_suspend to i64), i64 ptrtoint (void (i8*)* @no_coro_suspend to i64),
i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @no_coro_suspend_fp, i32 0, i32 1) to i64) i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @no_coro_suspend_fp, i32 0, i32 1) to i64)
) )
to i32), to i32),
i32 128 ; Initial async context size without space for frame i32 128 ; Initial async context size without space for frame
}> }>
define swiftcc void @no_coro_suspend(i8* %async.ctx) "coroutine.presplit"="1" { define swiftcc void @no_coro_suspend(i8* %async.ctx) presplitcoroutine {
entry: entry:
%some_alloca = alloca i64 %some_alloca = alloca i64
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @no_coro_suspend_fp to i8*)) i8* bitcast (<{i32, i32}>* @no_coro_suspend_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
call void @some_may_write(i64* %some_alloca) call void @some_may_write(i64* %some_alloca)
call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 0) call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 0)
unreachable unreachable
Show All 10 Lines <{ i32 trunc ( ; Relative pointer to async function
i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @no_coro_suspend_swifterror_fp, i32 0, i32 1) to i64) i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @no_coro_suspend_swifterror_fp, i32 0, i32 1) to i64)
) )
to i32), to i32),
i32 128 ; Initial async context size without space for frame i32 128 ; Initial async context size without space for frame
}> }>
declare void @do_with_swifterror(i64** swifterror) declare void @do_with_swifterror(i64** swifterror)
define swiftcc void @no_coro_suspend_swifterror(i8* %async.ctx) "coroutine.presplit"="1" { define swiftcc void @no_coro_suspend_swifterror(i8* %async.ctx) presplitcoroutine {
entry: entry:
%some_alloca = alloca swifterror i64* %some_alloca = alloca swifterror i64*
%id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0, %id = call token @llvm.coro.id.async(i32 128, i32 16, i32 0,
i8* bitcast (<{i32, i32}>* @no_coro_suspend_swifterror_fp to i8*)) i8* bitcast (<{i32, i32}>* @no_coro_suspend_swifterror_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
store i64* null, i64** %some_alloca, align 8 store i64* null, i64** %some_alloca, align 8
call void @do_with_swifterror(i64** swifterror %some_alloca) call void @do_with_swifterror(i64** swifterror %some_alloca)
call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 0) call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 0)
Show All 13 Lines <{ i32 trunc (
) )
to i32), to i32),
i32 24 i32 24
}> }>
declare void @crash() declare void @crash()
declare void @use(i8*) declare void @use(i8*)
define swiftcc void @undefined_coro_async_resume(i8 *%async.ctx) "coroutine.presplit"="1" { define swiftcc void @undefined_coro_async_resume(i8 *%async.ctx) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id.async(i32 24, i32 16, i32 0, i8* bitcast (<{i32, i32}>* @undefined_coro_async_resume_fp to i8*)) %id = call token @llvm.coro.id.async(i32 24, i32 16, i32 0, i8* bitcast (<{i32, i32}>* @undefined_coro_async_resume_fp to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%undefined_resume_pointer = call i8* @llvm.coro.async.resume() %undefined_resume_pointer = call i8* @llvm.coro.async.resume()
call void @use(i8* %undefined_resume_pointer) call void @use(i8* %undefined_resume_pointer)
call void @crash() call void @crash()
%unused = call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 false) %unused = call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 false)
unreachable unreachable
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
; Function Attrs: nobuiltin nounwind ; Function Attrs: nobuiltin nounwind
declare void @_ZdlPv(i8*) local_unnamed_addr #8 declare void @_ZdlPv(i8*) local_unnamed_addr #8
; Function Attrs: argmemonly nounwind readonly ; Function Attrs: argmemonly nounwind readonly
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
attributes #0 = { noinline ssp uwtable mustprogress "coroutine.presplit"="1" "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" } attributes #0 = { noinline ssp uwtable mustprogress presplitcoroutine "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nobuiltin nofree allocsize(0) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" } attributes #3 = { nobuiltin nofree allocsize(0) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind readnone } attributes #4 = { nounwind readnone }
attributes #5 = { argmemonly nofree nosync nounwind willreturn } attributes #5 = { argmemonly nofree nosync nounwind willreturn }
attributes #6 = { argmemonly nofree nounwind willreturn } attributes #6 = { argmemonly nofree nounwind willreturn }
attributes #7 = { noinline nounwind ssp uwtable willreturn mustprogress "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" } attributes #7 = { noinline nounwind ssp uwtable willreturn mustprogress "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" }
attributes #8 = { nobuiltin nounwind "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" } attributes #8 = { nobuiltin nounwind "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-cpu"="generic" }
attributes #9 = { allocsize(0) } attributes #9 = { allocsize(0) }
attributes #10 = { noduplicate } attributes #10 = { noduplicate }

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

; Tests the PHI nodes in cleanuppads for catchswitch instructions are correctly ; Tests the PHI nodes in cleanuppads for catchswitch instructions are correctly
; split up. ; split up.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg<switch-range-to-icmp>,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg<switch-range-to-icmp>,early-cse' -S | FileCheck %s
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
define i8* @f2(i1 %val) "coroutine.presplit"="1" personality i32 (...)* @__CxxFrameHandler3 { define i8* @f2(i1 %val) presplitcoroutine personality i32 (...)* @__CxxFrameHandler3 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%valueA = call i32 @f(); %valueA = call i32 @f();
%valueB = call i32 @f(); %valueB = call i32 @f();
%need.alloc = call i1 @llvm.coro.alloc(token %id) %need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %dowork.0 br i1 %need.alloc, label %dyn.alloc, label %dowork.0
dyn.alloc: dyn.alloc:
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

; Verifies that we can insert the spill for a PHI preceding the catchswitch ; Verifies that we can insert the spill for a PHI preceding the catchswitch
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" 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" target triple = "i686-pc-windows-msvc"
; CHECK-LABEL: define void @f( ; CHECK-LABEL: define void @f(
define void @f(i1 %cond) "coroutine.presplit"="1" personality i32 0 { define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 8, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 8, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br i1 %cond, label %if.else, label %if.then br i1 %cond, label %if.else, label %if.then
if.then: if.then:
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s
; Checks whether the dbg.declare for `__promise` remains valid under O2. ; Checks whether the dbg.declare for `__promise` remains valid under O2.
; CHECK-LABEL: define internal fastcc void @f.resume({{.*}}) ; CHECK-LABEL: define internal fastcc void @f.resume({{.*}})
; CHECK: entry.resume: ; CHECK: entry.resume:
; CHECK: call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression( ; CHECK: call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
; ;
; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise" ; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise"
%promise_type = type { i32, i32, double } %promise_type = type { i32, i32, double }
define void @f() "coroutine.presplit"="0" !dbg !8 { define void @f() presplitcoroutine !dbg !8 {
entry: entry:
%__promise = alloca %promise_type, align 8 %__promise = alloca %promise_type, align 8
%0 = bitcast %promise_type* %__promise to i8* %0 = bitcast %promise_type* %__promise to i8*
%id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
%alloc = call i1 @llvm.coro.alloc(token %id) %alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry coro.alloc: ; preds = %entry
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
%promise_type = type { i32, i32, double } %promise_type = type { i32, i32, double }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
declare void @produce(%struct.big_structure*) declare void @produce(%struct.big_structure*)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @pi32(i32*) declare void @pi32(i32*)
declare void @pi64(i64*) declare void @pi64(i64*)
declare void @pdouble(double*) declare void @pdouble(double*)
define void @f(i32 %a, i32 %b, i64 %c, double %d) "coroutine.presplit"="0" !dbg !8 { define void @f(i32 %a, i32 %b, i64 %c, double %d) presplitcoroutine !dbg !8 {
entry: entry:
%__promise = alloca %promise_type, align 8 %__promise = alloca %promise_type, align 8
%0 = bitcast %promise_type* %__promise to i8* %0 = bitcast %promise_type* %__promise to i8*
%a.alloc = alloca i32, align 4 %a.alloc = alloca i32, align 4
%b.alloc = alloca i32, align 4 %b.alloc = alloca i32, align 4
%c.alloc = alloca i64, align 4 %c.alloc = alloca i64, align 4
%d.alloc = alloca double, align 4 %d.alloc = alloca double, align 4
store i32 %a, i32* %a.alloc store i32 %a, i32* %a.alloc
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Linescoro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
%end = call i1 @llvm.coro.end(i8* null, i1 false) %end = call i1 @llvm.coro.end(i8* null, i1 false)
ret void ret void
unreachable: ; preds = %after.coro.free unreachable: ; preds = %after.coro.free
unreachable unreachable
} }
define void @bar(i32 %a, i64 %c, double %d) "coroutine.presplit"="0" !dbg !19 { define void @bar(i32 %a, i64 %c, double %d) presplitcoroutine !dbg !19 {
entry: entry:
%__promise = alloca %promise_type, align 8 %__promise = alloca %promise_type, align 8
%0 = bitcast %promise_type* %__promise to i8* %0 = bitcast %promise_type* %__promise to i8*
%a.alloc = alloca i32, align 4 %a.alloc = alloca i32, align 4
%c.alloc = alloca i64, align 4 %c.alloc = alloca i64, align 4
%d.alloc = alloca double, align 4 %d.alloc = alloca double, align 4
store i32 %a, i32* %a.alloc store i32 %a, i32* %a.alloc
store i64 %c, i64* %c.alloc store i64 %c, i64* %c.alloc
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

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

Show All 37 Lines
; CHECK-DAG: ![[ZVAR_DESTROY]] = !DILocalVariable(name: "z" ; CHECK-DAG: ![[ZVAR_DESTROY]] = !DILocalVariable(name: "z"
; CHECK-DAG: ![[XVAR_CLEANUP]] = !DILocalVariable(name: "x" ; CHECK-DAG: ![[XVAR_CLEANUP]] = !DILocalVariable(name: "x"
; CHECK-DAG: ![[YVAR_CLEANUP]] = !DILocalVariable(name: "y" ; CHECK-DAG: ![[YVAR_CLEANUP]] = !DILocalVariable(name: "y"
; CHECK-DAG: ![[ZVAR_CLEANUP]] = !DILocalVariable(name: "z" ; CHECK-DAG: ![[ZVAR_CLEANUP]] = !DILocalVariable(name: "z"
source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll" source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll"
declare void @consume(i32) declare void @consume(i32)
define void @f(i32 %i, i32 %j, i8* %ptr) "coroutine.presplit"="0" !dbg !8 { define void @f(i32 %i, i32 %j, i8* %ptr) presplitcoroutine !dbg !8 {
entry: entry:
%__promise = alloca i8, align 8 %__promise = alloca i8, align 8
%x = alloca [10 x i32], align 16 %x = alloca [10 x i32], align 16
%produced = call i32 @value_producer() %produced = call i32 @value_producer()
%id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
%alloc = call i1 @llvm.coro.alloc(token %id) %alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init br i1 %alloc, label %coro.alloc, label %coro.init
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

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. ; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame.
; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; ;
; This file is based on coro-debug-frame-variable.ll. ; 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: 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: 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 ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_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" ; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i" ; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
; CHECK: ![[JVAR_RESUME]] = !DILocalVariable(name: "j" ; CHECK: ![[JVAR_RESUME]] = !DILocalVariable(name: "j"
source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll" source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll"
define void @f(i32 %i, i32 %j) "coroutine.presplit"="0" !dbg !8 { define void @f(i32 %i, i32 %j) presplitcoroutine !dbg !8 {
entry: entry:
%__promise = alloca i8, align 8 %__promise = alloca i8, align 8
%x = alloca [10 x i32], align 16 %x = alloca [10 x i32], align 16
%id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
%alloc = call i1 @llvm.coro.alloc(token %id) %alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry coro.alloc: ; preds = %entry
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

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

Show All 13 Lines
; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i" ; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
; CHECK: ![[XVAR_RESUME]] = !DILocalVariable(name: "x" ; CHECK: ![[XVAR_RESUME]] = !DILocalVariable(name: "x"
; CHECK: ![[JVAR_RESUME]] = !DILocalVariable(name: "j" ; CHECK: ![[JVAR_RESUME]] = !DILocalVariable(name: "j"
; CHECK: ![[SPILL_RESUME]] = !DILocalVariable(name: "produced" ; CHECK: ![[SPILL_RESUME]] = !DILocalVariable(name: "produced"
source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll" source_filename = "../llvm/test/Transforms/Coroutines/coro-debug-dbg.values-O2.ll"
declare void @consume(i32) declare void @consume(i32)
define void @f(i32 %i, i32 %j) "coroutine.presplit"="0" !dbg !8 { define void @f(i32 %i, i32 %j) presplitcoroutine !dbg !8 {
entry: entry:
%__promise = alloca i8, align 8 %__promise = alloca i8, align 8
%x = alloca [10 x i32], align 16 %x = alloca [10 x i32], align 16
%produced = call i32 @value_producer() %produced = call i32 @value_producer()
%id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
%alloc = call i1 @llvm.coro.alloc(token %id) %alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init br i1 %alloc, label %coro.alloc, label %coro.init
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
; CHECK-DAG: ![[JDBGLOC]] = !DILocation(line: 32, column: 7, scope: ![[SCOPE]]) ; CHECK-DAG: ![[JDBGLOC]] = !DILocation(line: 32, column: 7, scope: ![[SCOPE]])
; CHECK-DAG: ![[XVAR_RESUME]] = !DILocalVariable(name: "x" ; CHECK-DAG: ![[XVAR_RESUME]] = !DILocalVariable(name: "x"
; CHECK-DAG: ![[IDBGLOC_RESUME]] = !DILocation(line: 24, column: 7, scope: ![[RESUME_SCOPE:[0-9]+]]) ; CHECK-DAG: ![[IDBGLOC_RESUME]] = !DILocation(line: 24, column: 7, scope: ![[RESUME_SCOPE:[0-9]+]])
; CHECK-DAG: ![[RESUME_SCOPE]] = distinct !DILexicalBlock(scope: !8, file: !1, line: 23, column: 12) ; CHECK-DAG: ![[RESUME_SCOPE]] = distinct !DILexicalBlock(scope: !8, file: !1, line: 23, column: 12)
; CHECK-DAG: ![[IVAR_RESUME]] = !DILocalVariable(name: "i" ; CHECK-DAG: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
; CHECK-DAG: ![[JVAR_RESUME]] = !DILocalVariable(name: "j" ; CHECK-DAG: ![[JVAR_RESUME]] = !DILocalVariable(name: "j"
; CHECK-DAG: ![[JDBGLOC_RESUME]] = !DILocation(line: 32, column: 7, scope: ![[RESUME_SCOPE]]) ; CHECK-DAG: ![[JDBGLOC_RESUME]] = !DILocation(line: 32, column: 7, scope: ![[RESUME_SCOPE]])
define void @f() "coroutine.presplit"="0" { define void @f() presplitcoroutine {
entry: entry:
%__promise = alloca i8, align 8 %__promise = alloca i8, align 8
%i = alloca i32, align 4 %i = alloca i32, align 4
%j = alloca i32, align 4 %j = alloca i32, align 4
%x = alloca [10 x i32], align 16 %x = alloca [10 x i32], align 16
%id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
%alloc = call i1 @llvm.coro.alloc(token %id) %alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init br i1 %alloc, label %coro.alloc, label %coro.init
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
define private void @coro.devirt.trigger(i8*) #6 { define private void @coro.devirt.trigger(i8*) #6 {
entry: entry:
ret void ret void
} }
; Function Attrs: argmemonly nounwind readonly ; Function Attrs: argmemonly nounwind readonly
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #2 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #2
attributes #0 = { noinline nounwind "coroutine.presplit"="1" "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { noinline nounwind presplitcoroutine "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone speculatable } attributes #1 = { nounwind readnone speculatable }
attributes #2 = { argmemonly nounwind readonly } attributes #2 = { argmemonly nounwind readonly }
attributes #3 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #3 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #4 = { nounwind readnone } attributes #4 = { nounwind readnone }
attributes #5 = { nounwind } attributes #5 = { nounwind }
attributes #6 = { alwaysinline } attributes #6 = { alwaysinline }
attributes #7 = { noduplicate } attributes #7 = { noduplicate }
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @f.resume( ; CHECK-LABEL: define internal fastcc void @f.resume(
define void @f(i1 %cond) "coroutine.presplit"="1" personality i32 0 { define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
%size = tail call i64 @llvm.coro.size.i64() %size = tail call i64 @llvm.coro.size.i64()
%alloc = call i8* @malloc(i64 %size) %alloc = call i8* @malloc(i64 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false) %sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [ switch i8 %sp, label %coro.ret [
i8 0, label %resume i8 0, label %resume
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @g.resume( ; CHECK-LABEL: define internal fastcc void @g.resume(
define void @g(i1 %cond, i32 %x, i32 %y) "coroutine.presplit"="1" personality i32 0 { define void @g(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
%size = tail call i64 @llvm.coro.size.i64() %size = tail call i64 @llvm.coro.size.i64()
%alloc = call i8* @malloc(i64 %size) %alloc = call i8* @malloc(i64 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false) %sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [ switch i8 %sp, label %coro.ret [
i8 0, label %resume i8 0, label %resume
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @h.resume( ; CHECK-LABEL: define internal fastcc void @h.resume(
define void @h(i1 %cond, i32 %x, i32 %y) "coroutine.presplit"="1" personality i32 0 { define void @h(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
%size = tail call i64 @llvm.coro.size.i64() %size = tail call i64 @llvm.coro.size.i64()
%alloc = call i8* @malloc(i64 %size) %alloc = call i8* @malloc(i64 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false) %sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [ switch i8 %sp, label %coro.ret [
i8 0, label %resume i8 0, label %resume
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

; Check that we can handle spills of array allocas ; Check that we can handle spills of array allocas
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
declare void @consume.double.ptr(double*) declare void @consume.double.ptr(double*)
declare void @consume.i32.ptr(i32*) declare void @consume.i32.ptr(i32*)
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%prefix = alloca double %prefix = alloca double
%data = alloca i32, i32 4 %data = alloca i32, i32 4
%suffix = alloca double %suffix = alloca double
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

; Check that we can handle spills of array allocas ; Check that we can handle spills of array allocas
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
; Function Attrs: noinline optnone uwtable ; Function Attrs: noinline optnone uwtable
define i8* @f(i1 %cond) "coroutine.presplit"="1" { define i8* @f(i1 %cond) presplitcoroutine {
entry: entry:
%data = alloca %struct.big_structure, align 1 %data = alloca %struct.big_structure, align 1
%data2 = alloca %struct.big_structure, align 1 %data2 = alloca %struct.big_structure, align 1
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br i1 %cond, label %then, label %else br i1 %cond, label %then, label %else
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; Tests that variables in a Corotuine whose lifetime range is not overlapping each other ; Tests that variables in a Corotuine whose lifetime range is not overlapping each other
; re-use the same slot in Coroutine frame. ; re-use the same slot in Coroutine frame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
define void @a(i1 zeroext %cond) "coroutine.presplit"="1" { define void @a(i1 zeroext %cond) presplitcoroutine {
entry: entry:
%__promise = alloca %"struct.task::promise_type", align 1 %__promise = alloca %"struct.task::promise_type", align 1
%a = alloca %struct.big_structure, align 1 %a = alloca %struct.big_structure, align 1
%ref.tmp7 = alloca %struct.awaitable, align 1 %ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure, align 1 %b = alloca %struct.big_structure, align 1
%ref.tmp18 = alloca %struct.awaitable, align 1 %ref.tmp18 = alloca %struct.awaitable, align 1
%0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0 %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
%1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null) %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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 ; 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. ; re-use the same slot in Coroutine frame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] } %struct.big_structure.2 = type { [300 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) "coroutine.presplit"="1" { define void @a(i1 zeroext %cond) presplitcoroutine {
entry: entry:
%__promise = alloca %"struct.task::promise_type", align 1 %__promise = alloca %"struct.task::promise_type", align 1
%a = alloca %struct.big_structure, align 1 %a = alloca %struct.big_structure, align 1
%ref.tmp7 = alloca %struct.awaitable, align 1 %ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 1 %b = alloca %struct.big_structure.2, align 1
%ref.tmp18 = alloca %struct.awaitable, align 1 %ref.tmp18 = alloca %struct.awaitable, align 1
%0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0 %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
%1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null) %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; Check that we should not reuse alloca sotrage in O0. ; Check that we should not reuse alloca sotrage in O0.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
; Function Attrs: noinline optnone uwtable ; Function Attrs: noinline optnone uwtable
define i8* @f(i1 %cond) "coroutine.presplit"="1" { define i8* @f(i1 %cond) presplitcoroutine {
entry: entry:
%data = alloca %struct.big_structure, align 1 %data = alloca %struct.big_structure, align 1
%data2 = alloca %struct.big_structure, align 1 %data2 = alloca %struct.big_structure, align 1
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br i1 %cond, label %then, label %else br i1 %cond, label %then, label %else
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; Tests that variables of different type with incompatible alignment in a Corotuine whose lifetime ; 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. ; range is not overlapping each other should not re-use the same slot in Coroutine frame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] } %struct.big_structure.2 = type { [300 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) "coroutine.presplit"="1" { define void @a(i1 zeroext %cond) presplitcoroutine {
entry: entry:
%__promise = alloca %"struct.task::promise_type", align 1 %__promise = alloca %"struct.task::promise_type", align 1
%a = alloca %struct.big_structure, align 1 %a = alloca %struct.big_structure, align 1
%ref.tmp7 = alloca %struct.awaitable, align 1 %ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 32 %b = alloca %struct.big_structure.2, align 32
%ref.tmp18 = alloca %struct.awaitable, align 1 %ref.tmp18 = alloca %struct.awaitable, align 1
%0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0 %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
%1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null) %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; Tests that variables of different type with incompatible alignment in a Corotuine whose ; 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. ; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [400 x i8] } %struct.big_structure.2 = type { [400 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) "coroutine.presplit"="1" { define void @a(i1 zeroext %cond) presplitcoroutine {
entry: entry:
%__promise = alloca %"struct.task::promise_type", align 1 %__promise = alloca %"struct.task::promise_type", align 1
%a = alloca %struct.big_structure, align 32 %a = alloca %struct.big_structure, align 32
%ref.tmp7 = alloca %struct.awaitable, align 1 %ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 16 %b = alloca %struct.big_structure.2, align 16
%ref.tmp18 = alloca %struct.awaitable, align 1 %ref.tmp18 = alloca %struct.awaitable, align 1
%0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0 %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
%1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null) %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; Check that coro-split doesn't choke on intrinsics in unreachable blocks ; Check that coro-split doesn't choke on intrinsics in unreachable blocks
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S
define i8* @f(i1 %arg) "coroutine.presplit"="1" personality i32 0 { define i8* @f(i1 %arg) presplitcoroutine personality i32 0 {
entry: entry:
%arg.addr = alloca i1 %arg.addr = alloca i1
store i1 %arg, i1* %arg.addr store i1 %arg, i1* %arg.addr
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br label %cont br label %cont
Show All 38 Lines

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

; Check that we can handle spills of the result of the invoke instruction ; Check that we can handle spills of the result of the invoke instruction
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i64 %this) "coroutine.presplit"="1" personality i32 0 { define i8* @f(i64 %this) presplitcoroutine personality i32 0 {
entry: entry:
%this.addr = alloca i64 %this.addr = alloca i64
store i64 %this, i64* %this.addr store i64 %this, i64* %this.addr
%this1 = load i64, i64* %this.addr %this1 = load i64, i64* %this.addr
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show All 18 Lines
} }
; CHECK-LABEL: define void @foo() ; CHECK-LABEL: define void @foo()
; CHECK: call void @ff() ; CHECK: call void @ff()
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
declare i8* @llvm.coro.begin(token, i8* writeonly) declare i8* @llvm.coro.begin(token, i8* writeonly)
attributes #0 = { alwaysinline ssp uwtable "coroutine.presplit"="1" "use-sample-profile" } attributes #0 = { alwaysinline ssp uwtable presplitcoroutine "use-sample-profile" }
!llvm.dbg.cu = !{} !llvm.dbg.cu = !{}
!llvm.module.flags = !{!1, !2, !3, !4} !llvm.module.flags = !{!1, !2, !3, !4}
!1 = !{i32 7, !"Dwarf Version", i32 4} !1 = !{i32 7, !"Dwarf Version", i32 4}
!2 = !{i32 2, !"Debug Info Version", i32 3} !2 = !{i32 2, !"Debug Info Version", i32 3}
!3 = !{i32 1, !"wchar_size", i32 4} !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 ; Verifies that we materialize instruction across suspend points
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="1" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%inc1 = add i32 %n, 1 %inc1 = add i32 %n, 1
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false) %sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
Show All 40 Lines

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

; RUN: opt < %s -S -passes=coro-early | FileCheck %s ; RUN: opt < %s -S -passes=coro-early | FileCheck %s
%struct.A = type <{ i64, i64, i32, [4 x i8] }> %struct.A = type <{ i64, i64, i32, [4 x i8] }>
define void @f(%struct.A* nocapture readonly noalias align 8 %a) "coroutine.presplit"="0" { define void @f(%struct.A* nocapture readonly noalias align 8 %a) presplitcoroutine {
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
call void @print(i32 0) call void @print(i32 0)
%s1 = call i8 @llvm.coro.suspend(token none, i1 false) %s1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %s1, label %suspend [i8 0, label %resume switch i8 %s1, label %suspend [i8 0, label %resume
i8 1, label %cleanup] i8 1, label %cleanup]
Show All 28 Lines

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

; Check that we will insert the correct padding if natural alignment of the ; Check that we will insert the correct padding if natural alignment of the
; spilled data does not match the alignment specified in alloca instruction. ; spilled data does not match the alignment specified in alloca instruction.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%PackedStruct = type <{ i64 }> %PackedStruct = type <{ i64 }>
declare void @consume(%PackedStruct*) declare void @consume(%PackedStruct*)
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%data = alloca %PackedStruct, align 32 %data = alloca %PackedStruct, align 32
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
call void @consume(%PackedStruct* %data) call void @consume(%PackedStruct* %data)
%0 = call i8 @llvm.coro.suspend(token none, i1 false) %0 = call i8 @llvm.coro.suspend(token none, i1 false)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; Check that we create copy the data from the alloca into the coroutine ; Check that we create copy the data from the alloca into the coroutine
; frame slot if it was written to. ; frame slot if it was written to.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%a.addr = alloca i64 ; read-only before coro.begin %a.addr = alloca i64 ; read-only before coro.begin
%a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy %a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy
%x.addr = alloca i64 %x.addr = alloca i64
call void @use(i64* %x.addr) ; uses %x.addr before coro.begin call void @use(i64* %x.addr) ; uses %x.addr before coro.begin
%y.addr = alloca i64 %y.addr = alloca i64
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

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

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
declare void @prototype_f(i8*, i1) declare void @prototype_f(i8*, i1)
declare noalias i8* @allocate(i32 %size) declare noalias i8* @allocate(i32 %size)
declare void @deallocate(i8* %ptr) declare void @deallocate(i8* %ptr)
declare void @init(i64 *%ptr) declare void @init(i64 *%ptr)
declare void @use(i8* %ptr) declare void @use(i8* %ptr)
declare void @use_addr_val(i64 %val, {i64, i64}*%addr) declare void @use_addr_val(i64 %val, {i64, i64}*%addr)
define { i8*, {i64, i64}* } @f(i8* %buffer) "coroutine.presplit"="1" { define { i8*, {i64, i64}* } @f(i8* %buffer) presplitcoroutine {
entry: entry:
%tmp = alloca { i64, i64 }, align 8 %tmp = alloca { i64, i64 }, align 8
%proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0 %proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0
%proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1 %proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1
store i64 0, i64* %proj.1, align 8 store i64 0, i64* %proj.1, align 8
store i64 0, i64* %proj.2, align 8 store i64 0, i64* %proj.2, align 8
%cast = bitcast { i64, i64 }* %tmp to i8* %cast = bitcast { i64, i64 }* %tmp to i8*
%escape_addr = ptrtoint {i64, i64}* %tmp to i64 %escape_addr = ptrtoint {i64, i64}* %tmp to i64
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,coro-cleanup' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,coro-cleanup' -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* %ptr) "coroutine.presplit"="1" { define {i8*, i32*} @f(i8* %buffer, i32* %ptr) presplitcoroutine {
entry: entry:
%temp = alloca i32, align 4 %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*)) %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)
%oldvalue = load i32, i32* %ptr %oldvalue = load i32, i32* %ptr
store i32 %oldvalue, i32* %temp store i32 %oldvalue, i32* %temp
%unwind = call i1 (...) @llvm.coro.suspend.retcon.i1(i32* %temp) %unwind = call i1 (...) @llvm.coro.suspend.retcon.i1(i32* %temp)
br i1 %unwind, label %cleanup, label %cont br i1 %unwind, label %cleanup, label %cont
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg,coro-cleanup' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg,coro-cleanup' -S | FileCheck %s
define i8* @f(i8* %buffer, i32 %n) "coroutine.presplit"="1" { define i8* @f(i8* %buffer, i32 %n) presplitcoroutine {
entry: 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*)) %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) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%value0 = call i32 (...) @llvm.coro.suspend.retcon.i32() %value0 = call i32 (...) @llvm.coro.suspend.retcon.i32()
%sum0 = call i32 @add(i32 %n, i32 %value0) %sum0 = call i32 @add(i32 %n, i32 %value0)
%value1 = call i32 (...) @llvm.coro.suspend.retcon.i32() %value1 = call i32 (...) @llvm.coro.suspend.retcon.i32()
%sum1 = call i32 @add(i32 %sum0, i32 %value0) %sum1 = call i32 @add(i32 %sum0, i32 %value0)
%sum2 = call i32 @add(i32 %sum1, i32 %value1) %sum2 = call i32 @add(i32 %sum1, i32 %value1)
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Verifies that we insert spills of PHI instruction _after) all PHI Nodes ; Verifies that we insert spills of PHI instruction _after) all PHI Nodes
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
; Verifies that the both phis are stored correctly in the coroutine frame ; Verifies that the both phis are stored correctly in the coroutine frame
; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i32, i1 } ; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i32, i1 }
define i8* @f(i1 %n) "coroutine.presplit"="1" { define i8* @f(i1 %n) presplitcoroutine {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; 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: [[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: [[ALLOC:%.*]] = call i8* @malloc(i32 32) ; CHECK-NEXT: [[ALLOC:%.*]] = call i8* @malloc(i32 32)
; CHECK-NEXT: [[HDL:%.*]] = call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[ALLOC]]) ; CHECK-NEXT: [[HDL:%.*]] = call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[ALLOC]])
; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[HDL]] to %f.Frame* ; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[HDL]] to %f.Frame*
; CHECK-NEXT: [[RESUME_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], %f.Frame* [[FRAMEPTR]], i32 0, i32 0 ; CHECK-NEXT: [[RESUME_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], %f.Frame* [[FRAMEPTR]], i32 0, i32 0
; CHECK-NEXT: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** [[RESUME_ADDR]], align 8 ; CHECK-NEXT: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** [[RESUME_ADDR]], align 8
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

; Check that we can spills coro.begin from an inlined inner coroutine. ; Check that we can spills coro.begin from an inlined inner coroutine.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%g.Frame = type { void (%g.Frame*)*, void (%g.Frame*)*, i32, i1, i32 } %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] @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*) declare void @g.dummy(%g.Frame*)
declare i8* @g() declare i8* @g()
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%innerid = call token @llvm.coro.id(i32 0, i8* null, i8* bitcast (i8* ()* @g to i8*), i8* bitcast ([3 x void (%g.Frame*)*]* @g.resumers to i8*)) %innerid = call token @llvm.coro.id(i32 0, i8* null, i8* bitcast (i8* ()* @g to i8*), i8* bitcast ([3 x void (%g.Frame*)*]* @g.resumers to i8*))
%innerhdl = call noalias nonnull i8* @llvm.coro.begin(token %innerid, i8* null) %innerhdl = call noalias nonnull i8* @llvm.coro.begin(token %innerid, i8* null)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

; Verifies that phi and invoke definitions before CoroBegin are spilled properly. ; Verifies that phi and invoke definitions before CoroBegin are spilled properly.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
define i8* @f(i1 %n) "coroutine.presplit"="1" personality i32 0 { define i8* @f(i1 %n) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%flag = call i1 @check(i8* %alloc) %flag = call i1 @check(i8* %alloc)
br i1 %flag, label %flag_true, label %flag_false br i1 %flag, label %flag_true, label %flag_false
flag_true: flag_true:
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

; Check that promise object is reloaded from the correct index of the coro frame. ; Check that promise object is reloaded from the correct index of the coro frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"class.task::promise_type" = type { [64 x i8] } %"class.task::promise_type" = type { [64 x i8] }
declare void @consume(i32*) declare void @consume(i32*)
declare void @consume2(%"class.task::promise_type"*) declare void @consume2(%"class.task::promise_type"*)
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%data = alloca i32, align 4 %data = alloca i32, align 4
%__promise = alloca %"class.task::promise_type", align 64 %__promise = alloca %"class.task::promise_type", align 64
%pv = bitcast %"class.task::promise_type"* %__promise to i8* %pv = bitcast %"class.task::promise_type"* %__promise to i8*
%id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
Show All 39 Lines

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

; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy ; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() "coroutine.presplit"="1" { define i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.alloc = call i1 @llvm.coro.alloc(token %id) %need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin br i1 %need.alloc, label %dyn.alloc, label %begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

; Tests that a coroutine is split, inlined into the caller and devirtualized. ; Tests that a coroutine is split, inlined into the caller and devirtualized.
; RUN: opt < %s -S -passes='default<O2>' | FileCheck %s ; RUN: opt < %s -S -passes='default<O2>' | FileCheck %s
define i8* @f() "coroutine.presplit"="0" { define i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; Tests that coro-split can handle the case when a code after coro.suspend uses ; 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) ; a value produces between coro.save and coro.suspend (%Result.i19)
; and checks whether stray coro.saves are properly removed ; and checks whether stray coro.saves are properly removed
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
define void @a() "coroutine.presplit"="1" { define void @a() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32 %testval = alloca i32
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
%save = call token @llvm.coro.save(i8* null) %save = call token @llvm.coro.save(i8* null)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; Tests that coro-split passes initialized values to coroutine frame allocator. ; Tests that coro-split passes initialized values to coroutine frame allocator.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i32 %argument) "coroutine.presplit"="1" { define i8* @f(i32 %argument) presplitcoroutine {
entry: entry:
%argument.addr = alloca i32, align 4 %argument.addr = alloca i32, align 4
%incremented = add i32 %argument, 1 %incremented = add i32 %argument, 1
store i32 %incremented, i32* %argument.addr, align 4 store i32 %incremented, i32* %argument.addr, align 4
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.alloc = call i1 @llvm.coro.alloc(token %id) %need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin br i1 %need.alloc, label %dyn.alloc, label %begin
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
declare i1 @llvm.coro.end(i8*, i1) #7 declare i1 @llvm.coro.end(i8*, i1) #7
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #5 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #5
declare void @llvm.dbg.value(metadata, metadata, metadata) #1 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone } attributes #1 = { nounwind readnone }
attributes #2 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #2 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind uwtable "coroutine.presplit"="1" "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #3 = { nounwind uwtable presplitcoroutine "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #4 = { argmemonly nounwind } attributes #4 = { argmemonly nounwind }
attributes #5 = { argmemonly nounwind readonly } attributes #5 = { argmemonly nounwind readonly }
attributes #6 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" } attributes #6 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #7 = { nounwind } attributes #7 = { nounwind }
attributes #8 = { alwaysinline nounwind } attributes #8 = { alwaysinline nounwind }
attributes #9 = { noduplicate } attributes #9 = { noduplicate }
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; Tests that coro-split removes cleanup code after coro.end in resume functions ; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function. ; and retains it in the start function.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %val) "coroutine.presplit"="1" personality i32 3 { define i8* @f(i1 %val) presplitcoroutine personality i32 3 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
call void @print(i32 0) call void @print(i32 0)
br i1 %val, label %resume, label %susp br i1 %val, label %resume, label %susp
susp: susp:
%0 = call i8 @llvm.coro.suspend(token none, i1 false) %0 = call i8 @llvm.coro.suspend(token none, i1 false)
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

; Tests that coro-split removes cleanup code after coro.end in resume functions ; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function. ; and retains it in the start function.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f2(i1 %val) "coroutine.presplit"="1" personality i32 4 { define i8* @f2(i1 %val) presplitcoroutine personality i32 4 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
call void @print(i32 0) call void @print(i32 0)
br i1 %val, label %resume, label %susp br i1 %val, label %resume, label %susp
susp: susp:
%0 = call i8 @llvm.coro.suspend(token none, i1 false) %0 = call i8 @llvm.coro.suspend(token none, i1 false)
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

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

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
declare token @llvm.coro.save(i8*) #2 declare token @llvm.coro.save(i8*) #2
declare i8* @llvm.coro.frame() #3 declare i8* @llvm.coro.frame() #3
declare i8 @llvm.coro.suspend(token, i1) #2 declare i8 @llvm.coro.suspend(token, i1) #2
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare i8 @switch_result() declare i8 @switch_result()
declare i8* @g() declare i8* @g()
declare i8* @h() declare i8* @h()
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
declare token @llvm.coro.save(i8*) #2 declare token @llvm.coro.save(i8*) #2
declare i8* @llvm.coro.frame() #3 declare i8* @llvm.coro.frame() #3
declare i8 @llvm.coro.suspend(token, i1) #2 declare i8 @llvm.coro.suspend(token, i1) #2
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare i8 @switch_result() declare i8 @switch_result()
declare i8* @g() declare i8* @g()
declare i8* @h() declare i8* @h()
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
declare i8* @llvm.coro.frame() #3 declare i8* @llvm.coro.frame() #3
declare i8 @llvm.coro.suspend(token, i1) #2 declare i8 @llvm.coro.suspend(token, i1) #2
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @delete(i8* nonnull) #2 declare void @delete(i8* nonnull) #2
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1 declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(i8*) declare void @consume(i8*)
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) 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)
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @delete(i8* nonnull) #2 declare void @delete(i8* nonnull) #2
declare void @consume(i64*) declare void @consume(i64*)
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) 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)
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
declare i1 @llvm.coro.end(i8*, i1) #2 declare i1 @llvm.coro.end(i8*, i1) #2
declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1 declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #1
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @delete(i8* nonnull) #2 declare void @delete(i8* nonnull) #2
declare void @consume(i64*) declare void @consume(i64*)
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) 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)
attributes #0 = { "coroutine.presplit"="1" } attributes #0 = { presplitcoroutine }
attributes #1 = { argmemonly nounwind readonly } attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind } attributes #2 = { nounwind }
attributes #3 = { nounwind readnone } attributes #3 = { nounwind readnone }

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

; RUN: opt -passes='module(coro-early),cgscc(coro-split)' -opaque-pointers=0 -S < %s | FileCheck %s ; RUN: opt -passes='module(coro-early),cgscc(coro-split)' -opaque-pointers=0 -S < %s | FileCheck %s
; RUN: opt -passes='module(coro-early),cgscc(coro-split)' -opaque-pointers=1 -S < %s | FileCheck %s ; RUN: opt -passes='module(coro-early),cgscc(coro-split)' -opaque-pointers=1 -S < %s | FileCheck %s
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
declare i8* @llvm.coro.begin(token, i8* writeonly) declare i8* @llvm.coro.begin(token, i8* writeonly)
declare token @llvm.coro.save(i8*) declare token @llvm.coro.save(i8*)
declare i8 @llvm.coro.suspend(token, i1) declare i8 @llvm.coro.suspend(token, i1)
; CHECK-LABEL: define void @foo() ; CHECK-LABEL: define void @foo()
; CHECK-LABEL: define {{.*}}void @foo.resume( ; CHECK-LABEL: define {{.*}}void @foo.resume(
; CHECK: call void @foo() ; CHECK: call void @foo()
; CHECK-LABEL: define {{.*}}void @foo.destroy( ; CHECK-LABEL: define {{.*}}void @foo.destroy(
define void @foo() "coroutine.presplit"="0" { define void @foo() presplitcoroutine {
entry: entry:
%__promise = alloca i32, align 8 %__promise = alloca i32, align 8
%0 = bitcast i32* %__promise to i8* %0 = bitcast i32* %__promise to i8*
%1 = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null) %1 = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
%2 = call i8* @llvm.coro.begin(token %1, i8* null) %2 = call i8* @llvm.coro.begin(token %1, i8* null)
br i1 undef, label %if.then154, label %init.suspend br i1 undef, label %if.then154, label %init.suspend
init.suspend: ; preds = %entry init.suspend: ; preds = %entry
Show All 12 Lines

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

; Tests that coro-split will optimize the lifetime.start maker of each local variable, ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block. ; sink them to the places after the suspend block.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
define void @a() "coroutine.presplit"="1" { define void @a() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32 %testval = alloca i32
%cast = bitcast i32* %testval to i8* %cast = bitcast i32* %testval to i8*
; lifetime of %testval starts here, but not used until await.ready. ; lifetime of %testval starts here, but not used until await.ready.
call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast) call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; Tests that coro-split will optimize the lifetime.start maker of each local variable, ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block. ; sink them to the places after the suspend block.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i1 @getcond() declare i1 @getcond()
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
define void @a() "coroutine.presplit"="1" { define void @a() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32 %testval = alloca i32
%cast = bitcast i32* %testval to i8* %cast = bitcast i32* %testval to i8*
; lifetime of %testval starts here, but not used until await.ready. ; lifetime of %testval starts here, but not used until await.ready.
call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast) call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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 ; 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. ; pass knows the operand of lifetime.start intrinsic may be GEP as well.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
%i8.array = type { [100 x i8] } %i8.array = type { [100 x i8] }
declare void @consume.i8.array(%i8.array*) declare void @consume.i8.array(%i8.array*)
define void @a.gep() "coroutine.presplit"="1" { define void @a.gep() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca %i8.array %testval = alloca %i8.array
%cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0 %cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0
; lifetime of %testval starts here, but not used until await.ready. ; lifetime of %testval starts here, but not used until await.ready.
call void @llvm.lifetime.start.p0i8(i64 100, i8* %cast) call void @llvm.lifetime.start.p0i8(i64 100, i8* %cast)
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; Tests that coro-split will optimize the lifetime.start maker of each local variable, ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block. ; sink them to the places after the suspend block.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
declare void @consume.i8(i8) declare void @consume.i8(i8)
define void @a() "coroutine.presplit"="1" { define void @a() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i8 %testval = alloca i8
; lifetime of %testval starts here, but not used until await.ready. ; lifetime of %testval starts here, but not used until await.ready.
call void @llvm.lifetime.start.p0i8(i64 1, i8* %testval) call void @llvm.lifetime.start.p0i8(i64 1, i8* %testval)
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @free(i8*) declare void @free(i8*)
declare void @usePointer(i8*) declare void @usePointer(i8*)
declare void @usePointer2([0 x i8]*) declare void @usePointer2([0 x i8]*)
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
declare i64 @llvm.coro.size.i64() declare i64 @llvm.coro.size.i64()
declare i8* @llvm.coro.begin(token, i8* writeonly) declare i8* @llvm.coro.begin(token, i8* writeonly)
declare i8 @llvm.coro.suspend(token, i1) declare i8 @llvm.coro.suspend(token, i1)
declare i1 @llvm.coro.end(i8*, i1) declare i1 @llvm.coro.end(i8*, i1)
declare i8* @llvm.coro.free(token, i8* nocapture readonly) declare i8* @llvm.coro.free(token, i8* nocapture readonly)
declare token @llvm.coro.save(i8*) declare token @llvm.coro.save(i8*)
define void @foo() "coroutine.presplit"="1" { define void @foo() presplitcoroutine {
entry: entry:
%a0 = alloca [0 x i8] %a0 = alloca [0 x i8]
%a1 = alloca i32 %a1 = alloca i32
%a2 = alloca [0 x i8] %a2 = alloca [0 x i8]
%a3 = alloca [0 x i8] %a3 = alloca [0 x i8]
%a4 = alloca i16 %a4 = alloca i16
%a5 = alloca [0 x i8] %a5 = alloca [0 x i8]
%a0.cast = bitcast [0 x i8]* %a0 to i8* %a0.cast = bitcast [0 x i8]* %a0 to i8*
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex0.ll

; First example from Doc/Coroutines.rst (two block loop) ; First example from Doc/Coroutines.rst (two block loop)
; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex1.ll

; First example from Doc/Coroutines.rst (one block loop) ; First example from Doc/Coroutines.rst (one block loop)
; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc)
br label %loop br label %loop
loop: loop:
%n.val = phi i32 [ %n, %entry ], [ %inc, %loop ] %n.val = phi i32 [ %n, %entry ], [ %inc, %loop ]
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex2.ll

; Second example from Doc/Coroutines.rst (custom alloc and free functions) ; Second example from Doc/Coroutines.rst (custom alloc and free functions)
; RUN: opt < %s -passes='default<O2>' -S | FileCheck %s ; RUN: opt < %s -passes='default<O2>' -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @CustomAlloc(i32 %size) %alloc = call i8* @CustomAlloc(i32 %size)
br label %coro.begin br label %coro.begin
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex3.ll

; Third example from Doc/Coroutines.rst (two suspend points) ; Third example from Doc/Coroutines.rst (two suspend points)
; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex4.ll

; Fourth example from Doc/Coroutines.rst (coroutine promise) ; Fourth example from Doc/Coroutines.rst (coroutine promise)
; RUN: opt < %s -passes='default<O2>' -S | FileCheck %s ; RUN: opt < %s -passes='default<O2>' -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%promise = alloca i32 %promise = alloca i32
%pv = bitcast i32* %promise to i8* %pv = bitcast i32* %promise to i8*
%id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ex5.ll

; Fifth example from Doc/Coroutines.rst (final suspend) ; Fifth example from Doc/Coroutines.rst (final suspend)
; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -preserve-alignment-assumptions-during-inlining=false -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc)
br label %while.cond br label %while.cond
while.cond: while.cond:
%n.val = phi i32 [ %n, %entry ], [ %dec, %while.body ] %n.val = phi i32 [ %n, %entry ], [ %dec, %while.body ]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

; Test no suspend coroutines ; Test no suspend coroutines
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
; Coroutine with no-suspends will turn into: ; Coroutine with no-suspends will turn into:
; ;
; CHECK-LABEL: define void @no_suspends( ; CHECK-LABEL: define void @no_suspends(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: alloca ; CHECK-NEXT: alloca
; CHECK-NEXT: bitcast ; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @print(i32 %n) ; CHECK-NEXT: call void @print(i32 %n)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
define void @no_suspends(i32 %n) "coroutine.presplit"="1" { define void @no_suspends(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 23 Lines
; CHECK-LABEL: define void @simplify_resume( ; CHECK-LABEL: define void @simplify_resume(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: alloca ; CHECK-NEXT: alloca
; CHECK-NEXT: bitcast ; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @llvm.memcpy ; CHECK-NEXT: call void @llvm.memcpy
; CHECK-NEXT: call void @print(i32 0) ; CHECK-NEXT: call void @print(i32 0)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
define void @simplify_resume(i8* %src, i8* %dst) "coroutine.presplit"="1" { define void @simplify_resume(i8* %src, i8* %dst) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 34 Lines
; ;
; CHECK-LABEL: define void @simplify_destroy( ; CHECK-LABEL: define void @simplify_destroy(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: alloca ; CHECK-NEXT: alloca
; CHECK-NEXT: bitcast ; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @print(i32 1) ; CHECK-NEXT: call void @print(i32 1)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
define void @simplify_destroy() "coroutine.presplit"="1" personality i32 0 { define void @simplify_destroy() presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; CHECK-LABEL: define void @simplify_resume_with_inlined_if( ; CHECK-LABEL: define void @simplify_resume_with_inlined_if(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: alloca ; CHECK-NEXT: alloca
; CHECK-NEXT: bitcast ; CHECK-NEXT: bitcast
; CHECK-NEXT: br i1 ; CHECK-NEXT: br i1
; CHECK: call void @print(i32 0) ; CHECK: call void @print(i32 0)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
define void @simplify_resume_with_inlined_if(i8* %src, i8* %dst, i1 %cond) "coroutine.presplit"="1" { define void @simplify_resume_with_inlined_if(i8* %src, i8* %dst, i1 %cond) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 39 Lines
; SimplifySuspendPoint won't be able to simplify if it detects that there are ; SimplifySuspendPoint won't be able to simplify if it detects that there are
; other calls between coro.save and coro.suspend. They potentially can call ; other calls between coro.save and coro.suspend. They potentially can call
; resume or destroy, so we should not simplify this suspend point. ; resume or destroy, so we should not simplify this suspend point.
; ;
; CHECK-LABEL: define void @cannot_simplify_other_calls( ; CHECK-LABEL: define void @cannot_simplify_other_calls(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: llvm.coro.id ; CHECK-NEXT: llvm.coro.id
define void @cannot_simplify_other_calls() "coroutine.presplit"="1" { define void @cannot_simplify_other_calls() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 36 Lines
; SimplifySuspendPoint won't be able to simplify if it detects that there are ; SimplifySuspendPoint won't be able to simplify if it detects that there are
; other calls between coro.save and coro.suspend. They potentially can call ; other calls between coro.save and coro.suspend. They potentially can call
; resume or destroy, so we should not simplify this suspend point. ; resume or destroy, so we should not simplify this suspend point.
; ;
; CHECK-LABEL: define void @cannot_simplify_calls_in_terminator( ; CHECK-LABEL: define void @cannot_simplify_calls_in_terminator(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: llvm.coro.id ; CHECK-NEXT: llvm.coro.id
define void @cannot_simplify_calls_in_terminator() "coroutine.presplit"="1" personality i32 0 { define void @cannot_simplify_calls_in_terminator() presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 36 Lines
; SimplifySuspendPoint won't be able to simplify if it detects that resume or ; SimplifySuspendPoint won't be able to simplify if it detects that resume or
; destroy does not immediately preceed coro.suspend. ; destroy does not immediately preceed coro.suspend.
; ;
; CHECK-LABEL: define void @cannot_simplify_not_last_instr( ; CHECK-LABEL: define void @cannot_simplify_not_last_instr(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: llvm.coro.id ; CHECK-NEXT: llvm.coro.id
define void @cannot_simplify_not_last_instr(i8* %dst, i8* %src) "coroutine.presplit"="1" { define void @cannot_simplify_not_last_instr(i8* %dst, i8* %src) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
Show All 29 Lines
} }
; SimplifySuspendPoint should not simplify final suspend point ; SimplifySuspendPoint should not simplify final suspend point
; ;
; CHECK-LABEL: define void @cannot_simplify_final_suspend( ; CHECK-LABEL: define void @cannot_simplify_final_suspend(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: llvm.coro.id ; CHECK-NEXT: llvm.coro.id
; ;
define void @cannot_simplify_final_suspend() "coroutine.presplit"="1" personality i32 0 { define void @cannot_simplify_final_suspend() presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id) %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc: dyn.alloc:
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
br label %coro.begin br label %coro.begin
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

; Verify that we correctly handle suspend when the coro.end block contains phi ; Verify that we correctly handle suspend when the coro.end block contains phi
; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -S | FileCheck %s
define i8* @f(i32 %n) "coroutine.presplit"="0" { define i8* @f(i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
%0 = call i8 @llvm.coro.suspend(token none, i1 false) %0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %cleanup i8 1, label %cleanup] switch i8 %0, label %suspend [i8 0, label %cleanup i8 1, label %cleanup]
Show All 36 Lines

llvm/test/Transforms/FunctionAttrs/noreturn.ll

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
; CHECK: Function Attrs: {{.*}}noreturn ; CHECK: Function Attrs: {{.*}}noreturn
; CHECK-NEXT: @unreachable ; CHECK-NEXT: @unreachable
define void @unreachable() { define void @unreachable() {
unreachable unreachable
} }
; CHECK-NOT: Function Attrs: {{.*}}noreturn ; CHECK-NOT: Function Attrs: {{.*}}noreturn
; CHECK: @coro ; CHECK: @coro
define void @coro() "coroutine.presplit"="1" { define void @coro() presplitcoroutine {
call token @llvm.coro.id.retcon.once(i32 0, i32 0, i8* null, i8* bitcast(void() *@coro to i8*), i8* null, i8* null) call token @llvm.coro.id.retcon.once(i32 0, i32 0, i8* null, i8* bitcast(void() *@coro to i8*), i8* null, i8* null)
call i1 @llvm.coro.end(i8* null, i1 false) call i1 @llvm.coro.end(i8* null, i1 false)
unreachable unreachable
} }
declare token @llvm.coro.id.retcon.once(i32 %size, i32 %align, i8* %buffer, i8* %prototype, i8* %alloc, i8* %free) declare token @llvm.coro.id.retcon.once(i32 %size, i32 %align, i8* %buffer, i8* %prototype, i8* %alloc, i8* %free)
declare i1 @llvm.coro.end(i8*, i1) declare i1 @llvm.coro.end(i8*, i1)

llvm/test/Transforms/Inline/ML/state-tracking-coro.ll

; Based on llvm/test/Transforms/Coroutines/coro-split-02.ll ; Based on llvm/test/Transforms/Coroutines/coro-split-02.ll
; Corosplit will keep f1 and add 3 more functions. ; Corosplit will keep f1 and add 3 more functions.
; RUN: opt -passes='default<O1>,print<inline-advisor>' -training-log=/dev/null \ ; RUN: opt -passes='default<O1>,print<inline-advisor>' -training-log=/dev/null \
; RUN: -S -enable-ml-inliner=development -keep-inline-advisor-for-printing < %s 2>&1 | FileCheck %s ; RUN: -S -enable-ml-inliner=development -keep-inline-advisor-for-printing < %s 2>&1 | FileCheck %s
; REQUIRES: have_tf_api ; REQUIRES: have_tf_api
; ;
; CHECK: [MLInlineAdvisor] Nodes: 4 Edges: 0 ; CHECK: [MLInlineAdvisor] Nodes: 4 Edges: 0
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
define void @a() "coroutine.presplit"="0" { define void @a() presplitcoroutine {
entry: entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8 %ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32 %testval = alloca i32
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%alloc = call i8* @malloc(i64 16) #3 %alloc = call i8* @malloc(i64 16) #3
%vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc) %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
%save = call token @llvm.coro.save(i8* null) %save = call token @llvm.coro.save(i8* null)
Show All 35 Lines

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines for (Block &block : func.getBody().getBlocks()) {
Operation *terminator = block.getTerminator(); Operation *terminator = block.getTerminator();
if (auto yield = dyn_cast<YieldOp>(terminator)) { if (auto yield = dyn_cast<YieldOp>(terminator)) {
builder.setInsertionPointToEnd(&block); builder.setInsertionPointToEnd(&block);
builder.create<cf::BranchOp>(cleanupBlock); builder.create<cf::BranchOp>(cleanupBlock);
} }
} }
// The switch-resumed API based coroutine should be marked with // The switch-resumed API based coroutine should be marked with
// "coroutine.presplit" attribute with value "0" to mark the function as a // coroutine.presplit attribute to mark the function as a coroutine.
// coroutine. func->setAttr("passthrough", builder.getArrayAttr(
func->setAttr("passthrough", builder.getArrayAttr(builder.getArrayAttr( StringAttr::get(ctx, "presplitcoroutine")));
{builder.getStringAttr("coroutine.presplit"),
builder.getStringAttr("0")})));
CoroMachinery machinery; CoroMachinery machinery;
machinery.func = func; machinery.func = func;
machinery.asyncToken = retToken; machinery.asyncToken = retToken;
machinery.returnValues = retValues; machinery.returnValues = retValues;
machinery.coroHandle = coroHdlOp.handle(); machinery.coroHandle = coroHdlOp.handle();
machinery.entry = entryBlock; machinery.entry = entryBlock;
machinery.setError = nullptr; // created lazily only if needed machinery.setError = nullptr; // created lazily only if needed
▲ Show 20 Lines • Show All 619 Lines • Show Last 20 Lines

mlir/test/mlir-opt/async.mlir

// Check if mlir marks the corresponding function with required coroutine attribute. // Check if mlir marks the corresponding function with required coroutine attribute.
// //
// RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \ // RUN: mlir-opt %s -pass-pipeline="async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts" \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}"coroutine.presplit", "0" // CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}"coroutine.presplit", "0" // CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}"coroutine.presplit", "0" // CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}presplitcoroutine
func.func @main() { func.func @main() {
%i0 = arith.constant 0 : index %i0 = arith.constant 0 : index
%i1 = arith.constant 1 : index %i1 = arith.constant 1 : index
%i2 = arith.constant 2 : index %i2 = arith.constant 2 : index
%i3 = arith.constant 3 : index %i3 = arith.constant 3 : index
%c0 = arith.constant 0.0 : f32 %c0 = arith.constant 0.0 : f32
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines