Bug Summary

File:tools/clang/lib/CodeGen/CGCoroutine.cpp
Warning:line 173, column 5
Value stored to 'SuspendBlock' is never read

Annotated Source Code

1//===----- CGCoroutine.cpp - Emit LLVM Code for C++ coroutines ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with C++ code generation of coroutines.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "llvm/ADT/ScopeExit.h"
16#include "clang/AST/StmtCXX.h"
17
18using namespace clang;
19using namespace CodeGen;
20
21using llvm::Value;
22using llvm::BasicBlock;
23
24namespace {
25enum class AwaitKind { Init, Normal, Yield, Final };
26static constexpr llvm::StringLiteral AwaitKindStr[] = {"init", "await", "yield",
27 "final"};
28}
29
30struct clang::CodeGen::CGCoroData {
31 // What is the current await expression kind and how many
32 // await/yield expressions were encountered so far.
33 // These are used to generate pretty labels for await expressions in LLVM IR.
34 AwaitKind CurrentAwaitKind = AwaitKind::Init;
35 unsigned AwaitNum = 0;
36 unsigned YieldNum = 0;
37
38 // How many co_return statements are in the coroutine. Used to decide whether
39 // we need to add co_return; equivalent at the end of the user authored body.
40 unsigned CoreturnCount = 0;
41
42 // A branch to this block is emitted when coroutine needs to suspend.
43 llvm::BasicBlock *SuspendBB = nullptr;
44
45 // Stores the jump destination just before the coroutine memory is freed.
46 // This is the destination that every suspend point jumps to for the cleanup
47 // branch.
48 CodeGenFunction::JumpDest CleanupJD;
49
50 // Stores the jump destination just before the final suspend. The co_return
51 // statements jumps to this point after calling return_xxx promise member.
52 CodeGenFunction::JumpDest FinalJD;
53
54 // Stores the llvm.coro.id emitted in the function so that we can supply it
55 // as the first argument to coro.begin, coro.alloc and coro.free intrinsics.
56 // Note: llvm.coro.id returns a token that cannot be directly expressed in a
57 // builtin.
58 llvm::CallInst *CoroId = nullptr;
59
60 // If coro.id came from the builtin, remember the expression to give better
61 // diagnostic. If CoroIdExpr is nullptr, the coro.id was created by
62 // EmitCoroutineBody.
63 CallExpr const *CoroIdExpr = nullptr;
64};
65
66// Defining these here allows to keep CGCoroData private to this file.
67clang::CodeGen::CodeGenFunction::CGCoroInfo::CGCoroInfo() {}
68CodeGenFunction::CGCoroInfo::~CGCoroInfo() {}
69
70static void createCoroData(CodeGenFunction &CGF,
71 CodeGenFunction::CGCoroInfo &CurCoro,
72 llvm::CallInst *CoroId,
73 CallExpr const *CoroIdExpr = nullptr) {
74 if (CurCoro.Data) {
75 if (CurCoro.Data->CoroIdExpr)
76 CGF.CGM.Error(CoroIdExpr->getLocStart(),
77 "only one __builtin_coro_id can be used in a function");
78 else if (CoroIdExpr)
79 CGF.CGM.Error(CoroIdExpr->getLocStart(),
80 "__builtin_coro_id shall not be used in a C++ coroutine");
81 else
82 llvm_unreachable("EmitCoroutineBodyStatement called twice?")::llvm::llvm_unreachable_internal("EmitCoroutineBodyStatement called twice?"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/CodeGen/CGCoroutine.cpp"
, 82)
;
83
84 return;
85 }
86
87 CurCoro.Data = std::unique_ptr<CGCoroData>(new CGCoroData);
88 CurCoro.Data->CoroId = CoroId;
89 CurCoro.Data->CoroIdExpr = CoroIdExpr;
90}
91
92// Synthesize a pretty name for a suspend point.
93static SmallString<32> buildSuspendPrefixStr(CGCoroData &Coro, AwaitKind Kind) {
94 unsigned No = 0;
95 switch (Kind) {
96 case AwaitKind::Init:
97 case AwaitKind::Final:
98 break;
99 case AwaitKind::Normal:
100 No = ++Coro.AwaitNum;
101 break;
102 case AwaitKind::Yield:
103 No = ++Coro.YieldNum;
104 break;
105 }
106 SmallString<32> Prefix(AwaitKindStr[static_cast<unsigned>(Kind)]);
107 if (No > 1) {
108 Twine(No).toVector(Prefix);
109 }
110 return Prefix;
111}
112
113// Emit suspend expression which roughly looks like:
114//
115// auto && x = CommonExpr();
116// if (!x.await_ready()) {
117// llvm_coro_save();
118// x.await_suspend(...); (*)
119// llvm_coro_suspend(); (**)
120// }
121// x.await_resume();
122//
123// where the result of the entire expression is the result of x.await_resume()
124//
125// (*) If x.await_suspend return type is bool, it allows to veto a suspend:
126// if (x.await_suspend(...))
127// llvm_coro_suspend();
128//
129// (**) llvm_coro_suspend() encodes three possible continuations as
130// a switch instruction:
131//
132// %where-to = call i8 @llvm.coro.suspend(...)
133// switch i8 %where-to, label %coro.ret [ ; jump to epilogue to suspend
134// i8 0, label %yield.ready ; go here when resumed
135// i8 1, label %yield.cleanup ; go here when destroyed
136// ]
137//
138// See llvm's docs/Coroutines.rst for more details.
139//
140static RValue emitSuspendExpression(CodeGenFunction &CGF, CGCoroData &Coro,
141 CoroutineSuspendExpr const &S,
142 AwaitKind Kind, AggValueSlot aggSlot,
143 bool ignoreResult) {
144 auto *E = S.getCommonExpr();
145 auto Binder =
146 CodeGenFunction::OpaqueValueMappingData::bind(CGF, S.getOpaqueValue(), E);
147 auto UnbindOnExit = llvm::make_scope_exit([&] { Binder.unbind(CGF); });
148
149 auto Prefix = buildSuspendPrefixStr(Coro, Kind);
150 BasicBlock *ReadyBlock = CGF.createBasicBlock(Prefix + Twine(".ready"));
151 BasicBlock *SuspendBlock = CGF.createBasicBlock(Prefix + Twine(".suspend"));
152 BasicBlock *CleanupBlock = CGF.createBasicBlock(Prefix + Twine(".cleanup"));
153
154 // If expression is ready, no need to suspend.
155 CGF.EmitBranchOnBoolExpr(S.getReadyExpr(), ReadyBlock, SuspendBlock, 0);
156
157 // Otherwise, emit suspend logic.
158 CGF.EmitBlock(SuspendBlock);
159
160 auto &Builder = CGF.Builder;
161 llvm::Function *CoroSave = CGF.CGM.getIntrinsic(llvm::Intrinsic::coro_save);
162 auto *NullPtr = llvm::ConstantPointerNull::get(CGF.CGM.Int8PtrTy);
163 auto *SaveCall = Builder.CreateCall(CoroSave, {NullPtr});
164
165 auto *SuspendRet = CGF.EmitScalarExpr(S.getSuspendExpr());
166 if (SuspendRet != nullptr) {
167 // Veto suspension if requested by bool returning await_suspend.
168 assert(SuspendRet->getType()->isIntegerTy(1) &&((SuspendRet->getType()->isIntegerTy(1) && "Sema should have already checked that it is void or bool"
) ? static_cast<void> (0) : __assert_fail ("SuspendRet->getType()->isIntegerTy(1) && \"Sema should have already checked that it is void or bool\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/CodeGen/CGCoroutine.cpp"
, 169, __PRETTY_FUNCTION__))
169 "Sema should have already checked that it is void or bool")((SuspendRet->getType()->isIntegerTy(1) && "Sema should have already checked that it is void or bool"
) ? static_cast<void> (0) : __assert_fail ("SuspendRet->getType()->isIntegerTy(1) && \"Sema should have already checked that it is void or bool\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/CodeGen/CGCoroutine.cpp"
, 169, __PRETTY_FUNCTION__))
;
170 BasicBlock *RealSuspendBlock =
171 CGF.createBasicBlock(Prefix + Twine(".suspend.bool"));
172 CGF.Builder.CreateCondBr(SuspendRet, RealSuspendBlock, ReadyBlock);
173 SuspendBlock = RealSuspendBlock;
Value stored to 'SuspendBlock' is never read
174 CGF.EmitBlock(RealSuspendBlock);
175 }
176
177 // Emit the suspend point.
178 const bool IsFinalSuspend = (Kind == AwaitKind::Final);
179 llvm::Function *CoroSuspend =
180 CGF.CGM.getIntrinsic(llvm::Intrinsic::coro_suspend);
181 auto *SuspendResult = Builder.CreateCall(
182 CoroSuspend, {SaveCall, Builder.getInt1(IsFinalSuspend)});
183
184 // Create a switch capturing three possible continuations.
185 auto *Switch = Builder.CreateSwitch(SuspendResult, Coro.SuspendBB, 2);
186 Switch->addCase(Builder.getInt8(0), ReadyBlock);
187 Switch->addCase(Builder.getInt8(1), CleanupBlock);
188
189 // Emit cleanup for this suspend point.
190 CGF.EmitBlock(CleanupBlock);
191 CGF.EmitBranchThroughCleanup(Coro.CleanupJD);
192
193 // Emit await_resume expression.
194 CGF.EmitBlock(ReadyBlock);
195 return CGF.EmitAnyExpr(S.getResumeExpr(), aggSlot, ignoreResult);
196}
197
198RValue CodeGenFunction::EmitCoawaitExpr(const CoawaitExpr &E,
199 AggValueSlot aggSlot,
200 bool ignoreResult) {
201 return emitSuspendExpression(*this, *CurCoro.Data, E,
202 CurCoro.Data->CurrentAwaitKind, aggSlot,
203 ignoreResult);
204}
205RValue CodeGenFunction::EmitCoyieldExpr(const CoyieldExpr &E,
206 AggValueSlot aggSlot,
207 bool ignoreResult) {
208 return emitSuspendExpression(*this, *CurCoro.Data, E, AwaitKind::Yield,
209 aggSlot, ignoreResult);
210}
211
212void CodeGenFunction::EmitCoreturnStmt(CoreturnStmt const &S) {
213 ++CurCoro.Data->CoreturnCount;
214 EmitStmt(S.getPromiseCall());
215 EmitBranchThroughCleanup(CurCoro.Data->FinalJD);
216}
217
218// For WinEH exception representation backend need to know what funclet coro.end
219// belongs to. That information is passed in a funclet bundle.
220static SmallVector<llvm::OperandBundleDef, 1>
221getBundlesForCoroEnd(CodeGenFunction &CGF) {
222 SmallVector<llvm::OperandBundleDef, 1> BundleList;
223
224 if (llvm::Instruction *EHPad = CGF.CurrentFuncletPad)
225 BundleList.emplace_back("funclet", EHPad);
226
227 return BundleList;
228}
229
230namespace {
231// We will insert coro.end to cut any of the destructors for objects that
232// do not need to be destroyed once the coroutine is resumed.
233// See llvm/docs/Coroutines.rst for more details about coro.end.
234struct CallCoroEnd final : public EHScopeStack::Cleanup {
235 void Emit(CodeGenFunction &CGF, Flags flags) override {
236 auto &CGM = CGF.CGM;
237 auto *NullPtr = llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
238 llvm::Function *CoroEndFn = CGM.getIntrinsic(llvm::Intrinsic::coro_end);
239 // See if we have a funclet bundle to associate coro.end with. (WinEH)
240 auto Bundles = getBundlesForCoroEnd(CGF);
241 auto *CoroEnd = CGF.Builder.CreateCall(
242 CoroEndFn, {NullPtr, CGF.Builder.getTrue()}, Bundles);
243 if (Bundles.empty()) {
244 // Otherwise, (landingpad model), create a conditional branch that leads
245 // either to a cleanup block or a block with EH resume instruction.
246 auto *ResumeBB = CGF.getEHResumeBlock(/*cleanup=*/true);
247 auto *CleanupContBB = CGF.createBasicBlock("cleanup.cont");
248 CGF.Builder.CreateCondBr(CoroEnd, ResumeBB, CleanupContBB);
249 CGF.EmitBlock(CleanupContBB);
250 }
251 }
252};
253}
254
255namespace {
256// Make sure to call coro.delete on scope exit.
257struct CallCoroDelete final : public EHScopeStack::Cleanup {
258 Stmt *Deallocate;
259
260 // TODO: Wrap deallocate in if(coro.free(...)) Deallocate.
261 void Emit(CodeGenFunction &CGF, Flags) override {
262 // Note: That deallocation will be emitted twice: once for a normal exit and
263 // once for exceptional exit. This usage is safe because Deallocate does not
264 // contain any declarations. The SubStmtBuilder::makeNewAndDeleteExpr()
265 // builds a single call to a deallocation function which is safe to emit
266 // multiple times.
267 CGF.EmitStmt(Deallocate);
268 }
269 explicit CallCoroDelete(Stmt *DeallocStmt) : Deallocate(DeallocStmt) {}
270};
271}
272
273void CodeGenFunction::EmitCoroutineBody(const CoroutineBodyStmt &S) {
274 auto *NullPtr = llvm::ConstantPointerNull::get(Builder.getInt8PtrTy());
275 auto &TI = CGM.getContext().getTargetInfo();
276 unsigned NewAlign = TI.getNewAlign() / TI.getCharWidth();
277
278 auto *FinalBB = createBasicBlock("coro.final");
279 auto *RetBB = createBasicBlock("coro.ret");
280
281 auto *CoroId = Builder.CreateCall(
282 CGM.getIntrinsic(llvm::Intrinsic::coro_id),
283 {Builder.getInt32(NewAlign), NullPtr, NullPtr, NullPtr});
284 createCoroData(*this, CurCoro, CoroId);
285 CurCoro.Data->SuspendBB = RetBB;
286
287 auto *AllocateCall = EmitScalarExpr(S.getAllocate());
288
289 // Handle allocation failure if 'ReturnStmtOnAllocFailure' was provided.
290 if (auto *RetOnAllocFailure = S.getReturnStmtOnAllocFailure()) {
291 auto *RetOnFailureBB = createBasicBlock("coro.ret.on.failure");
292 auto *InitBB = createBasicBlock("coro.init");
293
294 // See if allocation was successful.
295 auto *NullPtr = llvm::ConstantPointerNull::get(Int8PtrTy);
296 auto *Cond = Builder.CreateICmpNE(AllocateCall, NullPtr);
297 Builder.CreateCondBr(Cond, InitBB, RetOnFailureBB);
298
299 // If not, return OnAllocFailure object.
300 EmitBlock(RetOnFailureBB);
301 EmitStmt(RetOnAllocFailure);
302
303 EmitBlock(InitBB);
304 }
305
306 CurCoro.Data->CleanupJD = getJumpDestInCurrentScope(RetBB);
307 {
308 CodeGenFunction::RunCleanupsScope ResumeScope(*this);
309 EHStack.pushCleanup<CallCoroDelete>(NormalAndEHCleanup, S.getDeallocate());
310
311 EmitStmt(S.getPromiseDeclStmt());
312
313 EHStack.pushCleanup<CallCoroEnd>(EHCleanup);
314
315 CurCoro.Data->FinalJD = getJumpDestInCurrentScope(FinalBB);
316
317 // FIXME: Emit initial suspend and more before the body.
318
319 CurCoro.Data->CurrentAwaitKind = AwaitKind::Normal;
320 EmitStmt(S.getBody());
321
322 // See if we need to generate final suspend.
323 const bool CanFallthrough = Builder.GetInsertBlock();
324 const bool HasCoreturns = CurCoro.Data->CoreturnCount > 0;
325 if (CanFallthrough || HasCoreturns) {
326 EmitBlock(FinalBB);
327 // FIXME: Emit final suspend.
328 }
329 }
330
331 EmitBlock(RetBB);
332 llvm::Function *CoroEnd = CGM.getIntrinsic(llvm::Intrinsic::coro_end);
333 Builder.CreateCall(CoroEnd, {NullPtr, Builder.getFalse()});
334
335 // FIXME: Emit return for the coroutine return object.
336}
337
338// Emit coroutine intrinsic and patch up arguments of the token type.
339RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E,
340 unsigned int IID) {
341 SmallVector<llvm::Value *, 8> Args;
342 switch (IID) {
343 default:
344 break;
345 // The following three intrinsics take a token parameter referring to a token
346 // returned by earlier call to @llvm.coro.id. Since we cannot represent it in
347 // builtins, we patch it up here.
348 case llvm::Intrinsic::coro_alloc:
349 case llvm::Intrinsic::coro_begin:
350 case llvm::Intrinsic::coro_free: {
351 if (CurCoro.Data && CurCoro.Data->CoroId) {
352 Args.push_back(CurCoro.Data->CoroId);
353 break;
354 }
355 CGM.Error(E->getLocStart(), "this builtin expect that __builtin_coro_id has"
356 " been used earlier in this function");
357 // Fallthrough to the next case to add TokenNone as the first argument.
358 }
359 // @llvm.coro.suspend takes a token parameter. Add token 'none' as the first
360 // argument.
361 case llvm::Intrinsic::coro_suspend:
362 Args.push_back(llvm::ConstantTokenNone::get(getLLVMContext()));
363 break;
364 }
365 for (auto &Arg : E->arguments())
366 Args.push_back(EmitScalarExpr(Arg));
367
368 llvm::Value *F = CGM.getIntrinsic(IID);
369 llvm::CallInst *Call = Builder.CreateCall(F, Args);
370
371 // If we see @llvm.coro.id remember it in the CoroData. We will update
372 // coro.alloc, coro.begin and coro.free intrinsics to refer to it.
373 if (IID == llvm::Intrinsic::coro_id) {
374 createCoroData(*this, CurCoro, Call, E);
375 }
376 return RValue::get(Call);
377}