clang 20.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 "CGDebugInfo.h"
18#include "CGLoopInfo.h"
19#include "CGValue.h"
20#include "CodeGenModule.h"
21#include "CodeGenPGO.h"
22#include "EHScopeStack.h"
23#include "VarBypassDetector.h"
24#include "clang/AST/CharUnits.h"
26#include "clang/AST/ExprCXX.h"
27#include "clang/AST/ExprObjC.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 LLVMContext;
51class MDNode;
52class SwitchInst;
53class Twine;
54class Value;
55class CanonicalLoopInfo;
56}
57
58namespace clang {
59class ASTContext;
60class CXXDestructorDecl;
61class CXXForRangeStmt;
62class CXXTryStmt;
63class Decl;
64class LabelDecl;
65class FunctionDecl;
66class FunctionProtoType;
67class LabelStmt;
68class ObjCContainerDecl;
69class ObjCInterfaceDecl;
70class ObjCIvarDecl;
71class ObjCMethodDecl;
72class ObjCImplementationDecl;
73class ObjCPropertyImplDecl;
74class TargetInfo;
75class VarDecl;
76class ObjCForCollectionStmt;
77class ObjCAtTryStmt;
78class ObjCAtThrowStmt;
79class ObjCAtSynchronizedStmt;
80class ObjCAutoreleasePoolStmt;
81class OMPUseDevicePtrClause;
82class OMPUseDeviceAddrClause;
83class SVETypeFlags;
84class OMPExecutableDirective;
85
86namespace analyze_os_log {
87class OSLogBufferLayout;
88}
89
90namespace CodeGen {
91class CodeGenTypes;
92class CGCallee;
93class CGFunctionInfo;
94class CGBlockInfo;
95class CGCXXABI;
96class BlockByrefHelpers;
97class BlockByrefInfo;
98class BlockFieldFlags;
99class RegionCodeGenTy;
100class TargetCodeGenInfo;
101struct OMPTaskDataTy;
102struct CGCoroData;
103
104/// The kind of evaluation to perform on values of a particular
105/// type. Basically, is the code in CGExprScalar, CGExprComplex, or
106/// CGExprAgg?
107///
108/// TODO: should vectors maybe be split out into their own thing?
114
115#define LIST_SANITIZER_CHECKS \
116 SANITIZER_CHECK(AddOverflow, add_overflow, 0) \
117 SANITIZER_CHECK(BuiltinUnreachable, builtin_unreachable, 0) \
118 SANITIZER_CHECK(CFICheckFail, cfi_check_fail, 0) \
119 SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0) \
120 SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0) \
121 SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0) \
122 SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 0) \
123 SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0) \
124 SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0) \
125 SANITIZER_CHECK(InvalidObjCCast, invalid_objc_cast, 0) \
126 SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0) \
127 SANITIZER_CHECK(MissingReturn, missing_return, 0) \
128 SANITIZER_CHECK(MulOverflow, mul_overflow, 0) \
129 SANITIZER_CHECK(NegateOverflow, negate_overflow, 0) \
130 SANITIZER_CHECK(NullabilityArg, nullability_arg, 0) \
131 SANITIZER_CHECK(NullabilityReturn, nullability_return, 1) \
132 SANITIZER_CHECK(NonnullArg, nonnull_arg, 0) \
133 SANITIZER_CHECK(NonnullReturn, nonnull_return, 1) \
134 SANITIZER_CHECK(OutOfBounds, out_of_bounds, 0) \
135 SANITIZER_CHECK(PointerOverflow, pointer_overflow, 0) \
136 SANITIZER_CHECK(ShiftOutOfBounds, shift_out_of_bounds, 0) \
137 SANITIZER_CHECK(SubOverflow, sub_overflow, 0) \
138 SANITIZER_CHECK(TypeMismatch, type_mismatch, 1) \
139 SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0) \
140 SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0) \
141 SANITIZER_CHECK(BoundsSafety, bounds_safety, 0)
142
144#define SANITIZER_CHECK(Enum, Name, Version) Enum,
146#undef SANITIZER_CHECK
148
149/// Helper class with most of the code for saving a value for a
150/// conditional expression cleanup.
152 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
153
154 /// Answer whether the given value needs extra work to be saved.
155 static bool needsSaving(llvm::Value *value) {
156 if (!value)
157 return false;
158
159 // If it's not an instruction, we don't need to save.
160 if (!isa<llvm::Instruction>(value)) return false;
161
162 // If it's an instruction in the entry block, we don't need to save.
163 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
164 return (block != &block->getParent()->getEntryBlock());
165 }
166
167 static saved_type save(CodeGenFunction &CGF, llvm::Value *value);
168 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value);
169};
170
171/// A partial specialization of DominatingValue for llvm::Values that
172/// might be llvm::Instructions.
173template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
174 typedef T *type;
176 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
177 }
178};
179
180/// A specialization of DominatingValue for Address.
181template <> struct DominatingValue<Address> {
182 typedef Address type;
183
184 struct saved_type {
186 llvm::Type *ElementType;
189 llvm::PointerType *EffectiveType;
190 };
191
192 static bool needsSaving(type value) {
195 return true;
196 return false;
197 }
198 static saved_type save(CodeGenFunction &CGF, type value) {
199 return {DominatingLLVMValue::save(CGF, value.getBasePointer()),
200 value.getElementType(), value.getAlignment(),
201 DominatingLLVMValue::save(CGF, value.getOffset()), value.getType()};
202 }
204 return Address(DominatingLLVMValue::restore(CGF, value.BasePtr),
205 value.ElementType, value.Alignment, CGPointerAuthInfo(),
206 DominatingLLVMValue::restore(CGF, value.Offset));
207 }
208};
209
210/// A specialization of DominatingValue for RValue.
211template <> struct DominatingValue<RValue> {
212 typedef RValue type;
214 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
215 AggregateAddress, ComplexAddress };
216 union {
217 struct {
219 } Vals;
221 };
222 LLVM_PREFERRED_TYPE(Kind)
223 unsigned K : 3;
224
226 : Vals{Val1, DominatingLLVMValue::saved_type()}, K(K) {}
227
230 : Vals{Val1, Val2}, K(ComplexAddress) {}
231
232 saved_type(DominatingValue<Address>::saved_type AggregateAddr, unsigned K)
233 : AggregateAddr(AggregateAddr), K(K) {}
234
235 public:
236 static bool needsSaving(RValue value);
239
240 // implementations in CGCleanup.cpp
241 };
242
243 static bool needsSaving(type value) {
244 return saved_type::needsSaving(value);
245 }
246 static saved_type save(CodeGenFunction &CGF, type value) {
247 return saved_type::save(CGF, value);
248 }
250 return value.restore(CGF);
251 }
252};
253
254/// CodeGenFunction - This class organizes the per-function state that is used
255/// while generating LLVM code.
257 CodeGenFunction(const CodeGenFunction &) = delete;
258 void operator=(const CodeGenFunction &) = delete;
259
260 friend class CGCXXABI;
261public:
262 /// A jump destination is an abstract label, branching to which may
263 /// require a jump out through normal cleanups.
264 struct JumpDest {
265 JumpDest() : Block(nullptr), Index(0) {}
266 JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth,
267 unsigned Index)
268 : Block(Block), ScopeDepth(Depth), Index(Index) {}
269
270 bool isValid() const { return Block != nullptr; }
271 llvm::BasicBlock *getBlock() const { return Block; }
272 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
273 unsigned getDestIndex() const { return Index; }
274
275 // This should be used cautiously.
277 ScopeDepth = depth;
278 }
279
280 private:
281 llvm::BasicBlock *Block;
283 unsigned Index;
284 };
285
286 CodeGenModule &CGM; // Per-module state.
288
289 // For EH/SEH outlined funclets, this field points to parent's CGF
291
292 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
295
296 // Stores variables for which we can't generate correct lifetime markers
297 // because of jumps.
299
300 /// List of recently emitted OMPCanonicalLoops.
301 ///
302 /// Since OMPCanonicalLoops are nested inside other statements (in particular
303 /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
304 /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its
305 /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any
306 /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
307 /// this stack when done. Entering a new loop requires clearing this list; it
308 /// either means we start parsing a new loop nest (in which case the previous
309 /// loop nest goes out of scope) or a second loop in the same level in which
310 /// case it would be ambiguous into which of the two (or more) loops the loop
311 /// nest would extend.
313
314 /// Stack to track the Logical Operator recursion nest for MC/DC.
316
317 /// Stack to track the controlled convergence tokens.
319
320 /// Number of nested loop to be consumed by the last surrounding
321 /// loop-associated directive.
323
324 // CodeGen lambda for loops and support for ordered clause
325 typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
326 JumpDest)>
328 typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
329 const unsigned, const bool)>
331
332 // Codegen lambda for loop bounds in worksharing loop constructs
333 typedef llvm::function_ref<std::pair<LValue, LValue>(
336
337 // Codegen lambda for loop bounds in dispatch-based loop implementation
338 typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
340 Address UB)>
342
343 /// CGBuilder insert helper. This function is called after an
344 /// instruction is created using Builder.
345 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
346 llvm::BasicBlock::iterator InsertPt) const;
347
348 /// CurFuncDecl - Holds the Decl for the current outermost
349 /// non-closure context.
350 const Decl *CurFuncDecl = nullptr;
351 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
352 const Decl *CurCodeDecl = nullptr;
353 const CGFunctionInfo *CurFnInfo = nullptr;
355 llvm::Function *CurFn = nullptr;
356
357 /// Save Parameter Decl for coroutine.
359
360 // Holds coroutine data if the current function is a coroutine. We use a
361 // wrapper to manage its lifetime, so that we don't have to define CGCoroData
362 // in this header.
363 struct CGCoroInfo {
364 std::unique_ptr<CGCoroData> Data;
365 bool InSuspendBlock = false;
366 CGCoroInfo();
367 ~CGCoroInfo();
368 };
370
371 bool isCoroutine() const {
372 return CurCoro.Data != nullptr;
373 }
374
375 bool inSuspendBlock() const {
377 }
378
379 // Holds FramePtr for await_suspend wrapper generation,
380 // so that __builtin_coro_frame call can be lowered
381 // directly to value of its second argument
383 llvm::Value *FramePtr = nullptr;
384 };
386
387 // Generates wrapper function for `llvm.coro.await.suspend.*` intrinisics.
388 // It encapsulates SuspendExpr in a function, to separate it's body
389 // from the main coroutine to avoid miscompilations. Intrinisic
390 // is lowered to this function call in CoroSplit pass
391 // Function signature is:
392 // <type> __await_suspend_wrapper_<name>(ptr %awaiter, ptr %hdl)
393 // where type is one of (void, i1, ptr)
394 llvm::Function *generateAwaitSuspendWrapper(Twine const &CoroName,
395 Twine const &SuspendPointName,
396 CoroutineSuspendExpr const &S);
397
398 /// CurGD - The GlobalDecl for the current function being compiled.
400
401 /// PrologueCleanupDepth - The cleanup depth enclosing all the
402 /// cleanups associated with the parameters.
404
405 /// ReturnBlock - Unified return block.
407
408 /// ReturnValue - The temporary alloca to hold the return
409 /// value. This is invalid iff the function has no return value.
411
412 /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
413 /// This is invalid if sret is not in use.
415
416 /// If a return statement is being visited, this holds the return statment's
417 /// result expression.
418 const Expr *RetExpr = nullptr;
419
420 /// Return true if a label was seen in the current scope.
422 if (CurLexicalScope)
423 return CurLexicalScope->hasLabels();
424 return !LabelMap.empty();
425 }
426
427 /// AllocaInsertPoint - This is an instruction in the entry block before which
428 /// we prefer to insert allocas.
429 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
430
431private:
432 /// PostAllocaInsertPt - This is a place in the prologue where code can be
433 /// inserted that will be dominated by all the static allocas. This helps
434 /// achieve two things:
435 /// 1. Contiguity of all static allocas (within the prologue) is maintained.
436 /// 2. All other prologue code (which are dominated by static allocas) do
437 /// appear in the source order immediately after all static allocas.
438 ///
439 /// PostAllocaInsertPt will be lazily created when it is *really* required.
440 llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr;
441
442public:
443 /// Return PostAllocaInsertPt. If it is not yet created, then insert it
444 /// immediately after AllocaInsertPt.
445 llvm::Instruction *getPostAllocaInsertPoint() {
446 if (!PostAllocaInsertPt) {
447 assert(AllocaInsertPt &&
448 "Expected static alloca insertion point at function prologue");
449 assert(AllocaInsertPt->getParent()->isEntryBlock() &&
450 "EBB should be entry block of the current code gen function");
451 PostAllocaInsertPt = AllocaInsertPt->clone();
452 PostAllocaInsertPt->setName("postallocapt");
453 PostAllocaInsertPt->insertAfter(AllocaInsertPt);
454 }
455
456 return PostAllocaInsertPt;
457 }
458
459 /// API for captured statement code generation.
461 public:
463 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
466 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
467
469 S.getCapturedRecordDecl()->field_begin();
470 for (CapturedStmt::const_capture_iterator I = S.capture_begin(),
471 E = S.capture_end();
472 I != E; ++I, ++Field) {
473 if (I->capturesThis())
474 CXXThisFieldDecl = *Field;
475 else if (I->capturesVariable())
476 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
477 else if (I->capturesVariableByCopy())
478 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
479 }
480 }
481
482 virtual ~CGCapturedStmtInfo();
483
484 CapturedRegionKind getKind() const { return Kind; }
485
486 virtual void setContextValue(llvm::Value *V) { ThisValue = V; }
487 // Retrieve the value of the context parameter.
488 virtual llvm::Value *getContextValue() const { return ThisValue; }
489
490 /// Lookup the captured field decl for a variable.
491 virtual const FieldDecl *lookup(const VarDecl *VD) const {
492 return CaptureFields.lookup(VD->getCanonicalDecl());
493 }
494
495 bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; }
496 virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; }
497
498 static bool classof(const CGCapturedStmtInfo *) {
499 return true;
500 }
501
502 /// Emit the captured statement body.
503 virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
505 CGF.EmitStmt(S);
506 }
507
508 /// Get the name of the capture helper.
509 virtual StringRef getHelperName() const { return "__captured_stmt"; }
510
511 /// Get the CaptureFields
512 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() {
513 return CaptureFields;
514 }
515
516 private:
517 /// The kind of captured statement being generated.
519
520 /// Keep the map between VarDecl and FieldDecl.
521 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields;
522
523 /// The base address of the captured record, passed in as the first
524 /// argument of the parallel region function.
525 llvm::Value *ThisValue;
526
527 /// Captured 'this' type.
528 FieldDecl *CXXThisFieldDecl;
529 };
531
532 /// RAII for correct setting/restoring of CapturedStmtInfo.
534 private:
535 CodeGenFunction &CGF;
536 CGCapturedStmtInfo *PrevCapturedStmtInfo;
537 public:
539 CGCapturedStmtInfo *NewCapturedStmtInfo)
540 : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
541 CGF.CapturedStmtInfo = NewCapturedStmtInfo;
542 }
543 ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
544 };
545
546 /// An abstract representation of regular/ObjC call/message targets.
548 /// The function declaration of the callee.
549 const Decl *CalleeDecl;
550
551 public:
552 AbstractCallee() : CalleeDecl(nullptr) {}
553 AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
554 AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {}
555 bool hasFunctionDecl() const {
556 return isa_and_nonnull<FunctionDecl>(CalleeDecl);
557 }
558 const Decl *getDecl() const { return CalleeDecl; }
559 unsigned getNumParams() const {
560 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
561 return FD->getNumParams();
562 return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
563 }
564 const ParmVarDecl *getParamDecl(unsigned I) const {
565 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
566 return FD->getParamDecl(I);
567 return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
568 }
569 };
570
571 /// Sanitizers enabled for this function.
573
574 /// True if CodeGen currently emits code implementing sanitizer checks.
575 bool IsSanitizerScope = false;
576
577 /// RAII object to set/unset CodeGenFunction::IsSanitizerScope.
579 CodeGenFunction *CGF;
580 public:
583 };
584
585 /// In C++, whether we are code generating a thunk. This controls whether we
586 /// should emit cleanups.
587 bool CurFuncIsThunk = false;
588
589 /// In ARC, whether we should autorelease the return value.
590 bool AutoreleaseResult = false;
591
592 /// Whether we processed a Microsoft-style asm block during CodeGen. These can
593 /// potentially set the return value.
594 bool SawAsmBlock = false;
595
597
598 /// True if the current function is an outlined SEH helper. This can be a
599 /// finally block or filter expression.
601
602 /// True if CodeGen currently emits code inside presereved access index
603 /// region.
605
606 /// True if the current statement has nomerge attribute.
608
609 /// True if the current statement has noinline attribute.
611
612 /// True if the current statement has always_inline attribute.
614
615 /// True if the current statement has noconvergent attribute.
617
618 // The CallExpr within the current statement that the musttail attribute
619 // applies to. nullptr if there is no 'musttail' on the current statement.
620 const CallExpr *MustTailCall = nullptr;
621
622 /// Returns true if a function must make progress, which means the
623 /// mustprogress attribute can be added.
625 if (CGM.getCodeGenOpts().getFiniteLoops() ==
627 return false;
628
629 // C++11 and later guarantees that a thread eventually will do one of the
630 // following (C++11 [intro.multithread]p24 and C++17 [intro.progress]p1):
631 // - terminate,
632 // - make a call to a library I/O function,
633 // - perform an access through a volatile glvalue, or
634 // - perform a synchronization operation or an atomic operation.
635 //
636 // Hence each function is 'mustprogress' in C++11 or later.
637 return getLangOpts().CPlusPlus11;
638 }
639
640 /// Returns true if a loop must make progress, which means the mustprogress
641 /// attribute can be added. \p HasConstantCond indicates whether the branch
642 /// condition is a known constant.
643 bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody);
644
646 llvm::Value *BlockPointer = nullptr;
647
648 llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
650
651 /// A mapping from NRVO variables to the flags used to indicate
652 /// when the NRVO has been applied to this variable.
653 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
654
657
658 // A stack of cleanups which were added to EHStack but have to be deactivated
659 // later before being popped or emitted. These are usually deactivated on
660 // exiting a `CleanupDeactivationScope` scope. For instance, after a
661 // full-expr.
662 //
663 // These are specially useful for correctly emitting cleanups while
664 // encountering branches out of expression (through stmt-expr or coroutine
665 // suspensions).
668 llvm::Instruction *DominatingIP;
669 };
671
672 // Enters a new scope for capturing cleanups which are deferred to be
673 // deactivated, all of which will be deactivated once the scope is exited.
682
684 assert(!Deactivated && "Deactivating already deactivated scope");
686 for (size_t I = Stack.size(); I > OldDeactivateCleanupStackSize; I--) {
687 CGF.DeactivateCleanupBlock(Stack[I - 1].Cleanup,
688 Stack[I - 1].DominatingIP);
689 Stack[I - 1].DominatingIP->eraseFromParent();
690 }
691 Stack.resize(OldDeactivateCleanupStackSize);
692 Deactivated = true;
693 }
694
696 if (Deactivated)
697 return;
699 }
700 };
701
703
704 llvm::Instruction *CurrentFuncletPad = nullptr;
705
707 bool isRedundantBeforeReturn() override { return true; }
708
709 llvm::Value *Addr;
710 llvm::Value *Size;
711
712 public:
713 CallLifetimeEnd(RawAddress addr, llvm::Value *size)
714 : Addr(addr.getPointer()), Size(size) {}
715
716 void Emit(CodeGenFunction &CGF, Flags flags) override {
717 CGF.EmitLifetimeEnd(Size, Addr);
718 }
719 };
720
721 /// Header for data within LifetimeExtendedCleanupStack.
723 /// The size of the following cleanup object.
724 unsigned Size;
725 /// The kind of cleanup to push.
726 LLVM_PREFERRED_TYPE(CleanupKind)
728 /// Whether this is a conditional cleanup.
729 LLVM_PREFERRED_TYPE(bool)
730 unsigned IsConditional : 1;
731
732 size_t getSize() const { return Size; }
733 CleanupKind getKind() const { return (CleanupKind)Kind; }
734 bool isConditional() const { return IsConditional; }
735 };
736
737 /// i32s containing the indexes of the cleanup destinations.
739
741
742 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
743 llvm::BasicBlock *EHResumeBlock = nullptr;
744
745 /// The exception slot. All landing pads write the current exception pointer
746 /// into this alloca.
747 llvm::Value *ExceptionSlot = nullptr;
748
749 /// The selector slot. Under the MandatoryCleanup model, all landing pads
750 /// write the current selector value into this alloca.
751 llvm::AllocaInst *EHSelectorSlot = nullptr;
752
753 /// A stack of exception code slots. Entering an __except block pushes a slot
754 /// on the stack and leaving pops one. The __exception_code() intrinsic loads
755 /// a value from the top of the stack.
757
758 /// Value returned by __exception_info intrinsic.
759 llvm::Value *SEHInfo = nullptr;
760
761 /// Emits a landing pad for the current EH stack.
762 llvm::BasicBlock *EmitLandingPad();
763
764 llvm::BasicBlock *getInvokeDestImpl();
765
766 /// Parent loop-based directive for scan directive.
768 llvm::BasicBlock *OMPBeforeScanBlock = nullptr;
769 llvm::BasicBlock *OMPAfterScanBlock = nullptr;
770 llvm::BasicBlock *OMPScanExitBlock = nullptr;
771 llvm::BasicBlock *OMPScanDispatch = nullptr;
772 bool OMPFirstScanLoop = false;
773
774 /// Manages parent directive for scan directives.
776 CodeGenFunction &CGF;
777 const OMPExecutableDirective *ParentLoopDirectiveForScan;
778
779 public:
781 CodeGenFunction &CGF,
782 const OMPExecutableDirective &ParentLoopDirectiveForScan)
783 : CGF(CGF),
784 ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) {
785 CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan;
786 }
788 CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan;
789 }
790 };
791
792 template <class T>
794 return DominatingValue<T>::save(*this, value);
795 }
796
798 public:
799 CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures);
802
803 private:
804 void ConstructorHelper(FPOptions FPFeatures);
805 CodeGenFunction &CGF;
806 FPOptions OldFPFeatures;
807 llvm::fp::ExceptionBehavior OldExcept;
808 llvm::RoundingMode OldRounding;
809 std::optional<CGBuilderTy::FastMathFlagGuard> FMFGuard;
810 };
812
813public:
814 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
815 /// rethrows.
817
818 /// A class controlling the emission of a finally block.
820 /// Where the catchall's edge through the cleanup should go.
821 JumpDest RethrowDest;
822
823 /// A function to call to enter the catch.
824 llvm::FunctionCallee BeginCatchFn;
825
826 /// An i1 variable indicating whether or not the @finally is
827 /// running for an exception.
828 llvm::AllocaInst *ForEHVar = nullptr;
829
830 /// An i8* variable into which the exception pointer to rethrow
831 /// has been saved.
832 llvm::AllocaInst *SavedExnVar = nullptr;
833
834 public:
835 void enter(CodeGenFunction &CGF, const Stmt *Finally,
836 llvm::FunctionCallee beginCatchFn,
837 llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
838 void exit(CodeGenFunction &CGF);
839 };
840
841 /// Returns true inside SEH __try blocks.
842 bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
843
844 /// Returns true while emitting a cleanuppad.
845 bool isCleanupPadScope() const {
846 return CurrentFuncletPad && isa<llvm::CleanupPadInst>(CurrentFuncletPad);
847 }
848
849 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
850 /// current full-expression. Safe against the possibility that
851 /// we're currently inside a conditionally-evaluated expression.
852 template <class T, class... As>
853 void pushFullExprCleanup(CleanupKind kind, As... A) {
854 // If we're not in a conditional branch, or if none of the
855 // arguments requires saving, then use the unconditional cleanup.
857 return EHStack.pushCleanup<T>(kind, A...);
858
859 // Stash values in a tuple so we can guarantee the order of saves.
860 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
861 SavedTuple Saved{saveValueInCond(A)...};
862
863 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
864 EHStack.pushCleanupTuple<CleanupType>(kind, Saved);
866 }
867
868 /// Queue a cleanup to be pushed after finishing the current full-expression,
869 /// potentially with an active flag.
870 template <class T, class... As>
873 return pushCleanupAfterFullExprWithActiveFlag<T>(
874 Kind, RawAddress::invalid(), A...);
875
876 RawAddress ActiveFlag = createCleanupActiveFlag();
877 assert(!DominatingValue<Address>::needsSaving(ActiveFlag) &&
878 "cleanup active flag should never need saving");
879
880 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
881 SavedTuple Saved{saveValueInCond(A)...};
882
883 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
884 pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved);
885 }
886
887 template <class T, class... As>
889 RawAddress ActiveFlag, As... A) {
890 LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
891 ActiveFlag.isValid()};
892
895 LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
896 (Header.IsConditional ? sizeof(ActiveFlag) : 0));
897
898 static_assert(sizeof(Header) % alignof(T) == 0,
899 "Cleanup will be allocated on misaligned address");
900 char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
901 new (Buffer) LifetimeExtendedCleanupHeader(Header);
902 new (Buffer + sizeof(Header)) T(A...);
903 if (Header.IsConditional)
904 new (Buffer + sizeof(Header) + sizeof(T)) RawAddress(ActiveFlag);
905 }
906
907 // Push a cleanup onto EHStack and deactivate it later. It is usually
908 // deactivated when exiting a `CleanupDeactivationScope` (for example: after a
909 // full expression).
910 template <class T, class... As>
912 // Placeholder dominating IP for this cleanup.
913 llvm::Instruction *DominatingIP =
914 Builder.CreateFlagLoad(llvm::Constant::getNullValue(Int8PtrTy));
915 EHStack.pushCleanup<T>(Kind, A...);
917 {EHStack.stable_begin(), DominatingIP});
918 }
919
920 /// Set up the last cleanup that was pushed as a conditional
921 /// full-expression cleanup.
924 }
925
928
929 /// PushDestructorCleanup - Push a cleanup to call the
930 /// complete-object destructor of an object of the given type at the
931 /// given address. Does nothing if T is not a C++ class type with a
932 /// non-trivial destructor.
934
935 /// PushDestructorCleanup - Push a cleanup to call the
936 /// complete-object variant of the given destructor on the object at
937 /// the given address.
939 Address Addr);
940
941 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
942 /// process all branch fixups.
943 void PopCleanupBlock(bool FallThroughIsBranchThrough = false,
944 bool ForDeactivation = false);
945
946 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
947 /// The block cannot be reactivated. Pops it if it's the top of the
948 /// stack.
949 ///
950 /// \param DominatingIP - An instruction which is known to
951 /// dominate the current IP (if set) and which lies along
952 /// all paths of execution between the current IP and the
953 /// the point at which the cleanup comes into scope.
955 llvm::Instruction *DominatingIP);
956
957 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
958 /// Cannot be used to resurrect a deactivated cleanup.
959 ///
960 /// \param DominatingIP - An instruction which is known to
961 /// dominate the current IP (if set) and which lies along
962 /// all paths of execution between the current IP and the
963 /// the point at which the cleanup comes into scope.
965 llvm::Instruction *DominatingIP);
966
967 /// Enters a new scope for capturing cleanups, all of which
968 /// will be executed once the scope is exited.
970 EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth;
971 size_t LifetimeExtendedCleanupStackSize;
972 CleanupDeactivationScope DeactivateCleanups;
973 bool OldDidCallStackSave;
974 protected:
976 private:
977
978 RunCleanupsScope(const RunCleanupsScope &) = delete;
979 void operator=(const RunCleanupsScope &) = delete;
980
981 protected:
983
984 public:
985 /// Enter a new cleanup scope.
987 : DeactivateCleanups(CGF), PerformCleanup(true), CGF(CGF) {
988 CleanupStackDepth = CGF.EHStack.stable_begin();
989 LifetimeExtendedCleanupStackSize =
991 OldDidCallStackSave = CGF.DidCallStackSave;
992 CGF.DidCallStackSave = false;
993 OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth;
994 CGF.CurrentCleanupScopeDepth = CleanupStackDepth;
995 }
996
997 /// Exit this cleanup scope, emitting any accumulated cleanups.
999 if (PerformCleanup)
1000 ForceCleanup();
1001 }
1002
1003 /// Determine whether this scope requires any cleanups.
1004 bool requiresCleanups() const {
1005 return CGF.EHStack.stable_begin() != CleanupStackDepth;
1006 }
1007
1008 /// Force the emission of cleanups now, instead of waiting
1009 /// until this object is destroyed.
1010 /// \param ValuesToReload - A list of values that need to be available at
1011 /// the insertion point after cleanup emission. If cleanup emission created
1012 /// a shared cleanup block, these value pointers will be rewritten.
1013 /// Otherwise, they not will be modified.
1014 void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
1015 assert(PerformCleanup && "Already forced cleanup");
1016 CGF.DidCallStackSave = OldDidCallStackSave;
1017 DeactivateCleanups.ForceDeactivate();
1018 CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
1019 ValuesToReload);
1020 PerformCleanup = false;
1021 CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
1022 }
1023 };
1024
1025 // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
1028
1030 SourceRange Range;
1032 LexicalScope *ParentScope;
1033
1034 LexicalScope(const LexicalScope &) = delete;
1035 void operator=(const LexicalScope &) = delete;
1036
1037 public:
1038 /// Enter a new cleanup scope.
1040 : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) {
1041 CGF.CurLexicalScope = this;
1042 if (CGDebugInfo *DI = CGF.getDebugInfo())
1043 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
1044 }
1045
1046 void addLabel(const LabelDecl *label) {
1047 assert(PerformCleanup && "adding label to dead scope?");
1048 Labels.push_back(label);
1049 }
1050
1051 /// Exit this cleanup scope, emitting any accumulated
1052 /// cleanups.
1054 if (CGDebugInfo *DI = CGF.getDebugInfo())
1055 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
1056
1057 // If we should perform a cleanup, force them now. Note that
1058 // this ends the cleanup scope before rescoping any labels.
1059 if (PerformCleanup) {
1060 ApplyDebugLocation DL(CGF, Range.getEnd());
1061 ForceCleanup();
1062 }
1063 }
1064
1065 /// Force the emission of cleanups now, instead of waiting
1066 /// until this object is destroyed.
1068 CGF.CurLexicalScope = ParentScope;
1070
1071 if (!Labels.empty())
1072 rescopeLabels();
1073 }
1074
1075 bool hasLabels() const {
1076 return !Labels.empty();
1077 }
1078
1079 void rescopeLabels();
1080 };
1081
1082 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
1083
1084 /// The class used to assign some variables some temporarily addresses.
1086 DeclMapTy SavedLocals;
1087 DeclMapTy SavedTempAddresses;
1088 OMPMapVars(const OMPMapVars &) = delete;
1089 void operator=(const OMPMapVars &) = delete;
1090
1091 public:
1092 explicit OMPMapVars() = default;
1094 assert(SavedLocals.empty() && "Did not restored original addresses.");
1095 };
1096
1097 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
1098 /// function \p CGF.
1099 /// \return true if at least one variable was set already, false otherwise.
1100 bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD,
1101 Address TempAddr) {
1102 LocalVD = LocalVD->getCanonicalDecl();
1103 // Only save it once.
1104 if (SavedLocals.count(LocalVD)) return false;
1105
1106 // Copy the existing local entry to SavedLocals.
1107 auto it = CGF.LocalDeclMap.find(LocalVD);
1108 if (it != CGF.LocalDeclMap.end())
1109 SavedLocals.try_emplace(LocalVD, it->second);
1110 else
1111 SavedLocals.try_emplace(LocalVD, Address::invalid());
1112
1113 // Generate the private entry.
1114 QualType VarTy = LocalVD->getType();
1115 if (VarTy->isReferenceType()) {
1116 Address Temp = CGF.CreateMemTemp(VarTy);
1117 CGF.Builder.CreateStore(TempAddr.emitRawPointer(CGF), Temp);
1118 TempAddr = Temp;
1119 }
1120 SavedTempAddresses.try_emplace(LocalVD, TempAddr);
1121
1122 return true;
1123 }
1124
1125 /// Applies new addresses to the list of the variables.
1126 /// \return true if at least one variable is using new address, false
1127 /// otherwise.
1129 copyInto(SavedTempAddresses, CGF.LocalDeclMap);
1130 SavedTempAddresses.clear();
1131 return !SavedLocals.empty();
1132 }
1133
1134 /// Restores original addresses of the variables.
1136 if (!SavedLocals.empty()) {
1137 copyInto(SavedLocals, CGF.LocalDeclMap);
1138 SavedLocals.clear();
1139 }
1140 }
1141
1142 private:
1143 /// Copy all the entries in the source map over the corresponding
1144 /// entries in the destination, which must exist.
1145 static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) {
1146 for (auto &[Decl, Addr] : Src) {
1147 if (!Addr.isValid())
1148 Dest.erase(Decl);
1149 else
1150 Dest.insert_or_assign(Decl, Addr);
1151 }
1152 }
1153 };
1154
1155 /// The scope used to remap some variables as private in the OpenMP loop body
1156 /// (or other captured region emitted without outlining), and to restore old
1157 /// vars back on exit.
1159 OMPMapVars MappedVars;
1160 OMPPrivateScope(const OMPPrivateScope &) = delete;
1161 void operator=(const OMPPrivateScope &) = delete;
1162
1163 public:
1164 /// Enter a new OpenMP private scope.
1166
1167 /// Registers \p LocalVD variable as a private with \p Addr as the address
1168 /// of the corresponding private variable. \p
1169 /// PrivateGen is the address of the generated private variable.
1170 /// \return true if the variable is registered as private, false if it has
1171 /// been privatized already.
1172 bool addPrivate(const VarDecl *LocalVD, Address Addr) {
1173 assert(PerformCleanup && "adding private to dead scope");
1174 return MappedVars.setVarAddr(CGF, LocalVD, Addr);
1175 }
1176
1177 /// Privatizes local variables previously registered as private.
1178 /// Registration is separate from the actual privatization to allow
1179 /// initializers use values of the original variables, not the private one.
1180 /// This is important, for example, if the private variable is a class
1181 /// variable initialized by a constructor that references other private
1182 /// variables. But at initialization original variables must be used, not
1183 /// private copies.
1184 /// \return true if at least one variable was privatized, false otherwise.
1185 bool Privatize() { return MappedVars.apply(CGF); }
1186
1189 restoreMap();
1190 }
1191
1192 /// Exit scope - all the mapped variables are restored.
1194 if (PerformCleanup)
1195 ForceCleanup();
1196 }
1197
1198 /// Checks if the global variable is captured in current function.
1199 bool isGlobalVarCaptured(const VarDecl *VD) const {
1200 VD = VD->getCanonicalDecl();
1201 return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1202 }
1203
1204 /// Restore all mapped variables w/o clean up. This is usefully when we want
1205 /// to reference the original variables but don't want the clean up because
1206 /// that could emit lifetime end too early, causing backend issue #56913.
1207 void restoreMap() { MappedVars.restore(CGF); }
1208 };
1209
1210 /// Save/restore original map of previously emitted local vars in case when we
1211 /// need to duplicate emission of the same code several times in the same
1212 /// function for OpenMP code.
1214 CodeGenFunction &CGF;
1215 DeclMapTy SavedMap;
1216
1217 public:
1219 : CGF(CGF), SavedMap(CGF.LocalDeclMap) {}
1220 ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); }
1221 };
1222
1223 /// Takes the old cleanup stack size and emits the cleanup blocks
1224 /// that have been added.
1225 void
1227 std::initializer_list<llvm::Value **> ValuesToReload = {});
1228
1229 /// Takes the old cleanup stack size and emits the cleanup blocks
1230 /// that have been added, then adds all lifetime-extended cleanups from
1231 /// the given position to the stack.
1232 void
1234 size_t OldLifetimeExtendedStackSize,
1235 std::initializer_list<llvm::Value **> ValuesToReload = {});
1236
1237 void ResolveBranchFixups(llvm::BasicBlock *Target);
1238
1239 /// The given basic block lies in the current EH scope, but may be a
1240 /// target of a potentially scope-crossing jump; get a stable handle
1241 /// to which we can perform this jump later.
1243 return JumpDest(Target,
1246 }
1247
1248 /// The given basic block lies in the current EH scope, but may be a
1249 /// target of a potentially scope-crossing jump; get a stable handle
1250 /// to which we can perform this jump later.
1251 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
1253 }
1254
1255 /// EmitBranchThroughCleanup - Emit a branch from the current insert
1256 /// block through the normal cleanup handling code (if any) and then
1257 /// on to \arg Dest.
1259
1260 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1261 /// specified destination obviously has no cleanups to run. 'false' is always
1262 /// a conservatively correct answer for this method.
1264
1265 /// popCatchScope - Pops the catch scope at the top of the EHScope
1266 /// stack, emitting any required code (other than the catch handlers
1267 /// themselves).
1269
1270 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
1272 llvm::BasicBlock *
1274
1275 /// An object to manage conditionally-evaluated expressions.
1277 llvm::BasicBlock *StartBB;
1278
1279 public:
1281 : StartBB(CGF.Builder.GetInsertBlock()) {}
1282
1284 assert(CGF.OutermostConditional != this);
1285 if (!CGF.OutermostConditional)
1286 CGF.OutermostConditional = this;
1287 }
1288
1290 assert(CGF.OutermostConditional != nullptr);
1291 if (CGF.OutermostConditional == this)
1292 CGF.OutermostConditional = nullptr;
1293 }
1294
1295 /// Returns a block which will be executed prior to each
1296 /// evaluation of the conditional code.
1297 llvm::BasicBlock *getStartingBlock() const {
1298 return StartBB;
1299 }
1300 };
1301
1302 /// isInConditionalBranch - Return true if we're currently emitting
1303 /// one branch or the other of a conditional expression.
1304 bool isInConditionalBranch() const { return OutermostConditional != nullptr; }
1305
1306 void setBeforeOutermostConditional(llvm::Value *value, Address addr,
1307 CodeGenFunction &CGF) {
1308 assert(isInConditionalBranch());
1309 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1310 auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF),
1311 block->back().getIterator());
1312 store->setAlignment(addr.getAlignment().getAsAlign());
1313 }
1314
1315 /// An RAII object to record that we're evaluating a statement
1316 /// expression.
1318 CodeGenFunction &CGF;
1319
1320 /// We have to save the outermost conditional: cleanups in a
1321 /// statement expression aren't conditional just because the
1322 /// StmtExpr is.
1323 ConditionalEvaluation *SavedOutermostConditional;
1324
1325 public:
1327 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1328 CGF.OutermostConditional = nullptr;
1329 }
1330
1332 CGF.OutermostConditional = SavedOutermostConditional;
1333 CGF.EnsureInsertPoint();
1334 }
1335 };
1336
1337 /// An object which temporarily prevents a value from being
1338 /// destroyed by aggressive peephole optimizations that assume that
1339 /// all uses of a value have been realized in the IR.
1341 llvm::Instruction *Inst = nullptr;
1342 friend class CodeGenFunction;
1343
1344 public:
1346 };
1347
1348 /// A non-RAII class containing all the information about a bound
1349 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
1350 /// this which makes individual mappings very simple; using this
1351 /// class directly is useful when you have a variable number of
1352 /// opaque values or don't want the RAII functionality for some
1353 /// reason.
1355 const OpaqueValueExpr *OpaqueValue;
1356 bool BoundLValue;
1358
1360 bool boundLValue)
1361 : OpaqueValue(ov), BoundLValue(boundLValue) {}
1362 public:
1363 OpaqueValueMappingData() : OpaqueValue(nullptr) {}
1364
1365 static bool shouldBindAsLValue(const Expr *expr) {
1366 // gl-values should be bound as l-values for obvious reasons.
1367 // Records should be bound as l-values because IR generation
1368 // always keeps them in memory. Expressions of function type
1369 // act exactly like l-values but are formally required to be
1370 // r-values in C.
1371 return expr->isGLValue() ||
1372 expr->getType()->isFunctionType() ||
1373 hasAggregateEvaluationKind(expr->getType());
1374 }
1375
1377 const OpaqueValueExpr *ov,
1378 const Expr *e) {
1379 if (shouldBindAsLValue(ov))
1380 return bind(CGF, ov, CGF.EmitLValue(e));
1381 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1382 }
1383
1385 const OpaqueValueExpr *ov,
1386 const LValue &lv) {
1387 assert(shouldBindAsLValue(ov));
1388 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1389 return OpaqueValueMappingData(ov, true);
1390 }
1391
1393 const OpaqueValueExpr *ov,
1394 const RValue &rv) {
1395 assert(!shouldBindAsLValue(ov));
1396 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1397
1398 OpaqueValueMappingData data(ov, false);
1399
1400 // Work around an extremely aggressive peephole optimization in
1401 // EmitScalarConversion which assumes that all other uses of a
1402 // value are extant.
1403 data.Protection = CGF.protectFromPeepholes(rv);
1404
1405 return data;
1406 }
1407
1408 bool isValid() const { return OpaqueValue != nullptr; }
1409 void clear() { OpaqueValue = nullptr; }
1410
1412 assert(OpaqueValue && "no data to unbind!");
1413
1414 if (BoundLValue) {
1415 CGF.OpaqueLValues.erase(OpaqueValue);
1416 } else {
1417 CGF.OpaqueRValues.erase(OpaqueValue);
1418 CGF.unprotectFromPeepholes(Protection);
1419 }
1420 }
1421 };
1422
1423 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1425 CodeGenFunction &CGF;
1427
1428 public:
1429 static bool shouldBindAsLValue(const Expr *expr) {
1431 }
1432
1433 /// Build the opaque value mapping for the given conditional
1434 /// operator if it's the GNU ?: extension. This is a common
1435 /// enough pattern that the convenience operator is really
1436 /// helpful.
1437 ///
1439 const AbstractConditionalOperator *op) : CGF(CGF) {
1440 if (isa<ConditionalOperator>(op))
1441 // Leave Data empty.
1442 return;
1443
1444 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
1446 e->getCommon());
1447 }
1448
1449 /// Build the opaque value mapping for an OpaqueValueExpr whose source
1450 /// expression is set to the expression the OVE represents.
1452 : CGF(CGF) {
1453 if (OV) {
1454 assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1455 "for OVE with no source expression");
1457 }
1458 }
1459
1461 const OpaqueValueExpr *opaqueValue,
1462 LValue lvalue)
1463 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
1464 }
1465
1467 const OpaqueValueExpr *opaqueValue,
1468 RValue rvalue)
1469 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
1470 }
1471
1472 void pop() {
1473 Data.unbind(CGF);
1474 Data.clear();
1475 }
1476
1478 if (Data.isValid()) Data.unbind(CGF);
1479 }
1480 };
1481
1482private:
1483 CGDebugInfo *DebugInfo;
1484 /// Used to create unique names for artificial VLA size debug info variables.
1485 unsigned VLAExprCounter = 0;
1486 bool DisableDebugInfo = false;
1487
1488 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1489 /// calling llvm.stacksave for multiple VLAs in the same scope.
1490 bool DidCallStackSave = false;
1491
1492 /// IndirectBranch - The first time an indirect goto is seen we create a block
1493 /// with an indirect branch. Every time we see the address of a label taken,
1494 /// we add the label to the indirect goto. Every subsequent indirect goto is
1495 /// codegen'd as a jump to the IndirectBranch's basic block.
1496 llvm::IndirectBrInst *IndirectBranch = nullptr;
1497
1498 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1499 /// decls.
1500 DeclMapTy LocalDeclMap;
1501
1502 // Keep track of the cleanups for callee-destructed parameters pushed to the
1503 // cleanup stack so that they can be deactivated later.
1504 llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
1505 CalleeDestructedParamCleanups;
1506
1507 /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1508 /// will contain a mapping from said ParmVarDecl to its implicit "object_size"
1509 /// parameter.
1510 llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2>
1511 SizeArguments;
1512
1513 /// Track escaped local variables with auto storage. Used during SEH
1514 /// outlining to produce a call to llvm.localescape.
1515 llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
1516
1517 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1518 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
1519
1520 // BreakContinueStack - This keeps track of where break and continue
1521 // statements should jump to.
1522 struct BreakContinue {
1523 BreakContinue(JumpDest Break, JumpDest Continue)
1524 : BreakBlock(Break), ContinueBlock(Continue) {}
1525
1526 JumpDest BreakBlock;
1527 JumpDest ContinueBlock;
1528 };
1529 SmallVector<BreakContinue, 8> BreakContinueStack;
1530
1531 /// Handles cancellation exit points in OpenMP-related constructs.
1532 class OpenMPCancelExitStack {
1533 /// Tracks cancellation exit point and join point for cancel-related exit
1534 /// and normal exit.
1535 struct CancelExit {
1536 CancelExit() = default;
1537 CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
1538 JumpDest ContBlock)
1539 : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
1540 OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
1541 /// true if the exit block has been emitted already by the special
1542 /// emitExit() call, false if the default codegen is used.
1543 bool HasBeenEmitted = false;
1544 JumpDest ExitBlock;
1545 JumpDest ContBlock;
1546 };
1547
1548 SmallVector<CancelExit, 8> Stack;
1549
1550 public:
1551 OpenMPCancelExitStack() : Stack(1) {}
1552 ~OpenMPCancelExitStack() = default;
1553 /// Fetches the exit block for the current OpenMP construct.
1554 JumpDest getExitBlock() const { return Stack.back().ExitBlock; }
1555 /// Emits exit block with special codegen procedure specific for the related
1556 /// OpenMP construct + emits code for normal construct cleanup.
1557 void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
1558 const llvm::function_ref<void(CodeGenFunction &)> CodeGen) {
1559 if (Stack.back().Kind == Kind && getExitBlock().isValid()) {
1560 assert(CGF.getOMPCancelDestination(Kind).isValid());
1561 assert(CGF.HaveInsertPoint());
1562 assert(!Stack.back().HasBeenEmitted);
1563 auto IP = CGF.Builder.saveAndClearIP();
1564 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1565 CodeGen(CGF);
1566 CGF.EmitBranch(Stack.back().ContBlock.getBlock());
1567 CGF.Builder.restoreIP(IP);
1568 Stack.back().HasBeenEmitted = true;
1569 }
1570 CodeGen(CGF);
1571 }
1572 /// Enter the cancel supporting \a Kind construct.
1573 /// \param Kind OpenMP directive that supports cancel constructs.
1574 /// \param HasCancel true, if the construct has inner cancel directive,
1575 /// false otherwise.
1576 void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) {
1577 Stack.push_back({Kind,
1578 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1579 : JumpDest(),
1580 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1581 : JumpDest()});
1582 }
1583 /// Emits default exit point for the cancel construct (if the special one
1584 /// has not be used) + join point for cancel/normal exits.
1585 void exit(CodeGenFunction &CGF) {
1586 if (getExitBlock().isValid()) {
1587 assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid());
1588 bool HaveIP = CGF.HaveInsertPoint();
1589 if (!Stack.back().HasBeenEmitted) {
1590 if (HaveIP)
1591 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1592 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1593 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1594 }
1595 CGF.EmitBlock(Stack.back().ContBlock.getBlock());
1596 if (!HaveIP) {
1597 CGF.Builder.CreateUnreachable();
1598 CGF.Builder.ClearInsertionPoint();
1599 }
1600 }
1601 Stack.pop_back();
1602 }
1603 };
1604 OpenMPCancelExitStack OMPCancelStack;
1605
1606 /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
1607 llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
1608 Stmt::Likelihood LH);
1609
1610 CodeGenPGO PGO;
1611
1612 /// Bitmap used by MC/DC to track condition outcomes of a boolean expression.
1613 Address MCDCCondBitmapAddr = Address::invalid();
1614
1615 /// Calculate branch weights appropriate for PGO data
1616 llvm::MDNode *createProfileWeights(uint64_t TrueCount,
1617 uint64_t FalseCount) const;
1618 llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
1619 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1620 uint64_t LoopCount) const;
1621
1622public:
1623 auto getIsCounterPair(const Stmt *S) const { return PGO.getIsCounterPair(S); }
1624
1625 void markStmtAsUsed(bool Skipped, const Stmt *S) {
1626 PGO.markStmtAsUsed(Skipped, S);
1627 }
1628 void markStmtMaybeUsed(const Stmt *S) { PGO.markStmtMaybeUsed(S); }
1629
1630 /// Increment the profiler's counter for the given statement by \p StepV.
1631 /// If \p StepV is null, the default increment is 1.
1632 void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
1634 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile) &&
1635 !CurFn->hasFnAttribute(llvm::Attribute::SkipProfile)) {
1636 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1637 PGO.emitCounterSetOrIncrement(Builder, S, StepV);
1638 }
1639 PGO.setCurrentStmt(S);
1640 }
1641
1644 CGM.getCodeGenOpts().MCDCCoverage &&
1645 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile));
1646 }
1647
1648 /// Allocate a temp value on the stack that MCDC can use to track condition
1649 /// results.
1651 if (isMCDCCoverageEnabled()) {
1652 PGO.emitMCDCParameters(Builder);
1653 MCDCCondBitmapAddr =
1654 CreateIRTemp(getContext().UnsignedIntTy, "mcdc.addr");
1655 }
1656 }
1657
1658 bool isBinaryLogicalOp(const Expr *E) const {
1659 const BinaryOperator *BOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
1660 return (BOp && BOp->isLogicalOp());
1661 }
1662
1663 /// Zero-init the MCDC temp value.
1666 PGO.emitMCDCCondBitmapReset(Builder, E, MCDCCondBitmapAddr);
1667 PGO.setCurrentStmt(E);
1668 }
1669 }
1670
1671 /// Increment the profiler's counter for the given expression by \p StepV.
1672 /// If \p StepV is null, the default increment is 1.
1675 PGO.emitMCDCTestVectorBitmapUpdate(Builder, E, MCDCCondBitmapAddr, *this);
1676 PGO.setCurrentStmt(E);
1677 }
1678 }
1679
1680 /// Update the MCDC temp value with the condition's evaluated result.
1681 void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val) {
1682 if (isMCDCCoverageEnabled()) {
1683 PGO.emitMCDCCondBitmapUpdate(Builder, E, MCDCCondBitmapAddr, Val, *this);
1684 PGO.setCurrentStmt(E);
1685 }
1686 }
1687
1688 /// Get the profiler's count for the given statement.
1689 uint64_t getProfileCount(const Stmt *S) {
1690 return PGO.getStmtCount(S).value_or(0);
1691 }
1692
1693 /// Set the profiler's current count.
1694 void setCurrentProfileCount(uint64_t Count) {
1695 PGO.setCurrentRegionCount(Count);
1696 }
1697
1698 /// Get the profiler's current count. This is generally the count for the most
1699 /// recently incremented counter.
1701 return PGO.getCurrentRegionCount();
1702 }
1703
1704private:
1705
1706 /// SwitchInsn - This is nearest current switch instruction. It is null if
1707 /// current context is not in a switch.
1708 llvm::SwitchInst *SwitchInsn = nullptr;
1709 /// The branch weights of SwitchInsn when doing instrumentation based PGO.
1710 SmallVector<uint64_t, 16> *SwitchWeights = nullptr;
1711
1712 /// The likelihood attributes of the SwitchCase.
1713 SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr;
1714
1715 /// CaseRangeBlock - This block holds if condition check for last case
1716 /// statement range in current switch instruction.
1717 llvm::BasicBlock *CaseRangeBlock = nullptr;
1718
1719 /// OpaqueLValues - Keeps track of the current set of opaque value
1720 /// expressions.
1721 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1722 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1723
1724 // VLASizeMap - This keeps track of the associated size for each VLA type.
1725 // We track this by the size expression rather than the type itself because
1726 // in certain situations, like a const qualifier applied to an VLA typedef,
1727 // multiple VLA types can share the same size expression.
1728 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1729 // enter/leave scopes.
1730 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
1731
1732 /// A block containing a single 'unreachable' instruction. Created
1733 /// lazily by getUnreachableBlock().
1734 llvm::BasicBlock *UnreachableBlock = nullptr;
1735
1736 /// Counts of the number return expressions in the function.
1737 unsigned NumReturnExprs = 0;
1738
1739 /// Count the number of simple (constant) return expressions in the function.
1740 unsigned NumSimpleReturnExprs = 0;
1741
1742 /// The last regular (non-return) debug location (breakpoint) in the function.
1743 SourceLocation LastStopPoint;
1744
1745public:
1746 /// Source location information about the default argument or member
1747 /// initializer expression we're evaluating, if any.
1751
1752 /// A scope within which we are constructing the fields of an object which
1753 /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use
1754 /// if we need to evaluate a CXXDefaultInitExpr within the evaluation.
1756 public:
1758 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1759 CGF.CXXDefaultInitExprThis = This;
1760 }
1762 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1763 }
1764
1765 private:
1766 CodeGenFunction &CGF;
1767 Address OldCXXDefaultInitExprThis;
1768 };
1769
1770 /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
1771 /// is overridden to be the object under construction.
1773 public:
1775 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
1776 OldCXXThisAlignment(CGF.CXXThisAlignment),
1778 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getBasePointer();
1779 CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
1780 }
1782 CGF.CXXThisValue = OldCXXThisValue;
1783 CGF.CXXThisAlignment = OldCXXThisAlignment;
1784 }
1785
1786 public:
1788 llvm::Value *OldCXXThisValue;
1791 };
1792
1796 };
1797
1798 /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
1799 /// current loop index is overridden.
1801 public:
1802 ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
1803 : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {
1804 CGF.ArrayInitIndex = Index;
1805 }
1807 CGF.ArrayInitIndex = OldArrayInitIndex;
1808 }
1809
1810 private:
1811 CodeGenFunction &CGF;
1812 llvm::Value *OldArrayInitIndex;
1813 };
1814
1816 public:
1818 : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl),
1819 OldCurCodeDecl(CGF.CurCodeDecl),
1820 OldCXXABIThisDecl(CGF.CXXABIThisDecl),
1821 OldCXXABIThisValue(CGF.CXXABIThisValue),
1822 OldCXXThisValue(CGF.CXXThisValue),
1823 OldCXXABIThisAlignment(CGF.CXXABIThisAlignment),
1824 OldCXXThisAlignment(CGF.CXXThisAlignment),
1825 OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy),
1826 OldCXXInheritedCtorInitExprArgs(
1827 std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1828 CGF.CurGD = GD;
1829 CGF.CurFuncDecl = CGF.CurCodeDecl =
1830 cast<CXXConstructorDecl>(GD.getDecl());
1831 CGF.CXXABIThisDecl = nullptr;
1832 CGF.CXXABIThisValue = nullptr;
1833 CGF.CXXThisValue = nullptr;
1834 CGF.CXXABIThisAlignment = CharUnits();
1835 CGF.CXXThisAlignment = CharUnits();
1837 CGF.FnRetTy = QualType();
1838 CGF.CXXInheritedCtorInitExprArgs.clear();
1839 }
1841 CGF.CurGD = OldCurGD;
1842 CGF.CurFuncDecl = OldCurFuncDecl;
1843 CGF.CurCodeDecl = OldCurCodeDecl;
1844 CGF.CXXABIThisDecl = OldCXXABIThisDecl;
1845 CGF.CXXABIThisValue = OldCXXABIThisValue;
1846 CGF.CXXThisValue = OldCXXThisValue;
1847 CGF.CXXABIThisAlignment = OldCXXABIThisAlignment;
1848 CGF.CXXThisAlignment = OldCXXThisAlignment;
1849 CGF.ReturnValue = OldReturnValue;
1850 CGF.FnRetTy = OldFnRetTy;
1851 CGF.CXXInheritedCtorInitExprArgs =
1852 std::move(OldCXXInheritedCtorInitExprArgs);
1853 }
1854
1855 private:
1856 CodeGenFunction &CGF;
1857 GlobalDecl OldCurGD;
1858 const Decl *OldCurFuncDecl;
1859 const Decl *OldCurCodeDecl;
1860 ImplicitParamDecl *OldCXXABIThisDecl;
1861 llvm::Value *OldCXXABIThisValue;
1862 llvm::Value *OldCXXThisValue;
1863 CharUnits OldCXXABIThisAlignment;
1864 CharUnits OldCXXThisAlignment;
1865 Address OldReturnValue;
1866 QualType OldFnRetTy;
1867 CallArgList OldCXXInheritedCtorInitExprArgs;
1868 };
1869
1870 // Helper class for the OpenMP IR Builder. Allows reusability of code used for
1871 // region body, and finalization codegen callbacks. This will class will also
1872 // contain privatization functions used by the privatization call backs
1873 //
1874 // TODO: this is temporary class for things that are being moved out of
1875 // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or
1876 // utility function for use with the OMPBuilder. Once that move to use the
1877 // OMPBuilder is done, everything here will either become part of CodeGenFunc.
1878 // directly, or a new helper class that will contain functions used by both
1879 // this and the OMPBuilder
1880
1882
1886
1887 using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
1888
1889 /// Cleanup action for allocate support.
1891
1892 private:
1893 llvm::CallInst *RTLFnCI;
1894
1895 public:
1896 OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) {
1897 RLFnCI->removeFromParent();
1898 }
1899
1900 void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
1901 if (!CGF.HaveInsertPoint())
1902 return;
1903 CGF.Builder.Insert(RTLFnCI);
1904 }
1905 };
1906
1907 /// Returns address of the threadprivate variable for the current
1908 /// thread. This Also create any necessary OMP runtime calls.
1909 ///
1910 /// \param VD VarDecl for Threadprivate variable.
1911 /// \param VDAddr Address of the Vardecl
1912 /// \param Loc The location where the barrier directive was encountered
1914 const VarDecl *VD, Address VDAddr,
1916
1917 /// Gets the OpenMP-specific address of the local variable /p VD.
1919 const VarDecl *VD);
1920 /// Get the platform-specific name separator.
1921 /// \param Parts different parts of the final name that needs separation
1922 /// \param FirstSeparator First separator used between the initial two
1923 /// parts of the name.
1924 /// \param Separator separator used between all of the rest consecutinve
1925 /// parts of the name
1926 static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
1927 StringRef FirstSeparator = ".",
1928 StringRef Separator = ".");
1929 /// Emit the Finalization for an OMP region
1930 /// \param CGF The Codegen function this belongs to
1931 /// \param IP Insertion point for generating the finalization code.
1933 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1934 assert(IP.getBlock()->end() != IP.getPoint() &&
1935 "OpenMP IR Builder should cause terminated block!");
1936
1937 llvm::BasicBlock *IPBB = IP.getBlock();
1938 llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1939 assert(DestBB && "Finalization block should have one successor!");
1940
1941 // erase and replace with cleanup branch.
1942 IPBB->getTerminator()->eraseFromParent();
1943 CGF.Builder.SetInsertPoint(IPBB);
1945 CGF.EmitBranchThroughCleanup(Dest);
1946 }
1947
1948 /// Emit the body of an OMP region
1949 /// \param CGF The Codegen function this belongs to
1950 /// \param RegionBodyStmt The body statement for the OpenMP region being
1951 /// generated
1952 /// \param AllocaIP Where to insert alloca instructions
1953 /// \param CodeGenIP Where to insert the region code
1954 /// \param RegionName Name to be used for new blocks
1956 const Stmt *RegionBodyStmt,
1957 InsertPointTy AllocaIP,
1958 InsertPointTy CodeGenIP,
1959 Twine RegionName);
1960
1961 static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP,
1962 llvm::BasicBlock &FiniBB, llvm::Function *Fn,
1964 llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1965 if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1966 CodeGenIPBBTI->eraseFromParent();
1967
1968 CGF.Builder.SetInsertPoint(CodeGenIPBB);
1969
1970 if (Fn->doesNotThrow())
1971 CGF.EmitNounwindRuntimeCall(Fn, Args);
1972 else
1973 CGF.EmitRuntimeCall(Fn, Args);
1974
1975 if (CGF.Builder.saveIP().isSet())
1976 CGF.Builder.CreateBr(&FiniBB);
1977 }
1978
1979 /// Emit the body of an OMP region that will be outlined in
1980 /// OpenMPIRBuilder::finalize().
1981 /// \param CGF The Codegen function this belongs to
1982 /// \param RegionBodyStmt The body statement for the OpenMP region being
1983 /// generated
1984 /// \param AllocaIP Where to insert alloca instructions
1985 /// \param CodeGenIP Where to insert the region code
1986 /// \param RegionName Name to be used for new blocks
1988 const Stmt *RegionBodyStmt,
1989 InsertPointTy AllocaIP,
1990 InsertPointTy CodeGenIP,
1991 Twine RegionName);
1992
1993 /// RAII for preserving necessary info during Outlined region body codegen.
1995
1996 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
1997 CodeGenFunction::JumpDest OldReturnBlock;
1998 CodeGenFunction &CGF;
1999
2000 public:
2002 llvm::BasicBlock &RetBB)
2003 : CGF(cgf) {
2004 assert(AllocaIP.isSet() &&
2005 "Must specify Insertion point for allocas of outlined function");
2006 OldAllocaIP = CGF.AllocaInsertPt;
2007 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2008
2009 OldReturnBlock = CGF.ReturnBlock;
2010 CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB);
2011 }
2012
2014 CGF.AllocaInsertPt = OldAllocaIP;
2015 CGF.ReturnBlock = OldReturnBlock;
2016 }
2017 };
2018
2019 /// RAII for preserving necessary info during inlined region body codegen.
2021
2022 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
2023 CodeGenFunction &CGF;
2024
2025 public:
2027 llvm::BasicBlock &FiniBB)
2028 : CGF(cgf) {
2029 // Alloca insertion block should be in the entry block of the containing
2030 // function so it expects an empty AllocaIP in which case will reuse the
2031 // old alloca insertion point, or a new AllocaIP in the same block as
2032 // the old one
2033 assert((!AllocaIP.isSet() ||
2034 CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
2035 "Insertion point should be in the entry block of containing "
2036 "function!");
2037 OldAllocaIP = CGF.AllocaInsertPt;
2038 if (AllocaIP.isSet())
2039 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2040
2041 // TODO: Remove the call, after making sure the counter is not used by
2042 // the EHStack.
2043 // Since this is an inlined region, it should not modify the
2044 // ReturnBlock, and should reuse the one for the enclosing outlined
2045 // region. So, the JumpDest being return by the function is discarded
2046 (void)CGF.getJumpDestInCurrentScope(&FiniBB);
2047 }
2048
2050 };
2051 };
2052
2053private:
2054 /// CXXThisDecl - When generating code for a C++ member function,
2055 /// this will hold the implicit 'this' declaration.
2056 ImplicitParamDecl *CXXABIThisDecl = nullptr;
2057 llvm::Value *CXXABIThisValue = nullptr;
2058 llvm::Value *CXXThisValue = nullptr;
2059 CharUnits CXXABIThisAlignment;
2060 CharUnits CXXThisAlignment;
2061
2062 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
2063 /// this expression.
2064 Address CXXDefaultInitExprThis = Address::invalid();
2065
2066 /// The current array initialization index when evaluating an
2067 /// ArrayInitIndexExpr within an ArrayInitLoopExpr.
2068 llvm::Value *ArrayInitIndex = nullptr;
2069
2070 /// The values of function arguments to use when evaluating
2071 /// CXXInheritedCtorInitExprs within this context.
2072 CallArgList CXXInheritedCtorInitExprArgs;
2073
2074 /// CXXStructorImplicitParamDecl - When generating code for a constructor or
2075 /// destructor, this will hold the implicit argument (e.g. VTT).
2076 ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr;
2077 llvm::Value *CXXStructorImplicitParamValue = nullptr;
2078
2079 /// OutermostConditional - Points to the outermost active
2080 /// conditional control. This is used so that we know if a
2081 /// temporary should be destroyed conditionally.
2082 ConditionalEvaluation *OutermostConditional = nullptr;
2083
2084 /// The current lexical scope.
2085 LexicalScope *CurLexicalScope = nullptr;
2086
2087 /// The current source location that should be used for exception
2088 /// handling code.
2089 SourceLocation CurEHLocation;
2090
2091 /// BlockByrefInfos - For each __block variable, contains
2092 /// information about the layout of the variable.
2093 llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
2094
2095 /// Used by -fsanitize=nullability-return to determine whether the return
2096 /// value can be checked.
2097 llvm::Value *RetValNullabilityPrecondition = nullptr;
2098
2099 /// Check if -fsanitize=nullability-return instrumentation is required for
2100 /// this function.
2101 bool requiresReturnValueNullabilityCheck() const {
2102 return RetValNullabilityPrecondition;
2103 }
2104
2105 /// Used to store precise source locations for return statements by the
2106 /// runtime return value checks.
2107 Address ReturnLocation = Address::invalid();
2108
2109 /// Check if the return value of this function requires sanitization.
2110 bool requiresReturnValueCheck() const;
2111
2112 bool isInAllocaArgument(CGCXXABI &ABI, QualType Ty);
2113 bool hasInAllocaArg(const CXXMethodDecl *MD);
2114
2115 llvm::BasicBlock *TerminateLandingPad = nullptr;
2116 llvm::BasicBlock *TerminateHandler = nullptr;
2118
2119 /// Terminate funclets keyed by parent funclet pad.
2120 llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
2121
2122 /// Largest vector width used in ths function. Will be used to create a
2123 /// function attribute.
2124 unsigned LargestVectorWidth = 0;
2125
2126 /// True if we need emit the life-time markers. This is initially set in
2127 /// the constructor, but could be overwritten to true if this is a coroutine.
2128 bool ShouldEmitLifetimeMarkers;
2129
2130 /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
2131 /// the function metadata.
2132 void EmitKernelMetadata(const FunctionDecl *FD, llvm::Function *Fn);
2133
2134public:
2135 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
2137
2138 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
2139 ASTContext &getContext() const { return CGM.getContext(); }
2141 if (DisableDebugInfo)
2142 return nullptr;
2143 return DebugInfo;
2144 }
2145 void disableDebugInfo() { DisableDebugInfo = true; }
2146 void enableDebugInfo() { DisableDebugInfo = false; }
2147
2149 return CGM.getCodeGenOpts().OptimizationLevel == 0;
2150 }
2151
2152 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
2153
2154 /// Returns a pointer to the function's exception object and selector slot,
2155 /// which is assigned in every landing pad.
2158
2159 /// Returns the contents of the function's exception object and selector
2160 /// slots.
2161 llvm::Value *getExceptionFromSlot();
2162 llvm::Value *getSelectorFromSlot();
2163
2165
2166 llvm::BasicBlock *getUnreachableBlock() {
2167 if (!UnreachableBlock) {
2168 UnreachableBlock = createBasicBlock("unreachable");
2169 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
2170 }
2171 return UnreachableBlock;
2172 }
2173
2174 llvm::BasicBlock *getInvokeDest() {
2175 if (!EHStack.requiresLandingPad()) return nullptr;
2176 return getInvokeDestImpl();
2177 }
2178
2179 bool currentFunctionUsesSEHTry() const { return !!CurSEHParent; }
2180
2181 const TargetInfo &getTarget() const { return Target; }
2182 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
2184 return CGM.getTargetCodeGenInfo();
2185 }
2186
2187 //===--------------------------------------------------------------------===//
2188 // Cleanups
2189 //===--------------------------------------------------------------------===//
2190
2191 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
2192
2193 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
2194 Address arrayEndPointer,
2195 QualType elementType,
2196 CharUnits elementAlignment,
2197 Destroyer *destroyer);
2198 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
2199 llvm::Value *arrayEnd,
2200 QualType elementType,
2201 CharUnits elementAlignment,
2202 Destroyer *destroyer);
2203
2205 Address addr, QualType type);
2207 Address addr, QualType type);
2209 Destroyer *destroyer, bool useEHCleanupForArray);
2211 Address addr, QualType type);
2213 QualType type, Destroyer *destroyer,
2214 bool useEHCleanupForArray);
2216 QualType type, Destroyer *destroyer,
2217 bool useEHCleanupForArray);
2218 void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
2219 llvm::Value *CompletePtr,
2220 QualType ElementType);
2223 std::pair<llvm::Value *, llvm::Value *> AddrSizePair);
2225 bool useEHCleanupForArray);
2227 Destroyer *destroyer,
2228 bool useEHCleanupForArray,
2229 const VarDecl *VD);
2230 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
2231 QualType elementType, CharUnits elementAlign,
2232 Destroyer *destroyer,
2233 bool checkZeroLength, bool useEHCleanup);
2234
2236
2237 /// Determines whether an EH cleanup is required to destroy a type
2238 /// with the given destruction kind.
2240 switch (kind) {
2241 case QualType::DK_none:
2242 return false;
2246 return getLangOpts().Exceptions;
2248 return getLangOpts().Exceptions &&
2249 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
2250 }
2251 llvm_unreachable("bad destruction kind");
2252 }
2253
2256 }
2257
2258 //===--------------------------------------------------------------------===//
2259 // Objective-C
2260 //===--------------------------------------------------------------------===//
2261
2263
2265
2266 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2268 const ObjCPropertyImplDecl *PID);
2270 const ObjCPropertyImplDecl *propImpl,
2271 const ObjCMethodDecl *GetterMothodDecl,
2272 llvm::Constant *AtomicHelperFn);
2273
2275 ObjCMethodDecl *MD, bool ctor);
2276
2277 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2278 /// for the given property.
2280 const ObjCPropertyImplDecl *PID);
2282 const ObjCPropertyImplDecl *propImpl,
2283 llvm::Constant *AtomicHelperFn);
2284
2285 //===--------------------------------------------------------------------===//
2286 // Block Bits
2287 //===--------------------------------------------------------------------===//
2288
2289 /// Emit block literal.
2290 /// \return an LLVM value which is a pointer to a struct which contains
2291 /// information about the block, including the block invoke function, the
2292 /// captured variables, etc.
2293 llvm::Value *EmitBlockLiteral(const BlockExpr *);
2294
2296 const CGBlockInfo &Info,
2297 const DeclMapTy &ldm,
2298 bool IsLambdaConversionToBlock,
2299 bool BuildGlobalBlock);
2300
2301 /// Check if \p T is a C++ class that has a destructor that can throw.
2303
2304 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
2305 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
2307 const ObjCPropertyImplDecl *PID);
2309 const ObjCPropertyImplDecl *PID);
2310 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
2311
2312 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
2313 bool CanThrow);
2314
2315 class AutoVarEmission;
2316
2318
2319 /// Enter a cleanup to destroy a __block variable. Note that this
2320 /// cleanup should be a no-op if the variable hasn't left the stack
2321 /// yet; if a cleanup is required for the variable itself, that needs
2322 /// to be done externally.
2323 ///
2324 /// \param Kind Cleanup kind.
2325 ///
2326 /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block
2327 /// structure that will be passed to _Block_object_dispose. When
2328 /// \p LoadBlockVarAddr is true, the address of the field of the block
2329 /// structure that holds the address of the __block structure.
2330 ///
2331 /// \param Flags The flag that will be passed to _Block_object_dispose.
2332 ///
2333 /// \param LoadBlockVarAddr Indicates whether we need to emit a load from
2334 /// \p Addr to get the address of the __block structure.
2336 bool LoadBlockVarAddr, bool CanThrow);
2337
2338 void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum,
2339 llvm::Value *ptr);
2340
2343
2344 /// BuildBlockByrefAddress - Computes the location of the
2345 /// data in a variable which is declared as __block.
2347 bool followForward = true);
2349 const BlockByrefInfo &info,
2350 bool followForward,
2351 const llvm::Twine &name);
2352
2354
2356
2357 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
2358 const CGFunctionInfo &FnInfo);
2359
2360 /// Annotate the function with an attribute that disables TSan checking at
2361 /// runtime.
2362 void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
2363
2364 /// Emit code for the start of a function.
2365 /// \param Loc The location to be associated with the function.
2366 /// \param StartLoc The location of the function body.
2368 QualType RetTy,
2369 llvm::Function *Fn,
2370 const CGFunctionInfo &FnInfo,
2371 const FunctionArgList &Args,
2373 SourceLocation StartLoc = SourceLocation());
2374
2376
2380 void EmitFunctionBody(const Stmt *Body);
2381 void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2382
2383 void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator,
2384 CallArgList &CallArgs,
2385 const CGFunctionInfo *CallOpFnInfo = nullptr,
2386 llvm::Constant *CallOpFn = nullptr);
2390 CallArgList &CallArgs);
2392 const CGFunctionInfo **ImplFnInfo,
2393 llvm::Function **ImplFn);
2396 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2397 }
2398 void EmitAsanPrologueOrEpilogue(bool Prologue);
2399
2400 /// Emit the unified return block, trying to avoid its emission when
2401 /// possible.
2402 /// \return The debug location of the user written return statement if the
2403 /// return block is avoided.
2404 llvm::DebugLoc EmitReturnBlock();
2405
2406 /// FinishFunction - Complete IR generation of the current function. It is
2407 /// legal to call this function even if there is no current insertion point.
2409
2410 void StartThunk(llvm::Function *Fn, GlobalDecl GD,
2411 const CGFunctionInfo &FnInfo, bool IsUnprototyped);
2412
2413 void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
2414 const ThunkInfo *Thunk, bool IsUnprototyped);
2415
2417
2418 /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
2419 void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
2420 llvm::FunctionCallee Callee);
2421
2422 /// Generate a thunk for the given method.
2423 void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
2424 GlobalDecl GD, const ThunkInfo &Thunk,
2425 bool IsUnprototyped);
2426
2427 llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
2428 const CGFunctionInfo &FnInfo,
2429 GlobalDecl GD, const ThunkInfo &Thunk);
2430
2432 FunctionArgList &Args);
2433
2435
2436 /// Struct with all information about dynamic [sub]class needed to set vptr.
2437 struct VPtr {
2442 };
2443
2444 /// Initialize the vtable pointer of the given subobject.
2446
2448
2451
2453 CharUnits OffsetFromNearestVBase,
2454 bool BaseIsNonVirtualPrimaryBase,
2455 const CXXRecordDecl *VTableClass,
2456 VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs);
2457
2459
2460 // VTableTrapMode - whether we guarantee that loading the
2461 // vtable is guaranteed to trap on authentication failure,
2462 // even if the resulting vtable pointer is unused.
2463 enum class VTableAuthMode {
2465 MustTrap,
2466 UnsafeUbsanStrip // Should only be used for Vptr UBSan check
2467 };
2468 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2469 /// to by This.
2470 llvm::Value *
2471 GetVTablePtr(Address This, llvm::Type *VTableTy,
2472 const CXXRecordDecl *VTableClass,
2474
2483 };
2484
2485 /// Derived is the presumed address of an object of type T after a
2486 /// cast. If T is a polymorphic class type, emit a check that the virtual
2487 /// table for Derived belongs to a class derived from T.
2488 void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull,
2490
2491 /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2492 /// If vptr CFI is enabled, emit a check that VTable is valid.
2493 void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable,
2495
2496 /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2497 /// RD using llvm.type.test.
2498 void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable,
2500
2501 /// If whole-program virtual table optimization is enabled, emit an assumption
2502 /// that VTable is a member of RD's type identifier. Or, if vptr CFI is
2503 /// enabled, emit a check that VTable is a member of RD's type identifier.
2505 llvm::Value *VTable, SourceLocation Loc);
2506
2507 /// Returns whether we should perform a type checked load when loading a
2508 /// virtual function for virtual calls to members of RD. This is generally
2509 /// true when both vcall CFI and whole-program-vtables are enabled.
2511
2512 /// Emit a type checked load from the given vtable.
2514 llvm::Value *VTable,
2515 llvm::Type *VTableTy,
2516 uint64_t VTableByteOffset);
2517
2518 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2519 /// given phase of destruction for a destructor. The end result
2520 /// should call destructors on members and base classes in reverse
2521 /// order of their construction.
2523
2524 /// ShouldInstrumentFunction - Return true if the current function should be
2525 /// instrumented with __cyg_profile_func_* calls
2527
2528 /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2529 /// should not be instrumented with sanitizers.
2531
2532 /// ShouldXRayInstrument - Return true if the current function should be
2533 /// instrumented with XRay nop sleds.
2535
2536 /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2537 /// XRay custom event handling calls.
2539
2540 /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2541 /// XRay typed event handling calls.
2543
2544 /// Return a type hash constant for a function instrumented by
2545 /// -fsanitize=function.
2546 llvm::ConstantInt *getUBSanFunctionTypeHash(QualType T) const;
2547
2548 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2549 /// arguments for the given function. This is also responsible for naming the
2550 /// LLVM function arguments.
2552 llvm::Function *Fn,
2553 const FunctionArgList &Args);
2554
2555 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2556 /// given temporary.
2557 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc,
2558 SourceLocation EndLoc);
2559
2560 /// Emit a test that checks if the return value \p RV is nonnull.
2561 void EmitReturnValueCheck(llvm::Value *RV);
2562
2563 /// EmitStartEHSpec - Emit the start of the exception spec.
2564 void EmitStartEHSpec(const Decl *D);
2565
2566 /// EmitEndEHSpec - Emit the end of the exception spec.
2567 void EmitEndEHSpec(const Decl *D);
2568
2569 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2570 llvm::BasicBlock *getTerminateLandingPad();
2571
2572 /// getTerminateLandingPad - Return a cleanup funclet that just calls
2573 /// terminate.
2574 llvm::BasicBlock *getTerminateFunclet();
2575
2576 /// getTerminateHandler - Return a handler (not a landing pad, just
2577 /// a catch handler) that just calls terminate. This is used when
2578 /// a terminate scope encloses a try.
2579 llvm::BasicBlock *getTerminateHandler();
2580
2582 llvm::Type *ConvertType(QualType T);
2584 llvm::Type *LLVMTy = nullptr);
2585 llvm::Type *ConvertType(const TypeDecl *T) {
2586 return ConvertType(getContext().getTypeDeclType(T));
2587 }
2588
2589 /// LoadObjCSelf - Load the value of self. This function is only valid while
2590 /// generating code for an Objective-C method.
2591 llvm::Value *LoadObjCSelf();
2592
2593 /// TypeOfSelfObject - Return type of object that this self represents.
2595
2596 /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2598
2600 return getEvaluationKind(T) == TEK_Scalar;
2601 }
2602
2605 }
2606
2607 /// createBasicBlock - Create an LLVM basic block.
2608 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
2609 llvm::Function *parent = nullptr,
2610 llvm::BasicBlock *before = nullptr) {
2611 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
2612 }
2613
2614 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2615 /// label maps to.
2617
2618 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2619 /// another basic block, simplify it. This assumes that no other code could
2620 /// potentially reference the basic block.
2621 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
2622
2623 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2624 /// adding a fall-through branch from the current insert block if
2625 /// necessary. It is legal to call this function even if there is no current
2626 /// insertion point.
2627 ///
2628 /// IsFinished - If true, indicates that the caller has finished emitting
2629 /// branches to the given block and does not expect to emit code into it. This
2630 /// means the block can be ignored if it is unreachable.
2631 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
2632
2633 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2634 /// near its uses, and leave the insertion point in it.
2635 void EmitBlockAfterUses(llvm::BasicBlock *BB);
2636
2637 /// EmitBranch - Emit a branch to the specified basic block from the current
2638 /// insert block, taking care to avoid creation of branches from dummy
2639 /// blocks. It is legal to call this function even if there is no current
2640 /// insertion point.
2641 ///
2642 /// This function clears the current insertion point. The caller should follow
2643 /// calls to this function with calls to Emit*Block prior to generation new
2644 /// code.
2645 void EmitBranch(llvm::BasicBlock *Block);
2646
2647 /// HaveInsertPoint - True if an insertion point is defined. If not, this
2648 /// indicates that the current code being emitted is unreachable.
2649 bool HaveInsertPoint() const {
2650 return Builder.GetInsertBlock() != nullptr;
2651 }
2652
2653 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2654 /// emitted IR has a place to go. Note that by definition, if this function
2655 /// creates a block then that block is unreachable; callers may do better to
2656 /// detect when no insertion point is defined and simply skip IR generation.
2658 if (!HaveInsertPoint())
2660 }
2661
2662 /// ErrorUnsupported - Print out an error that codegen doesn't support the
2663 /// specified stmt yet.
2664 void ErrorUnsupported(const Stmt *S, const char *Type);
2665
2666 //===--------------------------------------------------------------------===//
2667 // Helpers
2668 //===--------------------------------------------------------------------===//
2669
2671 llvm::BasicBlock *LHSBlock,
2672 llvm::BasicBlock *RHSBlock,
2673 llvm::BasicBlock *MergeBlock,
2674 QualType MergedType) {
2675 Builder.SetInsertPoint(MergeBlock);
2676 llvm::PHINode *PtrPhi = Builder.CreatePHI(LHS.getType(), 2, "cond");
2677 PtrPhi->addIncoming(LHS.getBasePointer(), LHSBlock);
2678 PtrPhi->addIncoming(RHS.getBasePointer(), RHSBlock);
2679 LHS.replaceBasePointer(PtrPhi);
2680 LHS.setAlignment(std::min(LHS.getAlignment(), RHS.getAlignment()));
2681 return LHS;
2682 }
2683
2684 /// Construct an address with the natural alignment of T. If a pointer to T
2685 /// is expected to be signed, the pointer passed to this function must have
2686 /// been signed, and the returned Address will have the pointer authentication
2687 /// information needed to authenticate the signed pointer.
2689 llvm::Value *Ptr, QualType T, CharUnits Alignment = CharUnits::Zero(),
2690 bool ForPointeeType = false, LValueBaseInfo *BaseInfo = nullptr,
2691 TBAAAccessInfo *TBAAInfo = nullptr,
2692 KnownNonNull_t IsKnownNonNull = NotKnownNonNull) {
2693 if (Alignment.isZero())
2694 Alignment =
2695 CGM.getNaturalTypeAlignment(T, BaseInfo, TBAAInfo, ForPointeeType);
2696 return Address(Ptr, ConvertTypeForMem(T), Alignment,
2697 CGM.getPointerAuthInfoForPointeeType(T), /*Offset=*/nullptr,
2698 IsKnownNonNull);
2699 }
2700
2703 return MakeAddrLValue(Addr, T, LValueBaseInfo(Source),
2705 }
2706
2708 TBAAAccessInfo TBAAInfo) {
2709 return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2710 }
2711
2712 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2714 return MakeAddrLValue(makeNaturalAddressForPointer(V, T, Alignment), T,
2716 }
2717
2718 /// Same as MakeAddrLValue above except that the pointer is known to be
2719 /// unsigned.
2720 LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2722 Address Addr(V, ConvertTypeForMem(T), Alignment);
2723 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2725 }
2726
2727 LValue
2730 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2731 TBAAAccessInfo());
2732 }
2733
2734 /// Given a value of type T* that may not be to a complete object, construct
2735 /// an l-value with the natural pointee alignment of T.
2737
2738 LValue
2740 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
2741
2742 /// Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known
2743 /// to be unsigned.
2745
2747
2749 LValueBaseInfo *PointeeBaseInfo = nullptr,
2750 TBAAAccessInfo *PointeeTBAAInfo = nullptr);
2753 AlignmentSource Source =
2755 LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2756 CGM.getTBAAAccessInfo(RefTy));
2757 return EmitLoadOfReferenceLValue(RefLVal);
2758 }
2759
2760 /// Load a pointer with type \p PtrTy stored at address \p Ptr.
2761 /// Note that \p PtrTy is the type of the loaded pointer, not the addresses
2762 /// it is loaded from.
2764 LValueBaseInfo *BaseInfo = nullptr,
2765 TBAAAccessInfo *TBAAInfo = nullptr);
2767
2768private:
2769 struct AllocaTracker {
2770 void Add(llvm::AllocaInst *I) { Allocas.push_back(I); }
2771 llvm::SmallVector<llvm::AllocaInst *> Take() { return std::move(Allocas); }
2772
2773 private:
2775 };
2776 AllocaTracker *Allocas = nullptr;
2777
2778public:
2779 // Captures all the allocas created during the scope of its RAII object.
2782 : CGF(CGF), OldTracker(CGF.Allocas) {
2783 CGF.Allocas = &Tracker;
2784 }
2785 ~AllocaTrackerRAII() { CGF.Allocas = OldTracker; }
2786
2787 llvm::SmallVector<llvm::AllocaInst *> Take() { return Tracker.Take(); }
2788
2789 private:
2790 CodeGenFunction &CGF;
2791 AllocaTracker *OldTracker;
2792 AllocaTracker Tracker;
2793 };
2794
2795 /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2796 /// block if \p ArraySize is nullptr, otherwise inserts it at the current
2797 /// insertion point of the builder. The caller is responsible for setting an
2798 /// appropriate alignment on
2799 /// the alloca.
2800 ///
2801 /// \p ArraySize is the number of array elements to be allocated if it
2802 /// is not nullptr.
2803 ///
2804 /// LangAS::Default is the address space of pointers to local variables and
2805 /// temporaries, as exposed in the source language. In certain
2806 /// configurations, this is not the same as the alloca address space, and a
2807 /// cast is needed to lift the pointer from the alloca AS into
2808 /// LangAS::Default. This can happen when the target uses a restricted
2809 /// address space for the stack but the source language requires
2810 /// LangAS::Default to be a generic address space. The latter condition is
2811 /// common for most programming languages; OpenCL is an exception in that
2812 /// LangAS::Default is the private address space, which naturally maps
2813 /// to the stack.
2814 ///
2815 /// Because the address of a temporary is often exposed to the program in
2816 /// various ways, this function will perform the cast. The original alloca
2817 /// instruction is returned through \p Alloca if it is not nullptr.
2818 ///
2819 /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2820 /// more efficient if the caller knows that the address will not be exposed.
2821 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2822 llvm::Value *ArraySize = nullptr);
2824 const Twine &Name = "tmp",
2825 llvm::Value *ArraySize = nullptr,
2826 RawAddress *Alloca = nullptr);
2828 const Twine &Name = "tmp",
2829 llvm::Value *ArraySize = nullptr);
2830
2831 /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2832 /// default ABI alignment of the given LLVM type.
2833 ///
2834 /// IMPORTANT NOTE: This is *not* generally the right alignment for
2835 /// any given AST type that happens to have been lowered to the
2836 /// given IR type. This should only ever be used for function-local,
2837 /// IR-driven manipulations like saving and restoring a value. Do
2838 /// not hand this address off to arbitrary IRGen routines, and especially
2839 /// do not pass it as an argument to a function that might expect a
2840 /// properly ABI-aligned value.
2842 const Twine &Name = "tmp");
2843
2844 /// CreateIRTemp - Create a temporary IR object of the given type, with
2845 /// appropriate alignment. This routine should only be used when an temporary
2846 /// value needs to be stored into an alloca (for example, to avoid explicit
2847 /// PHI construction), but the type is the IR type, not the type appropriate
2848 /// for storing in memory.
2849 ///
2850 /// That is, this is exactly equivalent to CreateMemTemp, but calling
2851 /// ConvertType instead of ConvertTypeForMem.
2852 RawAddress CreateIRTemp(QualType T, const Twine &Name = "tmp");
2853
2854 /// CreateMemTemp - Create a temporary memory object of the given type, with
2855 /// appropriate alignmen and cast it to the default address space. Returns
2856 /// the original alloca instruction by \p Alloca if it is not nullptr.
2857 RawAddress CreateMemTemp(QualType T, const Twine &Name = "tmp",
2858 RawAddress *Alloca = nullptr);
2860 const Twine &Name = "tmp",
2861 RawAddress *Alloca = nullptr);
2862
2863 /// CreateMemTemp - Create a temporary memory object of the given type, with
2864 /// appropriate alignmen without casting it to the default address space.
2865 RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2867 const Twine &Name = "tmp");
2868
2869 /// CreateAggTemp - Create a temporary memory object for the given
2870 /// aggregate type.
2871 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp",
2872 RawAddress *Alloca = nullptr) {
2873 return AggValueSlot::forAddr(
2874 CreateMemTemp(T, Name, Alloca), T.getQualifiers(),
2877 }
2878
2879 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2880 /// expression and compare the result against zero, returning an Int1Ty value.
2881 llvm::Value *EvaluateExprAsBool(const Expr *E);
2882
2883 /// Retrieve the implicit cast expression of the rhs in a binary operator
2884 /// expression by passing pointers to Value and QualType
2885 /// This is used for implicit bitfield conversion checks, which
2886 /// must compare with the value before potential truncation.
2888 llvm::Value **Previous,
2889 QualType *SrcType);
2890
2891 /// Emit a check that an [implicit] conversion of a bitfield. It is not UB,
2892 /// so we use the value after conversion.
2893 void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType,
2894 llvm::Value *Dst, QualType DstType,
2895 const CGBitFieldInfo &Info,
2897
2898 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
2899 void EmitIgnoredExpr(const Expr *E);
2900
2901 /// EmitAnyExpr - Emit code to compute the specified expression which can have
2902 /// any type. The result is returned as an RValue struct. If this is an
2903 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
2904 /// the result should be returned.
2905 ///
2906 /// \param ignoreResult True if the resulting value isn't used.
2909 bool ignoreResult = false);
2910
2911 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2912 // or the value of the expression, depending on how va_list is defined.
2914
2915 /// Emit a "reference" to a __builtin_ms_va_list; this is
2916 /// always the value of the expression, because a __builtin_ms_va_list is a
2917 /// pointer to a char.
2919
2920 /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2921 /// always be accessible even if no aggregate location is provided.
2923
2924 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2925 /// arbitrary expression into the given memory location.
2926 void EmitAnyExprToMem(const Expr *E, Address Location,
2927 Qualifiers Quals, bool IsInitializer);
2928
2929 void EmitAnyExprToExn(const Expr *E, Address Addr);
2930
2931 /// EmitInitializationToLValue - Emit an initializer to an LValue.
2933 const Expr *E, LValue LV,
2935
2936 /// EmitExprAsInit - Emits the code necessary to initialize a
2937 /// location in memory with the given initializer.
2938 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2939 bool capturedByInit);
2940
2941 /// hasVolatileMember - returns true if aggregate type has a volatile
2942 /// member.
2944 if (const RecordType *RT = T->getAs<RecordType>()) {
2945 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2946 return RD->hasVolatileMember();
2947 }
2948 return false;
2949 }
2950
2951 /// Determine whether a return value slot may overlap some other object.
2953 // FIXME: Assuming no overlap here breaks guaranteed copy elision for base
2954 // class subobjects. These cases may need to be revisited depending on the
2955 // resolution of the relevant core issue.
2957 }
2958
2959 /// Determine whether a field initialization may overlap some other object.
2961
2962 /// Determine whether a base class initialization may overlap some other
2963 /// object.
2965 const CXXRecordDecl *BaseRD,
2966 bool IsVirtual);
2967
2968 /// Emit an aggregate assignment.
2970 bool IsVolatile = hasVolatileMember(EltTy);
2971 EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile);
2972 }
2973
2975 AggValueSlot::Overlap_t MayOverlap) {
2976 EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap);
2977 }
2978
2979 /// EmitAggregateCopy - Emit an aggregate copy.
2980 ///
2981 /// \param isVolatile \c true iff either the source or the destination is
2982 /// volatile.
2983 /// \param MayOverlap Whether the tail padding of the destination might be
2984 /// occupied by some other object. More efficient code can often be
2985 /// generated if not.
2987 AggValueSlot::Overlap_t MayOverlap,
2988 bool isVolatile = false);
2989
2990 /// GetAddrOfLocalVar - Return the address of a local variable.
2992 auto it = LocalDeclMap.find(VD);
2993 assert(it != LocalDeclMap.end() &&
2994 "Invalid argument to GetAddrOfLocalVar(), no decl!");
2995 return it->second;
2996 }
2997
2998 /// Given an opaque value expression, return its LValue mapping if it exists,
2999 /// otherwise create one.
3001
3002 /// Given an opaque value expression, return its RValue mapping if it exists,
3003 /// otherwise create one.
3005
3006 /// Get the index of the current ArrayInitLoopExpr, if any.
3007 llvm::Value *getArrayInitIndex() { return ArrayInitIndex; }
3008
3009 /// getAccessedFieldNo - Given an encoded value and a result number, return
3010 /// the input field number being accessed.
3011 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
3012
3013 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
3014 llvm::BasicBlock *GetIndirectGotoBlock();
3015
3016 /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
3017 static bool IsWrappedCXXThis(const Expr *E);
3018
3019 /// EmitNullInitialization - Generate code to set a value of the given type to
3020 /// null, If the type contains data member pointers, they will be initialized
3021 /// to -1 in accordance with the Itanium C++ ABI.
3023
3024 /// Emits a call to an LLVM variable-argument intrinsic, either
3025 /// \c llvm.va_start or \c llvm.va_end.
3026 /// \param ArgValue A reference to the \c va_list as emitted by either
3027 /// \c EmitVAListRef or \c EmitMSVAListRef.
3028 /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise,
3029 /// calls \c llvm.va_end.
3030 llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart);
3031
3032 /// Generate code to get an argument from the passed in pointer
3033 /// and update it accordingly.
3034 /// \param VE The \c VAArgExpr for which to generate code.
3035 /// \param VAListAddr Receives a reference to the \c va_list as emitted by
3036 /// either \c EmitVAListRef or \c EmitMSVAListRef.
3037 /// \returns A pointer to the argument.
3038 // FIXME: We should be able to get rid of this method and use the va_arg
3039 // instruction in LLVM instead once it works well enough.
3042
3043 /// emitArrayLength - Compute the length of an array, even if it's a
3044 /// VLA, and drill down to the base element type.
3046 QualType &baseType,
3047 Address &addr);
3048
3049 /// EmitVLASize - Capture all the sizes for the VLA expressions in
3050 /// the given variably-modified type and store them in the VLASizeMap.
3051 ///
3052 /// This function can be called with a null (unreachable) insert point.
3054
3056 llvm::Value *NumElts;
3058
3059 VlaSizePair(llvm::Value *NE, QualType T) : NumElts(NE), Type(T) {}
3060 };
3061
3062 /// Return the number of elements for a single dimension
3063 /// for the given array type.
3066
3067 /// Returns an LLVM value that corresponds to the size,
3068 /// in non-variably-sized elements, of a variable length array type,
3069 /// plus that largest non-variably-sized element type. Assumes that
3070 /// the type has already been emitted with EmitVariablyModifiedType.
3073
3074 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
3075 /// generating code for an C++ member function.
3076 llvm::Value *LoadCXXThis() {
3077 assert(CXXThisValue && "no 'this' value for this function");
3078 return CXXThisValue;
3079 }
3081
3082 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
3083 /// virtual bases.
3084 // FIXME: Every place that calls LoadCXXVTT is something
3085 // that needs to be abstracted properly.
3086 llvm::Value *LoadCXXVTT() {
3087 assert(CXXStructorImplicitParamValue && "no VTT value for this function");
3088 return CXXStructorImplicitParamValue;
3089 }
3090
3091 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
3092 /// complete class to the given direct base.
3093 Address
3095 const CXXRecordDecl *Derived,
3096 const CXXRecordDecl *Base,
3097 bool BaseIsVirtual);
3098
3099 static bool ShouldNullCheckClassCastValue(const CastExpr *Cast);
3100
3101 /// GetAddressOfBaseClass - This function will add the necessary delta to the
3102 /// load of 'this' and returns address of the base class.
3104 const CXXRecordDecl *Derived,
3107 bool NullCheckValue, SourceLocation Loc);
3108
3110 const CXXRecordDecl *Derived,
3113 bool NullCheckValue);
3114
3115 /// GetVTTParameter - Return the VTT parameter that should be passed to a
3116 /// base constructor/destructor with virtual bases.
3117 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
3118 /// to ItaniumCXXABI.cpp together with all the references to VTT.
3119 llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
3120 bool Delegating);
3121
3123 CXXCtorType CtorType,
3124 const FunctionArgList &Args,
3126 // It's important not to confuse this and the previous function. Delegating
3127 // constructors are the C++0x feature. The constructor delegate optimization
3128 // is used to reduce duplication in the base and complete consturctors where
3129 // they are substantially the same.
3131 const FunctionArgList &Args);
3132
3133 /// Emit a call to an inheriting constructor (that is, one that invokes a
3134 /// constructor inherited from a base class) by inlining its definition. This
3135 /// is necessary if the ABI does not support forwarding the arguments to the
3136 /// base class constructor (because they're variadic or similar).
3138 CXXCtorType CtorType,
3139 bool ForVirtualBase,
3140 bool Delegating,
3141 CallArgList &Args);
3142
3143 /// Emit a call to a constructor inherited from a base class, passing the
3144 /// current constructor's arguments along unmodified (without even making
3145 /// a copy).
3147 bool ForVirtualBase, Address This,
3148 bool InheritedFromVBase,
3150
3152 bool ForVirtualBase, bool Delegating,
3153 AggValueSlot ThisAVS, const CXXConstructExpr *E);
3154
3156 bool ForVirtualBase, bool Delegating,
3157 Address This, CallArgList &Args,
3159 SourceLocation Loc, bool NewPointerIsChecked,
3160 llvm::CallBase **CallOrInvoke = nullptr);
3161
3162 /// Emit assumption load for all bases. Requires to be called only on
3163 /// most-derived class and not under construction of the object.
3165
3166 /// Emit assumption that vptr load == global vtable.
3167 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
3168
3170 Address This, Address Src,
3171 const CXXConstructExpr *E);
3172
3174 const ArrayType *ArrayTy,
3175 Address ArrayPtr,
3176 const CXXConstructExpr *E,
3177 bool NewPointerIsChecked,
3178 bool ZeroInitialization = false);
3179
3181 llvm::Value *NumElements,
3182 Address ArrayPtr,
3183 const CXXConstructExpr *E,
3184 bool NewPointerIsChecked,
3185 bool ZeroInitialization = false);
3186
3188
3190 bool ForVirtualBase, bool Delegating, Address This,
3191 QualType ThisTy);
3192
3194 llvm::Type *ElementTy, Address NewPtr,
3195 llvm::Value *NumElements,
3196 llvm::Value *AllocSizeWithoutCookie);
3197
3198 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
3199 Address Ptr);
3200
3205
3206 llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr);
3207 void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
3208
3209 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
3211
3212 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
3213 QualType DeleteTy, llvm::Value *NumElements = nullptr,
3214 CharUnits CookieSize = CharUnits());
3215
3217 const CallExpr *TheCallExpr, bool IsDelete);
3218
3219 llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E);
3220 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
3222
3223 /// Situations in which we might emit a check for the suitability of a
3224 /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
3225 /// compiler-rt.
3227 /// Checking the operand of a load. Must be suitably sized and aligned.
3229 /// Checking the destination of a store. Must be suitably sized and aligned.
3231 /// Checking the bound value in a reference binding. Must be suitably sized
3232 /// and aligned, but is not required to refer to an object (until the
3233 /// reference is used), per core issue 453.
3235 /// Checking the object expression in a non-static data member access. Must
3236 /// be an object within its lifetime.
3238 /// Checking the 'this' pointer for a call to a non-static member function.
3239 /// Must be an object within its lifetime.
3241 /// Checking the 'this' pointer for a constructor call.
3243 /// Checking the operand of a static_cast to a derived pointer type. Must be
3244 /// null or an object within its lifetime.
3246 /// Checking the operand of a static_cast to a derived reference type. Must
3247 /// be an object within its lifetime.
3249 /// Checking the operand of a cast to a base object. Must be suitably sized
3250 /// and aligned.
3252 /// Checking the operand of a cast to a virtual base object. Must be an
3253 /// object within its lifetime.
3255 /// Checking the value assigned to a _Nonnull pointer. Must not be null.
3257 /// Checking the operand of a dynamic_cast or a typeid expression. Must be
3258 /// null or an object within its lifetime.
3261
3262 /// Determine whether the pointer type check \p TCK permits null pointers.
3264
3265 /// Determine whether the pointer type check \p TCK requires a vptr check.
3267
3268 /// Whether any type-checking sanitizers are enabled. If \c false,
3269 /// calls to EmitTypeCheck can be skipped.
3271
3273 QualType Type, SanitizerSet SkippedChecks = SanitizerSet(),
3274 llvm::Value *ArraySize = nullptr) {
3276 return;
3277 EmitTypeCheck(TCK, Loc, LV.emitRawPointer(*this), Type, LV.getAlignment(),
3278 SkippedChecks, ArraySize);
3279 }
3280
3282 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3283 SanitizerSet SkippedChecks = SanitizerSet(),
3284 llvm::Value *ArraySize = nullptr) {
3286 return;
3287 EmitTypeCheck(TCK, Loc, Addr.emitRawPointer(*this), Type, Alignment,
3288 SkippedChecks, ArraySize);
3289 }
3290
3291 /// Emit a check that \p V is the address of storage of the
3292 /// appropriate size and alignment for an object of type \p Type
3293 /// (or if ArraySize is provided, for an array of that bound).
3295 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3296 SanitizerSet SkippedChecks = SanitizerSet(),
3297 llvm::Value *ArraySize = nullptr);
3298
3299 /// Emit a check that \p Base points into an array object, which
3300 /// we can access at index \p Index. \p Accessed should be \c false if we
3301 /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
3302 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
3303 QualType IndexType, bool Accessed);
3304 void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound,
3305 llvm::Value *Index, QualType IndexType,
3306 QualType IndexedType, bool Accessed);
3307
3308 // Find a struct's flexible array member and get its offset. It may be
3309 // embedded inside multiple sub-structs, but must still be the last field.
3310 const FieldDecl *
3312 const FieldDecl *FAMDecl,
3313 uint64_t &Offset);
3314
3316 const FieldDecl *FAMDecl,
3317 const FieldDecl *CountDecl);
3318
3319 /// Build an expression accessing the "counted_by" field.
3321 const FieldDecl *FAMDecl,
3322 const FieldDecl *CountDecl);
3323
3325 bool isInc, bool isPre);
3327 bool isInc, bool isPre);
3328
3329 /// Converts Location to a DebugLoc, if debug information is enabled.
3330 llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location);
3331
3332 /// Get the record field index as represented in debug info.
3333 unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex);
3334
3335
3336 //===--------------------------------------------------------------------===//
3337 // Declaration Emission
3338 //===--------------------------------------------------------------------===//
3339
3340 /// EmitDecl - Emit a declaration.
3341 ///
3342 /// This function can be called with a null (unreachable) insert point.
3343 void EmitDecl(const Decl &D);
3344
3345 /// EmitVarDecl - Emit a local variable declaration.
3346 ///
3347 /// This function can be called with a null (unreachable) insert point.
3348 void EmitVarDecl(const VarDecl &D);
3349
3350 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
3351 bool capturedByInit);
3352
3354 llvm::Value *Address);
3355
3356 /// Determine whether the given initializer is trivial in the sense
3357 /// that it requires no code to be generated.
3359
3360 /// EmitAutoVarDecl - Emit an auto variable declaration.
3361 ///
3362 /// This function can be called with a null (unreachable) insert point.
3364
3366 friend class CodeGenFunction;
3367
3368 const VarDecl *Variable;
3369
3370 /// The address of the alloca for languages with explicit address space
3371 /// (e.g. OpenCL) or alloca casted to generic pointer for address space
3372 /// agnostic languages (e.g. C++). Invalid if the variable was emitted
3373 /// as a global constant.
3374 Address Addr;
3375
3376 llvm::Value *NRVOFlag;
3377
3378 /// True if the variable is a __block variable that is captured by an
3379 /// escaping block.
3380 bool IsEscapingByRef;
3381
3382 /// True if the variable is of aggregate type and has a constant
3383 /// initializer.
3384 bool IsConstantAggregate;
3385
3386 /// Non-null if we should use lifetime annotations.
3387 llvm::Value *SizeForLifetimeMarkers;
3388
3389 /// Address with original alloca instruction. Invalid if the variable was
3390 /// emitted as a global constant.
3391 RawAddress AllocaAddr;
3392
3393 struct Invalid {};
3394 AutoVarEmission(Invalid)
3395 : Variable(nullptr), Addr(Address::invalid()),
3396 AllocaAddr(RawAddress::invalid()) {}
3397
3398 AutoVarEmission(const VarDecl &variable)
3399 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
3400 IsEscapingByRef(false), IsConstantAggregate(false),
3401 SizeForLifetimeMarkers(nullptr), AllocaAddr(RawAddress::invalid()) {}
3402
3403 bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
3404
3405 public:
3406 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
3407
3408 bool useLifetimeMarkers() const {
3409 return SizeForLifetimeMarkers != nullptr;
3410 }
3411 llvm::Value *getSizeForLifetimeMarkers() const {
3412 assert(useLifetimeMarkers());
3413 return SizeForLifetimeMarkers;
3414 }
3415
3416 /// Returns the raw, allocated address, which is not necessarily
3417 /// the address of the object itself. It is casted to default
3418 /// address space for address space agnostic languages.
3420 return Addr;
3421 }
3422
3423 /// Returns the address for the original alloca instruction.
3424 RawAddress getOriginalAllocatedAddress() const { return AllocaAddr; }
3425
3426 /// Returns the address of the object within this declaration.
3427 /// Note that this does not chase the forwarding pointer for
3428 /// __block decls.
3430 if (!IsEscapingByRef) return Addr;
3431
3432 return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false);
3433 }
3434 };
3436 void EmitAutoVarInit(const AutoVarEmission &emission);
3439 QualType::DestructionKind dtorKind);
3440
3441 /// Emits the alloca and debug information for the size expressions for each
3442 /// dimension of an array. It registers the association of its (1-dimensional)
3443 /// QualTypes and size expression's debug node, so that CGDebugInfo can
3444 /// reference this node when creating the DISubrange object to describe the
3445 /// array types.
3447 const VarDecl &D,
3448 bool EmitDebugInfo);
3449
3451 llvm::GlobalValue::LinkageTypes Linkage);
3452
3454 union {
3456 llvm::Value *Value;
3457 };
3458
3459 bool IsIndirect;
3460
3461 ParamValue(llvm::Value *V) : Value(V), IsIndirect(false) {}
3462 ParamValue(Address A) : Addr(A), IsIndirect(true) {}
3463
3464 public:
3465 static ParamValue forDirect(llvm::Value *value) {
3466 return ParamValue(value);
3467 }
3469 assert(!addr.getAlignment().isZero());
3470 return ParamValue(addr);
3471 }
3472
3473 bool isIndirect() const { return IsIndirect; }
3474 llvm::Value *getAnyValue() const {
3475 if (!isIndirect())
3476 return Value;
3477 assert(!Addr.hasOffset() && "unexpected offset");
3478 return Addr.getBasePointer();
3479 }
3480
3481 llvm::Value *getDirectValue() const {
3482 assert(!isIndirect());
3483 return Value;
3484 }
3485
3487 assert(isIndirect());
3488 return Addr;
3489 }
3490 };
3491
3492 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3493 void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo);
3494
3495 /// protectFromPeepholes - Protect a value that we're intending to
3496 /// store to the side, but which will probably be used later, from
3497 /// aggressive peepholing optimizations that might delete it.
3498 ///
3499 /// Pass the result to unprotectFromPeepholes to declare that
3500 /// protection is no longer required.
3501 ///
3502 /// There's no particular reason why this shouldn't apply to
3503 /// l-values, it's just that no existing peepholes work on pointers.
3506
3507 void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty,
3509 SourceLocation AssumptionLoc,
3510 llvm::Value *Alignment,
3511 llvm::Value *OffsetValue,
3512 llvm::Value *TheCheck,
3513 llvm::Instruction *Assumption);
3514
3515 void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
3516 SourceLocation Loc, SourceLocation AssumptionLoc,
3517 llvm::Value *Alignment,
3518 llvm::Value *OffsetValue = nullptr);
3519
3520 void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3521 SourceLocation AssumptionLoc,
3522 llvm::Value *Alignment,
3523 llvm::Value *OffsetValue = nullptr);
3524
3525 //===--------------------------------------------------------------------===//
3526 // Statement Emission
3527 //===--------------------------------------------------------------------===//
3528
3529 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3530 void EmitStopPoint(const Stmt *S);
3531
3532 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3533 /// this function even if there is no current insertion point.
3534 ///
3535 /// This function may clear the current insertion point; callers should use
3536 /// EnsureInsertPoint if they wish to subsequently generate code without first
3537 /// calling EmitBlock, EmitBranch, or EmitStmt.
3538 void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = {});
3539
3540 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3541 /// necessarily require an insertion point or debug information; typically
3542 /// because the statement amounts to a jump or a container of other
3543 /// statements.
3544 ///
3545 /// \return True if the statement was handled.
3547
3548 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
3551 bool GetLast = false,
3552 AggValueSlot AVS =
3554
3555 /// EmitLabel - Emit the block for the given label. It is legal to call this
3556 /// function even if there is no current insertion point.
3557 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
3558
3559 void EmitLabelStmt(const LabelStmt &S);
3561 void EmitGotoStmt(const GotoStmt &S);
3563 void EmitIfStmt(const IfStmt &S);
3564
3566 void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = {});
3567 void EmitForStmt(const ForStmt &S, ArrayRef<const Attr *> Attrs = {});
3569 void EmitDeclStmt(const DeclStmt &S);
3570 void EmitBreakStmt(const BreakStmt &S);
3576 void EmitAsmStmt(const AsmStmt &S);
3577
3583
3588 bool ignoreResult = false);
3592 bool ignoreResult = false);
3594 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3595
3596 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3597 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3598
3604 void VolatilizeTryBlocks(llvm::BasicBlock *BB,
3606
3608 llvm::Function *FinallyFunc);
3610 const Stmt *OutlinedStmt);
3611
3613 const SEHExceptStmt &Except);
3614
3616 const SEHFinallyStmt &Finally);
3617
3619 llvm::Value *ParentFP,
3620 llvm::Value *EntryEBP);
3621 llvm::Value *EmitSEHExceptionCode();
3622 llvm::Value *EmitSEHExceptionInfo();
3624
3625 /// Emit simple code for OpenMP directives in Simd-only mode.
3627
3628 /// Scan the outlined statement for captures from the parent function. For
3629 /// each capture, mark the capture as escaped and emit a call to
3630 /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap.
3632 bool IsFilter);
3633
3634 /// Recovers the address of a local in a parent function. ParentVar is the
3635 /// address of the variable used in the immediate parent function. It can
3636 /// either be an alloca or a call to llvm.localrecover if there are nested
3637 /// outlined functions. ParentFP is the frame pointer of the outermost parent
3638 /// frame.
3640 Address ParentVar,
3641 llvm::Value *ParentFP);
3642
3644 ArrayRef<const Attr *> Attrs = {});
3645
3646 /// Controls insertion of cancellation exit blocks in worksharing constructs.
3648 CodeGenFunction &CGF;
3649
3650 public:
3652 bool HasCancel)
3653 : CGF(CGF) {
3654 CGF.OMPCancelStack.enter(CGF, Kind, HasCancel);
3655 }
3656 ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); }
3657 };
3658
3659 /// Returns calculated size of the specified type.
3660 llvm::Value *getTypeSize(QualType Ty);
3668 SmallVectorImpl<llvm::Value *> &CapturedVars);
3669 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3671 /// Perform element by element copying of arrays with type \a
3672 /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
3673 /// generated by \a CopyGen.
3674 ///
3675 /// \param DestAddr Address of the destination array.
3676 /// \param SrcAddr Address of the source array.
3677 /// \param OriginalType Type of destination and source arrays.
3678 /// \param CopyGen Copying procedure that copies value of single array element
3679 /// to another single array element.
3681 Address DestAddr, Address SrcAddr, QualType OriginalType,
3682 const llvm::function_ref<void(Address, Address)> CopyGen);
3683 /// Emit proper copying of data from one variable to another.
3684 ///
3685 /// \param OriginalType Original type of the copied variables.
3686 /// \param DestAddr Destination address.
3687 /// \param SrcAddr Source address.
3688 /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3689 /// type of the base array element).
3690 /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3691 /// the base array element).
3692 /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
3693 /// DestVD.
3694 void EmitOMPCopy(QualType OriginalType,
3695 Address DestAddr, Address SrcAddr,
3696 const VarDecl *DestVD, const VarDecl *SrcVD,
3697 const Expr *Copy);
3698 /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or
3699 /// \a X = \a E \a BO \a E.
3700 ///
3701 /// \param X Value to be updated.
3702 /// \param E Update value.
3703 /// \param BO Binary operation for update operation.
3704 /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3705 /// expression, false otherwise.
3706 /// \param AO Atomic ordering of the generated atomic instructions.
3707 /// \param CommonGen Code generator for complex expressions that cannot be
3708 /// expressed through atomicrmw instruction.
3709 /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was
3710 /// generated, <false, RValue::get(nullptr)> otherwise.
3711 std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3712 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3713 llvm::AtomicOrdering AO, SourceLocation Loc,
3714 const llvm::function_ref<RValue(RValue)> CommonGen);
3716 OMPPrivateScope &PrivateScope);
3718 OMPPrivateScope &PrivateScope);
3720 const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope,
3721 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3722 CaptureDeviceAddrMap);
3724 const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope,
3725 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3726 CaptureDeviceAddrMap);
3727 /// Emit code for copyin clause in \a D directive. The next code is
3728 /// generated at the start of outlined functions for directives:
3729 /// \code
3730 /// threadprivate_var1 = master_threadprivate_var1;
3731 /// operator=(threadprivate_var2, master_threadprivate_var2);
3732 /// ...
3733 /// __kmpc_barrier(&loc, global_tid);
3734 /// \endcode
3735 ///
3736 /// \param D OpenMP directive possibly with 'copyin' clause(s).
3737 /// \returns true if at least one copyin variable is found, false otherwise.
3739 /// Emit initial code for lastprivate variables. If some variable is
3740 /// not also firstprivate, then the default initialization is used. Otherwise
3741 /// initialization of this variable is performed by EmitOMPFirstprivateClause
3742 /// method.
3743 ///
3744 /// \param D Directive that may have 'lastprivate' directives.
3745 /// \param PrivateScope Private scope for capturing lastprivate variables for
3746 /// proper codegen in internal captured statement.
3747 ///
3748 /// \returns true if there is at least one lastprivate variable, false
3749 /// otherwise.
3751 OMPPrivateScope &PrivateScope);
3752 /// Emit final copying of lastprivate values to original variables at
3753 /// the end of the worksharing or simd directive.
3754 ///
3755 /// \param D Directive that has at least one 'lastprivate' directives.
3756 /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
3757 /// it is the last iteration of the loop code in associated directive, or to
3758 /// 'i1 false' otherwise. If this item is nullptr, no final check is required.
3760 bool NoFinals,
3761 llvm::Value *IsLastIterCond = nullptr);
3762 /// Emit initial code for linear clauses.
3764 CodeGenFunction::OMPPrivateScope &PrivateScope);
3765 /// Emit final code for linear clauses.
3766 /// \param CondGen Optional conditional code for final part of codegen for
3767 /// linear clause.
3769 const OMPLoopDirective &D,
3770 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3771 /// Emit initial code for reduction variables. Creates reduction copies
3772 /// and initializes them with the values according to OpenMP standard.
3773 ///
3774 /// \param D Directive (possibly) with the 'reduction' clause.
3775 /// \param PrivateScope Private scope for capturing reduction variables for
3776 /// proper codegen in internal captured statement.
3777 ///
3779 OMPPrivateScope &PrivateScope,
3780 bool ForInscan = false);
3781 /// Emit final update of reduction values to original variables at
3782 /// the end of the directive.
3783 ///
3784 /// \param D Directive that has at least one 'reduction' directives.
3785 /// \param ReductionKind The kind of reduction to perform.
3787 const OpenMPDirectiveKind ReductionKind);
3788 /// Emit initial code for linear variables. Creates private copies
3789 /// and initializes them with the values according to OpenMP standard.
3790 ///
3791 /// \param D Directive (possibly) with the 'linear' clause.
3792 /// \return true if at least one linear variable is found that should be
3793 /// initialized with the value of the original variable, false otherwise.
3795
3796 typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/,
3797 llvm::Function * /*OutlinedFn*/,
3798 const OMPTaskDataTy & /*Data*/)>
3801 const OpenMPDirectiveKind CapturedRegion,
3802 const RegionCodeGenTy &BodyGen,
3803 const TaskGenTy &TaskGen, OMPTaskDataTy &Data);
3810 explicit OMPTargetDataInfo() = default;
3813 unsigned NumberOfTargetItems)
3817 };
3819 const RegionCodeGenTy &BodyGen,
3820 OMPTargetDataInfo &InputInfo);
3823 CodeGenFunction &CGF,
3824 const CapturedStmt *CS,
3863 void
3866 void
3873 void
3891 void
3916
3917 /// Emit device code for the target directive.
3919 StringRef ParentName,
3920 const OMPTargetDirective &S);
3921 static void
3924 /// Emit device code for the target parallel for directive.
3926 CodeGenModule &CGM, StringRef ParentName,
3928 /// Emit device code for the target parallel for simd directive.
3930 CodeGenModule &CGM, StringRef ParentName,
3932 /// Emit device code for the target teams directive.
3933 static void
3935 const OMPTargetTeamsDirective &S);
3936 /// Emit device code for the target teams distribute directive.
3938 CodeGenModule &CGM, StringRef ParentName,
3940 /// Emit device code for the target teams distribute simd directive.
3942 CodeGenModule &CGM, StringRef ParentName,
3944 /// Emit device code for the target simd directive.
3946 StringRef ParentName,
3947 const OMPTargetSimdDirective &S);
3948 /// Emit device code for the target teams distribute parallel for simd
3949 /// directive.
3951 CodeGenModule &CGM, StringRef ParentName,
3953
3954 /// Emit device code for the target teams loop directive.
3956 CodeGenModule &CGM, StringRef ParentName,
3958
3959 /// Emit device code for the target parallel loop directive.
3961 CodeGenModule &CGM, StringRef ParentName,
3963
3965 CodeGenModule &CGM, StringRef ParentName,
3967
3968 /// Emit the Stmt \p S and return its topmost canonical loop, if any.
3969 /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
3970 /// future it is meant to be the number of loops expected in the loop nests
3971 /// (usually specified by the "collapse" clause) that are collapsed to a
3972 /// single loop by this function.
3973 llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S,
3974 int Depth);
3975
3976 /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
3978
3979 /// Emit inner loop of the worksharing/simd construct.
3980 ///
3981 /// \param S Directive, for which the inner loop must be emitted.
3982 /// \param RequiresCleanup true, if directive has some associated private
3983 /// variables.
3984 /// \param LoopCond Bollean condition for loop continuation.
3985 /// \param IncExpr Increment expression for loop control variable.
3986 /// \param BodyGen Generator for the inner body of the inner loop.
3987 /// \param PostIncGen Genrator for post-increment code (required for ordered
3988 /// loop directvies).
3990 const OMPExecutableDirective &S, bool RequiresCleanup,
3991 const Expr *LoopCond, const Expr *IncExpr,
3992 const llvm::function_ref<void(CodeGenFunction &)> BodyGen,
3993 const llvm::function_ref<void(CodeGenFunction &)> PostIncGen);
3994
3996 /// Emit initial code for loop counters of loop-based directives.
3998 OMPPrivateScope &LoopScope);
3999
4000 /// Helper for the OpenMP loop directives.
4002
4003 /// Emit code for the worksharing loop-based directive.
4004 /// \return true, if this construct has any lastprivate clause, false -
4005 /// otherwise.
4007 const CodeGenLoopBoundsTy &CodeGenLoopBounds,
4008 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4009
4010 /// Emit code for the distribute loop-based directive.
4012 const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
4013
4014 /// Helpers for the OpenMP loop directives.
4017 const OMPLoopDirective &D,
4018 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
4019
4020 /// Emits the lvalue for the expression with possibly captured variable.
4022
4023private:
4024 /// Helpers for blocks.
4025 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info);
4026
4027 /// struct with the values to be passed to the OpenMP loop-related functions
4028 struct OMPLoopArguments {
4029 /// loop lower bound
4031 /// loop upper bound
4033 /// loop stride
4035 /// isLastIteration argument for runtime functions
4037 /// Chunk value generated by sema
4038 llvm::Value *Chunk = nullptr;
4039 /// EnsureUpperBound
4040 Expr *EUB = nullptr;
4041 /// IncrementExpression
4042 Expr *IncExpr = nullptr;
4043 /// Loop initialization
4044 Expr *Init = nullptr;
4045 /// Loop exit condition
4046 Expr *Cond = nullptr;
4047 /// Update of LB after a whole chunk has been executed
4048 Expr *NextLB = nullptr;
4049 /// Update of UB after a whole chunk has been executed
4050 Expr *NextUB = nullptr;
4051 /// Distinguish between the for distribute and sections
4052 OpenMPDirectiveKind DKind = llvm::omp::OMPD_unknown;
4053 OMPLoopArguments() = default;
4054 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
4055 llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
4056 Expr *IncExpr = nullptr, Expr *Init = nullptr,
4057 Expr *Cond = nullptr, Expr *NextLB = nullptr,
4058 Expr *NextUB = nullptr)
4059 : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB),
4060 IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB),
4061 NextUB(NextUB) {}
4062 };
4063 void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic,
4064 const OMPLoopDirective &S, OMPPrivateScope &LoopScope,
4065 const OMPLoopArguments &LoopArgs,
4066 const CodeGenLoopTy &CodeGenLoop,
4067 const CodeGenOrderedTy &CodeGenOrdered);
4068 void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind,
4069 bool IsMonotonic, const OMPLoopDirective &S,
4070 OMPPrivateScope &LoopScope, bool Ordered,
4071 const OMPLoopArguments &LoopArgs,
4072 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4073 void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind,
4074 const OMPLoopDirective &S,
4075 OMPPrivateScope &LoopScope,
4076 const OMPLoopArguments &LoopArgs,
4077 const CodeGenLoopTy &CodeGenLoopContent);
4078 /// Emit code for sections directive.
4079 void EmitSections(const OMPExecutableDirective &S);
4080
4081public:
4082 //===--------------------------------------------------------------------===//
4083 // OpenACC Emission
4084 //===--------------------------------------------------------------------===//
4086 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4087 // simply emitting its structured block, but in the future we will implement
4088 // some sort of IR.
4089 EmitStmt(S.getStructuredBlock());
4090 }
4091
4093 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4094 // simply emitting its loop, but in the future we will implement
4095 // some sort of IR.
4096 EmitStmt(S.getLoop());
4097 }
4098
4100 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4101 // simply emitting its loop, but in the future we will implement
4102 // some sort of IR.
4103 EmitStmt(S.getLoop());
4104 }
4105
4107 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4108 // simply emitting its structured block, but in the future we will implement
4109 // some sort of IR.
4110 EmitStmt(S.getStructuredBlock());
4111 }
4112
4114 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4115 // but in the future we will implement some sort of IR.
4116 }
4117
4119 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4120 // but in the future we will implement some sort of IR.
4121 }
4122
4124 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4125 // simply emitting its structured block, but in the future we will implement
4126 // some sort of IR.
4127 EmitStmt(S.getStructuredBlock());
4128 }
4129
4131 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4132 // but in the future we will implement some sort of IR.
4133 }
4134
4136 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4137 // but in the future we will implement some sort of IR.
4138 }
4139
4141 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4142 // but in the future we will implement some sort of IR.
4143 }
4144
4146 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4147 // but in the future we will implement some sort of IR.
4148 }
4149
4151 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4152 // but in the future we will implement some sort of IR.
4153 }
4154
4155 //===--------------------------------------------------------------------===//
4156 // LValue Expression Emission
4157 //===--------------------------------------------------------------------===//
4158
4159 /// Create a check that a scalar RValue is non-null.
4161
4162 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
4164
4165 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
4166 /// and issue an ErrorUnsupported style diagnostic (using the
4167 /// provided Name).
4169 const char *Name);
4170
4171 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
4172 /// an ErrorUnsupported style diagnostic (using the provided Name).
4174 const char *Name);
4175
4176 /// EmitLValue - Emit code to compute a designator that specifies the location
4177 /// of the expression.
4178 ///
4179 /// This can return one of two things: a simple address or a bitfield
4180 /// reference. In either case, the LLVM Value* in the LValue structure is
4181 /// guaranteed to be an LLVM pointer type.
4182 ///
4183 /// If this returns a bitfield reference, nothing about the pointee type of
4184 /// the LLVM value is known: For example, it may not be a pointer to an
4185 /// integer.
4186 ///
4187 /// If this returns a normal address, and if the lvalue's C type is fixed
4188 /// size, this method guarantees that the returned pointer type will point to
4189 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
4190 /// variable length type, this is not possible.
4191 ///
4193 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
4194
4195private:
4196 LValue EmitLValueHelper(const Expr *E, KnownNonNull_t IsKnownNonNull);
4197
4198public:
4199 /// Same as EmitLValue but additionally we generate checking code to
4200 /// guard against undefined behavior. This is only suitable when we know
4201 /// that the address will be used to access the object.
4203
4206
4207 void EmitAtomicInit(Expr *E, LValue lvalue);
4208
4210
4213
4215 llvm::AtomicOrdering AO, bool IsVolatile = false,
4217
4218 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
4219
4220 void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
4221 bool IsVolatile, bool isInit);
4222
4223 std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
4225 llvm::AtomicOrdering Success =
4226 llvm::AtomicOrdering::SequentiallyConsistent,
4227 llvm::AtomicOrdering Failure =
4228 llvm::AtomicOrdering::SequentiallyConsistent,
4229 bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored());
4230
4231 /// Emit an atomicrmw instruction, and applying relevant metadata when
4232 /// applicable.
4233 llvm::AtomicRMWInst *emitAtomicRMWInst(
4234 llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val,
4235 llvm::AtomicOrdering Order = llvm::AtomicOrdering::SequentiallyConsistent,
4236 llvm::SyncScope::ID SSID = llvm::SyncScope::System,
4237 const AtomicExpr *AE = nullptr);
4238
4239 void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
4240 const llvm::function_ref<RValue(RValue)> &UpdateOp,
4241 bool IsVolatile);
4242
4243 /// EmitToMemory - Change a scalar value from its value
4244 /// representation to its in-memory representation.
4245 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
4246
4247 /// EmitFromMemory - Change a scalar value from its memory
4248 /// representation to its value representation.
4249 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
4250
4251 /// Check if the scalar \p Value is within the valid range for the given
4252 /// type \p Ty.
4253 ///
4254 /// Returns true if a check is needed (even if the range is unknown).
4255 bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty,
4257
4258 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4259 /// care to appropriately convert from the memory representation to
4260 /// the LLVM value representation.
4261 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4264 bool isNontemporal = false) {
4265 return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source),
4266 CGM.getTBAAAccessInfo(Ty), isNontemporal);
4267 }
4268
4269 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4271 TBAAAccessInfo TBAAInfo,
4272 bool isNontemporal = false);
4273
4274 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4275 /// care to appropriately convert from the memory representation to
4276 /// the LLVM value representation. The l-value must be a simple
4277 /// l-value.
4279
4280 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4281 /// care to appropriately convert from the memory representation to
4282 /// the LLVM value representation.
4283 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
4284 bool Volatile, QualType Ty,
4286 bool isInit = false, bool isNontemporal = false) {
4287 EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source),
4288 CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal);
4289 }
4290
4291 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
4292 bool Volatile, QualType Ty,
4293 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo,
4294 bool isInit = false, bool isNontemporal = false);
4295
4296 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4297 /// care to appropriately convert from the memory representation to
4298 /// the LLVM value representation. The l-value must be a simple
4299 /// l-value. The isInit flag indicates whether this is an initialization.
4300 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
4301 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
4302
4303 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
4304 /// this method emits the address of the lvalue, then loads the result as an
4305 /// rvalue, returning the rvalue.
4310
4311 /// Like EmitLoadOfLValue but also handles complex and aggregate types.
4314 SourceLocation Loc = {});
4315
4316 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
4317 /// lvalue, where both are guaranteed to the have the same type, and that type
4318 /// is 'Ty'.
4319 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
4322
4323 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
4324 /// as EmitStoreThroughLValue.
4325 ///
4326 /// \param Result [out] - If non-null, this will be set to a Value* for the
4327 /// bit-field contents after the store, appropriate for use as the result of
4328 /// an assignment to the bit-field.
4330 llvm::Value **Result=nullptr);
4331
4332 /// Emit an l-value for an assignment (simple or compound) of complex type.
4336 llvm::Value *&Result);
4337
4338 // Note: only available for agg return types
4341 // Note: only available for agg return types
4343 llvm::CallBase **CallOrInvoke = nullptr);
4344 // Note: only available for agg return types
4352 bool Accessed = false);
4353 llvm::Value *EmitMatrixIndexExpr(const Expr *E);
4356 bool IsLowerBound = true);
4368
4369 std::pair<LValue, LValue> EmitHLSLOutArgLValues(const HLSLOutArgExpr *E,
4370 QualType Ty);
4372 QualType Ty);
4373
4375
4377
4379 LValueBaseInfo *BaseInfo = nullptr,
4380 TBAAAccessInfo *TBAAInfo = nullptr);
4381
4383 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
4384 ConstantEmission(llvm::Constant *C, bool isReference)
4385 : ValueAndIsReference(C, isReference) {}
4386 public:
4388 static ConstantEmission forReference(llvm::Constant *C) {
4389 return ConstantEmission(C, true);
4390 }
4391 static ConstantEmission forValue(llvm::Constant *C) {
4392 return ConstantEmission(C, false);
4393 }
4394
4395 explicit operator bool() const {
4396 return ValueAndIsReference.getOpaqueValue() != nullptr;
4397 }
4398
4399 bool isReference() const { return ValueAndIsReference.getInt(); }
4401 assert(isReference());
4402 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
4403 refExpr->getType());
4404 }
4405
4406 llvm::Constant *getValue() const {
4407 assert(!isReference());
4408 return ValueAndIsReference.getPointer();
4409 }
4410 };
4411
4414 llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
4415
4419
4421 const ObjCIvarDecl *Ivar);
4423 const ObjCIvarDecl *Ivar);
4427 llvm::Value *ThisValue);
4428
4429 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
4430 /// if the Field is a reference, this will return the address of the reference
4431 /// and not the address of the value stored in the reference.
4433 const FieldDecl* Field);
4434
4436 llvm::Value* Base, const ObjCIvarDecl *Ivar,
4437 unsigned CVRQualifiers);
4438
4443
4450
4451 //===--------------------------------------------------------------------===//
4452 // Scalar Expression Emission
4453 //===--------------------------------------------------------------------===//
4454
4455 /// EmitCall - Generate a call of the given function, expecting the given
4456 /// result type, and using the given argument list which specifies both the
4457 /// LLVM arguments and the types they were derived from.
4458 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4460 llvm::CallBase **CallOrInvoke, bool IsMustTail,
4462 bool IsVirtualFunctionPointerThunk = false);
4463 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4465 llvm::CallBase **CallOrInvoke = nullptr,
4466 bool IsMustTail = false) {
4467 return EmitCall(CallInfo, Callee, ReturnValue, Args, CallOrInvoke,
4468 IsMustTail, SourceLocation());
4469 }
4470 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
4471 ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr,
4472 llvm::CallBase **CallOrInvoke = nullptr,
4473 CGFunctionInfo const **ResolvedFnInfo = nullptr);
4474
4475 // If a Call or Invoke instruction was emitted for this CallExpr, this method
4476 // writes the pointer to `CallOrInvoke` if it's not null.
4479 llvm::CallBase **CallOrInvoke = nullptr);
4481 llvm::CallBase **CallOrInvoke = nullptr);
4483
4484 void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
4486
4487 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4488 const Twine &name = "");
4489 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4491 const Twine &name = "");
4492 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4493 const Twine &name = "");
4494 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4495 ArrayRef<Address> args,
4496 const Twine &name = "");
4497 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4499 const Twine &name = "");
4500
4502 getBundlesForFunclet(llvm::Value *Callee);
4503
4504 llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee,
4506 const Twine &Name = "");
4507 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4509 const Twine &name = "");
4510 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4511 const Twine &name = "");
4512 void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4514
4516 NestedNameSpecifier *Qual,
4517 llvm::Type *Ty);
4518
4521 const CXXRecordDecl *RD);
4522
4524
4525 /// Create the discriminator from the storage address and the entity hash.
4526 llvm::Value *EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
4527 llvm::Value *Discriminator);
4529 llvm::Value *StorageAddress,
4530 GlobalDecl SchemaDecl,
4531 QualType SchemaType);
4532
4533 llvm::Value *EmitPointerAuthSign(const CGPointerAuthInfo &Info,
4534 llvm::Value *Pointer);
4535
4536 llvm::Value *EmitPointerAuthAuth(const CGPointerAuthInfo &Info,
4537 llvm::Value *Pointer);
4538
4540 const CGPointerAuthInfo &CurAuthInfo,
4541 const CGPointerAuthInfo &NewAuthInfo,
4542 bool IsKnownNonNull);
4543 llvm::Value *emitPointerAuthResignCall(llvm::Value *Pointer,
4544 const CGPointerAuthInfo &CurInfo,
4545 const CGPointerAuthInfo &NewInfo);
4546
4548 const CGPointerAuthInfo &Info,
4550
4551 llvm::Value *authPointerToPointerCast(llvm::Value *ResultPtr,
4552 QualType SourceType, QualType DestType);
4554 QualType DestType);
4555
4557
4558 llvm::Value *getAsNaturalPointerTo(Address Addr, QualType PointeeType) {
4559 return getAsNaturalAddressOf(Addr, PointeeType).getBasePointer();
4560 }
4561
4562 // Return the copy constructor name with the prefix "__copy_constructor_"
4563 // removed.
4565 CharUnits Alignment,
4566 bool IsVolatile,
4567 ASTContext &Ctx);
4568
4569 // Return the destructor name with the prefix "__destructor_" removed.
4571 CharUnits Alignment,
4572 bool IsVolatile,
4573 ASTContext &Ctx);
4574
4575 // These functions emit calls to the special functions of non-trivial C
4576 // structs.
4584
4586 const CXXMethodDecl *Method, const CGCallee &Callee,
4587 ReturnValueSlot ReturnValue, llvm::Value *This,
4588 llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E,
4589 CallArgList *RtlArgs, llvm::CallBase **CallOrInvoke);
4591 llvm::Value *This, QualType ThisTy,
4592 llvm::Value *ImplicitParam,
4593 QualType ImplicitParamTy, const CallExpr *E,
4594 llvm::CallBase **CallOrInvoke = nullptr);
4597 llvm::CallBase **CallOrInvoke = nullptr);
4599 const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
4600 bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
4601 const Expr *Base, llvm::CallBase **CallOrInvoke);
4602 // Compute the object pointer.
4604 llvm::Value *memberPtr,
4605 const MemberPointerType *memberPtrType,
4606 LValueBaseInfo *BaseInfo = nullptr,
4607 TBAAAccessInfo *TBAAInfo = nullptr);
4610 llvm::CallBase **CallOrInvoke);
4611
4613 const CXXMethodDecl *MD,
4615 llvm::CallBase **CallOrInvoke);
4617
4620 llvm::CallBase **CallOrInvoke);
4621
4624
4625 RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
4627
4628 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
4629
4630 /// Emit IR for __builtin_os_log_format.
4632
4633 /// Emit IR for __builtin_is_aligned.
4635 /// Emit IR for __builtin_align_up/__builtin_align_down.
4636 RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp);
4637
4640 CharUnits BufferAlignment);
4641
4643 llvm::CallBase **CallOrInvoke);
4644
4645 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4646 /// is unhandled by the current target.
4647 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4649
4650 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty,
4651 const llvm::CmpInst::Predicate Fp,
4652 const llvm::CmpInst::Predicate Ip,
4653 const llvm::Twine &Name = "");
4654 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4656 llvm::Triple::ArchType Arch);
4657 llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4659 llvm::Triple::ArchType Arch);
4660 llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4662 llvm::Triple::ArchType Arch);
4663 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy,
4664 QualType RTy);
4665 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy,
4666 QualType RTy);
4667
4668 llvm::Value *EmitCommonNeonBuiltinExpr(unsigned BuiltinID,
4669 unsigned LLVMIntrinsic,
4670 unsigned AltLLVMIntrinsic,
4671 const char *NameHint,
4672 unsigned Modifier,
4673 const CallExpr *E,
4675 Address PtrOp0, Address PtrOp1,
4676 llvm::Triple::ArchType Arch);
4677
4678 llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
4679 unsigned Modifier, llvm::Type *ArgTy,
4680 const CallExpr *E);
4681 llvm::Value *EmitNeonCall(llvm::Function *F,
4683 const char *name,
4684 unsigned shift = 0, bool rightshift = false);
4685 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
4686 const llvm::ElementCount &Count);
4687 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
4688 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
4689 bool negateForRightShift);
4690 llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt,
4691 llvm::Type *Ty, bool usgn, const char *name);
4692 llvm::Value *vectorWrapScalar16(llvm::Value *Op);
4693 /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4694 /// access builtin. Only required if it can't be inferred from the base
4695 /// pointer operand.
4696 llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags);
4697
4699 getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType,
4701 llvm::Type *getEltType(const SVETypeFlags &TypeFlags);
4702 llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags);
4703 llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags);
4704 llvm::Value *EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags,
4706 llvm::Value *EmitSVETupleCreate(const SVETypeFlags &TypeFlags,
4707 llvm::Type *ReturnType,
4709 llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags);
4710 llvm::Value *EmitSVEDupX(llvm::Value *Scalar);
4711 llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty);
4712 llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty);
4713 llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags,
4715 unsigned BuiltinID);
4716 llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags,
4718 unsigned BuiltinID);
4719 llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred,
4720 llvm::ScalableVectorType *VTy);
4721 llvm::Value *EmitSVEPredicateTupleCast(llvm::Value *PredTuple,
4722 llvm::StructType *Ty);
4723 llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags,
4725 unsigned IntID);
4726 llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags,
4728 unsigned IntID);
4729 llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy,
4731 unsigned BuiltinID, bool IsZExtReturn);
4732 llvm::Value *EmitSVEMaskedStore(const CallExpr *,
4734 unsigned BuiltinID);
4735 llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags,
4737 unsigned BuiltinID);
4738 llvm::Value *EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags,
4740 unsigned IntID);
4741 llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags,
4743 unsigned IntID);
4744 llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags,
4746 unsigned IntID);
4747 llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4748
4749 llvm::Value *EmitSMELd1St1(const SVETypeFlags &TypeFlags,
4751 unsigned IntID);
4752 llvm::Value *EmitSMEReadWrite(const SVETypeFlags &TypeFlags,
4754 unsigned IntID);
4755 llvm::Value *EmitSMEZero(const SVETypeFlags &TypeFlags,
4757 unsigned IntID);
4758 llvm::Value *EmitSMELdrStr(const SVETypeFlags &TypeFlags,
4760 unsigned IntID);
4761
4762 void GetAArch64SVEProcessedOperands(unsigned BuiltinID, const CallExpr *E,
4764 SVETypeFlags TypeFlags);
4765
4766 llvm::Value *EmitAArch64SMEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4767
4768 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4769 llvm::Triple::ArchType Arch);
4770 llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4771
4773 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4774 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4775 llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4776 llvm::Value *EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4778 llvm::Value *EmitSPIRVBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4779 llvm::Value *EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx,
4780 const CallExpr *E);
4781 llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4782 llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4783 llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
4784 const CallExpr *E);
4785 llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4786 llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4788
4789 llvm::Value *EmitRISCVCpuSupports(const CallExpr *E);
4790 llvm::Value *EmitRISCVCpuSupports(ArrayRef<StringRef> FeaturesStrs);
4791 llvm::Value *EmitRISCVCpuInit();
4792 llvm::Value *EmitRISCVCpuIs(const CallExpr *E);
4793 llvm::Value *EmitRISCVCpuIs(StringRef CPUStr);
4794
4795 void AddAMDGPUFenceAddressSpaceMMRA(llvm::Instruction *Inst,
4796 const CallExpr *E);
4797 void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope,
4798 llvm::AtomicOrdering &AO,
4799 llvm::SyncScope::ID &SSID);
4800
4801 enum class MSVCIntrin;
4802 llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4803
4804 llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version);
4805
4808 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E);
4811 llvm::Value *EmitObjCCollectionLiteral(const Expr *E,
4812 const ObjCMethodDecl *MethodWithObjects);
4815 ReturnValueSlot Return = ReturnValueSlot());
4816
4817 /// Retrieves the default cleanup kind for an ARC cleanup.
4818 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4820 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
4822 }
4823
4824 // ARC primitives.
4825 void EmitARCInitWeak(Address addr, llvm::Value *value);
4827 llvm::Value *EmitARCLoadWeak(Address addr);
4829 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
4830 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4831 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4834 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
4835 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
4836 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
4837 bool resultIgnored);
4838 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
4839 bool resultIgnored);
4840 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
4841 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
4842 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
4844 void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4845 llvm::Value *EmitARCAutorelease(llvm::Value *value);
4846 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
4847 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
4848 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
4849 llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value);
4850
4851 llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
4852 llvm::Value *EmitObjCRetainNonBlock(llvm::Value *value,
4853 llvm::Type *returnType);
4854 void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4855
4856 std::pair<LValue,llvm::Value*>
4858 std::pair<LValue,llvm::Value*>
4859 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
4860 std::pair<LValue,llvm::Value*>
4862
4863 llvm::Value *EmitObjCAlloc(llvm::Value *value,
4864 llvm::Type *returnType);
4865 llvm::Value *EmitObjCAllocWithZone(llvm::Value *value,
4866 llvm::Type *returnType);
4867 llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
4868
4869 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
4870 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
4871 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
4872
4873 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
4874 llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
4875 bool allowUnsafeClaim);
4876 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
4879
4881
4883
4889
4890 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
4893 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
4894 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
4895
4896 /// Emits a reference binding to the passed in expression.
4898
4899 //===--------------------------------------------------------------------===//
4900 // Expression Emission
4901 //===--------------------------------------------------------------------===//
4902
4903 // Expressions are broken into three classes: scalar, complex, aggregate.
4904
4905 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
4906 /// scalar type, returning the result.
4907 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
4908
4909 /// Emit a conversion from the specified type to the specified destination
4910 /// type, both of which are LLVM scalar types.
4911 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
4912 QualType DstTy, SourceLocation Loc);
4913
4914 /// Emit a conversion from the specified complex type to the specified
4915 /// destination type, where the destination type is an LLVM scalar type.
4917 QualType DstTy,
4919
4920 /// EmitAggExpr - Emit the computation of the specified expression
4921 /// of aggregate type. The result is computed into the given slot,
4922 /// which may be null to indicate that the value is not needed.
4923 void EmitAggExpr(const Expr *E, AggValueSlot AS);
4924
4925 /// EmitAggExprToLValue - Emit the computation of the specified expression of
4926 /// aggregate type into a temporary LValue.
4928
4930
4931 /// EmitAggFinalDestCopy - Emit copy of the specified aggregate into
4932 /// destination address.
4934 ExprValueKind SrcKind);
4935
4936 /// Create a store to \arg DstPtr from \arg Src, truncating the stored value
4937 /// to at most \arg DstSize bytes.
4938 void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize,
4939 bool DstIsVolatile);
4940
4941 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
4942 /// make sure it survives garbage collection until this point.
4943 void EmitExtendGCLifetime(llvm::Value *object);
4944
4945 /// EmitComplexExpr - Emit the computation of the specified expression of
4946 /// complex type, returning the result.
4948 bool IgnoreReal = false,
4949 bool IgnoreImag = false);
4950
4951 /// EmitComplexExprIntoLValue - Emit the given expression of complex
4952 /// type and place its result into the specified l-value.
4953 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
4954
4955 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
4956 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
4957
4958 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
4960
4962 llvm::Value *EmitPromotedScalarExpr(const Expr *E, QualType PromotionType);
4965
4968
4969 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
4970 /// global variable that has already been created for it. If the initializer
4971 /// has a different type than GV does, this may free GV and return a different
4972 /// one. Otherwise it just returns GV.
4973 llvm::GlobalVariable *
4975 llvm::GlobalVariable *GV);
4976
4977 // Emit an @llvm.invariant.start call for the given memory region.
4978 void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
4979
4980 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
4981 /// variable with global storage.
4982 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV,
4983 bool PerformInit);
4984
4985 llvm::Constant *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
4986 llvm::Constant *Addr);
4987
4988 llvm::Function *createTLSAtExitStub(const VarDecl &VD,
4989 llvm::FunctionCallee Dtor,
4990 llvm::Constant *Addr,
4991 llvm::FunctionCallee &AtExit);
4992
4993 /// Call atexit() with a function that passes the given argument to
4994 /// the given function.
4995 void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
4996 llvm::Constant *addr);
4997
4998 /// Registers the dtor using 'llvm.global_dtors' for platforms that do not
4999 /// support an 'atexit()' function.
5000 void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn,
5001 llvm::Constant *addr);
5002
5003 /// Call atexit() with function dtorStub.
5004 void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
5005
5006 /// Call unatexit() with function dtorStub.
5007 llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub);
5008
5009 /// Emit code in this function to perform a guarded variable
5010 /// initialization. Guarded initializations are used when it's not
5011 /// possible to prove that an initialization will be done exactly
5012 /// once, e.g. with a static local variable or a static data member
5013 /// of a class template.
5014 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
5015 bool PerformInit);
5016
5018
5019 /// Emit a branch to select whether or not to perform guarded initialization.
5020 void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
5021 llvm::BasicBlock *InitBlock,
5022 llvm::BasicBlock *NoInitBlock,
5023 GuardKind Kind, const VarDecl *D);
5024
5025 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
5026 /// variables.
5027 void
5028 GenerateCXXGlobalInitFunc(llvm::Function *Fn,
5029 ArrayRef<llvm::Function *> CXXThreadLocals,
5031
5032 /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
5033 /// variables.
5035 llvm::Function *Fn,
5036 ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
5037 llvm::Constant *>>
5038 DtorsOrStermFinalizers);
5039
5040 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
5041 const VarDecl *D,
5042 llvm::GlobalVariable *Addr,
5043 bool PerformInit);
5044
5046
5047 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
5048
5049 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
5050
5052
5053 //===--------------------------------------------------------------------===//
5054 // Annotations Emission
5055 //===--------------------------------------------------------------------===//
5056
5057 /// Emit an annotation call (intrinsic).
5058 llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
5059 llvm::Value *AnnotatedVal,
5060 StringRef AnnotationStr,
5061 SourceLocation Location,
5062 const AnnotateAttr *Attr);
5063
5064 /// Emit local annotations for the local variable V, declared by D.
5065 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
5066
5067 /// Emit field annotations for the given field & value. Returns the
5068 /// annotation result.
5070
5071 //===--------------------------------------------------------------------===//
5072 // Internal Helpers
5073 //===--------------------------------------------------------------------===//
5074
5075 /// ContainsLabel - Return true if the statement contains a label in it. If
5076 /// this statement is not executed normally, it not containing a label means
5077 /// that we can just remove the code.
5078 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
5079
5080 /// containsBreak - Return true if the statement contains a break out of it.
5081 /// If the statement (recursively) contains a switch or loop with a break
5082 /// inside of it, this is fine.
5083 static bool containsBreak(const Stmt *S);
5084
5085 /// Determine if the given statement might introduce a declaration into the
5086 /// current scope, by being a (possibly-labelled) DeclStmt.
5087 static bool mightAddDeclToScope(const Stmt *S);
5088
5089 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5090 /// to a constant, or if it does but contains a label, return false. If it
5091 /// constant folds return true and set the boolean result in Result.
5093 bool AllowLabels = false);
5094
5095 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5096 /// to a constant, or if it does but contains a label, return false. If it
5097 /// constant folds return true and set the folded value.
5098 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result,
5099 bool AllowLabels = false);
5100
5101 /// Ignore parentheses and logical-NOT to track conditions consistently.
5102 static const Expr *stripCond(const Expr *C);
5103
5104 /// isInstrumentedCondition - Determine whether the given condition is an
5105 /// instrumentable condition (i.e. no "&&" or "||").
5106 static bool isInstrumentedCondition(const Expr *C);
5107
5108 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
5109 /// increments a profile counter based on the semantics of the given logical
5110 /// operator opcode. This is used to instrument branch condition coverage
5111 /// for logical operators.
5113 llvm::BasicBlock *TrueBlock,
5114 llvm::BasicBlock *FalseBlock,
5115 uint64_t TrueCount = 0,
5117 const Expr *CntrIdx = nullptr);
5118
5119 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
5120 /// if statement) to the specified blocks. Based on the condition, this might
5121 /// try to simplify the codegen of the conditional based on the branch.
5122 /// TrueCount should be the number of times we expect the condition to
5123 /// evaluate to true based on PGO data.
5124 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
5125 llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
5127 const Expr *ConditionalOp = nullptr);
5128
5129 /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
5130 /// nonnull, if \p LHS is marked _Nonnull.
5131 void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
5132
5133 /// An enumeration which makes it easier to specify whether or not an
5134 /// operation is a subtraction.
5135 enum { NotSubtraction = false, IsSubtraction = true };
5136
5137 /// Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to
5138 /// detect undefined behavior when the pointer overflow sanitizer is enabled.
5139 /// \p SignedIndices indicates whether any of the GEP indices are signed.
5140 /// \p IsSubtraction indicates whether the expression used to form the GEP
5141 /// is a subtraction.
5142 llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr,
5144 bool SignedIndices,
5145 bool IsSubtraction,
5147 const Twine &Name = "");
5148
5150 llvm::Type *elementType, bool SignedIndices,
5152 CharUnits Align, const Twine &Name = "");
5153
5154 /// Specifies which type of sanitizer check to apply when handling a
5155 /// particular builtin.
5160 };
5161
5162 /// Emits an argument for a call to a builtin. If the builtin sanitizer is
5163 /// enabled, a runtime check specified by \p Kind is also emitted.
5165
5166 /// Emits an argument for a call to a `__builtin_assume`. If the builtin
5167 /// sanitizer is enabled, a runtime check is also emitted.
5168 llvm::Value *EmitCheckedArgForAssume(const Expr *E);
5169
5170 /// Emit a description of a type in a format suitable for passing to
5171 /// a runtime sanitizer handler.
5173
5174 /// Convert a value into a format suitable for passing to a runtime
5175 /// sanitizer handler.
5176 llvm::Value *EmitCheckValue(llvm::Value *V);
5177
5178 /// Emit a description of a source location in a format suitable for
5179 /// passing to a runtime sanitizer handler.
5181
5184
5185 /// Create a basic block that will either trap or call a handler function in
5186 /// the UBSan runtime with the provided arguments, and create a conditional
5187 /// branch to it.
5188 void EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked,
5190 ArrayRef<llvm::Value *> DynamicArgs);
5191
5192 /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath
5193 /// if Cond if false.
5194 void EmitCfiSlowPathCheck(SanitizerMask Kind, llvm::Value *Cond,
5195 llvm::ConstantInt *TypeId, llvm::Value *Ptr,
5196 ArrayRef<llvm::Constant *> StaticArgs);
5197
5198 /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime
5199 /// checking is enabled. Otherwise, just emit an unreachable instruction.
5201
5202 /// Create a basic block that will call the trap intrinsic, and emit a
5203 /// conditional branch to it, for the -ftrapv checks.
5204 void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID,
5205 bool NoMerge = false);
5206
5207 /// Emit a call to trap or debugtrap and attach function attribute
5208 /// "trap-func-name" if specified.
5209 llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID);
5210
5211 /// Emit a stub for the cross-DSO CFI check function.
5213
5214 /// Emit a cross-DSO CFI failure handling function.
5216
5217 /// Create a check for a function parameter that may potentially be
5218 /// declared as non-null.
5220 AbstractCallee AC, unsigned ParmNum);
5221
5223 SourceLocation ArgLoc, AbstractCallee AC,
5224 unsigned ParmNum);
5225
5226 /// EmitWriteback - Emit callbacks for function.
5227 void EmitWritebacks(const CallArgList &Args);
5228
5229 /// EmitCallArg - Emit a single call argument.
5230 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
5231
5232 /// EmitDelegateCallArg - We are performing a delegate call; that
5233 /// is, the current function is delegating to another one. Produce
5234 /// a r-value suitable for passing the given parameter.
5235 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param,
5236 SourceLocation loc);
5237
5238 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
5239 /// point operation, expressed as the maximum relative error in ulp.
5240 void SetFPAccuracy(llvm::Value *Val, float Accuracy);
5241
5242 /// Set the minimum required accuracy of the given sqrt operation
5243 /// based on CodeGenOpts.
5244 void SetSqrtFPAccuracy(llvm::Value *Val);
5245
5246 /// Set the minimum required accuracy of the given sqrt operation based on
5247 /// CodeGenOpts.
5248 void SetDivFPAccuracy(llvm::Value *Val);
5249
5250 /// Set the codegen fast-math flags.
5251 void SetFastMathFlags(FPOptions FPFeatures);
5252
5253 // Truncate or extend a boolean vector to the requested number of elements.
5254 llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec,
5255 unsigned NumElementsDst,
5256 const llvm::Twine &Name = "");
5257
5258private:
5259 // Emits a convergence_loop instruction for the given |BB|, with |ParentToken|
5260 // as it's parent convergence instr.
5261 llvm::ConvergenceControlInst *emitConvergenceLoopToken(llvm::BasicBlock *BB);
5262
5263 // Adds a convergence_ctrl token with |ParentToken| as parent convergence
5264 // instr to the call |Input|.
5265 llvm::CallBase *addConvergenceControlToken(llvm::CallBase *Input);
5266
5267 // Find the convergence_entry instruction |F|, or emits ones if none exists.
5268 // Returns the convergence instruction.
5269 llvm::ConvergenceControlInst *
5270 getOrEmitConvergenceEntryToken(llvm::Function *F);
5271
5272private:
5273 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
5274 void EmitReturnOfRValue(RValue RV, QualType Ty);
5275
5276 void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
5277
5279 DeferredReplacements;
5280
5281 /// Set the address of a local variable.
5282 void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
5283 assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
5284 LocalDeclMap.insert({VD, Addr});
5285 }
5286
5287 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
5288 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
5289 ///
5290 /// \param AI - The first function argument of the expansion.
5291 void ExpandTypeFromArgs(QualType Ty, LValue Dst,
5292 llvm::Function::arg_iterator &AI);
5293
5294 /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg
5295 /// Ty, into individual arguments on the provided vector \arg IRCallArgs,
5296 /// starting at index \arg IRCallArgPos. See ABIArgInfo::Expand.
5297 void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
5299 unsigned &IRCallArgPos);
5300
5301 std::pair<llvm::Value *, llvm::Type *>
5302 EmitAsmInput(const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr,
5303 std::string &ConstraintStr);
5304
5305 std::pair<llvm::Value *, llvm::Type *>
5306 EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue,
5307 QualType InputType, std::string &ConstraintStr,
5309
5310 /// Attempts to statically evaluate the object size of E. If that
5311 /// fails, emits code to figure the size of E out for us. This is
5312 /// pass_object_size aware.
5313 ///
5314 /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
5315 llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
5316 llvm::IntegerType *ResType,
5317 llvm::Value *EmittedE,
5318 bool IsDynamic);
5319
5320 /// Emits the size of E, as required by __builtin_object_size. This
5321 /// function is aware of pass_object_size parameters, and will act accordingly
5322 /// if E is a parameter with the pass_object_size attribute.
5323 llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
5324 llvm::IntegerType *ResType,
5325 llvm::Value *EmittedE,
5326 bool IsDynamic);
5327
5328 llvm::Value *emitFlexibleArrayMemberSize(const Expr *E, unsigned Type,
5329 llvm::IntegerType *ResType);
5330
5331 void emitZeroOrPatternForAutoVarInit(QualType type, const VarDecl &D,
5332 Address Loc);
5333
5334public:
5335 enum class EvaluationOrder {
5336 ///! No language constraints on evaluation order.
5337 Default,
5338 ///! Language semantics require left-to-right evaluation.
5340 ///! Language semantics require right-to-left evaluation.
5342 };
5343
5344 // Wrapper for function prototype sources. Wraps either a FunctionProtoType or
5345 // an ObjCMethodDecl.
5347 llvm::PointerUnion<const FunctionProtoType *, const ObjCMethodDecl *> P;
5348
5351 };
5352
5354 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
5356 unsigned ParamsToSkip = 0,
5358
5359 /// EmitPointerWithAlignment - Given an expression with a pointer type,
5360 /// emit the value and compute our best estimate of the alignment of the
5361 /// pointee.
5362 ///
5363 /// \param BaseInfo - If non-null, this will be initialized with
5364 /// information about the source of the alignment and the may-alias
5365 /// attribute. Note that this function will conservatively fall back on
5366 /// the type when it doesn't recognize the expression and may-alias will
5367 /// be set to false.
5368 ///
5369 /// One reasonable way to use this information is when there's a language
5370 /// guarantee that the pointer must be aligned to some stricter value, and
5371 /// we're simply trying to ensure that sufficiently obvious uses of under-
5372 /// aligned objects don't get miscompiled; for example, a placement new
5373 /// into the address of a local variable. In such a case, it's quite
5374 /// reasonable to just ignore the returned alignment when it isn't from an
5375 /// explicit source.
5376 Address
5377 EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo = nullptr,
5378 TBAAAccessInfo *TBAAInfo = nullptr,
5379 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
5380
5381 /// If \p E references a parameter with pass_object_size info or a constant
5382 /// array size modifier, emit the object size divided by the size of \p EltTy.
5383 /// Otherwise return null.
5384 llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy);
5385
5386 void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK);
5387
5389 llvm::Function *Function;
5391 std::optional<StringRef> Architecture;
5392
5393 FMVResolverOption(llvm::Function *F, ArrayRef<StringRef> Feats,
5394 std::optional<StringRef> Arch = std::nullopt)
5395 : Function(F), Features(Feats), Architecture(Arch) {}
5396 };
5397
5398 // Emits the body of a multiversion function's resolver. Assumes that the
5399 // options are already sorted in the proper order, with the 'default' option
5400 // last (if it exists).
5401 void EmitMultiVersionResolver(llvm::Function *Resolver,
5403 void EmitX86MultiVersionResolver(llvm::Function *Resolver,
5405 void EmitAArch64MultiVersionResolver(llvm::Function *Resolver,
5407 void EmitRISCVMultiVersionResolver(llvm::Function *Resolver,
5409
5410private:
5411 QualType getVarArgType(const Expr *Arg);
5412
5413 void EmitDeclMetadata();
5414
5415 BlockByrefHelpers *buildByrefHelpers(llvm::StructType &byrefType,
5416 const AutoVarEmission &emission);
5417
5418 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
5419
5420 llvm::Value *GetValueForARMHint(unsigned BuiltinID);
5421 llvm::Value *EmitX86CpuIs(const CallExpr *E);
5422 llvm::Value *EmitX86CpuIs(StringRef CPUStr);
5423 llvm::Value *EmitX86CpuSupports(const CallExpr *E);
5424 llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs);
5425 llvm::Value *EmitX86CpuSupports(std::array<uint32_t, 4> FeatureMask);
5426 llvm::Value *EmitX86CpuInit();
5427 llvm::Value *FormX86ResolverCondition(const FMVResolverOption &RO);
5428 llvm::Value *EmitAArch64CpuInit();
5429 llvm::Value *FormAArch64ResolverCondition(const FMVResolverOption &RO);
5430 llvm::Value *EmitAArch64CpuSupports(const CallExpr *E);
5431 llvm::Value *EmitAArch64CpuSupports(ArrayRef<StringRef> FeatureStrs);
5432};
5433
5436 if (!needsSaving(value)) return saved_type(value, false);
5437
5438 // Otherwise, we need an alloca.
5439 auto align = CharUnits::fromQuantity(
5440 CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
5441 Address alloca =
5442 CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
5443 CGF.Builder.CreateStore(value, alloca);
5444
5445 return saved_type(alloca.emitRawPointer(CGF), true);
5446}
5447
5449 saved_type value) {
5450 // If the value says it wasn't saved, trust that it's still dominating.
5451 if (!value.getInt()) return value.getPointer();
5452
5453 // Otherwise, it should be an alloca instruction, as set up in save().
5454 auto alloca = cast<llvm::AllocaInst>(value.getPointer());
5455 return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca,
5456 alloca->getAlign());
5457}
5458
5459} // end namespace CodeGen
5460
5461// Map the LangOption for floating point exception behavior into
5462// the corresponding enum in the IR.
5463llvm::fp::ExceptionBehavior
5465} // end namespace clang
5466
5467#endif
Enums/classes describing ABI related information about constructors, destructors and thunks.
#define V(N, I)
Definition: ASTContext.h:3453
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2686
@ ForDeactivation
Definition: CGCleanup.cpp:1205
const Decl * D
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
Expr * E
unsigned OldSize
Defines the clang::Expr interface and subclasses for C++ expressions.
const CFGBlock * Block
Definition: HTMLLogger.cpp:152
#define X(type, name)
Definition: Value.h:144
llvm::MachO::Architecture Architecture
Definition: MachO.h:27
llvm::MachO::Target Target
Definition: MachO.h:51
Defines some OpenMP-specific enums and functions.
SourceRange Range
Definition: SemaObjC.cpp:758
VarDecl * Variable
Definition: SemaObjC.cpp:757
SourceLocation Loc
Definition: SemaObjC.cpp:759
const char * Data
This file defines OpenACC AST classes for statement-level contructs.
This file defines OpenMP AST classes for executable directives and clauses.
C Language Family Type Representation.
StateNode * Previous
#define bool
Definition: amdgpuintrin.h:20
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:188
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition: Expr.h:4224
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
Definition: Expr.h:6986
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2718
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3577
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
Definition: Stmt.h:3127
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition: Expr.h:6678
Attr - This represents one attribute.
Definition: Attr.h:43
Represents an attribute applied to a statement.
Definition: Stmt.h:2107
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4324
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition: Expr.h:4362
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:4359
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3909
static bool isLogicalOp(Opcode Opc)
Definition: Expr.h:4042
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:6414
BreakStmt - This represents a break.
Definition: Stmt.h:3007
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:231
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1491
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1546
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2553
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1268
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1375
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2498
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2817
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:478
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:1737
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:176
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2078
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2241
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:81
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2617
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
Represents a C++ temporary.
Definition: ExprCXX.h:1457
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1206
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:845
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1066
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2874
Describes the capture of either a variable, or 'this', or variable-length array type.
Definition: Stmt.h:3797
This captures a statement into a function.
Definition: Stmt.h:3784
CaseStmt - Represent a case statement.
Definition: Stmt.h:1828
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3547
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:3614
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
Represents a 'co_await' expression.
Definition: ExprCXX.h:5191
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
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:193
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:251
CharUnits getAlignment() const
Definition: Address.h:189
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:207
bool hasOffset() const
Definition: Address.h:242
void setAlignment(CharUnits Value)
Definition: Address.h:191
llvm::Value * getOffset() const
Definition: Address.h:244
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:181
bool isValid() const
Definition: Address.h:177
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:199
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 debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:858
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:898
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:156
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:136
llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")
Emit a load from an i1 flag variable.
Definition: CGBuilder.h:158
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:128
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:58
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
An abstract representation of regular/ObjC call/message targets.
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.
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.
RAII for correct setting/restoring of CapturedStmtInfo.
CGCapturedStmtRAII(CodeGenFunction &CGF, CGCapturedStmtInfo *NewCapturedStmtInfo)
CXXDefaultInitExprScope(CodeGenFunction &CGF, const CXXDefaultInitExpr *E)
void Emit(CodeGenFunction &CGF, Flags flags) override
Emit the cleanup.
CallLifetimeEnd(RawAddress addr, llvm::Value *size)
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, Expr *refExpr) const
A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr...
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.
InlinedInheritingConstructorScope(CodeGenFunction &CGF, GlobalDecl GD)
void rescopeLabels()
Change the cleanup scope of the labels in this lexical scope to match the scope of the enclosing cont...
Definition: CGStmt.cpp:725
LexicalScope(CodeGenFunction &CGF, SourceRange Range)
Enter a new cleanup scope.
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
~LexicalScope()
Exit this cleanup scope, emitting any accumulated cleanups.
RAII for preserving necessary info during inlined region body codegen.
InlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, llvm::BasicBlock &FiniBB)
void Emit(CodeGenFunction &CGF, Flags) override
Emit the cleanup.
RAII for preserving necessary info during Outlined region body codegen.
OutlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, llvm::BasicBlock &RetBB)
Controls insertion of cancellation exit blocks in worksharing constructs.
OMPCancelStackRAII(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel)
Save/restore original map of previously emitted local vars in case when we need to duplicate emission...
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)
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
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...
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited.
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.
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
An RAII object to record that we're evaluating a statement expression.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
llvm::Value * EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, llvm::Triple::ArchType Arch)
void emitAutoVarTypeCleanup(const AutoVarEmission &emission, QualType::DestructionKind dtorKind)
EHScopeStack::stable_iterator CurrentCleanupScopeDepth
llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)
EmitFromMemory - Change a scalar value from its memory representation to its value representation.
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
llvm::Value * EmitPointerAuthAuth(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e)
RValue EmitLoadOfGlobalRegLValue(LValue LV)
void EmitGotoStmt(const GotoStmt &S)
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)
void EmitDestructorBody(FunctionArgList &Args)
void EmitOMPTaskBasedDirective(const OMPExecutableDirective &S, const OpenMPDirectiveKind CapturedRegion, const RegionCodeGenTy &BodyGen, const TaskGenTy &TaskGen, OMPTaskDataTy &Data)
void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD)
llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)
void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S)
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
llvm::Value * EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E)
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...
LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E)
void EmitARCDestroyWeak(Address addr)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E)
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)
Enter a cleanup to destroy a __block variable.
void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile)
Create a store to.
void EmitOMPParallelGenericLoopDirective(const OMPLoopDirective &S)
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...
llvm::Value * EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr)
void EmitPointerAuthOperandBundle(const CGPointerAuthInfo &Info, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
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.
Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
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())
void EmitAsanPrologueOrEpilogue(bool Prologue)
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody)
Returns true if a loop must make progress, which means the mustprogress attribute can be added.
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)
Create a check that a scalar RValue is non-null.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
LValue EmitCastLValue(const CastExpr *E)
void EnterSEHTryStmt(const SEHTryStmt &S)
CurrentSourceLocExprScope CurSourceLocExprScope
Source location information about the default argument or member initializer expression we're evaluat...
void checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl)
llvm::Value * EmitSVEPredicateCast(llvm::Value *Pred, llvm::ScalableVectorType *VTy)
Address getExceptionSlot()
Returns a pointer to the function's exception object and selector slot, which is assigned in every la...
RawAddress CreateMemTemp(QualType T, CharUnits Align, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
bool isBinaryLogicalOp(const Expr *E) const
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
void VolatilizeTryBlocks(llvm::BasicBlock *BB, llvm::SmallPtrSet< llvm::BasicBlock *, 10 > &V)
void EmitLambdaInAllocaImplFn(const CXXMethodDecl *CallOp, const CGFunctionInfo **ImplFnInfo, llvm::Function **ImplFn)
llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.
llvm::Function * GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except)
static Destroyer destroyNonTrivialCStruct
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...
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee, const ThunkInfo *Thunk, bool IsUnprototyped)
void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, CXXCtorType CtorType, const FunctionArgList &Args, SourceLocation Loc)
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
static bool cxxDestructorCanThrow(QualType T)
Check if T is a C++ class that has a destructor that can throw.
void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, const FunctionArgList &Args)
llvm::Function * GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk)
SanitizerSet SanOpts
Sanitizers enabled for this function.
RValue EmitBuiltinIsAligned(const CallExpr *E)
Emit IR for __builtin_is_aligned.
LValue EmitCoawaitLValue(const CoawaitExpr *E)
llvm::BasicBlock * getInvokeDestImpl()
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
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 EmitIfStmt(const IfStmt &S)
void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator, CallArgList &CallArgs, const CGFunctionInfo *CallOpFnInfo=nullptr, llvm::Constant *CallOpFn=nullptr)
void EmitWhileStmt(const WhileStmt &S, ArrayRef< const Attr * > Attrs={})
void EmitOMPOrderedDirective(const OMPOrderedDirective &S)
void EmitOMPTargetDirective(const OMPTargetDirective &S)
void PushDestructorCleanup(const CXXDestructorDecl *Dtor, QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object variant of the given destructor on...
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...
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
bool IsOutlinedSEHHelper
True if the current function is an outlined SEH helper.
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.
bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
void EmitARCMoveWeak(Address dst, Address src)
LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, llvm::Value *&Result)
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
void EmitAArch64MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
void EmitOMPReductionClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope, bool ForInscan=false)
Emit initial code for reduction variables.
llvm::Value * EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
void EmitOMPAtomicDirective(const OMPAtomicDirective &S)
void EmitVTableAssumptionLoad(const VPtr &vptr, Address This)
Emit assumption that vptr load == global vtable.
void unprotectFromPeepholes(PeepholeProtection protection)
Address getAsNaturalAddressOf(Address Addr, QualType PointeeTy)
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)
void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S)
llvm::Value * EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void EmitOMPParallelMasterTaskLoopDirective(const OMPParallelMasterTaskLoopDirective &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...
void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, const ObjCMethodDecl *GetterMothodDecl, llvm::Constant *AtomicHelperFn)
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
void GetAArch64SVEProcessedOperands(unsigned BuiltinID, const CallExpr *E, SmallVectorImpl< llvm::Value * > &Ops, SVETypeFlags TypeFlags)
llvm::Value * EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
llvm::Value * EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
llvm::Constant * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)
LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, AlignmentSource Source=AlignmentSource::Type)
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
static void EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDirective &S)
Emit device code for the target teams directive.
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
void callCStructDefaultConstructor(LValue Dst)
void EmitOMPReverseDirective(const OMPReverseDirective &S)
static bool hasScalarEvaluationKind(QualType T)
llvm::Value * EmitObjCAutoreleasePoolPush()
bool isCleanupPadScope() const
Returns true while emitting a cleanuppad.
llvm::Value * EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx)
void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
void EmitOpenACCExitDataConstruct(const OpenACCExitDataConstruct &S)
llvm::Value * EmitARCRetainAutoreleaseNonBlock(llvm::Value *value)
void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr)
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
AwaitSuspendWrapperInfo CurAwaitSuspendWrapper
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
void EmitMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
llvm::function_ref< std::pair< llvm::Value *, llvm::Value * >(CodeGenFunction &, const OMPExecutableDirective &S, Address LB, Address UB)> CodeGenDispatchBoundsTy
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
CGCapturedStmtInfo * CapturedStmtInfo
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
BuiltinCheckKind
Specifies which type of sanitizer check to apply when handling a particular builtin.
void EmitIndirectGotoStmt(const IndirectGotoStmt &S)
LValue EmitCallExprLValue(const CallExpr *E, llvm::CallBase **CallOrInvoke=nullptr)
void EmitDecl(const Decl &D)
EmitDecl - Emit a declaration.
LValue MakeNaturalAlignPointeeRawAddrLValue(llvm::Value *V, QualType T)
Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known to be unsigned.
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.
Address authPointerToPointerCast(Address Ptr, QualType SourceType, QualType DestType)
void EmitCXXTryStmt(const CXXTryStmt &S)
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 EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID, bool NoMerge=false)
Create a basic block that will call the trap intrinsic, and emit a conditional branch to it,...
std::pair< LValue, llvm::Value * > EmitARCStoreStrong(const BinaryOperator *e, bool ignored)
void EmitKCFIOperandBundle(const CGCallee &Callee, SmallVectorImpl< llvm::OperandBundleDef > &Bundles)
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)
llvm::Value * EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind)
Emits an argument for a call to a builtin.
bool EmitSimpleStmt(const Stmt *S, ArrayRef< const Attr * > Attrs)
EmitSimpleStmt - Try to emit a "simple" statement which does not necessarily require an insertion poi...
LValue EmitHLSLArrayAssignLValue(const BinaryOperator *E)
void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped)
Generate a thunk for the given method.
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
llvm::Value * EmitARCRetainAutoreleasedReturnValue(llvm::Value *value)
void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue, llvm::Value *TheCheck, llvm::Instruction *Assumption)
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
static void EmitOMPTargetTeamsDistributeDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeDirective &S)
Emit device code for the target teams distribute directive.
Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Load a pointer with type PtrTy stored at address Ptr.
RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
static void EmitOMPTargetParallelForSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelForSimdDirective &S)
Emit device code for the target parallel for simd directive.
llvm::Value * EmitObjCAllocWithZone(llvm::Value *value, llvm::Type *returnType)
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, llvm::Value *NumElements, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=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...
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...
llvm::Value * EmitSVEGatherLoad(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=false)
void popCatchScope()
popCatchScope - Pops the catch scope at the top of the EHScope stack, emitting any required code (oth...
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
llvm::Value * EmitRISCVCpuSupports(const CallExpr *E)
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual)
Determine whether a base class initialization may overlap some other object.
void EmitLabel(const LabelDecl *D)
EmitLabel - Emit the block for the given label.
const OMPExecutableDirective * OMPParentLoopDirectiveForScan
Parent loop-based directive for scan directive.
llvm::Value * EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void EmitOpenACCInitConstruct(const OpenACCInitConstruct &S)
void EmitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &S)
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
void EmitOMPTaskDirective(const OMPTaskDirective &S)
RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)
void EmitOMPScanDirective(const OMPScanDirective &S)
void EmitAnyExprToExn(const Expr *E, Address Addr)
void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)
JumpDest getOMPCancelDestination(OpenMPDirectiveKind Kind)
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)
RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow, const Expr *Base, llvm::CallBase **CallOrInvoke)
void EmitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &S)
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
SmallVector< llvm::ConvergenceControlInst *, 4 > ConvergenceTokenStack
Stack to track the controlled convergence tokens.
llvm::Value * EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
void EmitOMPUseDevicePtrClause(const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope, const llvm::DenseMap< const ValueDecl *, llvm::Value * > CaptureDeviceAddrMap)
RValue emitBuiltinOSLogFormat(const CallExpr &E)
Emit IR for __builtin_os_log_format.
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
bool isSEHTryScope() const
Returns true inside SEH __try blocks.
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.
llvm::Value * EmitARCAutorelease(llvm::Value *value)
llvm::Value * emitPointerAuthResignCall(llvm::Value *Pointer, const CGPointerAuthInfo &CurInfo, const CGPointerAuthInfo &NewInfo)
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
llvm::Value * EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart)
Emits a call to an LLVM variable-argument intrinsic, either llvm.va_start or llvm....
void EmitOMPDistributeLoop(const OMPLoopDirective &S, const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr)
Emit code for the distribute loop-based directive.
void EmitARCNoopIntrinsicUse(ArrayRef< llvm::Value * > values)
bool hasVolatileMember(QualType T)
hasVolatileMember - returns true if aggregate type has a volatile member.
llvm::Value * EmitSVEMaskedStore(const CallExpr *, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)
void EmitOMPTaskLoopBasedDirective(const OMPLoopDirective &S)
void callCStructMoveConstructor(LValue Dst, LValue Src)
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
llvm::Value * EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty)
llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)
llvm::Value * getAsNaturalPointerTo(Address Addr, QualType PointeeType)
llvm::BasicBlock * getEHResumeBlock(bool isCleanup)
static void EmitOMPTargetDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetDirective &S)
Emit device code for the target directive.
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
LValue EmitBinaryOperatorLValue(const BinaryOperator *E)
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
void callCStructCopyConstructor(LValue Dst, LValue Src)
void EmitCaseStmt(const CaseStmt &S, ArrayRef< const Attr * > Attrs)
RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO, const llvm::function_ref< RValue(RValue)> &UpdateOp, bool IsVolatile)
RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)
LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
llvm::Value * EmitSEHExceptionInfo()
RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp)
Emit IR for __builtin_align_up/__builtin_align_down.
llvm::Value * EmitARCLoadWeakRetained(Address addr)
void EmitDefaultStmt(const DefaultStmt &S, ArrayRef< const Attr * > Attrs)
const LangOptions & getLangOpts() const
llvm::Value * LoadPassedObjectSize(const Expr *E, QualType EltTy)
If E references a parameter with pass_object_size info or a constant array size modifier,...
llvm::Value * EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FAMDecl, const FieldDecl *CountDecl)
Build an expression accessing the "counted_by" field.
static void EmitOMPTargetSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetSimdDirective &S)
Emit device code for the target simd directive.
void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S)
llvm::Value * EmitObjCProtocolExpr(const ObjCProtocolExpr *E)
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope, llvm::AtomicOrdering &AO, llvm::SyncScope::ID &SSID)
void EmitOMPPrivateLoopCounters(const OMPLoopDirective &S, OMPPrivateScope &LoopScope)
Emit initial code for loop counters of loop-based directives.
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.
void pushEHDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...
void EmitOpenACCShutdownConstruct(const OpenACCShutdownConstruct &S)
LValue EmitInitListLValue(const InitListExpr *E)
llvm::Value * EmitARCRetainAutorelease(QualType type, llvm::Value *value)
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
bool InNoConvergentAttributedStmt
True if the current statement has noconvergent attribute.
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 EmitOMPInterchangeDirective(const OMPInterchangeDirective &S)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, Address Addr, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
llvm::Function * generateAwaitSuspendWrapper(Twine const &CoroName, Twine const &SuspendPointName, CoroutineSuspendExpr const &S)
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
void EmitUnreachable(SourceLocation Loc)
Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.
static bool isInstrumentedCondition(const Expr *C)
isInstrumentedCondition - Determine whether the given condition is an instrumentable condition (i....
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
void EmitOMPTeamsGenericLoopDirective(const OMPTeamsGenericLoopDirective &S)
bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
void pushDestroyAndDeferDeactivation(QualType::DestructionKind dtorKind, Address addr, QualType type)
void EmitFunctionBody(const Stmt *Body)
VlaSizePair getVLAElements1D(QualType vla)
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...
llvm::Value * EmitSVETupleCreate(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType, ArrayRef< llvm::Value * > Ops)
const CodeGen::CGBlockInfo * BlockInfo
void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)
void EmitAggregateCopyCtor(LValue Dest, LValue Src, AggValueSlot::Overlap_t MayOverlap)
llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, llvm::Type *VTableTy, uint64_t VTableByteOffset)
Emit a type checked load from the given vtable.
void pushDestroyAndDeferDeactivation(CleanupKind cleanupKind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
void EmitRISCVMultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
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.
SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)
void markStmtAsUsed(bool Skipped, const Stmt *S)
void EmitOpenACCWaitConstruct(const OpenACCWaitConstruct &S)
llvm::Value * EmitObjCBoxedExpr(const ObjCBoxedExpr *E)
llvm::AllocaInst * EHSelectorSlot
The selector slot.
llvm::Value * EmitCheckedArgForAssume(const Expr *E)
Emits an argument for a call to a __builtin_assume.
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
void EmitOMPParallelMaskedTaskLoopDirective(const OMPParallelMaskedTaskLoopDirective &S)
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...
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, const Twine &name="")
void emitByrefStructureInit(const AutoVarEmission &emission)
void SimplifyForwardingBlocks(llvm::BasicBlock *BB)
SimplifyForwardingBlocks - If the given basic block is only a branch to another basic block,...
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type,...
void callCStructDestructor(LValue Dst)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
llvm::Value * EmitObjCRetainNonBlock(llvm::Value *value, llvm::Type *returnType)
llvm::Value * GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, bool Delegating)
GetVTTParameter - Return the VTT parameter that should be passed to a base constructor/destructor wit...
RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)
void EmitOMPParallelDirective(const OMPParallelDirective &S)
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...
llvm::Value * EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType)
Address EmitExtVectorElementLValue(LValue V)
void EmitOMPSimdFinal(const OMPLoopDirective &D, const llvm::function_ref< llvm::Value *(CodeGenFunction &)> CondGen)
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...
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.
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
llvm::Value * EmitSMELdrStr(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
void SetDivFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
void EmitContinueStmt(const ContinueStmt &S)
void setCurrentProfileCount(uint64_t Count)
Set the profiler's current count.
llvm::BasicBlock * getTerminateFunclet()
getTerminateLandingPad - Return a cleanup funclet that just calls terminate.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo, bool isInit=false, bool isNontemporal=false)
bool InNoMergeAttributedStmt
True if the current statement has nomerge attribute.
LValue EmitUnsupportedLValue(const Expr *E, const char *Name)
EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue an ErrorUnsupported style ...
llvm::Value * EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx, const llvm::ElementCount &Count)
VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass)
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.
llvm::Type * ConvertTypeForMem(QualType T)
llvm::Function * createTLSAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr, llvm::FunctionCallee &AtExit)
Address EmitCheckedInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *elementType, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, CharUnits Align, const Twine &Name="")
void EmitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &S)
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
LValue MakeAddrLValueWithoutTBAA(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitAutoVarInit(const AutoVarEmission &emission)
llvm::BasicBlock * getUnreachableBlock()
void EmitOMPForSimdDirective(const OMPForSimdDirective &S)
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 GenerateOpenMPCapturedVars(const CapturedStmt &S, SmallVectorImpl< llvm::Value * > &CapturedVars)
void EmitNonNullArgCheck(Address Addr, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum)
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
bool isPointerKnownNonNull(const Expr *E)
RawAddress CreateMemTempWithoutCast(QualType T, CharUnits Align, const Twine &Name="tmp")
llvm::Value * EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID, bool IsZExtReturn)
bool AlwaysEmitXRayCustomEvents() const
AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit XRay custom event handling c...
llvm::SmallVector< const JumpDest *, 2 > SEHTryEpilogueStack
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
JumpDest ReturnBlock
ReturnBlock - Unified return block.
DominatingValue< T >::saved_type saveValueInCond(T value)
const llvm::function_ref< void(CodeGenFunction &, llvm::Function *, const OMPTaskDataTy &)> TaskGenTy
static void EmitOMPTargetTeamsGenericLoopDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsGenericLoopDirective &S)
Emit device code for the target teams loop directive.
llvm::Value * ExceptionSlot
The exception slot.
unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex)
Get the record field index as represented in debug info.
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
QualType TypeOfSelfObject()
TypeOfSelfObject - Return type of object that this self represents.
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.
llvm::Value * EmitSVEDupX(llvm::Value *Scalar)
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...
void EmitOMPFlushDirective(const OMPFlushDirective &S)
void EmitStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
void markStmtMaybeUsed(const Stmt *S)
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
@ ForceLeftToRight
! Language semantics require left-to-right evaluation.
@ Default
! No language constraints on evaluation order.
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
void EmitAttributedStmt(const AttributedStmt &S)
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
llvm::BasicBlock * OMPBeforeScanBlock
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...
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
void EmitOMPCancelDirective(const OMPCancelDirective &S)
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > VisitedVirtualBasesSetTy
void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
void EmitOMPGenericLoopDirective(const OMPGenericLoopDirective &S)
llvm::Value * EmitPointerAuthSign(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
void EmitOMPTargetTeamsDistributeDirective(const OMPTargetTeamsDistributeDirective &S)
void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
void pushCleanupAndDeferDeactivation(CleanupKind Kind, As... A)
void EmitAtomicInit(Expr *E, LValue lvalue)
static const Expr * stripCond(const Expr *C)
Ignore parentheses and logical-NOT to track conditions consistently.
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
llvm::DenseMap< const Decl *, Address > DeclMapTy
void EmitCaseStmtRange(const CaseStmt &S, ArrayRef< const Attr * > Attrs)
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we're intending to store to the side, but which will prob...
ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr)
llvm::Value * EmitARCLoadWeak(Address addr)
const TargetInfo & getTarget() const
void initFullExprCleanup()
Set up the last cleanup that was pushed as a conditional full-expression cleanup.
LValue EmitCXXConstructLValue(const CXXConstructExpr *E)
llvm::Value * EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy, QualType RTy)
void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S)
static void EmitOMPTargetTeamsDistributeParallelForDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeParallelForDirective &S)
void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy, SourceLocation Loc)
bool isInConditionalBranch() const
isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...
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.
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
void EmitCXXForRangeStmt(const CXXForRangeStmt &S, ArrayRef< const Attr * > Attrs={})
llvm::Value * EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress, llvm::Value *Discriminator)
Create the discriminator from the storage address and the entity hash.
llvm::Constant * GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo)
llvm::Value * vectorWrapScalar16(llvm::Value *Op)
llvm::Function * LookupNeonLLVMIntrinsic(unsigned IntrinsicID, unsigned Modifier, llvm::Type *ArgTy, const CallExpr *E)
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
void EmitLabelStmt(const LabelStmt &S)
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
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.
llvm::Value * EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType)
LValue EmitVAArgExprLValue(const VAArgExpr *E)
llvm::Value * EmitSEHExceptionCode()
bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, SourceLocation Loc)
Check if the scalar Value is within the valid range for the given type Ty.
llvm::Value * EmitObjCCollectionLiteral(const Expr *E, const ObjCMethodDecl *MethodWithObjects)
void EmitOMPDepobjDirective(const OMPDepobjDirective &S)
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
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...
llvm::Value * EmitMatrixIndexExpr(const Expr *E)
llvm::Value * EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
EmitTargetBuiltinExpr - Emit the given builtin call.
void GenerateCXXGlobalCleanUpFunc(llvm::Function *Fn, ArrayRef< std::tuple< llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant * > > DtorsOrStermFinalizers)
GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global variables.
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
const Expr * RetExpr
If a return statement is being visited, this holds the return statment's result expression.
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
LValue EmitCoyieldLValue(const CoyieldExpr *E)
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
void EmitX86MultiVersionResolver(llvm::Function *Resolver, ArrayRef< FMVResolverOption > Options)
RValue EmitAnyExprToTemp(const Expr *E)
EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...
void pushCleanupAfterFullExpr(CleanupKind Kind, As... A)
Queue a cleanup to be pushed after finishing the current full-expression, potentially with an active ...
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
llvm::Value * emitPointerAuthResign(llvm::Value *Pointer, QualType PointerType, const CGPointerAuthInfo &CurAuthInfo, const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull)
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....
void EmitOMPSingleDirective(const OMPSingleDirective &S)
std::pair< LValue, llvm::Value * > EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored)
ComplexPairTy EmitPromotedComplexExpr(const Expr *E, QualType PromotionType)
void pushFullExprCleanup(CleanupKind kind, As... A)
pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.
RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID)
void initFullExprCleanupWithFlag(RawAddress ActiveFlag)
llvm::Value * EmitAArch64SMEBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void EmitOMPTargetTeamsGenericLoopDirective(const OMPTargetTeamsGenericLoopDirective &S)
RValue EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E)
void EmitReturnValueCheck(llvm::Value *RV)
Emit a test that checks if the return value RV is nonnull.
llvm::BasicBlock * getInvokeDest()
Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const CallExpr *TheCallExpr, bool IsDelete)
Address mergeAddressesInConditionalExpr(Address LHS, Address RHS, llvm::BasicBlock *LHSBlock, llvm::BasicBlock *RHSBlock, llvm::BasicBlock *MergeBlock, QualType MergedType)
llvm::CanonicalLoopInfo * EmitOMPCollapsedCanonicalLoopNest(const Stmt *S, int Depth)
Emit the Stmt S and return its topmost canonical loop, if any.
llvm::Value * EmitRISCVCpuSupports(ArrayRef< StringRef > FeaturesStrs)
LValue EmitUnaryOpLValue(const UnaryOperator *E)
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
RValue EmitUnsupportedRValue(const Expr *E, const char *Name)
EmitUnsupportedRValue - Emit a dummy r-value using the type of E and issue an ErrorUnsupported style ...
void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO, bool IsVolatile, bool isInit)
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
void EmitARCCopyWeak(Address dst, Address src)
void maybeResetMCDCCondBitmap(const Expr *E)
Zero-init the MCDC temp value.
static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts)
getAccessedFieldNo - Given an encoded value and a result number, return the input field number being ...
void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D)
Emit simple code for OpenMP directives in Simd-only mode.
void EmitForStmt(const ForStmt &S, ArrayRef< const Attr * > Attrs={})
void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc)
RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
void PushDestructorCleanup(QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object destructor of an object of the giv...
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, AggValueSlot ThisAVS, const CXXConstructExpr *E)
void EmitOMPDistributeDirective(const OMPDistributeDirective &S)
CGCallee BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD, CXXDtorType Type, const CXXRecordDecl *RD)
void EmitOpenACCCombinedConstruct(const OpenACCCombinedConstruct &S)
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.
void EmitOMPParallelForDirective(const OMPParallelForDirective &S)
void EmitOMPTeamsDirective(const OMPTeamsDirective &S)
bool ShouldSkipSanitizerInstrumentation()
ShouldSkipSanitizerInstrumentation - Return true if the current function should not be instrumented w...
uint64_t getCurrentProfileCount()
Get the profiler's current count.
auto getIsCounterPair(const Stmt *S) const
void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, llvm::Value *Index, QualType IndexType, QualType IndexedType, bool Accessed)
llvm::Value * EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty)
llvm::Value * EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
SmallVector< const BinaryOperator *, 16 > MCDCLogOpStack
Stack to track the Logical Operator recursion nest for MC/DC.
llvm::Value * EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty, const llvm::CmpInst::Predicate Fp, const llvm::CmpInst::Predicate Ip, const llvm::Twine &Name="")
void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)
void defaultInitNonTrivialCStructVar(LValue Dst)
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.
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
RValue EmitLoadOfExtVectorElementLValue(LValue V)
llvm::ScalableVectorType * getSVEType(const SVETypeFlags &TypeFlags)
void EmitOMPUnrollDirective(const OMPUnrollDirective &S)
void EmitOMPParallelMasterTaskLoopSimdDirective(const OMPParallelMasterTaskLoopSimdDirective &S)
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke=nullptr, bool IsMustTail=false)
void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)
EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...
void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S)
RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
RValue emitRotate(const CallExpr *E, bool IsRotateRight)
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type,...
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
void EmitSwitchStmt(const SwitchStmt &S)
LValue EmitLValueForLambdaField(const FieldDecl *Field, llvm::Value *ThisValue)
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
LValue EmitComplexAssignmentLValue(const BinaryOperator *E)
Emit an l-value for an assignment (simple or compound) of complex type.
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
void EmitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &S)
Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP)
Recovers the address of a local in a parent function.
const FieldDecl * FindFlexibleArrayMemberFieldAndOffset(ASTContext &Ctx, const RecordDecl *RD, const FieldDecl *FAMDecl, uint64_t &Offset)
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 * EmitRISCVCpuIs(const CallExpr *E)
LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E)
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...
Address EmitVAListRef(const Expr *E)
LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E)
Address emitAddrOfImagComponent(Address complex, QualType complexType)
Address emitBlockByrefAddress(Address baseAddr, const BlockByrefInfo &info, bool followForward, const llvm::Twine &name)
LValue EmitDeclRefLValue(const DeclRefExpr *E)
llvm::Value * EmitLoadOfScalar(LValue lvalue, SourceLocation Loc)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
void EmitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &S)
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)
Determine whether a field initialization may overlap some other object.
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::Function * GenerateCapturedStmtFunction(const CapturedStmt &S)
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
void EmitSEHTryStmt(const SEHTryStmt &S)
void maybeCreateMCDCCondBitmap()
Allocate a temp value on the stack that MCDC can use to track condition results.
void EmitOMPInteropDirective(const OMPInteropDirective &S)
llvm::Value * EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty, bool negateForRightShift)
void ExitSEHTryStmt(const SEHTryStmt &S)
llvm::Constant * GenerateCopyHelperFunction(const CGBlockInfo &blockInfo)
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
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 * unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub)
Call unatexit() with function dtorStub.
llvm::BasicBlock * OMPScanDispatch
llvm::BasicBlock * getTerminateLandingPad()
getTerminateLandingPad - Return a landing pad that just calls terminate.
llvm::BasicBlock * getTerminateHandler()
getTerminateHandler - Return a handler (not a landing pad, just a catch handler) that just calls term...
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr)
llvm::Value * EmitSVEMovl(const SVETypeFlags &TypeFlags, llvm::ArrayRef< llvm::Value * > Ops, unsigned BuiltinID)
llvm::function_ref< std::pair< LValue, LValue >(CodeGenFunction &, const OMPExecutableDirective &S)> CodeGenLoopBoundsTy
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
const TargetCodeGenInfo & getTargetHooks() const
void setBeforeOutermostConditional(llvm::Value *value, Address addr, CodeGenFunction &CGF)
llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")
LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)
LValue EmitPredefinedLValue(const PredefinedExpr *E)
llvm::Value * EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
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...
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
llvm::Type * getEltType(const SVETypeFlags &TypeFlags)
CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false)
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
void EmitOMPTargetTaskBasedDirective(const OMPExecutableDirective &S, const RegionCodeGenTy &BodyGen, OMPTargetDataInfo &InputInfo)
void EmitDeclStmt(const DeclStmt &S)
void EmitOMPScopeDirective(const OMPScopeDirective &S)
bool ShouldXRayInstrumentFunction() const
ShouldXRayInstrument - Return true if the current function should be instrumented with XRay nop sleds...
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
bool InNoInlineAttributedStmt
True if the current statement has noinline attribute.
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor)
llvm::Function * GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &Info, const DeclMapTy &ldm, bool IsLambdaConversionToBlock, bool BuildGlobalBlock)
void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst)
void EmitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &S)
static void EmitOMPTargetParallelForDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelForDirective &S)
Emit device code for the target parallel for directive.
llvm::Value * EmitSVEPMull(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned BuiltinID)
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void EmitCoroutineBody(const CoroutineBodyStmt &S)
RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)
EmitToMemory - Change a scalar value from its value representation to its in-memory representation.
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, Address This, CallArgList &Args, AggValueSlot::Overlap_t Overlap, SourceLocation Loc, bool NewPointerIsChecked, llvm::CallBase **CallOrInvoke=nullptr)
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
llvm::Value * EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy, QualType RTy)
void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
bool IsInPreservedAIRegion
True if CodeGen currently emits code inside presereved access index region.
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
llvm::Value * authPointerToPointerCast(llvm::Value *ResultPtr, QualType SourceType, QualType DestType)
bool AlwaysEmitXRayTypedEvents() const
AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit XRay typed event handling ...
void pushCleanupAfterFullExprWithActiveFlag(CleanupKind Kind, RawAddress ActiveFlag, As... A)
void SetSqrtFPAccuracy(llvm::Value *Val)
Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.
void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub)
Call atexit() with function dtorStub.
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,...
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.
void EmitOMPSimdInit(const OMPLoopDirective &D)
Helpers for the OpenMP loop directives.
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
llvm::Value * EmitSVEScatterStore(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
void EmitConstructorBody(FunctionArgList &Args)
void SetFastMathFlags(FPOptions FPFeatures)
Set the codegen fast-math flags.
int ExpectedOMPLoopDepth
Number of nested loop to be consumed by the last surrounding loop-associated directive.
void EmitVarDecl(const VarDecl &D)
EmitVarDecl - Emit a local variable declaration.
llvm::Value * EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value)
void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::Value * EmitBuiltinAvailable(const VersionTuple &Version)
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier *Qual, llvm::Type *Ty)
LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E)
void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This)
Emit assumption load for all bases.
llvm::Function * generateBuiltinOSLogHelperFunction(const analyze_os_log::OSLogBufferLayout &Layout, CharUnits BufferAlignment)
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...
CGCallee EmitCallee(const Expr *E)
llvm::Value * EmitBlockLiteral(const BlockExpr *)
Emit block literal.
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.
void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)
EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
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="")
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
ComplexPairTy EmitUnPromotedValue(ComplexPairTy result, QualType PromotionType)
LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy)
llvm::Value * EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx, const CallExpr *E)
void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val)
Update the MCDC temp value with the condition's evaluated result.
static void EmitOMPTargetTeamsDistributeSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeSimdDirective &S)
Emit device code for the target teams distribute simd directive.
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
void EmitLambdaInAllocaCallOpBody(const CXXMethodDecl *MD)
std::pair< LValue, LValue > EmitHLSLOutArgLValues(const HLSLOutArgExpr *E, QualType Ty)
SmallVector< llvm::CanonicalLoopInfo *, 4 > OMPLoopNestStack
List of recently emitted OMPCanonicalLoops.
bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB, const CodeGenLoopBoundsTy &CodeGenLoopBounds, const CodeGenDispatchBoundsTy &CGDispatchBounds)
Emit code for the worksharing loop-based directive.
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
llvm::Value * LoadCXXVTT()
LoadCXXVTT - Load the VTT parameter to base constructors/destructors have virtual bases.
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
void EmitOpenACCLoopConstruct(const OpenACCLoopConstruct &S)
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
void EmitOMPLinearClause(const OMPLoopDirective &D, CodeGenFunction::OMPPrivateScope &PrivateScope)
Emit initial code for linear clauses.
llvm::Instruction * getPostAllocaInsertPoint()
Return PostAllocaInsertPt.
void StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo, bool IsUnprototyped)
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 ...
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
LValue EmitMemberExpr(const MemberExpr *E)
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, bool Accessed=false)
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...
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...
Address ReturnValuePointer
ReturnValuePointer - The temporary alloca to hold a pointer to sret.
llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const
Return a type hash constant for a function instrumented by -fsanitize=function.
ComplexPairTy EmitPromotedValue(ComplexPairTy result, QualType PromotionType)
llvm::Value * SEHInfo
Value returned by __exception_info intrinsic.
llvm::Value * BuildVector(ArrayRef< llvm::Value * > Ops)
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})
EmitStmt - Emit the code for the statement.
ConstantEmission tryEmitAsConstant(const MemberExpr *ME)
llvm::Value * EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)
void EmitAutoVarCleanups(const AutoVarEmission &emission)
llvm::GlobalVariable * AddInitializerToStaticVarDecl(const VarDecl &D, llvm::GlobalVariable *GV)
AddInitializerToStaticVarDecl - Add the initializer for 'D' to the global variable that has already b...
llvm::Value * EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
void EmitOMPTileDirective(const OMPTileDirective &S)
llvm::Value * GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FAMDecl, const FieldDecl *CountDecl)
void PopCleanupBlock(bool FallThroughIsBranchThrough=false, bool ForDeactivation=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
bool EmitOMPLinearClauseInit(const OMPLoopDirective &D)
Emit initial code for linear variables.
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
llvm::Value * EmitPromotedScalarExpr(const Expr *E, QualType PromotionType)
llvm::BasicBlock * EmitLandingPad()
Emits a landing pad for the current EH stack.
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
llvm::Function * EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K)
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...
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="")
void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit)
Helper for the OpenMP loop directives.
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
VlaSizePair getVLASize(QualType vla)
llvm::Value * EmitSVEPredicateTupleCast(llvm::Value *PredTuple, llvm::StructType *Ty)
llvm::Value * EmitObjCMRRAutoreleasePoolPush()
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size)
void maybeUpdateMCDCTestVectorBitmap(const Expr *E)
Increment the profiler's counter for the given expression by StepV.
void EmitOMPLinearClauseFinal(const OMPLoopDirective &D, const llvm::function_ref< llvm::Value *(CodeGenFunction &)> CondGen)
Emit final code for linear clauses.
llvm::Type * ConvertType(QualType T)
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)
void EmitOMPSectionsDirective(const OMPSectionsDirective &S)
void EmitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct &S)
Address GetAddrOfBlockDecl(const VarDecl *var)
CodeGenTypes & getTypes() const
void EmitWritebacks(const CallArgList &Args)
EmitWriteback - Emit callbacks for function.
void EmitARCInitWeak(Address addr, llvm::Value *value)
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
LValue EmitArraySectionExpr(const ArraySectionExpr *E, bool IsLowerBound=true)
llvm::BasicBlock * OMPScanExitBlock
llvm::Value * EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
static void EmitOMPTargetTeamsDistributeParallelForSimdDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeParallelForSimdDirective &S)
Emit device code for the target teams distribute parallel for simd directive.
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E)
llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")
void EmitDoStmt(const DoStmt &S, ArrayRef< const Attr * > Attrs={})
llvm::Value * EmitRISCVCpuIs(StringRef CPUStr)
void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst)
Address EmitCXXUuidofExpr(const CXXUuidofExpr *E)
bool InAlwaysInlineAttributedStmt
True if the current statement has always_inline attribute.
RawAddress CreateTempAlloca(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr, RawAddress *Alloca=nullptr)
void EmitOMPUseDeviceAddrClause(const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope, const llvm::DenseMap< const ValueDecl *, llvm::Value * > CaptureDeviceAddrMap)
void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, llvm::Constant *AtomicHelperFn)
void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S)
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)
void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType)
EmitCallArg - Emit a single call argument.
llvm::Value * EmitSMEReadWrite(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
void EmitOpenACCComputeConstruct(const OpenACCComputeConstruct &S)
void EmitOMPSimdDirective(const OMPSimdDirective &S)
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
llvm::Value * EmitSMELd1St1(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
void EmitOMPCriticalDirective(const OMPCriticalDirective &S)
llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs
Save Parameter Decl for coroutine.
void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
ActivateCleanupBlock - Activates an initially-inactive cleanup.
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, size_t OldLifetimeExtendedStackSize, std::initializer_list< llvm::Value ** > ValuesToReload={})
Takes the old cleanup stack size and emits the cleanup blocks that have been added,...
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit)
llvm::Value * EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
LValue EmitStringLiteralLValue(const StringLiteral *E)
void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)
Scan the outlined statement for captures from the parent function.
static Destroyer destroyARCStrongPrecise
void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)
RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E)
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
void EmitOMPForDirective(const OMPForDirective &S)
void EmitOMPMetaDirective(const OMPMetaDirective &S)
void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, FunctionArgList &Args)
RawAddress NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc, llvm::AtomicOrdering AO, bool IsVolatile=false, AggValueSlot slot=AggValueSlot::ignored())
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
llvm::Value * EmitSVEStructLoad(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S)
LValue InitCapturedStruct(const CapturedStmt &S)
void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S)
void EmitReturnStmt(const ReturnStmt &S)
AggValueSlot::Overlap_t getOverlapForReturnValue()
Determine whether a return value slot may overlap some other object.
RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD, CallArgList &CallArgs)
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression,...
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 ...
LValue EmitOMPSharedLValue(const Expr *E)
Emits the lvalue for the expression with possibly captured variable.
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 EmitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &S)
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
void processInReduction(const OMPExecutableDirective &S, OMPTaskDataTy &Data, CodeGenFunction &CGF, const CapturedStmt *CS, OMPPrivateScope &Scope)
void EmitOMPMasterDirective(const OMPMasterDirective &S)
void EmitOpenACCHostDataConstruct(const OpenACCHostDataConstruct &S)
void EmitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &S)
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters.
void EmitOpenACCUpdateConstruct(const OpenACCUpdateConstruct &S)
void EmitOMPTargetParallelGenericLoopDirective(const OMPTargetParallelGenericLoopDirective &S)
void pushStackRestore(CleanupKind kind, Address SPMem)
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
llvm::Value * EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt, llvm::Type *Ty, bool usgn, const char *name)
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property.
void EmitOMPAssumeDirective(const OMPAssumeDirective &S)
bool EmitOMPCopyinClause(const OMPExecutableDirective &D)
Emit code for copyin clause in D directive.
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope,...
SmallVector< llvm::Type *, 2 > getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType, ArrayRef< llvm::Value * > Ops)
void EmitOMPMaskedDirective(const OMPMaskedDirective &S)
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E)
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
static bool hasAggregateEvaluationKind(QualType T)
void EmitOMPPrivateClause(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)
llvm::Function * GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S, SourceLocation Loc)
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
void EmitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &S)
RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo, bool isNontemporal=false)
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
void SetFPAccuracy(llvm::Value *Val, float Accuracy)
SetFPAccuracy - Set the minimum required accuracy of the given floating point operation,...
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
void EmitBreakStmt(const BreakStmt &S)
Address GenerateCapturedStmtArgument(const CapturedStmt &S)
void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)
static void EmitOMPTargetParallelGenericLoopDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelGenericLoopDirective &S)
Emit device code for the target parallel loop directive.
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of 'this'.
llvm::function_ref< void(CodeGenFunction &, SourceLocation, const unsigned, const bool)> CodeGenOrderedTy
llvm::Value * EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Triple::ArchType Arch)
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
LValue EmitLoadOfReferenceLValue(LValue RefLVal)
const CGFunctionInfo * CurFnInfo
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const
isObviouslyBranchWithoutCleanups - Return true if a branch to the specified destination obviously has...
llvm::Value * EmitSVEStructStore(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
llvm::BasicBlock * getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope)
void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)
llvm::Value * getArrayInitIndex()
Get the index of the current ArrayInitLoopExpr, if any.
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
void pushKmpcAllocFree(CleanupKind Kind, std::pair< llvm::Value *, llvm::Value * > AddrSizePair)
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo)
EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
llvm::Value * EmitSEHAbnormalTermination()
void EmitCfiSlowPathCheck(SanitizerMask Kind, 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.
void EmitCoreturnStmt(const CoreturnStmt &S)
void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type)
EnterDtorCleanups - Enter the cleanups necessary to complete the given phase of destruction for a des...
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)
EmitInitializationToLValue - Emit an initializer to an LValue.
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
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...
llvm::Value * EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E)
void EmitOpenACCSetConstruct(const OpenACCSetConstruct &S)
llvm::BasicBlock * OMPAfterScanBlock
LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E)
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S)
static bool isNullPointerAllowed(TypeCheckKind TCK)
Determine whether the pointer type check TCK permits null pointers.
void EmitOMPErrorDirective(const OMPErrorDirective &S)
static Destroyer destroyARCStrongImprecise
void EmitOMPSectionDirective(const OMPSectionDirective &S)
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
static void EmitOMPTargetParallelDeviceFunction(CodeGenModule &CGM, StringRef ParentName, const OMPTargetParallelDirective &S)
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.
llvm::Value * EmitSVEAllTruePred(const SVETypeFlags &TypeFlags)
void EmitOMPBarrierDirective(const OMPBarrierDirective &S)
void EmitStopPoint(const Stmt *S)
EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E)
RValue GetUndefRValue(QualType Ty)
GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
void EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S)
llvm::Value * EmitObjCAlloc(llvm::Value *value, llvm::Type *returnType)
llvm::Value * emitScalarConstant(const ConstantEmission &Constant, Expr *E)
LValue EmitStmtExprLValue(const StmtExpr *E)
llvm::Instruction * CurrentFuncletPad
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)
llvm::Type * SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags)
SVEBuiltinMemEltTy - Returns the memory element type for this memory access builtin.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
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 ...
llvm::LLVMContext & getLLVMContext()
void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S)
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
void ResolveBranchFixups(llvm::BasicBlock *Target)
void AddAMDGPUFenceAddressSpaceMMRA(llvm::Instruction *Inst, const CallExpr *E)
bool checkIfFunctionMustProgress()
Returns true if a function must make progress, which means the mustprogress attribute can be added.
void EmitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &S)
bool LValueIsSuitableForInlineAtomic(LValue Src)
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
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.
RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})
Like EmitLoadOfLValue but also handles complex and aggregate types.
llvm::SmallVector< VPtr, 4 > VPtrsVector
llvm::Value * EmitSMEZero(const SVETypeFlags &TypeFlags, llvm::SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
llvm::Value * getSelectorFromSlot()
llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)
bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope)
Emit initial code for lastprivate variables.
static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
void InitializeVTablePointers(const CXXRecordDecl *ClassDecl)
llvm::Value * EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)
void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S)
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)
void getVTablePointers(BaseSubobject Base, const CXXRecordDecl *NearestVBase, CharUnits OffsetFromNearestVBase, bool BaseIsNonVirtualPrimaryBase, const CXXRecordDecl *VTableClass, VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs)
llvm::function_ref< void(CodeGenFunction &, const OMPLoopDirective &, JumpDest)> CodeGenLoopTy
void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags, bool CanThrow)
llvm::Value * EmitNeonCall(llvm::Function *F, SmallVectorImpl< llvm::Value * > &O, const char *name, unsigned shift=0, bool rightshift=false)
void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S)
Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
void InitializeVTablePointer(const VPtr &vptr)
Initialize the vtable pointer of the given subobject.
llvm::Value * EmitAnnotationCall(llvm::Function *AnnotationFn, llvm::Value *AnnotatedVal, StringRef AnnotationStr, SourceLocation Location, const AnnotateAttr *Attr)
Emit an annotation call (intrinsic).
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E, ReturnValueSlot ReturnValue, llvm::Value *Chain=nullptr, llvm::CallBase **CallOrInvoke=nullptr, CGFunctionInfo const **ResolvedFnInfo=nullptr)
void EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S)
llvm::BasicBlock * GetIndirectGotoBlock()
void EmitAsmStmt(const AsmStmt &S)
Address emitAddrOfRealComponent(Address complex, QualType complexType)
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty)
Determine whether the pointer type check TCK requires a vptr check.
llvm::ScalableVectorType * getSVEPredType(const SVETypeFlags &TypeFlags)
LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)
llvm::Type * convertTypeForLoadStore(QualType ASTTy, llvm::Type *LLVMTy=nullptr)
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
llvm::Value * getExceptionFromSlot()
Returns the contents of the function's exception object and selector slots.
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E)
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
llvm::Value * EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags, SmallVectorImpl< llvm::Value * > &Ops, unsigned IntID)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, ArrayRef< Address > args, const Twine &name="")
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...
bool hasLabelBeenSeenInCurrentScope() const
Return true if a label was seen in the current scope.
RValue EmitAtomicExpr(AtomicExpr *E)
RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee, llvm::Value *This, QualType ThisTy, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, llvm::CallBase **CallOrInvoke=nullptr)
CGPointerAuthInfo EmitPointerAuthInfo(const PointerAuthSchema &Schema, llvm::Value *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E)
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.
void EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S)
RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc)
llvm::Value * EmitSPIRVBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy, AlignmentSource Source=AlignmentSource::Type)
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.
LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E)
llvm::Value * EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
LValue EmitLValueForLambdaField(const FieldDecl *Field)
void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, llvm::FunctionCallee Callee)
Emit a musttail call for a thunk with a potentially adjusted this pointer.
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
void pushDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
llvm::Value * EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags, ArrayRef< llvm::Value * > Ops)
llvm::Type * ConvertType(const TypeDecl *T)
This class organizes the cross-function state that is used while generating LLVM code.
const LangOptions & getLangOpts() const
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CGPointerAuthInfo getPointerAuthInfoForPointeeType(QualType type)
const llvm::DataLayout & getDataLayout() const
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
ASTContext & getContext() const
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
llvm::LLVMContext & getLLVMContext()
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
Definition: CodeGenTypes.h:54
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:294
static ConstantAddress invalid()
Definition: Address.h:302
DominatingValue< Address >::saved_type AggregateAddr
static saved_type save(CodeGenFunction &CGF, RValue value)
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:141
ConditionalCleanup stores the saved form of its parameters, then restores them and performs the clean...
Definition: EHScopeStack.h:203
A saved depth on the scope stack.
Definition: EHScopeStack.h:101
A stack of scopes which respond to exceptions, including cleanups and catch blocks.
Definition: EHScopeStack.h:94
stable_iterator getInnermostNormalCleanup() const
Returns the innermost normal cleanup on the stack, or stable_end() if there are no normal cleanups.
Definition: EHScopeStack.h:370
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:393
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
Definition: EHScopeStack.h:398
void pushCleanupTuple(CleanupKind Kind, std::tuple< As... > A)
Push a lazily-created cleanup on the stack. Tuple version.
Definition: EHScopeStack.h:295
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition: CGCall.h:382
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:204
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
bool isValid() const
Definition: Address.h:62
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:386
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:4171
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3477
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1628
ContinueStmt - This represents a continue.
Definition: Stmt.h:2977
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:473
Represents the body of a coroutine.
Definition: StmtCXX.h:320
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Definition: ExprCXX.h:5077
Represents a 'co_yield' expression.
Definition: ExprCXX.h:5272
Represents the current source location and context used to determine the value of the source location...
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2369
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1265
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1519
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:2752
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:6354
Represents a member of a struct/union/class.
Definition: Decl.h:3033
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:2808
Represents a function declaration or definition.
Definition: Decl.h:1935
Represents a prototype with parameter type info, e.g.
Definition: Type.h:5102
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
const Decl * getDecl() const
Definition: GlobalDecl.h:103
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2889
This class represents temporary values used to represent inout and out arguments in HLSL.
Definition: Expr.h:7152
IfStmt - This represents an if/then/else.
Definition: Stmt.h:2165
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2928
Describes an C or C++ initializer list.
Definition: Expr.h:5088
Represents the declaration of a label.
Definition: Decl.h:503
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:2058
FPExceptionModeKind
Possible floating point exception behavior.
Definition: LangOptions.h:287
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:499
Represents a point when we exit a loop.
Definition: ProgramPoint.h:711
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4734
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Definition: Expr.h:2796
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3236
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:3519
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This represents '#pragma omp atomic' directive.
Definition: StmtOpenMP.h:2947
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:2625
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:3655
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:3597
Representation of an OpenMP canonical loop.
Definition: StmtOpenMP.h:142
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:2076
This represents '#pragma omp depobj' directive.
Definition: StmtOpenMP.h:2841
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:4425
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4547
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:4643
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:4708
This represents '#pragma omp error' directive.
Definition: StmtOpenMP.h:6432
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:2789
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:1634
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1724
This represents '#pragma omp loop' directive.
Definition: StmtOpenMP.h:6103
Represents the '#pragma omp interchange' loop transformation directive.
Definition: StmtOpenMP.h:5769
This represents '#pragma omp interop' directive.
Definition: StmtOpenMP.h:5895
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1004
This represents '#pragma omp masked' directive.
Definition: StmtOpenMP.h:6013
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:2028
This represents '#pragma omp master taskloop' directive.
Definition: StmtOpenMP.h:3854
This represents '#pragma omp master taskloop simd' directive.
Definition: StmtOpenMP.h:4006
This represents '#pragma omp metadirective' directive.
Definition: StmtOpenMP.h:6064
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:2893
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:612
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:2147
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:2244
This represents '#pragma omp parallel masked' directive.
Definition: StmtOpenMP.h:2372
This represents '#pragma omp parallel masked taskloop' directive.
Definition: StmtOpenMP.h:4215
This represents '#pragma omp parallel master' directive.
Definition: StmtOpenMP.h:2309
This represents '#pragma omp parallel master taskloop' directive.
Definition: StmtOpenMP.h:4137
This represents '#pragma omp parallel master taskloop simd' directive.
Definition: StmtOpenMP.h:4293
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:2436
Represents the '#pragma omp reverse' loop transformation directive.
Definition: StmtOpenMP.h:5704
This represents '#pragma omp scan' directive.
Definition: StmtOpenMP.h:5842
This represents '#pragma omp scope' directive.
Definition: StmtOpenMP.h:1925
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1864
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1787
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:1571
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1977
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:3206
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:3152
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:3260
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:3315
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:3369
This represents '#pragma omp target parallel for' directive.
Definition: StmtOpenMP.h:3449
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:4774
This represents '#pragma omp target parallel loop' directive.
Definition: StmtOpenMP.h:6370
This represents '#pragma omp target simd' directive.
Definition: StmtOpenMP.h:4841
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:5199
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:5255
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:5322
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:5420
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:5490
This represents '#pragma omp target teams loop' directive.
Definition: StmtOpenMP.h:6230
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:4491
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:2517
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:3715
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:3788
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:2722
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:2671
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:2579
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:3544
This represents '#pragma omp teams distribute' directive.
Definition: StmtOpenMP.h:4906
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:5106
This represents '#pragma omp teams distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:5040
This represents '#pragma omp teams distribute simd' combined directive.
Definition: StmtOpenMP.h:4972
This represents '#pragma omp teams loop' directive.
Definition: StmtOpenMP.h:6165
This represents the '#pragma omp tile' loop transformation directive.
Definition: StmtOpenMP.h:5548
This represents the '#pragma omp unroll' loop transformation directive.
Definition: StmtOpenMP.h:5630
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:191
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:127
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:947
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:309
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:410
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:2596
Represents an ObjC class declaration.
Definition: DeclObjC.h:1153
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1487
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1951
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:549
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:941
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:2804
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:505
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:455
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1173
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:1223
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
Definition: StmtOpenACC.h:131
This class represents a 'loop' construct.
Definition: StmtOpenACC.h:194
Represents a parameter to a function.
Definition: Decl.h:1725
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:3198
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1991
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6546
A (possibly-)qualified type.
Definition: Type.h:929
@ DK_cxx_destructor
Definition: Type.h:1521
@ DK_nontrivial_c_struct
Definition: Type.h:1524
@ DK_objc_weak_lifetime
Definition: Type.h:1523
@ DK_objc_strong_lifetime
Definition: Type.h:1522
The collection of all-type qualifiers we support.
Definition: Type.h:324
Represents a struct/union/class.
Definition: Decl.h:4160
bool hasVolatileMember() const
Definition: Decl.h:4223
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6072
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition: Stmt.h:3046
Represents a __leave statement.
Definition: Stmt.h:3745
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:4466
Stmt - This represents one statement.
Definition: Stmt.h:84
Likelihood
The likelihood of a branch being taken.
Definition: Stmt.h:1323
@ LH_None
No attribute set or branches of the IfStmt have the same attribute.
Definition: Stmt.h:1325
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1778
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2415
Exposes information about the current target.
Definition: TargetInfo.h:220
Represents a declaration of a type.
Definition: Decl.h:3382
The base class of the type hierarchy.
Definition: Type.h:1828
bool isReferenceType() const
Definition: Type.h:8204
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8731
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2232
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4750
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:671
QualType getType() const
Definition: Decl.h:682
Represents a variable declaration or definition.
Definition: Decl.h:882
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2246
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:1213
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3808
Expr * getSizeExpr() const
Definition: Type.h:3827
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2611
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.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
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...
Definition: EHScopeStack.h:84
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
Definition: CGValue.h:135
@ NotKnownNonNull
Definition: Address.h:33
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const AstTypeMatcher< ComplexType > complexType
Matches C99 complex types.
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:25
BinaryOperatorKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
@ CR_Default
Definition: CapturedStmt.h:17
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
Definition: OpenMPKinds.h:104
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.
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
const FunctionProtoType * T
@ Success
Template argument deduction was successful.
llvm::fp::ExceptionBehavior ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind)
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
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.
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.
llvm::PointerIntPair< llvm::Value *, 1, bool > saved_type
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.
Definition: EHScopeStack.h:65
static saved_type save(CodeGenFunction &CGF, type value)
Definition: EHScopeStack.h:59
Scheduling data for loop-based OpenMP directives.
Definition: OpenMPKinds.h:180
The this pointer adjustment as well as an optional return adjustment for a thunk.
Definition: Thunk.h:157