clang 22.0.0git
CodeGenFunction.h
Go to the documentation of this file.
1//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- 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//
9// This is the internal per-function state used for llvm translation.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H
14#define LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H
15
16#include "CGBuilder.h"
17#include "CGLoopInfo.h"
18#include "CGValue.h"
19#include "CodeGenModule.h"
20#include "EHScopeStack.h"
21#include "SanitizerHandler.h"
22#include "VarBypassDetector.h"
23#include "clang/AST/CharUnits.h"
25#include "clang/AST/ExprCXX.h"
26#include "clang/AST/ExprObjC.h"
30#include "clang/AST/StmtSYCL.h"
31#include "clang/AST/Type.h"
32#include "clang/Basic/ABI.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/MapVector.h"
40#include "llvm/ADT/SmallVector.h"
41#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
42#include "llvm/IR/Instructions.h"
43#include "llvm/IR/ValueHandle.h"
44#include "llvm/Support/Debug.h"
45#include "llvm/Transforms/Utils/SanitizerStats.h"
46#include <optional>
47
48namespace llvm {
49class BasicBlock;
50class ConvergenceControlInst;
51class LLVMContext;
52class MDNode;
53class SwitchInst;
54class Twine;
55class Value;
56class CanonicalLoopInfo;
57} // namespace llvm
58
59namespace clang {
60class ASTContext;
62class CXXForRangeStmt;
63class CXXTryStmt;
64class Decl;
65class LabelDecl;
66class FunctionDecl;
68class LabelStmt;
71class ObjCIvarDecl;
72class ObjCMethodDecl;
75class TargetInfo;
76class VarDecl;
78class ObjCAtTryStmt;
79class ObjCAtThrowStmt;
84class SVETypeFlags;
85class OMPExecutableDirective;
86
87namespace analyze_os_log {
89}
90
91namespace CodeGen {
92class CodeGenTypes;
93class CodeGenPGO;
94class CGCallee;
95class CGFunctionInfo;
96class CGBlockInfo;
97class CGCXXABI;
99class BlockByrefInfo;
100class BlockFieldFlags;
101class RegionCodeGenTy;
103struct OMPTaskDataTy;
104struct CGCoroData;
105
106// clang-format off
107/// The kind of evaluation to perform on values of a particular
108/// type. Basically, is the code in CGExprScalar, CGExprComplex, or
109/// CGExprAgg?
110///
111/// TODO: should vectors maybe be split out into their own thing?
117// clang-format on
118
119/// Helper class with most of the code for saving a value for a
120/// conditional expression cleanup.
122 typedef llvm::PointerIntPair<llvm::Value *, 1, bool> saved_type;
123
124 /// Answer whether the given value needs extra work to be saved.
125 static bool needsSaving(llvm::Value *value) {
126 if (!value)
127 return false;
128
129 // If it's not an instruction, we don't need to save.
130 if (!isa<llvm::Instruction>(value))
131 return false;
132
133 // If it's an instruction in the entry block, we don't need to save.
134 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
135 return (block != &block->getParent()->getEntryBlock());
136 }
137
138 static saved_type save(CodeGenFunction &CGF, llvm::Value *value);
139 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value);
140};
141
142/// A partial specialization of DominatingValue for llvm::Values that
143/// might be llvm::Instructions.
144template <class T> struct DominatingPointer<T, true> : DominatingLLVMValue {
145 typedef T *type;
147 return static_cast<T *>(DominatingLLVMValue::restore(CGF, value));
148 }
149};
150
151/// A specialization of DominatingValue for Address.
152template <> struct DominatingValue<Address> {
153 typedef Address type;
154
162
163 static bool needsSaving(type value) {
166 return true;
167 return false;
168 }
169 static saved_type save(CodeGenFunction &CGF, type value) {
170 return {DominatingLLVMValue::save(CGF, value.getBasePointer()),
171 value.getElementType(), value.getAlignment(),
172 DominatingLLVMValue::save(CGF, value.getOffset()), value.getType()};
173 }
178 }
179};
180
181/// A specialization of DominatingValue for RValue.
182template <> struct DominatingValue<RValue> {
183 typedef RValue type;
184 class saved_type {
185 enum Kind {
186 ScalarLiteral,
187 ScalarAddress,
188 AggregateLiteral,
189 AggregateAddress,
190 ComplexAddress
191 };
192 union {
193 struct {
195 } Vals;
197 };
198 LLVM_PREFERRED_TYPE(Kind)
199 unsigned K : 3;
200
202 : Vals{Val1, DominatingLLVMValue::saved_type()}, K(K) {}
203
206 : Vals{Val1, Val2}, K(ComplexAddress) {}
207
208 saved_type(DominatingValue<Address>::saved_type AggregateAddr, unsigned K)
209 : AggregateAddr(AggregateAddr), K(K) {}
210
211 public:
212 static bool needsSaving(RValue value);
213 static saved_type save(CodeGenFunction &CGF, RValue value);
215
216 // implementations in CGCleanup.cpp
217 };
218
219 static bool needsSaving(type value) { return saved_type::needsSaving(value); }
220 static saved_type save(CodeGenFunction &CGF, type value) {
221 return saved_type::save(CGF, value);
222 }
224 return value.restore(CGF);
225 }
226};
227
228/// A scoped helper to set the current source atom group for
229/// CGDebugInfo::addInstToCurrentSourceAtom. A source atom is a source construct
230/// that is "interesting" for debug stepping purposes. We use an atom group
231/// number to track the instruction(s) that implement the functionality for the
232/// atom, plus backup instructions/source locations.
233class ApplyAtomGroup {
234 uint64_t OriginalAtom = 0;
235 CGDebugInfo *DI = nullptr;
236
237 ApplyAtomGroup(const ApplyAtomGroup &) = delete;
238 void operator=(const ApplyAtomGroup &) = delete;
239
240public:
241 ApplyAtomGroup(CGDebugInfo *DI);
243};
244
245/// CodeGenFunction - This class organizes the per-function state that is used
246/// while generating LLVM code.
247class CodeGenFunction : public CodeGenTypeCache {
248 CodeGenFunction(const CodeGenFunction &) = delete;
249 void operator=(const CodeGenFunction &) = delete;
250
251 friend class CGCXXABI;
252
253public:
254 /// A jump destination is an abstract label, branching to which may
255 /// require a jump out through normal cleanups.
256 struct JumpDest {
257 JumpDest() : Block(nullptr), Index(0) {}
258 JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth,
259 unsigned Index)
260 : Block(Block), ScopeDepth(Depth), Index(Index) {}
261
262 bool isValid() const { return Block != nullptr; }
263 llvm::BasicBlock *getBlock() const { return Block; }
264 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
265 unsigned getDestIndex() const { return Index; }
266
267 // This should be used cautiously.
269 ScopeDepth = depth;
270 }
271
272 private:
273 llvm::BasicBlock *Block;
275 unsigned Index;
276 };
277
278 CodeGenModule &CGM; // Per-module state.
280
281 // For EH/SEH outlined funclets, this field points to parent's CGF
282 CodeGenFunction *ParentCGF = nullptr;
283
284 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
287
288 // Stores variables for which we can't generate correct lifetime markers
289 // because of jumps.
291
292 /// List of recently emitted OMPCanonicalLoops.
293 ///
294 /// Since OMPCanonicalLoops are nested inside other statements (in particular
295 /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
296 /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its
297 /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any
298 /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
299 /// this stack when done. Entering a new loop requires clearing this list; it
300 /// either means we start parsing a new loop nest (in which case the previous
301 /// loop nest goes out of scope) or a second loop in the same level in which
302 /// case it would be ambiguous into which of the two (or more) loops the loop
303 /// nest would extend.
305
306 /// Stack to track the Logical Operator recursion nest for MC/DC.
308
309 /// Stack to track the controlled convergence tokens.
311
312 /// Number of nested loop to be consumed by the last surrounding
313 /// loop-associated directive.
315
316 // CodeGen lambda for loops and support for ordered clause
317 typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
318 JumpDest)>
320 typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
321 const unsigned, const bool)>
323
324 // Codegen lambda for loop bounds in worksharing loop constructs
325 typedef llvm::function_ref<std::pair<LValue, LValue>(
326 CodeGenFunction &, const OMPExecutableDirective &S)>
328
329 // Codegen lambda for loop bounds in dispatch-based loop implementation
330 typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
331 CodeGenFunction &, const OMPExecutableDirective &S, Address LB,
332 Address UB)>
334
335 /// CGBuilder insert helper. This function is called after an
336 /// instruction is created using Builder.
337 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
338 llvm::BasicBlock::iterator InsertPt) const;
339
340 /// CurFuncDecl - Holds the Decl for the current outermost
341 /// non-closure context.
342 const Decl *CurFuncDecl = nullptr;
343 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
344 const Decl *CurCodeDecl = nullptr;
345 const CGFunctionInfo *CurFnInfo = nullptr;
347 llvm::Function *CurFn = nullptr;
348
349 /// If a cast expression is being visited, this holds the current cast's
350 /// expression.
351 const CastExpr *CurCast = nullptr;
352
353 /// Save Parameter Decl for coroutine.
355
356 // Holds coroutine data if the current function is a coroutine. We use a
357 // wrapper to manage its lifetime, so that we don't have to define CGCoroData
358 // in this header.
359 struct CGCoroInfo {
360 std::unique_ptr<CGCoroData> Data;
361 bool InSuspendBlock = false;
362 CGCoroInfo();
363 ~CGCoroInfo();
364 };
366
367 bool isCoroutine() const { return CurCoro.Data != nullptr; }
368
369 bool inSuspendBlock() const {
370 return isCoroutine() && CurCoro.InSuspendBlock;
371 }
372
373 // Holds FramePtr for await_suspend wrapper generation,
374 // so that __builtin_coro_frame call can be lowered
375 // directly to value of its second argument
377 llvm::Value *FramePtr = nullptr;
378 };
380
381 // Generates wrapper function for `llvm.coro.await.suspend.*` intrinisics.
382 // It encapsulates SuspendExpr in a function, to separate it's body
383 // from the main coroutine to avoid miscompilations. Intrinisic
384 // is lowered to this function call in CoroSplit pass
385 // Function signature is:
386 // <type> __await_suspend_wrapper_<name>(ptr %awaiter, ptr %hdl)
387 // where type is one of (void, i1, ptr)
388 llvm::Function *generateAwaitSuspendWrapper(Twine const &CoroName,
389 Twine const &SuspendPointName,
390 CoroutineSuspendExpr const &S);
391
392 /// CurGD - The GlobalDecl for the current function being compiled.
394
395 /// PrologueCleanupDepth - The cleanup depth enclosing all the
396 /// cleanups associated with the parameters.
398
399 /// ReturnBlock - Unified return block.
401
402 /// ReturnValue - The temporary alloca to hold the return
403 /// value. This is invalid iff the function has no return value.
405
406 /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
407 /// This is invalid if sret is not in use.
409
410 /// If a return statement is being visited, this holds the return statment's
411 /// result expression.
412 const Expr *RetExpr = nullptr;
413
414 /// Return true if a label was seen in the current scope.
416 if (CurLexicalScope)
417 return CurLexicalScope->hasLabels();
418 return !LabelMap.empty();
419 }
420
421 /// AllocaInsertPoint - This is an instruction in the entry block before which
422 /// we prefer to insert allocas.
423 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
424
425private:
426 /// PostAllocaInsertPt - This is a place in the prologue where code can be
427 /// inserted that will be dominated by all the static allocas. This helps
428 /// achieve two things:
429 /// 1. Contiguity of all static allocas (within the prologue) is maintained.
430 /// 2. All other prologue code (which are dominated by static allocas) do
431 /// appear in the source order immediately after all static allocas.
432 ///
433 /// PostAllocaInsertPt will be lazily created when it is *really* required.
434 llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr;
435
436public:
437 /// Return PostAllocaInsertPt. If it is not yet created, then insert it
438 /// immediately after AllocaInsertPt.
439 llvm::Instruction *getPostAllocaInsertPoint() {
440 if (!PostAllocaInsertPt) {
441 assert(AllocaInsertPt &&
442 "Expected static alloca insertion point at function prologue");
443 assert(AllocaInsertPt->getParent()->isEntryBlock() &&
444 "EBB should be entry block of the current code gen function");
445 PostAllocaInsertPt = AllocaInsertPt->clone();
446 PostAllocaInsertPt->setName("postallocapt");
447 PostAllocaInsertPt->insertAfter(AllocaInsertPt->getIterator());
448 }
449
450 return PostAllocaInsertPt;
451 }
452
453 /// API for captured statement code generation.
455 public:
457 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
460 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
461
463 S.getCapturedRecordDecl()->field_begin();
465 E = S.capture_end();
466 I != E; ++I, ++Field) {
467 if (I->capturesThis())
468 CXXThisFieldDecl = *Field;
469 else if (I->capturesVariable())
470 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
471 else if (I->capturesVariableByCopy())
472 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
473 }
474 }
475
476 virtual ~CGCapturedStmtInfo();
477
478 CapturedRegionKind getKind() const { return Kind; }
479
480 virtual void setContextValue(llvm::Value *V) { ThisValue = V; }
481 // Retrieve the value of the context parameter.
482 virtual llvm::Value *getContextValue() const { return ThisValue; }
483
484 /// Lookup the captured field decl for a variable.
485 virtual const FieldDecl *lookup(const VarDecl *VD) const {
486 return CaptureFields.lookup(VD->getCanonicalDecl());
487 }
488
489 bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; }
490 virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; }
491
492 static bool classof(const CGCapturedStmtInfo *) { return true; }
493
494 /// Emit the captured statement body.
495 virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
497 CGF.EmitStmt(S);
498 }
499
500 /// Get the name of the capture helper.
501 virtual StringRef getHelperName() const { return "__captured_stmt"; }
502
503 /// Get the CaptureFields
504 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() {
505 return CaptureFields;
506 }
507
508 private:
509 /// The kind of captured statement being generated.
511
512 /// Keep the map between VarDecl and FieldDecl.
513 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields;
514
515 /// The base address of the captured record, passed in as the first
516 /// argument of the parallel region function.
517 llvm::Value *ThisValue;
518
519 /// Captured 'this' type.
520 FieldDecl *CXXThisFieldDecl;
521 };
523
524 /// RAII for correct setting/restoring of CapturedStmtInfo.
526 private:
527 CodeGenFunction &CGF;
528 CGCapturedStmtInfo *PrevCapturedStmtInfo;
529
530 public:
531 CGCapturedStmtRAII(CodeGenFunction &CGF,
532 CGCapturedStmtInfo *NewCapturedStmtInfo)
533 : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
534 CGF.CapturedStmtInfo = NewCapturedStmtInfo;
535 }
536 ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
537 };
538
539 /// An abstract representation of regular/ObjC call/message targets.
541 /// The function declaration of the callee.
542 const Decl *CalleeDecl;
543
544 public:
545 AbstractCallee() : CalleeDecl(nullptr) {}
546 AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
547 AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {}
548 bool hasFunctionDecl() const {
549 return isa_and_nonnull<FunctionDecl>(CalleeDecl);
550 }
551 const Decl *getDecl() const { return CalleeDecl; }
552 unsigned getNumParams() const {
553 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
554 return FD->getNumParams();
555 return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
556 }
557 const ParmVarDecl *getParamDecl(unsigned I) const {
558 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
559 return FD->getParamDecl(I);
560 return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
561 }
562 };
563
564 /// Sanitizers enabled for this function.
566
567 /// True if CodeGen currently emits code implementing sanitizer checks.
568 bool IsSanitizerScope = false;
569
570 /// RAII object to set/unset CodeGenFunction::IsSanitizerScope.
572 CodeGenFunction *CGF;
573
574 public:
575 SanitizerScope(CodeGenFunction *CGF);
577 };
578
579 /// In C++, whether we are code generating a thunk. This controls whether we
580 /// should emit cleanups.
581 bool CurFuncIsThunk = false;
582
583 /// In ARC, whether we should autorelease the return value.
584 bool AutoreleaseResult = false;
585
586 /// Whether we processed a Microsoft-style asm block during CodeGen. These can
587 /// potentially set the return value.
588 bool SawAsmBlock = false;
589
591
592 /// True if the current function is an outlined SEH helper. This can be a
593 /// finally block or filter expression.
595
596 /// True if CodeGen currently emits code inside presereved access index
597 /// region.
599
600 /// True if the current statement has nomerge attribute.
602
603 /// True if the current statement has noinline attribute.
605
606 /// True if the current statement has always_inline attribute.
608
609 /// True if the current statement has noconvergent attribute.
611
612 /// HLSL Branch attribute.
613 HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr =
614 HLSLControlFlowHintAttr::SpellingNotCalculated;
615
616 // The CallExpr within the current statement that the musttail attribute
617 // applies to. nullptr if there is no 'musttail' on the current statement.
618 const CallExpr *MustTailCall = nullptr;
619
620 /// Returns true if a function must make progress, which means the
621 /// mustprogress attribute can be added.
623 if (CGM.getCodeGenOpts().getFiniteLoops() ==
625 return false;
626
627 // C++11 and later guarantees that a thread eventually will do one of the
628 // following (C++11 [intro.multithread]p24 and C++17 [intro.progress]p1):
629 // - terminate,
630 // - make a call to a library I/O function,
631 // - perform an access through a volatile glvalue, or
632 // - perform a synchronization operation or an atomic operation.
633 //
634 // Hence each function is 'mustprogress' in C++11 or later.
635 return getLangOpts().CPlusPlus11;
636 }
637
638 /// Returns true if a loop must make progress, which means the mustprogress
639 /// attribute can be added. \p HasConstantCond indicates whether the branch
640 /// condition is a known constant.
641 bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody);
642
644 llvm::Value *BlockPointer = nullptr;
645
646 llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
648
649 /// A mapping from NRVO variables to the flags used to indicate
650 /// when the NRVO has been applied to this variable.
651 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
652
655
656 // A stack of cleanups which were added to EHStack but have to be deactivated
657 // later before being popped or emitted. These are usually deactivated on
658 // exiting a `CleanupDeactivationScope` scope. For instance, after a
659 // full-expr.
660 //
661 // These are specially useful for correctly emitting cleanups while
662 // encountering branches out of expression (through stmt-expr or coroutine
663 // suspensions).
669
670 // Enters a new scope for capturing cleanups which are deferred to be
671 // deactivated, all of which will be deactivated once the scope is exited.
673 CodeGenFunction &CGF;
680
682 assert(!Deactivated && "Deactivating already deactivated scope");
683 auto &Stack = CGF.DeferredDeactivationCleanupStack;
684 for (size_t I = Stack.size(); I > OldDeactivateCleanupStackSize; I--) {
685 CGF.DeactivateCleanupBlock(Stack[I - 1].Cleanup,
686 Stack[I - 1].DominatingIP);
687 Stack[I - 1].DominatingIP->eraseFromParent();
688 }
689 Stack.resize(OldDeactivateCleanupStackSize);
690 Deactivated = true;
691 }
692
694 if (Deactivated)
695 return;
697 }
698 };
699
701
702 llvm::Instruction *CurrentFuncletPad = nullptr;
703
704 class CallLifetimeEnd final : public EHScopeStack::Cleanup {
705 bool isRedundantBeforeReturn() override { return true; }
706
707 llvm::Value *Addr;
708
709 public:
710 CallLifetimeEnd(RawAddress addr) : Addr(addr.getPointer()) {}
711
712 void Emit(CodeGenFunction &CGF, Flags flags) override {
713 CGF.EmitLifetimeEnd(Addr);
714 }
715 };
716
717 // We are using objects of this 'cleanup' class to emit fake.use calls
718 // for -fextend-variable-liveness. They are placed at the end of a variable's
719 // scope analogous to lifetime markers.
720 class FakeUse final : public EHScopeStack::Cleanup {
721 Address Addr;
722
723 public:
724 FakeUse(Address addr) : Addr(addr) {}
725
726 void Emit(CodeGenFunction &CGF, Flags flags) override {
727 CGF.EmitFakeUse(Addr);
728 }
729 };
730
731 /// Header for data within LifetimeExtendedCleanupStack.
732 struct alignas(uint64_t) LifetimeExtendedCleanupHeader {
733 /// The size of the following cleanup object.
734 unsigned Size;
735 /// The kind of cleanup to push.
736 LLVM_PREFERRED_TYPE(CleanupKind)
738 /// Whether this is a conditional cleanup.
739 LLVM_PREFERRED_TYPE(bool)
740 unsigned IsConditional : 1;
741
742 size_t getSize() const { return Size; }
743 CleanupKind getKind() const { return (CleanupKind)Kind; }
744 bool isConditional() const { return IsConditional; }
745 };
746
747 /// i32s containing the indexes of the cleanup destinations.
749
751
752 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
753 llvm::BasicBlock *EHResumeBlock = nullptr;
754
755 /// The exception slot. All landing pads write the current exception pointer
756 /// into this alloca.
757 llvm::Value *ExceptionSlot = nullptr;
758
759 /// The selector slot. Under the MandatoryCleanup model, all landing pads
760 /// write the current selector value into this alloca.
761 llvm::AllocaInst *EHSelectorSlot = nullptr;
762
763 /// A stack of exception code slots. Entering an __except block pushes a slot
764 /// on the stack and leaving pops one. The __exception_code() intrinsic loads
765 /// a value from the top of the stack.
767
768 /// Value returned by __exception_info intrinsic.
769 llvm::Value *SEHInfo = nullptr;
770
771 /// Emits a landing pad for the current EH stack.
772 llvm::BasicBlock *EmitLandingPad();
773
774 llvm::BasicBlock *getInvokeDestImpl();
775
776 /// Parent loop-based directive for scan directive.
778 llvm::BasicBlock *OMPBeforeScanBlock = nullptr;
779 llvm::BasicBlock *OMPAfterScanBlock = nullptr;
780 llvm::BasicBlock *OMPScanExitBlock = nullptr;
781 llvm::BasicBlock *OMPScanDispatch = nullptr;
782 bool OMPFirstScanLoop = false;
783
784 /// Manages parent directive for scan directives.
786 CodeGenFunction &CGF;
787 const OMPExecutableDirective *ParentLoopDirectiveForScan;
788
789 public:
791 CodeGenFunction &CGF,
792 const OMPExecutableDirective &ParentLoopDirectiveForScan)
793 : CGF(CGF),
794 ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) {
795 CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan;
796 }
798 CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan;
799 }
800 };
801
802 template <class T>
804 return DominatingValue<T>::save(*this, value);
805 }
806
808 public:
809 CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures);
810 CGFPOptionsRAII(CodeGenFunction &CGF, const Expr *E);
812
813 private:
814 void ConstructorHelper(FPOptions FPFeatures);
815 CodeGenFunction &CGF;
816 FPOptions OldFPFeatures;
817 llvm::fp::ExceptionBehavior OldExcept;
818 llvm::RoundingMode OldRounding;
819 std::optional<CGBuilderTy::FastMathFlagGuard> FMFGuard;
820 };
822
824 public:
826 : CGM(CGM_), SavedAtomicOpts(CGM.getAtomicOpts()) {
827 CGM.setAtomicOpts(AO);
828 }
829 CGAtomicOptionsRAII(CodeGenModule &CGM_, const AtomicAttr *AA)
830 : CGM(CGM_), SavedAtomicOpts(CGM.getAtomicOpts()) {
831 if (!AA)
832 return;
833 AtomicOptions AO = SavedAtomicOpts;
834 for (auto Option : AA->atomicOptions()) {
835 switch (Option) {
836 case AtomicAttr::remote_memory:
837 AO.remote_memory = true;
838 break;
839 case AtomicAttr::no_remote_memory:
840 AO.remote_memory = false;
841 break;
842 case AtomicAttr::fine_grained_memory:
843 AO.fine_grained_memory = true;
844 break;
845 case AtomicAttr::no_fine_grained_memory:
846 AO.fine_grained_memory = false;
847 break;
848 case AtomicAttr::ignore_denormal_mode:
849 AO.ignore_denormal_mode = true;
850 break;
851 case AtomicAttr::no_ignore_denormal_mode:
852 AO.ignore_denormal_mode = false;
853 break;
854 }
855 }
856 CGM.setAtomicOpts(AO);
857 }
858
861 ~CGAtomicOptionsRAII() { CGM.setAtomicOpts(SavedAtomicOpts); }
862
863 private:
865 AtomicOptions SavedAtomicOpts;
866 };
867
868public:
869 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
870 /// rethrows.
872
873 /// A class controlling the emission of a finally block.
875 /// Where the catchall's edge through the cleanup should go.
876 JumpDest RethrowDest;
877
878 /// A function to call to enter the catch.
879 llvm::FunctionCallee BeginCatchFn;
880
881 /// An i1 variable indicating whether or not the @finally is
882 /// running for an exception.
883 llvm::AllocaInst *ForEHVar = nullptr;
884
885 /// An i8* variable into which the exception pointer to rethrow
886 /// has been saved.
887 llvm::AllocaInst *SavedExnVar = nullptr;
888
889 public:
890 void enter(CodeGenFunction &CGF, const Stmt *Finally,
891 llvm::FunctionCallee beginCatchFn,
892 llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
893 void exit(CodeGenFunction &CGF);
894 };
895
896 /// Returns true inside SEH __try blocks.
897 bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
898
899 /// Returns true while emitting a cleanuppad.
903
904 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
905 /// current full-expression. Safe against the possibility that
906 /// we're currently inside a conditionally-evaluated expression.
907 template <class T, class... As>
908 void pushFullExprCleanup(CleanupKind kind, As... A) {
909 // If we're not in a conditional branch, or if none of the
910 // arguments requires saving, then use the unconditional cleanup.
912 return EHStack.pushCleanup<T>(kind, A...);
913
914 // Stash values in a tuple so we can guarantee the order of saves.
915 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
916 SavedTuple Saved{saveValueInCond(A)...};
917
918 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
919 EHStack.pushCleanupTuple<CleanupType>(kind, Saved);
921 }
922
923 /// Queue a cleanup to be pushed after finishing the current full-expression,
924 /// potentially with an active flag.
925 template <class T, class... As>
929 Kind, RawAddress::invalid(), A...);
930
931 RawAddress ActiveFlag = createCleanupActiveFlag();
932 assert(!DominatingValue<Address>::needsSaving(ActiveFlag) &&
933 "cleanup active flag should never need saving");
934
935 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
936 SavedTuple Saved{saveValueInCond(A)...};
937
938 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
940 Saved);
941 }
942
943 template <class T, class... As>
945 RawAddress ActiveFlag, As... A) {
946 LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
947 ActiveFlag.isValid()};
948
949 size_t OldSize = LifetimeExtendedCleanupStack.size();
951 LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
952 (Header.IsConditional ? sizeof(ActiveFlag) : 0));
953
954 static_assert((alignof(LifetimeExtendedCleanupHeader) == alignof(T)) &&
955 (alignof(T) == alignof(RawAddress)),
956 "Cleanup will be allocated on misaligned address");
957 char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
958 new (Buffer) LifetimeExtendedCleanupHeader(Header);
959 new (Buffer + sizeof(Header)) T(A...);
960 if (Header.IsConditional)
961 new (Buffer + sizeof(Header) + sizeof(T)) RawAddress(ActiveFlag);
962 }
963
964 // Push a cleanup onto EHStack and deactivate it later. It is usually
965 // deactivated when exiting a `CleanupDeactivationScope` (for example: after a
966 // full expression).
967 template <class T, class... As>
969 // Placeholder dominating IP for this cleanup.
970 llvm::Instruction *DominatingIP =
971 Builder.CreateFlagLoad(llvm::Constant::getNullValue(Int8PtrTy));
972 EHStack.pushCleanup<T>(Kind, A...);
974 {EHStack.stable_begin(), DominatingIP});
975 }
976
977 /// Set up the last cleanup that was pushed as a conditional
978 /// full-expression cleanup.
982
985
986 /// PushDestructorCleanup - Push a cleanup to call the
987 /// complete-object destructor of an object of the given type at the
988 /// given address. Does nothing if T is not a C++ class type with a
989 /// non-trivial destructor.
991
992 /// PushDestructorCleanup - Push a cleanup to call the
993 /// complete-object variant of the given destructor on the object at
994 /// the given address.
996 Address Addr);
997
998 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
999 /// process all branch fixups.
1000 void PopCleanupBlock(bool FallThroughIsBranchThrough = false,
1001 bool ForDeactivation = false);
1002
1003 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
1004 /// The block cannot be reactivated. Pops it if it's the top of the
1005 /// stack.
1006 ///
1007 /// \param DominatingIP - An instruction which is known to
1008 /// dominate the current IP (if set) and which lies along
1009 /// all paths of execution between the current IP and the
1010 /// the point at which the cleanup comes into scope.
1012 llvm::Instruction *DominatingIP);
1013
1014 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
1015 /// Cannot be used to resurrect a deactivated cleanup.
1016 ///
1017 /// \param DominatingIP - An instruction which is known to
1018 /// dominate the current IP (if set) and which lies along
1019 /// all paths of execution between the current IP and the
1020 /// the point at which the cleanup comes into scope.
1022 llvm::Instruction *DominatingIP);
1023
1024 /// Enters a new scope for capturing cleanups, all of which
1025 /// will be executed once the scope is exited.
1026 class RunCleanupsScope {
1027 EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth;
1028 size_t LifetimeExtendedCleanupStackSize;
1029 CleanupDeactivationScope DeactivateCleanups;
1030 bool OldDidCallStackSave;
1031
1032 protected:
1034
1035 private:
1036 RunCleanupsScope(const RunCleanupsScope &) = delete;
1037 void operator=(const RunCleanupsScope &) = delete;
1038
1039 protected:
1040 CodeGenFunction &CGF;
1041
1042 public:
1043 /// Enter a new cleanup scope.
1044 explicit RunCleanupsScope(CodeGenFunction &CGF)
1045 : DeactivateCleanups(CGF), PerformCleanup(true), CGF(CGF) {
1046 CleanupStackDepth = CGF.EHStack.stable_begin();
1047 LifetimeExtendedCleanupStackSize =
1048 CGF.LifetimeExtendedCleanupStack.size();
1049 OldDidCallStackSave = CGF.DidCallStackSave;
1050 CGF.DidCallStackSave = false;
1051 OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth;
1052 CGF.CurrentCleanupScopeDepth = CleanupStackDepth;
1053 }
1054
1055 /// Exit this cleanup scope, emitting any accumulated cleanups.
1057 if (PerformCleanup)
1058 ForceCleanup();
1059 }
1060
1061 /// Determine whether this scope requires any cleanups.
1062 bool requiresCleanups() const {
1063 return CGF.EHStack.stable_begin() != CleanupStackDepth;
1064 }
1065
1066 /// Force the emission of cleanups now, instead of waiting
1067 /// until this object is destroyed.
1068 /// \param ValuesToReload - A list of values that need to be available at
1069 /// the insertion point after cleanup emission. If cleanup emission created
1070 /// a shared cleanup block, these value pointers will be rewritten.
1071 /// Otherwise, they not will be modified.
1072 void
1073 ForceCleanup(std::initializer_list<llvm::Value **> ValuesToReload = {}) {
1074 assert(PerformCleanup && "Already forced cleanup");
1075 CGF.DidCallStackSave = OldDidCallStackSave;
1076 DeactivateCleanups.ForceDeactivate();
1077 CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
1078 ValuesToReload);
1079 PerformCleanup = false;
1080 CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
1081 }
1082 };
1083
1084 // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
1087
1088 class LexicalScope : public RunCleanupsScope {
1089 SourceRange Range;
1091 LexicalScope *ParentScope;
1092
1093 LexicalScope(const LexicalScope &) = delete;
1094 void operator=(const LexicalScope &) = delete;
1095
1096 public:
1097 /// Enter a new cleanup scope.
1098 explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range);
1099
1100 void addLabel(const LabelDecl *label) {
1101 assert(PerformCleanup && "adding label to dead scope?");
1102 Labels.push_back(label);
1103 }
1104
1105 /// Exit this cleanup scope, emitting any accumulated
1106 /// cleanups.
1107 ~LexicalScope();
1108
1109 /// Force the emission of cleanups now, instead of waiting
1110 /// until this object is destroyed.
1112 CGF.CurLexicalScope = ParentScope;
1114
1115 if (!Labels.empty())
1116 rescopeLabels();
1117 }
1118
1119 bool hasLabels() const { return !Labels.empty(); }
1120
1121 void rescopeLabels();
1122 };
1123
1124 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
1125
1126 /// The class used to assign some variables some temporarily addresses.
1127 class OMPMapVars {
1128 DeclMapTy SavedLocals;
1129 DeclMapTy SavedTempAddresses;
1130 OMPMapVars(const OMPMapVars &) = delete;
1131 void operator=(const OMPMapVars &) = delete;
1132
1133 public:
1134 explicit OMPMapVars() = default;
1136 assert(SavedLocals.empty() && "Did not restored original addresses.");
1137 };
1138
1139 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
1140 /// function \p CGF.
1141 /// \return true if at least one variable was set already, false otherwise.
1142 bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD,
1143 Address TempAddr) {
1144 LocalVD = LocalVD->getCanonicalDecl();
1145 // Only save it once.
1146 if (SavedLocals.count(LocalVD))
1147 return false;
1148
1149 // Copy the existing local entry to SavedLocals.
1150 auto it = CGF.LocalDeclMap.find(LocalVD);
1151 if (it != CGF.LocalDeclMap.end())
1152 SavedLocals.try_emplace(LocalVD, it->second);
1153 else
1154 SavedLocals.try_emplace(LocalVD, Address::invalid());
1155
1156 // Generate the private entry.
1157 QualType VarTy = LocalVD->getType();
1158 if (VarTy->isReferenceType()) {
1159 Address Temp = CGF.CreateMemTemp(VarTy);
1160 CGF.Builder.CreateStore(TempAddr.emitRawPointer(CGF), Temp);
1161 TempAddr = Temp;
1162 }
1163 SavedTempAddresses.try_emplace(LocalVD, TempAddr);
1164
1165 return true;
1166 }
1167
1168 /// Applies new addresses to the list of the variables.
1169 /// \return true if at least one variable is using new address, false
1170 /// otherwise.
1171 bool apply(CodeGenFunction &CGF) {
1172 copyInto(SavedTempAddresses, CGF.LocalDeclMap);
1173 SavedTempAddresses.clear();
1174 return !SavedLocals.empty();
1175 }
1176
1177 /// Restores original addresses of the variables.
1178 void restore(CodeGenFunction &CGF) {
1179 if (!SavedLocals.empty()) {
1180 copyInto(SavedLocals, CGF.LocalDeclMap);
1181 SavedLocals.clear();
1182 }
1183 }
1184
1185 private:
1186 /// Copy all the entries in the source map over the corresponding
1187 /// entries in the destination, which must exist.
1188 static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) {
1189 for (auto &[Decl, Addr] : Src) {
1190 if (!Addr.isValid())
1191 Dest.erase(Decl);
1192 else
1193 Dest.insert_or_assign(Decl, Addr);
1194 }
1195 }
1196 };
1197
1198 /// The scope used to remap some variables as private in the OpenMP loop body
1199 /// (or other captured region emitted without outlining), and to restore old
1200 /// vars back on exit.
1201 class OMPPrivateScope : public RunCleanupsScope {
1202 OMPMapVars MappedVars;
1203 OMPPrivateScope(const OMPPrivateScope &) = delete;
1204 void operator=(const OMPPrivateScope &) = delete;
1205
1206 public:
1207 /// Enter a new OpenMP private scope.
1208 explicit OMPPrivateScope(CodeGenFunction &CGF) : RunCleanupsScope(CGF) {}
1209
1210 /// Registers \p LocalVD variable as a private with \p Addr as the address
1211 /// of the corresponding private variable. \p
1212 /// PrivateGen is the address of the generated private variable.
1213 /// \return true if the variable is registered as private, false if it has
1214 /// been privatized already.
1215 bool addPrivate(const VarDecl *LocalVD, Address Addr) {
1216 assert(PerformCleanup && "adding private to dead scope");
1217 return MappedVars.setVarAddr(CGF, LocalVD, Addr);
1218 }
1219
1220 /// Privatizes local variables previously registered as private.
1221 /// Registration is separate from the actual privatization to allow
1222 /// initializers use values of the original variables, not the private one.
1223 /// This is important, for example, if the private variable is a class
1224 /// variable initialized by a constructor that references other private
1225 /// variables. But at initialization original variables must be used, not
1226 /// private copies.
1227 /// \return true if at least one variable was privatized, false otherwise.
1228 bool Privatize() { return MappedVars.apply(CGF); }
1229
1234
1235 /// Exit scope - all the mapped variables are restored.
1237 if (PerformCleanup)
1238 ForceCleanup();
1239 }
1240
1241 /// Checks if the global variable is captured in current function.
1242 bool isGlobalVarCaptured(const VarDecl *VD) const {
1243 VD = VD->getCanonicalDecl();
1244 return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1245 }
1246
1247 /// Restore all mapped variables w/o clean up. This is usefully when we want
1248 /// to reference the original variables but don't want the clean up because
1249 /// that could emit lifetime end too early, causing backend issue #56913.
1250 void restoreMap() { MappedVars.restore(CGF); }
1251 };
1252
1253 /// Save/restore original map of previously emitted local vars in case when we
1254 /// need to duplicate emission of the same code several times in the same
1255 /// function for OpenMP code.
1257 CodeGenFunction &CGF;
1258 DeclMapTy SavedMap;
1259
1260 public:
1261 OMPLocalDeclMapRAII(CodeGenFunction &CGF)
1262 : CGF(CGF), SavedMap(CGF.LocalDeclMap) {}
1263 ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); }
1264 };
1265
1266 /// Takes the old cleanup stack size and emits the cleanup blocks
1267 /// that have been added.
1268 void
1270 std::initializer_list<llvm::Value **> ValuesToReload = {});
1271
1272 /// Takes the old cleanup stack size and emits the cleanup blocks
1273 /// that have been added, then adds all lifetime-extended cleanups from
1274 /// the given position to the stack.
1275 void
1276 PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize,
1277 size_t OldLifetimeExtendedStackSize,
1278 std::initializer_list<llvm::Value **> ValuesToReload = {});
1279
1280 void ResolveBranchFixups(llvm::BasicBlock *Target);
1281
1282 /// The given basic block lies in the current EH scope, but may be a
1283 /// target of a potentially scope-crossing jump; get a stable handle
1284 /// to which we can perform this jump later.
1286 return JumpDest(Target, EHStack.getInnermostNormalCleanup(),
1288 }
1289
1290 /// The given basic block lies in the current EH scope, but may be a
1291 /// target of a potentially scope-crossing jump; get a stable handle
1292 /// to which we can perform this jump later.
1293 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
1295 }
1296
1297 /// EmitBranchThroughCleanup - Emit a branch from the current insert
1298 /// block through the normal cleanup handling code (if any) and then
1299 /// on to \arg Dest.
1300 void EmitBranchThroughCleanup(JumpDest Dest);
1301
1302 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1303 /// specified destination obviously has no cleanups to run. 'false' is always
1304 /// a conservatively correct answer for this method.
1305 bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const;
1306
1307 /// popCatchScope - Pops the catch scope at the top of the EHScope
1308 /// stack, emitting any required code (other than the catch handlers
1309 /// themselves).
1310 void popCatchScope();
1311
1312 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
1313 llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope);
1314 llvm::BasicBlock *
1316
1317 /// An object to manage conditionally-evaluated expressions.
1319 llvm::BasicBlock *StartBB;
1320
1321 public:
1322 ConditionalEvaluation(CodeGenFunction &CGF)
1323 : StartBB(CGF.Builder.GetInsertBlock()) {}
1324
1325 void begin(CodeGenFunction &CGF) {
1326 assert(CGF.OutermostConditional != this);
1327 if (!CGF.OutermostConditional)
1328 CGF.OutermostConditional = this;
1329 }
1330
1331 void end(CodeGenFunction &CGF) {
1332 assert(CGF.OutermostConditional != nullptr);
1333 if (CGF.OutermostConditional == this)
1334 CGF.OutermostConditional = nullptr;
1335 }
1336
1337 /// Returns a block which will be executed prior to each
1338 /// evaluation of the conditional code.
1339 llvm::BasicBlock *getStartingBlock() const { return StartBB; }
1340 };
1341
1342 /// isInConditionalBranch - Return true if we're currently emitting
1343 /// one branch or the other of a conditional expression.
1344 bool isInConditionalBranch() const { return OutermostConditional != nullptr; }
1345
1346 void setBeforeOutermostConditional(llvm::Value *value, Address addr,
1347 CodeGenFunction &CGF) {
1348 assert(isInConditionalBranch());
1349 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1350 auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF),
1351 block->back().getIterator());
1352 store->setAlignment(addr.getAlignment().getAsAlign());
1353 }
1354
1355 /// An RAII object to record that we're evaluating a statement
1356 /// expression.
1358 CodeGenFunction &CGF;
1359
1360 /// We have to save the outermost conditional: cleanups in a
1361 /// statement expression aren't conditional just because the
1362 /// StmtExpr is.
1363 ConditionalEvaluation *SavedOutermostConditional;
1364
1365 public:
1366 StmtExprEvaluation(CodeGenFunction &CGF)
1367 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1368 CGF.OutermostConditional = nullptr;
1369 }
1370
1372 CGF.OutermostConditional = SavedOutermostConditional;
1373 CGF.EnsureInsertPoint();
1374 }
1375 };
1376
1377 /// An object which temporarily prevents a value from being
1378 /// destroyed by aggressive peephole optimizations that assume that
1379 /// all uses of a value have been realized in the IR.
1381 llvm::Instruction *Inst = nullptr;
1382 friend class CodeGenFunction;
1383
1384 public:
1386 };
1387
1388 /// A non-RAII class containing all the information about a bound
1389 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
1390 /// this which makes individual mappings very simple; using this
1391 /// class directly is useful when you have a variable number of
1392 /// opaque values or don't want the RAII functionality for some
1393 /// reason.
1394 class OpaqueValueMappingData {
1395 const OpaqueValueExpr *OpaqueValue;
1396 bool BoundLValue;
1398
1399 OpaqueValueMappingData(const OpaqueValueExpr *ov, bool boundLValue)
1400 : OpaqueValue(ov), BoundLValue(boundLValue) {}
1401
1402 public:
1404
1405 static bool shouldBindAsLValue(const Expr *expr) {
1406 // gl-values should be bound as l-values for obvious reasons.
1407 // Records should be bound as l-values because IR generation
1408 // always keeps them in memory. Expressions of function type
1409 // act exactly like l-values but are formally required to be
1410 // r-values in C.
1411 return expr->isGLValue() || expr->getType()->isFunctionType() ||
1412 hasAggregateEvaluationKind(expr->getType());
1413 }
1414
1416 bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const Expr *e) {
1417 if (shouldBindAsLValue(ov))
1418 return bind(CGF, ov, CGF.EmitLValue(e));
1419 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1420 }
1421
1423 bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const LValue &lv) {
1424 assert(shouldBindAsLValue(ov));
1425 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1426 return OpaqueValueMappingData(ov, true);
1427 }
1428
1430 bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const RValue &rv) {
1431 assert(!shouldBindAsLValue(ov));
1432 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1433
1434 OpaqueValueMappingData data(ov, false);
1435
1436 // Work around an extremely aggressive peephole optimization in
1437 // EmitScalarConversion which assumes that all other uses of a
1438 // value are extant.
1439 data.Protection = CGF.protectFromPeepholes(rv);
1440
1441 return data;
1442 }
1443
1444 bool isValid() const { return OpaqueValue != nullptr; }
1445 void clear() { OpaqueValue = nullptr; }
1446
1447 void unbind(CodeGenFunction &CGF) {
1448 assert(OpaqueValue && "no data to unbind!");
1449
1450 if (BoundLValue) {
1451 CGF.OpaqueLValues.erase(OpaqueValue);
1452 } else {
1453 CGF.OpaqueRValues.erase(OpaqueValue);
1454 CGF.unprotectFromPeepholes(Protection);
1455 }
1456 }
1457 };
1458
1459 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1461 CodeGenFunction &CGF;
1463
1464 public:
1468
1469 /// Build the opaque value mapping for the given conditional
1470 /// operator if it's the GNU ?: extension. This is a common
1471 /// enough pattern that the convenience operator is really
1472 /// helpful.
1473 ///
1474 OpaqueValueMapping(CodeGenFunction &CGF,
1476 : CGF(CGF) {
1478 // Leave Data empty.
1479 return;
1480
1483 e->getCommon());
1484 }
1485
1486 /// Build the opaque value mapping for an OpaqueValueExpr whose source
1487 /// expression is set to the expression the OVE represents.
1488 OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *OV)
1489 : CGF(CGF) {
1490 if (OV) {
1491 assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1492 "for OVE with no source expression");
1493 Data = OpaqueValueMappingData::bind(CGF, OV, OV->getSourceExpr());
1494 }
1495 }
1496
1497 OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *opaqueValue,
1498 LValue lvalue)
1499 : CGF(CGF),
1500 Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {}
1501
1502 OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *opaqueValue,
1503 RValue rvalue)
1504 : CGF(CGF),
1505 Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {}
1506
1507 void pop() {
1508 Data.unbind(CGF);
1509 Data.clear();
1510 }
1511
1513 if (Data.isValid())
1514 Data.unbind(CGF);
1515 }
1516 };
1517
1518private:
1519 CGDebugInfo *DebugInfo;
1520 /// Used to create unique names for artificial VLA size debug info variables.
1521 unsigned VLAExprCounter = 0;
1522 bool DisableDebugInfo = false;
1523
1524 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1525 /// calling llvm.stacksave for multiple VLAs in the same scope.
1526 bool DidCallStackSave = false;
1527
1528 /// IndirectBranch - The first time an indirect goto is seen we create a block
1529 /// with an indirect branch. Every time we see the address of a label taken,
1530 /// we add the label to the indirect goto. Every subsequent indirect goto is
1531 /// codegen'd as a jump to the IndirectBranch's basic block.
1532 llvm::IndirectBrInst *IndirectBranch = nullptr;
1533
1534 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1535 /// decls.
1536 DeclMapTy LocalDeclMap;
1537
1538 // Keep track of the cleanups for callee-destructed parameters pushed to the
1539 // cleanup stack so that they can be deactivated later.
1540 llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
1541 CalleeDestructedParamCleanups;
1542
1543 /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1544 /// will contain a mapping from said ParmVarDecl to its implicit "object_size"
1545 /// parameter.
1546 llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2>
1547 SizeArguments;
1548
1549 /// Track escaped local variables with auto storage. Used during SEH
1550 /// outlining to produce a call to llvm.localescape.
1551 llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
1552
1553 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1554 llvm::DenseMap<const LabelDecl *, JumpDest> LabelMap;
1555
1556 // BreakContinueStack - This keeps track of where break and continue
1557 // statements should jump to.
1558 struct BreakContinue {
1559 BreakContinue(const Stmt &LoopOrSwitch, JumpDest Break, JumpDest Continue)
1560 : LoopOrSwitch(&LoopOrSwitch), BreakBlock(Break),
1561 ContinueBlock(Continue) {}
1562
1563 const Stmt *LoopOrSwitch;
1564 JumpDest BreakBlock;
1565 JumpDest ContinueBlock;
1566 };
1567 SmallVector<BreakContinue, 8> BreakContinueStack;
1568
1569 /// Handles cancellation exit points in OpenMP-related constructs.
1570 class OpenMPCancelExitStack {
1571 /// Tracks cancellation exit point and join point for cancel-related exit
1572 /// and normal exit.
1573 struct CancelExit {
1574 CancelExit() = default;
1575 CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
1576 JumpDest ContBlock)
1577 : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
1578 OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
1579 /// true if the exit block has been emitted already by the special
1580 /// emitExit() call, false if the default codegen is used.
1581 bool HasBeenEmitted = false;
1582 JumpDest ExitBlock;
1583 JumpDest ContBlock;
1584 };
1585
1586 SmallVector<CancelExit, 8> Stack;
1587
1588 public:
1589 OpenMPCancelExitStack() : Stack(1) {}
1590 ~OpenMPCancelExitStack() = default;
1591 /// Fetches the exit block for the current OpenMP construct.
1592 JumpDest getExitBlock() const { return Stack.back().ExitBlock; }
1593 /// Emits exit block with special codegen procedure specific for the related
1594 /// OpenMP construct + emits code for normal construct cleanup.
1595 void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
1596 const llvm::function_ref<void(CodeGenFunction &)> CodeGen) {
1597 if (Stack.back().Kind == Kind && getExitBlock().isValid()) {
1598 assert(CGF.getOMPCancelDestination(Kind).isValid());
1599 assert(CGF.HaveInsertPoint());
1600 assert(!Stack.back().HasBeenEmitted);
1601 auto IP = CGF.Builder.saveAndClearIP();
1602 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1603 CodeGen(CGF);
1604 CGF.EmitBranch(Stack.back().ContBlock.getBlock());
1605 CGF.Builder.restoreIP(IP);
1606 Stack.back().HasBeenEmitted = true;
1607 }
1608 CodeGen(CGF);
1609 }
1610 /// Enter the cancel supporting \a Kind construct.
1611 /// \param Kind OpenMP directive that supports cancel constructs.
1612 /// \param HasCancel true, if the construct has inner cancel directive,
1613 /// false otherwise.
1614 void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) {
1615 Stack.push_back({Kind,
1616 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1617 : JumpDest(),
1618 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1619 : JumpDest()});
1620 }
1621 /// Emits default exit point for the cancel construct (if the special one
1622 /// has not be used) + join point for cancel/normal exits.
1623 void exit(CodeGenFunction &CGF) {
1624 if (getExitBlock().isValid()) {
1625 assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid());
1626 bool HaveIP = CGF.HaveInsertPoint();
1627 if (!Stack.back().HasBeenEmitted) {
1628 if (HaveIP)
1629 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1630 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1631 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1632 }
1633 CGF.EmitBlock(Stack.back().ContBlock.getBlock());
1634 if (!HaveIP) {
1635 CGF.Builder.CreateUnreachable();
1636 CGF.Builder.ClearInsertionPoint();
1637 }
1638 }
1639 Stack.pop_back();
1640 }
1641 };
1642 OpenMPCancelExitStack OMPCancelStack;
1643
1644 /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
1645 llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
1646 Stmt::Likelihood LH);
1647
1648 std::unique_ptr<CodeGenPGO> PGO;
1649
1650 /// Bitmap used by MC/DC to track condition outcomes of a boolean expression.
1651 Address MCDCCondBitmapAddr = Address::invalid();
1652
1653 /// Calculate branch weights appropriate for PGO data
1654 llvm::MDNode *createProfileWeights(uint64_t TrueCount,
1655 uint64_t FalseCount) const;
1656 llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
1657 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1658 uint64_t LoopCount) const;
1659
1660public:
1661 std::pair<bool, bool> getIsCounterPair(const Stmt *S) const;
1662 void markStmtAsUsed(bool Skipped, const Stmt *S);
1663 void markStmtMaybeUsed(const Stmt *S);
1664
1665 /// Increment the profiler's counter for the given statement by \p StepV.
1666 /// If \p StepV is null, the default increment is 1.
1667 void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr);
1668
1670 return (CGM.getCodeGenOpts().hasProfileClangInstr() &&
1671 CGM.getCodeGenOpts().MCDCCoverage &&
1672 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile));
1673 }
1674
1675 /// Allocate a temp value on the stack that MCDC can use to track condition
1676 /// results.
1678
1679 bool isBinaryLogicalOp(const Expr *E) const {
1680 const BinaryOperator *BOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
1681 return (BOp && BOp->isLogicalOp());
1682 }
1683
1684 /// Zero-init the MCDC temp value.
1685 void maybeResetMCDCCondBitmap(const Expr *E);
1686
1687 /// Increment the profiler's counter for the given expression by \p StepV.
1688 /// If \p StepV is null, the default increment is 1.
1690
1691 /// Update the MCDC temp value with the condition's evaluated result.
1692 void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val);
1693
1694 /// Get the profiler's count for the given statement.
1695 uint64_t getProfileCount(const Stmt *S);
1696
1697 /// Set the profiler's current count.
1698 void setCurrentProfileCount(uint64_t Count);
1699
1700 /// Get the profiler's current count. This is generally the count for the most
1701 /// recently incremented counter.
1702 uint64_t getCurrentProfileCount();
1703
1704 /// See CGDebugInfo::addInstToCurrentSourceAtom.
1705 void addInstToCurrentSourceAtom(llvm::Instruction *KeyInstruction,
1706 llvm::Value *Backup);
1707
1708 /// See CGDebugInfo::addInstToSpecificSourceAtom.
1709 void addInstToSpecificSourceAtom(llvm::Instruction *KeyInstruction,
1710 llvm::Value *Backup, uint64_t Atom);
1711
1712 /// Add \p KeyInstruction and an optional \p Backup instruction to a new atom
1713 /// group (See ApplyAtomGroup for more info).
1714 void addInstToNewSourceAtom(llvm::Instruction *KeyInstruction,
1715 llvm::Value *Backup);
1716
1717private:
1718 /// SwitchInsn - This is nearest current switch instruction. It is null if
1719 /// current context is not in a switch.
1720 llvm::SwitchInst *SwitchInsn = nullptr;
1721 /// The branch weights of SwitchInsn when doing instrumentation based PGO.
1722 SmallVector<uint64_t, 16> *SwitchWeights = nullptr;
1723
1724 /// The likelihood attributes of the SwitchCase.
1725 SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr;
1726
1727 /// CaseRangeBlock - This block holds if condition check for last case
1728 /// statement range in current switch instruction.
1729 llvm::BasicBlock *CaseRangeBlock = nullptr;
1730
1731 /// OpaqueLValues - Keeps track of the current set of opaque value
1732 /// expressions.
1733 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1734 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1735
1736 // VLASizeMap - This keeps track of the associated size for each VLA type.
1737 // We track this by the size expression rather than the type itself because
1738 // in certain situations, like a const qualifier applied to an VLA typedef,
1739 // multiple VLA types can share the same size expression.
1740 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1741 // enter/leave scopes.
1742 llvm::DenseMap<const Expr *, llvm::Value *> VLASizeMap;
1743
1744 /// A block containing a single 'unreachable' instruction. Created
1745 /// lazily by getUnreachableBlock().
1746 llvm::BasicBlock *UnreachableBlock = nullptr;
1747
1748 /// Counts of the number return expressions in the function.
1749 unsigned NumReturnExprs = 0;
1750
1751 /// Count the number of simple (constant) return expressions in the function.
1752 unsigned NumSimpleReturnExprs = 0;
1753
1754 /// The last regular (non-return) debug location (breakpoint) in the function.
1755 SourceLocation LastStopPoint;
1756
1757public:
1758 /// Source location information about the default argument or member
1759 /// initializer expression we're evaluating, if any.
1763
1764 /// A scope within which we are constructing the fields of an object which
1765 /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use
1766 /// if we need to evaluate a CXXDefaultInitExpr within the evaluation.
1768 public:
1769 FieldConstructionScope(CodeGenFunction &CGF, Address This)
1770 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1771 CGF.CXXDefaultInitExprThis = This;
1772 }
1774 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1775 }
1776
1777 private:
1778 CodeGenFunction &CGF;
1779 Address OldCXXDefaultInitExprThis;
1780 };
1781
1782 /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
1783 /// is overridden to be the object under construction.
1785 public:
1787 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
1788 OldCXXThisAlignment(CGF.CXXThisAlignment),
1790 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getBasePointer();
1791 CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
1792 }
1794 CGF.CXXThisValue = OldCXXThisValue;
1795 CGF.CXXThisAlignment = OldCXXThisAlignment;
1796 }
1797
1798 public:
1799 CodeGenFunction &CGF;
1800 llvm::Value *OldCXXThisValue;
1803 };
1804
1809
1810 /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
1811 /// current loop index is overridden.
1813 public:
1814 ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
1815 : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {
1816 CGF.ArrayInitIndex = Index;
1817 }
1818 ~ArrayInitLoopExprScope() { CGF.ArrayInitIndex = OldArrayInitIndex; }
1819
1820 private:
1821 CodeGenFunction &CGF;
1822 llvm::Value *OldArrayInitIndex;
1823 };
1824
1826 public:
1828 : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl),
1829 OldCurCodeDecl(CGF.CurCodeDecl),
1830 OldCXXABIThisDecl(CGF.CXXABIThisDecl),
1831 OldCXXABIThisValue(CGF.CXXABIThisValue),
1832 OldCXXThisValue(CGF.CXXThisValue),
1833 OldCXXABIThisAlignment(CGF.CXXABIThisAlignment),
1834 OldCXXThisAlignment(CGF.CXXThisAlignment),
1835 OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy),
1836 OldCXXInheritedCtorInitExprArgs(
1837 std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1838 CGF.CurGD = GD;
1839 CGF.CurFuncDecl = CGF.CurCodeDecl =
1841 CGF.CXXABIThisDecl = nullptr;
1842 CGF.CXXABIThisValue = nullptr;
1843 CGF.CXXThisValue = nullptr;
1844 CGF.CXXABIThisAlignment = CharUnits();
1845 CGF.CXXThisAlignment = CharUnits();
1846 CGF.ReturnValue = Address::invalid();
1847 CGF.FnRetTy = QualType();
1848 CGF.CXXInheritedCtorInitExprArgs.clear();
1849 }
1851 CGF.CurGD = OldCurGD;
1852 CGF.CurFuncDecl = OldCurFuncDecl;
1853 CGF.CurCodeDecl = OldCurCodeDecl;
1854 CGF.CXXABIThisDecl = OldCXXABIThisDecl;
1855 CGF.CXXABIThisValue = OldCXXABIThisValue;
1856 CGF.CXXThisValue = OldCXXThisValue;
1857 CGF.CXXABIThisAlignment = OldCXXABIThisAlignment;
1858 CGF.CXXThisAlignment = OldCXXThisAlignment;
1859 CGF.ReturnValue = OldReturnValue;
1860 CGF.FnRetTy = OldFnRetTy;
1861 CGF.CXXInheritedCtorInitExprArgs =
1862 std::move(OldCXXInheritedCtorInitExprArgs);
1863 }
1864
1865 private:
1866 CodeGenFunction &CGF;
1867 GlobalDecl OldCurGD;
1868 const Decl *OldCurFuncDecl;
1869 const Decl *OldCurCodeDecl;
1870 ImplicitParamDecl *OldCXXABIThisDecl;
1871 llvm::Value *OldCXXABIThisValue;
1872 llvm::Value *OldCXXThisValue;
1873 CharUnits OldCXXABIThisAlignment;
1874 CharUnits OldCXXThisAlignment;
1875 Address OldReturnValue;
1876 QualType OldFnRetTy;
1877 CallArgList OldCXXInheritedCtorInitExprArgs;
1878 };
1879
1880 // Helper class for the OpenMP IR Builder. Allows reusability of code used for
1881 // region body, and finalization codegen callbacks. This will class will also
1882 // contain privatization functions used by the privatization call backs
1883 //
1884 // TODO: this is temporary class for things that are being moved out of
1885 // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or
1886 // utility function for use with the OMPBuilder. Once that move to use the
1887 // OMPBuilder is done, everything here will either become part of CodeGenFunc.
1888 // directly, or a new helper class that will contain functions used by both
1889 // this and the OMPBuilder
1890
1892
1896
1897 using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
1898
1899 /// Cleanup action for allocate support.
1900 class OMPAllocateCleanupTy final : public EHScopeStack::Cleanup {
1901
1902 private:
1903 llvm::CallInst *RTLFnCI;
1904
1905 public:
1906 OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) {
1907 RLFnCI->removeFromParent();
1908 }
1909
1910 void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
1911 if (!CGF.HaveInsertPoint())
1912 return;
1913 CGF.Builder.Insert(RTLFnCI);
1914 }
1915 };
1916
1917 /// Returns address of the threadprivate variable for the current
1918 /// thread. This Also create any necessary OMP runtime calls.
1919 ///
1920 /// \param VD VarDecl for Threadprivate variable.
1921 /// \param VDAddr Address of the Vardecl
1922 /// \param Loc The location where the barrier directive was encountered
1923 static Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
1924 const VarDecl *VD, Address VDAddr,
1925 SourceLocation Loc);
1926
1927 /// Gets the OpenMP-specific address of the local variable /p VD.
1928 static Address getAddressOfLocalVariable(CodeGenFunction &CGF,
1929 const VarDecl *VD);
1930 /// Get the platform-specific name separator.
1931 /// \param Parts different parts of the final name that needs separation
1932 /// \param FirstSeparator First separator used between the initial two
1933 /// parts of the name.
1934 /// \param Separator separator used between all of the rest consecutinve
1935 /// parts of the name
1936 static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
1937 StringRef FirstSeparator = ".",
1938 StringRef Separator = ".");
1939 /// Emit the Finalization for an OMP region
1940 /// \param CGF The Codegen function this belongs to
1941 /// \param IP Insertion point for generating the finalization code.
1942 static void FinalizeOMPRegion(CodeGenFunction &CGF, InsertPointTy IP) {
1943 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1944 assert(IP.getBlock()->end() != IP.getPoint() &&
1945 "OpenMP IR Builder should cause terminated block!");
1946
1947 llvm::BasicBlock *IPBB = IP.getBlock();
1948 llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1949 assert(DestBB && "Finalization block should have one successor!");
1950
1951 // erase and replace with cleanup branch.
1952 IPBB->getTerminator()->eraseFromParent();
1953 CGF.Builder.SetInsertPoint(IPBB);
1955 CGF.EmitBranchThroughCleanup(Dest);
1956 }
1957
1958 /// Emit the body of an OMP region
1959 /// \param CGF The Codegen function this belongs to
1960 /// \param RegionBodyStmt The body statement for the OpenMP region being
1961 /// generated
1962 /// \param AllocaIP Where to insert alloca instructions
1963 /// \param CodeGenIP Where to insert the region code
1964 /// \param RegionName Name to be used for new blocks
1965 static void EmitOMPInlinedRegionBody(CodeGenFunction &CGF,
1966 const Stmt *RegionBodyStmt,
1967 InsertPointTy AllocaIP,
1968 InsertPointTy CodeGenIP,
1969 Twine RegionName);
1970
1971 static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP,
1972 llvm::BasicBlock &FiniBB, llvm::Function *Fn,
1974 llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1975 if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1976 CodeGenIPBBTI->eraseFromParent();
1977
1978 CGF.Builder.SetInsertPoint(CodeGenIPBB);
1979
1980 if (Fn->doesNotThrow())
1981 CGF.EmitNounwindRuntimeCall(Fn, Args);
1982 else
1983 CGF.EmitRuntimeCall(Fn, Args);
1984
1985 if (CGF.Builder.saveIP().isSet())
1986 CGF.Builder.CreateBr(&FiniBB);
1987 }
1988
1989 /// Emit the body of an OMP region that will be outlined in
1990 /// OpenMPIRBuilder::finalize().
1991 /// \param CGF The Codegen function this belongs to
1992 /// \param RegionBodyStmt The body statement for the OpenMP region being
1993 /// generated
1994 /// \param AllocaIP Where to insert alloca instructions
1995 /// \param CodeGenIP Where to insert the region code
1996 /// \param RegionName Name to be used for new blocks
1997 static void EmitOMPOutlinedRegionBody(CodeGenFunction &CGF,
1998 const Stmt *RegionBodyStmt,
1999 InsertPointTy AllocaIP,
2000 InsertPointTy CodeGenIP,
2001 Twine RegionName);
2002
2003 /// RAII for preserving necessary info during Outlined region body codegen.
2005
2006 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
2007 CodeGenFunction::JumpDest OldReturnBlock;
2008 CodeGenFunction &CGF;
2009
2010 public:
2011 OutlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP,
2012 llvm::BasicBlock &RetBB)
2013 : CGF(cgf) {
2014 assert(AllocaIP.isSet() &&
2015 "Must specify Insertion point for allocas of outlined function");
2016 OldAllocaIP = CGF.AllocaInsertPt;
2017 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2018
2019 OldReturnBlock = CGF.ReturnBlock;
2020 CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB);
2021 }
2022
2024 CGF.AllocaInsertPt = OldAllocaIP;
2025 CGF.ReturnBlock = OldReturnBlock;
2026 }
2027 };
2028
2029 /// RAII for preserving necessary info during inlined region body codegen.
2031
2032 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
2033 CodeGenFunction &CGF;
2034
2035 public:
2036 InlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP,
2037 llvm::BasicBlock &FiniBB)
2038 : CGF(cgf) {
2039 // Alloca insertion block should be in the entry block of the containing
2040 // function so it expects an empty AllocaIP in which case will reuse the
2041 // old alloca insertion point, or a new AllocaIP in the same block as
2042 // the old one
2043 assert((!AllocaIP.isSet() ||
2044 CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
2045 "Insertion point should be in the entry block of containing "
2046 "function!");
2047 OldAllocaIP = CGF.AllocaInsertPt;
2048 if (AllocaIP.isSet())
2049 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2050
2051 // TODO: Remove the call, after making sure the counter is not used by
2052 // the EHStack.
2053 // Since this is an inlined region, it should not modify the
2054 // ReturnBlock, and should reuse the one for the enclosing outlined
2055 // region. So, the JumpDest being return by the function is discarded
2056 (void)CGF.getJumpDestInCurrentScope(&FiniBB);
2057 }
2058
2059 ~InlinedRegionBodyRAII() { CGF.AllocaInsertPt = OldAllocaIP; }
2060 };
2061 };
2062
2063private:
2064 /// CXXThisDecl - When generating code for a C++ member function,
2065 /// this will hold the implicit 'this' declaration.
2066 ImplicitParamDecl *CXXABIThisDecl = nullptr;
2067 llvm::Value *CXXABIThisValue = nullptr;
2068 llvm::Value *CXXThisValue = nullptr;
2069 CharUnits CXXABIThisAlignment;
2070 CharUnits CXXThisAlignment;
2071
2072 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
2073 /// this expression.
2074 Address CXXDefaultInitExprThis = Address::invalid();
2075
2076 /// The current array initialization index when evaluating an
2077 /// ArrayInitIndexExpr within an ArrayInitLoopExpr.
2078 llvm::Value *ArrayInitIndex = nullptr;
2079
2080 /// The values of function arguments to use when evaluating
2081 /// CXXInheritedCtorInitExprs within this context.
2082 CallArgList CXXInheritedCtorInitExprArgs;
2083
2084 /// CXXStructorImplicitParamDecl - When generating code for a constructor or
2085 /// destructor, this will hold the implicit argument (e.g. VTT).
2086 ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr;
2087 llvm::Value *CXXStructorImplicitParamValue = nullptr;
2088
2089 /// OutermostConditional - Points to the outermost active
2090 /// conditional control. This is used so that we know if a
2091 /// temporary should be destroyed conditionally.
2092 ConditionalEvaluation *OutermostConditional = nullptr;
2093
2094 /// The current lexical scope.
2095 LexicalScope *CurLexicalScope = nullptr;
2096
2097 /// The current source location that should be used for exception
2098 /// handling code.
2099 SourceLocation CurEHLocation;
2100
2101 /// BlockByrefInfos - For each __block variable, contains
2102 /// information about the layout of the variable.
2103 llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
2104
2105 /// Used by -fsanitize=nullability-return to determine whether the return
2106 /// value can be checked.
2107 llvm::Value *RetValNullabilityPrecondition = nullptr;
2108
2109 /// Check if -fsanitize=nullability-return instrumentation is required for
2110 /// this function.
2111 bool requiresReturnValueNullabilityCheck() const {
2112 return RetValNullabilityPrecondition;
2113 }
2114
2115 /// Used to store precise source locations for return statements by the
2116 /// runtime return value checks.
2117 Address ReturnLocation = Address::invalid();
2118
2119 /// Check if the return value of this function requires sanitization.
2120 bool requiresReturnValueCheck() const;
2121
2122 bool isInAllocaArgument(CGCXXABI &ABI, QualType Ty);
2123 bool hasInAllocaArg(const CXXMethodDecl *MD);
2124
2125 llvm::BasicBlock *TerminateLandingPad = nullptr;
2126 llvm::BasicBlock *TerminateHandler = nullptr;
2128
2129 /// Terminate funclets keyed by parent funclet pad.
2130 llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
2131
2132 /// Largest vector width used in ths function. Will be used to create a
2133 /// function attribute.
2134 unsigned LargestVectorWidth = 0;
2135
2136 /// True if we need emit the life-time markers. This is initially set in
2137 /// the constructor, but could be overwritten to true if this is a coroutine.
2138 bool ShouldEmitLifetimeMarkers;
2139
2140 /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
2141 /// the function metadata.
2142 void EmitKernelMetadata(const FunctionDecl *FD, llvm::Function *Fn);
2143
2144public:
2145 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext = false);
2147
2148 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
2149 ASTContext &getContext() const { return CGM.getContext(); }
2151 if (DisableDebugInfo)
2152 return nullptr;
2153 return DebugInfo;
2154 }
2155 void disableDebugInfo() { DisableDebugInfo = true; }
2156 void enableDebugInfo() { DisableDebugInfo = false; }
2157
2159 return CGM.getCodeGenOpts().OptimizationLevel == 0;
2160 }
2161
2162 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
2163
2164 /// Returns a pointer to the function's exception object and selector slot,
2165 /// which is assigned in every landing pad.
2168
2169 /// Returns the contents of the function's exception object and selector
2170 /// slots.
2171 llvm::Value *getExceptionFromSlot();
2172 llvm::Value *getSelectorFromSlot();
2173
2175
2176 llvm::BasicBlock *getUnreachableBlock() {
2177 if (!UnreachableBlock) {
2178 UnreachableBlock = createBasicBlock("unreachable");
2179 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
2180 }
2181 return UnreachableBlock;
2182 }
2183
2184 llvm::BasicBlock *getInvokeDest() {
2185 if (!EHStack.requiresLandingPad())
2186 return nullptr;
2187 return getInvokeDestImpl();
2188 }
2189
2190 bool currentFunctionUsesSEHTry() const { return !!CurSEHParent; }
2191
2192 const TargetInfo &getTarget() const { return Target; }
2193 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
2195 return CGM.getTargetCodeGenInfo();
2196 }
2197
2198 //===--------------------------------------------------------------------===//
2199 // Cleanups
2200 //===--------------------------------------------------------------------===//
2201
2202 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
2203
2204 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
2205 Address arrayEndPointer,
2206 QualType elementType,
2207 CharUnits elementAlignment,
2208 Destroyer *destroyer);
2209 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
2210 llvm::Value *arrayEnd,
2211 QualType elementType,
2212 CharUnits elementAlignment,
2213 Destroyer *destroyer);
2214
2215 void pushDestroy(QualType::DestructionKind dtorKind, Address addr,
2216 QualType type);
2218 QualType type);
2219 void pushDestroy(CleanupKind kind, Address addr, QualType type,
2220 Destroyer *destroyer, bool useEHCleanupForArray);
2222 Address addr, QualType type);
2224 QualType type, Destroyer *destroyer,
2225 bool useEHCleanupForArray);
2227 QualType type, Destroyer *destroyer,
2228 bool useEHCleanupForArray);
2230 Address addr, QualType type);
2231 void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
2232 llvm::Value *CompletePtr,
2233 QualType ElementType);
2234 void pushStackRestore(CleanupKind kind, Address SPMem);
2236 std::pair<llvm::Value *, llvm::Value *> AddrSizePair);
2237 void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
2238 bool useEHCleanupForArray);
2239 llvm::Function *generateDestroyHelper(Address addr, QualType type,
2240 Destroyer *destroyer,
2241 bool useEHCleanupForArray,
2242 const VarDecl *VD);
2243 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
2244 QualType elementType, CharUnits elementAlign,
2245 Destroyer *destroyer, bool checkZeroLength,
2246 bool useEHCleanup);
2247
2249
2250 /// Determines whether an EH cleanup is required to destroy a type
2251 /// with the given destruction kind.
2253 switch (kind) {
2254 case QualType::DK_none:
2255 return false;
2259 return getLangOpts().Exceptions;
2261 return getLangOpts().Exceptions &&
2262 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
2263 }
2264 llvm_unreachable("bad destruction kind");
2265 }
2266
2270
2271 //===--------------------------------------------------------------------===//
2272 // Objective-C
2273 //===--------------------------------------------------------------------===//
2274
2275 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
2276
2277 void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD);
2278
2279 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2281 const ObjCPropertyImplDecl *PID);
2282 void generateObjCGetterBody(const ObjCImplementationDecl *classImpl,
2283 const ObjCPropertyImplDecl *propImpl,
2284 const ObjCMethodDecl *GetterMothodDecl,
2285 llvm::Constant *AtomicHelperFn);
2286
2288 ObjCMethodDecl *MD, bool ctor);
2289
2290 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2291 /// for the given property.
2293 const ObjCPropertyImplDecl *PID);
2294 void generateObjCSetterBody(const ObjCImplementationDecl *classImpl,
2295 const ObjCPropertyImplDecl *propImpl,
2296 llvm::Constant *AtomicHelperFn);
2297
2298 //===--------------------------------------------------------------------===//
2299 // Block Bits
2300 //===--------------------------------------------------------------------===//
2301
2302 /// Emit block literal.
2303 /// \return an LLVM value which is a pointer to a struct which contains
2304 /// information about the block, including the block invoke function, the
2305 /// captured variables, etc.
2306 llvm::Value *EmitBlockLiteral(const BlockExpr *);
2307
2308 llvm::Function *GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &Info,
2309 const DeclMapTy &ldm,
2310 bool IsLambdaConversionToBlock,
2311 bool BuildGlobalBlock);
2312
2313 /// Check if \p T is a C++ class that has a destructor that can throw.
2314 static bool cxxDestructorCanThrow(QualType T);
2315
2316 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
2317 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
2318 llvm::Constant *
2320 llvm::Constant *
2322 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
2323
2324 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
2325 bool CanThrow);
2326
2327 class AutoVarEmission;
2328
2329 void emitByrefStructureInit(const AutoVarEmission &emission);
2330
2331 /// Enter a cleanup to destroy a __block variable. Note that this
2332 /// cleanup should be a no-op if the variable hasn't left the stack
2333 /// yet; if a cleanup is required for the variable itself, that needs
2334 /// to be done externally.
2335 ///
2336 /// \param Kind Cleanup kind.
2337 ///
2338 /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block
2339 /// structure that will be passed to _Block_object_dispose. When
2340 /// \p LoadBlockVarAddr is true, the address of the field of the block
2341 /// structure that holds the address of the __block structure.
2342 ///
2343 /// \param Flags The flag that will be passed to _Block_object_dispose.
2344 ///
2345 /// \param LoadBlockVarAddr Indicates whether we need to emit a load from
2346 /// \p Addr to get the address of the __block structure.
2348 bool LoadBlockVarAddr, bool CanThrow);
2349
2350 void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum,
2351 llvm::Value *ptr);
2352
2355
2356 /// BuildBlockByrefAddress - Computes the location of the
2357 /// data in a variable which is declared as __block.
2359 bool followForward = true);
2361 bool followForward, const llvm::Twine &name);
2362
2363 const BlockByrefInfo &getBlockByrefInfo(const VarDecl *var);
2364
2366
2367 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
2368 const CGFunctionInfo &FnInfo);
2369
2370 /// Annotate the function with an attribute that disables TSan checking at
2371 /// runtime.
2372 void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
2373
2374 /// Emit code for the start of a function.
2375 /// \param Loc The location to be associated with the function.
2376 /// \param StartLoc The location of the function body.
2377 void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn,
2378 const CGFunctionInfo &FnInfo, const FunctionArgList &Args,
2380 SourceLocation StartLoc = SourceLocation());
2381
2382 static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor);
2383
2387 void EmitFunctionBody(const Stmt *Body);
2388 void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2389
2390 void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator,
2391 CallArgList &CallArgs,
2392 const CGFunctionInfo *CallOpFnInfo = nullptr,
2393 llvm::Constant *CallOpFn = nullptr);
2397 CallArgList &CallArgs);
2398 void EmitLambdaInAllocaImplFn(const CXXMethodDecl *CallOp,
2399 const CGFunctionInfo **ImplFnInfo,
2400 llvm::Function **ImplFn);
2403 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2404 }
2405 void EmitAsanPrologueOrEpilogue(bool Prologue);
2406
2407 /// Emit the unified return block, trying to avoid its emission when
2408 /// possible.
2409 /// \return The debug location of the user written return statement if the
2410 /// return block is avoided.
2411 llvm::DebugLoc EmitReturnBlock();
2412
2413 /// FinishFunction - Complete IR generation of the current function. It is
2414 /// legal to call this function even if there is no current insertion point.
2416
2417 void StartThunk(llvm::Function *Fn, GlobalDecl GD,
2418 const CGFunctionInfo &FnInfo, bool IsUnprototyped);
2419
2420 void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
2421 const ThunkInfo *Thunk, bool IsUnprototyped);
2422
2423 void FinishThunk();
2424
2425 /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
2426 void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
2427 llvm::FunctionCallee Callee);
2428
2429 /// Generate a thunk for the given method.
2430 void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
2431 GlobalDecl GD, const ThunkInfo &Thunk,
2432 bool IsUnprototyped);
2433
2434 llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
2435 const CGFunctionInfo &FnInfo,
2436 GlobalDecl GD, const ThunkInfo &Thunk);
2437
2439 FunctionArgList &Args);
2440
2441 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
2442
2443 /// Struct with all information about dynamic [sub]class needed to set vptr.
2450
2451 /// Initialize the vtable pointer of the given subobject.
2452 void InitializeVTablePointer(const VPtr &vptr);
2453
2455
2457 VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass);
2458
2459 void getVTablePointers(BaseSubobject Base, const CXXRecordDecl *NearestVBase,
2460 CharUnits OffsetFromNearestVBase,
2461 bool BaseIsNonVirtualPrimaryBase,
2462 const CXXRecordDecl *VTableClass,
2463 VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs);
2464
2465 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
2466
2467 // VTableTrapMode - whether we guarantee that loading the
2468 // vtable is guaranteed to trap on authentication failure,
2469 // even if the resulting vtable pointer is unused.
2470 enum class VTableAuthMode {
2473 UnsafeUbsanStrip // Should only be used for Vptr UBSan check
2474 };
2475 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2476 /// to by This.
2477 llvm::Value *
2478 GetVTablePtr(Address This, llvm::Type *VTableTy,
2479 const CXXRecordDecl *VTableClass,
2481
2491
2492 /// Derived is the presumed address of an object of type T after a
2493 /// cast. If T is a polymorphic class type, emit a check that the virtual
2494 /// table for Derived belongs to a class derived from T.
2495 void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull,
2497
2498 /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2499 /// If vptr CFI is enabled, emit a check that VTable is valid.
2500 void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable,
2502
2503 /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2504 /// RD using llvm.type.test.
2505 void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable,
2507
2508 /// If whole-program virtual table optimization is enabled, emit an assumption
2509 /// that VTable is a member of RD's type identifier. Or, if vptr CFI is
2510 /// enabled, emit a check that VTable is a member of RD's type identifier.
2512 llvm::Value *VTable, SourceLocation Loc);
2513
2514 /// Returns whether we should perform a type checked load when loading a
2515 /// virtual function for virtual calls to members of RD. This is generally
2516 /// true when both vcall CFI and whole-program-vtables are enabled.
2518
2519 /// Emit a type checked load from the given vtable.
2520 llvm::Value *EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD,
2521 llvm::Value *VTable,
2522 llvm::Type *VTableTy,
2523 uint64_t VTableByteOffset);
2524
2525 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2526 /// given phase of destruction for a destructor. The end result
2527 /// should call destructors on members and base classes in reverse
2528 /// order of their construction.
2530
2531 /// ShouldInstrumentFunction - Return true if the current function should be
2532 /// instrumented with __cyg_profile_func_* calls
2534
2535 /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2536 /// should not be instrumented with sanitizers.
2538
2539 /// ShouldXRayInstrument - Return true if the current function should be
2540 /// instrumented with XRay nop sleds.
2541 bool ShouldXRayInstrumentFunction() const;
2542
2543 /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2544 /// XRay custom event handling calls.
2545 bool AlwaysEmitXRayCustomEvents() const;
2546
2547 /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2548 /// XRay typed event handling calls.
2549 bool AlwaysEmitXRayTypedEvents() const;
2550
2551 /// Return a type hash constant for a function instrumented by
2552 /// -fsanitize=function.
2553 llvm::ConstantInt *getUBSanFunctionTypeHash(QualType T) const;
2554
2555 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2556 /// arguments for the given function. This is also responsible for naming the
2557 /// LLVM function arguments.
2558 void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn,
2559 const FunctionArgList &Args);
2560
2561 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2562 /// given temporary. Specify the source location atom group (Key Instructions
2563 /// debug info feature) for the `ret` using \p RetKeyInstructionsSourceAtom.
2564 /// If it's 0, the `ret` will get added to a new source atom group.
2565 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc,
2566 SourceLocation EndLoc,
2567 uint64_t RetKeyInstructionsSourceAtom);
2568
2569 /// Emit a test that checks if the return value \p RV is nonnull.
2570 void EmitReturnValueCheck(llvm::Value *RV);
2571
2572 /// EmitStartEHSpec - Emit the start of the exception spec.
2573 void EmitStartEHSpec(const Decl *D);
2574
2575 /// EmitEndEHSpec - Emit the end of the exception spec.
2576 void EmitEndEHSpec(const Decl *D);
2577
2578 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2579 llvm::BasicBlock *getTerminateLandingPad();
2580
2581 /// getTerminateLandingPad - Return a cleanup funclet that just calls
2582 /// terminate.
2583 llvm::BasicBlock *getTerminateFunclet();
2584
2585 /// getTerminateHandler - Return a handler (not a landing pad, just
2586 /// a catch handler) that just calls terminate. This is used when
2587 /// a terminate scope encloses a try.
2588 llvm::BasicBlock *getTerminateHandler();
2589
2590 llvm::Type *ConvertTypeForMem(QualType T);
2591 llvm::Type *ConvertType(QualType T);
2592 llvm::Type *convertTypeForLoadStore(QualType ASTTy,
2593 llvm::Type *LLVMTy = nullptr);
2594 llvm::Type *ConvertType(const TypeDecl *T) {
2595 return ConvertType(getContext().getTypeDeclType(T));
2596 }
2597
2598 /// LoadObjCSelf - Load the value of self. This function is only valid while
2599 /// generating code for an Objective-C method.
2600 llvm::Value *LoadObjCSelf();
2601
2602 /// TypeOfSelfObject - Return type of object that this self represents.
2604
2605 /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2607
2609 return getEvaluationKind(T) == TEK_Scalar;
2610 }
2611
2615
2616 /// createBasicBlock - Create an LLVM basic block.
2617 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
2618 llvm::Function *parent = nullptr,
2619 llvm::BasicBlock *before = nullptr) {
2620 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
2621 }
2622
2623 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2624 /// label maps to.
2625 JumpDest getJumpDestForLabel(const LabelDecl *S);
2626
2627 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2628 /// another basic block, simplify it. This assumes that no other code could
2629 /// potentially reference the basic block.
2630 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
2631
2632 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2633 /// adding a fall-through branch from the current insert block if
2634 /// necessary. It is legal to call this function even if there is no current
2635 /// insertion point.
2636 ///
2637 /// IsFinished - If true, indicates that the caller has finished emitting
2638 /// branches to the given block and does not expect to emit code into it. This
2639 /// means the block can be ignored if it is unreachable.
2640 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished = false);
2641
2642 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2643 /// near its uses, and leave the insertion point in it.
2644 void EmitBlockAfterUses(llvm::BasicBlock *BB);
2645
2646 /// EmitBranch - Emit a branch to the specified basic block from the current
2647 /// insert block, taking care to avoid creation of branches from dummy
2648 /// blocks. It is legal to call this function even if there is no current
2649 /// insertion point.
2650 ///
2651 /// This function clears the current insertion point. The caller should follow
2652 /// calls to this function with calls to Emit*Block prior to generation new
2653 /// code.
2654 void EmitBranch(llvm::BasicBlock *Block);
2655
2656 /// HaveInsertPoint - True if an insertion point is defined. If not, this
2657 /// indicates that the current code being emitted is unreachable.
2658 bool HaveInsertPoint() const { return Builder.GetInsertBlock() != nullptr; }
2659
2660 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2661 /// emitted IR has a place to go. Note that by definition, if this function
2662 /// creates a block then that block is unreachable; callers may do better to
2663 /// detect when no insertion point is defined and simply skip IR generation.
2665 if (!HaveInsertPoint())
2667 }
2668
2669 /// ErrorUnsupported - Print out an error that codegen doesn't support the
2670 /// specified stmt yet.
2671 void ErrorUnsupported(const Stmt *S, const char *Type);
2672
2673 //===--------------------------------------------------------------------===//
2674 // Helpers
2675 //===--------------------------------------------------------------------===//
2676
2678 llvm::BasicBlock *LHSBlock,
2679 llvm::BasicBlock *RHSBlock,
2680 llvm::BasicBlock *MergeBlock,
2681 QualType MergedType) {
2682 Builder.SetInsertPoint(MergeBlock);
2683 llvm::PHINode *PtrPhi = Builder.CreatePHI(LHS.getType(), 2, "cond");
2684 PtrPhi->addIncoming(LHS.getBasePointer(), LHSBlock);
2685 PtrPhi->addIncoming(RHS.getBasePointer(), RHSBlock);
2686 LHS.replaceBasePointer(PtrPhi);
2687 LHS.setAlignment(std::min(LHS.getAlignment(), RHS.getAlignment()));
2688 return LHS;
2689 }
2690
2691 /// Construct an address with the natural alignment of T. If a pointer to T
2692 /// is expected to be signed, the pointer passed to this function must have
2693 /// been signed, and the returned Address will have the pointer authentication
2694 /// information needed to authenticate the signed pointer.
2696 llvm::Value *Ptr, QualType T, CharUnits Alignment = CharUnits::Zero(),
2697 bool ForPointeeType = false, LValueBaseInfo *BaseInfo = nullptr,
2698 TBAAAccessInfo *TBAAInfo = nullptr,
2699 KnownNonNull_t IsKnownNonNull = NotKnownNonNull) {
2700 if (Alignment.isZero())
2701 Alignment =
2702 CGM.getNaturalTypeAlignment(T, BaseInfo, TBAAInfo, ForPointeeType);
2703 return Address(Ptr, ConvertTypeForMem(T), Alignment,
2704 CGM.getPointerAuthInfoForPointeeType(T), /*Offset=*/nullptr,
2705 IsKnownNonNull);
2706 }
2707
2710 return MakeAddrLValue(Addr, T, LValueBaseInfo(Source),
2711 CGM.getTBAAAccessInfo(T));
2712 }
2713
2715 TBAAAccessInfo TBAAInfo) {
2716 return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2717 }
2718
2719 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2721 return MakeAddrLValue(makeNaturalAddressForPointer(V, T, Alignment), T,
2722 LValueBaseInfo(Source), CGM.getTBAAAccessInfo(T));
2723 }
2724
2725 /// Same as MakeAddrLValue above except that the pointer is known to be
2726 /// unsigned.
2727 LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2729 Address Addr(V, ConvertTypeForMem(T), Alignment);
2730 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2731 CGM.getTBAAAccessInfo(T));
2732 }
2733
2734 LValue
2740
2741 /// Given a value of type T* that may not be to a complete object, construct
2742 /// an l-value with the natural pointee alignment of T.
2744
2745 LValue
2746 MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T,
2747 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
2748
2749 /// Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known
2750 /// to be unsigned.
2752
2754
2756 LValueBaseInfo *PointeeBaseInfo = nullptr,
2757 TBAAAccessInfo *PointeeTBAAInfo = nullptr);
2759 LValue
2762 LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2763 CGM.getTBAAAccessInfo(RefTy));
2764 return EmitLoadOfReferenceLValue(RefLVal);
2765 }
2766
2767 /// Load a pointer with type \p PtrTy stored at address \p Ptr.
2768 /// Note that \p PtrTy is the type of the loaded pointer, not the addresses
2769 /// it is loaded from.
2770 Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy,
2771 LValueBaseInfo *BaseInfo = nullptr,
2772 TBAAAccessInfo *TBAAInfo = nullptr);
2774
2775private:
2776 struct AllocaTracker {
2777 void Add(llvm::AllocaInst *I) { Allocas.push_back(I); }
2778 llvm::SmallVector<llvm::AllocaInst *> Take() { return std::move(Allocas); }
2779
2780 private:
2782 };
2783 AllocaTracker *Allocas = nullptr;
2784
2785 /// CGDecl helper.
2786 void emitStoresForConstant(const VarDecl &D, Address Loc, bool isVolatile,
2787 llvm::Constant *constant, bool IsAutoInit);
2788 /// CGDecl helper.
2789 void emitStoresForZeroInit(const VarDecl &D, Address Loc, bool isVolatile);
2790 /// CGDecl helper.
2791 void emitStoresForPatternInit(const VarDecl &D, Address Loc, bool isVolatile);
2792 /// CGDecl helper.
2793 void emitStoresForInitAfterBZero(llvm::Constant *Init, Address Loc,
2794 bool isVolatile, bool IsAutoInit);
2795
2796public:
2797 // Captures all the allocas created during the scope of its RAII object.
2799 AllocaTrackerRAII(CodeGenFunction &CGF)
2800 : CGF(CGF), OldTracker(CGF.Allocas) {
2801 CGF.Allocas = &Tracker;
2802 }
2803 ~AllocaTrackerRAII() { CGF.Allocas = OldTracker; }
2804
2805 llvm::SmallVector<llvm::AllocaInst *> Take() { return Tracker.Take(); }
2806
2807 private:
2808 CodeGenFunction &CGF;
2809 AllocaTracker *OldTracker;
2810 AllocaTracker Tracker;
2811 };
2812
2813private:
2814 /// If \p Alloca is not in the same address space as \p DestLangAS, insert an
2815 /// address space cast and return a new RawAddress based on this value.
2816 RawAddress MaybeCastStackAddressSpace(RawAddress Alloca, LangAS DestLangAS,
2817 llvm::Value *ArraySize = nullptr);
2818
2819public:
2820 /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2821 /// block if \p ArraySize is nullptr, otherwise inserts it at the current
2822 /// insertion point of the builder. The caller is responsible for setting an
2823 /// appropriate alignment on
2824 /// the alloca.
2825 ///
2826 /// \p ArraySize is the number of array elements to be allocated if it
2827 /// is not nullptr.
2828 ///
2829 /// LangAS::Default is the address space of pointers to local variables and
2830 /// temporaries, as exposed in the source language. In certain
2831 /// configurations, this is not the same as the alloca address space, and a
2832 /// cast is needed to lift the pointer from the alloca AS into
2833 /// LangAS::Default. This can happen when the target uses a restricted
2834 /// address space for the stack but the source language requires
2835 /// LangAS::Default to be a generic address space. The latter condition is
2836 /// common for most programming languages; OpenCL is an exception in that
2837 /// LangAS::Default is the private address space, which naturally maps
2838 /// to the stack.
2839 ///
2840 /// Because the address of a temporary is often exposed to the program in
2841 /// various ways, this function will perform the cast. The original alloca
2842 /// instruction is returned through \p Alloca if it is not nullptr.
2843 ///
2844 /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2845 /// more efficient if the caller knows that the address will not be exposed.
2846 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2847 llvm::Value *ArraySize = nullptr);
2848
2849 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
2850 /// block. The alloca is casted to the address space of \p UseAddrSpace if
2851 /// necessary.
2852 RawAddress CreateTempAlloca(llvm::Type *Ty, LangAS UseAddrSpace,
2853 CharUnits align, const Twine &Name = "tmp",
2854 llvm::Value *ArraySize = nullptr,
2855 RawAddress *Alloca = nullptr);
2856
2857 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
2858 /// block. The alloca is casted to default address space if necessary.
2859 ///
2860 /// FIXME: This version should be removed, and context should provide the
2861 /// context use address space used instead of default.
2863 const Twine &Name = "tmp",
2864 llvm::Value *ArraySize = nullptr,
2865 RawAddress *Alloca = nullptr) {
2866 return CreateTempAlloca(Ty, LangAS::Default, align, Name, ArraySize,
2867 Alloca);
2868 }
2869
2870 RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align,
2871 const Twine &Name = "tmp",
2872 llvm::Value *ArraySize = nullptr);
2873
2874 /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2875 /// default ABI alignment of the given LLVM type.
2876 ///
2877 /// IMPORTANT NOTE: This is *not* generally the right alignment for
2878 /// any given AST type that happens to have been lowered to the
2879 /// given IR type. This should only ever be used for function-local,
2880 /// IR-driven manipulations like saving and restoring a value. Do
2881 /// not hand this address off to arbitrary IRGen routines, and especially
2882 /// do not pass it as an argument to a function that might expect a
2883 /// properly ABI-aligned value.
2885 const Twine &Name = "tmp");
2886
2887 /// CreateIRTemp - Create a temporary IR object of the given type, with
2888 /// appropriate alignment. This routine should only be used when an temporary
2889 /// value needs to be stored into an alloca (for example, to avoid explicit
2890 /// PHI construction), but the type is the IR type, not the type appropriate
2891 /// for storing in memory.
2892 ///
2893 /// That is, this is exactly equivalent to CreateMemTemp, but calling
2894 /// ConvertType instead of ConvertTypeForMem.
2895 RawAddress CreateIRTemp(QualType T, const Twine &Name = "tmp");
2896
2897 /// CreateMemTemp - Create a temporary memory object of the given type, with
2898 /// appropriate alignmen and cast it to the default address space. Returns
2899 /// the original alloca instruction by \p Alloca if it is not nullptr.
2900 RawAddress CreateMemTemp(QualType T, const Twine &Name = "tmp",
2901 RawAddress *Alloca = nullptr);
2903 const Twine &Name = "tmp",
2904 RawAddress *Alloca = nullptr);
2905
2906 /// CreateMemTemp - Create a temporary memory object of the given type, with
2907 /// appropriate alignmen without casting it to the default address space.
2908 RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2910 const Twine &Name = "tmp");
2911
2912 /// CreateAggTemp - Create a temporary memory object for the given
2913 /// aggregate type.
2914 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp",
2915 RawAddress *Alloca = nullptr) {
2916 return AggValueSlot::forAddr(
2917 CreateMemTemp(T, Name, Alloca), T.getQualifiers(),
2920 }
2921
2922 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2923 /// expression and compare the result against zero, returning an Int1Ty value.
2924 llvm::Value *EvaluateExprAsBool(const Expr *E);
2925
2926 /// Retrieve the implicit cast expression of the rhs in a binary operator
2927 /// expression by passing pointers to Value and QualType
2928 /// This is used for implicit bitfield conversion checks, which
2929 /// must compare with the value before potential truncation.
2931 llvm::Value **Previous,
2932 QualType *SrcType);
2933
2934 /// Emit a check that an [implicit] conversion of a bitfield. It is not UB,
2935 /// so we use the value after conversion.
2936 void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType,
2937 llvm::Value *Dst, QualType DstType,
2938 const CGBitFieldInfo &Info,
2939 SourceLocation Loc);
2940
2941 /// EmitIgnoredExpr - Emit an expression in a context which ignores the
2942 /// result.
2943 void EmitIgnoredExpr(const Expr *E);
2944
2945 /// EmitAnyExpr - Emit code to compute the specified expression which can have
2946 /// any type. The result is returned as an RValue struct. If this is an
2947 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
2948 /// the result should be returned.
2949 ///
2950 /// \param ignoreResult True if the resulting value isn't used.
2951 RValue EmitAnyExpr(const Expr *E,
2953 bool ignoreResult = false);
2954
2955 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2956 // or the value of the expression, depending on how va_list is defined.
2957 Address EmitVAListRef(const Expr *E);
2958
2959 /// Emit a "reference" to a __builtin_ms_va_list; this is
2960 /// always the value of the expression, because a __builtin_ms_va_list is a
2961 /// pointer to a char.
2962 Address EmitMSVAListRef(const Expr *E);
2963
2964 /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2965 /// always be accessible even if no aggregate location is provided.
2966 RValue EmitAnyExprToTemp(const Expr *E);
2967
2968 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2969 /// arbitrary expression into the given memory location.
2970 void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals,
2971 bool IsInitializer);
2972
2973 void EmitAnyExprToExn(const Expr *E, Address Addr);
2974
2975 /// EmitInitializationToLValue - Emit an initializer to an LValue.
2977 const Expr *E, LValue LV,
2979
2980 /// EmitExprAsInit - Emits the code necessary to initialize a
2981 /// location in memory with the given initializer.
2982 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2983 bool capturedByInit);
2984
2985 /// hasVolatileMember - returns true if aggregate type has a volatile
2986 /// member.
2988 if (const auto *RD = T->getAsRecordDecl())
2989 return RD->hasVolatileMember();
2990 return false;
2991 }
2992
2993 /// Determine whether a return value slot may overlap some other object.
2995 // FIXME: Assuming no overlap here breaks guaranteed copy elision for base
2996 // class subobjects. These cases may need to be revisited depending on the
2997 // resolution of the relevant core issue.
2999 }
3000
3001 /// Determine whether a field initialization may overlap some other object.
3003
3004 /// Determine whether a base class initialization may overlap some other
3005 /// object.
3007 const CXXRecordDecl *BaseRD,
3008 bool IsVirtual);
3009
3010 /// Emit an aggregate assignment.
3013 bool IsVolatile = hasVolatileMember(EltTy);
3014 EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile);
3015 }
3016
3018 AggValueSlot::Overlap_t MayOverlap) {
3019 EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap);
3020 }
3021
3022 /// EmitAggregateCopy - Emit an aggregate copy.
3023 ///
3024 /// \param isVolatile \c true iff either the source or the destination is
3025 /// volatile.
3026 /// \param MayOverlap Whether the tail padding of the destination might be
3027 /// occupied by some other object. More efficient code can often be
3028 /// generated if not.
3029 void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy,
3030 AggValueSlot::Overlap_t MayOverlap,
3031 bool isVolatile = false);
3032
3033 /// GetAddrOfLocalVar - Return the address of a local variable.
3035 auto it = LocalDeclMap.find(VD);
3036 assert(it != LocalDeclMap.end() &&
3037 "Invalid argument to GetAddrOfLocalVar(), no decl!");
3038 return it->second;
3039 }
3040
3041 /// Given an opaque value expression, return its LValue mapping if it exists,
3042 /// otherwise create one.
3044
3045 /// Given an opaque value expression, return its RValue mapping if it exists,
3046 /// otherwise create one.
3048
3049 /// isOpaqueValueEmitted - Return true if the opaque value expression has
3050 /// already been emitted.
3052
3053 /// Get the index of the current ArrayInitLoopExpr, if any.
3054 llvm::Value *getArrayInitIndex() { return ArrayInitIndex; }
3055
3056 /// getAccessedFieldNo - Given an encoded value and a result number, return
3057 /// the input field number being accessed.
3058 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
3059
3060 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
3061 llvm::BasicBlock *GetIndirectGotoBlock();
3062
3063 /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
3064 static bool IsWrappedCXXThis(const Expr *E);
3065
3066 /// EmitNullInitialization - Generate code to set a value of the given type to
3067 /// null, If the type contains data member pointers, they will be initialized
3068 /// to -1 in accordance with the Itanium C++ ABI.
3069 void EmitNullInitialization(Address DestPtr, QualType Ty);
3070
3071 /// Emits a call to an LLVM variable-argument intrinsic, either
3072 /// \c llvm.va_start or \c llvm.va_end.
3073 /// \param ArgValue A reference to the \c va_list as emitted by either
3074 /// \c EmitVAListRef or \c EmitMSVAListRef.
3075 /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise,
3076 /// calls \c llvm.va_end.
3077 llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart);
3078
3079 /// Generate code to get an argument from the passed in pointer
3080 /// and update it accordingly.
3081 /// \param VE The \c VAArgExpr for which to generate code.
3082 /// \param VAListAddr Receives a reference to the \c va_list as emitted by
3083 /// either \c EmitVAListRef or \c EmitMSVAListRef.
3084 /// \returns A pointer to the argument.
3085 // FIXME: We should be able to get rid of this method and use the va_arg
3086 // instruction in LLVM instead once it works well enough.
3087 RValue EmitVAArg(VAArgExpr *VE, Address &VAListAddr,
3089
3090 /// emitArrayLength - Compute the length of an array, even if it's a
3091 /// VLA, and drill down to the base element type.
3092 llvm::Value *emitArrayLength(const ArrayType *arrayType, QualType &baseType,
3093 Address &addr);
3094
3095 /// EmitVLASize - Capture all the sizes for the VLA expressions in
3096 /// the given variably-modified type and store them in the VLASizeMap.
3097 ///
3098 /// This function can be called with a null (unreachable) insert point.
3100
3102 llvm::Value *NumElts;
3104
3105 VlaSizePair(llvm::Value *NE, QualType T) : NumElts(NE), Type(T) {}
3106 };
3107
3108 /// Return the number of elements for a single dimension
3109 /// for the given array type.
3110 VlaSizePair getVLAElements1D(const VariableArrayType *vla);
3111 VlaSizePair getVLAElements1D(QualType vla);
3112
3113 /// Returns an LLVM value that corresponds to the size,
3114 /// in non-variably-sized elements, of a variable length array type,
3115 /// plus that largest non-variably-sized element type. Assumes that
3116 /// the type has already been emitted with EmitVariablyModifiedType.
3117 VlaSizePair getVLASize(const VariableArrayType *vla);
3118 VlaSizePair getVLASize(QualType vla);
3119
3120 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
3121 /// generating code for an C++ member function.
3122 llvm::Value *LoadCXXThis() {
3123 assert(CXXThisValue && "no 'this' value for this function");
3124 return CXXThisValue;
3125 }
3127
3128 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
3129 /// virtual bases.
3130 // FIXME: Every place that calls LoadCXXVTT is something
3131 // that needs to be abstracted properly.
3132 llvm::Value *LoadCXXVTT() {
3133 assert(CXXStructorImplicitParamValue && "no VTT value for this function");
3134 return CXXStructorImplicitParamValue;
3135 }
3136
3137 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
3138 /// complete class to the given direct base.
3140 const CXXRecordDecl *Derived,
3141 const CXXRecordDecl *Base,
3142 bool BaseIsVirtual);
3143
3144 static bool ShouldNullCheckClassCastValue(const CastExpr *Cast);
3145
3146 /// GetAddressOfBaseClass - This function will add the necessary delta to the
3147 /// load of 'this' and returns address of the base class.
3151 bool NullCheckValue, SourceLocation Loc);
3152
3156 bool NullCheckValue);
3157
3158 /// GetVTTParameter - Return the VTT parameter that should be passed to a
3159 /// base constructor/destructor with virtual bases.
3160 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
3161 /// to ItaniumCXXABI.cpp together with all the references to VTT.
3162 llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
3163 bool Delegating);
3164
3166 CXXCtorType CtorType,
3167 const FunctionArgList &Args,
3168 SourceLocation Loc);
3169 // It's important not to confuse this and the previous function. Delegating
3170 // constructors are the C++0x feature. The constructor delegate optimization
3171 // is used to reduce duplication in the base and complete consturctors where
3172 // they are substantially the same.
3174 const FunctionArgList &Args);
3175
3176 /// Emit a call to an inheriting constructor (that is, one that invokes a
3177 /// constructor inherited from a base class) by inlining its definition. This
3178 /// is necessary if the ABI does not support forwarding the arguments to the
3179 /// base class constructor (because they're variadic or similar).
3181 CXXCtorType CtorType,
3182 bool ForVirtualBase,
3183 bool Delegating,
3184 CallArgList &Args);
3185
3186 /// Emit a call to a constructor inherited from a base class, passing the
3187 /// current constructor's arguments along unmodified (without even making
3188 /// a copy).
3190 bool ForVirtualBase, Address This,
3191 bool InheritedFromVBase,
3192 const CXXInheritedCtorInitExpr *E);
3193
3195 bool ForVirtualBase, bool Delegating,
3196 AggValueSlot ThisAVS, const CXXConstructExpr *E);
3197
3199 bool ForVirtualBase, bool Delegating,
3200 Address This, CallArgList &Args,
3202 SourceLocation Loc, bool NewPointerIsChecked,
3203 llvm::CallBase **CallOrInvoke = nullptr);
3204
3205 /// Emit assumption load for all bases. Requires to be called only on
3206 /// most-derived class and not under construction of the object.
3207 void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This);
3208
3209 /// Emit assumption that vptr load == global vtable.
3210 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
3211
3213 Address Src, const CXXConstructExpr *E);
3214
3216 const ArrayType *ArrayTy, Address ArrayPtr,
3217 const CXXConstructExpr *E,
3218 bool NewPointerIsChecked,
3219 bool ZeroInitialization = false);
3220
3222 llvm::Value *NumElements, Address ArrayPtr,
3223 const CXXConstructExpr *E,
3224 bool NewPointerIsChecked,
3225 bool ZeroInitialization = false);
3226
3228
3230 bool ForVirtualBase, bool Delegating, Address This,
3231 QualType ThisTy);
3232
3233 void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType,
3234 llvm::Type *ElementTy, Address NewPtr,
3235 llvm::Value *NumElements,
3236 llvm::Value *AllocSizeWithoutCookie);
3237
3238 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
3239 Address Ptr);
3240
3241 void EmitSehCppScopeBegin();
3242 void EmitSehCppScopeEnd();
3243 void EmitSehTryScopeBegin();
3244 void EmitSehTryScopeEnd();
3245
3246 bool EmitLifetimeStart(llvm::Value *Addr);
3247 void EmitLifetimeEnd(llvm::Value *Addr);
3248
3249 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
3250 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
3251
3252 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
3253 QualType DeleteTy, llvm::Value *NumElements = nullptr,
3254 CharUnits CookieSize = CharUnits());
3255
3257 const CallExpr *TheCallExpr, bool IsDelete);
3258
3259 llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E);
3260 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
3262
3263 /// Situations in which we might emit a check for the suitability of a
3264 /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
3265 /// compiler-rt.
3267 /// Checking the operand of a load. Must be suitably sized and aligned.
3269 /// Checking the destination of a store. Must be suitably sized and aligned.
3271 /// Checking the bound value in a reference binding. Must be suitably sized
3272 /// and aligned, but is not required to refer to an object (until the
3273 /// reference is used), per core issue 453.
3275 /// Checking the object expression in a non-static data member access. Must
3276 /// be an object within its lifetime.
3278 /// Checking the 'this' pointer for a call to a non-static member function.
3279 /// Must be an object within its lifetime.
3281 /// Checking the 'this' pointer for a constructor call.
3283 /// Checking the operand of a static_cast to a derived pointer type. Must be
3284 /// null or an object within its lifetime.
3286 /// Checking the operand of a static_cast to a derived reference type. Must
3287 /// be an object within its lifetime.
3289 /// Checking the operand of a cast to a base object. Must be suitably sized
3290 /// and aligned.
3292 /// Checking the operand of a cast to a virtual base object. Must be an
3293 /// object within its lifetime.
3295 /// Checking the value assigned to a _Nonnull pointer. Must not be null.
3297 /// Checking the operand of a dynamic_cast or a typeid expression. Must be
3298 /// null or an object within its lifetime.
3300 };
3301
3302 /// Determine whether the pointer type check \p TCK permits null pointers.
3303 static bool isNullPointerAllowed(TypeCheckKind TCK);
3304
3305 /// Determine whether the pointer type check \p TCK requires a vptr check.
3306 static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty);
3307
3308 /// Whether any type-checking sanitizers are enabled. If \c false,
3309 /// calls to EmitTypeCheck can be skipped.
3310 bool sanitizePerformTypeCheck() const;
3311
3313 QualType Type, SanitizerSet SkippedChecks = SanitizerSet(),
3314 llvm::Value *ArraySize = nullptr) {
3316 return;
3317 EmitTypeCheck(TCK, Loc, LV.emitRawPointer(*this), Type, LV.getAlignment(),
3318 SkippedChecks, ArraySize);
3319 }
3320
3322 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3323 SanitizerSet SkippedChecks = SanitizerSet(),
3324 llvm::Value *ArraySize = nullptr) {
3326 return;
3327 EmitTypeCheck(TCK, Loc, Addr.emitRawPointer(*this), Type, Alignment,
3328 SkippedChecks, ArraySize);
3329 }
3330
3331 /// Emit a check that \p V is the address of storage of the
3332 /// appropriate size and alignment for an object of type \p Type
3333 /// (or if ArraySize is provided, for an array of that bound).
3334 void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V,
3335 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3336 SanitizerSet SkippedChecks = SanitizerSet(),
3337 llvm::Value *ArraySize = nullptr);
3338
3339 /// Emit a check that \p Base points into an array object, which
3340 /// we can access at index \p Index. \p Accessed should be \c false if we
3341 /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
3342 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
3343 QualType IndexType, bool Accessed);
3344 void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound,
3345 llvm::Value *Index, QualType IndexType,
3346 QualType IndexedType, bool Accessed);
3347
3348 /// Returns debug info, with additional annotation if
3349 /// CGM.getCodeGenOpts().SanitizeAnnotateDebugInfo[Ordinal] is enabled for
3350 /// any of the ordinals.
3351 llvm::DILocation *
3353 SanitizerHandler Handler);
3354
3355 /// Build metadata used by the AllocToken instrumentation.
3356 llvm::MDNode *buildAllocToken(QualType AllocType);
3357 /// Emit and set additional metadata used by the AllocToken instrumentation.
3358 void EmitAllocToken(llvm::CallBase *CB, QualType AllocType);
3359 /// Build additional metadata used by the AllocToken instrumentation,
3360 /// inferring the type from an allocation call expression.
3361 llvm::MDNode *buildAllocToken(const CallExpr *E);
3362 /// Emit and set additional metadata used by the AllocToken instrumentation,
3363 /// inferring the type from an allocation call expression.
3364 void EmitAllocToken(llvm::CallBase *CB, const CallExpr *E);
3365
3366 llvm::Value *GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD,
3367 const FieldDecl *CountDecl);
3368
3369 /// Build an expression accessing the "counted_by" field.
3370 llvm::Value *EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD,
3371 const FieldDecl *CountDecl);
3372
3373 // Emit bounds checking for flexible array and pointer members with the
3374 // counted_by attribute.
3375 void EmitCountedByBoundsChecking(const Expr *E, llvm::Value *Idx,
3376 Address Addr, QualType IdxTy,
3377 QualType ArrayTy, bool Accessed,
3378 bool FlexibleArray);
3379
3380 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
3381 bool isInc, bool isPre);
3383 bool isInc, bool isPre);
3384
3385 /// Converts Location to a DebugLoc, if debug information is enabled.
3386 llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location);
3387
3388 /// Get the record field index as represented in debug info.
3389 unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex);
3390
3391 //===--------------------------------------------------------------------===//
3392 // Declaration Emission
3393 //===--------------------------------------------------------------------===//
3394
3395 /// EmitDecl - Emit a declaration.
3396 ///
3397 /// This function can be called with a null (unreachable) insert point.
3398 void EmitDecl(const Decl &D, bool EvaluateConditionDecl = false);
3399
3400 /// EmitVarDecl - Emit a local variable declaration.
3401 ///
3402 /// This function can be called with a null (unreachable) insert point.
3403 void EmitVarDecl(const VarDecl &D);
3404
3405 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
3406 bool capturedByInit);
3407
3408 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
3409 llvm::Value *Address);
3410
3411 /// Determine whether the given initializer is trivial in the sense
3412 /// that it requires no code to be generated.
3413 bool isTrivialInitializer(const Expr *Init);
3414
3415 /// EmitAutoVarDecl - Emit an auto variable declaration.
3416 ///
3417 /// This function can be called with a null (unreachable) insert point.
3418 void EmitAutoVarDecl(const VarDecl &D);
3419
3420 class AutoVarEmission {
3421 friend class CodeGenFunction;
3422
3423 const VarDecl *Variable;
3424
3425 /// The address of the alloca for languages with explicit address space
3426 /// (e.g. OpenCL) or alloca casted to generic pointer for address space
3427 /// agnostic languages (e.g. C++). Invalid if the variable was emitted
3428 /// as a global constant.
3429 Address Addr;
3430
3431 llvm::Value *NRVOFlag;
3432
3433 /// True if the variable is a __block variable that is captured by an
3434 /// escaping block.
3435 bool IsEscapingByRef;
3436
3437 /// True if the variable is of aggregate type and has a constant
3438 /// initializer.
3439 bool IsConstantAggregate;
3440
3441 /// True if lifetime markers should be used.
3442 bool UseLifetimeMarkers;
3443
3444 /// Address with original alloca instruction. Invalid if the variable was
3445 /// emitted as a global constant.
3446 RawAddress AllocaAddr;
3447
3448 struct Invalid {};
3450 : Variable(nullptr), Addr(Address::invalid()),
3451 AllocaAddr(RawAddress::invalid()) {}
3452
3453 AutoVarEmission(const VarDecl &variable)
3454 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
3455 IsEscapingByRef(false), IsConstantAggregate(false),
3456 UseLifetimeMarkers(false), AllocaAddr(RawAddress::invalid()) {}
3457
3458 bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
3459
3460 public:
3461 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
3462
3463 bool useLifetimeMarkers() const { return UseLifetimeMarkers; }
3464
3465 /// Returns the raw, allocated address, which is not necessarily
3466 /// the address of the object itself. It is casted to default
3467 /// address space for address space agnostic languages.
3468 Address getAllocatedAddress() const { return Addr; }
3469
3470 /// Returns the address for the original alloca instruction.
3471 RawAddress getOriginalAllocatedAddress() const { return AllocaAddr; }
3472
3473 /// Returns the address of the object within this declaration.
3474 /// Note that this does not chase the forwarding pointer for
3475 /// __block decls.
3477 if (!IsEscapingByRef)
3478 return Addr;
3479
3480 return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false);
3481 }
3482 };
3483 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
3484 void EmitAutoVarInit(const AutoVarEmission &emission);
3485 void EmitAutoVarCleanups(const AutoVarEmission &emission);
3486 void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
3487 QualType::DestructionKind dtorKind);
3488
3489 void MaybeEmitDeferredVarDeclInit(const VarDecl *var);
3490
3491 /// Emits the alloca and debug information for the size expressions for each
3492 /// dimension of an array. It registers the association of its (1-dimensional)
3493 /// QualTypes and size expression's debug node, so that CGDebugInfo can
3494 /// reference this node when creating the DISubrange object to describe the
3495 /// array types.
3497 bool EmitDebugInfo);
3498
3499 void EmitStaticVarDecl(const VarDecl &D,
3500 llvm::GlobalValue::LinkageTypes Linkage);
3501
3502 class ParamValue {
3503 union {
3505 llvm::Value *Value;
3506 };
3507
3508 bool IsIndirect;
3509
3510 ParamValue(llvm::Value *V) : Value(V), IsIndirect(false) {}
3511 ParamValue(Address A) : Addr(A), IsIndirect(true) {}
3512
3513 public:
3514 static ParamValue forDirect(llvm::Value *value) {
3515 return ParamValue(value);
3516 }
3517 static ParamValue forIndirect(Address addr) {
3518 assert(!addr.getAlignment().isZero());
3519 return ParamValue(addr);
3520 }
3521
3522 bool isIndirect() const { return IsIndirect; }
3523 llvm::Value *getAnyValue() const {
3524 if (!isIndirect())
3525 return Value;
3526 assert(!Addr.hasOffset() && "unexpected offset");
3527 return Addr.getBasePointer();
3528 }
3529
3530 llvm::Value *getDirectValue() const {
3531 assert(!isIndirect());
3532 return Value;
3533 }
3534
3536 assert(isIndirect());
3537 return Addr;
3538 }
3539 };
3540
3541 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3542 void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo);
3543
3544 /// protectFromPeepholes - Protect a value that we're intending to
3545 /// store to the side, but which will probably be used later, from
3546 /// aggressive peepholing optimizations that might delete it.
3547 ///
3548 /// Pass the result to unprotectFromPeepholes to declare that
3549 /// protection is no longer required.
3550 ///
3551 /// There's no particular reason why this shouldn't apply to
3552 /// l-values, it's just that no existing peepholes work on pointers.
3553 PeepholeProtection protectFromPeepholes(RValue rvalue);
3554 void unprotectFromPeepholes(PeepholeProtection protection);
3555
3556 void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty,
3557 SourceLocation Loc,
3558 SourceLocation AssumptionLoc,
3559 llvm::Value *Alignment,
3560 llvm::Value *OffsetValue,
3561 llvm::Value *TheCheck,
3562 llvm::Instruction *Assumption);
3563
3564 void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
3565 SourceLocation Loc, SourceLocation AssumptionLoc,
3566 llvm::Value *Alignment,
3567 llvm::Value *OffsetValue = nullptr);
3568
3569 void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3570 SourceLocation AssumptionLoc,
3571 llvm::Value *Alignment,
3572 llvm::Value *OffsetValue = nullptr);
3573
3574 //===--------------------------------------------------------------------===//
3575 // Statement Emission
3576 //===--------------------------------------------------------------------===//
3577
3578 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3579 void EmitStopPoint(const Stmt *S);
3580
3581 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3582 /// this function even if there is no current insertion point.
3583 ///
3584 /// This function may clear the current insertion point; callers should use
3585 /// EnsureInsertPoint if they wish to subsequently generate code without first
3586 /// calling EmitBlock, EmitBranch, or EmitStmt.
3587 void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = {});
3588
3589 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3590 /// necessarily require an insertion point or debug information; typically
3591 /// because the statement amounts to a jump or a container of other
3592 /// statements.
3593 ///
3594 /// \return True if the statement was handled.
3595 bool EmitSimpleStmt(const Stmt *S, ArrayRef<const Attr *> Attrs);
3596
3597 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
3598 AggValueSlot AVS = AggValueSlot::ignored());
3599 Address
3600 EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast = false,
3601 AggValueSlot AVS = AggValueSlot::ignored());
3602
3603 /// EmitLabel - Emit the block for the given label. It is legal to call this
3604 /// function even if there is no current insertion point.
3605 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
3606
3607 void EmitLabelStmt(const LabelStmt &S);
3608 void EmitAttributedStmt(const AttributedStmt &S);
3609 void EmitGotoStmt(const GotoStmt &S);
3611 void EmitIfStmt(const IfStmt &S);
3612
3613 void EmitWhileStmt(const WhileStmt &S, ArrayRef<const Attr *> Attrs = {});
3614 void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = {});
3615 void EmitForStmt(const ForStmt &S, ArrayRef<const Attr *> Attrs = {});
3616 void EmitReturnStmt(const ReturnStmt &S);
3617 void EmitDeclStmt(const DeclStmt &S);
3618 void EmitBreakStmt(const BreakStmt &S);
3619 void EmitContinueStmt(const ContinueStmt &S);
3620 void EmitSwitchStmt(const SwitchStmt &S);
3621 void EmitDefaultStmt(const DefaultStmt &S, ArrayRef<const Attr *> Attrs);
3622 void EmitCaseStmt(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3623 void EmitCaseStmtRange(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3624 void EmitAsmStmt(const AsmStmt &S);
3625
3626 const BreakContinue *GetDestForLoopControlStmt(const LoopControlStmt &S);
3627
3628 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
3629 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
3630 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
3631 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
3632 void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S);
3633
3634 void EmitCoroutineBody(const CoroutineBodyStmt &S);
3635 void EmitCoreturnStmt(const CoreturnStmt &S);
3636 RValue EmitCoawaitExpr(const CoawaitExpr &E,
3637 AggValueSlot aggSlot = AggValueSlot::ignored(),
3638 bool ignoreResult = false);
3639 LValue EmitCoawaitLValue(const CoawaitExpr *E);
3640 RValue EmitCoyieldExpr(const CoyieldExpr &E,
3641 AggValueSlot aggSlot = AggValueSlot::ignored(),
3642 bool ignoreResult = false);
3643 LValue EmitCoyieldLValue(const CoyieldExpr *E);
3644 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3645
3646 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3647 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3648
3649 void EmitCXXTryStmt(const CXXTryStmt &S);
3650 void EmitSEHTryStmt(const SEHTryStmt &S);
3651 void EmitSEHLeaveStmt(const SEHLeaveStmt &S);
3652 void EnterSEHTryStmt(const SEHTryStmt &S);
3653 void ExitSEHTryStmt(const SEHTryStmt &S);
3654 void VolatilizeTryBlocks(llvm::BasicBlock *BB,
3655 llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V);
3656
3657 void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc);
3658 void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter,
3659 const Stmt *OutlinedStmt);
3660
3661 llvm::Function *GenerateSEHFilterFunction(CodeGenFunction &ParentCGF,
3662 const SEHExceptStmt &Except);
3663
3664 llvm::Function *GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF,
3665 const SEHFinallyStmt &Finally);
3666
3667 void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF,
3668 llvm::Value *ParentFP, llvm::Value *EntryEBP);
3669 llvm::Value *EmitSEHExceptionCode();
3670 llvm::Value *EmitSEHExceptionInfo();
3671 llvm::Value *EmitSEHAbnormalTermination();
3672
3673 /// Emit simple code for OpenMP directives in Simd-only mode.
3674 void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D);
3675
3676 /// Scan the outlined statement for captures from the parent function. For
3677 /// each capture, mark the capture as escaped and emit a call to
3678 /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap.
3679 void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt,
3680 bool IsFilter);
3681
3682 /// Recovers the address of a local in a parent function. ParentVar is the
3683 /// address of the variable used in the immediate parent function. It can
3684 /// either be an alloca or a call to llvm.localrecover if there are nested
3685 /// outlined functions. ParentFP is the frame pointer of the outermost parent
3686 /// frame.
3687 Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
3688 Address ParentVar, llvm::Value *ParentFP);
3689
3690 void EmitCXXForRangeStmt(const CXXForRangeStmt &S,
3691 ArrayRef<const Attr *> Attrs = {});
3692
3693 /// Controls insertion of cancellation exit blocks in worksharing constructs.
3695 CodeGenFunction &CGF;
3696
3697 public:
3698 OMPCancelStackRAII(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
3699 bool HasCancel)
3700 : CGF(CGF) {
3701 CGF.OMPCancelStack.enter(CGF, Kind, HasCancel);
3702 }
3703 ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); }
3704 };
3705
3706 /// Returns calculated size of the specified type.
3707 llvm::Value *getTypeSize(QualType Ty);
3709 llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
3710 llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
3712 llvm::Function *
3714 const OMPExecutableDirective &D);
3716 SmallVectorImpl<llvm::Value *> &CapturedVars);
3717 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3718 SourceLocation Loc);
3719 /// Perform element by element copying of arrays with type \a
3720 /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
3721 /// generated by \a CopyGen.
3722 ///
3723 /// \param DestAddr Address of the destination array.
3724 /// \param SrcAddr Address of the source array.
3725 /// \param OriginalType Type of destination and source arrays.
3726 /// \param CopyGen Copying procedure that copies value of single array element
3727 /// to another single array element.
3729 Address DestAddr, Address SrcAddr, QualType OriginalType,
3730 const llvm::function_ref<void(Address, Address)> CopyGen);
3731 /// Emit proper copying of data from one variable to another.
3732 ///
3733 /// \param OriginalType Original type of the copied variables.
3734 /// \param DestAddr Destination address.
3735 /// \param SrcAddr Source address.
3736 /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3737 /// type of the base array element).
3738 /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3739 /// the base array element).
3740 /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
3741 /// DestVD.
3742 void EmitOMPCopy(QualType OriginalType, Address DestAddr, Address SrcAddr,
3743 const VarDecl *DestVD, const VarDecl *SrcVD,
3744 const Expr *Copy);
3745 /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or
3746 /// \a X = \a E \a BO \a E.
3747 ///
3748 /// \param X Value to be updated.
3749 /// \param E Update value.
3750 /// \param BO Binary operation for update operation.
3751 /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3752 /// expression, false otherwise.
3753 /// \param AO Atomic ordering of the generated atomic instructions.
3754 /// \param CommonGen Code generator for complex expressions that cannot be
3755 /// expressed through atomicrmw instruction.
3756 /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was
3757 /// generated, <false, RValue::get(nullptr)> otherwise.
3758 std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3760 llvm::AtomicOrdering AO, SourceLocation Loc,
3761 const llvm::function_ref<RValue(RValue)> CommonGen);
3763 OMPPrivateScope &PrivateScope);
3765 OMPPrivateScope &PrivateScope);
3767 const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope,
3768 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3769 CaptureDeviceAddrMap);
3771 const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope,
3772 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3773 CaptureDeviceAddrMap);
3774 /// Emit code for copyin clause in \a D directive. The next code is
3775 /// generated at the start of outlined functions for directives:
3776 /// \code
3777 /// threadprivate_var1 = master_threadprivate_var1;
3778 /// operator=(threadprivate_var2, master_threadprivate_var2);
3779 /// ...
3780 /// __kmpc_barrier(&loc, global_tid);
3781 /// \endcode
3782 ///
3783 /// \param D OpenMP directive possibly with 'copyin' clause(s).
3784 /// \returns true if at least one copyin variable is found, false otherwise.
3786 /// Emit initial code for lastprivate variables. If some variable is
3787 /// not also firstprivate, then the default initialization is used. Otherwise
3788 /// initialization of this variable is performed by EmitOMPFirstprivateClause
3789 /// method.
3790 ///
3791 /// \param D Directive that may have 'lastprivate' directives.
3792 /// \param PrivateScope Private scope for capturing lastprivate variables for
3793 /// proper codegen in internal captured statement.
3794 ///
3795 /// \returns true if there is at least one lastprivate variable, false
3796 /// otherwise.
3798 OMPPrivateScope &PrivateScope);
3799 /// Emit final copying of lastprivate values to original variables at
3800 /// the end of the worksharing or simd directive.
3801 ///
3802 /// \param D Directive that has at least one 'lastprivate' directives.
3803 /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
3804 /// it is the last iteration of the loop code in associated directive, or to
3805 /// 'i1 false' otherwise. If this item is nullptr, no final check is required.
3807 bool NoFinals,
3808 llvm::Value *IsLastIterCond = nullptr);
3809 /// Emit initial code for linear clauses.
3811 CodeGenFunction::OMPPrivateScope &PrivateScope);
3812 /// Emit final code for linear clauses.
3813 /// \param CondGen Optional conditional code for final part of codegen for
3814 /// linear clause.
3816 const OMPLoopDirective &D,
3817 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3818 /// Emit initial code for reduction variables. Creates reduction copies
3819 /// and initializes them with the values according to OpenMP standard.
3820 ///
3821 /// \param D Directive (possibly) with the 'reduction' clause.
3822 /// \param PrivateScope Private scope for capturing reduction variables for
3823 /// proper codegen in internal captured statement.
3824 ///
3826 OMPPrivateScope &PrivateScope,
3827 bool ForInscan = false);
3828 /// Emit final update of reduction values to original variables at
3829 /// the end of the directive.
3830 ///
3831 /// \param D Directive that has at least one 'reduction' directives.
3832 /// \param ReductionKind The kind of reduction to perform.
3834 const OpenMPDirectiveKind ReductionKind);
3835 /// Emit initial code for linear variables. Creates private copies
3836 /// and initializes them with the values according to OpenMP standard.
3837 ///
3838 /// \param D Directive (possibly) with the 'linear' clause.
3839 /// \return true if at least one linear variable is found that should be
3840 /// initialized with the value of the original variable, false otherwise.
3842
3843 typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/,
3844 llvm::Function * /*OutlinedFn*/,
3845 const OMPTaskDataTy & /*Data*/)>
3848 const OpenMPDirectiveKind CapturedRegion,
3849 const RegionCodeGenTy &BodyGen,
3850 const TaskGenTy &TaskGen, OMPTaskDataTy &Data);
3866 const RegionCodeGenTy &BodyGen,
3867 OMPTargetDataInfo &InputInfo);
3869 CodeGenFunction &CGF, const CapturedStmt *CS,
3870 OMPPrivateScope &Scope);
3872 void EmitOMPParallelDirective(const OMPParallelDirective &S);
3873 void EmitOMPSimdDirective(const OMPSimdDirective &S);
3880 void EmitOMPForDirective(const OMPForDirective &S);
3881 void EmitOMPForSimdDirective(const OMPForSimdDirective &S);
3882 void EmitOMPScopeDirective(const OMPScopeDirective &S);
3883 void EmitOMPSectionsDirective(const OMPSectionsDirective &S);
3884 void EmitOMPSectionDirective(const OMPSectionDirective &S);
3885 void EmitOMPSingleDirective(const OMPSingleDirective &S);
3886 void EmitOMPMasterDirective(const OMPMasterDirective &S);
3888 void EmitOMPCriticalDirective(const OMPCriticalDirective &S);
3889 void EmitOMPParallelForDirective(const OMPParallelForDirective &S);
3890 void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S);
3891 void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S);
3892 void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S);
3893 void EmitOMPTaskDirective(const OMPTaskDirective &S);
3894 void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S);
3896 void EmitOMPBarrierDirective(const OMPBarrierDirective &S);
3897 void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S);
3898 void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S);
3899 void EmitOMPFlushDirective(const OMPFlushDirective &S);
3900 void EmitOMPDepobjDirective(const OMPDepobjDirective &S);
3902 void EmitOMPOrderedDirective(const OMPOrderedDirective &S);
3903 void EmitOMPAtomicDirective(const OMPAtomicDirective &S);
3910 void
3913 void
3921 void
3923 void
3943 void
3966 void EmitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &S);
3968
3969 /// Emit device code for the target directive.
3971 StringRef ParentName,
3972 const OMPTargetDirective &S);
3973 static void
3976 /// Emit device code for the target parallel for directive.
3978 CodeGenModule &CGM, StringRef ParentName,
3980 /// Emit device code for the target parallel for simd directive.
3982 CodeGenModule &CGM, StringRef ParentName,
3984 /// Emit device code for the target teams directive.
3985 static void
3986 EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName,
3987 const OMPTargetTeamsDirective &S);
3988 /// Emit device code for the target teams distribute directive.
3990 CodeGenModule &CGM, StringRef ParentName,
3992 /// Emit device code for the target teams distribute simd directive.
3994 CodeGenModule &CGM, StringRef ParentName,
3996 /// Emit device code for the target simd directive.
3998 StringRef ParentName,
3999 const OMPTargetSimdDirective &S);
4000 /// Emit device code for the target teams distribute parallel for simd
4001 /// directive.
4003 CodeGenModule &CGM, StringRef ParentName,
4005
4006 /// Emit device code for the target teams loop directive.
4008 CodeGenModule &CGM, StringRef ParentName,
4010
4011 /// Emit device code for the target parallel loop directive.
4013 CodeGenModule &CGM, StringRef ParentName,
4015
4017 CodeGenModule &CGM, StringRef ParentName,
4019
4020 /// Emit the Stmt \p S and return its topmost canonical loop, if any.
4021 /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
4022 /// future it is meant to be the number of loops expected in the loop nests
4023 /// (usually specified by the "collapse" clause) that are collapsed to a
4024 /// single loop by this function.
4025 llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S,
4026 int Depth);
4027
4028 /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
4029 void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S);
4030
4031 /// Emit inner loop of the worksharing/simd construct.
4032 ///
4033 /// \param S Directive, for which the inner loop must be emitted.
4034 /// \param RequiresCleanup true, if directive has some associated private
4035 /// variables.
4036 /// \param LoopCond Bollean condition for loop continuation.
4037 /// \param IncExpr Increment expression for loop control variable.
4038 /// \param BodyGen Generator for the inner body of the inner loop.
4039 /// \param PostIncGen Genrator for post-increment code (required for ordered
4040 /// loop directvies).
4041 void EmitOMPInnerLoop(
4042 const OMPExecutableDirective &S, bool RequiresCleanup,
4043 const Expr *LoopCond, const Expr *IncExpr,
4044 const llvm::function_ref<void(CodeGenFunction &)> BodyGen,
4045 const llvm::function_ref<void(CodeGenFunction &)> PostIncGen);
4046
4048 /// Emit initial code for loop counters of loop-based directives.
4050 OMPPrivateScope &LoopScope);
4051
4052 /// Helper for the OpenMP loop directives.
4053 void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit);
4054
4055 /// Emit code for the worksharing loop-based directive.
4056 /// \return true, if this construct has any lastprivate clause, false -
4057 /// otherwise.
4058 bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB,
4059 const CodeGenLoopBoundsTy &CodeGenLoopBounds,
4060 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4061
4062 /// Emit code for the distribute loop-based directive.
4064 const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
4065
4066 /// Helpers for the OpenMP loop directives.
4067 void EmitOMPSimdInit(const OMPLoopDirective &D);
4068 void EmitOMPSimdFinal(
4069 const OMPLoopDirective &D,
4070 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
4071
4072 /// Emits the lvalue for the expression with possibly captured variable.
4074
4075private:
4076 /// Helpers for blocks.
4077 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info);
4078
4079 /// struct with the values to be passed to the OpenMP loop-related functions
4080 struct OMPLoopArguments {
4081 /// loop lower bound
4083 /// loop upper bound
4085 /// loop stride
4087 /// isLastIteration argument for runtime functions
4089 /// Chunk value generated by sema
4090 llvm::Value *Chunk = nullptr;
4091 /// EnsureUpperBound
4092 Expr *EUB = nullptr;
4093 /// IncrementExpression
4094 Expr *IncExpr = nullptr;
4095 /// Loop initialization
4096 Expr *Init = nullptr;
4097 /// Loop exit condition
4098 Expr *Cond = nullptr;
4099 /// Update of LB after a whole chunk has been executed
4100 Expr *NextLB = nullptr;
4101 /// Update of UB after a whole chunk has been executed
4102 Expr *NextUB = nullptr;
4103 /// Distinguish between the for distribute and sections
4104 OpenMPDirectiveKind DKind = llvm::omp::OMPD_unknown;
4105 OMPLoopArguments() = default;
4106 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
4107 llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
4108 Expr *IncExpr = nullptr, Expr *Init = nullptr,
4109 Expr *Cond = nullptr, Expr *NextLB = nullptr,
4110 Expr *NextUB = nullptr)
4111 : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB),
4112 IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB),
4113 NextUB(NextUB) {}
4114 };
4115 void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic,
4116 const OMPLoopDirective &S, OMPPrivateScope &LoopScope,
4117 const OMPLoopArguments &LoopArgs,
4118 const CodeGenLoopTy &CodeGenLoop,
4119 const CodeGenOrderedTy &CodeGenOrdered);
4120 void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind,
4121 bool IsMonotonic, const OMPLoopDirective &S,
4122 OMPPrivateScope &LoopScope, bool Ordered,
4123 const OMPLoopArguments &LoopArgs,
4124 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4125 void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind,
4126 const OMPLoopDirective &S,
4127 OMPPrivateScope &LoopScope,
4128 const OMPLoopArguments &LoopArgs,
4129 const CodeGenLoopTy &CodeGenLoopContent);
4130 /// Emit code for sections directive.
4131 void EmitSections(const OMPExecutableDirective &S);
4132
4133public:
4134 //===--------------------------------------------------------------------===//
4135 // OpenACC Emission
4136 //===--------------------------------------------------------------------===//
4138 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4139 // simply emitting its structured block, but in the future we will implement
4140 // some sort of IR.
4141 EmitStmt(S.getStructuredBlock());
4142 }
4143
4145 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4146 // simply emitting its loop, but in the future we will implement
4147 // some sort of IR.
4148 EmitStmt(S.getLoop());
4149 }
4150
4152 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4153 // simply emitting its loop, but in the future we will implement
4154 // some sort of IR.
4155 EmitStmt(S.getLoop());
4156 }
4157
4159 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4160 // simply emitting its structured block, but in the future we will implement
4161 // some sort of IR.
4163 }
4164
4166 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4167 // but in the future we will implement some sort of IR.
4168 }
4169
4171 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4172 // but in the future we will implement some sort of IR.
4173 }
4174
4176 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4177 // simply emitting its structured block, but in the future we will implement
4178 // some sort of IR.
4180 }
4181
4183 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4184 // but in the future we will implement some sort of IR.
4185 }
4186
4188 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4189 // but in the future we will implement some sort of IR.
4190 }
4191
4193 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4194 // but in the future we will implement some sort of IR.
4195 }
4196
4198 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4199 // but in the future we will implement some sort of IR.
4200 }
4201
4203 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4204 // but in the future we will implement some sort of IR.
4205 }
4206
4208 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4209 // simply emitting its associated stmt, but in the future we will implement
4210 // some sort of IR.
4212 }
4214 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4215 // but in the future we will implement some sort of IR.
4216 }
4217
4218 //===--------------------------------------------------------------------===//
4219 // LValue Expression Emission
4220 //===--------------------------------------------------------------------===//
4221
4222 /// Create a check that a scalar RValue is non-null.
4223 llvm::Value *EmitNonNullRValueCheck(RValue RV, QualType T);
4224
4225 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
4227
4228 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
4229 /// and issue an ErrorUnsupported style diagnostic (using the
4230 /// provided Name).
4231 RValue EmitUnsupportedRValue(const Expr *E, const char *Name);
4232
4233 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
4234 /// an ErrorUnsupported style diagnostic (using the provided Name).
4235 LValue EmitUnsupportedLValue(const Expr *E, const char *Name);
4236
4237 /// EmitLValue - Emit code to compute a designator that specifies the location
4238 /// of the expression.
4239 ///
4240 /// This can return one of two things: a simple address or a bitfield
4241 /// reference. In either case, the LLVM Value* in the LValue structure is
4242 /// guaranteed to be an LLVM pointer type.
4243 ///
4244 /// If this returns a bitfield reference, nothing about the pointee type of
4245 /// the LLVM value is known: For example, it may not be a pointer to an
4246 /// integer.
4247 ///
4248 /// If this returns a normal address, and if the lvalue's C type is fixed
4249 /// size, this method guarantees that the returned pointer type will point to
4250 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
4251 /// variable length type, this is not possible.
4252 ///
4253 LValue EmitLValue(const Expr *E,
4254 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
4255
4256private:
4257 LValue EmitLValueHelper(const Expr *E, KnownNonNull_t IsKnownNonNull);
4258
4259public:
4260 /// Same as EmitLValue but additionally we generate checking code to
4261 /// guard against undefined behavior. This is only suitable when we know
4262 /// that the address will be used to access the object.
4264
4266
4267 void EmitAtomicInit(Expr *E, LValue lvalue);
4268
4270
4273
4275 llvm::AtomicOrdering AO, bool IsVolatile = false,
4277
4278 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
4279
4280 void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
4281 bool IsVolatile, bool isInit);
4282
4283 std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
4284 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
4285 llvm::AtomicOrdering Success =
4286 llvm::AtomicOrdering::SequentiallyConsistent,
4287 llvm::AtomicOrdering Failure =
4288 llvm::AtomicOrdering::SequentiallyConsistent,
4289 bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored());
4290
4291 /// Emit an atomicrmw instruction, and applying relevant metadata when
4292 /// applicable.
4293 llvm::AtomicRMWInst *emitAtomicRMWInst(
4294 llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val,
4295 llvm::AtomicOrdering Order = llvm::AtomicOrdering::SequentiallyConsistent,
4296 llvm::SyncScope::ID SSID = llvm::SyncScope::System,
4297 const AtomicExpr *AE = nullptr);
4298
4299 void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
4300 const llvm::function_ref<RValue(RValue)> &UpdateOp,
4301 bool IsVolatile);
4302
4303 /// EmitToMemory - Change a scalar value from its value
4304 /// representation to its in-memory representation.
4305 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
4306
4307 /// EmitFromMemory - Change a scalar value from its memory
4308 /// representation to its value representation.
4309 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
4310
4311 /// Check if the scalar \p Value is within the valid range for the given
4312 /// type \p Ty.
4313 ///
4314 /// Returns true if a check is needed (even if the range is unknown).
4315 bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty,
4316 SourceLocation Loc);
4317
4318 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4319 /// care to appropriately convert from the memory representation to
4320 /// the LLVM value representation.
4321 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4322 SourceLocation Loc,
4324 bool isNontemporal = false) {
4325 return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source),
4326 CGM.getTBAAAccessInfo(Ty), isNontemporal);
4327 }
4328
4329 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4330 SourceLocation Loc, LValueBaseInfo BaseInfo,
4331 TBAAAccessInfo TBAAInfo,
4332 bool isNontemporal = false);
4333
4334 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4335 /// care to appropriately convert from the memory representation to
4336 /// the LLVM value representation. The l-value must be a simple
4337 /// l-value.
4338 llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc);
4339
4340 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4341 /// care to appropriately convert from the memory representation to
4342 /// the LLVM value representation.
4343 void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile,
4344 QualType Ty,
4346 bool isInit = false, bool isNontemporal = false) {
4347 EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source),
4348 CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal);
4349 }
4350
4351 void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile,
4352 QualType Ty, LValueBaseInfo BaseInfo,
4353 TBAAAccessInfo TBAAInfo, bool isInit = false,
4354 bool isNontemporal = false);
4355
4356 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4357 /// care to appropriately convert from the memory representation to
4358 /// the LLVM value representation. The l-value must be a simple
4359 /// l-value. The isInit flag indicates whether this is an initialization.
4360 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
4361 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
4362 bool isInit = false);
4363
4364 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
4365 /// this method emits the address of the lvalue, then loads the result as an
4366 /// rvalue, returning the rvalue.
4371
4372 /// Like EmitLoadOfLValue but also handles complex and aggregate types.
4375 SourceLocation Loc = {});
4376
4377 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
4378 /// lvalue, where both are guaranteed to the have the same type, and that type
4379 /// is 'Ty'.
4380 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
4381 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
4382 void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst);
4383
4384 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
4385 /// as EmitStoreThroughLValue.
4386 ///
4387 /// \param Result [out] - If non-null, this will be set to a Value* for the
4388 /// bit-field contents after the store, appropriate for use as the result of
4389 /// an assignment to the bit-field.
4390 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
4391 llvm::Value **Result = nullptr);
4392
4393 /// Emit an l-value for an assignment (simple or compound) of complex type.
4397 llvm::Value *&Result);
4398
4399 // Note: only available for agg return types
4402 // Note: only available for agg return types
4403 LValue EmitCallExprLValue(const CallExpr *E,
4404 llvm::CallBase **CallOrInvoke = nullptr);
4405 // Note: only available for agg return types
4406 LValue EmitVAArgExprLValue(const VAArgExpr *E);
4407 LValue EmitDeclRefLValue(const DeclRefExpr *E);
4408 LValue EmitStringLiteralLValue(const StringLiteral *E);
4410 LValue EmitPredefinedLValue(const PredefinedExpr *E);
4411 LValue EmitUnaryOpLValue(const UnaryOperator *E);
4413 bool Accessed = false);
4414 llvm::Value *EmitMatrixIndexExpr(const Expr *E);
4416 LValue EmitArraySectionExpr(const ArraySectionExpr *E,
4417 bool IsLowerBound = true);
4419 LValue EmitMemberExpr(const MemberExpr *E);
4420 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
4422 LValue EmitInitListLValue(const InitListExpr *E);
4425 LValue EmitCastLValue(const CastExpr *E);
4427 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
4429
4430 std::pair<LValue, LValue> EmitHLSLOutArgLValues(const HLSLOutArgExpr *E,
4431 QualType Ty);
4432 LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args,
4433 QualType Ty);
4434
4435 Address EmitExtVectorElementLValue(LValue V);
4436
4437 RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc);
4438
4439 Address EmitArrayToPointerDecay(const Expr *Array,
4440 LValueBaseInfo *BaseInfo = nullptr,
4441 TBAAAccessInfo *TBAAInfo = nullptr);
4442
4443 class ConstantEmission {
4444 llvm::PointerIntPair<llvm::Constant *, 1, bool> ValueAndIsReference;
4445 ConstantEmission(llvm::Constant *C, bool isReference)
4446 : ValueAndIsReference(C, isReference) {}
4447
4448 public:
4450 static ConstantEmission forReference(llvm::Constant *C) {
4451 return ConstantEmission(C, true);
4452 }
4453 static ConstantEmission forValue(llvm::Constant *C) {
4454 return ConstantEmission(C, false);
4455 }
4456
4457 explicit operator bool() const {
4458 return ValueAndIsReference.getOpaqueValue() != nullptr;
4459 }
4460
4461 bool isReference() const { return ValueAndIsReference.getInt(); }
4462 LValue getReferenceLValue(CodeGenFunction &CGF, const Expr *RefExpr) const {
4463 assert(isReference());
4464 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
4465 RefExpr->getType());
4466 }
4467
4468 llvm::Constant *getValue() const {
4469 assert(!isReference());
4470 return ValueAndIsReference.getPointer();
4471 }
4472 };
4473
4474 ConstantEmission tryEmitAsConstant(const DeclRefExpr *RefExpr);
4475 ConstantEmission tryEmitAsConstant(const MemberExpr *ME);
4476 llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
4477
4481
4483 SmallVectorImpl<LValue> &AccessList);
4484
4485 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
4486 const ObjCIvarDecl *Ivar);
4488 const ObjCIvarDecl *Ivar);
4490 bool IsInBounds = true);
4493 llvm::Value *ThisValue);
4494
4495 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
4496 /// if the Field is a reference, this will return the address of the reference
4497 /// and not the address of the value stored in the reference.
4499
4500 LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base,
4501 const ObjCIvarDecl *Ivar, unsigned CVRQualifiers);
4502
4507
4513 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init);
4514
4515 //===--------------------------------------------------------------------===//
4516 // Scalar Expression Emission
4517 //===--------------------------------------------------------------------===//
4518
4519 /// EmitCall - Generate a call of the given function, expecting the given
4520 /// result type, and using the given argument list which specifies both the
4521 /// LLVM arguments and the types they were derived from.
4522 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4524 llvm::CallBase **CallOrInvoke, bool IsMustTail,
4525 SourceLocation Loc,
4526 bool IsVirtualFunctionPointerThunk = false);
4527 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4529 llvm::CallBase **CallOrInvoke = nullptr,
4530 bool IsMustTail = false) {
4531 return EmitCall(CallInfo, Callee, ReturnValue, Args, CallOrInvoke,
4532 IsMustTail, SourceLocation());
4533 }
4534 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
4535 ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr,
4536 llvm::CallBase **CallOrInvoke = nullptr,
4537 CGFunctionInfo const **ResolvedFnInfo = nullptr);
4538
4539 // If a Call or Invoke instruction was emitted for this CallExpr, this method
4540 // writes the pointer to `CallOrInvoke` if it's not null.
4541 RValue EmitCallExpr(const CallExpr *E,
4543 llvm::CallBase **CallOrInvoke = nullptr);
4545 llvm::CallBase **CallOrInvoke = nullptr);
4546 CGCallee EmitCallee(const Expr *E);
4547
4548 void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
4549 void checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl);
4550
4551 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4552 const Twine &name = "");
4553 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4555 const Twine &name = "");
4556 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4557 const Twine &name = "");
4558 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4559 ArrayRef<Address> args,
4560 const Twine &name = "");
4561 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4563 const Twine &name = "");
4564
4566 getBundlesForFunclet(llvm::Value *Callee);
4567
4568 llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee,
4570 const Twine &Name = "");
4571 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4573 const Twine &name = "");
4574 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4575 const Twine &name = "");
4576 void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4578
4580 NestedNameSpecifier Qual, llvm::Type *Ty);
4581
4584 const CXXRecordDecl *RD);
4585
4586 bool isPointerKnownNonNull(const Expr *E);
4587 /// Check whether the underlying base pointer is a constant null.
4589
4590 /// Create the discriminator from the storage address and the entity hash.
4591 llvm::Value *EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
4592 llvm::Value *Discriminator);
4594 llvm::Value *StorageAddress,
4595 GlobalDecl SchemaDecl,
4596 QualType SchemaType);
4597
4598 llvm::Value *EmitPointerAuthSign(const CGPointerAuthInfo &Info,
4599 llvm::Value *Pointer);
4600
4601 llvm::Value *EmitPointerAuthAuth(const CGPointerAuthInfo &Info,
4602 llvm::Value *Pointer);
4603
4604 llvm::Value *emitPointerAuthResign(llvm::Value *Pointer, QualType PointerType,
4605 const CGPointerAuthInfo &CurAuthInfo,
4606 const CGPointerAuthInfo &NewAuthInfo,
4607 bool IsKnownNonNull);
4608 llvm::Value *emitPointerAuthResignCall(llvm::Value *Pointer,
4609 const CGPointerAuthInfo &CurInfo,
4610 const CGPointerAuthInfo &NewInfo);
4611
4613 const CGPointerAuthInfo &Info,
4615
4617 Address StorageAddress);
4618 llvm::Value *EmitPointerAuthQualify(PointerAuthQualifier Qualifier,
4619 llvm::Value *Pointer, QualType ValueType,
4620 Address StorageAddress,
4621 bool IsKnownNonNull);
4622 llvm::Value *EmitPointerAuthQualify(PointerAuthQualifier Qualifier,
4623 const Expr *PointerExpr,
4624 Address StorageAddress);
4625 llvm::Value *EmitPointerAuthUnqualify(PointerAuthQualifier Qualifier,
4626 llvm::Value *Pointer,
4628 Address StorageAddress,
4629 bool IsKnownNonNull);
4631 Address DestField, Address SrcField);
4632
4633 std::pair<llvm::Value *, CGPointerAuthInfo>
4634 EmitOrigPointerRValue(const Expr *E);
4635
4636 llvm::Value *authPointerToPointerCast(llvm::Value *ResultPtr,
4637 QualType SourceType, QualType DestType);
4639 QualType DestType);
4640
4642
4643 llvm::Value *getAsNaturalPointerTo(Address Addr, QualType PointeeType) {
4644 return getAsNaturalAddressOf(Addr, PointeeType).getBasePointer();
4645 }
4646
4647 // Return the copy constructor name with the prefix "__copy_constructor_"
4648 // removed.
4649 static std::string getNonTrivialCopyConstructorStr(QualType QT,
4650 CharUnits Alignment,
4651 bool IsVolatile,
4652 ASTContext &Ctx);
4653
4654 // Return the destructor name with the prefix "__destructor_" removed.
4655 static std::string getNonTrivialDestructorStr(QualType QT,
4656 CharUnits Alignment,
4657 bool IsVolatile,
4658 ASTContext &Ctx);
4659
4660 // These functions emit calls to the special functions of non-trivial C
4661 // structs.
4664 void callCStructDestructor(LValue Dst);
4669
4671 const CXXMethodDecl *Method, const CGCallee &Callee,
4672 ReturnValueSlot ReturnValue, llvm::Value *This,
4673 llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E,
4674 CallArgList *RtlArgs, llvm::CallBase **CallOrInvoke);
4675 RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee,
4676 llvm::Value *This, QualType ThisTy,
4677 llvm::Value *ImplicitParam,
4678 QualType ImplicitParamTy, const CallExpr *E,
4679 llvm::CallBase **CallOrInvoke = nullptr);
4682 llvm::CallBase **CallOrInvoke = nullptr);
4684 const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
4685 bool HasQualifier, NestedNameSpecifier Qualifier, bool IsArrow,
4686 const Expr *Base, llvm::CallBase **CallOrInvoke);
4687 // Compute the object pointer.
4689 const Expr *E, Address base, llvm::Value *memberPtr,
4690 const MemberPointerType *memberPtrType, bool IsInBounds,
4691 LValueBaseInfo *BaseInfo = nullptr, TBAAAccessInfo *TBAAInfo = nullptr);
4694 llvm::CallBase **CallOrInvoke);
4695
4697 const CXXMethodDecl *MD,
4699 llvm::CallBase **CallOrInvoke);
4701
4704 llvm::CallBase **CallOrInvoke);
4705
4708
4709 RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
4711
4712 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
4713
4714 /// Emit IR for __builtin_os_log_format.
4716
4717 /// Emit IR for __builtin_is_aligned.
4719 /// Emit IR for __builtin_align_up/__builtin_align_down.
4720 RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp);
4721
4722 llvm::Function *generateBuiltinOSLogHelperFunction(
4724 CharUnits BufferAlignment);
4725
4727 llvm::CallBase **CallOrInvoke);
4728
4729 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4730 /// is unhandled by the current target.
4731 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4733
4734 llvm::Value *
4735 EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty,
4736 const llvm::CmpInst::Predicate Pred,
4737 const llvm::Twine &Name = "");
4738 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4740 llvm::Triple::ArchType Arch);
4741 llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4743 llvm::Triple::ArchType Arch);
4744 llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4746 llvm::Triple::ArchType Arch);
4747 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy,
4748 QualType RTy);
4749 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy,
4750 QualType RTy);
4751
4752 llvm::Value *
4753 EmitCommonNeonBuiltinExpr(unsigned BuiltinID, unsigned LLVMIntrinsic,
4754 unsigned AltLLVMIntrinsic, const char *NameHint,
4755 unsigned Modifier, const CallExpr *E,
4757 Address PtrOp1, llvm::Triple::ArchType Arch);
4758
4759 llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
4760 unsigned Modifier, llvm::Type *ArgTy,
4761 const CallExpr *E);
4762 llvm::Value *EmitNeonCall(llvm::Function *F,
4763 SmallVectorImpl<llvm::Value *> &O, const char *name,
4764 unsigned shift = 0, bool rightshift = false);
4765 llvm::Value *EmitFP8NeonCall(unsigned IID, ArrayRef<llvm::Type *> Tys,
4767 const CallExpr *E, const char *name);
4768 llvm::Value *EmitFP8NeonCvtCall(unsigned IID, llvm::Type *Ty0,
4769 llvm::Type *Ty1, bool Extract,
4771 const CallExpr *E, const char *name);
4772 llvm::Value *EmitFP8NeonFDOTCall(unsigned IID, bool ExtendLaneArg,
4773 llvm::Type *RetTy,
4775 const CallExpr *E, const char *name);
4776 llvm::Value *EmitFP8NeonFMLACall(unsigned IID, bool ExtendLaneArg,
4777 llvm::Type *RetTy,
4779 const CallExpr *E, const char *name);
4780 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
4781 const llvm::ElementCount &Count);
4782 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
4783 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
4784 bool negateForRightShift);
4785 llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt,
4786 llvm::Type *Ty, bool usgn, const char *name);
4787 llvm::Value *vectorWrapScalar16(llvm::Value *Op);
4788 /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4789 /// access builtin. Only required if it can't be inferred from the base
4790 /// pointer operand.
4791 llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags);
4792
4794 getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType,
4796 llvm::Type *getEltType(const SVETypeFlags &TypeFlags);
4797 llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags);
4798 llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags);
4799 llvm::Value *EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags,
4801 llvm::Value *EmitSVETupleCreate(const SVETypeFlags &TypeFlags,
4802 llvm::Type *ReturnType,
4804 llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags);
4805 llvm::Value *EmitSVEDupX(llvm::Value *Scalar);
4806 llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty);
4807 llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty);
4808 llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags,
4810 unsigned BuiltinID);
4811 llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags,
4813 unsigned BuiltinID);
4814 llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred,
4815 llvm::ScalableVectorType *VTy);
4816 llvm::Value *EmitSVEPredicateTupleCast(llvm::Value *PredTuple,
4817 llvm::StructType *Ty);
4818 llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags,
4820 unsigned IntID);
4821 llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags,
4823 unsigned IntID);
4824 llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy,
4826 unsigned BuiltinID, bool IsZExtReturn);
4827 llvm::Value *EmitSVEMaskedStore(const CallExpr *,
4829 unsigned BuiltinID);
4830 llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags,
4832 unsigned BuiltinID);
4833 llvm::Value *EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags,
4835 unsigned IntID);
4836 llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags,
4838 unsigned IntID);
4839 llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags,
4841 unsigned IntID);
4842 llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4843
4844 llvm::Value *EmitSMELd1St1(const SVETypeFlags &TypeFlags,
4846 unsigned IntID);
4847 llvm::Value *EmitSMEReadWrite(const SVETypeFlags &TypeFlags,
4849 unsigned IntID);
4850 llvm::Value *EmitSMEZero(const SVETypeFlags &TypeFlags,
4852 unsigned IntID);
4853 llvm::Value *EmitSMELdrStr(const SVETypeFlags &TypeFlags,
4855 unsigned IntID);
4856
4857 void GetAArch64SVEProcessedOperands(unsigned BuiltinID, const CallExpr *E,
4859 SVETypeFlags TypeFlags);
4860
4861 llvm::Value *EmitAArch64SMEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4862
4863 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4864 llvm::Triple::ArchType Arch);
4865 llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4866
4867 llvm::Value *BuildVector(ArrayRef<llvm::Value *> Ops);
4868 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4869 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4870 llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4871 llvm::Value *EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4873
4874 // Returns a builtin function that the SPIR-V backend will expand into a spec
4875 // constant.
4876 llvm::Function *
4877 getSpecConstantFunction(const clang::QualType &SpecConstantType);
4878
4879 llvm::Value *EmitDirectXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4880 llvm::Value *EmitSPIRVBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4881 llvm::Value *EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx,
4882 const CallExpr *E);
4883 llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4884 llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4885 llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
4886 const CallExpr *E);
4887 llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4888 llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4890
4891 llvm::Value *EmitRISCVCpuSupports(const CallExpr *E);
4892 llvm::Value *EmitRISCVCpuSupports(ArrayRef<StringRef> FeaturesStrs);
4893 llvm::Value *EmitRISCVCpuInit();
4894 llvm::Value *EmitRISCVCpuIs(const CallExpr *E);
4895 llvm::Value *EmitRISCVCpuIs(StringRef CPUStr);
4896
4897 void AddAMDGPUFenceAddressSpaceMMRA(llvm::Instruction *Inst,
4898 const CallExpr *E);
4899 void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope,
4900 llvm::AtomicOrdering &AO,
4901 llvm::SyncScope::ID &SSID);
4902
4903 enum class MSVCIntrin;
4904 llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4905
4906 llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version);
4907
4908 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
4909 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
4910 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E);
4911 llvm::Value *EmitObjCArrayLiteral(const ObjCArrayLiteral *E);
4912 llvm::Value *EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E);
4913 llvm::Value *
4915 const ObjCMethodDecl *MethodWithObjects);
4916 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
4918 ReturnValueSlot Return = ReturnValueSlot());
4919
4920 /// Retrieves the default cleanup kind for an ARC cleanup.
4921 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4923 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions ? NormalAndEHCleanup
4924 : NormalCleanup;
4925 }
4926
4927 // ARC primitives.
4928 void EmitARCInitWeak(Address addr, llvm::Value *value);
4929 void EmitARCDestroyWeak(Address addr);
4930 llvm::Value *EmitARCLoadWeak(Address addr);
4931 llvm::Value *EmitARCLoadWeakRetained(Address addr);
4932 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
4933 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4934 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4935 void EmitARCCopyWeak(Address dst, Address src);
4936 void EmitARCMoveWeak(Address dst, Address src);
4937 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
4938 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
4939 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
4940 bool resultIgnored);
4941 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
4942 bool resultIgnored);
4943 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
4944 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
4945 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
4947 void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4948 llvm::Value *EmitARCAutorelease(llvm::Value *value);
4949 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
4950 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
4951 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
4952 llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value);
4953
4954 llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
4955 llvm::Value *EmitObjCRetainNonBlock(llvm::Value *value,
4956 llvm::Type *returnType);
4957 void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4958
4959 std::pair<LValue, llvm::Value *>
4961 std::pair<LValue, llvm::Value *> EmitARCStoreStrong(const BinaryOperator *e,
4962 bool ignored);
4963 std::pair<LValue, llvm::Value *>
4964 EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored);
4965
4966 llvm::Value *EmitObjCAlloc(llvm::Value *value, llvm::Type *returnType);
4967 llvm::Value *EmitObjCAllocWithZone(llvm::Value *value,
4968 llvm::Type *returnType);
4969 llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
4970
4971 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
4972 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
4973 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
4974
4975 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
4976 llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
4977 bool allowUnsafeClaim);
4978 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
4979 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
4980 llvm::Value *EmitARCUnsafeUnretainedScalarExpr(const Expr *expr);
4981
4983
4985
4991
4992 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
4993 llvm::Value *EmitObjCAutoreleasePoolPush();
4994 llvm::Value *EmitObjCMRRAutoreleasePoolPush();
4995 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
4996 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
4997
4998 /// Emits a reference binding to the passed in expression.
5000
5001 //===--------------------------------------------------------------------===//
5002 // Expression Emission
5003 //===--------------------------------------------------------------------===//
5004
5005 // Expressions are broken into three classes: scalar, complex, aggregate.
5006
5007 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
5008 /// scalar type, returning the result.
5009 llvm::Value *EmitScalarExpr(const Expr *E, bool IgnoreResultAssign = false);
5010
5011 /// Emit a conversion from the specified type to the specified destination
5012 /// type, both of which are LLVM scalar types.
5013 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
5014 QualType DstTy, SourceLocation Loc);
5015
5016 /// Emit a conversion from the specified complex type to the specified
5017 /// destination type, where the destination type is an LLVM scalar type.
5019 QualType DstTy,
5020 SourceLocation Loc);
5021
5022 /// EmitAggExpr - Emit the computation of the specified expression
5023 /// of aggregate type. The result is computed into the given slot,
5024 /// which may be null to indicate that the value is not needed.
5025 void EmitAggExpr(const Expr *E, AggValueSlot AS);
5026
5027 /// EmitAggExprToLValue - Emit the computation of the specified expression of
5028 /// aggregate type into a temporary LValue.
5030
5032
5033 /// EmitAggFinalDestCopy - Emit copy of the specified aggregate into
5034 /// destination address.
5035 void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src,
5036 ExprValueKind SrcKind);
5037
5038 /// Create a store to \arg DstPtr from \arg Src, truncating the stored value
5039 /// to at most \arg DstSize bytes.
5040 void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize,
5041 bool DstIsVolatile);
5042
5043 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
5044 /// make sure it survives garbage collection until this point.
5045 void EmitExtendGCLifetime(llvm::Value *object);
5046
5047 /// EmitComplexExpr - Emit the computation of the specified expression of
5048 /// complex type, returning the result.
5049 ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal = false,
5050 bool IgnoreImag = false);
5051
5052 /// EmitComplexExprIntoLValue - Emit the given expression of complex
5053 /// type and place its result into the specified l-value.
5054 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
5055
5056 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
5057 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
5058
5059 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
5061
5062 ComplexPairTy EmitPromotedComplexExpr(const Expr *E, QualType PromotionType);
5063 llvm::Value *EmitPromotedScalarExpr(const Expr *E, QualType PromotionType);
5066 QualType PromotionType);
5067
5070
5071 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
5072 /// global variable that has already been created for it. If the initializer
5073 /// has a different type than GV does, this may free GV and return a different
5074 /// one. Otherwise it just returns GV.
5075 llvm::GlobalVariable *AddInitializerToStaticVarDecl(const VarDecl &D,
5076 llvm::GlobalVariable *GV);
5077
5078 // Emit an @llvm.invariant.start call for the given memory region.
5079 void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
5080
5081 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
5082 /// variable with global storage.
5083 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV,
5084 bool PerformInit);
5085
5086 llvm::Constant *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
5087 llvm::Constant *Addr);
5088
5089 llvm::Function *createTLSAtExitStub(const VarDecl &VD,
5090 llvm::FunctionCallee Dtor,
5091 llvm::Constant *Addr,
5092 llvm::FunctionCallee &AtExit);
5093
5094 /// Call atexit() with a function that passes the given argument to
5095 /// the given function.
5096 void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
5097 llvm::Constant *addr);
5098
5099 /// Registers the dtor using 'llvm.global_dtors' for platforms that do not
5100 /// support an 'atexit()' function.
5101 void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn,
5102 llvm::Constant *addr);
5103
5104 /// Call atexit() with function dtorStub.
5105 void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
5106
5107 /// Call unatexit() with function dtorStub.
5108 llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub);
5109
5110 /// Emit code in this function to perform a guarded variable
5111 /// initialization. Guarded initializations are used when it's not
5112 /// possible to prove that an initialization will be done exactly
5113 /// once, e.g. with a static local variable or a static data member
5114 /// of a class template.
5115 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
5116 bool PerformInit);
5117
5119
5120 /// Emit a branch to select whether or not to perform guarded initialization.
5121 void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
5122 llvm::BasicBlock *InitBlock,
5123 llvm::BasicBlock *NoInitBlock, GuardKind Kind,
5124 const VarDecl *D);
5125
5126 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
5127 /// variables.
5128 void
5129 GenerateCXXGlobalInitFunc(llvm::Function *Fn,
5130 ArrayRef<llvm::Function *> CXXThreadLocals,
5132
5133 /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
5134 /// variables.
5136 llvm::Function *Fn,
5137 ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
5138 llvm::Constant *>>
5139 DtorsOrStermFinalizers);
5140
5141 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D,
5142 llvm::GlobalVariable *Addr,
5143 bool PerformInit);
5144
5146
5147 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
5148
5149 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
5150
5152
5153 void EmitFakeUse(Address Addr);
5154
5155 //===--------------------------------------------------------------------===//
5156 // Annotations Emission
5157 //===--------------------------------------------------------------------===//
5158
5159 /// Emit an annotation call (intrinsic).
5160 llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
5161 llvm::Value *AnnotatedVal,
5162 StringRef AnnotationStr,
5163 SourceLocation Location,
5164 const AnnotateAttr *Attr);
5165
5166 /// Emit local annotations for the local variable V, declared by D.
5167 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
5168
5169 /// Emit field annotations for the given field & value. Returns the
5170 /// annotation result.
5172
5173 //===--------------------------------------------------------------------===//
5174 // Internal Helpers
5175 //===--------------------------------------------------------------------===//
5176
5177 /// ContainsLabel - Return true if the statement contains a label in it. If
5178 /// this statement is not executed normally, it not containing a label means
5179 /// that we can just remove the code.
5180 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
5181
5182 /// containsBreak - Return true if the statement contains a break out of it.
5183 /// If the statement (recursively) contains a switch or loop with a break
5184 /// inside of it, this is fine.
5185 static bool containsBreak(const Stmt *S);
5186
5187 /// Determine if the given statement might introduce a declaration into the
5188 /// current scope, by being a (possibly-labelled) DeclStmt.
5189 static bool mightAddDeclToScope(const Stmt *S);
5190
5191 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5192 /// to a constant, or if it does but contains a label, return false. If it
5193 /// constant folds return true and set the boolean result in Result.
5194 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result,
5195 bool AllowLabels = false);
5196
5197 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5198 /// to a constant, or if it does but contains a label, return false. If it
5199 /// constant folds return true and set the folded value.
5200 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result,
5201 bool AllowLabels = false);
5202
5203 /// Ignore parentheses and logical-NOT to track conditions consistently.
5204 static const Expr *stripCond(const Expr *C);
5205
5206 /// isInstrumentedCondition - Determine whether the given condition is an
5207 /// instrumentable condition (i.e. no "&&" or "||").
5208 static bool isInstrumentedCondition(const Expr *C);
5209
5210 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
5211 /// increments a profile counter based on the semantics of the given logical
5212 /// operator opcode. This is used to instrument branch condition coverage
5213 /// for logical operators.
5215 llvm::BasicBlock *TrueBlock,
5216 llvm::BasicBlock *FalseBlock,
5217 uint64_t TrueCount = 0,
5219 const Expr *CntrIdx = nullptr);
5220
5221 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
5222 /// if statement) to the specified blocks. Based on the condition, this might
5223 /// try to simplify the codegen of the conditional based on the branch.
5224 /// TrueCount should be the number of times we expect the condition to
5225 /// evaluate to true based on PGO data.
5226 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
5227 llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
5229 const Expr *ConditionalOp = nullptr,
5230 const VarDecl *ConditionalDecl = nullptr);
5231
5232 /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
5233 /// nonnull, if \p LHS is marked _Nonnull.
5234 void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
5235
5236 /// An enumeration which makes it easier to specify whether or not an
5237 /// operation is a subtraction.
5238 enum { NotSubtraction = false, IsSubtraction = true };
5239
5240 /// Emit pointer + index arithmetic.
5241 llvm::Value *EmitPointerArithmetic(const BinaryOperator *BO,
5242 Expr *pointerOperand, llvm::Value *pointer,
5243 Expr *indexOperand, llvm::Value *index,
5244 bool isSubtraction);
5245
5246 /// Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to
5247 /// detect undefined behavior when the pointer overflow sanitizer is enabled.
5248 /// \p SignedIndices indicates whether any of the GEP indices are signed.
5249 /// \p IsSubtraction indicates whether the expression used to form the GEP
5250 /// is a subtraction.
5251 llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr,
5253 bool SignedIndices, bool IsSubtraction,
5254 SourceLocation Loc,
5255 const Twine &Name = "");
5256
5258 llvm::Type *elementType, bool SignedIndices,
5259 bool IsSubtraction, SourceLocation Loc,
5260 CharUnits Align, const Twine &Name = "");
5261
5262 /// Specifies which type of sanitizer check to apply when handling a
5263 /// particular builtin.
5269
5270 /// Emits an argument for a call to a builtin. If the builtin sanitizer is
5271 /// enabled, a runtime check specified by \p Kind is also emitted.
5272 llvm::Value *EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind);
5273
5274 /// Emits an argument for a call to a `__builtin_assume`. If the builtin
5275 /// sanitizer is enabled, a runtime check is also emitted.
5276 llvm::Value *EmitCheckedArgForAssume(const Expr *E);
5277
5278 /// Emit a description of a type in a format suitable for passing to
5279 /// a runtime sanitizer handler.
5280 llvm::Constant *EmitCheckTypeDescriptor(QualType T);
5281
5282 /// Convert a value into a format suitable for passing to a runtime
5283 /// sanitizer handler.
5284 llvm::Value *EmitCheckValue(llvm::Value *V);
5285
5286 /// Emit a description of a source location in a format suitable for
5287 /// passing to a runtime sanitizer handler.
5288 llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc);
5289
5290 void EmitKCFIOperandBundle(const CGCallee &Callee,
5292
5293 /// Create a basic block that will either trap or call a handler function in
5294 /// the UBSan runtime with the provided arguments, and create a conditional
5295 /// branch to it.
5296 void
5297 EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerKind::SanitizerOrdinal>>
5298 Checked,
5300 ArrayRef<llvm::Value *> DynamicArgs,
5301 const TrapReason *TR = nullptr);
5302
5303 /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath
5304 /// if Cond if false.
5306 llvm::Value *Cond, llvm::ConstantInt *TypeId,
5307 llvm::Value *Ptr,
5308 ArrayRef<llvm::Constant *> StaticArgs);
5309
5310 /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime
5311 /// checking is enabled. Otherwise, just emit an unreachable instruction.
5313
5314 /// Create a basic block that will call the trap intrinsic, and emit a
5315 /// conditional branch to it, for the -ftrapv checks.
5316 void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID,
5317 bool NoMerge = false, const TrapReason *TR = nullptr);
5318
5319 /// Emit a call to trap or debugtrap and attach function attribute
5320 /// "trap-func-name" if specified.
5321 llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID);
5322
5323 /// Emit a stub for the cross-DSO CFI check function.
5324 void EmitCfiCheckStub();
5325
5326 /// Emit a cross-DSO CFI failure handling function.
5327 void EmitCfiCheckFail();
5328
5329 /// Create a check for a function parameter that may potentially be
5330 /// declared as non-null.
5331 void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc,
5332 AbstractCallee AC, unsigned ParmNum);
5333
5335 SourceLocation ArgLoc, AbstractCallee AC,
5336 unsigned ParmNum);
5337
5338 /// EmitWriteback - Emit callbacks for function.
5339 void EmitWritebacks(const CallArgList &Args);
5340
5341 /// EmitCallArg - Emit a single call argument.
5342 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
5343
5344 /// EmitDelegateCallArg - We are performing a delegate call; that
5345 /// is, the current function is delegating to another one. Produce
5346 /// a r-value suitable for passing the given parameter.
5347 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param,
5348 SourceLocation loc);
5349
5350 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
5351 /// point operation, expressed as the maximum relative error in ulp.
5352 void SetFPAccuracy(llvm::Value *Val, float Accuracy);
5353
5354 /// Set the minimum required accuracy of the given sqrt operation
5355 /// based on CodeGenOpts.
5356 void SetSqrtFPAccuracy(llvm::Value *Val);
5357
5358 /// Set the minimum required accuracy of the given sqrt operation based on
5359 /// CodeGenOpts.
5360 void SetDivFPAccuracy(llvm::Value *Val);
5361
5362 /// Set the codegen fast-math flags.
5363 void SetFastMathFlags(FPOptions FPFeatures);
5364
5365 // Truncate or extend a boolean vector to the requested number of elements.
5366 llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec,
5367 unsigned NumElementsDst,
5368 const llvm::Twine &Name = "");
5369
5370 void maybeAttachRangeForLoad(llvm::LoadInst *Load, QualType Ty,
5371 SourceLocation Loc);
5372
5373private:
5374 // Emits a convergence_loop instruction for the given |BB|, with |ParentToken|
5375 // as it's parent convergence instr.
5376 llvm::ConvergenceControlInst *emitConvergenceLoopToken(llvm::BasicBlock *BB);
5377
5378 // Adds a convergence_ctrl token with |ParentToken| as parent convergence
5379 // instr to the call |Input|.
5380 llvm::CallBase *addConvergenceControlToken(llvm::CallBase *Input);
5381
5382 // Find the convergence_entry instruction |F|, or emits ones if none exists.
5383 // Returns the convergence instruction.
5384 llvm::ConvergenceControlInst *
5385 getOrEmitConvergenceEntryToken(llvm::Function *F);
5386
5387private:
5388 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
5389 void EmitReturnOfRValue(RValue RV, QualType Ty);
5390
5391 void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
5392
5394 DeferredReplacements;
5395
5396 /// Set the address of a local variable.
5397 void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
5398 assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
5399 LocalDeclMap.insert({VD, Addr});
5400 }
5401
5402 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
5403 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
5404 ///
5405 /// \param AI - The first function argument of the expansion.
5406 void ExpandTypeFromArgs(QualType Ty, LValue Dst,
5407 llvm::Function::arg_iterator &AI);
5408
5409 /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg
5410 /// Ty, into individual arguments on the provided vector \arg IRCallArgs,
5411 /// starting at index \arg IRCallArgPos. See ABIArgInfo::Expand.
5412 void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
5413 SmallVectorImpl<llvm::Value *> &IRCallArgs,
5414 unsigned &IRCallArgPos);
5415
5416 std::pair<llvm::Value *, llvm::Type *>
5417 EmitAsmInput(const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr,
5418 std::string &ConstraintStr);
5419
5420 std::pair<llvm::Value *, llvm::Type *>
5421 EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue,
5422 QualType InputType, std::string &ConstraintStr,
5423 SourceLocation Loc);
5424
5425 /// Attempts to statically evaluate the object size of E. If that
5426 /// fails, emits code to figure the size of E out for us. This is
5427 /// pass_object_size aware.
5428 ///
5429 /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
5430 llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
5431 llvm::IntegerType *ResType,
5432 llvm::Value *EmittedE,
5433 bool IsDynamic);
5434
5435 /// Emits the size of E, as required by __builtin_object_size. This
5436 /// function is aware of pass_object_size parameters, and will act accordingly
5437 /// if E is a parameter with the pass_object_size attribute.
5438 llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
5439 llvm::IntegerType *ResType,
5440 llvm::Value *EmittedE, bool IsDynamic);
5441
5442 llvm::Value *emitCountedBySize(const Expr *E, llvm::Value *EmittedE,
5443 unsigned Type, llvm::IntegerType *ResType);
5444
5445 llvm::Value *emitCountedByMemberSize(const MemberExpr *E, const Expr *Idx,
5446 llvm::Value *EmittedE,
5447 QualType CastedArrayElementTy,
5448 unsigned Type,
5449 llvm::IntegerType *ResType);
5450
5451 llvm::Value *emitCountedByPointerSize(const ImplicitCastExpr *E,
5452 const Expr *Idx, llvm::Value *EmittedE,
5453 QualType CastedArrayElementTy,
5454 unsigned Type,
5455 llvm::IntegerType *ResType);
5456
5457 void emitZeroOrPatternForAutoVarInit(QualType type, const VarDecl &D,
5458 Address Loc);
5459
5460public:
5461 enum class EvaluationOrder {
5462 ///! No language constraints on evaluation order.
5464 ///! Language semantics require left-to-right evaluation.
5466 ///! Language semantics require right-to-left evaluation.
5468 };
5469
5470 // Wrapper for function prototype sources. Wraps either a FunctionProtoType or
5471 // an ObjCMethodDecl.
5473 llvm::PointerUnion<const FunctionProtoType *, const ObjCMethodDecl *> P;
5474
5477 };
5478
5479 void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype,
5480 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
5481 AbstractCallee AC = AbstractCallee(),
5482 unsigned ParamsToSkip = 0,
5484
5485 /// EmitPointerWithAlignment - Given an expression with a pointer type,
5486 /// emit the value and compute our best estimate of the alignment of the
5487 /// pointee.
5488 ///
5489 /// \param BaseInfo - If non-null, this will be initialized with
5490 /// information about the source of the alignment and the may-alias
5491 /// attribute. Note that this function will conservatively fall back on
5492 /// the type when it doesn't recognize the expression and may-alias will
5493 /// be set to false.
5494 ///
5495 /// One reasonable way to use this information is when there's a language
5496 /// guarantee that the pointer must be aligned to some stricter value, and
5497 /// we're simply trying to ensure that sufficiently obvious uses of under-
5498 /// aligned objects don't get miscompiled; for example, a placement new
5499 /// into the address of a local variable. In such a case, it's quite
5500 /// reasonable to just ignore the returned alignment when it isn't from an
5501 /// explicit source.
5502 Address
5503 EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo = nullptr,
5504 TBAAAccessInfo *TBAAInfo = nullptr,
5505 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
5506
5507 /// If \p E references a parameter with pass_object_size info or a constant
5508 /// array size modifier, emit the object size divided by the size of \p EltTy.
5509 /// Otherwise return null.
5510 llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy);
5511
5512 void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK);
5513
5515 llvm::Function *Function;
5517 std::optional<StringRef> Architecture;
5518
5519 FMVResolverOption(llvm::Function *F, ArrayRef<StringRef> Feats,
5520 std::optional<StringRef> Arch = std::nullopt)
5521 : Function(F), Features(Feats), Architecture(Arch) {}
5522 };
5523
5524 // Emits the body of a multiversion function's resolver. Assumes that the
5525 // options are already sorted in the proper order, with the 'default' option
5526 // last (if it exists).
5527 void EmitMultiVersionResolver(llvm::Function *Resolver,
5529 void EmitX86MultiVersionResolver(llvm::Function *Resolver,
5531 void EmitAArch64MultiVersionResolver(llvm::Function *Resolver,
5533 void EmitRISCVMultiVersionResolver(llvm::Function *Resolver,
5535
5536private:
5537 QualType getVarArgType(const Expr *Arg);
5538
5539 void EmitDeclMetadata();
5540
5541 BlockByrefHelpers *buildByrefHelpers(llvm::StructType &byrefType,
5542 const AutoVarEmission &emission);
5543
5544 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
5545
5546 llvm::Value *GetValueForARMHint(unsigned BuiltinID);
5547 llvm::Value *EmitX86CpuIs(const CallExpr *E);
5548 llvm::Value *EmitX86CpuIs(StringRef CPUStr);
5549 llvm::Value *EmitX86CpuSupports(const CallExpr *E);
5550 llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs);
5551 llvm::Value *EmitX86CpuSupports(std::array<uint32_t, 4> FeatureMask);
5552 llvm::Value *EmitX86CpuInit();
5553 llvm::Value *FormX86ResolverCondition(const FMVResolverOption &RO);
5554 llvm::Value *EmitAArch64CpuInit();
5555 llvm::Value *FormAArch64ResolverCondition(const FMVResolverOption &RO);
5556 llvm::Value *EmitAArch64CpuSupports(const CallExpr *E);
5557 llvm::Value *EmitAArch64CpuSupports(ArrayRef<StringRef> FeatureStrs);
5558};
5559
5562 if (!needsSaving(value))
5563 return saved_type(value, false);
5564
5565 // Otherwise, we need an alloca.
5566 auto align = CharUnits::fromQuantity(
5567 CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
5568 Address alloca =
5569 CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
5570 CGF.Builder.CreateStore(value, alloca);
5571
5572 return saved_type(alloca.emitRawPointer(CGF), true);
5573}
5574
5576 saved_type value) {
5577 // If the value says it wasn't saved, trust that it's still dominating.
5578 if (!value.getInt())
5579 return value.getPointer();
5580
5581 // Otherwise, it should be an alloca instruction, as set up in save().
5582 auto alloca = cast<llvm::AllocaInst>(value.getPointer());
5583 return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca,
5584 alloca->getAlign());
5585}
5586
5587} // end namespace CodeGen
5588
5589// Map the LangOption for floating point exception behavior into
5590// the corresponding enum in the IR.
5591llvm::fp::ExceptionBehavior
5593} // end namespace clang
5594
5595#endif
Enums/classes describing ABI related information about constructors, destructors and thunks.
#define V(N, I)
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition CFG.cpp:2777
static T * buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, T &&generator)
Lazily build the copy and dispose helpers for a __block variable with the given information.
static bool isInAllocaArgument(CGCXXABI &ABI, QualType type)
Definition CGCall.cpp:4263
@ ForDeactivation
CodeGenFunction::ComplexPairTy ComplexPairTy
Defines the clang::Expr interface and subclasses for C++ expressions.
FormatToken * Previous
The previous token in the unwrapped line.
#define X(type, name)
Definition Value.h:97
llvm::MachO::Target Target
Definition MachO.h:51
Defines some OpenMP-specific enums and functions.
SanitizerHandler
This file defines OpenACC AST classes for statement-level contructs.
This file defines OpenMP AST classes for executable directives and clauses.
This file defines SYCL AST classes used to represent calls to SYCL kernels.
C Language Family Type Representation.
This represents 'pragma omp cancel' directive.
This represents 'pragma omp cancellation point' directive.
This represents 'pragma omp distribute' directive.
This represents 'pragma omp distribute parallel for' composite directive.
This represents 'pragma omp distribute parallel for simd' composite directive.
This represents 'pragma omp distribute simd' composite directive.
This represents 'pragma omp error' directive.
Represents the 'pragma omp fuse' loop transformation directive.
This represents 'pragma omp loop' directive.
Represents the 'pragma omp interchange' loop transformation directive.
This represents 'pragma omp interop' directive.
This represents 'pragma omp masked' directive.
This represents 'pragma omp masked taskloop' directive.
This represents 'pragma omp masked taskloop simd' directive.
This represents 'pragma omp master taskloop' directive.
This represents 'pragma omp master taskloop simd' directive.
This represents 'pragma omp metadirective' directive.
This represents 'pragma omp parallel masked taskloop' directive.
This represents 'pragma omp parallel masked taskloop simd' directive.
This represents 'pragma omp parallel master taskloop' directive.
This represents 'pragma omp parallel master taskloop simd' directive.
Represents the 'pragma omp reverse' loop transformation directive.
This represents 'pragma omp scan' directive.
This represents the 'pragma omp stripe' loop transformation directive.
This represents 'pragma omp target data' directive.
This represents 'pragma omp target' directive.
This represents 'pragma omp target enter data' directive.
This represents 'pragma omp target exit data' directive.
This represents 'pragma omp target parallel' directive.
This represents 'pragma omp target parallel for' directive.
This represents 'pragma omp target parallel for simd' directive.
This represents 'pragma omp target parallel loop' directive.
This represents 'pragma omp target simd' directive.
This represents 'pragma omp target teams' directive.
This represents 'pragma omp target teams distribute' combined directive.
This represents 'pragma omp target teams distribute parallel for' combined directive.
This represents 'pragma omp target teams distribute parallel for simd' combined directive.
This represents 'pragma omp target teams distribute simd' combined directive.
This represents 'pragma omp target teams loop' directive.
This represents 'pragma omp target update' directive.
This represents 'pragma omp taskloop' directive.
This represents 'pragma omp taskloop simd' directive.
This represents 'pragma omp teams' directive.
This represents 'pragma omp teams distribute' directive.
This represents 'pragma omp teams distribute parallel for' composite directive.
This represents 'pragma omp teams distribute parallel for simd' composite directive.
This represents 'pragma omp teams distribute simd' combined directive.
This represents 'pragma omp teams loop' directive.
This represents the 'pragma omp tile' loop transformation directive.
This represents the 'pragma omp unroll' loop transformation directive.
const Stmt * getAssociatedStmt() const
Stmt * getStructuredBlock()
This class represents a 'loop' construct. The 'loop' construct applies to a 'for' loop (or range-for ...
a trap message and trap category.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition Expr.h:4287
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
Definition Expr.h:7105
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition Expr.h:2721
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition TypeBase.h:3722
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition Expr.h:6814
Attr - This represents one attribute.
Definition Attr.h:44
Represents an attribute applied to a statement.
Definition Stmt.h:2203
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition Expr.h:4387
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition Expr.h:4425
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition Expr.h:4422
A builtin binary operation expression such as "x + y" or "x <= y".
Definition Expr.h:3972
static bool isLogicalOp(Opcode Opc)
Definition Expr.h:4105
BinaryOperatorKind Opcode
Definition Expr.h:3977
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition Expr.h:6558
Represents a call to a CUDA kernel function.
Definition ExprCXX.h:234
Represents binding an expression to a temporary.
Definition ExprCXX.h:1494
Represents a call to a C++ constructor.
Definition ExprCXX.h:1549
Represents a C++ constructor within a class.
Definition DeclCXX.h:2604
A default argument (C++ [dcl.fct.default]).
Definition ExprCXX.h:1271
A use of a default initializer in a constructor or in aggregate initialization.
Definition ExprCXX.h:1378
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition ExprCXX.h:2628
Represents a C++ destructor within a class.
Definition DeclCXX.h:2869
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition ExprCXX.h:481
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition StmtCXX.h:135
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition ExprCXX.h:1753
Represents a call to a member function that may be written either with member call syntax (e....
Definition ExprCXX.h:179
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:2129
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition ExprCXX.h:2357
A call to an overloaded operator written using operator syntax.
Definition ExprCXX.h:84
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition ExprCXX.h:2747
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
Represents a C++ temporary.
Definition ExprCXX.h:1460
A C++ throw-expression (C++ [except.throw]).
Definition ExprCXX.h:1209
CXXTryStmt - A C++ try block, including all handlers.
Definition StmtCXX.h:69
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition ExprCXX.h:848
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition ExprCXX.h:1069
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2877
This captures a statement into a function.
Definition Stmt.h:3886
const Capture * const_capture_iterator
Definition Stmt.h:4020
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of captures.
Definition Stmt.h:4037
const RecordDecl * getCapturedRecordDecl() const
Retrieve the record declaration for captured variables.
Definition Stmt.h:4007
capture_iterator capture_begin()
Retrieve an iterator pointing to the first capture.
Definition Stmt.h:4032
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition Expr.h:3610
const CXXBaseSpecifier *const * path_const_iterator
Definition Expr.h:3677
CharUnits - This is an opaque type for sizes expressed in character units.
Definition CharUnits.h:38
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition CharUnits.h:122
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition CharUnits.h:189
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition CharUnits.h:63
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition CharUnits.h:53
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
Definition Address.h:128
llvm::Value * getBasePointer() const
Definition Address.h:198
static Address invalid()
Definition Address.h:176
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
Definition Address.h:253
CharUnits getAlignment() const
Definition Address.h:194
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition Address.h:209
void setAlignment(CharUnits Value)
Definition Address.h:196
llvm::Value * getOffset() const
Definition Address.h:246
void replaceBasePointer(llvm::Value *P)
This function is used in situations where the caller is doing some sort of opaque "laundering" of the...
Definition Address.h:186
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition Address.h:204
An aggregate value slot.
Definition CGValue.h:504
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.
Definition CGValue.h:572
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
Definition CGValue.h:587
A scoped helper to set the current source atom group for CGDebugInfo::addInstToCurrentSourceAtom.
A pair of helper functions for a __block variable.
Information about the layout of a __block variable.
Definition CGBlocks.h:136
CGBlockInfo - Information to generate a block literal.
Definition CGBlocks.h:157
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition CGBuilder.h:140
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition CGBuilder.h:132
Implements C++ ABI-specific code generation functions.
Definition CGCXXABI.h:43
All available information about a concrete callee.
Definition CGCall.h:63
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition CGDebugInfo.h:59
CGFunctionInfo - Class to encapsulate the information about a function definition.
CallArgList - Type for representing both the value and type of arguments in a call.
Definition CGCall.h:274
const ParmVarDecl * getParamDecl(unsigned I) const
ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
Address getAllocatedAddress() const
Returns the raw, allocated address, which is not necessarily the address of the object itself.
RawAddress getOriginalAllocatedAddress() const
Returns the address for the original alloca instruction.
Address getObjectAddress(CodeGenFunction &CGF) const
Returns the address of the object within this declaration.
CGAtomicOptionsRAII(CodeGenModule &CGM_, AtomicOptions AO)
CGAtomicOptionsRAII(CodeGenModule &CGM_, const AtomicAttr *AA)
CGAtomicOptionsRAII(const CGAtomicOptionsRAII &)=delete
CGAtomicOptionsRAII & operator=(const CGAtomicOptionsRAII &)=delete
API for captured statement code generation.
static bool classof(const CGCapturedStmtInfo *)
llvm::SmallDenseMap< const VarDecl *, FieldDecl * > getCaptureFields()
Get the CaptureFields.
CGCapturedStmtInfo(CapturedRegionKind K=CR_Default)
virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S)
Emit the captured statement body.
virtual StringRef getHelperName() const
Get the name of the capture helper.
CGCapturedStmtInfo(const CapturedStmt &S, CapturedRegionKind K=CR_Default)
virtual const FieldDecl * lookup(const VarDecl *VD) const
Lookup the captured field decl for a variable.
CGCapturedStmtRAII(CodeGenFunction &CGF, CGCapturedStmtInfo *NewCapturedStmtInfo)
CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures)
CXXDefaultInitExprScope(CodeGenFunction &CGF, const CXXDefaultInitExpr *E)
void Emit(CodeGenFunction &CGF, Flags flags) override
An object to manage conditionally-evaluated expressions.
llvm::BasicBlock * getStartingBlock() const
Returns a block which will be executed prior to each evaluation of the conditional code.
static ConstantEmission forValue(llvm::Constant *C)
static ConstantEmission forReference(llvm::Constant *C)
LValue getReferenceLValue(CodeGenFunction &CGF, const Expr *RefExpr) const
void Emit(CodeGenFunction &CGF, Flags flags) override
FieldConstructionScope(CodeGenFunction &CGF, Address This)
A class controlling the emission of a finally block.
void enter(CodeGenFunction &CGF, const Stmt *Finally, llvm::FunctionCallee beginCatchFn, llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn)
Enters a finally block for an implementation using zero-cost exceptions.
void rescopeLabels()
Change the cleanup scope of the labels in this lexical scope to match the scope of the enclosing cont...
Definition CGStmt.cpp:757
~LexicalScope()
Exit this cleanup scope, emitting any accumulated cleanups.
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
InlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, llvm::BasicBlock &FiniBB)
OutlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, llvm::BasicBlock &RetBB)
OMPCancelStackRAII(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel)
The class used to assign some variables some temporarily addresses.
bool apply(CodeGenFunction &CGF)
Applies new addresses to the list of the variables.
void restore(CodeGenFunction &CGF)
Restores original addresses of the variables.
bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD, Address TempAddr)
Sets the address of the variable LocalVD to be TempAddr in function CGF.
The scope used to remap some variables as private in the OpenMP loop body (or other captured region e...
void restoreMap()
Restore all mapped variables w/o clean up.
bool Privatize()
Privatizes local variables previously registered as private.
bool isGlobalVarCaptured(const VarDecl *VD) const
Checks if the global variable is captured in current function.
OMPPrivateScope(CodeGenFunction &CGF)
Enter a new OpenMP private scope.
~OMPPrivateScope()
Exit scope - all the mapped variables are restored.
bool addPrivate(const VarDecl *LocalVD, Address Addr)
Registers LocalVD variable as a private with Addr as the address of the corresponding private variabl...
A non-RAII class containing all the information about a bound opaque value.
static OpaqueValueMappingData bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const LValue &lv)
static OpaqueValueMappingData bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const RValue &rv)
static OpaqueValueMappingData bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const Expr *e)
OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *OV)
Build the opaque value mapping for an OpaqueValueExpr whose source expression is set to the expressio...
OpaqueValueMapping(CodeGenFunction &CGF, const AbstractConditionalOperator *op)
Build the opaque value mapping for the given conditional operator if it's the GNU ?
OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *opaqueValue, RValue rvalue)
OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *opaqueValue, LValue lvalue)
static ParamValue forIndirect(Address addr)
static ParamValue forDirect(llvm::Value *value)
ParentLoopDirectiveForScanRegion(CodeGenFunction &CGF, const OMPExecutableDirective &ParentLoopDirectiveForScan)
An object which temporarily prevents a value from being destroyed by aggressive peephole optimization...
RunCleanupsScope(CodeGenFunction &CGF)
Enter a new cleanup scope.
~RunCleanupsScope()
Exit this cleanup scope, emitting any accumulated cleanups.
void ForceCleanup(std::initializer_list< llvm::Value ** > ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile)
Create a store to.
Definition CGCall.cpp:1398
EHScopeStack::stable_iterator CurrentCleanupScopeDepth
RValue EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E)
LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E)
Definition CGExpr.cpp:4817
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
emitArrayDestroy - Destroys all the elements of the given array, beginning from last to first.
Definition CGDecl.cpp:2434
LValue EmitCoawaitLValue(const CoawaitExpr *E)
llvm::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass, VTableAuthMode AuthMode=VTableAuthMode::Authenticate)
GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.
Definition CGClass.cpp:2752
void EmitOMPParallelMaskedTaskLoopDirective(const OMPParallelMaskedTaskLoopDirective &S)
RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E)
llvm::Value * EmitSVEPredicateCast(llvm::Value *Pred, llvm::ScalableVectorType *VTy)
Definition ARM.cpp:3877
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
Definition CGObjC.cpp:2152
llvm::Value * EmitFP8NeonFMLACall(unsigned IID, bool ExtendLaneArg, llvm::Type *RetTy, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
Definition ARM.cpp:474
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
void EmitRISCVMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
void EmitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &S)
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)
LValue EmitLoadOfReferenceLValue(LValue RefLVal)
Definition CGExpr.cpp:3071
void EmitCXXTryStmt(const CXXTryStmt &S)
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr, const VarDecl *ConditionalDecl=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
void setCurrentProfileCount(uint64_t Count)
Set the profiler's current count.
llvm::Constant * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)
Create a stub function, suitable for being passed to atexit, which passes the given address to the gi...
llvm::Value * EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType)
Autorelease the given object.
Definition CGObjC.cpp:2848
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
Definition CGObjC.cpp:573
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
void EmitOMPLastprivateClauseFinal(const OMPExecutableDirective &D, bool NoFinals, llvm::Value *IsLastIterCond=nullptr)
Emit final copying of lastprivate values to original variables at the end of the worksharing or simd ...
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
CurrentSourceLocExprScope CurSourceLocExprScope
Source location information about the default argument or member initializer expression we're evaluat...
void EmitARCMoveWeak(Address dst, Address src)
void @objc_moveWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition CGObjC.cpp:2692
llvm::BasicBlock * getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope)
void EmitAArch64MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, const FunctionArgList &Args)
Definition CGClass.cpp:2548
void processInReduction(const OMPExecutableDirective &S, OMPTaskDataTy &Data, CodeGenFunction &CGF, const CapturedStmt *CS, OMPPrivateScope &Scope)
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition CGObjC.cpp:2599
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
emitDestroy - Immediately perform the destruction of the given object.
Definition CGDecl.cpp:2394
LValue EmitCXXConstructLValue(const CXXConstructExpr *E)
Definition CGExpr.cpp:6321
void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, llvm::FunctionCallee Callee)
Emit a musttail call for a thunk with a potentially adjusted this pointer.
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)
Determine whether a field initialization may overlap some other object.
RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID)
bool isBinaryLogicalOp(const Expr *E) const
llvm::Value * BuildVector(ArrayRef< llvm::Value * > Ops)
Definition ARM.cpp:8071
void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, CXXCtorType CtorType, const FunctionArgList &Args, SourceLocation Loc)
Definition CGClass.cpp:2489
void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
ActivateCleanupBlock - Activates an initially-inactive cleanup.
void emitByrefStructureInit(const AutoVarEmission &emission)
Initialize the structural components of a __block variable, i.e.
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E)
Definition CGExpr.cpp:5635
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
Definition CGObjC.cpp:3089
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
Definition CGObjC.cpp:3679
void EmitOMPTaskLoopBasedDirective(const OMPLoopDirective &S)
ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
Definition CGExpr.cpp:1313
void SetDivFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
Definition CGExpr.cpp:6730
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
EmitARCUnsafeUnretainedScalarExpr - Semantically equivalent to immediately releasing the resut of Emi...
Definition CGObjC.cpp:3618
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
Emit a selector.
Definition CGObjC.cpp:257
llvm::Value * EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx, const CallExpr *E)
Definition AMDGPU.cpp:346
void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags, bool CanThrow)
llvm::Function * createTLSAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr, llvm::FunctionCallee &AtExit)
Create a stub function, suitable for being passed to __pt_atexit_np, which passes the given address t...
SanitizerSet SanOpts
Sanitizers enabled for this function.
void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy, SourceLocation Loc)
static void EmitOMPTargetParallelDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelDirective &S)
void EmitAsanPrologueOrEpilogue(bool Prologue)
Definition CGClass.cpp:768
void callCStructMoveConstructor(LValue Dst, LValue Src)
void EmitInlinedInheritingCXXConstructorCall(const CXXConstructorDecl *Ctor, CXXCtorType CtorType, bool ForVirtualBase, bool Delegating, CallArgList &Args)
Emit a call to an inheriting constructor (that is, one that invokes a constructor inherited from a ba...
Definition CGClass.cpp:2386
void pushStackRestore(CleanupKind kind, Address SPMem)
Definition CGDecl.cpp:2322
LValue EmitInitListLValue(const InitListExpr *E)
Definition CGExpr.cpp:5519
bool isUnderlyingBasePointerConstantNull(const Expr *E)
Check whether the underlying base pointer is a constant null.
Definition CGExpr.cpp:5101
llvm::DenseMap< const VarDecl *, llvm::Value * > NRVOFlags
A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
bool IsOutlinedSEHHelper
True if the current function is an outlined SEH helper.
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
Definition CGObjC.cpp:2663
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
Definition CGExpr.cpp:183
void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S)
Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
llvm::Value * getExceptionFromSlot()
Returns the contents of the function's exception object and selector slots.
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, bool Accessed=false)
Definition CGExpr.cpp:4603
llvm::Value * EmitSVEStructLoad(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4072
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
llvm::Value * EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID, bool IsZExtReturn)
Definition ARM.cpp:4180
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
bool ShouldSkipSanitizerInstrumentation()
ShouldSkipSanitizerInstrumentation - Return true if the current function should not be instrumented w...
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
Definition CGObjC.cpp:251
void EmitCXXForRangeStmt(const CXXForRangeStmt &S, ArrayRef< const Attr * > Attrs={})
Definition CGStmt.cpp:1451
void EmitOMPGenericLoopDirective(const OMPGenericLoopDirective &S)
SmallVector< Address, 1 > SEHCodeSlotStack
A stack of exception code slots.
JumpDest getJumpDestInCurrentScope(StringRef Name=StringRef())
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
llvm::Value * EmitFP8NeonCall(unsigned IID, ArrayRef< llvm::Type * > Tys, SmallVectorImpl< llvm::Value * > &O, const CallExpr *E, const char *name)
Definition ARM.cpp:448
LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E)
Definition CGExpr.cpp:6353
llvm::Value * GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
Definition CGExpr.cpp:1187
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
void VolatilizeTryBlocks(llvm::BasicBlock *BB, llvm::SmallPtrSet< llvm::BasicBlock *, 10 > &V)
LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, AlignmentSource Source=AlignmentSource::Type)
llvm::Value * EmitRISCVCpuSupports(const CallExpr *E)
Definition RISCV.cpp:970
void EmitOMPScanDirective(const OMPScanDirective &S)
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
llvm::BasicBlock * getInvokeDestImpl()
llvm::Value * EmitRISCVCpuInit()
Definition RISCV.cpp:960
const CastExpr * CurCast
If a cast expression is being visited, this holds the current cast's expression.
static bool hasScalarEvaluationKind(QualType T)
llvm::Type * ConvertType(QualType T)
bool isCleanupPadScope() const
Returns true while emitting a cleanuppad.
llvm::Value * EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx)
void EmitOpenACCExitDataConstruct(const OpenACCExitDataConstruct &S)
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
Address EmitCXXUuidofExpr(const CXXUuidofExpr *E)
Definition CGExpr.cpp:6334
AwaitSuspendWrapperInfo CurAwaitSuspendWrapper
void EmitFakeUse(Address Addr)
Definition CGDecl.cpp:1379
llvm::function_ref< std::pair< llvm::Value *, llvm::Value * >(CodeGenFunction &, const OMPExecutableDirective &S, Address LB, Address UB)> CodeGenDispatchBoundsTy
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
LValue InitCapturedStruct(const CapturedStmt &S)
Definition CGStmt.cpp:3252
void addInstToNewSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
Add KeyInstruction and an optional Backup instruction to a new atom group (See ApplyAtomGroup for mor...
CGCapturedStmtInfo * CapturedStmtInfo
void EmitOMPDistributeDirective(const OMPDistributeDirective &S)
BuiltinCheckKind
Specifies which type of sanitizer check to apply when handling a particular builtin.
Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP)
Recovers the address of a local in a parent function.
RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)
llvm::Value * EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4039
llvm::Value * EmitObjCProtocolExpr(const ObjCProtocolExpr *E)
Definition CGObjC.cpp:265
void EmitOMPParallelForDirective(const OMPParallelForDirective &S)
llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")
Emits a call or invoke instruction to the given function, depending on the current state of the EH st...
Definition CGCall.cpp:5087
llvm::Value * EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition SystemZ.cpp:39
void pushEHDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushEHDestroy - Push the standard destructor for the given type as an EH-only cleanup.
Definition CGDecl.cpp:2268
void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)
Emits a call or invoke to the given noreturn runtime function.
Definition CGCall.cpp:5050
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition CGCall.cpp:5077
RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier Qualifier, bool IsArrow, const Expr *Base, llvm::CallBase **CallOrInvoke)
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we're intending to store to the side, but which will prob...
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
void EmitOMPMasterDirective(const OMPMasterDirective &S)
llvm::Value * EmitSEHAbnormalTermination()
void EmitOMPParallelMasterTaskLoopSimdDirective(const OMPParallelMasterTaskLoopSimdDirective &S)
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
Autorelease the given object.
Definition CGObjC.cpp:2589
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
Produce the code to do a retain.
Definition CGObjC.cpp:2328
llvm::Value * EmitPointerAuthQualify(PointerAuthQualifier Qualifier, llvm::Value *Pointer, QualType ValueType, Address StorageAddress, bool IsKnownNonNull)
void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
Definition CGClass.cpp:2876
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
Definition CGClass.cpp:3113
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
llvm::Value * EmitARCAutorelease(llvm::Value *value)
Autorelease the given object.
Definition CGObjC.cpp:2580
void EmitOMPSimdInit(const OMPLoopDirective &D)
Helpers for the OpenMP loop directives.
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
Definition CGObjC.cpp:3508
llvm::Value * EmitSMEReadWrite(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4327
llvm::Type * SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags)
SVEBuiltinMemEltTy - Returns the memory element type for this memory access builtin.
Definition ARM.cpp:3736
const OMPExecutableDirective * OMPParentLoopDirectiveForScan
Parent loop-based directive for scan directive.
llvm::Value * EmitSVEScatterStore(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:3982
void EmitOpenACCInitConstruct(const OpenACCInitConstruct &S)
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
void EmitAtomicInit(Expr *E, LValue lvalue)
void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD, CallArgList &CallArgs)
Definition CGClass.cpp:3135
void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)
EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
Definition CGObjC.cpp:2681
Address GetAddressOfBaseClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue, SourceLocation Loc)
GetAddressOfBaseClass - This function will add the necessary delta to the load of 'this' and returns ...
Definition CGClass.cpp:286
LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T)
Given a value of type T* that may not be to a complete object, construct an l-value with the natural ...
void EmitOMPFlushDirective(const OMPFlushDirective &S)
void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst)
Definition CGExpr.cpp:2800
llvm::Value * EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart)
Emits a call to an LLVM variable-argument intrinsic, either llvm.va_start or llvm....
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
static void EmitOMPTargetDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetDirective &S)
Emit device code for the target directive.
llvm::Value * EmitSVEMaskedStore(const CallExpr *, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
Definition ARM.cpp:4237
LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E)
Definition CGExpr.cpp:3537
bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition CGObjC.cpp:2867
void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S)
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
Definition CGStmt.cpp:709
void EmitCoreturnStmt(const CoreturnStmt &S)
void EmitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &S)
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushRegularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the gi...
Definition CGDecl.cpp:2594
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
SmallVector< llvm::ConvergenceControlInst *, 4 > ConvergenceTokenStack
Stack to track the controlled convergence tokens.
static void EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDirective &S)
Emit device code for the target teams directive.
llvm::Value * EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition AMDGPU.cpp:420
LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E)
Definition CGExpr.cpp:5492
bool isSEHTryScope() const
Returns true inside SEH __try blocks.
void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)
Call atexit() with a function that passes the given argument to the given function.
llvm::Value * EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType)
Definition CGObjC.cpp:2805
void unprotectFromPeepholes(PeepholeProtection protection)
void EmitOMPReductionClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope, bool ForInscan=false)
Emit initial code for reduction variables.
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
Definition CGObjC.cpp:2129
void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S)
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)
Given the address of a temporary variable, produce an r-value of its type.
Definition CGExpr.cpp:6683
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
Definition CGExpr.cpp:2721
llvm::Value * EmitAArch64SMEBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition ARM.cpp:4894
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
Definition CGDecl.cpp:1348
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Definition CGExpr.cpp:3689
void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)
Definition CGObjC.cpp:2916
LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E)
Definition CGExpr.cpp:6339
bool hasVolatileMember(QualType T)
hasVolatileMember - returns true if aggregate type has a volatile member.
void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)
Enter a cleanup to destroy a __block variable.
void EmitAutoVarInit(const AutoVarEmission &emission)
Definition CGDecl.cpp:1929
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
void SetSqrtFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
Definition CGExpr.cpp:6709
static void EmitOMPTargetTeamsDistributeDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeDirective &S)
Emit device code for the target teams distribute directive.
RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
Emit a CallExpr without considering whether it might be a subclass.
Definition CGExpr.cpp:6025
llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack
RValue EmitVAArg(VAArgExpr *VE, Address &VAListAddr, AggValueSlot Slot=AggValueSlot::ignored())
Generate code to get an argument from the passed in pointer and update it accordingly.
Definition CGCall.cpp:6296
static bool isNullPointerAllowed(TypeCheckKind TCK)
Determine whether the pointer type check TCK permits null pointers.
Definition CGExpr.cpp:723
void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator, CallArgList &CallArgs, const CGFunctionInfo *CallOpFnInfo=nullptr, llvm::Constant *CallOpFn=nullptr)
Definition CGClass.cpp:3040
void EmitReturnValueCheck(llvm::Value *RV)
Emit a test that checks if the return value RV is nonnull.
Definition CGCall.cpp:4199
llvm::Value * getAsNaturalPointerTo(Address Addr, QualType PointeeType)
bool EmitSimpleStmt(const Stmt *S, ArrayRef< const Attr * > Attrs)
EmitSimpleStmt - Try to emit a "simple" statement which does not necessarily require an insertion poi...
Definition CGStmt.cpp:508
void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, QualType IndexType, bool Accessed)
Emit a check that Base points into an array object, which we can access at index Index.
Definition CGExpr.cpp:1238
RValue emitBuiltinOSLogFormat(const CallExpr &E)
Emit IR for __builtin_os_log_format.
llvm::Value * emitPointerAuthResignCall(llvm::Value *Pointer, const CGPointerAuthInfo &CurInfo, const CGPointerAuthInfo &NewInfo)
void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
Definition CGExpr.cpp:6830
void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)
EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...
Definition CGCall.cpp:4286
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S)
void maybeUpdateMCDCTestVectorBitmap(const Expr *E)
Increment the profiler's counter for the given expression by StepV.
void addInstToCurrentSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
See CGDebugInfo::addInstToCurrentSourceAtom.
unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex)
Get the record field index as represented in debug info.
Definition CGExpr.cpp:5211
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual)
Determine whether a base class initialization may overlap some other object.
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
Definition CGObjC.cpp:247
llvm::Function * generateBuiltinOSLogHelperFunction(const analyze_os_log::OSLogBufferLayout &Layout, CharUnits BufferAlignment)
llvm::Value * EmitPromotedScalarExpr(const Expr *E, QualType PromotionType)
const LangOptions & getLangOpts() const
void addInstToSpecificSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup, uint64_t Atom)
See CGDebugInfo::addInstToSpecificSourceAtom.
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
Definition CGExpr.cpp:4060
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
Definition CGExpr.cpp:686
llvm::Value * EmitARCRetainAutorelease(QualType type, llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition CGObjC.cpp:2611
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition CGObjC.cpp:2545
llvm::Value * EmitARCRetainAutoreleasedReturnValue(llvm::Value *value)
Retain the given object which is the result of a function call.
Definition CGObjC.cpp:2463
bool isPointerKnownNonNull(const Expr *E)
void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD)
StartObjCMethod - Begin emission of an ObjCMethod.
Definition CGObjC.cpp:752
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition CGDecl.cpp:1482
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
Definition CGExpr.cpp:6660
llvm::Value * EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value)
Claim a possibly-autoreleased return value at +0.
Definition CGObjC.cpp:2475
llvm::Value * EmitObjCMRRAutoreleasePoolPush()
Produce the code to do an MRR version objc_autoreleasepool_push.
Definition CGObjC.cpp:2764
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
void EmitOpenACCShutdownConstruct(const OpenACCShutdownConstruct &S)
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
Definition CGExpr.cpp:6387
void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO, const llvm::function_ref< RValue(RValue)> &UpdateOp, bool IsVolatile)
bool InNoConvergentAttributedStmt
True if the current statement has noconvergent attribute.
static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor)
Checks whether the given constructor is a valid subject for the complete-to-base constructor delegati...
Definition CGClass.cpp:720
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
Definition CGObjC.cpp:1752
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, Address Addr, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
Definition CGClass.cpp:394
llvm::Value * EmitObjCAllocWithZone(llvm::Value *value, llvm::Type *returnType)
Allocate the given objc object.
Definition CGObjC.cpp:2798
void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E)
Definition CGExpr.cpp:5617
void GetAArch64SVEProcessedOperands(unsigned BuiltinID, const CallExpr *E, SmallVectorImpl< llvm::Value * > &Ops, SVETypeFlags TypeFlags)
Definition ARM.cpp:4464
void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for RD using llvm....
Definition CGClass.cpp:2937
llvm::Value * EmitSVEGatherLoad(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:3928
llvm::Function * GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &Info, const DeclMapTy &ldm, bool IsLambdaConversionToBlock, bool BuildGlobalBlock)
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
llvm::Function * LookupNeonLLVMIntrinsic(unsigned IntrinsicID, unsigned Modifier, llvm::Type *ArgTy, const CallExpr *E)
Definition ARM.cpp:1639
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushDestroy - Push the standard destructor for the given type as at least a normal cleanup.
Definition CGDecl.cpp:2278
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition CGDecl.cpp:787
void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc)
Given an assignment *LHS = RHS, emit a test that checks if RHS is nonnull, if LHS is marked _Nonnull.
Definition CGDecl.cpp:765
void EmitConstructorBody(FunctionArgList &Args)
EmitConstructorBody - Emits the body of the current constructor.
Definition CGClass.cpp:830
const CodeGen::CGBlockInfo * BlockInfo
void EmitKCFIOperandBundle(const CGCallee &Callee, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
llvm::Value * EmitPointerAuthUnqualify(PointerAuthQualifier Qualifier, llvm::Value *Pointer, QualType PointerType, Address StorageAddress, bool IsKnownNonNull)
void EmitAggregateCopyCtor(LValue Dest, LValue Src, AggValueSlot::Overlap_t MayOverlap)
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
Construct an address with the natural alignment of T.
void EmitOpenACCWaitConstruct(const OpenACCWaitConstruct &S)
llvm::AllocaInst * EHSelectorSlot
The selector slot.
Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Load a pointer with type PtrTy stored at address Ptr.
Definition CGExpr.cpp:3080
LValue MakeNaturalAlignPointeeRawAddrLValue(llvm::Value *V, QualType T)
Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known to be unsigned.
llvm::BasicBlock * EmitLandingPad()
Emits a landing pad for the current EH stack.
void EmitLambdaInAllocaImplFn(const CXXMethodDecl *CallOp, const CGFunctionInfo **ImplFnInfo, llvm::Function **ImplFn)
Definition CGClass.cpp:3187
llvm::Constant * GenerateCopyHelperFunction(const CGBlockInfo &blockInfo)
Generate the copy-helper function for a block closure object: static void block_copy_helper(block_t *...
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=false)
EmitCXXAggrConstructorCall - Emit a loop to call a particular constructor for each of several members...
Definition CGClass.cpp:2049
std::pair< RValue, llvm::Value * > EmitAtomicCompareExchange(LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc, llvm::AtomicOrdering Success=llvm::AtomicOrdering::SequentiallyConsistent, llvm::AtomicOrdering Failure=llvm::AtomicOrdering::SequentiallyConsistent, bool IsWeak=false, AggValueSlot Slot=AggValueSlot::ignored())
Emit a compare-and-exchange op for atomic type.
CurrentSourceLocExprScope::SourceLocExprScopeGuard SourceLocExprScopeGuard
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
Definition CGStmt.cpp:692
RValue EmitLoadOfGlobalRegLValue(LValue LV)
Load of global named registers are always calls to intrinsics.
Definition CGExpr.cpp:2550
VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass)
Definition CGClass.cpp:2672
void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull, CFITypeCheckKind TCK, SourceLocation Loc)
Derived is the presumed address of an object of type T after a cast.
Definition CGClass.cpp:2890
TypeCheckKind
Situations in which we might emit a check for the suitability of a pointer or glvalue.
@ TCK_DowncastPointer
Checking the operand of a static_cast to a derived pointer type.
@ TCK_DowncastReference
Checking the operand of a static_cast to a derived reference type.
@ TCK_MemberAccess
Checking the object expression in a non-static data member access.
@ TCK_ConstructorCall
Checking the 'this' pointer for a constructor call.
@ TCK_Store
Checking the destination of a store. Must be suitably sized and aligned.
@ TCK_NonnullAssign
Checking the value assigned to a _Nonnull pointer. Must not be null.
@ TCK_UpcastToVirtualBase
Checking the operand of a cast to a virtual base object.
@ TCK_MemberCall
Checking the 'this' pointer for a call to a non-static member function.
@ TCK_DynamicOperation
Checking the operand of a dynamic_cast or a typeid expression.
@ TCK_ReferenceBinding
Checking the bound value in a reference binding.
@ TCK_Load
Checking the operand of a load. Must be suitably sized and aligned.
@ TCK_Upcast
Checking the operand of a cast to a base object.
llvm::Type * getEltType(const SVETypeFlags &TypeFlags)
Definition ARM.cpp:3752
void SimplifyForwardingBlocks(llvm::BasicBlock *BB)
SimplifyForwardingBlocks - If the given basic block is only a branch to another basic block,...
Definition CGStmt.cpp:633
static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition CGObjC.cpp:3542
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)
Definition CGClass.cpp:2577
LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
BuildByrefInfo - This routine changes a __block variable declared as T x into:
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
void EmitOMPReductionClauseFinal(const OMPExecutableDirective &D, const OpenMPDirectiveKind ReductionKind)
Emit final update of reduction values to original variables at the end of the directive.
llvm::Value * EmitCommonNeonBuiltinExpr(unsigned BuiltinID, unsigned LLVMIntrinsic, unsigned AltLLVMIntrinsic, const char *NameHint, unsigned Modifier, const CallExpr *E, SmallVectorImpl< llvm::Value * > &Ops, Address PtrOp0, Address PtrOp1, llvm::Triple::ArchType Arch)
Definition ARM.cpp:1740
llvm::Value * EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
Definition RISCV.cpp:1073
LValue EmitBinaryOperatorLValue(const BinaryOperator *E)
Definition CGExpr.cpp:6176
bool InNoMergeAttributedStmt
True if the current statement has nomerge attribute.
llvm::Value * EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx, const llvm::ElementCount &Count)
LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushIrregularPartialArrayCleanup - Push a NormalAndEHCleanup to destroy already-constructed elements ...
Definition CGDecl.cpp:2578
llvm::Value * EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind)
Emits an argument for a call to a builtin.
void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit)
Helper for the OpenMP loop directives.
Address EmitCheckedInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *elementType, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, CharUnits Align, const Twine &Name="")
void EmitOMPScopeDirective(const OMPScopeDirective &S)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
LValue MakeAddrLValueWithoutTBAA(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
llvm::BasicBlock * getUnreachableBlock()
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition CGDecl.cpp:2251
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy)
Emit an aggregate assignment.
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition CGObjC.cpp:2481
void maybeAttachRangeForLoad(llvm::LoadInst *Load, QualType Ty, SourceLocation Loc)
Definition CGExpr.cpp:2049
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType, llvm::Value *Dst, QualType DstType, const CGBitFieldInfo &Info, SourceLocation Loc)
Emit a check that an [implicit] conversion of a bitfield.
void PushDestructorCleanup(QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object destructor of an object of the giv...
Definition CGClass.cpp:2608
llvm::SmallVector< const JumpDest *, 2 > SEHTryEpilogueStack
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
void EmitFunctionBody(const Stmt *Body)
JumpDest ReturnBlock
ReturnBlock - Unified return block.
void EmitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &S)
RValue EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method, const CGCallee &Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, CallArgList *RtlArgs, llvm::CallBase **CallOrInvoke)
Definition CGExprCXX.cpp:85
DominatingValue< T >::saved_type saveValueInCond(T value)
void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)
const llvm::function_ref< void(CodeGenFunction &, llvm::Function *, const OMPTaskDataTy &)> TaskGenTy
std::pair< LValue, llvm::Value * > EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored)
Definition CGObjC.cpp:3629
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
static bool cxxDestructorCanThrow(QualType T)
Check if T is a C++ class that has a destructor that can throw.
llvm::Value * ExceptionSlot
The exception slot.
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
Definition CGExpr.cpp:6835
ComplexPairTy EmitPromotedComplexExpr(const Expr *E, QualType PromotionType)
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
Definition CGExpr.cpp:3579
void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, llvm::Value *Index, QualType IndexType, QualType IndexedType, bool Accessed)
Definition CGExpr.cpp:1252
void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee, const ThunkInfo *Thunk, bool IsUnprototyped)
bool EmitOMPCopyinClause(const OMPExecutableDirective &D)
Emit code for copyin clause in D directive.
llvm::Value * EmitSVEDupX(llvm::Value *Scalar)
LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e)
Definition CGExpr.cpp:5874
void EmitOMPLinearClause(const OMPLoopDirective &D, CodeGenFunction::OMPPrivateScope &PrivateScope)
Emit initial code for linear clauses.
llvm::Value * LoadPassedObjectSize(const Expr *E, QualType EltTy)
If E references a parameter with pass_object_size info or a constant array size modifier,...
Definition CGExpr.cpp:965
void EmitAnyExprToExn(const Expr *E, Address Addr)
@ ForceLeftToRight
! Language semantics require left-to-right evaluation.
@ Default
! No language constraints on evaluation order.
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, llvm::Value *&Result)
llvm::BasicBlock * OMPBeforeScanBlock
void EmitOMPInterchangeDirective(const OMPInterchangeDirective &S)
void EmitOMPPrivateLoopCounters(const OMPLoopDirective &S, OMPPrivateScope &LoopScope)
Emit initial code for loop counters of loop-based directives.
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > VisitedVirtualBasesSetTy
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
Definition CGObjC.cpp:1049
llvm::Value * EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
Definition CGExpr.cpp:6379
void initFullExprCleanupWithFlag(RawAddress ActiveFlag)
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
void pushCleanupAndDeferDeactivation(CleanupKind Kind, As... A)
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum)
Create a check for a function parameter that may potentially be declared as non-null.
Definition CGCall.cpp:4576
RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})
Like EmitLoadOfLValue but also handles complex and aggregate types.
Definition CGExpr.cpp:2359
llvm::BasicBlock * getEHResumeBlock(bool isCleanup)
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
llvm::DenseMap< const Decl *, Address > DeclMapTy
LValue EmitLValueForField(LValue Base, const FieldDecl *Field, bool IsInBounds=true)
Definition CGExpr.cpp:5293
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
Definition CGExpr.cpp:176
const TargetInfo & getTarget() const
RValue emitRotate(const CallExpr *E, bool IsRotateRight)
void initFullExprCleanup()
Set up the last cleanup that was pushed as a conditional full-expression cleanup.
llvm::Value * EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition ARM.cpp:4507
llvm::Function * getSpecConstantFunction(const clang::QualType &SpecConstantType)
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
llvm::Value * EmitAnnotationCall(llvm::Function *AnnotationFn, llvm::Value *AnnotatedVal, StringRef AnnotationStr, SourceLocation Location, const AnnotateAttr *Attr)
Emit an annotation call (intrinsic).
void EmitStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition CGDecl.cpp:404
bool isInConditionalBranch() const
isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...
llvm::Value * EmitFP8NeonCvtCall(unsigned IID, llvm::Type *Ty0, llvm::Type *Ty1, bool Extract, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
Definition ARM.cpp:495
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
Definition CGStmt.cpp:581
void pushKmpcAllocFree(CleanupKind Kind, std::pair< llvm::Value *, llvm::Value * > AddrSizePair)
Definition CGDecl.cpp:2326
void GenerateOpenMPCapturedVars(const CapturedStmt &S, SmallVectorImpl< llvm::Value * > &CapturedVars)
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
Definition CGObjC.cpp:3953
Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, bool IsInBounds, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Emit the address of a field using a member data pointer.
Definition CGClass.cpp:150
void EmitGotoStmt(const GotoStmt &S)
Definition CGStmt.cpp:845
llvm::BasicBlock * getTerminateHandler()
getTerminateHandler - Return a handler (not a landing pad, just a catch handler) that just calls term...
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list< llvm::Value ** > ValuesToReload={})
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
void EmitOMPDepobjDirective(const OMPDepobjDirective &S)
void maybeCreateMCDCCondBitmap()
Allocate a temp value on the stack that MCDC can use to track condition results.
void EmitOMPMetaDirective(const OMPMetaDirective &S)
llvm::Value * EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
Definition ARM.cpp:2664
LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)
Definition CGExpr.cpp:5897
static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty)
Determine whether the pointer type check TCK requires a vptr check.
Definition CGExpr.cpp:728
CGCallee EmitCallee(const Expr *E)
Definition CGExpr.cpp:6101
void EmitWritebacks(const CallArgList &Args)
EmitWriteback - Emit callbacks for function.
Definition CGCall.cpp:4867
void EmitOMPCriticalDirective(const OMPCriticalDirective &S)
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition CGExpr.cpp:244
void EnterSEHTryStmt(const SEHTryStmt &S)
llvm::Value * EmitRISCVCpuIs(const CallExpr *E)
Definition RISCV.cpp:1032
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)
Definition CGExpr.cpp:5975
llvm::ScalableVectorType * getSVEType(const SVETypeFlags &TypeFlags)
Definition ARM.cpp:3825
void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
Definition CGExpr.cpp:2377
void EmitOMPCancelDirective(const OMPCancelDirective &S)
void pushDestroyAndDeferDeactivation(QualType::DestructionKind dtorKind, Address addr, QualType type)
Definition CGDecl.cpp:2303
LValue EmitArraySectionExpr(const ArraySectionExpr *E, bool IsLowerBound=true)
Definition CGExpr.cpp:4876
const Expr * RetExpr
If a return statement is being visited, this holds the return statment's result expression.
Address GetAddrOfBlockDecl(const VarDecl *var)
void EmitOMPBarrierDirective(const OMPBarrierDirective &S)
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type,...
static bool isInstrumentedCondition(const Expr *C)
isInstrumentedCondition - Determine whether the given condition is an instrumentable condition (i....
void EmitOMPOrderedDirective(const OMPOrderedDirective &S)
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
Destroy a __strong variable.
Definition CGObjC.cpp:2510
void pushCleanupAfterFullExpr(CleanupKind Kind, As... A)
Queue a cleanup to be pushed after finishing the current full-expression, potentially with an active ...
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
Definition CGExpr.cpp:4021
void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
llvm::Value * EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition ARM.cpp:7962
bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB, const CodeGenLoopBoundsTy &CodeGenLoopBounds, const CodeGenDispatchBoundsTy &CGDispatchBounds)
Emit code for the worksharing loop-based directive.
void EmitForStmt(const ForStmt &S, ArrayRef< const Attr * > Attrs={})
Definition CGStmt.cpp:1293
CGCallee BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD, CXXDtorType Type, const CXXRecordDecl *RD)
BuildVirtualCall - This routine makes indirect vtable call for call to virtual destructors.
Definition CGCXX.cpp:293
void pushFullExprCleanup(CleanupKind kind, As... A)
pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.
bool AlwaysEmitXRayCustomEvents() const
AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit XRay custom event handling c...
void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type)
EnterDtorCleanups - Enter the cleanups necessary to complete the given phase of destruction for a des...
Definition CGClass.cpp:1913
llvm::Value * EmitSMELdrStr(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4349
LValue EmitOMPSharedLValue(const Expr *E)
Emits the lvalue for the expression with possibly captured variable.
QualType TypeOfSelfObject()
TypeOfSelfObject - Return type of object that this self represents.
Definition CGObjC.cpp:1796
llvm::CanonicalLoopInfo * EmitOMPCollapsedCanonicalLoopNest(const Stmt *S, int Depth)
Emit the Stmt S and return its topmost canonical loop, if any.
void EmitOMPSectionsDirective(const OMPSectionsDirective &S)
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
Definition CGObjC.cpp:3688
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
void EmitOMPInteropDirective(const OMPInteropDirective &S)
void SetFPAccuracy(llvm::Value *Val, float Accuracy)
SetFPAccuracy - Set the minimum required accuracy of the given floating point operation,...
Definition CGExpr.cpp:6698
Address mergeAddressesInConditionalExpr(Address LHS, Address RHS, llvm::BasicBlock *LHSBlock, llvm::BasicBlock *RHSBlock, llvm::BasicBlock *MergeBlock, QualType MergedType)
Address emitAddrOfImagComponent(Address complex, QualType complexType)
llvm::Value * EmitPointerAuthSign(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
llvm::Value * EmitSVETupleCreate(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType, ArrayRef< llvm::Value * > Ops)
Definition ARM.cpp:4452
void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S)
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, AggValueSlot ThisAVS, const CXXConstructExpr *E)
Definition CGClass.cpp:2189
llvm::Value * EmitSVEPMull(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
Definition ARM.cpp:4135
llvm::Value * EmitObjCBoxedExpr(const ObjCBoxedExpr *E)
EmitObjCBoxedExpr - This routine generates code to call the appropriate expression boxing method.
Definition CGObjC.cpp:64
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
void EmitOMPCopy(QualType OriginalType, Address DestAddr, Address SrcAddr, const VarDecl *DestVD, const VarDecl *SrcVD, const Expr *Copy)
Emit proper copying of data from one variable to another.
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Definition CGExpr.cpp:225
void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType)
EmitCallArg - Emit a single call argument.
Definition CGCall.cpp:4872
void maybeResetMCDCCondBitmap(const Expr *E)
Zero-init the MCDC temp value.
RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
void EmitWhileStmt(const WhileStmt &S, ArrayRef< const Attr * > Attrs={})
Definition CGStmt.cpp:1078
JumpDest getOMPCancelDestination(OpenMPDirectiveKind Kind)
void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, llvm::Constant *AtomicHelperFn)
Definition CGObjC.cpp:1468
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
llvm::Value * EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition PPC.cpp:73
LValue EmitPredefinedLValue(const PredefinedExpr *E)
Definition CGExpr.cpp:3542
void EmitPointerAuthOperandBundle(const CGPointerAuthInfo &Info, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
void EmitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &S)
void EmitOMPTargetParallelGenericLoopDirective(const OMPTargetParallelGenericLoopDirective &S)
Emit combined directive 'target parallel loop' as if its constituent constructs are 'target',...
void EmitOpenACCCombinedConstruct(const OpenACCCombinedConstruct &S)
void EmitOMPUseDeviceAddrClause(const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope, const llvm::DenseMap< const ValueDecl *, llvm::Value * > CaptureDeviceAddrMap)
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs, const TrapReason *TR=nullptr)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
Definition CGExpr.cpp:3829
void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit)
Emit the code necessary to initialize the given global variable.
llvm::Value * EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty)
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
Definition CGObjC.cpp:3716
void ResolveBranchFixups(llvm::BasicBlock *Target)
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Definition CGExpr.cpp:3246
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
void EmitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &S)
SmallVector< const BinaryOperator *, 16 > MCDCLogOpStack
Stack to track the Logical Operator recursion nest for MC/DC.
LValue EmitStringLiteralLValue(const StringLiteral *E)
Definition CGExpr.cpp:3532
llvm::Value * EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
Definition ARM.cpp:3469
void EmitOMPMaskedDirective(const OMPMaskedDirective &S)
Address getAsNaturalAddressOf(Address Addr, QualType PointeeTy)
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody)
Returns true if a loop must make progress, which means the mustprogress attribute can be added.
Definition CGStmt.cpp:1015
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
Definition CGExpr.cpp:5928
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke=nullptr, bool IsMustTail=false)
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
void callCStructCopyConstructor(LValue Dst, LValue Src)
void EmitOMPAggregateAssign(Address DestAddr, Address SrcAddr, QualType OriginalType, const llvm::function_ref< void(Address, Address)> CopyGen)
Perform element by element copying of arrays with type OriginalType from SrcAddr to DestAddr using co...
Address getExceptionSlot()
Returns a pointer to the function's exception object and selector slot, which is assigned in every la...
void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D)
Emit a branch to select whether or not to perform guarded initialization.
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
void EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S)
llvm::Function * GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk)
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
bool AlwaysEmitXRayTypedEvents() const
AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit XRay typed event handling ...
void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This)
Emit assumption load for all bases.
Definition CGClass.cpp:2452
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
Retain the given block, with _Block_copy semantics.
Definition CGObjC.cpp:2349
llvm::Value * EmitObjCCollectionLiteral(const Expr *E, const ObjCMethodDecl *MethodWithObjects)
Definition CGObjC.cpp:123
llvm::BasicBlock * getTerminateFunclet()
getTerminateLandingPad - Return a cleanup funclet that just calls terminate.
void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size)
llvm::Value * EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt, llvm::Type *Ty, bool usgn, const char *name)
Definition ARM.cpp:511
llvm::BasicBlock * getTerminateLandingPad()
getTerminateLandingPad - Return a landing pad that just calls terminate.
void EmitOMPDistributeLoop(const OMPLoopDirective &S, const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr)
Emit code for the distribute loop-based directive.
llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)
llvm::Value * emitScalarConstant(const ConstantEmission &Constant, Expr *E)
Definition CGExpr.cpp:2004
void AddAMDGPUFenceAddressSpaceMMRA(llvm::Instruction *Inst, const CallExpr *E)
Definition AMDGPU.cpp:363
void EmitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &S)
llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)
EmitARCRetainScalarExpr - Semantically equivalent to EmitARCRetainObject(e->getType(),...
Definition CGObjC.cpp:3493
void EmitOMPReverseDirective(const OMPReverseDirective &S)
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
bool EmitLifetimeStart(llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
Definition CGDecl.cpp:1356
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void popCatchScope()
popCatchScope - Pops the catch scope at the top of the EHScope stack, emitting any required code (oth...
LValue EmitUnsupportedLValue(const Expr *E, const char *Name)
EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue an ErrorUnsupported style ...
Definition CGExpr.cpp:1601
void EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S)
void EmitDestructorBody(FunctionArgList &Args)
EmitDestructorBody - Emits the body of the current destructor.
Definition CGClass.cpp:1446
void EmitOpenACCDataConstruct(const OpenACCDataConstruct &S)
LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, AlignmentSource Source=AlignmentSource::Type)
Same as MakeAddrLValue above except that the pointer is known to be unsigned.
llvm::MDNode * buildAllocToken(QualType AllocType)
Build metadata used by the AllocToken instrumentation.
Definition CGExpr.cpp:1277
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
void EmitX86MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...
Definition CGExpr.cpp:5467
llvm::Value * EmitBlockLiteral(const BlockExpr *)
Emit block literal.
Definition CGBlocks.cpp:764
void EmitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &S)
llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)
EmitToMemory - Change a scalar value from its value representation to its in-memory representation.
Definition CGExpr.cpp:2190
Address GetAddressOfDirectBaseInCompleteClass(Address Value, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, bool BaseIsVirtual)
GetAddressOfBaseOfCompleteClass - Convert the given pointer to a complete class to the given direct b...
Definition CGClass.cpp:216
void EmitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective &S)
Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V, bool followForward=true)
BuildBlockByrefAddress - Computes the location of the data in a variable which is declared as __block...
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition CGExpr.cpp:153
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
Definition CGObjC.cpp:2125
SmallVector< llvm::Type *, 2 > getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType, ArrayRef< llvm::Value * > Ops)
Definition ARM.cpp:4416
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)
Arrange a function prototype that can be called by Windows exception handling personalities.
void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val)
Update the MCDC temp value with the condition's evaluated result.
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
Definition CGExpr.cpp:5914
llvm::function_ref< std::pair< LValue, LValue >(CodeGenFunction &, const OMPExecutableDirective &S)> CodeGenLoopBoundsTy
llvm::Function * generateAwaitSuspendWrapper(Twine const &CoroName, Twine const &SuspendPointName, CoroutineSuspendExpr const &S)
bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, SourceLocation Loc)
Check if the scalar Value is within the valid range for the given type Ty.
Definition CGExpr.cpp:2063
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type,...
void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue, llvm::Value *TheCheck, llvm::Instruction *Assumption)
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)
EmitCall - Generate a call of the given function, expecting the given result type,...
Definition CGCall.cpp:5233
const TargetCodeGenInfo & getTargetHooks() const
void setBeforeOutermostConditional(llvm::Value *value, Address addr, CodeGenFunction &CGF)
CGPointerAuthInfo EmitPointerAuthInfo(const PointerAuthSchema &Schema, llvm::Value *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
Emit the concrete pointer authentication informaton for the given authentication schema.
void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S)
void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, FunctionArgList &Args)
EmitCtorPrologue - This routine generates necessary code to initialize base classes and non-static da...
Definition CGClass.cpp:1266
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp)
Emit IR for __builtin_align_up/__builtin_align_down.
LValue EmitHLSLArrayAssignLValue(const BinaryOperator *E)
Definition CGExpr.cpp:6291
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
void EmitLifetimeEnd(llvm::Value *Addr)
Definition CGDecl.cpp:1368
RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
Definition CGExpr.cpp:217
void EmitBranchToCounterBlock(const Expr *Cond, BinaryOperator::Opcode LOp, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount=0, Stmt::Likelihood LH=Stmt::LH_None, const Expr *CntrIdx=nullptr)
EmitBranchToCounterBlock - Emit a conditional branch to a new block that increments a profile counter...
void EmitPointerAuthCopy(PointerAuthQualifier Qualifier, QualType Type, Address DestField, Address SrcField)
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S)
LValue EmitVAArgExprLValue(const VAArgExpr *E)
Definition CGExpr.cpp:6316
bool InNoInlineAttributedStmt
True if the current statement has noinline attribute.
SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)
Definition CGCall.cpp:5015
void EmitOMPMaskedTaskLoopSimdDirective(const OMPMaskedTaskLoopSimdDirective &S)
llvm::Value * EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
llvm::Value * EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty, bool negateForRightShift)
Definition ARM.cpp:489
void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, llvm::Value *VTable, SourceLocation Loc)
If whole-program virtual table optimization is enabled, emit an assumption that VTable is a member of...
Definition CGClass.cpp:2825
void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)
Scan the outlined statement for captures from the parent function.
llvm::Value * EmitObjCAlloc(llvm::Value *value, llvm::Type *returnType)
Allocate the given objc object.
Definition CGObjC.cpp:2789
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition CGObjC.cpp:1788
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
Definition CGObjC.cpp:807
void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)
std::pair< bool, RValue > EmitOMPAtomicSimpleUpdateExpr(LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart, llvm::AtomicOrdering AO, SourceLocation Loc, const llvm::function_ref< RValue(RValue)> CommonGen)
Emit atomic update code for constructs: X = X BO E or X = E BO E.
bool IsInPreservedAIRegion
True if CodeGen currently emits code inside presereved access index region.
RValue EmitAnyExprToTemp(const Expr *E)
EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...
Definition CGExpr.cpp:285
void EmitCoroutineBody(const CoroutineBodyStmt &S)
void pushCleanupAfterFullExprWithActiveFlag(CleanupKind Kind, RawAddress ActiveFlag, As... A)
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
LValue EmitStmtExprLValue(const StmtExpr *E)
Definition CGExpr.cpp:6419
void EmitOMPParallelDirective(const OMPParallelDirective &S)
void EmitOMPTaskDirective(const OMPTaskDirective &S)
llvm::Value * unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub)
Call unatexit() with function dtorStub.
void EmitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &S)
void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc)
llvm::Value * EmitARCLoadWeakRetained(Address addr)
i8* @objc_loadWeakRetained(i8** addr)
Definition CGObjC.cpp:2643
void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)
void EmitOMPAssumeDirective(const OMPAssumeDirective &S)
llvm::Value * emitPointerAuthResign(llvm::Value *Pointer, QualType PointerType, const CGPointerAuthInfo &CurAuthInfo, const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull)
int ExpectedOMPLoopDepth
Number of nested loop to be consumed by the last surrounding loop-associated directive.
void EmitOMPPrivateClause(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)
llvm::Value * EmitDirectXBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition DirectX.cpp:22
llvm::Value * EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, llvm::Triple::ArchType Arch)
Definition ARM.cpp:4974
void EmitStopPoint(const Stmt *S)
EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Definition CGStmt.cpp:51
RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates a alloca and inserts it into the entry block.
Definition CGExpr.cpp:105
void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S)
llvm::Value * EmitWithOriginalRHSBitfieldAssignment(const BinaryOperator *E, llvm::Value **Previous, QualType *SrcType)
Retrieve the implicit cast expression of the rhs in a binary operator expression by passing pointers ...
llvm::Value * EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E)
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
void EmitOMPTargetTeamsGenericLoopDirective(const OMPTargetTeamsGenericLoopDirective &S)
llvm::Value * EmitFP8NeonFDOTCall(unsigned IID, bool ExtendLaneArg, llvm::Type *RetTy, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
Definition ARM.cpp:458
void EmitMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
void EmitIfStmt(const IfStmt &S)
Definition CGStmt.cpp:881
void emitAutoVarTypeCleanup(const AutoVarEmission &emission, QualType::DestructionKind dtorKind)
Enter a destroy cleanup for the given local variable.
Definition CGDecl.cpp:2135
void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
Definition CGObjC.cpp:2714
llvm::Value * vectorWrapScalar16(llvm::Value *Op)
Definition ARM.cpp:3724
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition CGDecl.cpp:2202
LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E)
Definition CGExpr.cpp:6395
llvm::Value * EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
Definition ARM.cpp:3570
void EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo)
Emits the alloca and debug information for the size expressions for each dimension of an array.
Definition CGDecl.cpp:1387
static const Expr * stripCond(const Expr *C)
Ignore parentheses and logical-NOT to track conditions consistently.
void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)
EmitFunctionProlog - Emit the target specific LLVM code to load the arguments for the given function.
Definition CGCall.cpp:3098
void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)
Registers the dtor using 'llvm.global_dtors' for platforms that do not support an 'atexit()' function...
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Definition CGExpr.cpp:2574
SmallVector< llvm::CanonicalLoopInfo *, 4 > OMPLoopNestStack
List of recently emitted OMPCanonicalLoops.
Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Definition CGExpr.cpp:4269
void SetFastMathFlags(FPOptions FPFeatures)
Set the codegen fast-math flags.
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
Definition CGDecl.cpp:2331
llvm::Value * EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty, const llvm::CmpInst::Predicate Pred, const llvm::Twine &Name="")
Definition ARM.cpp:2442
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with non-trivial copy assignment...
Definition CGObjC.cpp:3733
llvm::Value * EmitSPIRVBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition SPIR.cpp:22
void EmitOpenACCAtomicConstruct(const OpenACCAtomicConstruct &S)
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
Definition CGObjC.cpp:2133
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
Definition CGStmt.cpp:569
llvm::Value * LoadCXXVTT()
LoadCXXVTT - Load the VTT parameter to base constructors/destructors have virtual bases.
RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
void EmitOpenACCCacheConstruct(const OpenACCCacheConstruct &S)
Address EmitVAListRef(const Expr *E)
void EmitOpenACCLoopConstruct(const OpenACCLoopConstruct &S)
void EmitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &S)
RValue GetUndefRValue(QualType Ty)
GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
Definition CGExpr.cpp:1569
void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo)
EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Definition CGDecl.cpp:2653
llvm::Instruction * getPostAllocaInsertPoint()
Return PostAllocaInsertPt.
RValue EmitBuiltinIsAligned(const CallExpr *E)
Emit IR for __builtin_is_aligned.
void EmitAllocToken(llvm::CallBase *CB, QualType AllocType)
Emit and set additional metadata used by the AllocToken instrumentation.
Definition CGExpr.cpp:1291
void EmitARCNoopIntrinsicUse(ArrayRef< llvm::Value * > values)
Emit a call to "clang.arc.noop.use", which consumes the result of a call that has operand bundle "cla...
Definition CGObjC.cpp:2179
llvm::AtomicRMWInst * emitAtomicRMWInst(llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val, llvm::AtomicOrdering Order=llvm::AtomicOrdering::SequentiallyConsistent, llvm::SyncScope::ID SSID=llvm::SyncScope::System, const AtomicExpr *AE=nullptr)
Emit an atomicrmw instruction, and applying relevant metadata when applicable.
LValue EmitComplexAssignmentLValue(const BinaryOperator *E)
Emit an l-value for an assignment (simple or compound) of complex type.
LValue EmitCastLValue(const CastExpr *E)
EmitCastLValue - Casts are never lvalues unless that cast is to a reference type.
Definition CGExpr.cpp:5685
void EmitOMPFuseDirective(const OMPFuseDirective &S)
llvm::Value * EmitPointerArithmetic(const BinaryOperator *BO, Expr *pointerOperand, llvm::Value *pointer, Expr *indexOperand, llvm::Value *index, bool isSubtraction)
Emit pointer + index arithmetic.
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)
Definition CGClass.cpp:682
LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
Definition CGExpr.cpp:510
LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy)
Definition CGExpr.cpp:3090
void EmitAsmStmt(const AsmStmt &S)
Definition CGStmt.cpp:2778
void EmitDefaultStmt(const DefaultStmt &S, ArrayRef< const Attr * > Attrs)
Definition CGStmt.cpp:1984
void EmitOMPTargetTeamsDistributeDirective(const OMPTargetTeamsDistributeDirective &S)
void EmitLambdaInAllocaCallOpBody(const CXXMethodDecl *MD)
Definition CGClass.cpp:3169
void EmitSwitchStmt(const SwitchStmt &S)
Definition CGStmt.cpp:2294
Address ReturnValuePointer
ReturnValuePointer - The temporary alloca to hold a pointer to sret.
void EmitOMPUseDevicePtrClause(const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope, const llvm::DenseMap< const ValueDecl *, llvm::Value * > CaptureDeviceAddrMap)
llvm::Value * SEHInfo
Value returned by __exception_info intrinsic.
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope,...
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
Definition CGExpr.cpp:3651
void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)
EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...
Definition CGExpr.cpp:295
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
Definition CGExpr.cpp:266
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E)
Definition CGExpr.cpp:5040
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})
EmitStmt - Emit the code for the statement.
Definition CGStmt.cpp:61
llvm::GlobalVariable * AddInitializerToStaticVarDecl(const VarDecl &D, llvm::GlobalVariable *GV)
AddInitializerToStaticVarDecl - Add the initializer for 'D' to the global variable that has already b...
Definition CGDecl.cpp:353
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const CallExpr *TheCallExpr, bool IsDelete)
RValue EmitUnsupportedRValue(const Expr *E, const char *Name)
EmitUnsupportedRValue - Emit a dummy r-value using the type of E and issue an ErrorUnsupported style ...
Definition CGExpr.cpp:1595
void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S)
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
CleanupKind getCleanupKind(QualType::DestructionKind kind)
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
uint64_t getCurrentProfileCount()
Get the profiler's current count.
std::pair< LValue, LValue > EmitHLSLOutArgLValues(const HLSLOutArgExpr *E, QualType Ty)
Definition CGExpr.cpp:5880
LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E)
Definition CGExpr.cpp:6367
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition CGObjC.cpp:2337
llvm::Type * ConvertTypeForMem(QualType T)
static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, const ObjCMethodDecl *GetterMothodDecl, llvm::Constant *AtomicHelperFn)
Definition CGObjC.cpp:1135
LValue EmitCallExprLValue(const CallExpr *E, llvm::CallBase **CallOrInvoke=nullptr)
Definition CGExpr.cpp:6301
llvm::Value * EmitARCRetainAutoreleaseNonBlock(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition CGObjC.cpp:2628
llvm::Value * EmitSVEMovl(const SVETypeFlags &TypeFlags, llvm::ArrayRef< llvm::Value * > Ops, unsigned BuiltinID)
Definition ARM.cpp:4153
void EmitOMPInnerLoop(const OMPExecutableDirective &S, bool RequiresCleanup, const Expr *LoopCond, const Expr *IncExpr, const llvm::function_ref< void(CodeGenFunction &)> BodyGen, const llvm::function_ref< void(CodeGenFunction &)> PostIncGen)
Emit inner loop of the worksharing/simd construct.
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)
Definition CGClass.cpp:2460
void GenerateCXXGlobalCleanUpFunc(llvm::Function *Fn, ArrayRef< std::tuple< llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant * > > DtorsOrStermFinalizers)
GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global variables.
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S)
static void EmitOMPTargetTeamsDistributeParallelForDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeParallelForDirective &S)
llvm::Value * EmitObjCAutoreleasePoolPush()
Produce the code to do a objc_autoreleasepool_push.
Definition CGObjC.cpp:2724
RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc)
Definition CGExpr.cpp:2448
RValue EmitAtomicExpr(AtomicExpr *E)
Definition CGAtomic.cpp:892
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property.
Definition CGObjC.cpp:1672
llvm::Value * EmitARCLoadWeak(Address addr)
i8* @objc_loadWeak(i8** addr) Essentially objc_autorelease(objc_loadWeakRetained(addr)).
Definition CGObjC.cpp:2636
void EmitOMPTargetDirective(const OMPTargetDirective &S)
void ExitSEHTryStmt(const SEHTryStmt &S)
void EmitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct &S)
LValue EmitLValueForLambdaField(const FieldDecl *Field)
Definition CGExpr.cpp:5205
static void EmitOMPTargetParallelForSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelForSimdDirective &S)
Emit device code for the target parallel for simd directive.
llvm::Value * EmitSVEPredicateTupleCast(llvm::Value *PredTuple, llvm::StructType *Ty)
Definition ARM.cpp:3912
void markStmtMaybeUsed(const Stmt *S)
llvm::Value * EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition Hexagon.cpp:77
CodeGenTypes & getTypes() const
llvm::Function * EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K)
Generate an outlined function for the body of a CapturedStmt, store any captured variables into the c...
Definition CGStmt.cpp:3278
llvm::Value * EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition X86.cpp:737
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped)
Generate a thunk for the given method.
void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
Definition CGExpr.cpp:6373
llvm::Value * EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
Definition ARM.cpp:4160
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
void FlattenAccessAndTypeLValue(LValue LVal, SmallVectorImpl< LValue > &AccessList)
Definition CGExpr.cpp:6839
void EmitOMPTeamsDirective(const OMPTeamsDirective &S)
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
Definition CGClass.cpp:1563
void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D)
Emit simple code for OpenMP directives in Simd-only mode.
HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr
HLSL Branch attribute.
LValue EmitCoyieldLValue(const CoyieldExpr *E)
bool InAlwaysInlineAttributedStmt
True if the current statement has always_inline attribute.
void EmitCaseStmt(const CaseStmt &S, ArrayRef< const Attr * > Attrs)
Definition CGStmt.cpp:1869
RawAddress CreateTempAlloca(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr, RawAddress *Alloca=nullptr)
CreateTempAlloca - This creates a alloca and inserts it into the entry block.
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
Definition CGObjC.cpp:3833
void EmitOMPErrorDirective(const OMPErrorDirective &S)
void EmitOMPTargetTaskBasedDirective(const OMPExecutableDirective &S, const RegionCodeGenTy &BodyGen, OMPTargetDataInfo &InputInfo)
void EmitBreakStmt(const BreakStmt &S)
Definition CGStmt.cpp:1755
void EmitOMPParallelMaskedTaskLoopSimdDirective(const OMPParallelMaskedTaskLoopSimdDirective &S)
void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S)
void EmitOpenACCComputeConstruct(const OpenACCComputeConstruct &S)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
void EmitCfiSlowPathCheck(SanitizerKind::SanitizerOrdinal Ordinal, llvm::Value *Cond, llvm::ConstantInt *TypeId, llvm::Value *Ptr, ArrayRef< llvm::Constant * > StaticArgs)
Emit a slow path cross-DSO CFI check which calls __cfi_slowpath if Cond if false.
Definition CGExpr.cpp:3973
RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
void EmitDoStmt(const DoStmt &S, ArrayRef< const Attr * > Attrs={})
Definition CGStmt.cpp:1205
void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S)
llvm::Value * EmitSMEZero(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4339
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
Emits all the code to cause the given temporary to be cleaned up.
llvm::Value * authPointerToPointerCast(llvm::Value *ResultPtr, QualType SourceType, QualType DestType)
Address GenerateCapturedStmtArgument(const CapturedStmt &S)
Definition CGStmt.cpp:3293
LValue EmitUnaryOpLValue(const UnaryOperator *E)
Definition CGExpr.cpp:3465
bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
Emit initial code for lastprivate variables.
void StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo, bool IsUnprototyped)
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc, uint64_t RetKeyInstructionsSourceAtom)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
Definition CGCall.cpp:3985
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition CGExpr.cpp:1552
static void EmitOMPTargetTeamsDistributeParallelForSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeParallelForSimdDirective &S)
Emit device code for the target teams distribute parallel for simd directive.
llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
Definition CGStmt.cpp:675
bool LValueIsSuitableForInlineAtomic(LValue Src)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
llvm::Function * GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S, const OMPExecutableDirective &D)
void EmitOMPSimdDirective(const OMPSimdDirective &S)
llvm::Value * EmitSVEStructStore(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4087
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.
Definition CGExpr.cpp:1633
void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, bool ForVirtualBase, Address This, bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E)
Emit a call to a constructor inherited from a base class, passing the current constructor's arguments...
Definition CGClass.cpp:2337
RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
Definition CGExpr.cpp:188
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
Definition CGExpr.cpp:3038
CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier Qual, llvm::Type *Ty)
BuildAppleKextVirtualCall - This routine is to support gcc's kext ABI making indirect call to virtual...
Definition CGCXX.cpp:279
RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)
Definition CGExpr.cpp:5947
void EmitOMPParallelGenericLoopDirective(const OMPLoopDirective &S)
void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S)
RawAddress NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
Definition CGObjC.cpp:2160
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
void EmitOMPTeamsGenericLoopDirective(const OMPTeamsGenericLoopDirective &S)
void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)
LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E)
Definition CGExpr.cpp:6345
RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
llvm::Type * convertTypeForLoadStore(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
llvm::Value * EmitSMELd1St1(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Definition ARM.cpp:4292
llvm::Value * EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress, llvm::Value *Discriminator)
Create the discriminator from the storage address and the entity hash.
void EmitVarDecl(const VarDecl &D)
EmitVarDecl - Emit a local variable declaration.
Definition CGDecl.cpp:203
std::pair< bool, bool > getIsCounterPair(const Stmt *S) const
AggValueSlot::Overlap_t getOverlapForReturnValue()
Determine whether a return value slot may overlap some other object.
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
Definition CGExpr.cpp:736
const BreakContinue * GetDestForLoopControlStmt(const LoopControlStmt &S)
Definition CGStmt.cpp:1741
Address EmitExtVectorElementLValue(LValue V)
Generates lvalue for partial ext_vector access.
Definition CGExpr.cpp:2532
bool EmitOMPLinearClauseInit(const OMPLoopDirective &D)
Emit initial code for linear variables.
void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D, llvm::Value *Address)
llvm::Value * EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr, ArrayRef< llvm::Value * > IdxList, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, const Twine &Name="")
Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to detect undefined behavior whe...
void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)
EmitInitializationToLValue - Emit an initializer to an LValue.
Definition CGExpr.cpp:325
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
llvm::BasicBlock * GetIndirectGotoBlock()
static void EmitOMPTargetParallelGenericLoopDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelGenericLoopDirective &S)
Emit device code for the target parallel loop directive.
llvm::Value * EmitBuiltinAvailable(const VersionTuple &Version)
Definition CGObjC.cpp:4033
void EmitOpenACCHostDataConstruct(const OpenACCHostDataConstruct &S)
Address emitAddrOfRealComponent(Address complex, QualType complexType)
llvm::DILocation * SanitizerAnnotateDebugInfo(ArrayRef< SanitizerKind::SanitizerOrdinal > Ordinals, SanitizerHandler Handler)
Returns debug info, with additional annotation if CGM.getCodeGenOpts().SanitizeAnnotateDebugInfo[Ordi...
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters.
void EmitOpenACCUpdateConstruct(const OpenACCUpdateConstruct &S)
llvm::Value * GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, bool Delegating)
GetVTTParameter - Return the VTT parameter that should be passed to a base constructor/destructor wit...
Definition CGClass.cpp:453
void EmitOMPUnrollDirective(const OMPUnrollDirective &S)
void EmitOMPStripeDirective(const OMPStripeDirective &S)
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression,...
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
RValue EmitLoadOfExtVectorElementLValue(LValue V)
Definition CGExpr.cpp:2485
static bool hasAggregateEvaluationKind(QualType T)
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
Definition CGExpr.cpp:1610
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
Definition CGCall.cpp:4673
llvm::Value * EmitMatrixIndexExpr(const Expr *E)
Definition CGExpr.cpp:4809
void EmitCaseStmtRange(const CaseStmt &S, ArrayRef< const Attr * > Attrs)
EmitCaseStmtRange - If case statement range is not too big then add multiple cases to switch instruct...
Definition CGStmt.cpp:1784
ComplexPairTy EmitUnPromotedValue(ComplexPairTy result, QualType PromotionType)
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
Definition CGExpr.cpp:4254
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitOMPSingleDirective(const OMPSingleDirective &S)
void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID, bool NoMerge=false, const TrapReason *TR=nullptr)
Create a basic block that will call the trap intrinsic, and emit a conditional branch to it,...
Definition CGExpr.cpp:4181
void EmitReturnStmt(const ReturnStmt &S)
EmitReturnStmt - Note that due to GCC extensions, this can have an operand if the function returns vo...
Definition CGStmt.cpp:1616
void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of 'this'.
llvm::function_ref< void(CodeGenFunction &, SourceLocation, const unsigned, const bool)> CodeGenOrderedTy
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)
EmitFromMemory - Change a scalar value from its memory representation to its value representation.
Definition CGExpr.cpp:2220
llvm::Value * EmitCheckedArgForAssume(const Expr *E)
Emits an argument for a call to a __builtin_assume.
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition CGObjC.cpp:2524
static void EmitOMPTargetSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetSimdDirective &S)
Emit device code for the target simd directive.
llvm::Function * GenerateCapturedStmtFunction(const CapturedStmt &S)
Creates the outlined function for a CapturedStmt.
Definition CGStmt.cpp:3300
static void EmitOMPTargetParallelForDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelForDirective &S)
Emit device code for the target parallel for directive.
void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
const CGFunctionInfo * CurFnInfo
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
llvm::Value * EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
Build an expression accessing the "counted_by" field.
Definition CGExpr.cpp:1230
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
llvm::Value * EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition NVPTX.cpp:414
llvm::Value * getArrayInitIndex()
Get the index of the current ArrayInitLoopExpr, if any.
void EmitDeclStmt(const DeclStmt &S)
Definition CGStmt.cpp:1731
void InitializeVTablePointer(const VPtr &vptr)
Initialize the vtable pointer of the given subobject.
Definition CGClass.cpp:2618
void EmitLabelStmt(const LabelStmt &S)
Definition CGStmt.cpp:778
llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, llvm::Type *VTableTy, uint64_t VTableByteOffset)
Emit a type checked load from the given vtable.
Definition CGClass.cpp:3007
void EmitUnreachable(SourceLocation Loc)
Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.
Definition CGExpr.cpp:4169
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
static void EmitOMPTargetTeamsGenericLoopDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsGenericLoopDirective &S)
Emit device code for the target teams loop directive.
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
Emits an instance of NSConstantString representing the object.
Definition CGObjC.cpp:51
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
llvm::Value * EmitSVEAllTruePred(const SVETypeFlags &TypeFlags)
Definition ARM.cpp:3862
llvm::Value * EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty)
Definition ARM.cpp:4380
void EmitOMPTileDirective(const OMPTileDirective &S)
void EmitDecl(const Decl &D, bool EvaluateConditionDecl=false)
EmitDecl - Emit a declaration.
Definition CGDecl.cpp:52
LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E)
Definition CGExpr.cpp:6330
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
generateDestroyHelper - Generates a helper function which, when invoked, destroys the given object.
void EmitOMPAtomicDirective(const OMPAtomicDirective &S)
LValue EmitMemberExpr(const MemberExpr *E)
Definition CGExpr.cpp:5108
void EmitOpenACCSetConstruct(const OpenACCSetConstruct &S)
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
ConstantEmission tryEmitAsConstant(const DeclRefExpr *RefExpr)
Try to emit a reference to the given value without producing it as an l-value.
Definition CGExpr.cpp:1901
void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
Definition CGObjC.cpp:2814
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
Definition CGExpr.cpp:1668
void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst)
Store of global named registers are always calls to intrinsics.
Definition CGExpr.cpp:2880
void EmitAttributedStmt(const AttributedStmt &S)
Definition CGStmt.cpp:788
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
Definition CGObjC.cpp:3524
bool ShouldXRayInstrumentFunction() const
ShouldXRayInstrument - Return true if the current function should be instrumented with XRay nop sleds...
bool isOpaqueValueEmitted(const OpaqueValueExpr *E)
isOpaqueValueEmitted - Return true if the opaque value expression has already been emitted.
Definition CGExpr.cpp:5941
std::pair< llvm::Value *, CGPointerAuthInfo > EmitOrigPointerRValue(const Expr *E)
Retrieve a pointer rvalue and its ptrauth info.
void EmitOMPParallelMasterTaskLoopDirective(const OMPParallelMasterTaskLoopDirective &S)
void EmitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &S)
void markStmtAsUsed(bool Skipped, const Stmt *S)
llvm::Instruction * CurrentFuncletPad
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
Definition CGObjC.cpp:2651
bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
Definition CGClass.cpp:2990
void EmitOMPSectionDirective(const OMPSectionDirective &S)
llvm::Constant * GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo)
Generate the destroy-helper function for a block closure object: static void block_destroy_helper(blo...
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
void EmitOMPForSimdDirective(const OMPForSimdDirective &S)
llvm::LLVMContext & getLLVMContext()
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
ComplexPairTy EmitPromotedValue(ComplexPairTy result, QualType PromotionType)
bool checkIfFunctionMustProgress()
Returns true if a function must make progress, which means the mustprogress attribute can be added.
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
Definition CGObjC.cpp:1804
llvm::SmallVector< VPtr, 4 > VPtrsVector
static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts)
getAccessedFieldNo - Given an encoded value and a result number, return the input field number being ...
Definition CGExpr.cpp:708
llvm::Value * EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
EmitTargetBuiltinExpr - Emit the given builtin call.
void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
static void EmitOMPTargetTeamsDistributeSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeSimdDirective &S)
Emit device code for the target teams distribute simd directive.
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
Definition CGObjC.cpp:2734
void InitializeVTablePointers(const CXXRecordDecl *ClassDecl)
Definition CGClass.cpp:2738
llvm::Value * EmitObjCRetainNonBlock(llvm::Value *value, llvm::Type *returnType)
Retain the given object, with normal retain semantics.
Definition CGObjC.cpp:2858
void EmitARCCopyWeak(Address dst, Address src)
void @objc_copyWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition CGObjC.cpp:2701
llvm::function_ref< void(CodeGenFunction &, const OMPLoopDirective &, JumpDest)> CodeGenLoopTy
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...
void EmitIndirectGotoStmt(const IndirectGotoStmt &S)
Definition CGStmt.cpp:857
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
void EmitVTableAssumptionLoad(const VPtr &vptr, Address This)
Emit assumption that vptr load == global vtable.
Definition CGClass.cpp:2431
llvm::Value * EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
void MaybeEmitDeferredVarDeclInit(const VarDecl *var)
Definition CGDecl.cpp:2074
void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope, llvm::AtomicOrdering &AO, llvm::SyncScope::ID &SSID)
Definition AMDGPU.cpp:281
bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const
isObviouslyBranchWithoutCleanups - Return true if a branch to the specified destination obviously has...
void EmitSEHTryStmt(const SEHTryStmt &S)
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
Definition CGDecl.cpp:1807
void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S)
llvm::ScalableVectorType * getSVEPredType(const SVETypeFlags &TypeFlags)
Definition ARM.cpp:3790
void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
Definition CGObjC.cpp:2707
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
When instrumenting to collect profile data, the counts for some blocks such as switch cases need to n...
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, ArrayRef< Address > args, const Twine &name="")
llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)
Create a check that a scalar RValue is non-null.
Definition CGExpr.cpp:1562
void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)
Given a number of pointers, inform the optimizer that they're being intrinsically used up until this ...
Definition CGObjC.cpp:2167
void EmitCountedByBoundsChecking(const Expr *E, llvm::Value *Idx, Address Addr, QualType IdxTy, QualType ArrayTy, bool Accessed, bool FlexibleArray)
EmitCountedByBoundsChecking - If the array being accessed has a "counted_by" attribute,...
Definition CGExpr.cpp:4556
llvm::Value * EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy, QualType RTy)
Definition CGCall.cpp:3939
void EmitOMPTaskBasedDirective(const OMPExecutableDirective &S, const OpenMPDirectiveKind CapturedRegion, const RegionCodeGenTy &BodyGen, const TaskGenTy &TaskGen, OMPTaskDataTy &Data)
llvm::Value * EmitNeonCall(llvm::Function *F, SmallVectorImpl< llvm::Value * > &O, const char *name, unsigned shift=0, bool rightshift=false)
Definition ARM.cpp:427
void PopCleanupBlock(bool FallThroughIsBranchThrough=false, bool ForDeactivation=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
void EmitOMPForDirective(const OMPForDirective &S)
bool hasLabelBeenSeenInCurrentScope() const
Return true if a label was seen in the current scope.
llvm::Function * GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except)
Create a stub filter function that will ultimately hold the code of the filter expression.
void EmitLabel(const LabelDecl *D)
EmitLabel - Emit the block for the given label.
Definition CGStmt.cpp:720
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
void EmitOMPLinearClauseFinal(const OMPLoopDirective &D, const llvm::function_ref< llvm::Value *(CodeGenFunction &)> CondGen)
Emit final code for linear clauses.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition CGStmt.cpp:655
void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
EmitExprAsInit - Emits the code necessary to initialize a location in memory with the given initializ...
Definition CGDecl.cpp:2092
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy, AlignmentSource Source=AlignmentSource::Type)
llvm::Value * EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags, ArrayRef< llvm::Value * > Ops)
Definition ARM.cpp:4441
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
llvm::Value * EmitPointerAuthAuth(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
void EmitContinueStmt(const ContinueStmt &S)
Definition CGStmt.cpp:1768
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
void EmitOMPSimdFinal(const OMPLoopDirective &D, const llvm::function_ref< llvm::Value *(CodeGenFunction &)> CondGen)
llvm::Type * ConvertType(const TypeDecl *T)
This class organizes the cross-function state that is used while generating LLVM code.
const llvm::DataLayout & getDataLayout() const
Per-function PGO state.
Definition CodeGenPGO.h:29
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
A specialization of Address that requires the address to be an LLVM Constant.
Definition Address.h:296
static ConstantAddress invalid()
Definition Address.h:304
DominatingValue< Address >::saved_type AggregateAddr
static saved_type save(CodeGenFunction &CGF, RValue value)
ConditionalCleanup stores the saved form of its parameters, then restores them and performs the clean...
A saved depth on the scope stack.
A stack of scopes which respond to exceptions, including cleanups and catch blocks.
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition CGCall.h:375
LValue - This represents an lvalue references.
Definition CGValue.h:182
CharUnits getAlignment() const
Definition CGValue.h:343
static LValue MakeAddr(Address Addr, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition CGValue.h:432
QualType getType() const
Definition CGValue.h:291
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
A stack of loop information corresponding to loop nesting levels.
Definition CGLoopInfo.h:207
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition CGValue.h:42
static RValue get(llvm::Value *V)
Definition CGValue.h:98
An abstract representation of an aligned address.
Definition Address.h:42
static RawAddress invalid()
Definition Address.h:61
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Definition CGCall.h:379
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
Definition TargetInfo.h:47
The class detects jumps which bypass local variables declaration: goto L; int a; L:
CompoundAssignOperator - For compound assignments (e.g.
Definition Expr.h:4234
CompoundLiteralExpr - [C99 6.5.2.5].
Definition Expr.h:3539
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition Stmt.h:1720
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Definition ExprCXX.h:5257
SourceLocExprScopeGuard(const Expr *DefaultExpr, CurrentSourceLocExprScope &Current)
Represents the current source location and context used to determine the value of the source location...
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
This represents one expression.
Definition Expr.h:112
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition Expr.cpp:3081
QualType getType() const
Definition Expr.h:144
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition Expr.h:6498
Represents a member of a struct/union/class.
Definition Decl.h:3160
Represents a function declaration or definition.
Definition Decl.h:2000
Represents a prototype with parameter type info, e.g.
Definition TypeBase.h:5254
GlobalDecl - represents a global declaration.
Definition GlobalDecl.h:57
const Decl * getDecl() const
Definition GlobalDecl.h:106
GotoStmt - This represents a direct goto.
Definition Stmt.h:2969
This class represents temporary values used to represent inout and out arguments in HLSL.
Definition Expr.h:7283
IfStmt - This represents an if/then/else.
Definition Stmt.h:2259
IndirectGotoStmt - This represents an indirect goto.
Definition Stmt.h:3008
Describes an C or C++ initializer list.
Definition Expr.h:5233
Represents the declaration of a label.
Definition Decl.h:524
LabelStmt - Represents a label, which has a substatement.
Definition Stmt.h:2146
FPExceptionModeKind
Possible floating point exception behavior.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Represents a point when we exit a loop.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition ExprCXX.h:4922
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Definition Expr.h:2799
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition Expr.h:3298
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition TypeBase.h:3653
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This represents clause 'use_device_addr' in the 'pragma omp ...' directives.
This represents clause 'use_device_ptr' in the 'pragma omp ...' directives.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Definition ExprObjC.h:192
Represents Objective-C's @synchronized statement.
Definition StmtObjC.h:303
Represents Objective-C's @throw statement.
Definition StmtObjC.h:358
Represents Objective-C's @try ... @catch ... @finally statement.
Definition StmtObjC.h:167
Represents Objective-C's @autoreleasepool Statement.
Definition StmtObjC.h:394
ObjCBoxedExpr - used for generalized expression boxing.
Definition ExprObjC.h:128
ObjCContainerDecl - Represents a container for method declarations.
Definition DeclObjC.h:948
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition ExprObjC.h:308
ObjCEncodeExpr, used for @encode in Objective-C.
Definition ExprObjC.h:409
Represents Objective-C's collection statement.
Definition StmtObjC.h:23
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition DeclObjC.h:2597
Represents an ObjC class declaration.
Definition DeclObjC.h:1154
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition ExprObjC.h:1498
ObjCIvarDecl - Represents an ObjC instance variable.
Definition DeclObjC.h:1952
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition ExprObjC.h:548
An expression that sends a message to the given Objective-C object or class.
Definition ExprObjC.h:940
ObjCMethodDecl - Represents an instance or class method declaration.
Definition DeclObjC.h:140
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition DeclObjC.h:2805
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition ExprObjC.h:504
ObjCSelectorExpr used for @selector in Objective-C.
Definition ExprObjC.h:454
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition ExprObjC.h:52
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition Expr.h:1178
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition Expr.h:1228
Represents a parameter to a function.
Definition Decl.h:1790
Pointer-authentication qualifiers.
Definition TypeBase.h:152
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition TypeBase.h:3328
[C99 6.4.2.2] - A predefined identifier such as func.
Definition Expr.h:2005
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition Expr.h:6690
A (possibly-)qualified type.
Definition TypeBase.h:937
The collection of all-type qualifiers we support.
Definition TypeBase.h:331
Represents a struct/union/class.
Definition Decl.h:4312
specific_decl_iterator< FieldDecl > field_iterator
Definition Decl.h:4512
Flags to identify the types for overloaded SVE builtins.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition Scope.h:41
Encodes a location in the source.
A trivial tuple used to represent a source range.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition Expr.h:4529
Stmt - This represents one statement.
Definition Stmt.h:85
Likelihood
The likelihood of a branch being taken.
Definition Stmt.h:1415
@ LH_None
No attribute set or branches of the IfStmt have the same attribute.
Definition Stmt.h:1417
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1799
Exposes information about the current target.
Definition TargetInfo.h:226
Represents a declaration of a type.
Definition Decl.h:3513
bool isReferenceType() const
Definition TypeBase.h:8539
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition Expr.h:2244
Represents a call to the builtin function __builtin_va_arg.
Definition Expr.h:4891
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
QualType getType() const
Definition Decl.h:723
Represents a variable declaration or definition.
Definition Decl.h:926
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition Decl.cpp:2257
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition Decl.h:1262
Represents a C array with a specified size that is not an integer-constant-expression.
Definition TypeBase.h:3966
Expr * getSizeExpr() const
Definition TypeBase.h:3980
WhileStmt - This represents a 'while' stmt.
Definition Stmt.h:2697
#define bool
Definition gpuintrin.h:32
Defines the clang::TargetInfo interface.
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
Definition CGValue.h:141
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
Definition CGValue.h:154
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
Definition CGValue.h:145
TypeEvaluationKind
The kind of evaluation to perform on values of a particular type.
@ NormalCleanup
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
Definition CGValue.h:135
VE builtins.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const AstTypeMatcher< ComplexType > complexType
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
Definition ABI.h:24
bool isa(CodeGen::Address addr)
Definition Address.h:330
@ Success
Annotation was successful.
Definition Parser.h:65
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
CapturedRegionKind
The different kinds of captured statement.
@ CR_Default
OpenACCComputeConstruct(OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)
Expr * Cond
};
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition Linkage.h:24
@ Result
The result type of a method or function.
Definition TypeBase.h:905
const FunctionProtoType * T
bool IsXLHSInRHSPart
True if UE has the first form and false if the second.
CXXDtorType
C++ destructor types.
Definition ABI.h:34
LangAS
Defines the address space values used by the address space qualifier of QualType.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition OpenMPKinds.h:25
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition Specifiers.h:132
llvm::fp::ExceptionBehavior ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind)
U cast(CodeGen::Address addr)
Definition Address.h:327
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5858
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
#define false
Definition stdbool.h:26
#define true
Definition stdbool.h:25
Structure with information about how a bitfield should be accessed.
llvm::SmallVector< llvm::AllocaInst * > Take()
CXXDefaultArgExprScope(CodeGenFunction &CGF, const CXXDefaultArgExpr *E)
FMVResolverOption(llvm::Function *F, ArrayRef< StringRef > Feats, std::optional< StringRef > Arch=std::nullopt)
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
void setScopeDepth(EHScopeStack::stable_iterator depth)
EHScopeStack::stable_iterator getScopeDepth() const
JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth, unsigned Index)
Header for data within LifetimeExtendedCleanupStack.
unsigned Size
The size of the following cleanup object.
unsigned IsConditional
Whether this is a conditional cleanup.
static Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)
Returns address of the threadprivate variable for the current thread.
llvm::OpenMPIRBuilder::InsertPointTy InsertPointTy
static void EmitOMPOutlinedRegionBody(CodeGenFunction &CGF, const Stmt *RegionBodyStmt, InsertPointTy AllocaIP, InsertPointTy CodeGenIP, Twine RegionName)
Emit the body of an OMP region that will be outlined in OpenMPIRBuilder::finalize().
static Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)
Gets the OpenMP-specific address of the local variable /p VD.
static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP, llvm::BasicBlock &FiniBB, llvm::Function *Fn, ArrayRef< llvm::Value * > Args)
static std::string getNameWithSeparators(ArrayRef< StringRef > Parts, StringRef FirstSeparator=".", StringRef Separator=".")
Get the platform-specific name separator.
static void FinalizeOMPRegion(CodeGenFunction &CGF, InsertPointTy IP)
Emit the Finalization for an OMP region.
static void EmitOMPInlinedRegionBody(CodeGenFunction &CGF, const Stmt *RegionBodyStmt, InsertPointTy AllocaIP, InsertPointTy CodeGenIP, Twine RegionName)
Emit the body of an OMP region.
OMPBuilderCBHelpers & operator=(const OMPBuilderCBHelpers &)=delete
OMPBuilderCBHelpers(const OMPBuilderCBHelpers &)=delete
OMPTargetDataInfo(Address BasePointersArray, Address PointersArray, Address SizesArray, Address MappersArray, unsigned NumberOfTargetItems)
llvm::PointerUnion< const FunctionProtoType *, const ObjCMethodDecl * > P
Struct with all information about dynamic [sub]class needed to set vptr.
This structure provides a set of types that are commonly used during IR emission.
Helper class with most of the code for saving a value for a conditional expression cleanup.
llvm::PointerIntPair< llvm::Value *, 1, bool > saved_type
static llvm::Value * restore(CodeGenFunction &CGF, saved_type value)
static saved_type save(CodeGenFunction &CGF, llvm::Value *value)
static bool needsSaving(llvm::Value *value)
Answer whether the given value needs extra work to be saved.
static type restore(CodeGenFunction &CGF, saved_type value)
static type restore(CodeGenFunction &CGF, saved_type value)
static saved_type save(CodeGenFunction &CGF, type value)
static saved_type save(CodeGenFunction &CGF, type value)
static type restore(CodeGenFunction &CGF, saved_type value)
A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function.
static bool needsSaving(type value)
static saved_type save(CodeGenFunction &CGF, type value)
The this pointer adjustment as well as an optional return adjustment for a thunk.
Definition Thunk.h:157