clang 21.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/StmtSYCL.h"
32#include "clang/AST/Type.h"
33#include "clang/Basic/ABI.h"
38#include "llvm/ADT/ArrayRef.h"
39#include "llvm/ADT/DenseMap.h"
40#include "llvm/ADT/MapVector.h"
41#include "llvm/ADT/SmallVector.h"
42#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
43#include "llvm/IR/Instructions.h"
44#include "llvm/IR/ValueHandle.h"
45#include "llvm/Support/Debug.h"
46#include "llvm/Transforms/Utils/SanitizerStats.h"
47#include <optional>
48
49namespace llvm {
50class BasicBlock;
51class LLVMContext;
52class MDNode;
53class SwitchInst;
54class Twine;
55class Value;
56class CanonicalLoopInfo;
57}
58
59namespace clang {
60class ASTContext;
61class CXXDestructorDecl;
62class CXXForRangeStmt;
63class CXXTryStmt;
64class Decl;
65class LabelDecl;
66class FunctionDecl;
67class FunctionProtoType;
68class LabelStmt;
69class ObjCContainerDecl;
70class ObjCInterfaceDecl;
71class ObjCIvarDecl;
72class ObjCMethodDecl;
73class ObjCImplementationDecl;
74class ObjCPropertyImplDecl;
75class TargetInfo;
76class VarDecl;
77class ObjCForCollectionStmt;
78class ObjCAtTryStmt;
79class ObjCAtThrowStmt;
80class ObjCAtSynchronizedStmt;
81class ObjCAutoreleasePoolStmt;
82class OMPUseDevicePtrClause;
83class OMPUseDeviceAddrClause;
84class SVETypeFlags;
85class OMPExecutableDirective;
86
87namespace analyze_os_log {
88class OSLogBufferLayout;
89}
90
91namespace CodeGen {
92class CodeGenTypes;
93class CGCallee;
94class CGFunctionInfo;
95class CGBlockInfo;
96class CGCXXABI;
97class BlockByrefHelpers;
98class BlockByrefInfo;
99class BlockFieldFlags;
100class RegionCodeGenTy;
101class TargetCodeGenInfo;
102struct OMPTaskDataTy;
103struct CGCoroData;
104
105/// The kind of evaluation to perform on values of a particular
106/// type. Basically, is the code in CGExprScalar, CGExprComplex, or
107/// CGExprAgg?
108///
109/// TODO: should vectors maybe be split out into their own thing?
115
116#define LIST_SANITIZER_CHECKS \
117 SANITIZER_CHECK(AddOverflow, add_overflow, 0) \
118 SANITIZER_CHECK(BuiltinUnreachable, builtin_unreachable, 0) \
119 SANITIZER_CHECK(CFICheckFail, cfi_check_fail, 0) \
120 SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0) \
121 SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0) \
122 SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0) \
123 SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 0) \
124 SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0) \
125 SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0) \
126 SANITIZER_CHECK(InvalidObjCCast, invalid_objc_cast, 0) \
127 SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0) \
128 SANITIZER_CHECK(MissingReturn, missing_return, 0) \
129 SANITIZER_CHECK(MulOverflow, mul_overflow, 0) \
130 SANITIZER_CHECK(NegateOverflow, negate_overflow, 0) \
131 SANITIZER_CHECK(NullabilityArg, nullability_arg, 0) \
132 SANITIZER_CHECK(NullabilityReturn, nullability_return, 1) \
133 SANITIZER_CHECK(NonnullArg, nonnull_arg, 0) \
134 SANITIZER_CHECK(NonnullReturn, nonnull_return, 1) \
135 SANITIZER_CHECK(OutOfBounds, out_of_bounds, 0) \
136 SANITIZER_CHECK(PointerOverflow, pointer_overflow, 0) \
137 SANITIZER_CHECK(ShiftOutOfBounds, shift_out_of_bounds, 0) \
138 SANITIZER_CHECK(SubOverflow, sub_overflow, 0) \
139 SANITIZER_CHECK(TypeMismatch, type_mismatch, 1) \
140 SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0) \
141 SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0) \
142 SANITIZER_CHECK(BoundsSafety, bounds_safety, 0)
143
145#define SANITIZER_CHECK(Enum, Name, Version) Enum,
147#undef SANITIZER_CHECK
149
150/// Helper class with most of the code for saving a value for a
151/// conditional expression cleanup.
153 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
154
155 /// Answer whether the given value needs extra work to be saved.
156 static bool needsSaving(llvm::Value *value) {
157 if (!value)
158 return false;
159
160 // If it's not an instruction, we don't need to save.
161 if (!isa<llvm::Instruction>(value)) return false;
162
163 // If it's an instruction in the entry block, we don't need to save.
164 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
165 return (block != &block->getParent()->getEntryBlock());
166 }
167
168 static saved_type save(CodeGenFunction &CGF, llvm::Value *value);
169 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value);
170};
171
172/// A partial specialization of DominatingValue for llvm::Values that
173/// might be llvm::Instructions.
174template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
175 typedef T *type;
177 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
178 }
179};
180
181/// A specialization of DominatingValue for Address.
182template <> struct DominatingValue<Address> {
183 typedef Address type;
184
185 struct saved_type {
187 llvm::Type *ElementType;
190 llvm::PointerType *EffectiveType;
191 };
192
193 static bool needsSaving(type value) {
196 return true;
197 return false;
198 }
199 static saved_type save(CodeGenFunction &CGF, type value) {
200 return {DominatingLLVMValue::save(CGF, value.getBasePointer()),
201 value.getElementType(), value.getAlignment(),
202 DominatingLLVMValue::save(CGF, value.getOffset()), value.getType()};
203 }
205 return Address(DominatingLLVMValue::restore(CGF, value.BasePtr),
206 value.ElementType, value.Alignment, CGPointerAuthInfo(),
207 DominatingLLVMValue::restore(CGF, value.Offset));
208 }
209};
210
211/// A specialization of DominatingValue for RValue.
212template <> struct DominatingValue<RValue> {
213 typedef RValue type;
215 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
216 AggregateAddress, ComplexAddress };
217 union {
218 struct {
220 } Vals;
222 };
223 LLVM_PREFERRED_TYPE(Kind)
224 unsigned K : 3;
225
227 : Vals{Val1, DominatingLLVMValue::saved_type()}, K(K) {}
228
231 : Vals{Val1, Val2}, K(ComplexAddress) {}
232
233 saved_type(DominatingValue<Address>::saved_type AggregateAddr, unsigned K)
234 : AggregateAddr(AggregateAddr), K(K) {}
235
236 public:
237 static bool needsSaving(RValue value);
240
241 // implementations in CGCleanup.cpp
242 };
243
244 static bool needsSaving(type value) {
245 return saved_type::needsSaving(value);
246 }
247 static saved_type save(CodeGenFunction &CGF, type value) {
248 return saved_type::save(CGF, value);
249 }
251 return value.restore(CGF);
252 }
253};
254
255/// CodeGenFunction - This class organizes the per-function state that is used
256/// while generating LLVM code.
258 CodeGenFunction(const CodeGenFunction &) = delete;
259 void operator=(const CodeGenFunction &) = delete;
260
261 friend class CGCXXABI;
262public:
263 /// A jump destination is an abstract label, branching to which may
264 /// require a jump out through normal cleanups.
265 struct JumpDest {
266 JumpDest() : Block(nullptr), Index(0) {}
267 JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth,
268 unsigned Index)
269 : Block(Block), ScopeDepth(Depth), Index(Index) {}
270
271 bool isValid() const { return Block != nullptr; }
272 llvm::BasicBlock *getBlock() const { return Block; }
273 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
274 unsigned getDestIndex() const { return Index; }
275
276 // This should be used cautiously.
278 ScopeDepth = depth;
279 }
280
281 private:
282 llvm::BasicBlock *Block;
284 unsigned Index;
285 };
286
287 CodeGenModule &CGM; // Per-module state.
289
290 // For EH/SEH outlined funclets, this field points to parent's CGF
292
293 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
296
297 // Stores variables for which we can't generate correct lifetime markers
298 // because of jumps.
300
301 /// List of recently emitted OMPCanonicalLoops.
302 ///
303 /// Since OMPCanonicalLoops are nested inside other statements (in particular
304 /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
305 /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its
306 /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any
307 /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
308 /// this stack when done. Entering a new loop requires clearing this list; it
309 /// either means we start parsing a new loop nest (in which case the previous
310 /// loop nest goes out of scope) or a second loop in the same level in which
311 /// case it would be ambiguous into which of the two (or more) loops the loop
312 /// nest would extend.
314
315 /// Stack to track the Logical Operator recursion nest for MC/DC.
317
318 /// Stack to track the controlled convergence tokens.
320
321 /// Number of nested loop to be consumed by the last surrounding
322 /// loop-associated directive.
324
325 // CodeGen lambda for loops and support for ordered clause
326 typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
327 JumpDest)>
329 typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
330 const unsigned, const bool)>
332
333 // Codegen lambda for loop bounds in worksharing loop constructs
334 typedef llvm::function_ref<std::pair<LValue, LValue>(
337
338 // Codegen lambda for loop bounds in dispatch-based loop implementation
339 typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
341 Address UB)>
343
344 /// CGBuilder insert helper. This function is called after an
345 /// instruction is created using Builder.
346 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
347 llvm::BasicBlock::iterator InsertPt) const;
348
349 /// CurFuncDecl - Holds the Decl for the current outermost
350 /// non-closure context.
351 const Decl *CurFuncDecl = nullptr;
352 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
353 const Decl *CurCodeDecl = nullptr;
354 const CGFunctionInfo *CurFnInfo = nullptr;
356 llvm::Function *CurFn = nullptr;
357
358 /// Save Parameter Decl for coroutine.
360
361 // Holds coroutine data if the current function is a coroutine. We use a
362 // wrapper to manage its lifetime, so that we don't have to define CGCoroData
363 // in this header.
364 struct CGCoroInfo {
365 std::unique_ptr<CGCoroData> Data;
366 bool InSuspendBlock = false;
367 CGCoroInfo();
368 ~CGCoroInfo();
369 };
371
372 bool isCoroutine() const {
373 return CurCoro.Data != nullptr;
374 }
375
376 bool inSuspendBlock() const {
378 }
379
380 // Holds FramePtr for await_suspend wrapper generation,
381 // so that __builtin_coro_frame call can be lowered
382 // directly to value of its second argument
384 llvm::Value *FramePtr = nullptr;
385 };
387
388 // Generates wrapper function for `llvm.coro.await.suspend.*` intrinisics.
389 // It encapsulates SuspendExpr in a function, to separate it's body
390 // from the main coroutine to avoid miscompilations. Intrinisic
391 // is lowered to this function call in CoroSplit pass
392 // Function signature is:
393 // <type> __await_suspend_wrapper_<name>(ptr %awaiter, ptr %hdl)
394 // where type is one of (void, i1, ptr)
395 llvm::Function *generateAwaitSuspendWrapper(Twine const &CoroName,
396 Twine const &SuspendPointName,
397 CoroutineSuspendExpr const &S);
398
399 /// CurGD - The GlobalDecl for the current function being compiled.
401
402 /// PrologueCleanupDepth - The cleanup depth enclosing all the
403 /// cleanups associated with the parameters.
405
406 /// ReturnBlock - Unified return block.
408
409 /// ReturnValue - The temporary alloca to hold the return
410 /// value. This is invalid iff the function has no return value.
412
413 /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
414 /// This is invalid if sret is not in use.
416
417 /// If a return statement is being visited, this holds the return statment's
418 /// result expression.
419 const Expr *RetExpr = nullptr;
420
421 /// Return true if a label was seen in the current scope.
423 if (CurLexicalScope)
424 return CurLexicalScope->hasLabels();
425 return !LabelMap.empty();
426 }
427
428 /// AllocaInsertPoint - This is an instruction in the entry block before which
429 /// we prefer to insert allocas.
430 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
431
432private:
433 /// PostAllocaInsertPt - This is a place in the prologue where code can be
434 /// inserted that will be dominated by all the static allocas. This helps
435 /// achieve two things:
436 /// 1. Contiguity of all static allocas (within the prologue) is maintained.
437 /// 2. All other prologue code (which are dominated by static allocas) do
438 /// appear in the source order immediately after all static allocas.
439 ///
440 /// PostAllocaInsertPt will be lazily created when it is *really* required.
441 llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr;
442
443public:
444 /// Return PostAllocaInsertPt. If it is not yet created, then insert it
445 /// immediately after AllocaInsertPt.
446 llvm::Instruction *getPostAllocaInsertPoint() {
447 if (!PostAllocaInsertPt) {
448 assert(AllocaInsertPt &&
449 "Expected static alloca insertion point at function prologue");
450 assert(AllocaInsertPt->getParent()->isEntryBlock() &&
451 "EBB should be entry block of the current code gen function");
452 PostAllocaInsertPt = AllocaInsertPt->clone();
453 PostAllocaInsertPt->setName("postallocapt");
454 PostAllocaInsertPt->insertAfter(AllocaInsertPt->getIterator());
455 }
456
457 return PostAllocaInsertPt;
458 }
459
460 /// API for captured statement code generation.
462 public:
464 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
467 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
468
470 S.getCapturedRecordDecl()->field_begin();
471 for (CapturedStmt::const_capture_iterator I = S.capture_begin(),
472 E = S.capture_end();
473 I != E; ++I, ++Field) {
474 if (I->capturesThis())
475 CXXThisFieldDecl = *Field;
476 else if (I->capturesVariable())
477 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
478 else if (I->capturesVariableByCopy())
479 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
480 }
481 }
482
483 virtual ~CGCapturedStmtInfo();
484
485 CapturedRegionKind getKind() const { return Kind; }
486
487 virtual void setContextValue(llvm::Value *V) { ThisValue = V; }
488 // Retrieve the value of the context parameter.
489 virtual llvm::Value *getContextValue() const { return ThisValue; }
490
491 /// Lookup the captured field decl for a variable.
492 virtual const FieldDecl *lookup(const VarDecl *VD) const {
493 return CaptureFields.lookup(VD->getCanonicalDecl());
494 }
495
496 bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; }
497 virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; }
498
499 static bool classof(const CGCapturedStmtInfo *) {
500 return true;
501 }
502
503 /// Emit the captured statement body.
504 virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
506 CGF.EmitStmt(S);
507 }
508
509 /// Get the name of the capture helper.
510 virtual StringRef getHelperName() const { return "__captured_stmt"; }
511
512 /// Get the CaptureFields
513 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() {
514 return CaptureFields;
515 }
516
517 private:
518 /// The kind of captured statement being generated.
520
521 /// Keep the map between VarDecl and FieldDecl.
522 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields;
523
524 /// The base address of the captured record, passed in as the first
525 /// argument of the parallel region function.
526 llvm::Value *ThisValue;
527
528 /// Captured 'this' type.
529 FieldDecl *CXXThisFieldDecl;
530 };
532
533 /// RAII for correct setting/restoring of CapturedStmtInfo.
535 private:
536 CodeGenFunction &CGF;
537 CGCapturedStmtInfo *PrevCapturedStmtInfo;
538 public:
540 CGCapturedStmtInfo *NewCapturedStmtInfo)
541 : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
542 CGF.CapturedStmtInfo = NewCapturedStmtInfo;
543 }
544 ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
545 };
546
547 /// An abstract representation of regular/ObjC call/message targets.
549 /// The function declaration of the callee.
550 const Decl *CalleeDecl;
551
552 public:
553 AbstractCallee() : CalleeDecl(nullptr) {}
554 AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
555 AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {}
556 bool hasFunctionDecl() const {
557 return isa_and_nonnull<FunctionDecl>(CalleeDecl);
558 }
559 const Decl *getDecl() const { return CalleeDecl; }
560 unsigned getNumParams() const {
561 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
562 return FD->getNumParams();
563 return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
564 }
565 const ParmVarDecl *getParamDecl(unsigned I) const {
566 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
567 return FD->getParamDecl(I);
568 return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
569 }
570 };
571
572 /// Sanitizers enabled for this function.
574
575 /// True if CodeGen currently emits code implementing sanitizer checks.
576 bool IsSanitizerScope = false;
577
578 /// RAII object to set/unset CodeGenFunction::IsSanitizerScope.
580 CodeGenFunction *CGF;
581 public:
584 };
585
586 /// In C++, whether we are code generating a thunk. This controls whether we
587 /// should emit cleanups.
588 bool CurFuncIsThunk = false;
589
590 /// In ARC, whether we should autorelease the return value.
591 bool AutoreleaseResult = false;
592
593 /// Whether we processed a Microsoft-style asm block during CodeGen. These can
594 /// potentially set the return value.
595 bool SawAsmBlock = false;
596
598
599 /// True if the current function is an outlined SEH helper. This can be a
600 /// finally block or filter expression.
602
603 /// True if CodeGen currently emits code inside presereved access index
604 /// region.
606
607 /// True if the current statement has nomerge attribute.
609
610 /// True if the current statement has noinline attribute.
612
613 /// True if the current statement has always_inline attribute.
615
616 /// True if the current statement has noconvergent attribute.
618
619 /// HLSL Branch attribute.
620 HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr =
621 HLSLControlFlowHintAttr::SpellingNotCalculated;
622
623 // The CallExpr within the current statement that the musttail attribute
624 // applies to. nullptr if there is no 'musttail' on the current statement.
625 const CallExpr *MustTailCall = nullptr;
626
627 /// Returns true if a function must make progress, which means the
628 /// mustprogress attribute can be added.
630 if (CGM.getCodeGenOpts().getFiniteLoops() ==
632 return false;
633
634 // C++11 and later guarantees that a thread eventually will do one of the
635 // following (C++11 [intro.multithread]p24 and C++17 [intro.progress]p1):
636 // - terminate,
637 // - make a call to a library I/O function,
638 // - perform an access through a volatile glvalue, or
639 // - perform a synchronization operation or an atomic operation.
640 //
641 // Hence each function is 'mustprogress' in C++11 or later.
642 return getLangOpts().CPlusPlus11;
643 }
644
645 /// Returns true if a loop must make progress, which means the mustprogress
646 /// attribute can be added. \p HasConstantCond indicates whether the branch
647 /// condition is a known constant.
648 bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody);
649
651 llvm::Value *BlockPointer = nullptr;
652
653 llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
655
656 /// A mapping from NRVO variables to the flags used to indicate
657 /// when the NRVO has been applied to this variable.
658 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
659
662
663 // A stack of cleanups which were added to EHStack but have to be deactivated
664 // later before being popped or emitted. These are usually deactivated on
665 // exiting a `CleanupDeactivationScope` scope. For instance, after a
666 // full-expr.
667 //
668 // These are specially useful for correctly emitting cleanups while
669 // encountering branches out of expression (through stmt-expr or coroutine
670 // suspensions).
673 llvm::Instruction *DominatingIP;
674 };
676
677 // Enters a new scope for capturing cleanups which are deferred to be
678 // deactivated, all of which will be deactivated once the scope is exited.
687
689 assert(!Deactivated && "Deactivating already deactivated scope");
691 for (size_t I = Stack.size(); I > OldDeactivateCleanupStackSize; I--) {
692 CGF.DeactivateCleanupBlock(Stack[I - 1].Cleanup,
693 Stack[I - 1].DominatingIP);
694 Stack[I - 1].DominatingIP->eraseFromParent();
695 }
696 Stack.resize(OldDeactivateCleanupStackSize);
697 Deactivated = true;
698 }
699
701 if (Deactivated)
702 return;
704 }
705 };
706
708
709 llvm::Instruction *CurrentFuncletPad = nullptr;
710
712 bool isRedundantBeforeReturn() override { return true; }
713
714 llvm::Value *Addr;
715 llvm::Value *Size;
716
717 public:
718 CallLifetimeEnd(RawAddress addr, llvm::Value *size)
719 : Addr(addr.getPointer()), Size(size) {}
720
721 void Emit(CodeGenFunction &CGF, Flags flags) override {
722 CGF.EmitLifetimeEnd(Size, Addr);
723 }
724 };
725
726 // We are using objects of this 'cleanup' class to emit fake.use calls
727 // for -fextend-variable-liveness. They are placed at the end of a variable's
728 // scope analogous to lifetime markers.
729 class FakeUse final : public EHScopeStack::Cleanup {
730 Address Addr;
731
732 public:
733 FakeUse(Address addr) : Addr(addr) {}
734
735 void Emit(CodeGenFunction &CGF, Flags flags) override {
736 CGF.EmitFakeUse(Addr);
737 }
738 };
739
740 /// Header for data within LifetimeExtendedCleanupStack.
742 /// The size of the following cleanup object.
743 unsigned Size;
744 /// The kind of cleanup to push.
745 LLVM_PREFERRED_TYPE(CleanupKind)
747 /// Whether this is a conditional cleanup.
748 LLVM_PREFERRED_TYPE(bool)
749 unsigned IsConditional : 1;
750
751 size_t getSize() const { return Size; }
752 CleanupKind getKind() const { return (CleanupKind)Kind; }
753 bool isConditional() const { return IsConditional; }
754 };
755
756 /// i32s containing the indexes of the cleanup destinations.
758
760
761 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
762 llvm::BasicBlock *EHResumeBlock = nullptr;
763
764 /// The exception slot. All landing pads write the current exception pointer
765 /// into this alloca.
766 llvm::Value *ExceptionSlot = nullptr;
767
768 /// The selector slot. Under the MandatoryCleanup model, all landing pads
769 /// write the current selector value into this alloca.
770 llvm::AllocaInst *EHSelectorSlot = nullptr;
771
772 /// A stack of exception code slots. Entering an __except block pushes a slot
773 /// on the stack and leaving pops one. The __exception_code() intrinsic loads
774 /// a value from the top of the stack.
776
777 /// Value returned by __exception_info intrinsic.
778 llvm::Value *SEHInfo = nullptr;
779
780 /// Emits a landing pad for the current EH stack.
781 llvm::BasicBlock *EmitLandingPad();
782
783 llvm::BasicBlock *getInvokeDestImpl();
784
785 /// Parent loop-based directive for scan directive.
787 llvm::BasicBlock *OMPBeforeScanBlock = nullptr;
788 llvm::BasicBlock *OMPAfterScanBlock = nullptr;
789 llvm::BasicBlock *OMPScanExitBlock = nullptr;
790 llvm::BasicBlock *OMPScanDispatch = nullptr;
791 bool OMPFirstScanLoop = false;
792
793 /// Manages parent directive for scan directives.
795 CodeGenFunction &CGF;
796 const OMPExecutableDirective *ParentLoopDirectiveForScan;
797
798 public:
800 CodeGenFunction &CGF,
801 const OMPExecutableDirective &ParentLoopDirectiveForScan)
802 : CGF(CGF),
803 ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) {
804 CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan;
805 }
807 CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan;
808 }
809 };
810
811 template <class T>
813 return DominatingValue<T>::save(*this, value);
814 }
815
817 public:
818 CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures);
821
822 private:
823 void ConstructorHelper(FPOptions FPFeatures);
824 CodeGenFunction &CGF;
825 FPOptions OldFPFeatures;
826 llvm::fp::ExceptionBehavior OldExcept;
827 llvm::RoundingMode OldRounding;
828 std::optional<CGBuilderTy::FastMathFlagGuard> FMFGuard;
829 };
831
832public:
833 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
834 /// rethrows.
836
837 /// A class controlling the emission of a finally block.
839 /// Where the catchall's edge through the cleanup should go.
840 JumpDest RethrowDest;
841
842 /// A function to call to enter the catch.
843 llvm::FunctionCallee BeginCatchFn;
844
845 /// An i1 variable indicating whether or not the @finally is
846 /// running for an exception.
847 llvm::AllocaInst *ForEHVar = nullptr;
848
849 /// An i8* variable into which the exception pointer to rethrow
850 /// has been saved.
851 llvm::AllocaInst *SavedExnVar = nullptr;
852
853 public:
854 void enter(CodeGenFunction &CGF, const Stmt *Finally,
855 llvm::FunctionCallee beginCatchFn,
856 llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
857 void exit(CodeGenFunction &CGF);
858 };
859
860 /// Returns true inside SEH __try blocks.
861 bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
862
863 /// Returns true while emitting a cleanuppad.
864 bool isCleanupPadScope() const {
865 return CurrentFuncletPad && isa<llvm::CleanupPadInst>(CurrentFuncletPad);
866 }
867
868 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
869 /// current full-expression. Safe against the possibility that
870 /// we're currently inside a conditionally-evaluated expression.
871 template <class T, class... As>
872 void pushFullExprCleanup(CleanupKind kind, As... A) {
873 // If we're not in a conditional branch, or if none of the
874 // arguments requires saving, then use the unconditional cleanup.
876 return EHStack.pushCleanup<T>(kind, A...);
877
878 // Stash values in a tuple so we can guarantee the order of saves.
879 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
880 SavedTuple Saved{saveValueInCond(A)...};
881
882 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
883 EHStack.pushCleanupTuple<CleanupType>(kind, Saved);
885 }
886
887 /// Queue a cleanup to be pushed after finishing the current full-expression,
888 /// potentially with an active flag.
889 template <class T, class... As>
892 return pushCleanupAfterFullExprWithActiveFlag<T>(
893 Kind, RawAddress::invalid(), A...);
894
895 RawAddress ActiveFlag = createCleanupActiveFlag();
896 assert(!DominatingValue<Address>::needsSaving(ActiveFlag) &&
897 "cleanup active flag should never need saving");
898
899 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
900 SavedTuple Saved{saveValueInCond(A)...};
901
902 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
903 pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved);
904 }
905
906 template <class T, class... As>
908 RawAddress ActiveFlag, As... A) {
909 LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
910 ActiveFlag.isValid()};
911
914 LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
915 (Header.IsConditional ? sizeof(ActiveFlag) : 0));
916
917 static_assert(sizeof(Header) % alignof(T) == 0,
918 "Cleanup will be allocated on misaligned address");
919 char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
920 new (Buffer) LifetimeExtendedCleanupHeader(Header);
921 new (Buffer + sizeof(Header)) T(A...);
922 if (Header.IsConditional)
923 new (Buffer + sizeof(Header) + sizeof(T)) RawAddress(ActiveFlag);
924 }
925
926 // Push a cleanup onto EHStack and deactivate it later. It is usually
927 // deactivated when exiting a `CleanupDeactivationScope` (for example: after a
928 // full expression).
929 template <class T, class... As>
931 // Placeholder dominating IP for this cleanup.
932 llvm::Instruction *DominatingIP =
933 Builder.CreateFlagLoad(llvm::Constant::getNullValue(Int8PtrTy));
934 EHStack.pushCleanup<T>(Kind, A...);
936 {EHStack.stable_begin(), DominatingIP});
937 }
938
939 /// Set up the last cleanup that was pushed as a conditional
940 /// full-expression cleanup.
943 }
944
947
948 /// PushDestructorCleanup - Push a cleanup to call the
949 /// complete-object destructor of an object of the given type at the
950 /// given address. Does nothing if T is not a C++ class type with a
951 /// non-trivial destructor.
953
954 /// PushDestructorCleanup - Push a cleanup to call the
955 /// complete-object variant of the given destructor on the object at
956 /// the given address.
958 Address Addr);
959
960 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
961 /// process all branch fixups.
962 void PopCleanupBlock(bool FallThroughIsBranchThrough = false,
963 bool ForDeactivation = false);
964
965 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
966 /// The block cannot be reactivated. Pops it if it's the top of the
967 /// stack.
968 ///
969 /// \param DominatingIP - An instruction which is known to
970 /// dominate the current IP (if set) and which lies along
971 /// all paths of execution between the current IP and the
972 /// the point at which the cleanup comes into scope.
974 llvm::Instruction *DominatingIP);
975
976 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
977 /// Cannot be used to resurrect a deactivated cleanup.
978 ///
979 /// \param DominatingIP - An instruction which is known to
980 /// dominate the current IP (if set) and which lies along
981 /// all paths of execution between the current IP and the
982 /// the point at which the cleanup comes into scope.
984 llvm::Instruction *DominatingIP);
985
986 /// Enters a new scope for capturing cleanups, all of which
987 /// will be executed once the scope is exited.
989 EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth;
990 size_t LifetimeExtendedCleanupStackSize;
991 CleanupDeactivationScope DeactivateCleanups;
992 bool OldDidCallStackSave;
993 protected:
995 private:
996
997 RunCleanupsScope(const RunCleanupsScope &) = delete;
998 void operator=(const RunCleanupsScope &) = delete;
999
1000 protected:
1002
1003 public:
1004 /// Enter a new cleanup scope.
1006 : DeactivateCleanups(CGF), PerformCleanup(true), CGF(CGF) {
1007 CleanupStackDepth = CGF.EHStack.stable_begin();
1008 LifetimeExtendedCleanupStackSize =
1010 OldDidCallStackSave = CGF.DidCallStackSave;
1011 CGF.DidCallStackSave = false;
1012 OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth;
1013 CGF.CurrentCleanupScopeDepth = CleanupStackDepth;
1014 }
1015
1016 /// Exit this cleanup scope, emitting any accumulated cleanups.
1018 if (PerformCleanup)
1019 ForceCleanup();
1020 }
1021
1022 /// Determine whether this scope requires any cleanups.
1023 bool requiresCleanups() const {
1024 return CGF.EHStack.stable_begin() != CleanupStackDepth;
1025 }
1026
1027 /// Force the emission of cleanups now, instead of waiting
1028 /// until this object is destroyed.
1029 /// \param ValuesToReload - A list of values that need to be available at
1030 /// the insertion point after cleanup emission. If cleanup emission created
1031 /// a shared cleanup block, these value pointers will be rewritten.
1032 /// Otherwise, they not will be modified.
1033 void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
1034 assert(PerformCleanup && "Already forced cleanup");
1035 CGF.DidCallStackSave = OldDidCallStackSave;
1036 DeactivateCleanups.ForceDeactivate();
1037 CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
1038 ValuesToReload);
1039 PerformCleanup = false;
1040 CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
1041 }
1042 };
1043
1044 // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
1047
1049 SourceRange Range;
1051 LexicalScope *ParentScope;
1052
1053 LexicalScope(const LexicalScope &) = delete;
1054 void operator=(const LexicalScope &) = delete;
1055
1056 public:
1057 /// Enter a new cleanup scope.
1059 : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) {
1060 CGF.CurLexicalScope = this;
1061 if (CGDebugInfo *DI = CGF.getDebugInfo())
1062 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
1063 }
1064
1065 void addLabel(const LabelDecl *label) {
1066 assert(PerformCleanup && "adding label to dead scope?");
1067 Labels.push_back(label);
1068 }
1069
1070 /// Exit this cleanup scope, emitting any accumulated
1071 /// cleanups.
1073 if (CGDebugInfo *DI = CGF.getDebugInfo())
1074 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
1075
1076 // If we should perform a cleanup, force them now. Note that
1077 // this ends the cleanup scope before rescoping any labels.
1078 if (PerformCleanup) {
1079 ApplyDebugLocation DL(CGF, Range.getEnd());
1080 ForceCleanup();
1081 }
1082 }
1083
1084 /// Force the emission of cleanups now, instead of waiting
1085 /// until this object is destroyed.
1087 CGF.CurLexicalScope = ParentScope;
1089
1090 if (!Labels.empty())
1091 rescopeLabels();
1092 }
1093
1094 bool hasLabels() const {
1095 return !Labels.empty();
1096 }
1097
1098 void rescopeLabels();
1099 };
1100
1101 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
1102
1103 /// The class used to assign some variables some temporarily addresses.
1105 DeclMapTy SavedLocals;
1106 DeclMapTy SavedTempAddresses;
1107 OMPMapVars(const OMPMapVars &) = delete;
1108 void operator=(const OMPMapVars &) = delete;
1109
1110 public:
1111 explicit OMPMapVars() = default;
1113 assert(SavedLocals.empty() && "Did not restored original addresses.");
1114 };
1115
1116 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
1117 /// function \p CGF.
1118 /// \return true if at least one variable was set already, false otherwise.
1119 bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD,
1120 Address TempAddr) {
1121 LocalVD = LocalVD->getCanonicalDecl();
1122 // Only save it once.
1123 if (SavedLocals.count(LocalVD)) return false;
1124
1125 // Copy the existing local entry to SavedLocals.
1126 auto it = CGF.LocalDeclMap.find(LocalVD);
1127 if (it != CGF.LocalDeclMap.end())
1128 SavedLocals.try_emplace(LocalVD, it->second);
1129 else
1130 SavedLocals.try_emplace(LocalVD, Address::invalid());
1131
1132 // Generate the private entry.
1133 QualType VarTy = LocalVD->getType();
1134 if (VarTy->isReferenceType()) {
1135 Address Temp = CGF.CreateMemTemp(VarTy);
1136 CGF.Builder.CreateStore(TempAddr.emitRawPointer(CGF), Temp);
1137 TempAddr = Temp;
1138 }
1139 SavedTempAddresses.try_emplace(LocalVD, TempAddr);
1140
1141 return true;
1142 }
1143
1144 /// Applies new addresses to the list of the variables.
1145 /// \return true if at least one variable is using new address, false
1146 /// otherwise.
1148 copyInto(SavedTempAddresses, CGF.LocalDeclMap);
1149 SavedTempAddresses.clear();
1150 return !SavedLocals.empty();
1151 }
1152
1153 /// Restores original addresses of the variables.
1155 if (!SavedLocals.empty()) {
1156 copyInto(SavedLocals, CGF.LocalDeclMap);
1157 SavedLocals.clear();
1158 }
1159 }
1160
1161 private:
1162 /// Copy all the entries in the source map over the corresponding
1163 /// entries in the destination, which must exist.
1164 static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) {
1165 for (auto &[Decl, Addr] : Src) {
1166 if (!Addr.isValid())
1167 Dest.erase(Decl);
1168 else
1169 Dest.insert_or_assign(Decl, Addr);
1170 }
1171 }
1172 };
1173
1174 /// The scope used to remap some variables as private in the OpenMP loop body
1175 /// (or other captured region emitted without outlining), and to restore old
1176 /// vars back on exit.
1178 OMPMapVars MappedVars;
1179 OMPPrivateScope(const OMPPrivateScope &) = delete;
1180 void operator=(const OMPPrivateScope &) = delete;
1181
1182 public:
1183 /// Enter a new OpenMP private scope.
1185
1186 /// Registers \p LocalVD variable as a private with \p Addr as the address
1187 /// of the corresponding private variable. \p
1188 /// PrivateGen is the address of the generated private variable.
1189 /// \return true if the variable is registered as private, false if it has
1190 /// been privatized already.
1191 bool addPrivate(const VarDecl *LocalVD, Address Addr) {
1192 assert(PerformCleanup && "adding private to dead scope");
1193 return MappedVars.setVarAddr(CGF, LocalVD, Addr);
1194 }
1195
1196 /// Privatizes local variables previously registered as private.
1197 /// Registration is separate from the actual privatization to allow
1198 /// initializers use values of the original variables, not the private one.
1199 /// This is important, for example, if the private variable is a class
1200 /// variable initialized by a constructor that references other private
1201 /// variables. But at initialization original variables must be used, not
1202 /// private copies.
1203 /// \return true if at least one variable was privatized, false otherwise.
1204 bool Privatize() { return MappedVars.apply(CGF); }
1205
1208 restoreMap();
1209 }
1210
1211 /// Exit scope - all the mapped variables are restored.
1213 if (PerformCleanup)
1214 ForceCleanup();
1215 }
1216
1217 /// Checks if the global variable is captured in current function.
1218 bool isGlobalVarCaptured(const VarDecl *VD) const {
1219 VD = VD->getCanonicalDecl();
1220 return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1221 }
1222
1223 /// Restore all mapped variables w/o clean up. This is usefully when we want
1224 /// to reference the original variables but don't want the clean up because
1225 /// that could emit lifetime end too early, causing backend issue #56913.
1226 void restoreMap() { MappedVars.restore(CGF); }
1227 };
1228
1229 /// Save/restore original map of previously emitted local vars in case when we
1230 /// need to duplicate emission of the same code several times in the same
1231 /// function for OpenMP code.
1233 CodeGenFunction &CGF;
1234 DeclMapTy SavedMap;
1235
1236 public:
1238 : CGF(CGF), SavedMap(CGF.LocalDeclMap) {}
1239 ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); }
1240 };
1241
1242 /// Takes the old cleanup stack size and emits the cleanup blocks
1243 /// that have been added.
1244 void
1246 std::initializer_list<llvm::Value **> ValuesToReload = {});
1247
1248 /// Takes the old cleanup stack size and emits the cleanup blocks
1249 /// that have been added, then adds all lifetime-extended cleanups from
1250 /// the given position to the stack.
1251 void
1253 size_t OldLifetimeExtendedStackSize,
1254 std::initializer_list<llvm::Value **> ValuesToReload = {});
1255
1256 void ResolveBranchFixups(llvm::BasicBlock *Target);
1257
1258 /// The given basic block lies in the current EH scope, but may be a
1259 /// target of a potentially scope-crossing jump; get a stable handle
1260 /// to which we can perform this jump later.
1262 return JumpDest(Target,
1265 }
1266
1267 /// The given basic block lies in the current EH scope, but may be a
1268 /// target of a potentially scope-crossing jump; get a stable handle
1269 /// to which we can perform this jump later.
1270 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
1272 }
1273
1274 /// EmitBranchThroughCleanup - Emit a branch from the current insert
1275 /// block through the normal cleanup handling code (if any) and then
1276 /// on to \arg Dest.
1278
1279 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1280 /// specified destination obviously has no cleanups to run. 'false' is always
1281 /// a conservatively correct answer for this method.
1283
1284 /// popCatchScope - Pops the catch scope at the top of the EHScope
1285 /// stack, emitting any required code (other than the catch handlers
1286 /// themselves).
1288
1289 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
1291 llvm::BasicBlock *
1293
1294 /// An object to manage conditionally-evaluated expressions.
1296 llvm::BasicBlock *StartBB;
1297
1298 public:
1300 : StartBB(CGF.Builder.GetInsertBlock()) {}
1301
1303 assert(CGF.OutermostConditional != this);
1304 if (!CGF.OutermostConditional)
1305 CGF.OutermostConditional = this;
1306 }
1307
1309 assert(CGF.OutermostConditional != nullptr);
1310 if (CGF.OutermostConditional == this)
1311 CGF.OutermostConditional = nullptr;
1312 }
1313
1314 /// Returns a block which will be executed prior to each
1315 /// evaluation of the conditional code.
1316 llvm::BasicBlock *getStartingBlock() const {
1317 return StartBB;
1318 }
1319 };
1320
1321 /// isInConditionalBranch - Return true if we're currently emitting
1322 /// one branch or the other of a conditional expression.
1323 bool isInConditionalBranch() const { return OutermostConditional != nullptr; }
1324
1325 void setBeforeOutermostConditional(llvm::Value *value, Address addr,
1326 CodeGenFunction &CGF) {
1327 assert(isInConditionalBranch());
1328 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1329 auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF),
1330 block->back().getIterator());
1331 store->setAlignment(addr.getAlignment().getAsAlign());
1332 }
1333
1334 /// An RAII object to record that we're evaluating a statement
1335 /// expression.
1337 CodeGenFunction &CGF;
1338
1339 /// We have to save the outermost conditional: cleanups in a
1340 /// statement expression aren't conditional just because the
1341 /// StmtExpr is.
1342 ConditionalEvaluation *SavedOutermostConditional;
1343
1344 public:
1346 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1347 CGF.OutermostConditional = nullptr;
1348 }
1349
1351 CGF.OutermostConditional = SavedOutermostConditional;
1352 CGF.EnsureInsertPoint();
1353 }
1354 };
1355
1356 /// An object which temporarily prevents a value from being
1357 /// destroyed by aggressive peephole optimizations that assume that
1358 /// all uses of a value have been realized in the IR.
1360 llvm::Instruction *Inst = nullptr;
1361 friend class CodeGenFunction;
1362
1363 public:
1365 };
1366
1367 /// A non-RAII class containing all the information about a bound
1368 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
1369 /// this which makes individual mappings very simple; using this
1370 /// class directly is useful when you have a variable number of
1371 /// opaque values or don't want the RAII functionality for some
1372 /// reason.
1374 const OpaqueValueExpr *OpaqueValue;
1375 bool BoundLValue;
1377
1379 bool boundLValue)
1380 : OpaqueValue(ov), BoundLValue(boundLValue) {}
1381 public:
1382 OpaqueValueMappingData() : OpaqueValue(nullptr) {}
1383
1384 static bool shouldBindAsLValue(const Expr *expr) {
1385 // gl-values should be bound as l-values for obvious reasons.
1386 // Records should be bound as l-values because IR generation
1387 // always keeps them in memory. Expressions of function type
1388 // act exactly like l-values but are formally required to be
1389 // r-values in C.
1390 return expr->isGLValue() ||
1391 expr->getType()->isFunctionType() ||
1392 hasAggregateEvaluationKind(expr->getType());
1393 }
1394
1396 const OpaqueValueExpr *ov,
1397 const Expr *e) {
1398 if (shouldBindAsLValue(ov))
1399 return bind(CGF, ov, CGF.EmitLValue(e));
1400 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1401 }
1402
1404 const OpaqueValueExpr *ov,
1405 const LValue &lv) {
1406 assert(shouldBindAsLValue(ov));
1407 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1408 return OpaqueValueMappingData(ov, true);
1409 }
1410
1412 const OpaqueValueExpr *ov,
1413 const RValue &rv) {
1414 assert(!shouldBindAsLValue(ov));
1415 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1416
1417 OpaqueValueMappingData data(ov, false);
1418
1419 // Work around an extremely aggressive peephole optimization in
1420 // EmitScalarConversion which assumes that all other uses of a
1421 // value are extant.
1422 data.Protection = CGF.protectFromPeepholes(rv);
1423
1424 return data;
1425 }
1426
1427 bool isValid() const { return OpaqueValue != nullptr; }
1428 void clear() { OpaqueValue = nullptr; }
1429
1431 assert(OpaqueValue && "no data to unbind!");
1432
1433 if (BoundLValue) {
1434 CGF.OpaqueLValues.erase(OpaqueValue);
1435 } else {
1436 CGF.OpaqueRValues.erase(OpaqueValue);
1437 CGF.unprotectFromPeepholes(Protection);
1438 }
1439 }
1440 };
1441
1442 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1444 CodeGenFunction &CGF;
1446
1447 public:
1448 static bool shouldBindAsLValue(const Expr *expr) {
1450 }
1451
1452 /// Build the opaque value mapping for the given conditional
1453 /// operator if it's the GNU ?: extension. This is a common
1454 /// enough pattern that the convenience operator is really
1455 /// helpful.
1456 ///
1458 const AbstractConditionalOperator *op) : CGF(CGF) {
1459 if (isa<ConditionalOperator>(op))
1460 // Leave Data empty.
1461 return;
1462
1463 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
1465 e->getCommon());
1466 }
1467
1468 /// Build the opaque value mapping for an OpaqueValueExpr whose source
1469 /// expression is set to the expression the OVE represents.
1471 : CGF(CGF) {
1472 if (OV) {
1473 assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1474 "for OVE with no source expression");
1476 }
1477 }
1478
1480 const OpaqueValueExpr *opaqueValue,
1481 LValue lvalue)
1482 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
1483 }
1484
1486 const OpaqueValueExpr *opaqueValue,
1487 RValue rvalue)
1488 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
1489 }
1490
1491 void pop() {
1492 Data.unbind(CGF);
1493 Data.clear();
1494 }
1495
1497 if (Data.isValid()) Data.unbind(CGF);
1498 }
1499 };
1500
1501private:
1502 CGDebugInfo *DebugInfo;
1503 /// Used to create unique names for artificial VLA size debug info variables.
1504 unsigned VLAExprCounter = 0;
1505 bool DisableDebugInfo = false;
1506
1507 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1508 /// calling llvm.stacksave for multiple VLAs in the same scope.
1509 bool DidCallStackSave = false;
1510
1511 /// IndirectBranch - The first time an indirect goto is seen we create a block
1512 /// with an indirect branch. Every time we see the address of a label taken,
1513 /// we add the label to the indirect goto. Every subsequent indirect goto is
1514 /// codegen'd as a jump to the IndirectBranch's basic block.
1515 llvm::IndirectBrInst *IndirectBranch = nullptr;
1516
1517 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1518 /// decls.
1519 DeclMapTy LocalDeclMap;
1520
1521 // Keep track of the cleanups for callee-destructed parameters pushed to the
1522 // cleanup stack so that they can be deactivated later.
1523 llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
1524 CalleeDestructedParamCleanups;
1525
1526 /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1527 /// will contain a mapping from said ParmVarDecl to its implicit "object_size"
1528 /// parameter.
1529 llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2>
1530 SizeArguments;
1531
1532 /// Track escaped local variables with auto storage. Used during SEH
1533 /// outlining to produce a call to llvm.localescape.
1534 llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
1535
1536 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1537 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
1538
1539 // BreakContinueStack - This keeps track of where break and continue
1540 // statements should jump to.
1541 struct BreakContinue {
1542 BreakContinue(JumpDest Break, JumpDest Continue)
1543 : BreakBlock(Break), ContinueBlock(Continue) {}
1544
1545 JumpDest BreakBlock;
1546 JumpDest ContinueBlock;
1547 };
1548 SmallVector<BreakContinue, 8> BreakContinueStack;
1549
1550 /// Handles cancellation exit points in OpenMP-related constructs.
1551 class OpenMPCancelExitStack {
1552 /// Tracks cancellation exit point and join point for cancel-related exit
1553 /// and normal exit.
1554 struct CancelExit {
1555 CancelExit() = default;
1556 CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
1557 JumpDest ContBlock)
1558 : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
1559 OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
1560 /// true if the exit block has been emitted already by the special
1561 /// emitExit() call, false if the default codegen is used.
1562 bool HasBeenEmitted = false;
1563 JumpDest ExitBlock;
1564 JumpDest ContBlock;
1565 };
1566
1567 SmallVector<CancelExit, 8> Stack;
1568
1569 public:
1570 OpenMPCancelExitStack() : Stack(1) {}
1571 ~OpenMPCancelExitStack() = default;
1572 /// Fetches the exit block for the current OpenMP construct.
1573 JumpDest getExitBlock() const { return Stack.back().ExitBlock; }
1574 /// Emits exit block with special codegen procedure specific for the related
1575 /// OpenMP construct + emits code for normal construct cleanup.
1576 void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
1577 const llvm::function_ref<void(CodeGenFunction &)> CodeGen) {
1578 if (Stack.back().Kind == Kind && getExitBlock().isValid()) {
1579 assert(CGF.getOMPCancelDestination(Kind).isValid());
1580 assert(CGF.HaveInsertPoint());
1581 assert(!Stack.back().HasBeenEmitted);
1582 auto IP = CGF.Builder.saveAndClearIP();
1583 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1584 CodeGen(CGF);
1585 CGF.EmitBranch(Stack.back().ContBlock.getBlock());
1586 CGF.Builder.restoreIP(IP);
1587 Stack.back().HasBeenEmitted = true;
1588 }
1589 CodeGen(CGF);
1590 }
1591 /// Enter the cancel supporting \a Kind construct.
1592 /// \param Kind OpenMP directive that supports cancel constructs.
1593 /// \param HasCancel true, if the construct has inner cancel directive,
1594 /// false otherwise.
1595 void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) {
1596 Stack.push_back({Kind,
1597 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1598 : JumpDest(),
1599 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1600 : JumpDest()});
1601 }
1602 /// Emits default exit point for the cancel construct (if the special one
1603 /// has not be used) + join point for cancel/normal exits.
1604 void exit(CodeGenFunction &CGF) {
1605 if (getExitBlock().isValid()) {
1606 assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid());
1607 bool HaveIP = CGF.HaveInsertPoint();
1608 if (!Stack.back().HasBeenEmitted) {
1609 if (HaveIP)
1610 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1611 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1612 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1613 }
1614 CGF.EmitBlock(Stack.back().ContBlock.getBlock());
1615 if (!HaveIP) {
1616 CGF.Builder.CreateUnreachable();
1617 CGF.Builder.ClearInsertionPoint();
1618 }
1619 }
1620 Stack.pop_back();
1621 }
1622 };
1623 OpenMPCancelExitStack OMPCancelStack;
1624
1625 /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
1626 llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
1627 Stmt::Likelihood LH);
1628
1629 CodeGenPGO PGO;
1630
1631 /// Bitmap used by MC/DC to track condition outcomes of a boolean expression.
1632 Address MCDCCondBitmapAddr = Address::invalid();
1633
1634 /// Calculate branch weights appropriate for PGO data
1635 llvm::MDNode *createProfileWeights(uint64_t TrueCount,
1636 uint64_t FalseCount) const;
1637 llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
1638 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1639 uint64_t LoopCount) const;
1640
1641public:
1642 auto getIsCounterPair(const Stmt *S) const { return PGO.getIsCounterPair(S); }
1643
1644 void markStmtAsUsed(bool Skipped, const Stmt *S) {
1645 PGO.markStmtAsUsed(Skipped, S);
1646 }
1647 void markStmtMaybeUsed(const Stmt *S) { PGO.markStmtMaybeUsed(S); }
1648
1649 /// Increment the profiler's counter for the given statement by \p StepV.
1650 /// If \p StepV is null, the default increment is 1.
1651 void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
1653 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile) &&
1654 !CurFn->hasFnAttribute(llvm::Attribute::SkipProfile)) {
1655 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1656 PGO.emitCounterSetOrIncrement(Builder, S, StepV);
1657 }
1658 PGO.setCurrentStmt(S);
1659 }
1660
1663 CGM.getCodeGenOpts().MCDCCoverage &&
1664 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile));
1665 }
1666
1667 /// Allocate a temp value on the stack that MCDC can use to track condition
1668 /// results.
1670 if (isMCDCCoverageEnabled()) {
1671 PGO.emitMCDCParameters(Builder);
1672 MCDCCondBitmapAddr =
1673 CreateIRTemp(getContext().UnsignedIntTy, "mcdc.addr");
1674 }
1675 }
1676
1677 bool isBinaryLogicalOp(const Expr *E) const {
1678 const BinaryOperator *BOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
1679 return (BOp && BOp->isLogicalOp());
1680 }
1681
1682 /// Zero-init the MCDC temp value.
1685 PGO.emitMCDCCondBitmapReset(Builder, E, MCDCCondBitmapAddr);
1686 PGO.setCurrentStmt(E);
1687 }
1688 }
1689
1690 /// Increment the profiler's counter for the given expression by \p StepV.
1691 /// If \p StepV is null, the default increment is 1.
1694 PGO.emitMCDCTestVectorBitmapUpdate(Builder, E, MCDCCondBitmapAddr, *this);
1695 PGO.setCurrentStmt(E);
1696 }
1697 }
1698
1699 /// Update the MCDC temp value with the condition's evaluated result.
1700 void maybeUpdateMCDCCondBitmap(const Expr *E, llvm::Value *Val) {
1701 if (isMCDCCoverageEnabled()) {
1702 PGO.emitMCDCCondBitmapUpdate(Builder, E, MCDCCondBitmapAddr, Val, *this);
1703 PGO.setCurrentStmt(E);
1704 }
1705 }
1706
1707 /// Get the profiler's count for the given statement.
1708 uint64_t getProfileCount(const Stmt *S) {
1709 return PGO.getStmtCount(S).value_or(0);
1710 }
1711
1712 /// Set the profiler's current count.
1713 void setCurrentProfileCount(uint64_t Count) {
1714 PGO.setCurrentRegionCount(Count);
1715 }
1716
1717 /// Get the profiler's current count. This is generally the count for the most
1718 /// recently incremented counter.
1720 return PGO.getCurrentRegionCount();
1721 }
1722
1723private:
1724
1725 /// SwitchInsn - This is nearest current switch instruction. It is null if
1726 /// current context is not in a switch.
1727 llvm::SwitchInst *SwitchInsn = nullptr;
1728 /// The branch weights of SwitchInsn when doing instrumentation based PGO.
1729 SmallVector<uint64_t, 16> *SwitchWeights = nullptr;
1730
1731 /// The likelihood attributes of the SwitchCase.
1732 SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr;
1733
1734 /// CaseRangeBlock - This block holds if condition check for last case
1735 /// statement range in current switch instruction.
1736 llvm::BasicBlock *CaseRangeBlock = nullptr;
1737
1738 /// OpaqueLValues - Keeps track of the current set of opaque value
1739 /// expressions.
1740 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1741 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1742
1743 // VLASizeMap - This keeps track of the associated size for each VLA type.
1744 // We track this by the size expression rather than the type itself because
1745 // in certain situations, like a const qualifier applied to an VLA typedef,
1746 // multiple VLA types can share the same size expression.
1747 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1748 // enter/leave scopes.
1749 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
1750
1751 /// A block containing a single 'unreachable' instruction. Created
1752 /// lazily by getUnreachableBlock().
1753 llvm::BasicBlock *UnreachableBlock = nullptr;
1754
1755 /// Counts of the number return expressions in the function.
1756 unsigned NumReturnExprs = 0;
1757
1758 /// Count the number of simple (constant) return expressions in the function.
1759 unsigned NumSimpleReturnExprs = 0;
1760
1761 /// The last regular (non-return) debug location (breakpoint) in the function.
1762 SourceLocation LastStopPoint;
1763
1764public:
1765 /// Source location information about the default argument or member
1766 /// initializer expression we're evaluating, if any.
1770
1771 /// A scope within which we are constructing the fields of an object which
1772 /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use
1773 /// if we need to evaluate a CXXDefaultInitExpr within the evaluation.
1775 public:
1777 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1778 CGF.CXXDefaultInitExprThis = This;
1779 }
1781 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1782 }
1783
1784 private:
1785 CodeGenFunction &CGF;
1786 Address OldCXXDefaultInitExprThis;
1787 };
1788
1789 /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
1790 /// is overridden to be the object under construction.
1792 public:
1794 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
1795 OldCXXThisAlignment(CGF.CXXThisAlignment),
1797 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getBasePointer();
1798 CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
1799 }
1801 CGF.CXXThisValue = OldCXXThisValue;
1802 CGF.CXXThisAlignment = OldCXXThisAlignment;
1803 }
1804
1805 public:
1807 llvm::Value *OldCXXThisValue;
1810 };
1811
1815 };
1816
1817 /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
1818 /// current loop index is overridden.
1820 public:
1821 ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
1822 : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {
1823 CGF.ArrayInitIndex = Index;
1824 }
1826 CGF.ArrayInitIndex = OldArrayInitIndex;
1827 }
1828
1829 private:
1830 CodeGenFunction &CGF;
1831 llvm::Value *OldArrayInitIndex;
1832 };
1833
1835 public:
1837 : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl),
1838 OldCurCodeDecl(CGF.CurCodeDecl),
1839 OldCXXABIThisDecl(CGF.CXXABIThisDecl),
1840 OldCXXABIThisValue(CGF.CXXABIThisValue),
1841 OldCXXThisValue(CGF.CXXThisValue),
1842 OldCXXABIThisAlignment(CGF.CXXABIThisAlignment),
1843 OldCXXThisAlignment(CGF.CXXThisAlignment),
1844 OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy),
1845 OldCXXInheritedCtorInitExprArgs(
1846 std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1847 CGF.CurGD = GD;
1848 CGF.CurFuncDecl = CGF.CurCodeDecl =
1849 cast<CXXConstructorDecl>(GD.getDecl());
1850 CGF.CXXABIThisDecl = nullptr;
1851 CGF.CXXABIThisValue = nullptr;
1852 CGF.CXXThisValue = nullptr;
1853 CGF.CXXABIThisAlignment = CharUnits();
1854 CGF.CXXThisAlignment = CharUnits();
1856 CGF.FnRetTy = QualType();
1857 CGF.CXXInheritedCtorInitExprArgs.clear();
1858 }
1860 CGF.CurGD = OldCurGD;
1861 CGF.CurFuncDecl = OldCurFuncDecl;
1862 CGF.CurCodeDecl = OldCurCodeDecl;
1863 CGF.CXXABIThisDecl = OldCXXABIThisDecl;
1864 CGF.CXXABIThisValue = OldCXXABIThisValue;
1865 CGF.CXXThisValue = OldCXXThisValue;
1866 CGF.CXXABIThisAlignment = OldCXXABIThisAlignment;
1867 CGF.CXXThisAlignment = OldCXXThisAlignment;
1868 CGF.ReturnValue = OldReturnValue;
1869 CGF.FnRetTy = OldFnRetTy;
1870 CGF.CXXInheritedCtorInitExprArgs =
1871 std::move(OldCXXInheritedCtorInitExprArgs);
1872 }
1873
1874 private:
1875 CodeGenFunction &CGF;
1876 GlobalDecl OldCurGD;
1877 const Decl *OldCurFuncDecl;
1878 const Decl *OldCurCodeDecl;
1879 ImplicitParamDecl *OldCXXABIThisDecl;
1880 llvm::Value *OldCXXABIThisValue;
1881 llvm::Value *OldCXXThisValue;
1882 CharUnits OldCXXABIThisAlignment;
1883 CharUnits OldCXXThisAlignment;
1884 Address OldReturnValue;
1885 QualType OldFnRetTy;
1886 CallArgList OldCXXInheritedCtorInitExprArgs;
1887 };
1888
1889 // Helper class for the OpenMP IR Builder. Allows reusability of code used for
1890 // region body, and finalization codegen callbacks. This will class will also
1891 // contain privatization functions used by the privatization call backs
1892 //
1893 // TODO: this is temporary class for things that are being moved out of
1894 // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or
1895 // utility function for use with the OMPBuilder. Once that move to use the
1896 // OMPBuilder is done, everything here will either become part of CodeGenFunc.
1897 // directly, or a new helper class that will contain functions used by both
1898 // this and the OMPBuilder
1899
1901
1905
1906 using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
1907
1908 /// Cleanup action for allocate support.
1910
1911 private:
1912 llvm::CallInst *RTLFnCI;
1913
1914 public:
1915 OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) {
1916 RLFnCI->removeFromParent();
1917 }
1918
1919 void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
1920 if (!CGF.HaveInsertPoint())
1921 return;
1922 CGF.Builder.Insert(RTLFnCI);
1923 }
1924 };
1925
1926 /// Returns address of the threadprivate variable for the current
1927 /// thread. This Also create any necessary OMP runtime calls.
1928 ///
1929 /// \param VD VarDecl for Threadprivate variable.
1930 /// \param VDAddr Address of the Vardecl
1931 /// \param Loc The location where the barrier directive was encountered
1933 const VarDecl *VD, Address VDAddr,
1935
1936 /// Gets the OpenMP-specific address of the local variable /p VD.
1938 const VarDecl *VD);
1939 /// Get the platform-specific name separator.
1940 /// \param Parts different parts of the final name that needs separation
1941 /// \param FirstSeparator First separator used between the initial two
1942 /// parts of the name.
1943 /// \param Separator separator used between all of the rest consecutinve
1944 /// parts of the name
1945 static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
1946 StringRef FirstSeparator = ".",
1947 StringRef Separator = ".");
1948 /// Emit the Finalization for an OMP region
1949 /// \param CGF The Codegen function this belongs to
1950 /// \param IP Insertion point for generating the finalization code.
1952 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1953 assert(IP.getBlock()->end() != IP.getPoint() &&
1954 "OpenMP IR Builder should cause terminated block!");
1955
1956 llvm::BasicBlock *IPBB = IP.getBlock();
1957 llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1958 assert(DestBB && "Finalization block should have one successor!");
1959
1960 // erase and replace with cleanup branch.
1961 IPBB->getTerminator()->eraseFromParent();
1962 CGF.Builder.SetInsertPoint(IPBB);
1964 CGF.EmitBranchThroughCleanup(Dest);
1965 }
1966
1967 /// Emit the body of an OMP region
1968 /// \param CGF The Codegen function this belongs to
1969 /// \param RegionBodyStmt The body statement for the OpenMP region being
1970 /// generated
1971 /// \param AllocaIP Where to insert alloca instructions
1972 /// \param CodeGenIP Where to insert the region code
1973 /// \param RegionName Name to be used for new blocks
1975 const Stmt *RegionBodyStmt,
1976 InsertPointTy AllocaIP,
1977 InsertPointTy CodeGenIP,
1978 Twine RegionName);
1979
1980 static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP,
1981 llvm::BasicBlock &FiniBB, llvm::Function *Fn,
1983 llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1984 if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1985 CodeGenIPBBTI->eraseFromParent();
1986
1987 CGF.Builder.SetInsertPoint(CodeGenIPBB);
1988
1989 if (Fn->doesNotThrow())
1990 CGF.EmitNounwindRuntimeCall(Fn, Args);
1991 else
1992 CGF.EmitRuntimeCall(Fn, Args);
1993
1994 if (CGF.Builder.saveIP().isSet())
1995 CGF.Builder.CreateBr(&FiniBB);
1996 }
1997
1998 /// Emit the body of an OMP region that will be outlined in
1999 /// OpenMPIRBuilder::finalize().
2000 /// \param CGF The Codegen function this belongs to
2001 /// \param RegionBodyStmt The body statement for the OpenMP region being
2002 /// generated
2003 /// \param AllocaIP Where to insert alloca instructions
2004 /// \param CodeGenIP Where to insert the region code
2005 /// \param RegionName Name to be used for new blocks
2007 const Stmt *RegionBodyStmt,
2008 InsertPointTy AllocaIP,
2009 InsertPointTy CodeGenIP,
2010 Twine RegionName);
2011
2012 /// RAII for preserving necessary info during Outlined region body codegen.
2014
2015 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
2016 CodeGenFunction::JumpDest OldReturnBlock;
2017 CodeGenFunction &CGF;
2018
2019 public:
2021 llvm::BasicBlock &RetBB)
2022 : CGF(cgf) {
2023 assert(AllocaIP.isSet() &&
2024 "Must specify Insertion point for allocas of outlined function");
2025 OldAllocaIP = CGF.AllocaInsertPt;
2026 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2027
2028 OldReturnBlock = CGF.ReturnBlock;
2029 CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB);
2030 }
2031
2033 CGF.AllocaInsertPt = OldAllocaIP;
2034 CGF.ReturnBlock = OldReturnBlock;
2035 }
2036 };
2037
2038 /// RAII for preserving necessary info during inlined region body codegen.
2040
2041 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
2042 CodeGenFunction &CGF;
2043
2044 public:
2046 llvm::BasicBlock &FiniBB)
2047 : CGF(cgf) {
2048 // Alloca insertion block should be in the entry block of the containing
2049 // function so it expects an empty AllocaIP in which case will reuse the
2050 // old alloca insertion point, or a new AllocaIP in the same block as
2051 // the old one
2052 assert((!AllocaIP.isSet() ||
2053 CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
2054 "Insertion point should be in the entry block of containing "
2055 "function!");
2056 OldAllocaIP = CGF.AllocaInsertPt;
2057 if (AllocaIP.isSet())
2058 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
2059
2060 // TODO: Remove the call, after making sure the counter is not used by
2061 // the EHStack.
2062 // Since this is an inlined region, it should not modify the
2063 // ReturnBlock, and should reuse the one for the enclosing outlined
2064 // region. So, the JumpDest being return by the function is discarded
2065 (void)CGF.getJumpDestInCurrentScope(&FiniBB);
2066 }
2067
2069 };
2070 };
2071
2072private:
2073 /// CXXThisDecl - When generating code for a C++ member function,
2074 /// this will hold the implicit 'this' declaration.
2075 ImplicitParamDecl *CXXABIThisDecl = nullptr;
2076 llvm::Value *CXXABIThisValue = nullptr;
2077 llvm::Value *CXXThisValue = nullptr;
2078 CharUnits CXXABIThisAlignment;
2079 CharUnits CXXThisAlignment;
2080
2081 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
2082 /// this expression.
2083 Address CXXDefaultInitExprThis = Address::invalid();
2084
2085 /// The current array initialization index when evaluating an
2086 /// ArrayInitIndexExpr within an ArrayInitLoopExpr.
2087 llvm::Value *ArrayInitIndex = nullptr;
2088
2089 /// The values of function arguments to use when evaluating
2090 /// CXXInheritedCtorInitExprs within this context.
2091 CallArgList CXXInheritedCtorInitExprArgs;
2092
2093 /// CXXStructorImplicitParamDecl - When generating code for a constructor or
2094 /// destructor, this will hold the implicit argument (e.g. VTT).
2095 ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr;
2096 llvm::Value *CXXStructorImplicitParamValue = nullptr;
2097
2098 /// OutermostConditional - Points to the outermost active
2099 /// conditional control. This is used so that we know if a
2100 /// temporary should be destroyed conditionally.
2101 ConditionalEvaluation *OutermostConditional = nullptr;
2102
2103 /// The current lexical scope.
2104 LexicalScope *CurLexicalScope = nullptr;
2105
2106 /// The current source location that should be used for exception
2107 /// handling code.
2108 SourceLocation CurEHLocation;
2109
2110 /// BlockByrefInfos - For each __block variable, contains
2111 /// information about the layout of the variable.
2112 llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
2113
2114 /// Used by -fsanitize=nullability-return to determine whether the return
2115 /// value can be checked.
2116 llvm::Value *RetValNullabilityPrecondition = nullptr;
2117
2118 /// Check if -fsanitize=nullability-return instrumentation is required for
2119 /// this function.
2120 bool requiresReturnValueNullabilityCheck() const {
2121 return RetValNullabilityPrecondition;
2122 }
2123
2124 /// Used to store precise source locations for return statements by the
2125 /// runtime return value checks.
2126 Address ReturnLocation = Address::invalid();
2127
2128 /// Check if the return value of this function requires sanitization.
2129 bool requiresReturnValueCheck() const;
2130
2131 bool isInAllocaArgument(CGCXXABI &ABI, QualType Ty);
2132 bool hasInAllocaArg(const CXXMethodDecl *MD);
2133
2134 llvm::BasicBlock *TerminateLandingPad = nullptr;
2135 llvm::BasicBlock *TerminateHandler = nullptr;
2137
2138 /// Terminate funclets keyed by parent funclet pad.
2139 llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
2140
2141 /// Largest vector width used in ths function. Will be used to create a
2142 /// function attribute.
2143 unsigned LargestVectorWidth = 0;
2144
2145 /// True if we need emit the life-time markers. This is initially set in
2146 /// the constructor, but could be overwritten to true if this is a coroutine.
2147 bool ShouldEmitLifetimeMarkers;
2148
2149 /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
2150 /// the function metadata.
2151 void EmitKernelMetadata(const FunctionDecl *FD, llvm::Function *Fn);
2152
2153public:
2154 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
2156
2157 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
2158 ASTContext &getContext() const { return CGM.getContext(); }
2160 if (DisableDebugInfo)
2161 return nullptr;
2162 return DebugInfo;
2163 }
2164 void disableDebugInfo() { DisableDebugInfo = true; }
2165 void enableDebugInfo() { DisableDebugInfo = false; }
2166
2168 return CGM.getCodeGenOpts().OptimizationLevel == 0;
2169 }
2170
2171 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
2172
2173 /// Returns a pointer to the function's exception object and selector slot,
2174 /// which is assigned in every landing pad.
2177
2178 /// Returns the contents of the function's exception object and selector
2179 /// slots.
2180 llvm::Value *getExceptionFromSlot();
2181 llvm::Value *getSelectorFromSlot();
2182
2184
2185 llvm::BasicBlock *getUnreachableBlock() {
2186 if (!UnreachableBlock) {
2187 UnreachableBlock = createBasicBlock("unreachable");
2188 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
2189 }
2190 return UnreachableBlock;
2191 }
2192
2193 llvm::BasicBlock *getInvokeDest() {
2194 if (!EHStack.requiresLandingPad()) return nullptr;
2195 return getInvokeDestImpl();
2196 }
2197
2198 bool currentFunctionUsesSEHTry() const { return !!CurSEHParent; }
2199
2200 const TargetInfo &getTarget() const { return Target; }
2201 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
2203 return CGM.getTargetCodeGenInfo();
2204 }
2205
2206 //===--------------------------------------------------------------------===//
2207 // Cleanups
2208 //===--------------------------------------------------------------------===//
2209
2210 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
2211
2212 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
2213 Address arrayEndPointer,
2214 QualType elementType,
2215 CharUnits elementAlignment,
2216 Destroyer *destroyer);
2217 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
2218 llvm::Value *arrayEnd,
2219 QualType elementType,
2220 CharUnits elementAlignment,
2221 Destroyer *destroyer);
2222
2224 Address addr, QualType type);
2226 Address addr, QualType type);
2228 Destroyer *destroyer, bool useEHCleanupForArray);
2230 Address addr, QualType type);
2232 QualType type, Destroyer *destroyer,
2233 bool useEHCleanupForArray);
2235 QualType type, Destroyer *destroyer,
2236 bool useEHCleanupForArray);
2237 void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
2238 llvm::Value *CompletePtr,
2239 QualType ElementType);
2242 std::pair<llvm::Value *, llvm::Value *> AddrSizePair);
2244 bool useEHCleanupForArray);
2246 Destroyer *destroyer,
2247 bool useEHCleanupForArray,
2248 const VarDecl *VD);
2249 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
2250 QualType elementType, CharUnits elementAlign,
2251 Destroyer *destroyer,
2252 bool checkZeroLength, bool useEHCleanup);
2253
2255
2256 /// Determines whether an EH cleanup is required to destroy a type
2257 /// with the given destruction kind.
2259 switch (kind) {
2260 case QualType::DK_none:
2261 return false;
2265 return getLangOpts().Exceptions;
2267 return getLangOpts().Exceptions &&
2268 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
2269 }
2270 llvm_unreachable("bad destruction kind");
2271 }
2272
2275 }
2276
2277 //===--------------------------------------------------------------------===//
2278 // Objective-C
2279 //===--------------------------------------------------------------------===//
2280
2282
2284
2285 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2287 const ObjCPropertyImplDecl *PID);
2289 const ObjCPropertyImplDecl *propImpl,
2290 const ObjCMethodDecl *GetterMothodDecl,
2291 llvm::Constant *AtomicHelperFn);
2292
2294 ObjCMethodDecl *MD, bool ctor);
2295
2296 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2297 /// for the given property.
2299 const ObjCPropertyImplDecl *PID);
2301 const ObjCPropertyImplDecl *propImpl,
2302 llvm::Constant *AtomicHelperFn);
2303
2304 //===--------------------------------------------------------------------===//
2305 // Block Bits
2306 //===--------------------------------------------------------------------===//
2307
2308 /// Emit block literal.
2309 /// \return an LLVM value which is a pointer to a struct which contains
2310 /// information about the block, including the block invoke function, the
2311 /// captured variables, etc.
2312 llvm::Value *EmitBlockLiteral(const BlockExpr *);
2313
2315 const CGBlockInfo &Info,
2316 const DeclMapTy &ldm,
2317 bool IsLambdaConversionToBlock,
2318 bool BuildGlobalBlock);
2319
2320 /// Check if \p T is a C++ class that has a destructor that can throw.
2322
2323 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
2324 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
2326 const ObjCPropertyImplDecl *PID);
2328 const ObjCPropertyImplDecl *PID);
2329 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
2330
2331 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
2332 bool CanThrow);
2333
2334 class AutoVarEmission;
2335
2337
2338 /// Enter a cleanup to destroy a __block variable. Note that this
2339 /// cleanup should be a no-op if the variable hasn't left the stack
2340 /// yet; if a cleanup is required for the variable itself, that needs
2341 /// to be done externally.
2342 ///
2343 /// \param Kind Cleanup kind.
2344 ///
2345 /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block
2346 /// structure that will be passed to _Block_object_dispose. When
2347 /// \p LoadBlockVarAddr is true, the address of the field of the block
2348 /// structure that holds the address of the __block structure.
2349 ///
2350 /// \param Flags The flag that will be passed to _Block_object_dispose.
2351 ///
2352 /// \param LoadBlockVarAddr Indicates whether we need to emit a load from
2353 /// \p Addr to get the address of the __block structure.
2355 bool LoadBlockVarAddr, bool CanThrow);
2356
2357 void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum,
2358 llvm::Value *ptr);
2359
2362
2363 /// BuildBlockByrefAddress - Computes the location of the
2364 /// data in a variable which is declared as __block.
2366 bool followForward = true);
2368 const BlockByrefInfo &info,
2369 bool followForward,
2370 const llvm::Twine &name);
2371
2373
2375
2376 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
2377 const CGFunctionInfo &FnInfo);
2378
2379 /// Annotate the function with an attribute that disables TSan checking at
2380 /// runtime.
2381 void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
2382
2383 /// Emit code for the start of a function.
2384 /// \param Loc The location to be associated with the function.
2385 /// \param StartLoc The location of the function body.
2387 QualType RetTy,
2388 llvm::Function *Fn,
2389 const CGFunctionInfo &FnInfo,
2390 const FunctionArgList &Args,
2392 SourceLocation StartLoc = SourceLocation());
2393
2395
2399 void EmitFunctionBody(const Stmt *Body);
2400 void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2401
2402 void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator,
2403 CallArgList &CallArgs,
2404 const CGFunctionInfo *CallOpFnInfo = nullptr,
2405 llvm::Constant *CallOpFn = nullptr);
2409 CallArgList &CallArgs);
2411 const CGFunctionInfo **ImplFnInfo,
2412 llvm::Function **ImplFn);
2415 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2416 }
2417 void EmitAsanPrologueOrEpilogue(bool Prologue);
2418
2419 /// Emit the unified return block, trying to avoid its emission when
2420 /// possible.
2421 /// \return The debug location of the user written return statement if the
2422 /// return block is avoided.
2423 llvm::DebugLoc EmitReturnBlock();
2424
2425 /// FinishFunction - Complete IR generation of the current function. It is
2426 /// legal to call this function even if there is no current insertion point.
2428
2429 void StartThunk(llvm::Function *Fn, GlobalDecl GD,
2430 const CGFunctionInfo &FnInfo, bool IsUnprototyped);
2431
2432 void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
2433 const ThunkInfo *Thunk, bool IsUnprototyped);
2434
2436
2437 /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
2438 void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
2439 llvm::FunctionCallee Callee);
2440
2441 /// Generate a thunk for the given method.
2442 void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
2443 GlobalDecl GD, const ThunkInfo &Thunk,
2444 bool IsUnprototyped);
2445
2446 llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
2447 const CGFunctionInfo &FnInfo,
2448 GlobalDecl GD, const ThunkInfo &Thunk);
2449
2451 FunctionArgList &Args);
2452
2454
2455 /// Struct with all information about dynamic [sub]class needed to set vptr.
2456 struct VPtr {
2461 };
2462
2463 /// Initialize the vtable pointer of the given subobject.
2465
2467
2470
2472 CharUnits OffsetFromNearestVBase,
2473 bool BaseIsNonVirtualPrimaryBase,
2474 const CXXRecordDecl *VTableClass,
2475 VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs);
2476
2478
2479 // VTableTrapMode - whether we guarantee that loading the
2480 // vtable is guaranteed to trap on authentication failure,
2481 // even if the resulting vtable pointer is unused.
2482 enum class VTableAuthMode {
2484 MustTrap,
2485 UnsafeUbsanStrip // Should only be used for Vptr UBSan check
2486 };
2487 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2488 /// to by This.
2489 llvm::Value *
2490 GetVTablePtr(Address This, llvm::Type *VTableTy,
2491 const CXXRecordDecl *VTableClass,
2493
2502 };
2503
2504 /// Derived is the presumed address of an object of type T after a
2505 /// cast. If T is a polymorphic class type, emit a check that the virtual
2506 /// table for Derived belongs to a class derived from T.
2507 void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull,
2509
2510 /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2511 /// If vptr CFI is enabled, emit a check that VTable is valid.
2512 void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable,
2514
2515 /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2516 /// RD using llvm.type.test.
2517 void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable,
2519
2520 /// If whole-program virtual table optimization is enabled, emit an assumption
2521 /// that VTable is a member of RD's type identifier. Or, if vptr CFI is
2522 /// enabled, emit a check that VTable is a member of RD's type identifier.
2524 llvm::Value *VTable, SourceLocation Loc);
2525
2526 /// Returns whether we should perform a type checked load when loading a
2527 /// virtual function for virtual calls to members of RD. This is generally
2528 /// true when both vcall CFI and whole-program-vtables are enabled.
2530
2531 /// Emit a type checked load from the given vtable.
2533 llvm::Value *VTable,
2534 llvm::Type *VTableTy,
2535 uint64_t VTableByteOffset);
2536
2537 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2538 /// given phase of destruction for a destructor. The end result
2539 /// should call destructors on members and base classes in reverse
2540 /// order of their construction.
2542
2543 /// ShouldInstrumentFunction - Return true if the current function should be
2544 /// instrumented with __cyg_profile_func_* calls
2546
2547 /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2548 /// should not be instrumented with sanitizers.
2550
2551 /// ShouldXRayInstrument - Return true if the current function should be
2552 /// instrumented with XRay nop sleds.
2554
2555 /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2556 /// XRay custom event handling calls.
2558
2559 /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2560 /// XRay typed event handling calls.
2562
2563 /// Return a type hash constant for a function instrumented by
2564 /// -fsanitize=function.
2565 llvm::ConstantInt *getUBSanFunctionTypeHash(QualType T) const;
2566
2567 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2568 /// arguments for the given function. This is also responsible for naming the
2569 /// LLVM function arguments.
2571 llvm::Function *Fn,
2572 const FunctionArgList &Args);
2573
2574 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2575 /// given temporary.
2576 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc,
2577 SourceLocation EndLoc);
2578
2579 /// Emit a test that checks if the return value \p RV is nonnull.
2580 void EmitReturnValueCheck(llvm::Value *RV);
2581
2582 /// EmitStartEHSpec - Emit the start of the exception spec.
2583 void EmitStartEHSpec(const Decl *D);
2584
2585 /// EmitEndEHSpec - Emit the end of the exception spec.
2586 void EmitEndEHSpec(const Decl *D);
2587
2588 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2589 llvm::BasicBlock *getTerminateLandingPad();
2590
2591 /// getTerminateLandingPad - Return a cleanup funclet that just calls
2592 /// terminate.
2593 llvm::BasicBlock *getTerminateFunclet();
2594
2595 /// getTerminateHandler - Return a handler (not a landing pad, just
2596 /// a catch handler) that just calls terminate. This is used when
2597 /// a terminate scope encloses a try.
2598 llvm::BasicBlock *getTerminateHandler();
2599
2601 llvm::Type *ConvertType(QualType T);
2603 llvm::Type *LLVMTy = nullptr);
2604 llvm::Type *ConvertType(const TypeDecl *T) {
2605 return ConvertType(getContext().getTypeDeclType(T));
2606 }
2607
2608 /// LoadObjCSelf - Load the value of self. This function is only valid while
2609 /// generating code for an Objective-C method.
2610 llvm::Value *LoadObjCSelf();
2611
2612 /// TypeOfSelfObject - Return type of object that this self represents.
2614
2615 /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2617
2619 return getEvaluationKind(T) == TEK_Scalar;
2620 }
2621
2624 }
2625
2626 /// createBasicBlock - Create an LLVM basic block.
2627 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
2628 llvm::Function *parent = nullptr,
2629 llvm::BasicBlock *before = nullptr) {
2630 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
2631 }
2632
2633 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2634 /// label maps to.
2636
2637 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2638 /// another basic block, simplify it. This assumes that no other code could
2639 /// potentially reference the basic block.
2640 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
2641
2642 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2643 /// adding a fall-through branch from the current insert block if
2644 /// necessary. It is legal to call this function even if there is no current
2645 /// insertion point.
2646 ///
2647 /// IsFinished - If true, indicates that the caller has finished emitting
2648 /// branches to the given block and does not expect to emit code into it. This
2649 /// means the block can be ignored if it is unreachable.
2650 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
2651
2652 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2653 /// near its uses, and leave the insertion point in it.
2654 void EmitBlockAfterUses(llvm::BasicBlock *BB);
2655
2656 /// EmitBranch - Emit a branch to the specified basic block from the current
2657 /// insert block, taking care to avoid creation of branches from dummy
2658 /// blocks. It is legal to call this function even if there is no current
2659 /// insertion point.
2660 ///
2661 /// This function clears the current insertion point. The caller should follow
2662 /// calls to this function with calls to Emit*Block prior to generation new
2663 /// code.
2664 void EmitBranch(llvm::BasicBlock *Block);
2665
2666 /// HaveInsertPoint - True if an insertion point is defined. If not, this
2667 /// indicates that the current code being emitted is unreachable.
2668 bool HaveInsertPoint() const {
2669 return Builder.GetInsertBlock() != nullptr;
2670 }
2671
2672 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2673 /// emitted IR has a place to go. Note that by definition, if this function
2674 /// creates a block then that block is unreachable; callers may do better to
2675 /// detect when no insertion point is defined and simply skip IR generation.
2677 if (!HaveInsertPoint())
2679 }
2680
2681 /// ErrorUnsupported - Print out an error that codegen doesn't support the
2682 /// specified stmt yet.
2683 void ErrorUnsupported(const Stmt *S, const char *Type);
2684
2685 //===--------------------------------------------------------------------===//
2686 // Helpers
2687 //===--------------------------------------------------------------------===//
2688
2690 llvm::BasicBlock *LHSBlock,
2691 llvm::BasicBlock *RHSBlock,
2692 llvm::BasicBlock *MergeBlock,
2693 QualType MergedType) {
2694 Builder.SetInsertPoint(MergeBlock);
2695 llvm::PHINode *PtrPhi = Builder.CreatePHI(LHS.getType(), 2, "cond");
2696 PtrPhi->addIncoming(LHS.getBasePointer(), LHSBlock);
2697 PtrPhi->addIncoming(RHS.getBasePointer(), RHSBlock);
2698 LHS.replaceBasePointer(PtrPhi);
2699 LHS.setAlignment(std::min(LHS.getAlignment(), RHS.getAlignment()));
2700 return LHS;
2701 }
2702
2703 /// Construct an address with the natural alignment of T. If a pointer to T
2704 /// is expected to be signed, the pointer passed to this function must have
2705 /// been signed, and the returned Address will have the pointer authentication
2706 /// information needed to authenticate the signed pointer.
2708 llvm::Value *Ptr, QualType T, CharUnits Alignment = CharUnits::Zero(),
2709 bool ForPointeeType = false, LValueBaseInfo *BaseInfo = nullptr,
2710 TBAAAccessInfo *TBAAInfo = nullptr,
2711 KnownNonNull_t IsKnownNonNull = NotKnownNonNull) {
2712 if (Alignment.isZero())
2713 Alignment =
2714 CGM.getNaturalTypeAlignment(T, BaseInfo, TBAAInfo, ForPointeeType);
2715 return Address(Ptr, ConvertTypeForMem(T), Alignment,
2716 CGM.getPointerAuthInfoForPointeeType(T), /*Offset=*/nullptr,
2717 IsKnownNonNull);
2718 }
2719
2722 return MakeAddrLValue(Addr, T, LValueBaseInfo(Source),
2724 }
2725
2727 TBAAAccessInfo TBAAInfo) {
2728 return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2729 }
2730
2731 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2733 return MakeAddrLValue(makeNaturalAddressForPointer(V, T, Alignment), T,
2735 }
2736
2737 /// Same as MakeAddrLValue above except that the pointer is known to be
2738 /// unsigned.
2739 LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2741 Address Addr(V, ConvertTypeForMem(T), Alignment);
2742 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2744 }
2745
2746 LValue
2749 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2750 TBAAAccessInfo());
2751 }
2752
2753 /// Given a value of type T* that may not be to a complete object, construct
2754 /// an l-value with the natural pointee alignment of T.
2756
2757 LValue
2759 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
2760
2761 /// Same as MakeNaturalAlignPointeeAddrLValue except that the pointer is known
2762 /// to be unsigned.
2764
2766
2768 LValueBaseInfo *PointeeBaseInfo = nullptr,
2769 TBAAAccessInfo *PointeeTBAAInfo = nullptr);
2772 AlignmentSource Source =
2774 LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2775 CGM.getTBAAAccessInfo(RefTy));
2776 return EmitLoadOfReferenceLValue(RefLVal);
2777 }
2778
2779 /// Load a pointer with type \p PtrTy stored at address \p Ptr.
2780 /// Note that \p PtrTy is the type of the loaded pointer, not the addresses
2781 /// it is loaded from.
2783 LValueBaseInfo *BaseInfo = nullptr,
2784 TBAAAccessInfo *TBAAInfo = nullptr);
2786
2787private:
2788 struct AllocaTracker {
2789 void Add(llvm::AllocaInst *I) { Allocas.push_back(I); }
2790 llvm::SmallVector<llvm::AllocaInst *> Take() { return std::move(Allocas); }
2791
2792 private:
2794 };
2795 AllocaTracker *Allocas = nullptr;
2796
2797public:
2798 // Captures all the allocas created during the scope of its RAII object.
2801 : CGF(CGF), OldTracker(CGF.Allocas) {
2802 CGF.Allocas = &Tracker;
2803 }
2804 ~AllocaTrackerRAII() { CGF.Allocas = OldTracker; }
2805
2806 llvm::SmallVector<llvm::AllocaInst *> Take() { return Tracker.Take(); }
2807
2808 private:
2809 CodeGenFunction &CGF;
2810 AllocaTracker *OldTracker;
2811 AllocaTracker Tracker;
2812 };
2813
2814 /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2815 /// block if \p ArraySize is nullptr, otherwise inserts it at the current
2816 /// insertion point of the builder. The caller is responsible for setting an
2817 /// appropriate alignment on
2818 /// the alloca.
2819 ///
2820 /// \p ArraySize is the number of array elements to be allocated if it
2821 /// is not nullptr.
2822 ///
2823 /// LangAS::Default is the address space of pointers to local variables and
2824 /// temporaries, as exposed in the source language. In certain
2825 /// configurations, this is not the same as the alloca address space, and a
2826 /// cast is needed to lift the pointer from the alloca AS into
2827 /// LangAS::Default. This can happen when the target uses a restricted
2828 /// address space for the stack but the source language requires
2829 /// LangAS::Default to be a generic address space. The latter condition is
2830 /// common for most programming languages; OpenCL is an exception in that
2831 /// LangAS::Default is the private address space, which naturally maps
2832 /// to the stack.
2833 ///
2834 /// Because the address of a temporary is often exposed to the program in
2835 /// various ways, this function will perform the cast. The original alloca
2836 /// instruction is returned through \p Alloca if it is not nullptr.
2837 ///
2838 /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2839 /// more efficient if the caller knows that the address will not be exposed.
2840 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2841 llvm::Value *ArraySize = nullptr);
2843 const Twine &Name = "tmp",
2844 llvm::Value *ArraySize = nullptr,
2845 RawAddress *Alloca = nullptr);
2847 const Twine &Name = "tmp",
2848 llvm::Value *ArraySize = nullptr);
2849
2850 /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2851 /// default ABI alignment of the given LLVM type.
2852 ///
2853 /// IMPORTANT NOTE: This is *not* generally the right alignment for
2854 /// any given AST type that happens to have been lowered to the
2855 /// given IR type. This should only ever be used for function-local,
2856 /// IR-driven manipulations like saving and restoring a value. Do
2857 /// not hand this address off to arbitrary IRGen routines, and especially
2858 /// do not pass it as an argument to a function that might expect a
2859 /// properly ABI-aligned value.
2861 const Twine &Name = "tmp");
2862
2863 /// CreateIRTemp - Create a temporary IR object of the given type, with
2864 /// appropriate alignment. This routine should only be used when an temporary
2865 /// value needs to be stored into an alloca (for example, to avoid explicit
2866 /// PHI construction), but the type is the IR type, not the type appropriate
2867 /// for storing in memory.
2868 ///
2869 /// That is, this is exactly equivalent to CreateMemTemp, but calling
2870 /// ConvertType instead of ConvertTypeForMem.
2871 RawAddress CreateIRTemp(QualType T, const Twine &Name = "tmp");
2872
2873 /// CreateMemTemp - Create a temporary memory object of the given type, with
2874 /// appropriate alignmen and cast it to the default address space. Returns
2875 /// the original alloca instruction by \p Alloca if it is not nullptr.
2876 RawAddress CreateMemTemp(QualType T, const Twine &Name = "tmp",
2877 RawAddress *Alloca = nullptr);
2879 const Twine &Name = "tmp",
2880 RawAddress *Alloca = nullptr);
2881
2882 /// CreateMemTemp - Create a temporary memory object of the given type, with
2883 /// appropriate alignmen without casting it to the default address space.
2884 RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2886 const Twine &Name = "tmp");
2887
2888 /// CreateAggTemp - Create a temporary memory object for the given
2889 /// aggregate type.
2890 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp",
2891 RawAddress *Alloca = nullptr) {
2892 return AggValueSlot::forAddr(
2893 CreateMemTemp(T, Name, Alloca), T.getQualifiers(),
2896 }
2897
2898 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2899 /// expression and compare the result against zero, returning an Int1Ty value.
2900 llvm::Value *EvaluateExprAsBool(const Expr *E);
2901
2902 /// Retrieve the implicit cast expression of the rhs in a binary operator
2903 /// expression by passing pointers to Value and QualType
2904 /// This is used for implicit bitfield conversion checks, which
2905 /// must compare with the value before potential truncation.
2907 llvm::Value **Previous,
2908 QualType *SrcType);
2909
2910 /// Emit a check that an [implicit] conversion of a bitfield. It is not UB,
2911 /// so we use the value after conversion.
2912 void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType,
2913 llvm::Value *Dst, QualType DstType,
2914 const CGBitFieldInfo &Info,
2916
2917 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
2918 void EmitIgnoredExpr(const Expr *E);
2919
2920 /// EmitAnyExpr - Emit code to compute the specified expression which can have
2921 /// any type. The result is returned as an RValue struct. If this is an
2922 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
2923 /// the result should be returned.
2924 ///
2925 /// \param ignoreResult True if the resulting value isn't used.
2928 bool ignoreResult = false);
2929
2930 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2931 // or the value of the expression, depending on how va_list is defined.
2933
2934 /// Emit a "reference" to a __builtin_ms_va_list; this is
2935 /// always the value of the expression, because a __builtin_ms_va_list is a
2936 /// pointer to a char.
2938
2939 /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2940 /// always be accessible even if no aggregate location is provided.
2942
2943 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2944 /// arbitrary expression into the given memory location.
2945 void EmitAnyExprToMem(const Expr *E, Address Location,
2946 Qualifiers Quals, bool IsInitializer);
2947
2948 void EmitAnyExprToExn(const Expr *E, Address Addr);
2949
2950 /// EmitInitializationToLValue - Emit an initializer to an LValue.
2952 const Expr *E, LValue LV,
2954
2955 /// EmitExprAsInit - Emits the code necessary to initialize a
2956 /// location in memory with the given initializer.
2957 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2958 bool capturedByInit);
2959
2960 /// hasVolatileMember - returns true if aggregate type has a volatile
2961 /// member.
2963 if (const RecordType *RT = T->getAs<RecordType>()) {
2964 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2965 return RD->hasVolatileMember();
2966 }
2967 return false;
2968 }
2969
2970 /// Determine whether a return value slot may overlap some other object.
2972 // FIXME: Assuming no overlap here breaks guaranteed copy elision for base
2973 // class subobjects. These cases may need to be revisited depending on the
2974 // resolution of the relevant core issue.
2976 }
2977
2978 /// Determine whether a field initialization may overlap some other object.
2980
2981 /// Determine whether a base class initialization may overlap some other
2982 /// object.
2984 const CXXRecordDecl *BaseRD,
2985 bool IsVirtual);
2986
2987 /// Emit an aggregate assignment.
2989 bool IsVolatile = hasVolatileMember(EltTy);
2990 EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile);
2991 }
2992
2994 AggValueSlot::Overlap_t MayOverlap) {
2995 EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap);
2996 }
2997
2998 /// EmitAggregateCopy - Emit an aggregate copy.
2999 ///
3000 /// \param isVolatile \c true iff either the source or the destination is
3001 /// volatile.
3002 /// \param MayOverlap Whether the tail padding of the destination might be
3003 /// occupied by some other object. More efficient code can often be
3004 /// generated if not.
3006 AggValueSlot::Overlap_t MayOverlap,
3007 bool isVolatile = false);
3008
3009 /// GetAddrOfLocalVar - Return the address of a local variable.
3011 auto it = LocalDeclMap.find(VD);
3012 assert(it != LocalDeclMap.end() &&
3013 "Invalid argument to GetAddrOfLocalVar(), no decl!");
3014 return it->second;
3015 }
3016
3017 /// Given an opaque value expression, return its LValue mapping if it exists,
3018 /// otherwise create one.
3020
3021 /// Given an opaque value expression, return its RValue mapping if it exists,
3022 /// otherwise create one.
3024
3025 /// Get the index of the current ArrayInitLoopExpr, if any.
3026 llvm::Value *getArrayInitIndex() { return ArrayInitIndex; }
3027
3028 /// getAccessedFieldNo - Given an encoded value and a result number, return
3029 /// the input field number being accessed.
3030 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
3031
3032 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
3033 llvm::BasicBlock *GetIndirectGotoBlock();
3034
3035 /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
3036 static bool IsWrappedCXXThis(const Expr *E);
3037
3038 /// EmitNullInitialization - Generate code to set a value of the given type to
3039 /// null, If the type contains data member pointers, they will be initialized
3040 /// to -1 in accordance with the Itanium C++ ABI.
3042
3043 /// Emits a call to an LLVM variable-argument intrinsic, either
3044 /// \c llvm.va_start or \c llvm.va_end.
3045 /// \param ArgValue A reference to the \c va_list as emitted by either
3046 /// \c EmitVAListRef or \c EmitMSVAListRef.
3047 /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise,
3048 /// calls \c llvm.va_end.
3049 llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart);
3050
3051 /// Generate code to get an argument from the passed in pointer
3052 /// and update it accordingly.
3053 /// \param VE The \c VAArgExpr for which to generate code.
3054 /// \param VAListAddr Receives a reference to the \c va_list as emitted by
3055 /// either \c EmitVAListRef or \c EmitMSVAListRef.
3056 /// \returns A pointer to the argument.
3057 // FIXME: We should be able to get rid of this method and use the va_arg
3058 // instruction in LLVM instead once it works well enough.
3061
3062 /// emitArrayLength - Compute the length of an array, even if it's a
3063 /// VLA, and drill down to the base element type.
3065 QualType &baseType,
3066 Address &addr);
3067
3068 /// EmitVLASize - Capture all the sizes for the VLA expressions in
3069 /// the given variably-modified type and store them in the VLASizeMap.
3070 ///
3071 /// This function can be called with a null (unreachable) insert point.
3073
3075 llvm::Value *NumElts;
3077
3078 VlaSizePair(llvm::Value *NE, QualType T) : NumElts(NE), Type(T) {}
3079 };
3080
3081 /// Return the number of elements for a single dimension
3082 /// for the given array type.
3085
3086 /// Returns an LLVM value that corresponds to the size,
3087 /// in non-variably-sized elements, of a variable length array type,
3088 /// plus that largest non-variably-sized element type. Assumes that
3089 /// the type has already been emitted with EmitVariablyModifiedType.
3092
3093 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
3094 /// generating code for an C++ member function.
3095 llvm::Value *LoadCXXThis() {
3096 assert(CXXThisValue && "no 'this' value for this function");
3097 return CXXThisValue;
3098 }
3100
3101 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
3102 /// virtual bases.
3103 // FIXME: Every place that calls LoadCXXVTT is something
3104 // that needs to be abstracted properly.
3105 llvm::Value *LoadCXXVTT() {
3106 assert(CXXStructorImplicitParamValue && "no VTT value for this function");
3107 return CXXStructorImplicitParamValue;
3108 }
3109
3110 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
3111 /// complete class to the given direct base.
3112 Address
3114 const CXXRecordDecl *Derived,
3115 const CXXRecordDecl *Base,
3116 bool BaseIsVirtual);
3117
3118 static bool ShouldNullCheckClassCastValue(const CastExpr *Cast);
3119
3120 /// GetAddressOfBaseClass - This function will add the necessary delta to the
3121 /// load of 'this' and returns address of the base class.
3123 const CXXRecordDecl *Derived,
3126 bool NullCheckValue, SourceLocation Loc);
3127
3129 const CXXRecordDecl *Derived,
3132 bool NullCheckValue);
3133
3134 /// GetVTTParameter - Return the VTT parameter that should be passed to a
3135 /// base constructor/destructor with virtual bases.
3136 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
3137 /// to ItaniumCXXABI.cpp together with all the references to VTT.
3138 llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
3139 bool Delegating);
3140
3142 CXXCtorType CtorType,
3143 const FunctionArgList &Args,
3145 // It's important not to confuse this and the previous function. Delegating
3146 // constructors are the C++0x feature. The constructor delegate optimization
3147 // is used to reduce duplication in the base and complete consturctors where
3148 // they are substantially the same.
3150 const FunctionArgList &Args);
3151
3152 /// Emit a call to an inheriting constructor (that is, one that invokes a
3153 /// constructor inherited from a base class) by inlining its definition. This
3154 /// is necessary if the ABI does not support forwarding the arguments to the
3155 /// base class constructor (because they're variadic or similar).
3157 CXXCtorType CtorType,
3158 bool ForVirtualBase,
3159 bool Delegating,
3160 CallArgList &Args);
3161
3162 /// Emit a call to a constructor inherited from a base class, passing the
3163 /// current constructor's arguments along unmodified (without even making
3164 /// a copy).
3166 bool ForVirtualBase, Address This,
3167 bool InheritedFromVBase,
3169
3171 bool ForVirtualBase, bool Delegating,
3172 AggValueSlot ThisAVS, const CXXConstructExpr *E);
3173
3175 bool ForVirtualBase, bool Delegating,
3176 Address This, CallArgList &Args,
3178 SourceLocation Loc, bool NewPointerIsChecked,
3179 llvm::CallBase **CallOrInvoke = nullptr);
3180
3181 /// Emit assumption load for all bases. Requires to be called only on
3182 /// most-derived class and not under construction of the object.
3184
3185 /// Emit assumption that vptr load == global vtable.
3186 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
3187
3189 Address This, Address Src,
3190 const CXXConstructExpr *E);
3191
3193 const ArrayType *ArrayTy,
3194 Address ArrayPtr,
3195 const CXXConstructExpr *E,
3196 bool NewPointerIsChecked,
3197 bool ZeroInitialization = false);
3198
3200 llvm::Value *NumElements,
3201 Address ArrayPtr,
3202 const CXXConstructExpr *E,
3203 bool NewPointerIsChecked,
3204 bool ZeroInitialization = false);
3205
3207
3209 bool ForVirtualBase, bool Delegating, Address This,
3210 QualType ThisTy);
3211
3213 llvm::Type *ElementTy, Address NewPtr,
3214 llvm::Value *NumElements,
3215 llvm::Value *AllocSizeWithoutCookie);
3216
3217 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
3218 Address Ptr);
3219
3224
3225 llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr);
3226 void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
3227
3228 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
3230
3231 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
3232 QualType DeleteTy, llvm::Value *NumElements = nullptr,
3233 CharUnits CookieSize = CharUnits());
3234
3236 const CallExpr *TheCallExpr, bool IsDelete);
3237
3238 llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E);
3239 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
3241
3242 /// Situations in which we might emit a check for the suitability of a
3243 /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
3244 /// compiler-rt.
3246 /// Checking the operand of a load. Must be suitably sized and aligned.
3248 /// Checking the destination of a store. Must be suitably sized and aligned.
3250 /// Checking the bound value in a reference binding. Must be suitably sized
3251 /// and aligned, but is not required to refer to an object (until the
3252 /// reference is used), per core issue 453.
3254 /// Checking the object expression in a non-static data member access. Must
3255 /// be an object within its lifetime.
3257 /// Checking the 'this' pointer for a call to a non-static member function.
3258 /// Must be an object within its lifetime.
3260 /// Checking the 'this' pointer for a constructor call.
3262 /// Checking the operand of a static_cast to a derived pointer type. Must be
3263 /// null or an object within its lifetime.
3265 /// Checking the operand of a static_cast to a derived reference type. Must
3266 /// be an object within its lifetime.
3268 /// Checking the operand of a cast to a base object. Must be suitably sized
3269 /// and aligned.
3271 /// Checking the operand of a cast to a virtual base object. Must be an
3272 /// object within its lifetime.
3274 /// Checking the value assigned to a _Nonnull pointer. Must not be null.
3276 /// Checking the operand of a dynamic_cast or a typeid expression. Must be
3277 /// null or an object within its lifetime.
3280
3281 /// Determine whether the pointer type check \p TCK permits null pointers.
3283
3284 /// Determine whether the pointer type check \p TCK requires a vptr check.
3286
3287 /// Whether any type-checking sanitizers are enabled. If \c false,
3288 /// calls to EmitTypeCheck can be skipped.
3290
3292 QualType Type, SanitizerSet SkippedChecks = SanitizerSet(),
3293 llvm::Value *ArraySize = nullptr) {
3295 return;
3296 EmitTypeCheck(TCK, Loc, LV.emitRawPointer(*this), Type, LV.getAlignment(),
3297 SkippedChecks, ArraySize);
3298 }
3299
3301 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3302 SanitizerSet SkippedChecks = SanitizerSet(),
3303 llvm::Value *ArraySize = nullptr) {
3305 return;
3306 EmitTypeCheck(TCK, Loc, Addr.emitRawPointer(*this), Type, Alignment,
3307 SkippedChecks, ArraySize);
3308 }
3309
3310 /// Emit a check that \p V is the address of storage of the
3311 /// appropriate size and alignment for an object of type \p Type
3312 /// (or if ArraySize is provided, for an array of that bound).
3314 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3315 SanitizerSet SkippedChecks = SanitizerSet(),
3316 llvm::Value *ArraySize = nullptr);
3317
3318 /// Emit a check that \p Base points into an array object, which
3319 /// we can access at index \p Index. \p Accessed should be \c false if we
3320 /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
3321 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
3322 QualType IndexType, bool Accessed);
3323 void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound,
3324 llvm::Value *Index, QualType IndexType,
3325 QualType IndexedType, bool Accessed);
3326
3327 llvm::Value *GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD,
3328 const FieldDecl *CountDecl);
3329
3330 /// Build an expression accessing the "counted_by" field.
3331 llvm::Value *EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD,
3332 const FieldDecl *CountDecl);
3333
3335 bool isInc, bool isPre);
3337 bool isInc, bool isPre);
3338
3339 /// Converts Location to a DebugLoc, if debug information is enabled.
3340 llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location);
3341
3342 /// Get the record field index as represented in debug info.
3343 unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex);
3344
3345
3346 //===--------------------------------------------------------------------===//
3347 // Declaration Emission
3348 //===--------------------------------------------------------------------===//
3349
3350 /// EmitDecl - Emit a declaration.
3351 ///
3352 /// This function can be called with a null (unreachable) insert point.
3353 void EmitDecl(const Decl &D);
3354
3355 /// EmitVarDecl - Emit a local variable declaration.
3356 ///
3357 /// This function can be called with a null (unreachable) insert point.
3358 void EmitVarDecl(const VarDecl &D);
3359
3360 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
3361 bool capturedByInit);
3362
3364 llvm::Value *Address);
3365
3366 /// Determine whether the given initializer is trivial in the sense
3367 /// that it requires no code to be generated.
3369
3370 /// EmitAutoVarDecl - Emit an auto variable declaration.
3371 ///
3372 /// This function can be called with a null (unreachable) insert point.
3374
3376 friend class CodeGenFunction;
3377
3378 const VarDecl *Variable;
3379
3380 /// The address of the alloca for languages with explicit address space
3381 /// (e.g. OpenCL) or alloca casted to generic pointer for address space
3382 /// agnostic languages (e.g. C++). Invalid if the variable was emitted
3383 /// as a global constant.
3384 Address Addr;
3385
3386 llvm::Value *NRVOFlag;
3387
3388 /// True if the variable is a __block variable that is captured by an
3389 /// escaping block.
3390 bool IsEscapingByRef;
3391
3392 /// True if the variable is of aggregate type and has a constant
3393 /// initializer.
3394 bool IsConstantAggregate;
3395
3396 /// Non-null if we should use lifetime annotations.
3397 llvm::Value *SizeForLifetimeMarkers;
3398
3399 /// Address with original alloca instruction. Invalid if the variable was
3400 /// emitted as a global constant.
3401 RawAddress AllocaAddr;
3402
3403 struct Invalid {};
3404 AutoVarEmission(Invalid)
3405 : Variable(nullptr), Addr(Address::invalid()),
3406 AllocaAddr(RawAddress::invalid()) {}
3407
3408 AutoVarEmission(const VarDecl &variable)
3409 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
3410 IsEscapingByRef(false), IsConstantAggregate(false),
3411 SizeForLifetimeMarkers(nullptr), AllocaAddr(RawAddress::invalid()) {}
3412
3413 bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
3414
3415 public:
3416 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
3417
3418 bool useLifetimeMarkers() const {
3419 return SizeForLifetimeMarkers != nullptr;
3420 }
3421 llvm::Value *getSizeForLifetimeMarkers() const {
3422 assert(useLifetimeMarkers());
3423 return SizeForLifetimeMarkers;
3424 }
3425
3426 /// Returns the raw, allocated address, which is not necessarily
3427 /// the address of the object itself. It is casted to default
3428 /// address space for address space agnostic languages.
3430 return Addr;
3431 }
3432
3433 /// Returns the address for the original alloca instruction.
3434 RawAddress getOriginalAllocatedAddress() const { return AllocaAddr; }
3435
3436 /// Returns the address of the object within this declaration.
3437 /// Note that this does not chase the forwarding pointer for
3438 /// __block decls.
3440 if (!IsEscapingByRef) return Addr;
3441
3442 return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false);
3443 }
3444 };
3446 void EmitAutoVarInit(const AutoVarEmission &emission);
3449 QualType::DestructionKind dtorKind);
3450
3451 /// Emits the alloca and debug information for the size expressions for each
3452 /// dimension of an array. It registers the association of its (1-dimensional)
3453 /// QualTypes and size expression's debug node, so that CGDebugInfo can
3454 /// reference this node when creating the DISubrange object to describe the
3455 /// array types.
3457 const VarDecl &D,
3458 bool EmitDebugInfo);
3459
3461 llvm::GlobalValue::LinkageTypes Linkage);
3462
3464 union {
3466 llvm::Value *Value;
3467 };
3468
3469 bool IsIndirect;
3470
3471 ParamValue(llvm::Value *V) : Value(V), IsIndirect(false) {}
3472 ParamValue(Address A) : Addr(A), IsIndirect(true) {}
3473
3474 public:
3475 static ParamValue forDirect(llvm::Value *value) {
3476 return ParamValue(value);
3477 }
3479 assert(!addr.getAlignment().isZero());
3480 return ParamValue(addr);
3481 }
3482
3483 bool isIndirect() const { return IsIndirect; }
3484 llvm::Value *getAnyValue() const {
3485 if (!isIndirect())
3486 return Value;
3487 assert(!Addr.hasOffset() && "unexpected offset");
3488 return Addr.getBasePointer();
3489 }
3490
3491 llvm::Value *getDirectValue() const {
3492 assert(!isIndirect());
3493 return Value;
3494 }
3495
3497 assert(isIndirect());
3498 return Addr;
3499 }
3500 };
3501
3502 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3503 void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo);
3504
3505 /// protectFromPeepholes - Protect a value that we're intending to
3506 /// store to the side, but which will probably be used later, from
3507 /// aggressive peepholing optimizations that might delete it.
3508 ///
3509 /// Pass the result to unprotectFromPeepholes to declare that
3510 /// protection is no longer required.
3511 ///
3512 /// There's no particular reason why this shouldn't apply to
3513 /// l-values, it's just that no existing peepholes work on pointers.
3516
3517 void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty,
3519 SourceLocation AssumptionLoc,
3520 llvm::Value *Alignment,
3521 llvm::Value *OffsetValue,
3522 llvm::Value *TheCheck,
3523 llvm::Instruction *Assumption);
3524
3525 void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
3526 SourceLocation Loc, SourceLocation AssumptionLoc,
3527 llvm::Value *Alignment,
3528 llvm::Value *OffsetValue = nullptr);
3529
3530 void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3531 SourceLocation AssumptionLoc,
3532 llvm::Value *Alignment,
3533 llvm::Value *OffsetValue = nullptr);
3534
3535 //===--------------------------------------------------------------------===//
3536 // Statement Emission
3537 //===--------------------------------------------------------------------===//
3538
3539 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3540 void EmitStopPoint(const Stmt *S);
3541
3542 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3543 /// this function even if there is no current insertion point.
3544 ///
3545 /// This function may clear the current insertion point; callers should use
3546 /// EnsureInsertPoint if they wish to subsequently generate code without first
3547 /// calling EmitBlock, EmitBranch, or EmitStmt.
3548 void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = {});
3549
3550 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3551 /// necessarily require an insertion point or debug information; typically
3552 /// because the statement amounts to a jump or a container of other
3553 /// statements.
3554 ///
3555 /// \return True if the statement was handled.
3557
3558 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
3561 bool GetLast = false,
3562 AggValueSlot AVS =
3564
3565 /// EmitLabel - Emit the block for the given label. It is legal to call this
3566 /// function even if there is no current insertion point.
3567 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
3568
3569 void EmitLabelStmt(const LabelStmt &S);
3571 void EmitGotoStmt(const GotoStmt &S);
3573 void EmitIfStmt(const IfStmt &S);
3574
3576 void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = {});
3577 void EmitForStmt(const ForStmt &S, ArrayRef<const Attr *> Attrs = {});
3579 void EmitDeclStmt(const DeclStmt &S);
3580 void EmitBreakStmt(const BreakStmt &S);
3586 void EmitAsmStmt(const AsmStmt &S);
3587
3593
3598 bool ignoreResult = false);
3602 bool ignoreResult = false);
3604 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3605
3606 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3607 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3608
3614 void VolatilizeTryBlocks(llvm::BasicBlock *BB,
3616
3618 llvm::Function *FinallyFunc);
3620 const Stmt *OutlinedStmt);
3621
3623 const SEHExceptStmt &Except);
3624
3626 const SEHFinallyStmt &Finally);
3627
3629 llvm::Value *ParentFP,
3630 llvm::Value *EntryEBP);
3631 llvm::Value *EmitSEHExceptionCode();
3632 llvm::Value *EmitSEHExceptionInfo();
3634
3635 /// Emit simple code for OpenMP directives in Simd-only mode.
3637
3638 /// Scan the outlined statement for captures from the parent function. For
3639 /// each capture, mark the capture as escaped and emit a call to
3640 /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap.
3642 bool IsFilter);
3643
3644 /// Recovers the address of a local in a parent function. ParentVar is the
3645 /// address of the variable used in the immediate parent function. It can
3646 /// either be an alloca or a call to llvm.localrecover if there are nested
3647 /// outlined functions. ParentFP is the frame pointer of the outermost parent
3648 /// frame.
3650 Address ParentVar,
3651 llvm::Value *ParentFP);
3652
3654 ArrayRef<const Attr *> Attrs = {});
3655
3656 /// Controls insertion of cancellation exit blocks in worksharing constructs.
3658 CodeGenFunction &CGF;
3659
3660 public:
3662 bool HasCancel)
3663 : CGF(CGF) {
3664 CGF.OMPCancelStack.enter(CGF, Kind, HasCancel);
3665 }
3666 ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); }
3667 };
3668
3669 /// Returns calculated size of the specified type.
3670 llvm::Value *getTypeSize(QualType Ty);
3678 SmallVectorImpl<llvm::Value *> &CapturedVars);
3679 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3681 /// Perform element by element copying of arrays with type \a
3682 /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
3683 /// generated by \a CopyGen.
3684 ///
3685 /// \param DestAddr Address of the destination array.
3686 /// \param SrcAddr Address of the source array.
3687 /// \param OriginalType Type of destination and source arrays.
3688 /// \param CopyGen Copying procedure that copies value of single array element
3689 /// to another single array element.
3691 Address DestAddr, Address SrcAddr, QualType OriginalType,
3692 const llvm::function_ref<void(Address, Address)> CopyGen);
3693 /// Emit proper copying of data from one variable to another.
3694 ///
3695 /// \param OriginalType Original type of the copied variables.
3696 /// \param DestAddr Destination address.
3697 /// \param SrcAddr Source address.
3698 /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3699 /// type of the base array element).
3700 /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3701 /// the base array element).
3702 /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
3703 /// DestVD.
3704 void EmitOMPCopy(QualType OriginalType,
3705 Address DestAddr, Address SrcAddr,
3706 const VarDecl *DestVD, const VarDecl *SrcVD,
3707 const Expr *Copy);
3708 /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or
3709 /// \a X = \a E \a BO \a E.
3710 ///
3711 /// \param X Value to be updated.
3712 /// \param E Update value.
3713 /// \param BO Binary operation for update operation.
3714 /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3715 /// expression, false otherwise.
3716 /// \param AO Atomic ordering of the generated atomic instructions.
3717 /// \param CommonGen Code generator for complex expressions that cannot be
3718 /// expressed through atomicrmw instruction.
3719 /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was
3720 /// generated, <false, RValue::get(nullptr)> otherwise.
3721 std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3722 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3723 llvm::AtomicOrdering AO, SourceLocation Loc,
3724 const llvm::function_ref<RValue(RValue)> CommonGen);
3726 OMPPrivateScope &PrivateScope);
3728 OMPPrivateScope &PrivateScope);
3730 const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope,
3731 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3732 CaptureDeviceAddrMap);
3734 const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope,
3735 const llvm::DenseMap<const ValueDecl *, llvm::Value *>
3736 CaptureDeviceAddrMap);
3737 /// Emit code for copyin clause in \a D directive. The next code is
3738 /// generated at the start of outlined functions for directives:
3739 /// \code
3740 /// threadprivate_var1 = master_threadprivate_var1;
3741 /// operator=(threadprivate_var2, master_threadprivate_var2);
3742 /// ...
3743 /// __kmpc_barrier(&loc, global_tid);
3744 /// \endcode
3745 ///
3746 /// \param D OpenMP directive possibly with 'copyin' clause(s).
3747 /// \returns true if at least one copyin variable is found, false otherwise.
3749 /// Emit initial code for lastprivate variables. If some variable is
3750 /// not also firstprivate, then the default initialization is used. Otherwise
3751 /// initialization of this variable is performed by EmitOMPFirstprivateClause
3752 /// method.
3753 ///
3754 /// \param D Directive that may have 'lastprivate' directives.
3755 /// \param PrivateScope Private scope for capturing lastprivate variables for
3756 /// proper codegen in internal captured statement.
3757 ///
3758 /// \returns true if there is at least one lastprivate variable, false
3759 /// otherwise.
3761 OMPPrivateScope &PrivateScope);
3762 /// Emit final copying of lastprivate values to original variables at
3763 /// the end of the worksharing or simd directive.
3764 ///
3765 /// \param D Directive that has at least one 'lastprivate' directives.
3766 /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
3767 /// it is the last iteration of the loop code in associated directive, or to
3768 /// 'i1 false' otherwise. If this item is nullptr, no final check is required.
3770 bool NoFinals,
3771 llvm::Value *IsLastIterCond = nullptr);
3772 /// Emit initial code for linear clauses.
3774 CodeGenFunction::OMPPrivateScope &PrivateScope);
3775 /// Emit final code for linear clauses.
3776 /// \param CondGen Optional conditional code for final part of codegen for
3777 /// linear clause.
3779 const OMPLoopDirective &D,
3780 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3781 /// Emit initial code for reduction variables. Creates reduction copies
3782 /// and initializes them with the values according to OpenMP standard.
3783 ///
3784 /// \param D Directive (possibly) with the 'reduction' clause.
3785 /// \param PrivateScope Private scope for capturing reduction variables for
3786 /// proper codegen in internal captured statement.
3787 ///
3789 OMPPrivateScope &PrivateScope,
3790 bool ForInscan = false);
3791 /// Emit final update of reduction values to original variables at
3792 /// the end of the directive.
3793 ///
3794 /// \param D Directive that has at least one 'reduction' directives.
3795 /// \param ReductionKind The kind of reduction to perform.
3797 const OpenMPDirectiveKind ReductionKind);
3798 /// Emit initial code for linear variables. Creates private copies
3799 /// and initializes them with the values according to OpenMP standard.
3800 ///
3801 /// \param D Directive (possibly) with the 'linear' clause.
3802 /// \return true if at least one linear variable is found that should be
3803 /// initialized with the value of the original variable, false otherwise.
3805
3806 typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/,
3807 llvm::Function * /*OutlinedFn*/,
3808 const OMPTaskDataTy & /*Data*/)>
3811 const OpenMPDirectiveKind CapturedRegion,
3812 const RegionCodeGenTy &BodyGen,
3813 const TaskGenTy &TaskGen, OMPTaskDataTy &Data);
3820 explicit OMPTargetDataInfo() = default;
3823 unsigned NumberOfTargetItems)
3827 };
3829 const RegionCodeGenTy &BodyGen,
3830 OMPTargetDataInfo &InputInfo);
3833 CodeGenFunction &CGF,
3834 const CapturedStmt *CS,
3873 void
3876 void
3884 void
3886 void
3906 void
3931
3932 /// Emit device code for the target directive.
3934 StringRef ParentName,
3935 const OMPTargetDirective &S);
3936 static void
3939 /// Emit device code for the target parallel for directive.
3941 CodeGenModule &CGM, StringRef ParentName,
3943 /// Emit device code for the target parallel for simd directive.
3945 CodeGenModule &CGM, StringRef ParentName,
3947 /// Emit device code for the target teams directive.
3948 static void
3950 const OMPTargetTeamsDirective &S);
3951 /// Emit device code for the target teams distribute directive.
3953 CodeGenModule &CGM, StringRef ParentName,
3955 /// Emit device code for the target teams distribute simd directive.
3957 CodeGenModule &CGM, StringRef ParentName,
3959 /// Emit device code for the target simd directive.
3961 StringRef ParentName,
3962 const OMPTargetSimdDirective &S);
3963 /// Emit device code for the target teams distribute parallel for simd
3964 /// directive.
3966 CodeGenModule &CGM, StringRef ParentName,
3968
3969 /// Emit device code for the target teams loop directive.
3971 CodeGenModule &CGM, StringRef ParentName,
3973
3974 /// Emit device code for the target parallel loop directive.
3976 CodeGenModule &CGM, StringRef ParentName,
3978
3980 CodeGenModule &CGM, StringRef ParentName,
3982
3983 /// Emit the Stmt \p S and return its topmost canonical loop, if any.
3984 /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
3985 /// future it is meant to be the number of loops expected in the loop nests
3986 /// (usually specified by the "collapse" clause) that are collapsed to a
3987 /// single loop by this function.
3988 llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S,
3989 int Depth);
3990
3991 /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
3993
3994 /// Emit inner loop of the worksharing/simd construct.
3995 ///
3996 /// \param S Directive, for which the inner loop must be emitted.
3997 /// \param RequiresCleanup true, if directive has some associated private
3998 /// variables.
3999 /// \param LoopCond Bollean condition for loop continuation.
4000 /// \param IncExpr Increment expression for loop control variable.
4001 /// \param BodyGen Generator for the inner body of the inner loop.
4002 /// \param PostIncGen Genrator for post-increment code (required for ordered
4003 /// loop directvies).
4005 const OMPExecutableDirective &S, bool RequiresCleanup,
4006 const Expr *LoopCond, const Expr *IncExpr,
4007 const llvm::function_ref<void(CodeGenFunction &)> BodyGen,
4008 const llvm::function_ref<void(CodeGenFunction &)> PostIncGen);
4009
4011 /// Emit initial code for loop counters of loop-based directives.
4013 OMPPrivateScope &LoopScope);
4014
4015 /// Helper for the OpenMP loop directives.
4017
4018 /// Emit code for the worksharing loop-based directive.
4019 /// \return true, if this construct has any lastprivate clause, false -
4020 /// otherwise.
4022 const CodeGenLoopBoundsTy &CodeGenLoopBounds,
4023 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4024
4025 /// Emit code for the distribute loop-based directive.
4027 const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
4028
4029 /// Helpers for the OpenMP loop directives.
4032 const OMPLoopDirective &D,
4033 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
4034
4035 /// Emits the lvalue for the expression with possibly captured variable.
4037
4038private:
4039 /// Helpers for blocks.
4040 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info);
4041
4042 /// struct with the values to be passed to the OpenMP loop-related functions
4043 struct OMPLoopArguments {
4044 /// loop lower bound
4046 /// loop upper bound
4048 /// loop stride
4050 /// isLastIteration argument for runtime functions
4052 /// Chunk value generated by sema
4053 llvm::Value *Chunk = nullptr;
4054 /// EnsureUpperBound
4055 Expr *EUB = nullptr;
4056 /// IncrementExpression
4057 Expr *IncExpr = nullptr;
4058 /// Loop initialization
4059 Expr *Init = nullptr;
4060 /// Loop exit condition
4061 Expr *Cond = nullptr;
4062 /// Update of LB after a whole chunk has been executed
4063 Expr *NextLB = nullptr;
4064 /// Update of UB after a whole chunk has been executed
4065 Expr *NextUB = nullptr;
4066 /// Distinguish between the for distribute and sections
4067 OpenMPDirectiveKind DKind = llvm::omp::OMPD_unknown;
4068 OMPLoopArguments() = default;
4069 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
4070 llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
4071 Expr *IncExpr = nullptr, Expr *Init = nullptr,
4072 Expr *Cond = nullptr, Expr *NextLB = nullptr,
4073 Expr *NextUB = nullptr)
4074 : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB),
4075 IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB),
4076 NextUB(NextUB) {}
4077 };
4078 void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic,
4079 const OMPLoopDirective &S, OMPPrivateScope &LoopScope,
4080 const OMPLoopArguments &LoopArgs,
4081 const CodeGenLoopTy &CodeGenLoop,
4082 const CodeGenOrderedTy &CodeGenOrdered);
4083 void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind,
4084 bool IsMonotonic, const OMPLoopDirective &S,
4085 OMPPrivateScope &LoopScope, bool Ordered,
4086 const OMPLoopArguments &LoopArgs,
4087 const CodeGenDispatchBoundsTy &CGDispatchBounds);
4088 void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind,
4089 const OMPLoopDirective &S,
4090 OMPPrivateScope &LoopScope,
4091 const OMPLoopArguments &LoopArgs,
4092 const CodeGenLoopTy &CodeGenLoopContent);
4093 /// Emit code for sections directive.
4094 void EmitSections(const OMPExecutableDirective &S);
4095
4096public:
4097 //===--------------------------------------------------------------------===//
4098 // OpenACC Emission
4099 //===--------------------------------------------------------------------===//
4101 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4102 // simply emitting its structured block, but in the future we will implement
4103 // some sort of IR.
4104 EmitStmt(S.getStructuredBlock());
4105 }
4106
4108 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4109 // simply emitting its loop, but in the future we will implement
4110 // some sort of IR.
4111 EmitStmt(S.getLoop());
4112 }
4113
4115 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4116 // simply emitting its loop, but in the future we will implement
4117 // some sort of IR.
4118 EmitStmt(S.getLoop());
4119 }
4120
4122 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4123 // simply emitting its structured block, but in the future we will implement
4124 // some sort of IR.
4125 EmitStmt(S.getStructuredBlock());
4126 }
4127
4129 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4130 // but in the future we will implement some sort of IR.
4131 }
4132
4134 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4135 // but in the future we will implement some sort of IR.
4136 }
4137
4139 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4140 // simply emitting its structured block, but in the future we will implement
4141 // some sort of IR.
4142 EmitStmt(S.getStructuredBlock());
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
4156 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4157 // but in the future we will implement some sort of IR.
4158 }
4159
4161 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4162 // but in the future we will implement some sort of IR.
4163 }
4164
4166 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4167 // but in the future we will implement some sort of IR.
4168 }
4169
4171 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4172 // simply emitting its associated stmt, but in the future we will implement
4173 // some sort of IR.
4174 EmitStmt(S.getAssociatedStmt());
4175 }
4176
4177 //===--------------------------------------------------------------------===//
4178 // LValue Expression Emission
4179 //===--------------------------------------------------------------------===//
4180
4181 /// Create a check that a scalar RValue is non-null.
4183
4184 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
4186
4187 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
4188 /// and issue an ErrorUnsupported style diagnostic (using the
4189 /// provided Name).
4191 const char *Name);
4192
4193 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
4194 /// an ErrorUnsupported style diagnostic (using the provided Name).
4196 const char *Name);
4197
4198 /// EmitLValue - Emit code to compute a designator that specifies the location
4199 /// of the expression.
4200 ///
4201 /// This can return one of two things: a simple address or a bitfield
4202 /// reference. In either case, the LLVM Value* in the LValue structure is
4203 /// guaranteed to be an LLVM pointer type.
4204 ///
4205 /// If this returns a bitfield reference, nothing about the pointee type of
4206 /// the LLVM value is known: For example, it may not be a pointer to an
4207 /// integer.
4208 ///
4209 /// If this returns a normal address, and if the lvalue's C type is fixed
4210 /// size, this method guarantees that the returned pointer type will point to
4211 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
4212 /// variable length type, this is not possible.
4213 ///
4215 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
4216
4217private:
4218 LValue EmitLValueHelper(const Expr *E, KnownNonNull_t IsKnownNonNull);
4219
4220public:
4221 /// Same as EmitLValue but additionally we generate checking code to
4222 /// guard against undefined behavior. This is only suitable when we know
4223 /// that the address will be used to access the object.
4225
4228
4229 void EmitAtomicInit(Expr *E, LValue lvalue);
4230
4232
4235
4237 llvm::AtomicOrdering AO, bool IsVolatile = false,
4239
4240 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
4241
4242 void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
4243 bool IsVolatile, bool isInit);
4244
4245 std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
4247 llvm::AtomicOrdering Success =
4248 llvm::AtomicOrdering::SequentiallyConsistent,
4249 llvm::AtomicOrdering Failure =
4250 llvm::AtomicOrdering::SequentiallyConsistent,
4251 bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored());
4252
4253 /// Emit an atomicrmw instruction, and applying relevant metadata when
4254 /// applicable.
4255 llvm::AtomicRMWInst *emitAtomicRMWInst(
4256 llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val,
4257 llvm::AtomicOrdering Order = llvm::AtomicOrdering::SequentiallyConsistent,
4258 llvm::SyncScope::ID SSID = llvm::SyncScope::System,
4259 const AtomicExpr *AE = nullptr);
4260
4261 void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
4262 const llvm::function_ref<RValue(RValue)> &UpdateOp,
4263 bool IsVolatile);
4264
4265 /// EmitToMemory - Change a scalar value from its value
4266 /// representation to its in-memory representation.
4267 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
4268
4269 /// EmitFromMemory - Change a scalar value from its memory
4270 /// representation to its value representation.
4271 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
4272
4273 /// Check if the scalar \p Value is within the valid range for the given
4274 /// type \p Ty.
4275 ///
4276 /// Returns true if a check is needed (even if the range is unknown).
4277 bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty,
4279
4280 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4281 /// care to appropriately convert from the memory representation to
4282 /// the LLVM value representation.
4283 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4286 bool isNontemporal = false) {
4287 return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source),
4288 CGM.getTBAAAccessInfo(Ty), isNontemporal);
4289 }
4290
4291 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
4293 TBAAAccessInfo TBAAInfo,
4294 bool isNontemporal = false);
4295
4296 /// EmitLoadOfScalar - Load a scalar value from 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.
4301
4302 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4303 /// care to appropriately convert from the memory representation to
4304 /// the LLVM value representation.
4305 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
4306 bool Volatile, QualType Ty,
4308 bool isInit = false, bool isNontemporal = false) {
4309 EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source),
4310 CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal);
4311 }
4312
4313 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
4314 bool Volatile, QualType Ty,
4315 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo,
4316 bool isInit = false, bool isNontemporal = false);
4317
4318 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4319 /// care to appropriately convert from the memory representation to
4320 /// the LLVM value representation. The l-value must be a simple
4321 /// l-value. The isInit flag indicates whether this is an initialization.
4322 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
4323 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
4324
4325 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
4326 /// this method emits the address of the lvalue, then loads the result as an
4327 /// rvalue, returning the rvalue.
4332
4333 /// Like EmitLoadOfLValue but also handles complex and aggregate types.
4336 SourceLocation Loc = {});
4337
4338 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
4339 /// lvalue, where both are guaranteed to the have the same type, and that type
4340 /// is 'Ty'.
4341 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
4344
4345 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
4346 /// as EmitStoreThroughLValue.
4347 ///
4348 /// \param Result [out] - If non-null, this will be set to a Value* for the
4349 /// bit-field contents after the store, appropriate for use as the result of
4350 /// an assignment to the bit-field.
4352 llvm::Value **Result=nullptr);
4353
4354 /// Emit an l-value for an assignment (simple or compound) of complex type.
4358 llvm::Value *&Result);
4359
4360 // Note: only available for agg return types
4363 // Note: only available for agg return types
4365 llvm::CallBase **CallOrInvoke = nullptr);
4366 // Note: only available for agg return types
4374 bool Accessed = false);
4375 llvm::Value *EmitMatrixIndexExpr(const Expr *E);
4378 bool IsLowerBound = true);
4390
4391 std::pair<LValue, LValue> EmitHLSLOutArgLValues(const HLSLOutArgExpr *E,
4392 QualType Ty);
4394 QualType Ty);
4395
4397
4399
4401 LValueBaseInfo *BaseInfo = nullptr,
4402 TBAAAccessInfo *TBAAInfo = nullptr);
4403
4405 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
4406 ConstantEmission(llvm::Constant *C, bool isReference)
4407 : ValueAndIsReference(C, isReference) {}
4408 public:
4410 static ConstantEmission forReference(llvm::Constant *C) {
4411 return ConstantEmission(C, true);
4412 }
4413 static ConstantEmission forValue(llvm::Constant *C) {
4414 return ConstantEmission(C, false);
4415 }
4416
4417 explicit operator bool() const {
4418 return ValueAndIsReference.getOpaqueValue() != nullptr;
4419 }
4420
4421 bool isReference() const { return ValueAndIsReference.getInt(); }
4423 assert(isReference());
4424 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
4425 refExpr->getType());
4426 }
4427
4428 llvm::Constant *getValue() const {
4429 assert(!isReference());
4430 return ValueAndIsReference.getPointer();
4431 }
4432 };
4433
4436 llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
4437
4441
4443 const ObjCIvarDecl *Ivar);
4445 const ObjCIvarDecl *Ivar);
4449 llvm::Value *ThisValue);
4450
4451 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
4452 /// if the Field is a reference, this will return the address of the reference
4453 /// and not the address of the value stored in the reference.
4455 const FieldDecl* Field);
4456
4458 llvm::Value* Base, const ObjCIvarDecl *Ivar,
4459 unsigned CVRQualifiers);
4460
4465
4472
4473 //===--------------------------------------------------------------------===//
4474 // Scalar Expression Emission
4475 //===--------------------------------------------------------------------===//
4476
4477 /// EmitCall - Generate a call of the given function, expecting the given
4478 /// result type, and using the given argument list which specifies both the
4479 /// LLVM arguments and the types they were derived from.
4480 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4482 llvm::CallBase **CallOrInvoke, bool IsMustTail,
4484 bool IsVirtualFunctionPointerThunk = false);
4485 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4487 llvm::CallBase **CallOrInvoke = nullptr,
4488 bool IsMustTail = false) {
4489 return EmitCall(CallInfo, Callee, ReturnValue, Args, CallOrInvoke,
4490 IsMustTail, SourceLocation());
4491 }
4492 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
4493 ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr,
4494 llvm::CallBase **CallOrInvoke = nullptr,
4495 CGFunctionInfo const **ResolvedFnInfo = nullptr);
4496
4497 // If a Call or Invoke instruction was emitted for this CallExpr, this method
4498 // writes the pointer to `CallOrInvoke` if it's not null.
4501 llvm::CallBase **CallOrInvoke = nullptr);
4503 llvm::CallBase **CallOrInvoke = nullptr);
4505
4506 void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
4508
4509 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4510 const Twine &name = "");
4511 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4513 const Twine &name = "");
4514 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4515 const Twine &name = "");
4516 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4517 ArrayRef<Address> args,
4518 const Twine &name = "");
4519 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4521 const Twine &name = "");
4522
4524 getBundlesForFunclet(llvm::Value *Callee);
4525
4526 llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee,
4528 const Twine &Name = "");
4529 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4531 const Twine &name = "");
4532 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4533 const Twine &name = "");
4534 void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4536
4538 NestedNameSpecifier *Qual,
4539 llvm::Type *Ty);
4540
4543 const CXXRecordDecl *RD);
4544
4546
4547 /// Create the discriminator from the storage address and the entity hash.
4548 llvm::Value *EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
4549 llvm::Value *Discriminator);
4551 llvm::Value *StorageAddress,
4552 GlobalDecl SchemaDecl,
4553 QualType SchemaType);
4554
4555 llvm::Value *EmitPointerAuthSign(const CGPointerAuthInfo &Info,
4556 llvm::Value *Pointer);
4557
4558 llvm::Value *EmitPointerAuthAuth(const CGPointerAuthInfo &Info,
4559 llvm::Value *Pointer);
4560
4562 const CGPointerAuthInfo &CurAuthInfo,
4563 const CGPointerAuthInfo &NewAuthInfo,
4564 bool IsKnownNonNull);
4565 llvm::Value *emitPointerAuthResignCall(llvm::Value *Pointer,
4566 const CGPointerAuthInfo &CurInfo,
4567 const CGPointerAuthInfo &NewInfo);
4568
4570 const CGPointerAuthInfo &Info,
4572
4573 llvm::Value *authPointerToPointerCast(llvm::Value *ResultPtr,
4574 QualType SourceType, QualType DestType);
4576 QualType DestType);
4577
4579
4580 llvm::Value *getAsNaturalPointerTo(Address Addr, QualType PointeeType) {
4581 return getAsNaturalAddressOf(Addr, PointeeType).getBasePointer();
4582 }
4583
4584 // Return the copy constructor name with the prefix "__copy_constructor_"
4585 // removed.
4587 CharUnits Alignment,
4588 bool IsVolatile,
4589 ASTContext &Ctx);
4590
4591 // Return the destructor name with the prefix "__destructor_" removed.
4593 CharUnits Alignment,
4594 bool IsVolatile,
4595 ASTContext &Ctx);
4596
4597 // These functions emit calls to the special functions of non-trivial C
4598 // structs.
4606
4608 const CXXMethodDecl *Method, const CGCallee &Callee,
4609 ReturnValueSlot ReturnValue, llvm::Value *This,
4610 llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E,
4611 CallArgList *RtlArgs, llvm::CallBase **CallOrInvoke);
4613 llvm::Value *This, QualType ThisTy,
4614 llvm::Value *ImplicitParam,
4615 QualType ImplicitParamTy, const CallExpr *E,
4616 llvm::CallBase **CallOrInvoke = nullptr);
4619 llvm::CallBase **CallOrInvoke = nullptr);
4621 const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
4622 bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
4623 const Expr *Base, llvm::CallBase **CallOrInvoke);
4624 // Compute the object pointer.
4626 llvm::Value *memberPtr,
4627 const MemberPointerType *memberPtrType,
4628 LValueBaseInfo *BaseInfo = nullptr,
4629 TBAAAccessInfo *TBAAInfo = nullptr);
4632 llvm::CallBase **CallOrInvoke);
4633
4635 const CXXMethodDecl *MD,
4637 llvm::CallBase **CallOrInvoke);
4639
4642 llvm::CallBase **CallOrInvoke);
4643
4646
4647 RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
4649
4650 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
4651
4652 /// Emit IR for __builtin_os_log_format.
4654
4655 /// Emit IR for __builtin_is_aligned.
4657 /// Emit IR for __builtin_align_up/__builtin_align_down.
4658 RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp);
4659
4662 CharUnits BufferAlignment);
4663
4665 llvm::CallBase **CallOrInvoke);
4666
4667 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4668 /// is unhandled by the current target.
4669 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4671
4672 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty,
4673 const llvm::CmpInst::Predicate Fp,
4674 const llvm::CmpInst::Predicate Ip,
4675 const llvm::Twine &Name = "");
4676 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4678 llvm::Triple::ArchType Arch);
4679 llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4681 llvm::Triple::ArchType Arch);
4682 llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4684 llvm::Triple::ArchType Arch);
4685 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy,
4686 QualType RTy);
4687 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy,
4688 QualType RTy);
4689
4690 llvm::Value *EmitCommonNeonBuiltinExpr(unsigned BuiltinID,
4691 unsigned LLVMIntrinsic,
4692 unsigned AltLLVMIntrinsic,
4693 const char *NameHint,
4694 unsigned Modifier,
4695 const CallExpr *E,
4697 Address PtrOp0, Address PtrOp1,
4698 llvm::Triple::ArchType Arch);
4699
4700 llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
4701 unsigned Modifier, llvm::Type *ArgTy,
4702 const CallExpr *E);
4703 llvm::Value *EmitNeonCall(llvm::Function *F,
4705 const char *name,
4706 unsigned shift = 0, bool rightshift = false);
4707 llvm::Value *EmitFP8NeonCall(unsigned IID, ArrayRef<llvm::Type *> Tys,
4709 const CallExpr *E, const char *name);
4710 llvm::Value *EmitFP8NeonCvtCall(unsigned IID, llvm::Type *Ty0,
4711 llvm::Type *Ty1, bool Extract,
4713 const CallExpr *E, const char *name);
4714 llvm::Value *EmitFP8NeonFDOTCall(unsigned IID, bool ExtendLaneArg,
4715 llvm::Type *RetTy,
4717 const CallExpr *E, const char *name);
4718 llvm::Value *EmitFP8NeonFMLACall(unsigned IID, bool ExtendLaneArg,
4719 llvm::Type *RetTy,
4721 const CallExpr *E, const char *name);
4722 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
4723 const llvm::ElementCount &Count);
4724 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
4725 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
4726 bool negateForRightShift);
4727 llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt,
4728 llvm::Type *Ty, bool usgn, const char *name);
4729 llvm::Value *vectorWrapScalar16(llvm::Value *Op);
4730 /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4731 /// access builtin. Only required if it can't be inferred from the base
4732 /// pointer operand.
4733 llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags);
4734
4736 getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType,
4738 llvm::Type *getEltType(const SVETypeFlags &TypeFlags);
4739 llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags);
4740 llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags);
4741 llvm::Value *EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags,
4743 llvm::Value *EmitSVETupleCreate(const SVETypeFlags &TypeFlags,
4744 llvm::Type *ReturnType,
4746 llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags);
4747 llvm::Value *EmitSVEDupX(llvm::Value *Scalar);
4748 llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty);
4749 llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty);
4750 llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags,
4752 unsigned BuiltinID);
4753 llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags,
4755 unsigned BuiltinID);
4756 llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred,
4757 llvm::ScalableVectorType *VTy);
4758 llvm::Value *EmitSVEPredicateTupleCast(llvm::Value *PredTuple,
4759 llvm::StructType *Ty);
4760 llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags,
4762 unsigned IntID);
4763 llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags,
4765 unsigned IntID);
4766 llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy,
4768 unsigned BuiltinID, bool IsZExtReturn);
4769 llvm::Value *EmitSVEMaskedStore(const CallExpr *,
4771 unsigned BuiltinID);
4772 llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags,
4774 unsigned BuiltinID);
4775 llvm::Value *EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags,
4777 unsigned IntID);
4778 llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags,
4780 unsigned IntID);
4781 llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags,
4783 unsigned IntID);
4784 llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4785
4786 llvm::Value *EmitSMELd1St1(const SVETypeFlags &TypeFlags,
4788 unsigned IntID);
4789 llvm::Value *EmitSMEReadWrite(const SVETypeFlags &TypeFlags,
4791 unsigned IntID);
4792 llvm::Value *EmitSMEZero(const SVETypeFlags &TypeFlags,
4794 unsigned IntID);
4795 llvm::Value *EmitSMELdrStr(const SVETypeFlags &TypeFlags,
4797 unsigned IntID);
4798
4799 void GetAArch64SVEProcessedOperands(unsigned BuiltinID, const CallExpr *E,
4801 SVETypeFlags TypeFlags);
4802
4803 llvm::Value *EmitAArch64SMEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4804
4805 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4806 llvm::Triple::ArchType Arch);
4807 llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4808
4810 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4811 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4812 llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4813 llvm::Value *EmitHLSLBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4815 llvm::Value *EmitSPIRVBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4816 llvm::Value *EmitScalarOrConstFoldImmArg(unsigned ICEArguments, unsigned Idx,
4817 const CallExpr *E);
4818 llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4819 llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4820 llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
4821 const CallExpr *E);
4822 llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4823 llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4825
4826 llvm::Value *EmitRISCVCpuSupports(const CallExpr *E);
4827 llvm::Value *EmitRISCVCpuSupports(ArrayRef<StringRef> FeaturesStrs);
4828 llvm::Value *EmitRISCVCpuInit();
4829 llvm::Value *EmitRISCVCpuIs(const CallExpr *E);
4830 llvm::Value *EmitRISCVCpuIs(StringRef CPUStr);
4831
4832 void AddAMDGPUFenceAddressSpaceMMRA(llvm::Instruction *Inst,
4833 const CallExpr *E);
4834 void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope,
4835 llvm::AtomicOrdering &AO,
4836 llvm::SyncScope::ID &SSID);
4837
4838 enum class MSVCIntrin;
4839 llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4840
4841 llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version);
4842
4845 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E);
4848 llvm::Value *EmitObjCCollectionLiteral(const Expr *E,
4849 const ObjCMethodDecl *MethodWithObjects);
4852 ReturnValueSlot Return = ReturnValueSlot());
4853
4854 /// Retrieves the default cleanup kind for an ARC cleanup.
4855 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4857 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
4859 }
4860
4861 // ARC primitives.
4862 void EmitARCInitWeak(Address addr, llvm::Value *value);
4864 llvm::Value *EmitARCLoadWeak(Address addr);
4866 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
4867 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4868 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4871 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
4872 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
4873 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
4874 bool resultIgnored);
4875 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
4876 bool resultIgnored);
4877 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
4878 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
4879 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
4881 void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4882 llvm::Value *EmitARCAutorelease(llvm::Value *value);
4883 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
4884 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
4885 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
4886 llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value);
4887
4888 llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
4889 llvm::Value *EmitObjCRetainNonBlock(llvm::Value *value,
4890 llvm::Type *returnType);
4891 void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4892
4893 std::pair<LValue,llvm::Value*>
4895 std::pair<LValue,llvm::Value*>
4896 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
4897 std::pair<LValue,llvm::Value*>
4899
4900 llvm::Value *EmitObjCAlloc(llvm::Value *value,
4901 llvm::Type *returnType);
4902 llvm::Value *EmitObjCAllocWithZone(llvm::Value *value,
4903 llvm::Type *returnType);
4904 llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
4905
4906 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
4907 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
4908 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
4909
4910 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
4911 llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
4912 bool allowUnsafeClaim);
4913 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
4916
4918
4920
4926
4927 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
4930 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
4931 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
4932
4933 /// Emits a reference binding to the passed in expression.
4935
4936 //===--------------------------------------------------------------------===//
4937 // Expression Emission
4938 //===--------------------------------------------------------------------===//
4939
4940 // Expressions are broken into three classes: scalar, complex, aggregate.
4941
4942 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
4943 /// scalar type, returning the result.
4944 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
4945
4946 /// Emit a conversion from the specified type to the specified destination
4947 /// type, both of which are LLVM scalar types.
4948 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
4949 QualType DstTy, SourceLocation Loc);
4950
4951 /// Emit a conversion from the specified complex type to the specified
4952 /// destination type, where the destination type is an LLVM scalar type.
4954 QualType DstTy,
4956
4957 /// EmitAggExpr - Emit the computation of the specified expression
4958 /// of aggregate type. The result is computed into the given slot,
4959 /// which may be null to indicate that the value is not needed.
4960 void EmitAggExpr(const Expr *E, AggValueSlot AS);
4961
4962 /// EmitAggExprToLValue - Emit the computation of the specified expression of
4963 /// aggregate type into a temporary LValue.
4965
4967
4968 /// EmitAggFinalDestCopy - Emit copy of the specified aggregate into
4969 /// destination address.
4971 ExprValueKind SrcKind);
4972
4973 /// Create a store to \arg DstPtr from \arg Src, truncating the stored value
4974 /// to at most \arg DstSize bytes.
4975 void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize,
4976 bool DstIsVolatile);
4977
4978 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
4979 /// make sure it survives garbage collection until this point.
4980 void EmitExtendGCLifetime(llvm::Value *object);
4981
4982 /// EmitComplexExpr - Emit the computation of the specified expression of
4983 /// complex type, returning the result.
4985 bool IgnoreReal = false,
4986 bool IgnoreImag = false);
4987
4988 /// EmitComplexExprIntoLValue - Emit the given expression of complex
4989 /// type and place its result into the specified l-value.
4990 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
4991
4992 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
4993 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
4994
4995 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
4997
4999 llvm::Value *EmitPromotedScalarExpr(const Expr *E, QualType PromotionType);
5002
5005
5006 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
5007 /// global variable that has already been created for it. If the initializer
5008 /// has a different type than GV does, this may free GV and return a different
5009 /// one. Otherwise it just returns GV.
5010 llvm::GlobalVariable *
5012 llvm::GlobalVariable *GV);
5013
5014 // Emit an @llvm.invariant.start call for the given memory region.
5015 void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
5016
5017 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
5018 /// variable with global storage.
5019 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV,
5020 bool PerformInit);
5021
5022 llvm::Constant *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
5023 llvm::Constant *Addr);
5024
5025 llvm::Function *createTLSAtExitStub(const VarDecl &VD,
5026 llvm::FunctionCallee Dtor,
5027 llvm::Constant *Addr,
5028 llvm::FunctionCallee &AtExit);
5029
5030 /// Call atexit() with a function that passes the given argument to
5031 /// the given function.
5032 void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
5033 llvm::Constant *addr);
5034
5035 /// Registers the dtor using 'llvm.global_dtors' for platforms that do not
5036 /// support an 'atexit()' function.
5037 void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn,
5038 llvm::Constant *addr);
5039
5040 /// Call atexit() with function dtorStub.
5041 void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
5042
5043 /// Call unatexit() with function dtorStub.
5044 llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub);
5045
5046 /// Emit code in this function to perform a guarded variable
5047 /// initialization. Guarded initializations are used when it's not
5048 /// possible to prove that an initialization will be done exactly
5049 /// once, e.g. with a static local variable or a static data member
5050 /// of a class template.
5051 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
5052 bool PerformInit);
5053
5055
5056 /// Emit a branch to select whether or not to perform guarded initialization.
5057 void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
5058 llvm::BasicBlock *InitBlock,
5059 llvm::BasicBlock *NoInitBlock,
5060 GuardKind Kind, const VarDecl *D);
5061
5062 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
5063 /// variables.
5064 void
5065 GenerateCXXGlobalInitFunc(llvm::Function *Fn,
5066 ArrayRef<llvm::Function *> CXXThreadLocals,
5068
5069 /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
5070 /// variables.
5072 llvm::Function *Fn,
5073 ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
5074 llvm::Constant *>>
5075 DtorsOrStermFinalizers);
5076
5077 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
5078 const VarDecl *D,
5079 llvm::GlobalVariable *Addr,
5080 bool PerformInit);
5081
5083
5084 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
5085
5086 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
5087
5089
5091
5092 //===--------------------------------------------------------------------===//
5093 // Annotations Emission
5094 //===--------------------------------------------------------------------===//
5095
5096 /// Emit an annotation call (intrinsic).
5097 llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
5098 llvm::Value *AnnotatedVal,
5099 StringRef AnnotationStr,
5100 SourceLocation Location,
5101 const AnnotateAttr *Attr);
5102
5103 /// Emit local annotations for the local variable V, declared by D.
5104 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
5105
5106 /// Emit field annotations for the given field & value. Returns the
5107 /// annotation result.
5109
5110 //===--------------------------------------------------------------------===//
5111 // Internal Helpers
5112 //===--------------------------------------------------------------------===//
5113
5114 /// ContainsLabel - Return true if the statement contains a label in it. If
5115 /// this statement is not executed normally, it not containing a label means
5116 /// that we can just remove the code.
5117 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
5118
5119 /// containsBreak - Return true if the statement contains a break out of it.
5120 /// If the statement (recursively) contains a switch or loop with a break
5121 /// inside of it, this is fine.
5122 static bool containsBreak(const Stmt *S);
5123
5124 /// Determine if the given statement might introduce a declaration into the
5125 /// current scope, by being a (possibly-labelled) DeclStmt.
5126 static bool mightAddDeclToScope(const Stmt *S);
5127
5128 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5129 /// to a constant, or if it does but contains a label, return false. If it
5130 /// constant folds return true and set the boolean result in Result.
5132 bool AllowLabels = false);
5133
5134 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5135 /// to a constant, or if it does but contains a label, return false. If it
5136 /// constant folds return true and set the folded value.
5137 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result,
5138 bool AllowLabels = false);
5139
5140 /// Ignore parentheses and logical-NOT to track conditions consistently.
5141 static const Expr *stripCond(const Expr *C);
5142
5143 /// isInstrumentedCondition - Determine whether the given condition is an
5144 /// instrumentable condition (i.e. no "&&" or "||").
5145 static bool isInstrumentedCondition(const Expr *C);
5146
5147 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
5148 /// increments a profile counter based on the semantics of the given logical
5149 /// operator opcode. This is used to instrument branch condition coverage
5150 /// for logical operators.
5152 llvm::BasicBlock *TrueBlock,
5153 llvm::BasicBlock *FalseBlock,
5154 uint64_t TrueCount = 0,
5156 const Expr *CntrIdx = nullptr);
5157
5158 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
5159 /// if statement) to the specified blocks. Based on the condition, this might
5160 /// try to simplify the codegen of the conditional based on the branch.
5161 /// TrueCount should be the number of times we expect the condition to
5162 /// evaluate to true based on PGO data.
5163 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
5164 llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
5166 const Expr *ConditionalOp = nullptr);
5167
5168 /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
5169 /// nonnull, if \p LHS is marked _Nonnull.
5170 void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
5171
5172 /// An enumeration which makes it easier to specify whether or not an
5173 /// operation is a subtraction.
5174 enum { NotSubtraction = false, IsSubtraction = true };
5175
5176 /// Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to
5177 /// detect undefined behavior when the pointer overflow sanitizer is enabled.
5178 /// \p SignedIndices indicates whether any of the GEP indices are signed.
5179 /// \p IsSubtraction indicates whether the expression used to form the GEP
5180 /// is a subtraction.
5181 llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr,
5183 bool SignedIndices,
5184 bool IsSubtraction,
5186 const Twine &Name = "");
5187
5189 llvm::Type *elementType, bool SignedIndices,
5191 CharUnits Align, const Twine &Name = "");
5192
5193 /// Specifies which type of sanitizer check to apply when handling a
5194 /// particular builtin.
5199 };
5200
5201 /// Emits an argument for a call to a builtin. If the builtin sanitizer is
5202 /// enabled, a runtime check specified by \p Kind is also emitted.
5204
5205 /// Emits an argument for a call to a `__builtin_assume`. If the builtin
5206 /// sanitizer is enabled, a runtime check is also emitted.
5207 llvm::Value *EmitCheckedArgForAssume(const Expr *E);
5208
5209 /// Emit a description of a type in a format suitable for passing to
5210 /// a runtime sanitizer handler.
5212
5213 /// Convert a value into a format suitable for passing to a runtime
5214 /// sanitizer handler.
5215 llvm::Value *EmitCheckValue(llvm::Value *V);
5216
5217 /// Emit a description of a source location in a format suitable for
5218 /// passing to a runtime sanitizer handler.
5220
5223
5224 /// Create a basic block that will either trap or call a handler function in
5225 /// the UBSan runtime with the provided arguments, and create a conditional
5226 /// branch to it.
5227 void
5228 EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerKind::SanitizerOrdinal>>
5229 Checked,
5231 ArrayRef<llvm::Value *> DynamicArgs);
5232
5233 /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath
5234 /// if Cond if false.
5236 llvm::Value *Cond, llvm::ConstantInt *TypeId,
5237 llvm::Value *Ptr,
5238 ArrayRef<llvm::Constant *> StaticArgs);
5239
5240 /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime
5241 /// checking is enabled. Otherwise, just emit an unreachable instruction.
5243
5244 /// Create a basic block that will call the trap intrinsic, and emit a
5245 /// conditional branch to it, for the -ftrapv checks.
5246 void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID,
5247 bool NoMerge = false);
5248
5249 /// Emit a call to trap or debugtrap and attach function attribute
5250 /// "trap-func-name" if specified.
5251 llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID);
5252
5253 /// Emit a stub for the cross-DSO CFI check function.
5255
5256 /// Emit a cross-DSO CFI failure handling function.
5258
5259 /// Create a check for a function parameter that may potentially be
5260 /// declared as non-null.
5262 AbstractCallee AC, unsigned ParmNum);
5263
5265 SourceLocation ArgLoc, AbstractCallee AC,
5266 unsigned ParmNum);
5267
5268 /// EmitWriteback - Emit callbacks for function.
5269 void EmitWritebacks(const CallArgList &Args);
5270
5271 /// EmitCallArg - Emit a single call argument.
5272 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
5273
5274 /// EmitDelegateCallArg - We are performing a delegate call; that
5275 /// is, the current function is delegating to another one. Produce
5276 /// a r-value suitable for passing the given parameter.
5277 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param,
5278 SourceLocation loc);
5279
5280 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
5281 /// point operation, expressed as the maximum relative error in ulp.
5282 void SetFPAccuracy(llvm::Value *Val, float Accuracy);
5283
5284 /// Set the minimum required accuracy of the given sqrt operation
5285 /// based on CodeGenOpts.
5286 void SetSqrtFPAccuracy(llvm::Value *Val);
5287
5288 /// Set the minimum required accuracy of the given sqrt operation based on
5289 /// CodeGenOpts.
5290 void SetDivFPAccuracy(llvm::Value *Val);
5291
5292 /// Set the codegen fast-math flags.
5293 void SetFastMathFlags(FPOptions FPFeatures);
5294
5295 // Truncate or extend a boolean vector to the requested number of elements.
5296 llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec,
5297 unsigned NumElementsDst,
5298 const llvm::Twine &Name = "");
5299
5300private:
5301 // Emits a convergence_loop instruction for the given |BB|, with |ParentToken|
5302 // as it's parent convergence instr.
5303 llvm::ConvergenceControlInst *emitConvergenceLoopToken(llvm::BasicBlock *BB);
5304
5305 // Adds a convergence_ctrl token with |ParentToken| as parent convergence
5306 // instr to the call |Input|.
5307 llvm::CallBase *addConvergenceControlToken(llvm::CallBase *Input);
5308
5309 // Find the convergence_entry instruction |F|, or emits ones if none exists.
5310 // Returns the convergence instruction.
5311 llvm::ConvergenceControlInst *
5312 getOrEmitConvergenceEntryToken(llvm::Function *F);
5313
5314private:
5315 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
5316 void EmitReturnOfRValue(RValue RV, QualType Ty);
5317
5318 void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
5319
5321 DeferredReplacements;
5322
5323 /// Set the address of a local variable.
5324 void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
5325 assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
5326 LocalDeclMap.insert({VD, Addr});
5327 }
5328
5329 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
5330 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
5331 ///
5332 /// \param AI - The first function argument of the expansion.
5333 void ExpandTypeFromArgs(QualType Ty, LValue Dst,
5334 llvm::Function::arg_iterator &AI);
5335
5336 /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg
5337 /// Ty, into individual arguments on the provided vector \arg IRCallArgs,
5338 /// starting at index \arg IRCallArgPos. See ABIArgInfo::Expand.
5339 void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
5341 unsigned &IRCallArgPos);
5342
5343 std::pair<llvm::Value *, llvm::Type *>
5344 EmitAsmInput(const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr,
5345 std::string &ConstraintStr);
5346
5347 std::pair<llvm::Value *, llvm::Type *>
5348 EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue,
5349 QualType InputType, std::string &ConstraintStr,
5351
5352 /// Attempts to statically evaluate the object size of E. If that
5353 /// fails, emits code to figure the size of E out for us. This is
5354 /// pass_object_size aware.
5355 ///
5356 /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
5357 llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
5358 llvm::IntegerType *ResType,
5359 llvm::Value *EmittedE,
5360 bool IsDynamic);
5361
5362 /// Emits the size of E, as required by __builtin_object_size. This
5363 /// function is aware of pass_object_size parameters, and will act accordingly
5364 /// if E is a parameter with the pass_object_size attribute.
5365 llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
5366 llvm::IntegerType *ResType,
5367 llvm::Value *EmittedE,
5368 bool IsDynamic);
5369
5370 llvm::Value *emitCountedByMemberSize(const Expr *E, llvm::Value *EmittedE,
5371 unsigned Type,
5372 llvm::IntegerType *ResType);
5373
5374 void emitZeroOrPatternForAutoVarInit(QualType type, const VarDecl &D,
5375 Address Loc);
5376
5377public:
5378 enum class EvaluationOrder {
5379 ///! No language constraints on evaluation order.
5380 Default,
5381 ///! Language semantics require left-to-right evaluation.
5383 ///! Language semantics require right-to-left evaluation.
5385 };
5386
5387 // Wrapper for function prototype sources. Wraps either a FunctionProtoType or
5388 // an ObjCMethodDecl.
5390 llvm::PointerUnion<const FunctionProtoType *, const ObjCMethodDecl *> P;
5391
5394 };
5395
5397 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
5399 unsigned ParamsToSkip = 0,
5401
5402 /// EmitPointerWithAlignment - Given an expression with a pointer type,
5403 /// emit the value and compute our best estimate of the alignment of the
5404 /// pointee.
5405 ///
5406 /// \param BaseInfo - If non-null, this will be initialized with
5407 /// information about the source of the alignment and the may-alias
5408 /// attribute. Note that this function will conservatively fall back on
5409 /// the type when it doesn't recognize the expression and may-alias will
5410 /// be set to false.
5411 ///
5412 /// One reasonable way to use this information is when there's a language
5413 /// guarantee that the pointer must be aligned to some stricter value, and
5414 /// we're simply trying to ensure that sufficiently obvious uses of under-
5415 /// aligned objects don't get miscompiled; for example, a placement new
5416 /// into the address of a local variable. In such a case, it's quite
5417 /// reasonable to just ignore the returned alignment when it isn't from an
5418 /// explicit source.
5419 Address
5420 EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo = nullptr,
5421 TBAAAccessInfo *TBAAInfo = nullptr,
5422 KnownNonNull_t IsKnownNonNull = NotKnownNonNull);
5423
5424 /// If \p E references a parameter with pass_object_size info or a constant
5425 /// array size modifier, emit the object size divided by the size of \p EltTy.
5426 /// Otherwise return null.
5427 llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy);
5428
5429 void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK);
5430
5432 llvm::Function *Function;
5434 std::optional<StringRef> Architecture;
5435
5436 FMVResolverOption(llvm::Function *F, ArrayRef<StringRef> Feats,
5437 std::optional<StringRef> Arch = std::nullopt)
5438 : Function(F), Features(Feats), Architecture(Arch) {}
5439 };
5440
5441 // Emits the body of a multiversion function's resolver. Assumes that the
5442 // options are already sorted in the proper order, with the 'default' option
5443 // last (if it exists).
5444 void EmitMultiVersionResolver(llvm::Function *Resolver,
5446 void EmitX86MultiVersionResolver(llvm::Function *Resolver,
5448 void EmitAArch64MultiVersionResolver(llvm::Function *Resolver,
5450 void EmitRISCVMultiVersionResolver(llvm::Function *Resolver,
5452
5453private:
5454 QualType getVarArgType(const Expr *Arg);
5455
5456 void EmitDeclMetadata();
5457
5458 BlockByrefHelpers *buildByrefHelpers(llvm::StructType &byrefType,
5459 const AutoVarEmission &emission);
5460
5461 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
5462
5463 llvm::Value *GetValueForARMHint(unsigned BuiltinID);
5464 llvm::Value *EmitX86CpuIs(const CallExpr *E);
5465 llvm::Value *EmitX86CpuIs(StringRef CPUStr);
5466 llvm::Value *EmitX86CpuSupports(const CallExpr *E);
5467 llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs);
5468 llvm::Value *EmitX86CpuSupports(std::array<uint32_t, 4> FeatureMask);
5469 llvm::Value *EmitX86CpuInit();
5470 llvm::Value *FormX86ResolverCondition(const FMVResolverOption &RO);
5471 llvm::Value *EmitAArch64CpuInit();
5472 llvm::Value *FormAArch64ResolverCondition(const FMVResolverOption &RO);
5473 llvm::Value *EmitAArch64CpuSupports(const CallExpr *E);
5474 llvm::Value *EmitAArch64CpuSupports(ArrayRef<StringRef> FeatureStrs);
5475};
5476
5479 if (!needsSaving(value)) return saved_type(value, false);
5480
5481 // Otherwise, we need an alloca.
5482 auto align = CharUnits::fromQuantity(
5483 CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
5484 Address alloca =
5485 CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
5486 CGF.Builder.CreateStore(value, alloca);
5487
5488 return saved_type(alloca.emitRawPointer(CGF), true);
5489}
5490
5492 saved_type value) {
5493 // If the value says it wasn't saved, trust that it's still dominating.
5494 if (!value.getInt()) return value.getPointer();
5495
5496 // Otherwise, it should be an alloca instruction, as set up in save().
5497 auto alloca = cast<llvm::AllocaInst>(value.getPointer());
5498 return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca,
5499 alloca->getAlign());
5500}
5501
5502} // end namespace CodeGen
5503
5504// Map the LangOption for floating point exception behavior into
5505// the corresponding enum in the IR.
5506llvm::fp::ExceptionBehavior
5508} // end namespace clang
5509
5510#endif
Enums/classes describing ABI related information about constructors, destructors and thunks.
#define V(N, I)
Definition: ASTContext.h:3460
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2686
@ ForDeactivation
Definition: CGCleanup.cpp:1212
enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind
const Decl * D
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.
This file defines SYCL AST classes used to represent calls to SYCL kernels.
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:3578
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:2592
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:2856
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:2117
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:5189
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
void Emit(CodeGenFunction &CGF, Flags flags) override
Emit the cleanup.
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:746
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)
void EmitOMPMaskedTaskLoopSimdDirective(const OMPMaskedTaskLoopSimdDirective &S)
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 * EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
Build an expression accessing the "counted_by" field.
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,...
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
llvm::Value * EmitFP8NeonCall(unsigned IID, ArrayRef< llvm::Type * > Tys, SmallVectorImpl< llvm::Value * > &O, const CallExpr *E, const char *name)
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 EmitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective &S)
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)
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 EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > 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...
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.
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...
void EmitFakeUse(Address Addr)
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())
void EmitCfiSlowPathCheck(SanitizerKind::SanitizerOrdinal Ordinal, llvm::Value *Cond, llvm::ConstantInt *TypeId, llvm::Value *Ptr, ArrayRef< llvm::Constant * > StaticArgs)
Emit a slow path cross-DSO CFI check which calls __cfi_slowpath if Cond if false.
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
void EmitOpenACCAtomicConstruct(const OpenACCAtomicConstruct &S)
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)
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)
void EmitOMPParallelMaskedTaskLoopSimdDirective(const OMPParallelMaskedTaskLoopSimdDirective &S)
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 * EmitFP8NeonFDOTCall(unsigned IID, bool ExtendLaneArg, llvm::Type *RetTy, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
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)
llvm::Value * EmitFP8NeonFMLACall(unsigned IID, bool ExtendLaneArg, llvm::Type *RetTy, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
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="")
HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr
HLSL Branch attribute.
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)
llvm::Value * EmitFP8NeonCvtCall(unsigned IID, llvm::Type *Ty0, llvm::Type *Ty1, bool Extract, SmallVectorImpl< llvm::Value * > &Ops, const CallExpr *E, const char *name)
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 * GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)
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 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:146
ConditionalCleanup stores the saved form of its parameters, then restores them and performs the clean...
Definition: EHScopeStack.h:208
A saved depth on the scope stack.
Definition: EHScopeStack.h:106
A stack of scopes which respond to exceptions, including cleanups and catch blocks.
Definition: EHScopeStack.h:99
stable_iterator getInnermostNormalCleanup() const
Returns the innermost normal cleanup on the stack, or stable_end() if there are no normal cleanups.
Definition: EHScopeStack.h:375
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:398
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
Definition: EHScopeStack.h:403
void pushCleanupTuple(CleanupKind Kind, std::tuple< As... > A)
Push a lazily-created cleanup on the stack. Tuple version.
Definition: EHScopeStack.h:300
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:5075
Represents a 'co_yield' expression.
Definition: ExprCXX.h:5270
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:2387
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:5108
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:290
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:502
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:4732
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:3520
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 masked taskloop' directive.
Definition: StmtOpenMP.h:3930
This represents '#pragma omp masked taskloop simd' directive.
Definition: StmtOpenMP.h:4071
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 masked taskloop simd' directive.
Definition: StmtOpenMP.h:4360
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:3199
[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:4162
bool hasVolatileMember() const
Definition: Decl.h:4225
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6078
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:3384
The base class of the type hierarchy.
Definition: Type.h:1828
bool isReferenceType() const
Definition: Type.h:8210
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8741
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:886
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:1217
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3809
Expr * getSizeExpr() const
Definition: Type.h:3828
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