CoroCleanup.cpp Source File (original) (raw)

18using namespace llvm;

20#define DEBUG_TYPE "coro-cleanup"

22namespace {

26 Lowerer(Module &M) : LowererBase(M), Builder(Context) {}

28};

29}

32 Builder.SetInsertPoint(SubFn);

34 int Index = SubFn->getIndex();

37 {Builder.getPtrTy(), Builder.getPtrTy()});

39 Builder.SetInsertPoint(SubFn);

40 auto *Gep = Builder.CreateConstInBoundsGEP2_32(FrameTy, FramePtr, 0, Index);

41 auto *Load = Builder.CreateLoad(FrameTy->getElementType(Index), Gep);

44}

47 bool IsPrivateAndUnprocessed = F.isPresplitCoroutine() && F.hasLocalLinkage();

52 switch (II->getIntrinsicID()) {

53 default:

54 continue;

55 case Intrinsic::coro_begin:

56 case Intrinsic::coro_begin_custom_abi:

57 II->replaceAllUsesWith(II->getArgOperand(1));

58 break;

59 case Intrinsic::coro_free:

60 II->replaceAllUsesWith(II->getArgOperand(1));

61 break;

62 case Intrinsic::coro_alloc:

64 break;

65 case Intrinsic::coro_async_resume:

66 II->replaceAllUsesWith(

68 break;

69 case Intrinsic::coro_id:

70 case Intrinsic::coro_id_retcon:

71 case Intrinsic::coro_id_retcon_once:

72 case Intrinsic::coro_id_async:

74 break;

75 case Intrinsic::coro_subfn_addr:

77 break;

78 case Intrinsic::coro_suspend_retcon:

79 case Intrinsic::coro_is_in_ramp:

80 if (IsPrivateAndUnprocessed) {

82 } else

83 continue;

84 break;

85 case Intrinsic::coro_async_size_replace:

88 ->getInitializer());

91 ->getInitializer());

92 auto *TargetSize = Target->getOperand(1);

93 auto *SourceSize = Source->getOperand(1);

94 if (TargetSize->isElementWiseEqual(SourceSize)) {

95 break;

96 }

97 auto *TargetRelativeFunOffset = Target->getOperand(0);

99 Target->getType(), TargetRelativeFunOffset, SourceSize);

100 Target->replaceAllUsesWith(NewFuncPtrStruct);

101 break;

102 }

103 II->eraseFromParent();

105 }

106 }

107

109}

110

113 M, {Intrinsic::coro_alloc, Intrinsic::coro_begin,

114 Intrinsic::coro_subfn_addr, Intrinsic::coro_free, Intrinsic::coro_id,

115 Intrinsic::coro_id_retcon, Intrinsic::coro_id_async,

116 Intrinsic::coro_id_retcon_once, Intrinsic::coro_async_size_replace,

117 Intrinsic::coro_async_resume, Intrinsic::coro_begin_custom_abi});

118}

119

124

127

130

133

134 Lowerer L(M);

135 for (auto &F : M) {

136 if (L.lower(F)) {

137 FAM.invalidate(F, FuncPA);

139 }

140 }

141

143}

Expand Atomic instructions

static bool declaresCoroCleanupIntrinsics(const Module &M)

Definition CoroCleanup.cpp:111

static void lowerSubFn(IRBuilder<> &Builder, CoroSubFnInst *SubFn)

Definition CoroCleanup.cpp:31

Module.h This file contains the declarations for the Module class.

This header defines various interfaces for pass management in LLVM.

uint64_t IntrinsicInst * II

FunctionAnalysisManager FAM

ModuleAnalysisManager MAM

This file provides the interface for the pass responsible for both simplifying and canonicalizing the...

static const unsigned FramePtr

Represents analyses that only rely on functions' control flow.

static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)

static LLVM_ABI ConstantPointerNull * get(PointerType *T)

Static factory methods - Return objects of the specified value.

static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)

static LLVM_ABI ConstantTokenNone * get(LLVMContext &Context)

Return the ConstantTokenNone.

This class represents the llvm.coro.subfn.addr instruction.

ResumeKind getIndex() const

This provides a uniform API for creating instructions and inserting them into a basic block: either a...

A Module instance is used to store all the information related to an LLVM module.

LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)

PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)

Run all of the passes in this manager over the given unit of IR.

static LLVM_ABI PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses none()

Convenience factory function for the empty preserved set.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses & preserveSet()

Mark an analysis set as preserved.

A pass to simplify and canonicalize the CFG of a function.

static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)

This static method is the primary way to create a literal StructType.

LLVM Value Representation.

LLVM_ABI void replaceAllUsesWith(Value *V)

Change all uses of this to point to a new Value.

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

bool declaresIntrinsics(const Module &M, ArrayRef< Intrinsic::ID > List)

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)

Make a range that does early increment to allow mutation of the underlying range without disrupting i...

InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy

Provide the FunctionAnalysisManager to Module proxy.

PassManager< Function > FunctionPassManager

Convenience typedef for a pass manager over functions.

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)

Definition CoroCleanup.cpp:120