LLVM 17.0.0git
CoroInstr.h
Go to the documentation of this file.
1//===-- CoroInstr.h - Coroutine Intrinsics Instruction Wrappers -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8// This file defines classes that make it really easy to deal with intrinsic
9// functions with the isa/dyncast family of functions. In particular, this
10// allows you to do things like:
11//
12// if (auto *SF = dyn_cast<CoroSubFnInst>(Inst))
13// ... SF->getFrame() ...
14//
15// All intrinsic function calls are instances of the call instruction, so these
16// are all subclasses of the CallInst class. Note that none of these classes
17// has state or virtual methods, which is an important part of this gross/neat
18// hack working.
19//
20// The helpful comment above is borrowed from llvm/IntrinsicInst.h, we keep
21// coroutine intrinsic wrappers here since they are only used by the passes in
22// the Coroutine library.
23//===----------------------------------------------------------------------===//
24
25#ifndef LLVM_LIB_TRANSFORMS_COROUTINES_COROINSTR_H
26#define LLVM_LIB_TRANSFORMS_COROUTINES_COROINSTR_H
27
31
32namespace llvm {
33
34/// This class represents the llvm.coro.subfn.addr instruction.
36 enum { FrameArg, IndexArg };
37
38public:
40 RestartTrigger = -1,
45 IndexFirst = RestartTrigger
46 };
47
48 Value *getFrame() const { return getArgOperand(FrameArg); }
50 int64_t Index = getRawIndex()->getValue().getSExtValue();
51 assert(Index >= IndexFirst && Index < IndexLast &&
52 "unexpected CoroSubFnInst index argument");
53 return static_cast<ResumeKind>(Index);
54 }
55
57 return cast<ConstantInt>(getArgOperand(IndexArg));
58 }
59
60 // Methods to support type inquiry through isa, cast, and dyn_cast:
61 static bool classof(const IntrinsicInst *I) {
62 return I->getIntrinsicID() == Intrinsic::coro_subfn_addr;
63 }
64 static bool classof(const Value *V) {
65 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
66 }
67};
68
69/// This represents the llvm.coro.alloc instruction.
71public:
72 // Methods to support type inquiry through isa, cast, and dyn_cast:
73 static bool classof(const IntrinsicInst *I) {
74 return I->getIntrinsicID() == Intrinsic::coro_alloc;
75 }
76 static bool classof(const Value *V) {
77 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
78 }
79};
80
81/// This represents a common base class for llvm.coro.id instructions.
83public:
85 for (User *U : users())
86 if (auto *CA = dyn_cast<CoroAllocInst>(U))
87 return CA;
88 return nullptr;
89 }
90
92 for (User *U : users())
93 if (auto *II = dyn_cast<IntrinsicInst>(U))
94 if (II->getIntrinsicID() == Intrinsic::coro_begin)
95 return II;
96 llvm_unreachable("no coro.begin associated with coro.id");
97 }
98
99 // Methods to support type inquiry through isa, cast, and dyn_cast:
100 static bool classof(const IntrinsicInst *I) {
101 auto ID = I->getIntrinsicID();
102 return ID == Intrinsic::coro_id || ID == Intrinsic::coro_id_retcon ||
103 ID == Intrinsic::coro_id_retcon_once ||
104 ID == Intrinsic::coro_id_async;
105 }
106
107 static bool classof(const Value *V) {
108 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
109 }
110};
111
112/// This represents the llvm.coro.id instruction.
114 enum { AlignArg, PromiseArg, CoroutineArg, InfoArg };
115
116public:
118 Value *Arg = getArgOperand(PromiseArg);
119 return isa<ConstantPointerNull>(Arg)
120 ? nullptr
121 : cast<AllocaInst>(Arg->stripPointerCasts());
122 }
123
125 Value *Arg = getArgOperand(PromiseArg);
126 setArgOperand(PromiseArg,
128 if (isa<AllocaInst>(Arg))
129 return;
130 assert((isa<BitCastInst>(Arg) || isa<GetElementPtrInst>(Arg)) &&
131 "unexpected instruction designating the promise");
132 // TODO: Add a check that any remaining users of Inst are after coro.begin
133 // or add code to move the users after coro.begin.
134 auto *Inst = cast<Instruction>(Arg);
135 if (Inst->use_empty()) {
136 Inst->eraseFromParent();
137 return;
138 }
139 Inst->moveBefore(getCoroBegin()->getNextNode());
140 }
141
142 // Info argument of coro.id is
143 // fresh out of the frontend: null ;
144 // outlined : {Init, Return, Susp1, Susp2, ...} ;
145 // postsplit : [resume, destroy, cleanup] ;
146 //
147 // If parts of the coroutine were outlined to protect against undesirable
148 // code motion, these functions will be stored in a struct literal referred to
149 // by the Info parameter. Note: this is only needed before coroutine is split.
150 //
151 // After coroutine is split, resume functions are stored in an array
152 // referred to by this parameter.
153
154 struct Info {
155 ConstantStruct *OutlinedParts = nullptr;
156 ConstantArray *Resumers = nullptr;
157
158 bool hasOutlinedParts() const { return OutlinedParts != nullptr; }
159 bool isPostSplit() const { return Resumers != nullptr; }
160 bool isPreSplit() const { return !isPostSplit(); }
161 };
162 Info getInfo() const {
163 Info Result;
164 auto *GV = dyn_cast<GlobalVariable>(getRawInfo());
165 if (!GV)
166 return Result;
167
168 assert(GV->isConstant() && GV->hasDefinitiveInitializer());
169 Constant *Initializer = GV->getInitializer();
170 if ((Result.OutlinedParts = dyn_cast<ConstantStruct>(Initializer)))
171 return Result;
172
173 Result.Resumers = cast<ConstantArray>(Initializer);
174 return Result;
175 }
177 return cast<Constant>(getArgOperand(InfoArg)->stripPointerCasts());
178 }
179
180 void setInfo(Constant *C) { setArgOperand(InfoArg, C); }
181
183 return cast<Function>(getArgOperand(CoroutineArg)->stripPointerCasts());
184 }
186 assert(isa<ConstantPointerNull>(getArgOperand(CoroutineArg)) &&
187 "Coroutine argument is already assigned");
188 auto *const Int8PtrTy = Type::getInt8PtrTy(getContext());
189 setArgOperand(CoroutineArg,
191 }
192
193 // Methods to support type inquiry through isa, cast, and dyn_cast:
194 static bool classof(const IntrinsicInst *I) {
195 return I->getIntrinsicID() == Intrinsic::coro_id;
196 }
197 static bool classof(const Value *V) {
198 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
199 }
200};
201
202/// This represents either the llvm.coro.id.retcon or
203/// llvm.coro.id.retcon.once instruction.
205 enum { SizeArg, AlignArg, StorageArg, PrototypeArg, AllocArg, DeallocArg };
206
207public:
208 void checkWellFormed() const;
209
211 return cast<ConstantInt>(getArgOperand(SizeArg))->getZExtValue();
212 }
213
215 return cast<ConstantInt>(getArgOperand(AlignArg))->getAlignValue();
216 }
217
218 Value *getStorage() const {
219 return getArgOperand(StorageArg);
220 }
221
222 /// Return the prototype for the continuation function. The type,
223 /// attributes, and calling convention of the continuation function(s)
224 /// are taken from this declaration.
226 return cast<Function>(getArgOperand(PrototypeArg)->stripPointerCasts());
227 }
228
229 /// Return the function to use for allocating memory.
231 return cast<Function>(getArgOperand(AllocArg)->stripPointerCasts());
232 }
233
234 /// Return the function to use for deallocating memory.
236 return cast<Function>(getArgOperand(DeallocArg)->stripPointerCasts());
237 }
238
239 // Methods to support type inquiry through isa, cast, and dyn_cast:
240 static bool classof(const IntrinsicInst *I) {
241 auto ID = I->getIntrinsicID();
242 return ID == Intrinsic::coro_id_retcon
243 || ID == Intrinsic::coro_id_retcon_once;
244 }
245 static bool classof(const Value *V) {
246 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
247 }
248};
249
250/// This represents the llvm.coro.id.retcon instruction.
252 : public AnyCoroIdRetconInst {
253public:
254 // Methods to support type inquiry through isa, cast, and dyn_cast:
255 static bool classof(const IntrinsicInst *I) {
256 return I->getIntrinsicID() == Intrinsic::coro_id_retcon;
257 }
258 static bool classof(const Value *V) {
259 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
260 }
261};
262
263/// This represents the llvm.coro.id.retcon.once instruction.
265 : public AnyCoroIdRetconInst {
266public:
267 // Methods to support type inquiry through isa, cast, and dyn_cast:
268 static bool classof(const IntrinsicInst *I) {
269 return I->getIntrinsicID() == Intrinsic::coro_id_retcon_once;
270 }
271 static bool classof(const Value *V) {
272 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
273 }
274};
275
276/// This represents the llvm.coro.id.async instruction.
278 enum { SizeArg, AlignArg, StorageArg, AsyncFuncPtrArg };
279
280public:
281 void checkWellFormed() const;
282
283 /// The initial async function context size. The fields of which are reserved
284 /// for use by the frontend. The frame will be allocated as a tail of this
285 /// context.
287 return cast<ConstantInt>(getArgOperand(SizeArg))->getZExtValue();
288 }
289
290 /// The alignment of the initial async function context.
292 return cast<ConstantInt>(getArgOperand(AlignArg))->getAlignValue();
293 }
294
295 /// The async context parameter.
296 Value *getStorage() const {
297 return getParent()->getParent()->getArg(getStorageArgumentIndex());
298 }
299
300 unsigned getStorageArgumentIndex() const {
301 auto *Arg = cast<ConstantInt>(getArgOperand(StorageArg));
302 return Arg->getZExtValue();
303 }
304
305 /// Return the async function pointer address. This should be the address of
306 /// a async function pointer struct for the current async function.
307 /// struct async_function_pointer {
308 /// uint32_t context_size;
309 /// uint32_t relative_async_function_pointer;
310 /// };
312 return cast<GlobalVariable>(
313 getArgOperand(AsyncFuncPtrArg)->stripPointerCasts());
314 }
315
316 // Methods to support type inquiry through isa, cast, and dyn_cast:
317 static bool classof(const IntrinsicInst *I) {
318 auto ID = I->getIntrinsicID();
319 return ID == Intrinsic::coro_id_async;
320 }
321
322 static bool classof(const Value *V) {
323 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
324 }
325};
326
327/// This represents the llvm.coro.context.alloc instruction.
329 enum { AsyncFuncPtrArg };
330
331public:
333 return cast<GlobalVariable>(
334 getArgOperand(AsyncFuncPtrArg)->stripPointerCasts());
335 }
336
337 // Methods to support type inquiry through isa, cast, and dyn_cast:
338 static bool classof(const IntrinsicInst *I) {
339 return I->getIntrinsicID() == Intrinsic::coro_async_context_alloc;
340 }
341 static bool classof(const Value *V) {
342 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
343 }
344};
345
346/// This represents the llvm.coro.context.dealloc instruction.
348 : public IntrinsicInst {
349 enum { AsyncContextArg };
350
351public:
353 return getArgOperand(AsyncContextArg)->stripPointerCasts();
354 }
355
356 // Methods to support type inquiry through isa, cast, and dyn_cast:
357 static bool classof(const IntrinsicInst *I) {
358 return I->getIntrinsicID() == Intrinsic::coro_async_context_dealloc;
359 }
360 static bool classof(const Value *V) {
361 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
362 }
363};
364
365/// This represents the llvm.coro.async.resume instruction.
366/// During lowering this is replaced by the resume function of a suspend point
367/// (the continuation function).
369public:
370 // Methods to support type inquiry through isa, cast, and dyn_cast:
371 static bool classof(const IntrinsicInst *I) {
372 return I->getIntrinsicID() == Intrinsic::coro_async_resume;
373 }
374 static bool classof(const Value *V) {
375 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
376 }
377};
378
379/// This represents the llvm.coro.async.size.replace instruction.
381public:
382 // Methods to support type inquiry through isa, cast, and dyn_cast:
383 static bool classof(const IntrinsicInst *I) {
384 return I->getIntrinsicID() == Intrinsic::coro_async_size_replace;
385 }
386 static bool classof(const Value *V) {
387 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
388 }
389};
390
391/// This represents the llvm.coro.frame instruction.
393public:
394 // Methods to support type inquiry through isa, cast, and dyn_cast:
395 static bool classof(const IntrinsicInst *I) {
396 return I->getIntrinsicID() == Intrinsic::coro_frame;
397 }
398 static bool classof(const Value *V) {
399 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
400 }
401};
402
403/// This represents the llvm.coro.free instruction.
405 enum { IdArg, FrameArg };
406
407public:
408 Value *getFrame() const { return getArgOperand(FrameArg); }
409
410 // Methods to support type inquiry through isa, cast, and dyn_cast:
411 static bool classof(const IntrinsicInst *I) {
412 return I->getIntrinsicID() == Intrinsic::coro_free;
413 }
414 static bool classof(const Value *V) {
415 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
416 }
417};
418
419/// This class represents the llvm.coro.begin instruction.
421 enum { IdArg, MemArg };
422
423public:
425 return cast<AnyCoroIdInst>(getArgOperand(IdArg));
426 }
427
428 Value *getMem() const { return getArgOperand(MemArg); }
429
430 // Methods for support type inquiry through isa, cast, and dyn_cast:
431 static bool classof(const IntrinsicInst *I) {
432 return I->getIntrinsicID() == Intrinsic::coro_begin;
433 }
434 static bool classof(const Value *V) {
435 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
436 }
437};
438
439/// This represents the llvm.coro.save instruction.
441public:
442 // Methods to support type inquiry through isa, cast, and dyn_cast:
443 static bool classof(const IntrinsicInst *I) {
444 return I->getIntrinsicID() == Intrinsic::coro_save;
445 }
446 static bool classof(const Value *V) {
447 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
448 }
449};
450
451/// This represents the llvm.coro.promise instruction.
453 enum { FrameArg, AlignArg, FromArg };
454
455public:
456 /// Are we translating from the frame to the promise (false) or from
457 /// the promise to the frame (true)?
458 bool isFromPromise() const {
459 return cast<Constant>(getArgOperand(FromArg))->isOneValue();
460 }
461
462 /// The required alignment of the promise. This must match the
463 /// alignment of the promise alloca in the coroutine.
465 return cast<ConstantInt>(getArgOperand(AlignArg))->getAlignValue();
466 }
467
468 // Methods to support type inquiry through isa, cast, and dyn_cast:
469 static bool classof(const IntrinsicInst *I) {
470 return I->getIntrinsicID() == Intrinsic::coro_promise;
471 }
472 static bool classof(const Value *V) {
473 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
474 }
475};
476
478public:
479 CoroSaveInst *getCoroSave() const;
480
481 // Methods to support type inquiry through isa, cast, and dyn_cast:
482 static bool classof(const IntrinsicInst *I) {
483 return I->getIntrinsicID() == Intrinsic::coro_suspend ||
484 I->getIntrinsicID() == Intrinsic::coro_suspend_async ||
485 I->getIntrinsicID() == Intrinsic::coro_suspend_retcon;
486 }
487 static bool classof(const Value *V) {
488 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
489 }
490};
491
492/// This represents the llvm.coro.suspend instruction.
494 enum { SaveArg, FinalArg };
495
496public:
498 Value *Arg = getArgOperand(SaveArg);
499 if (auto *SI = dyn_cast<CoroSaveInst>(Arg))
500 return SI;
501 assert(isa<ConstantTokenNone>(Arg));
502 return nullptr;
503 }
504
505 bool isFinal() const {
506 return cast<Constant>(getArgOperand(FinalArg))->isOneValue();
507 }
508
509 // Methods to support type inquiry through isa, cast, and dyn_cast:
510 static bool classof(const IntrinsicInst *I) {
511 return I->getIntrinsicID() == Intrinsic::coro_suspend;
512 }
513 static bool classof(const Value *V) {
514 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
515 }
516};
517
519 if (auto Suspend = dyn_cast<CoroSuspendInst>(this))
520 return Suspend->getCoroSave();
521 return nullptr;
522}
523
524/// This represents the llvm.coro.suspend.async instruction.
526public:
527 enum {
531 MustTailCallFuncArg
532 };
533
534 void checkWellFormed() const;
535
536 unsigned getStorageArgumentIndex() const {
537 auto *Arg = cast<ConstantInt>(getArgOperand(StorageArgNoArg));
538 return Arg->getZExtValue();
539 }
540
542 return cast<Function>(
543 getArgOperand(AsyncContextProjectionArg)->stripPointerCasts());
544 }
545
547 return cast<CoroAsyncResumeInst>(
548 getArgOperand(ResumeFunctionArg)->stripPointerCasts());
549 }
550
552 return cast<Function>(
553 getArgOperand(MustTailCallFuncArg)->stripPointerCasts());
554 }
555
556 // Methods to support type inquiry through isa, cast, and dyn_cast:
557 static bool classof(const IntrinsicInst *I) {
558 return I->getIntrinsicID() == Intrinsic::coro_suspend_async;
559 }
560 static bool classof(const Value *V) {
561 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
562 }
563};
564
565/// This represents the llvm.coro.suspend.retcon instruction.
567public:
568 op_iterator value_begin() { return arg_begin(); }
569 const_op_iterator value_begin() const { return arg_begin(); }
570
571 op_iterator value_end() { return arg_end(); }
572 const_op_iterator value_end() const { return arg_end(); }
573
575 return make_range(value_begin(), value_end());
576 }
578 return make_range(value_begin(), value_end());
579 }
580
581 // Methods to support type inquiry through isa, cast, and dyn_cast:
582 static bool classof(const IntrinsicInst *I) {
583 return I->getIntrinsicID() == Intrinsic::coro_suspend_retcon;
584 }
585 static bool classof(const Value *V) {
586 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
587 }
588};
589
590/// This represents the llvm.coro.size instruction.
592public:
593 // Methods to support type inquiry through isa, cast, and dyn_cast:
594 static bool classof(const IntrinsicInst *I) {
595 return I->getIntrinsicID() == Intrinsic::coro_size;
596 }
597 static bool classof(const Value *V) {
598 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
599 }
600};
601
602/// This represents the llvm.coro.align instruction.
604public:
605 // Methods to support type inquiry through isa, cast, and dyn_cast:
606 static bool classof(const IntrinsicInst *I) {
607 return I->getIntrinsicID() == Intrinsic::coro_align;
608 }
609 static bool classof(const Value *V) {
610 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
611 }
612};
613
615 enum { FrameArg, UnwindArg };
616
617public:
618 bool isFallthrough() const { return !isUnwind(); }
619 bool isUnwind() const {
620 return cast<Constant>(getArgOperand(UnwindArg))->isOneValue();
621 }
622
623 // Methods to support type inquiry through isa, cast, and dyn_cast:
624 static bool classof(const IntrinsicInst *I) {
625 auto ID = I->getIntrinsicID();
626 return ID == Intrinsic::coro_end || ID == Intrinsic::coro_end_async;
627 }
628 static bool classof(const Value *V) {
629 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
630 }
631};
632
633/// This represents the llvm.coro.end instruction.
635public:
636 // Methods to support type inquiry through isa, cast, and dyn_cast:
637 static bool classof(const IntrinsicInst *I) {
638 return I->getIntrinsicID() == Intrinsic::coro_end;
639 }
640 static bool classof(const Value *V) {
641 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
642 }
643};
644
645/// This represents the llvm.coro.end instruction.
647 enum { FrameArg, UnwindArg, MustTailCallFuncArg };
648
649public:
650 void checkWellFormed() const;
651
653 if (arg_size() < 3)
654 return nullptr;
655
656 return cast<Function>(
657 getArgOperand(MustTailCallFuncArg)->stripPointerCasts());
658 }
659
660 // Methods to support type inquiry through isa, cast, and dyn_cast:
661 static bool classof(const IntrinsicInst *I) {
662 return I->getIntrinsicID() == Intrinsic::coro_end_async;
663 }
664 static bool classof(const Value *V) {
665 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
666 }
667};
668
669/// This represents the llvm.coro.alloca.alloc instruction.
671 enum { SizeArg, AlignArg };
672public:
673 Value *getSize() const {
674 return getArgOperand(SizeArg);
675 }
677 return cast<ConstantInt>(getArgOperand(AlignArg))->getAlignValue();
678 }
679
680 // Methods to support type inquiry through isa, cast, and dyn_cast:
681 static bool classof(const IntrinsicInst *I) {
682 return I->getIntrinsicID() == Intrinsic::coro_alloca_alloc;
683 }
684 static bool classof(const Value *V) {
685 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
686 }
687};
688
689/// This represents the llvm.coro.alloca.get instruction.
691 enum { AllocArg };
692public:
694 return cast<CoroAllocaAllocInst>(getArgOperand(AllocArg));
695 }
696
697 // Methods to support type inquiry through isa, cast, and dyn_cast:
698 static bool classof(const IntrinsicInst *I) {
699 return I->getIntrinsicID() == Intrinsic::coro_alloca_get;
700 }
701 static bool classof(const Value *V) {
702 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
703 }
704};
705
706/// This represents the llvm.coro.alloca.free instruction.
708 enum { AllocArg };
709public:
711 return cast<CoroAllocaAllocInst>(getArgOperand(AllocArg));
712 }
713
714 // Methods to support type inquiry through isa, cast, and dyn_cast:
715 static bool classof(const IntrinsicInst *I) {
716 return I->getIntrinsicID() == Intrinsic::coro_alloca_free;
717 }
718 static bool classof(const Value *V) {
719 return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
720 }
721};
722
723} // End namespace llvm.
724
725#endif
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static const Function * getParent(const Value *V)
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library,...
Definition: Compiler.h:126
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:236
iv users
Definition: IVUsers.cpp:48
#define I(x, y, z)
Definition: MD5.cpp:58
@ SI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
an instruction to allocate memory on the stack
Definition: Instructions.h:58
bool isFallthrough() const
Definition: CoroInstr.h:618
static bool classof(const Value *V)
Definition: CoroInstr.h:628
bool isUnwind() const
Definition: CoroInstr.h:619
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:624
This represents a common base class for llvm.coro.id instructions.
Definition: CoroInstr.h:82
IntrinsicInst * getCoroBegin()
Definition: CoroInstr.h:91
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:100
static bool classof(const Value *V)
Definition: CoroInstr.h:107
CoroAllocInst * getCoroAlloc()
Definition: CoroInstr.h:84
This represents either the llvm.coro.id.retcon or llvm.coro.id.retcon.once instruction.
Definition: CoroInstr.h:204
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:240
Value * getStorage() const
Definition: CoroInstr.h:218
Align getStorageAlignment() const
Definition: CoroInstr.h:214
Function * getPrototype() const
Return the prototype for the continuation function.
Definition: CoroInstr.h:225
uint64_t getStorageSize() const
Definition: CoroInstr.h:210
Function * getAllocFunction() const
Return the function to use for allocating memory.
Definition: CoroInstr.h:230
static bool classof(const Value *V)
Definition: CoroInstr.h:245
Function * getDeallocFunction() const
Return the function to use for deallocating memory.
Definition: CoroInstr.h:235
static bool classof(const Value *V)
Definition: CoroInstr.h:487
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:482
CoroSaveInst * getCoroSave() const
Definition: CoroInstr.h:518
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2229
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1707
This is an important base class in LLVM.
Definition: Constant.h:41
This represents the llvm.coro.align instruction.
Definition: CoroInstr.h:603
static bool classof(const Value *V)
Definition: CoroInstr.h:609
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:606
This represents the llvm.coro.alloc instruction.
Definition: CoroInstr.h:70
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:73
static bool classof(const Value *V)
Definition: CoroInstr.h:76
This represents the llvm.coro.alloca.alloc instruction.
Definition: CoroInstr.h:670
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:681
Align getAlignment() const
Definition: CoroInstr.h:676
static bool classof(const Value *V)
Definition: CoroInstr.h:684
Value * getSize() const
Definition: CoroInstr.h:673
This represents the llvm.coro.alloca.free instruction.
Definition: CoroInstr.h:707
static bool classof(const Value *V)
Definition: CoroInstr.h:718
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:715
CoroAllocaAllocInst * getAlloc() const
Definition: CoroInstr.h:710
This represents the llvm.coro.alloca.get instruction.
Definition: CoroInstr.h:690
static bool classof(const Value *V)
Definition: CoroInstr.h:701
CoroAllocaAllocInst * getAlloc() const
Definition: CoroInstr.h:693
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:698
This represents the llvm.coro.context.alloc instruction.
Definition: CoroInstr.h:328
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:338
static bool classof(const Value *V)
Definition: CoroInstr.h:341
GlobalVariable * getAsyncFunctionPointer() const
Definition: CoroInstr.h:332
This represents the llvm.coro.context.dealloc instruction.
Definition: CoroInstr.h:348
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:357
static bool classof(const Value *V)
Definition: CoroInstr.h:360
This represents the llvm.coro.end instruction.
Definition: CoroInstr.h:646
Function * getMustTailCallFunction() const
Definition: CoroInstr.h:652
static bool classof(const Value *V)
Definition: CoroInstr.h:664
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:661
This represents the llvm.coro.async.resume instruction.
Definition: CoroInstr.h:368
static bool classof(const Value *V)
Definition: CoroInstr.h:374
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:371
This represents the llvm.coro.async.size.replace instruction.
Definition: CoroInstr.h:380
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:383
static bool classof(const Value *V)
Definition: CoroInstr.h:386
This class represents the llvm.coro.begin instruction.
Definition: CoroInstr.h:420
AnyCoroIdInst * getId() const
Definition: CoroInstr.h:424
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:431
static bool classof(const Value *V)
Definition: CoroInstr.h:434
Value * getMem() const
Definition: CoroInstr.h:428
This represents the llvm.coro.end instruction.
Definition: CoroInstr.h:634
static bool classof(const Value *V)
Definition: CoroInstr.h:640
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:637
This represents the llvm.coro.frame instruction.
Definition: CoroInstr.h:392
static bool classof(const Value *V)
Definition: CoroInstr.h:398
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:395
This represents the llvm.coro.free instruction.
Definition: CoroInstr.h:404
Value * getFrame() const
Definition: CoroInstr.h:408
static bool classof(const Value *V)
Definition: CoroInstr.h:414
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:411
This represents the llvm.coro.id.async instruction.
Definition: CoroInstr.h:277
Align getStorageAlignment() const
The alignment of the initial async function context.
Definition: CoroInstr.h:291
uint64_t getStorageSize() const
The initial async function context size.
Definition: CoroInstr.h:286
GlobalVariable * getAsyncFunctionPointer() const
Return the async function pointer address.
Definition: CoroInstr.h:311
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:317
Value * getStorage() const
The async context parameter.
Definition: CoroInstr.h:296
unsigned getStorageArgumentIndex() const
Definition: CoroInstr.h:300
static bool classof(const Value *V)
Definition: CoroInstr.h:322
This represents the llvm.coro.id instruction.
Definition: CoroInstr.h:113
static bool classof(const Value *V)
Definition: CoroInstr.h:197
void setInfo(Constant *C)
Definition: CoroInstr.h:180
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:194
Info getInfo() const
Definition: CoroInstr.h:162
Function * getCoroutine() const
Definition: CoroInstr.h:182
Constant * getRawInfo() const
Definition: CoroInstr.h:176
AllocaInst * getPromise() const
Definition: CoroInstr.h:117
void setCoroutineSelf()
Definition: CoroInstr.h:185
void clearPromise()
Definition: CoroInstr.h:124
This represents the llvm.coro.id.retcon instruction.
Definition: CoroInstr.h:252
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:255
static bool classof(const Value *V)
Definition: CoroInstr.h:258
This represents the llvm.coro.id.retcon.once instruction.
Definition: CoroInstr.h:265
static bool classof(const Value *V)
Definition: CoroInstr.h:271
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:268
This represents the llvm.coro.promise instruction.
Definition: CoroInstr.h:452
static bool classof(const Value *V)
Definition: CoroInstr.h:472
Align getAlignment() const
The required alignment of the promise.
Definition: CoroInstr.h:464
bool isFromPromise() const
Are we translating from the frame to the promise (false) or from the promise to the frame (true)?
Definition: CoroInstr.h:458
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:469
This represents the llvm.coro.save instruction.
Definition: CoroInstr.h:440
static bool classof(const Value *V)
Definition: CoroInstr.h:446
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:443
This represents the llvm.coro.size instruction.
Definition: CoroInstr.h:591
static bool classof(const Value *V)
Definition: CoroInstr.h:597
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:594
This class represents the llvm.coro.subfn.addr instruction.
Definition: CoroInstr.h:35
static bool classof(const Value *V)
Definition: CoroInstr.h:64
Value * getFrame() const
Definition: CoroInstr.h:48
ResumeKind getIndex() const
Definition: CoroInstr.h:49
ConstantInt * getRawIndex() const
Definition: CoroInstr.h:56
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:61
This represents the llvm.coro.suspend.async instruction.
Definition: CoroInstr.h:525
Function * getAsyncContextProjectionFunction() const
Definition: CoroInstr.h:541
static bool classof(const Value *V)
Definition: CoroInstr.h:560
unsigned getStorageArgumentIndex() const
Definition: CoroInstr.h:536
CoroAsyncResumeInst * getResumeFunction() const
Definition: CoroInstr.h:546
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:557
Function * getMustTailCallFunction() const
Definition: CoroInstr.h:551
This represents the llvm.coro.suspend instruction.
Definition: CoroInstr.h:493
bool isFinal() const
Definition: CoroInstr.h:505
CoroSaveInst * getCoroSave() const
Definition: CoroInstr.h:497
static bool classof(const Value *V)
Definition: CoroInstr.h:513
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:510
This represents the llvm.coro.suspend.retcon instruction.
Definition: CoroInstr.h:566
op_iterator value_begin()
Definition: CoroInstr.h:568
static bool classof(const Value *V)
Definition: CoroInstr.h:585
const_op_iterator value_begin() const
Definition: CoroInstr.h:569
const_op_iterator value_end() const
Definition: CoroInstr.h:572
iterator_range< const_op_iterator > value_operands() const
Definition: CoroInstr.h:577
iterator_range< op_iterator > value_operands()
Definition: CoroInstr.h:574
static bool classof(const IntrinsicInst *I)
Definition: CoroInstr.h:582
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:685
A range adaptor for a pair of iterators.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
bool hasOutlinedParts() const
Definition: CoroInstr.h:158
bool isPostSplit() const
Definition: CoroInstr.h:159
bool isPreSplit() const
Definition: CoroInstr.h:160