Debian Codegraph @

llvm-project/clang/lib/CodeGen/CodeGenFunction.h

raw
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"
25 #include "clang/AST/CurrentSourceLocExprScope.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/ExprOpenMP.h"
29 #include "clang/AST/StmtOpenMP.h"
30 #include "clang/AST/Type.h"
31 #include "clang/Basic/ABI.h"
32 #include "clang/Basic/CapturedStmt.h"
33 #include "clang/Basic/CodeGenOptions.h"
34 #include "clang/Basic/OpenMPKinds.h"
35 #include "clang/Basic/TargetInfo.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/ADT/DenseMap.h"
38 #include "llvm/ADT/MapVector.h"
39 #include "llvm/ADT/SmallVector.h"
40 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
41 #include "llvm/IR/ValueHandle.h"
42 #include "llvm/Support/Debug.h"
43 #include "llvm/Transforms/Utils/SanitizerStats.h"
44 #include <optional>
45
46 namespace llvm {
47 class BasicBlock;
48 class LLVMContext;
49 class MDNode;
50 class SwitchInst;
51 class Twine;
52 class Value;
53 class CanonicalLoopInfo;
54 }
55
56 namespace clang {
57 class ASTContext;
58 class CXXDestructorDecl;
59 class CXXForRangeStmt;
60 class CXXTryStmt;
61 class Decl;
62 class LabelDecl;
63 class FunctionDecl;
64 class FunctionProtoType;
65 class LabelStmt;
66 class ObjCContainerDecl;
67 class ObjCInterfaceDecl;
68 class ObjCIvarDecl;
69 class ObjCMethodDecl;
70 class ObjCImplementationDecl;
71 class ObjCPropertyImplDecl;
72 class TargetInfo;
73 class VarDecl;
74 class ObjCForCollectionStmt;
75 class ObjCAtTryStmt;
76 class ObjCAtThrowStmt;
77 class ObjCAtSynchronizedStmt;
78 class ObjCAutoreleasePoolStmt;
79 class OMPUseDevicePtrClause;
80 class OMPUseDeviceAddrClause;
81 class SVETypeFlags;
82 class OMPExecutableDirective;
83
84 namespace analyze_os_log {
85 class OSLogBufferLayout;
86 }
87
88 namespace CodeGen {
89 class CodeGenTypes;
90 class CGCallee;
91 class CGFunctionInfo;
92 class CGBlockInfo;
93 class CGCXXABI;
94 class BlockByrefHelpers;
95 class BlockByrefInfo;
96 class BlockFieldFlags;
97 class RegionCodeGenTy;
98 class TargetCodeGenInfo;
99 struct OMPTaskDataTy;
100 struct CGCoroData;
101
102 /// The kind of evaluation to perform on values of a particular
103 /// type. Basically, is the code in CGExprScalar, CGExprComplex, or
104 /// CGExprAgg?
105 ///
106 /// TODO: should vectors maybe be split out into their own thing?
107 enum TypeEvaluationKind {
108 TEK_Scalar,
109 TEK_Complex,
110 TEK_Aggregate
111 };
112
113 #define LIST_SANITIZER_CHECKS \
114 SANITIZER_CHECK(AddOverflow, add_overflow, 0) \
115 SANITIZER_CHECK(BuiltinUnreachable, builtin_unreachable, 0) \
116 SANITIZER_CHECK(CFICheckFail, cfi_check_fail, 0) \
117 SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0) \
118 SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0) \
119 SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0) \
120 SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 1) \
121 SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0) \
122 SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0) \
123 SANITIZER_CHECK(InvalidObjCCast, invalid_objc_cast, 0) \
124 SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0) \
125 SANITIZER_CHECK(MissingReturn, missing_return, 0) \
126 SANITIZER_CHECK(MulOverflow, mul_overflow, 0) \
127 SANITIZER_CHECK(NegateOverflow, negate_overflow, 0) \
128 SANITIZER_CHECK(NullabilityArg, nullability_arg, 0) \
129 SANITIZER_CHECK(NullabilityReturn, nullability_return, 1) \
130 SANITIZER_CHECK(NonnullArg, nonnull_arg, 0) \
131 SANITIZER_CHECK(NonnullReturn, nonnull_return, 1) \
132 SANITIZER_CHECK(OutOfBounds, out_of_bounds, 0) \
133 SANITIZER_CHECK(PointerOverflow, pointer_overflow, 0) \
134 SANITIZER_CHECK(ShiftOutOfBounds, shift_out_of_bounds, 0) \
135 SANITIZER_CHECK(SubOverflow, sub_overflow, 0) \
136 SANITIZER_CHECK(TypeMismatch, type_mismatch, 1) \
137 SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0) \
138 SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0)
139
140 enum SanitizerHandler {
141 #define SANITIZER_CHECK(Enum, Name, Version) Enum,
142 LIST_SANITIZER_CHECKS
143 #undef SANITIZER_CHECK
144 };
145
146 /// Helper class with most of the code for saving a value for a
147 /// conditional expression cleanup.
148 struct DominatingLLVMValue {
149 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
150
151 /// Answer whether the given value needs extra work to be saved.
152 static bool needsSaving(llvm::Value *value) {
153 // If it's not an instruction, we don't need to save.
154 if (!isa<llvm::Instruction>(value)) return false;
155
156 // If it's an instruction in the entry block, we don't need to save.
157 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
158 return (block != &block->getParent()->getEntryBlock());
159 }
160
161 static saved_type save(CodeGenFunction &CGF, llvm::Value *value);
162 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value);
163 };
164
165 /// A partial specialization of DominatingValue for llvm::Values that
166 /// might be llvm::Instructions.
167 template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
168 typedef T *type;
169 static type restore(CodeGenFunction &CGF, saved_type value) {
170 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
171 }
172 };
173
174 /// A specialization of DominatingValue for Address.
175 template <> struct DominatingValue<Address> {
176 typedef Address type;
177
178 struct saved_type {
179 DominatingLLVMValue::saved_type SavedValue;
180 llvm::Type *ElementType;
181 CharUnits Alignment;
182 };
183
184 static bool needsSaving(type value) {
185 return DominatingLLVMValue::needsSaving(value.getPointer());
186 }
187 static saved_type save(CodeGenFunction &CGF, type value) {
188 return { DominatingLLVMValue::save(CGF, value.getPointer()),
189 value.getElementType(), value.getAlignment() };
190 }
191 static type restore(CodeGenFunction &CGF, saved_type value) {
192 return Address(DominatingLLVMValue::restore(CGF, value.SavedValue),
193 value.ElementType, value.Alignment);
194 }
195 };
196
197 /// A specialization of DominatingValue for RValue.
198 template <> struct DominatingValue<RValue> {
199 typedef RValue type;
200 class saved_type {
201 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
202 AggregateAddress, ComplexAddress };
203
204 llvm::Value *Value;
205 llvm::Type *ElementType;
206 unsigned K : 3;
207 unsigned Align : 29;
208 saved_type(llvm::Value *v, llvm::Type *e, Kind k, unsigned a = 0)
209 : Value(v), ElementType(e), K(k), Align(a) {}
210
211 public:
212 static bool needsSaving(RValue value);
213 static saved_type save(CodeGenFunction &CGF, RValue value);
214 RValue restore(CodeGenFunction &CGF);
215
216 // implementations in CGCleanup.cpp
217 };
218
219 static bool needsSaving(type value) {
220 return saved_type::needsSaving(value);
221 }
222 static saved_type save(CodeGenFunction &CGF, type value) {
223 return saved_type::save(CGF, value);
224 }
225 static type restore(CodeGenFunction &CGF, saved_type value) {
226 return value.restore(CGF);
227 }
228 };
229
230 /// CodeGenFunction - This class organizes the per-function state that is used
231 /// while generating LLVM code.
232 class CodeGenFunction : public CodeGenTypeCache {
233 CodeGenFunction(const CodeGenFunction &) = delete;
234 void operator=(const CodeGenFunction &) = delete;
235
236 friend class CGCXXABI;
237 public:
238 /// A jump destination is an abstract label, branching to which may
239 /// require a jump out through normal cleanups.
240 struct JumpDest {
241 JumpDest() : Block(nullptr), Index(0) {}
242 JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth,
243 unsigned Index)
244 : Block(Block), ScopeDepth(Depth), Index(Index) {}
245
246 bool isValid() const { return Block != nullptr; }
247 llvm::BasicBlock *getBlock() const { return Block; }
248 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
249 unsigned getDestIndex() const { return Index; }
250
251 // This should be used cautiously.
252 void setScopeDepth(EHScopeStack::stable_iterator depth) {
253 ScopeDepth = depth;
254 }
255
256 private:
257 llvm::BasicBlock *Block;
258 EHScopeStack::stable_iterator ScopeDepth;
259 unsigned Index;
260 };
261
262 CodeGenModule &CGM; // Per-module state.
263 const TargetInfo &Target;
264
265 // For EH/SEH outlined funclets, this field points to parent's CGF
266 CodeGenFunction *ParentCGF = nullptr;
267
268 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
269 LoopInfoStack LoopStack;
270 CGBuilderTy Builder;
271
272 // Stores variables for which we can't generate correct lifetime markers
273 // because of jumps.
274 VarBypassDetector Bypasses;
275
276 /// List of recently emitted OMPCanonicalLoops.
277 ///
278 /// Since OMPCanonicalLoops are nested inside other statements (in particular
279 /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
280 /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its
281 /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any
282 /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
283 /// this stack when done. Entering a new loop requires clearing this list; it
284 /// either means we start parsing a new loop nest (in which case the previous
285 /// loop nest goes out of scope) or a second loop in the same level in which
286 /// case it would be ambiguous into which of the two (or more) loops the loop
287 /// nest would extend.
288 SmallVector<llvm::CanonicalLoopInfo *, 4> OMPLoopNestStack;
289
290 /// Number of nested loop to be consumed by the last surrounding
291 /// loop-associated directive.
292 int ExpectedOMPLoopDepth = 0;
293
294 // CodeGen lambda for loops and support for ordered clause
295 typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
296 JumpDest)>
297 CodeGenLoopTy;
298 typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
299 const unsigned, const bool)>
300 CodeGenOrderedTy;
301
302 // Codegen lambda for loop bounds in worksharing loop constructs
303 typedef llvm::function_ref<std::pair<LValue, LValue>(
304 CodeGenFunction &, const OMPExecutableDirective &S)>
305 CodeGenLoopBoundsTy;
306
307 // Codegen lambda for loop bounds in dispatch-based loop implementation
308 typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
309 CodeGenFunction &, const OMPExecutableDirective &S, Address LB,
310 Address UB)>
311 CodeGenDispatchBoundsTy;
312
313 /// CGBuilder insert helper. This function is called after an
314 /// instruction is created using Builder.
315 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
316 llvm::BasicBlock *BB,
317 llvm::BasicBlock::iterator InsertPt) const;
318
319 /// CurFuncDecl - Holds the Decl for the current outermost
320 /// non-closure context.
321 const Decl *CurFuncDecl;
322 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
323 const Decl *CurCodeDecl;
324 const CGFunctionInfo *CurFnInfo;
325 QualType FnRetTy;
326 llvm::Function *CurFn = nullptr;
327
328 /// Save Parameter Decl for coroutine.
329 llvm::SmallVector<const ParmVarDecl *, 4> FnArgs;
330
331 // Holds coroutine data if the current function is a coroutine. We use a
332 // wrapper to manage its lifetime, so that we don't have to define CGCoroData
333 // in this header.
334 struct CGCoroInfo {
335 std::unique_ptr<CGCoroData> Data;
336 CGCoroInfo();
337 ~CGCoroInfo();
338 };
339 CGCoroInfo CurCoro;
340
341 bool isCoroutine() const {
342 return CurCoro.Data != nullptr;
343 }
344
345 /// CurGD - The GlobalDecl for the current function being compiled.
346 GlobalDecl CurGD;
347
348 /// PrologueCleanupDepth - The cleanup depth enclosing all the
349 /// cleanups associated with the parameters.
350 EHScopeStack::stable_iterator PrologueCleanupDepth;
351
352 /// ReturnBlock - Unified return block.
353 JumpDest ReturnBlock;
354
355 /// ReturnValue - The temporary alloca to hold the return
356 /// value. This is invalid iff the function has no return value.
357 Address ReturnValue = Address::invalid();
358
359 /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
360 /// This is invalid if sret is not in use.
361 Address ReturnValuePointer = Address::invalid();
362
363 /// If a return statement is being visited, this holds the return statment's
364 /// result expression.
365 const Expr *RetExpr = nullptr;
366
367 /// Return true if a label was seen in the current scope.
368 bool hasLabelBeenSeenInCurrentScope() const {
369 if (CurLexicalScope)
370 return CurLexicalScope->hasLabels();
371 return !LabelMap.empty();
372 }
373
374 /// AllocaInsertPoint - This is an instruction in the entry block before which
375 /// we prefer to insert allocas.
376 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
377
378 private:
379 /// PostAllocaInsertPt - This is a place in the prologue where code can be
380 /// inserted that will be dominated by all the static allocas. This helps
381 /// achieve two things:
382 /// 1. Contiguity of all static allocas (within the prologue) is maintained.
383 /// 2. All other prologue code (which are dominated by static allocas) do
384 /// appear in the source order immediately after all static allocas.
385 ///
386 /// PostAllocaInsertPt will be lazily created when it is *really* required.
387 llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr;
388
389 public:
390 /// Return PostAllocaInsertPt. If it is not yet created, then insert it
391 /// immediately after AllocaInsertPt.
392 llvm::Instruction *getPostAllocaInsertPoint() {
393 if (!PostAllocaInsertPt) {
394 assert(AllocaInsertPt &&
395 "Expected static alloca insertion point at function prologue");
396 assert(AllocaInsertPt->getParent()->isEntryBlock() &&
397 "EBB should be entry block of the current code gen function");
398 PostAllocaInsertPt = AllocaInsertPt->clone();
399 PostAllocaInsertPt->setName("postallocapt");
400 PostAllocaInsertPt->insertAfter(AllocaInsertPt);
401 }
402
403 return PostAllocaInsertPt;
404 }
405
406 /// API for captured statement code generation.
407 class CGCapturedStmtInfo {
408 public:
409 explicit CGCapturedStmtInfo(CapturedRegionKind K = CR_Default)
410 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
411 explicit CGCapturedStmtInfo(const CapturedStmt &S,
412 CapturedRegionKind K = CR_Default)
413 : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
414
415 RecordDecl::field_iterator Field =
416 S.getCapturedRecordDecl()->field_begin();
417 for (CapturedStmt::const_capture_iterator I = S.capture_begin(),
418 E = S.capture_end();
419 I != E; ++I, ++Field) {
420 if (I->capturesThis())
421 CXXThisFieldDecl = *Field;
422 else if (I->capturesVariable())
423 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
424 else if (I->capturesVariableByCopy())
425 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
426 }
427 }
428
429 virtual ~CGCapturedStmtInfo();
430
431 CapturedRegionKind getKind() const { return Kind; }
432
433 virtual void setContextValue(llvm::Value *V) { ThisValue = V; }
434 // Retrieve the value of the context parameter.
435 virtual llvm::Value *getContextValue() const { return ThisValue; }
436
437 /// Lookup the captured field decl for a variable.
438 virtual const FieldDecl *lookup(const VarDecl *VD) const {
439 return CaptureFields.lookup(VD->getCanonicalDecl());
440 }
441
442 bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; }
443 virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; }
444
445 static bool classof(const CGCapturedStmtInfo *) {
446 return true;
447 }
448
449 /// Emit the captured statement body.
450 virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
451 CGF.incrementProfileCounter(S);
452 CGF.EmitStmt(S);
453 }
454
455 /// Get the name of the capture helper.
456 virtual StringRef getHelperName() const { return "__captured_stmt"; }
457
458 /// Get the CaptureFields
459 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() {
460 return CaptureFields;
461 }
462
463 private:
464 /// The kind of captured statement being generated.
465 CapturedRegionKind Kind;
466
467 /// Keep the map between VarDecl and FieldDecl.
468 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields;
469
470 /// The base address of the captured record, passed in as the first
471 /// argument of the parallel region function.
472 llvm::Value *ThisValue;
473
474 /// Captured 'this' type.
475 FieldDecl *CXXThisFieldDecl;
476 };
477 CGCapturedStmtInfo *CapturedStmtInfo = nullptr;
478
479 /// RAII for correct setting/restoring of CapturedStmtInfo.
480 class CGCapturedStmtRAII {
481 private:
482 CodeGenFunction &CGF;
483 CGCapturedStmtInfo *PrevCapturedStmtInfo;
484 public:
485 CGCapturedStmtRAII(CodeGenFunction &CGF,
486 CGCapturedStmtInfo *NewCapturedStmtInfo)
487 : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
488 CGF.CapturedStmtInfo = NewCapturedStmtInfo;
489 }
490 ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
491 };
492
493 /// An abstract representation of regular/ObjC call/message targets.
494 class AbstractCallee {
495 /// The function declaration of the callee.
496 const Decl *CalleeDecl;
497
498 public:
499 AbstractCallee() : CalleeDecl(nullptr) {}
500 AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
501 AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {}
502 bool hasFunctionDecl() const {
503 return isa_and_nonnull<FunctionDecl>(CalleeDecl);
504 }
505 const Decl *getDecl() const { return CalleeDecl; }
506 unsigned getNumParams() const {
507 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
508 return FD->getNumParams();
509 return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
510 }
511 const ParmVarDecl *getParamDecl(unsigned I) const {
512 if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
513 return FD->getParamDecl(I);
514 return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
515 }
516 };
517
518 /// Sanitizers enabled for this function.
519 SanitizerSet SanOpts;
520
521 /// True if CodeGen currently emits code implementing sanitizer checks.
522 bool IsSanitizerScope = false;
523
524 /// RAII object to set/unset CodeGenFunction::IsSanitizerScope.
525 class SanitizerScope {
526 CodeGenFunction *CGF;
527 public:
528 SanitizerScope(CodeGenFunction *CGF);
529 ~SanitizerScope();
530 };
531
532 /// In C++, whether we are code generating a thunk. This controls whether we
533 /// should emit cleanups.
534 bool CurFuncIsThunk = false;
535
536 /// In ARC, whether we should autorelease the return value.
537 bool AutoreleaseResult = false;
538
539 /// Whether we processed a Microsoft-style asm block during CodeGen. These can
540 /// potentially set the return value.
541 bool SawAsmBlock = false;
542
543 GlobalDecl CurSEHParent;
544
545 /// True if the current function is an outlined SEH helper. This can be a
546 /// finally block or filter expression.
547 bool IsOutlinedSEHHelper = false;
548
549 /// True if CodeGen currently emits code inside presereved access index
550 /// region.
551 bool IsInPreservedAIRegion = false;
552
553 /// True if the current statement has nomerge attribute.
554 bool InNoMergeAttributedStmt = false;
555
556 /// True if the current statement has noinline attribute.
557 bool InNoInlineAttributedStmt = false;
558
559 /// True if the current statement has always_inline attribute.
560 bool InAlwaysInlineAttributedStmt = false;
561
562 // The CallExpr within the current statement that the musttail attribute
563 // applies to. nullptr if there is no 'musttail' on the current statement.
564 const CallExpr *MustTailCall = nullptr;
565
566 /// Returns true if a function must make progress, which means the
567 /// mustprogress attribute can be added.
568 bool checkIfFunctionMustProgress() {
569 if (CGM.getCodeGenOpts().getFiniteLoops() ==
570 CodeGenOptions::FiniteLoopsKind::Never)
571 return false;
572
573 // C++11 and later guarantees that a thread eventually will do one of the
574 // following (C++11 [intro.multithread]p24 and C++17 [intro.progress]p1):
575 // - terminate,
576 // - make a call to a library I/O function,
577 // - perform an access through a volatile glvalue, or
578 // - perform a synchronization operation or an atomic operation.
579 //
580 // Hence each function is 'mustprogress' in C++11 or later.
581 return getLangOpts().CPlusPlus11;
582 }
583
584 /// Returns true if a loop must make progress, which means the mustprogress
585 /// attribute can be added. \p HasConstantCond indicates whether the branch
586 /// condition is a known constant.
587 bool checkIfLoopMustProgress(bool HasConstantCond) {
588 if (CGM.getCodeGenOpts().getFiniteLoops() ==
589 CodeGenOptions::FiniteLoopsKind::Always)
590 return true;
591 if (CGM.getCodeGenOpts().getFiniteLoops() ==
592 CodeGenOptions::FiniteLoopsKind::Never)
593 return false;
594
595 // If the containing function must make progress, loops also must make
596 // progress (as in C++11 and later).
597 if (checkIfFunctionMustProgress())
598 return true;
599
600 // Now apply rules for plain C (see 6.8.5.6 in C11).
601 // Loops with constant conditions do not have to make progress in any C
602 // version.
603 if (HasConstantCond)
604 return false;
605
606 // Loops with non-constant conditions must make progress in C11 and later.
607 return getLangOpts().C11;
608 }
609
610 const CodeGen::CGBlockInfo *BlockInfo = nullptr;
611 llvm::Value *BlockPointer = nullptr;
612
613 llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
614 FieldDecl *LambdaThisCaptureField = nullptr;
615
616 /// A mapping from NRVO variables to the flags used to indicate
617 /// when the NRVO has been applied to this variable.
618 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
619
620 EHScopeStack EHStack;
621 llvm::SmallVector<char, 256> LifetimeExtendedCleanupStack;
622 llvm::SmallVector<const JumpDest *, 2> SEHTryEpilogueStack;
623
624 llvm::Instruction *CurrentFuncletPad = nullptr;
625
626 class CallLifetimeEnd final : public EHScopeStack::Cleanup {
627 bool isRedundantBeforeReturn() override { return true; }
628
629 llvm::Value *Addr;
630 llvm::Value *Size;
631
632 public:
633 CallLifetimeEnd(Address addr, llvm::Value *size)
634 : Addr(addr.getPointer()), Size(size) {}
635
636 void Emit(CodeGenFunction &CGF, Flags flags) override {
637 CGF.EmitLifetimeEnd(Size, Addr);
638 }
639 };
640
641 /// Header for data within LifetimeExtendedCleanupStack.
642 struct LifetimeExtendedCleanupHeader {
643 /// The size of the following cleanup object.
644 unsigned Size;
645 /// The kind of cleanup to push: a value from the CleanupKind enumeration.
646 unsigned Kind : 31;
647 /// Whether this is a conditional cleanup.
648 unsigned IsConditional : 1;
649
650 size_t getSize() const { return Size; }
651 CleanupKind getKind() const { return (CleanupKind)Kind; }
652 bool isConditional() const { return IsConditional; }
653 };
654
655 /// i32s containing the indexes of the cleanup destinations.
656 Address NormalCleanupDest = Address::invalid();
657
658 unsigned NextCleanupDestIndex = 1;
659
660 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
661 llvm::BasicBlock *EHResumeBlock = nullptr;
662
663 /// The exception slot. All landing pads write the current exception pointer
664 /// into this alloca.
665 llvm::Value *ExceptionSlot = nullptr;
666
667 /// The selector slot. Under the MandatoryCleanup model, all landing pads
668 /// write the current selector value into this alloca.
669 llvm::AllocaInst *EHSelectorSlot = nullptr;
670
671 /// A stack of exception code slots. Entering an __except block pushes a slot
672 /// on the stack and leaving pops one. The __exception_code() intrinsic loads
673 /// a value from the top of the stack.
674 SmallVector<Address, 1> SEHCodeSlotStack;
675
676 /// Value returned by __exception_info intrinsic.
677 llvm::Value *SEHInfo = nullptr;
678
679 /// Emits a landing pad for the current EH stack.
680 llvm::BasicBlock *EmitLandingPad();
681
682 llvm::BasicBlock *getInvokeDestImpl();
683
684 /// Parent loop-based directive for scan directive.
685 const OMPExecutableDirective *OMPParentLoopDirectiveForScan = nullptr;
686 llvm::BasicBlock *OMPBeforeScanBlock = nullptr;
687 llvm::BasicBlock *OMPAfterScanBlock = nullptr;
688 llvm::BasicBlock *OMPScanExitBlock = nullptr;
689 llvm::BasicBlock *OMPScanDispatch = nullptr;
690 bool OMPFirstScanLoop = false;
691
692 /// Manages parent directive for scan directives.
693 class ParentLoopDirectiveForScanRegion {
694 CodeGenFunction &CGF;
695 const OMPExecutableDirective *ParentLoopDirectiveForScan;
696
697 public:
698 ParentLoopDirectiveForScanRegion(
699 CodeGenFunction &CGF,
700 const OMPExecutableDirective &ParentLoopDirectiveForScan)
701 : CGF(CGF),
702 ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) {
703 CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan;
704 }
705 ~ParentLoopDirectiveForScanRegion() {
706 CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan;
707 }
708 };
709
710 template <class T>
711 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
712 return DominatingValue<T>::save(*this, value);
713 }
714
715 class CGFPOptionsRAII {
716 public:
717 CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures);
718 CGFPOptionsRAII(CodeGenFunction &CGF, const Expr *E);
719 ~CGFPOptionsRAII();
720
721 private:
722 void ConstructorHelper(FPOptions FPFeatures);
723 CodeGenFunction &CGF;
724 FPOptions OldFPFeatures;
725 llvm::fp::ExceptionBehavior OldExcept;
726 llvm::RoundingMode OldRounding;
727 std::optional<CGBuilderTy::FastMathFlagGuard> FMFGuard;
728 };
729 FPOptions CurFPFeatures;
730
731 public:
732 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
733 /// rethrows.
734 SmallVector<llvm::Value*, 8> ObjCEHValueStack;
735
736 /// A class controlling the emission of a finally block.
737 class FinallyInfo {
738 /// Where the catchall's edge through the cleanup should go.
739 JumpDest RethrowDest;
740
741 /// A function to call to enter the catch.
742 llvm::FunctionCallee BeginCatchFn;
743
744 /// An i1 variable indicating whether or not the @finally is
745 /// running for an exception.
746 llvm::AllocaInst *ForEHVar;
747
748 /// An i8* variable into which the exception pointer to rethrow
749 /// has been saved.
750 llvm::AllocaInst *SavedExnVar;
751
752 public:
753 void enter(CodeGenFunction &CGF, const Stmt *Finally,
754 llvm::FunctionCallee beginCatchFn,
755 llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
756 void exit(CodeGenFunction &CGF);
757 };
758
759 /// Returns true inside SEH __try blocks.
760 bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
761
762 /// Returns true while emitting a cleanuppad.
763 bool isCleanupPadScope() const {
764 return CurrentFuncletPad && isa<llvm::CleanupPadInst>(CurrentFuncletPad);
765 }
766
767 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
768 /// current full-expression. Safe against the possibility that
769 /// we're currently inside a conditionally-evaluated expression.
770 template <class T, class... As>
771 void pushFullExprCleanup(CleanupKind kind, As... A) {
772 // If we're not in a conditional branch, or if none of the
773 // arguments requires saving, then use the unconditional cleanup.
774 if (!isInConditionalBranch())
775 return EHStack.pushCleanup<T>(kind, A...);
776
777 // Stash values in a tuple so we can guarantee the order of saves.
778 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
779 SavedTuple Saved{saveValueInCond(A)...};
780
781 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
782 EHStack.pushCleanupTuple<CleanupType>(kind, Saved);
783 initFullExprCleanup();
784 }
785
786 /// Queue a cleanup to be pushed after finishing the current full-expression,
787 /// potentially with an active flag.
788 template <class T, class... As>
789 void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) {
790 if (!isInConditionalBranch())
791 return pushCleanupAfterFullExprWithActiveFlag<T>(Kind, Address::invalid(),
792 A...);
793
794 Address ActiveFlag = createCleanupActiveFlag();
795 assert(!DominatingValue<Address>::needsSaving(ActiveFlag) &&
796 "cleanup active flag should never need saving");
797
798 typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
799 SavedTuple Saved{saveValueInCond(A)...};
800
801 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
802 pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved);
803 }
804
805 template <class T, class... As>
806 void pushCleanupAfterFullExprWithActiveFlag(CleanupKind Kind,
807 Address ActiveFlag, As... A) {
808 LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
809 ActiveFlag.isValid()};
810
811 size_t OldSize = LifetimeExtendedCleanupStack.size();
812 LifetimeExtendedCleanupStack.resize(
813 LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
814 (Header.IsConditional ? sizeof(ActiveFlag) : 0));
815
816 static_assert(sizeof(Header) % alignof(T) == 0,
817 "Cleanup will be allocated on misaligned address");
818 char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
819 new (Buffer) LifetimeExtendedCleanupHeader(Header);
820 new (Buffer + sizeof(Header)) T(A...);
821 if (Header.IsConditional)
822 new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag);
823 }
824
825 /// Set up the last cleanup that was pushed as a conditional
826 /// full-expression cleanup.
827 void initFullExprCleanup() {
828 initFullExprCleanupWithFlag(createCleanupActiveFlag());
829 }
830
831 void initFullExprCleanupWithFlag(Address ActiveFlag);
832 Address createCleanupActiveFlag();
833
834 /// PushDestructorCleanup - Push a cleanup to call the
835 /// complete-object destructor of an object of the given type at the
836 /// given address. Does nothing if T is not a C++ class type with a
837 /// non-trivial destructor.
838 void PushDestructorCleanup(QualType T, Address Addr);
839
840 /// PushDestructorCleanup - Push a cleanup to call the
841 /// complete-object variant of the given destructor on the object at
842 /// the given address.
843 void PushDestructorCleanup(const CXXDestructorDecl *Dtor, QualType T,
844 Address Addr);
845
846 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
847 /// process all branch fixups.
848 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
849
850 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
851 /// The block cannot be reactivated. Pops it if it's the top of the
852 /// stack.
853 ///
854 /// \param DominatingIP - An instruction which is known to
855 /// dominate the current IP (if set) and which lies along
856 /// all paths of execution between the current IP and the
857 /// the point at which the cleanup comes into scope.
858 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup,
859 llvm::Instruction *DominatingIP);
860
861 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
862 /// Cannot be used to resurrect a deactivated cleanup.
863 ///
864 /// \param DominatingIP - An instruction which is known to
865 /// dominate the current IP (if set) and which lies along
866 /// all paths of execution between the current IP and the
867 /// the point at which the cleanup comes into scope.
868 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup,
869 llvm::Instruction *DominatingIP);
870
871 /// Enters a new scope for capturing cleanups, all of which
872 /// will be executed once the scope is exited.
873 class RunCleanupsScope {
874 EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth;
875 size_t LifetimeExtendedCleanupStackSize;
876 bool OldDidCallStackSave;
877 protected:
878 bool PerformCleanup;
879 private:
880
881 RunCleanupsScope(const RunCleanupsScope &) = delete;
882 void operator=(const RunCleanupsScope &) = delete;
883
884 protected:
885 CodeGenFunction& CGF;
886
887 public:
888 /// Enter a new cleanup scope.
889 explicit RunCleanupsScope(CodeGenFunction &CGF)
890 : PerformCleanup(true), CGF(CGF)
891 {
892 CleanupStackDepth = CGF.EHStack.stable_begin();
893 LifetimeExtendedCleanupStackSize =
894 CGF.LifetimeExtendedCleanupStack.size();
895 OldDidCallStackSave = CGF.DidCallStackSave;
896 CGF.DidCallStackSave = false;
897 OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth;
898 CGF.CurrentCleanupScopeDepth = CleanupStackDepth;
899 }
900
901 /// Exit this cleanup scope, emitting any accumulated cleanups.
902 ~RunCleanupsScope() {
903 if (PerformCleanup)
904 ForceCleanup();
905 }
906
907 /// Determine whether this scope requires any cleanups.
908 bool requiresCleanups() const {
909 return CGF.EHStack.stable_begin() != CleanupStackDepth;
910 }
911
912 /// Force the emission of cleanups now, instead of waiting
913 /// until this object is destroyed.
914 /// \param ValuesToReload - A list of values that need to be available at
915 /// the insertion point after cleanup emission. If cleanup emission created
916 /// a shared cleanup block, these value pointers will be rewritten.
917 /// Otherwise, they not will be modified.
918 void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
919 assert(PerformCleanup && "Already forced cleanup");
920 CGF.DidCallStackSave = OldDidCallStackSave;
921 CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
922 ValuesToReload);
923 PerformCleanup = false;
924 CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
925 }
926 };
927
928 // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
929 EHScopeStack::stable_iterator CurrentCleanupScopeDepth =
930 EHScopeStack::stable_end();
931
932 class LexicalScope : public RunCleanupsScope {
933 SourceRange Range;
934 SmallVector<const LabelDecl*, 4> Labels;
935 LexicalScope *ParentScope;
936
937 LexicalScope(const LexicalScope &) = delete;
938 void operator=(const LexicalScope &) = delete;
939
940 public:
941 /// Enter a new cleanup scope.
942 explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range)
943 : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) {
944 CGF.CurLexicalScope = this;
945 if (CGDebugInfo *DI = CGF.getDebugInfo())
946 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
947 }
948
949 void addLabel(const LabelDecl *label) {
950 assert(PerformCleanup && "adding label to dead scope?");
951 Labels.push_back(label);
952 }
953
954 /// Exit this cleanup scope, emitting any accumulated
955 /// cleanups.
956 ~LexicalScope() {
957 if (CGDebugInfo *DI = CGF.getDebugInfo())
958 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
959
960 // If we should perform a cleanup, force them now. Note that
961 // this ends the cleanup scope before rescoping any labels.
962 if (PerformCleanup) {
963 ApplyDebugLocation DL(CGF, Range.getEnd());
964 ForceCleanup();
965 }
966 }
967
968 /// Force the emission of cleanups now, instead of waiting
969 /// until this object is destroyed.
970 void ForceCleanup() {
971 CGF.CurLexicalScope = ParentScope;
972 RunCleanupsScope::ForceCleanup();
973
974 if (!Labels.empty())
975 rescopeLabels();
976 }
977
978 bool hasLabels() const {
979 return !Labels.empty();
980 }
981
982 void rescopeLabels();
983 };
984
985 typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
986
987 /// The class used to assign some variables some temporarily addresses.
988 class OMPMapVars {
989 DeclMapTy SavedLocals;
990 DeclMapTy SavedTempAddresses;
991 OMPMapVars(const OMPMapVars &) = delete;
992 void operator=(const OMPMapVars &) = delete;
993
994 public:
995 explicit OMPMapVars() = default;
996 ~OMPMapVars() {
997 assert(SavedLocals.empty() && "Did not restored original addresses.");
998 };
999
1000 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
1001 /// function \p CGF.
1002 /// \return true if at least one variable was set already, false otherwise.
1003 bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD,
1004 Address TempAddr) {
1005 LocalVD = LocalVD->getCanonicalDecl();
1006 // Only save it once.
1007 if (SavedLocals.count(LocalVD)) return false;
1008
1009 // Copy the existing local entry to SavedLocals.
1010 auto it = CGF.LocalDeclMap.find(LocalVD);
1011 if (it != CGF.LocalDeclMap.end())
1012 SavedLocals.try_emplace(LocalVD, it->second);
1013 else
1014 SavedLocals.try_emplace(LocalVD, Address::invalid());
1015
1016 // Generate the private entry.
1017 QualType VarTy = LocalVD->getType();
1018 if (VarTy->isReferenceType()) {
1019 Address Temp = CGF.CreateMemTemp(VarTy);
1020 CGF.Builder.CreateStore(TempAddr.getPointer(), Temp);
1021 TempAddr = Temp;
1022 }
1023 SavedTempAddresses.try_emplace(LocalVD, TempAddr);
1024
1025 return true;
1026 }
1027
1028 /// Applies new addresses to the list of the variables.
1029 /// \return true if at least one variable is using new address, false
1030 /// otherwise.
1031 bool apply(CodeGenFunction &CGF) {
1032 copyInto(SavedTempAddresses, CGF.LocalDeclMap);
1033 SavedTempAddresses.clear();
1034 return !SavedLocals.empty();
1035 }
1036
1037 /// Restores original addresses of the variables.
1038 void restore(CodeGenFunction &CGF) {
1039 if (!SavedLocals.empty()) {
1040 copyInto(SavedLocals, CGF.LocalDeclMap);
1041 SavedLocals.clear();
1042 }
1043 }
1044
1045 private:
1046 /// Copy all the entries in the source map over the corresponding
1047 /// entries in the destination, which must exist.
1048 static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) {
1049 for (auto &Pair : Src) {
1050 if (!Pair.second.isValid()) {
1051 Dest.erase(Pair.first);
1052 continue;
1053 }
1054
1055 auto I = Dest.find(Pair.first);
1056 if (I != Dest.end())
1057 I->second = Pair.second;
1058 else
1059 Dest.insert(Pair);
1060 }
1061 }
1062 };
1063
1064 /// The scope used to remap some variables as private in the OpenMP loop body
1065 /// (or other captured region emitted without outlining), and to restore old
1066 /// vars back on exit.
1067 class OMPPrivateScope : public RunCleanupsScope {
1068 OMPMapVars MappedVars;
1069 OMPPrivateScope(const OMPPrivateScope &) = delete;
1070 void operator=(const OMPPrivateScope &) = delete;
1071
1072 public:
1073 /// Enter a new OpenMP private scope.
1074 explicit OMPPrivateScope(CodeGenFunction &CGF) : RunCleanupsScope(CGF) {}
1075
1076 /// Registers \p LocalVD variable as a private with \p Addr as the address
1077 /// of the corresponding private variable. \p
1078 /// PrivateGen is the address of the generated private variable.
1079 /// \return true if the variable is registered as private, false if it has
1080 /// been privatized already.
1081 bool addPrivate(const VarDecl *LocalVD, Address Addr) {
1082 assert(PerformCleanup && "adding private to dead scope");
1083 return MappedVars.setVarAddr(CGF, LocalVD, Addr);
1084 }
1085
1086 /// Privatizes local variables previously registered as private.
1087 /// Registration is separate from the actual privatization to allow
1088 /// initializers use values of the original variables, not the private one.
1089 /// This is important, for example, if the private variable is a class
1090 /// variable initialized by a constructor that references other private
1091 /// variables. But at initialization original variables must be used, not
1092 /// private copies.
1093 /// \return true if at least one variable was privatized, false otherwise.
1094 bool Privatize() { return MappedVars.apply(CGF); }
1095
1096 void ForceCleanup() {
1097 RunCleanupsScope::ForceCleanup();
1098 restoreMap();
1099 }
1100
1101 /// Exit scope - all the mapped variables are restored.
1102 ~OMPPrivateScope() {
1103 if (PerformCleanup)
1104 ForceCleanup();
1105 }
1106
1107 /// Checks if the global variable is captured in current function.
1108 bool isGlobalVarCaptured(const VarDecl *VD) const {
1109 VD = VD->getCanonicalDecl();
1110 return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1111 }
1112
1113 /// Restore all mapped variables w/o clean up. This is usefully when we want
1114 /// to reference the original variables but don't want the clean up because
1115 /// that could emit lifetime end too early, causing backend issue #56913.
1116 void restoreMap() { MappedVars.restore(CGF); }
1117 };
1118
1119 /// Save/restore original map of previously emitted local vars in case when we
1120 /// need to duplicate emission of the same code several times in the same
1121 /// function for OpenMP code.
1122 class OMPLocalDeclMapRAII {
1123 CodeGenFunction &CGF;
1124 DeclMapTy SavedMap;
1125
1126 public:
1127 OMPLocalDeclMapRAII(CodeGenFunction &CGF)
1128 : CGF(CGF), SavedMap(CGF.LocalDeclMap) {}
1129 ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); }
1130 };
1131
1132 /// Takes the old cleanup stack size and emits the cleanup blocks
1133 /// that have been added.
1134 void
1135 PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize,
1136 std::initializer_list<llvm::Value **> ValuesToReload = {});
1137
1138 /// Takes the old cleanup stack size and emits the cleanup blocks
1139 /// that have been added, then adds all lifetime-extended cleanups from
1140 /// the given position to the stack.
1141 void
1142 PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize,
1143 size_t OldLifetimeExtendedStackSize,
1144 std::initializer_list<llvm::Value **> ValuesToReload = {});
1145
1146 void ResolveBranchFixups(llvm::BasicBlock *Target);
1147
1148 /// The given basic block lies in the current EH scope, but may be a
1149 /// target of a potentially scope-crossing jump; get a stable handle
1150 /// to which we can perform this jump later.
1151 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
1152 return JumpDest(Target,
1153 EHStack.getInnermostNormalCleanup(),
1154 NextCleanupDestIndex++);
1155 }
1156
1157 /// The given basic block lies in the current EH scope, but may be a
1158 /// target of a potentially scope-crossing jump; get a stable handle
1159 /// to which we can perform this jump later.
1160 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
1161 return getJumpDestInCurrentScope(createBasicBlock(Name));
1162 }
1163
1164 /// EmitBranchThroughCleanup - Emit a branch from the current insert
1165 /// block through the normal cleanup handling code (if any) and then
1166 /// on to \arg Dest.
1167 void EmitBranchThroughCleanup(JumpDest Dest);
1168
1169 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1170 /// specified destination obviously has no cleanups to run. 'false' is always
1171 /// a conservatively correct answer for this method.
1172 bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const;
1173
1174 /// popCatchScope - Pops the catch scope at the top of the EHScope
1175 /// stack, emitting any required code (other than the catch handlers
1176 /// themselves).
1177 void popCatchScope();
1178
1179 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
1180 llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope);
1181 llvm::BasicBlock *
1182 getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope);
1183
1184 /// An object to manage conditionally-evaluated expressions.
1185 class ConditionalEvaluation {
1186 llvm::BasicBlock *StartBB;
1187
1188 public:
1189 ConditionalEvaluation(CodeGenFunction &CGF)
1190 : StartBB(CGF.Builder.GetInsertBlock()) {}
1191
1192 void begin(CodeGenFunction &CGF) {
1193 assert(CGF.OutermostConditional != this);
1194 if (!CGF.OutermostConditional)
1195 CGF.OutermostConditional = this;
1196 }
1197
1198 void end(CodeGenFunction &CGF) {
1199 assert(CGF.OutermostConditional != nullptr);
1200 if (CGF.OutermostConditional == this)
1201 CGF.OutermostConditional = nullptr;
1202 }
1203
1204 /// Returns a block which will be executed prior to each
1205 /// evaluation of the conditional code.
1206 llvm::BasicBlock *getStartingBlock() const {
1207 return StartBB;
1208 }
1209 };
1210
1211 /// isInConditionalBranch - Return true if we're currently emitting
1212 /// one branch or the other of a conditional expression.
1213 bool isInConditionalBranch() const { return OutermostConditional != nullptr; }
1214
1215 void setBeforeOutermostConditional(llvm::Value *value, Address addr) {
1216 assert(isInConditionalBranch());
1217 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1218 auto store = new llvm::StoreInst(value, addr.getPointer(), &block->back());
1219 store->setAlignment(addr.getAlignment().getAsAlign());
1220 }
1221
1222 /// An RAII object to record that we're evaluating a statement
1223 /// expression.
1224 class StmtExprEvaluation {
1225 CodeGenFunction &CGF;
1226
1227 /// We have to save the outermost conditional: cleanups in a
1228 /// statement expression aren't conditional just because the
1229 /// StmtExpr is.
1230 ConditionalEvaluation *SavedOutermostConditional;
1231
1232 public:
1233 StmtExprEvaluation(CodeGenFunction &CGF)
1234 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1235 CGF.OutermostConditional = nullptr;
1236 }
1237
1238 ~StmtExprEvaluation() {
1239 CGF.OutermostConditional = SavedOutermostConditional;
1240 CGF.EnsureInsertPoint();
1241 }
1242 };
1243
1244 /// An object which temporarily prevents a value from being
1245 /// destroyed by aggressive peephole optimizations that assume that
1246 /// all uses of a value have been realized in the IR.
1247 class PeepholeProtection {
1248 llvm::Instruction *Inst;
1249 friend class CodeGenFunction;
1250
1251 public:
1252 PeepholeProtection() : Inst(nullptr) {}
1253 };
1254
1255 /// A non-RAII class containing all the information about a bound
1256 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
1257 /// this which makes individual mappings very simple; using this
1258 /// class directly is useful when you have a variable number of
1259 /// opaque values or don't want the RAII functionality for some
1260 /// reason.
1261 class OpaqueValueMappingData {
1262 const OpaqueValueExpr *OpaqueValue;
1263 bool BoundLValue;
1264 CodeGenFunction::PeepholeProtection Protection;
1265
1266 OpaqueValueMappingData(const OpaqueValueExpr *ov,
1267 bool boundLValue)
1268 : OpaqueValue(ov), BoundLValue(boundLValue) {}
1269 public:
1270 OpaqueValueMappingData() : OpaqueValue(nullptr) {}
1271
1272 static bool shouldBindAsLValue(const Expr *expr) {
1273 // gl-values should be bound as l-values for obvious reasons.
1274 // Records should be bound as l-values because IR generation
1275 // always keeps them in memory. Expressions of function type
1276 // act exactly like l-values but are formally required to be
1277 // r-values in C.
1278 return expr->isGLValue() ||
1279 expr->getType()->isFunctionType() ||
1280 hasAggregateEvaluationKind(expr->getType());
1281 }
1282
1283 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1284 const OpaqueValueExpr *ov,
1285 const Expr *e) {
1286 if (shouldBindAsLValue(ov))
1287 return bind(CGF, ov, CGF.EmitLValue(e));
1288 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1289 }
1290
1291 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1292 const OpaqueValueExpr *ov,
1293 const LValue &lv) {
1294 assert(shouldBindAsLValue(ov));
1295 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1296 return OpaqueValueMappingData(ov, true);
1297 }
1298
1299 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1300 const OpaqueValueExpr *ov,
1301 const RValue &rv) {
1302 assert(!shouldBindAsLValue(ov));
1303 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1304
1305 OpaqueValueMappingData data(ov, false);
1306
1307 // Work around an extremely aggressive peephole optimization in
1308 // EmitScalarConversion which assumes that all other uses of a
1309 // value are extant.
1310 data.Protection = CGF.protectFromPeepholes(rv);
1311
1312 return data;
1313 }
1314
1315 bool isValid() const { return OpaqueValue != nullptr; }
1316 void clear() { OpaqueValue = nullptr; }
1317
1318 void unbind(CodeGenFunction &CGF) {
1319 assert(OpaqueValue && "no data to unbind!");
1320
1321 if (BoundLValue) {
1322 CGF.OpaqueLValues.erase(OpaqueValue);
1323 } else {
1324 CGF.OpaqueRValues.erase(OpaqueValue);
1325 CGF.unprotectFromPeepholes(Protection);
1326 }
1327 }
1328 };
1329
1330 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1331 class OpaqueValueMapping {
1332 CodeGenFunction &CGF;
1333 OpaqueValueMappingData Data;
1334
1335 public:
1336 static bool shouldBindAsLValue(const Expr *expr) {
1337 return OpaqueValueMappingData::shouldBindAsLValue(expr);
1338 }
1339
1340 /// Build the opaque value mapping for the given conditional
1341 /// operator if it's the GNU ?: extension. This is a common
1342 /// enough pattern that the convenience operator is really
1343 /// helpful.
1344 ///
1345 OpaqueValueMapping(CodeGenFunction &CGF,
1346 const AbstractConditionalOperator *op) : CGF(CGF) {
1347 if (isa<ConditionalOperator>(op))
1348 // Leave Data empty.
1349 return;
1350
1351 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
1352 Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(),
1353 e->getCommon());
1354 }
1355
1356 /// Build the opaque value mapping for an OpaqueValueExpr whose source
1357 /// expression is set to the expression the OVE represents.
1358 OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *OV)
1359 : CGF(CGF) {
1360 if (OV) {
1361 assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1362 "for OVE with no source expression");
1363 Data = OpaqueValueMappingData::bind(CGF, OV, OV->getSourceExpr());
1364 }
1365 }
1366
1367 OpaqueValueMapping(CodeGenFunction &CGF,
1368 const OpaqueValueExpr *opaqueValue,
1369 LValue lvalue)
1370 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
1371 }
1372
1373 OpaqueValueMapping(CodeGenFunction &CGF,
1374 const OpaqueValueExpr *opaqueValue,
1375 RValue rvalue)
1376 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
1377 }
1378
1379 void pop() {
1380 Data.unbind(CGF);
1381 Data.clear();
1382 }
1383
1384 ~OpaqueValueMapping() {
1385 if (Data.isValid()) Data.unbind(CGF);
1386 }
1387 };
1388
1389 private:
1390 CGDebugInfo *DebugInfo;
1391 /// Used to create unique names for artificial VLA size debug info variables.
1392 unsigned VLAExprCounter = 0;
1393 bool DisableDebugInfo = false;
1394
1395 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1396 /// calling llvm.stacksave for multiple VLAs in the same scope.
1397 bool DidCallStackSave = false;
1398
1399 /// IndirectBranch - The first time an indirect goto is seen we create a block
1400 /// with an indirect branch. Every time we see the address of a label taken,
1401 /// we add the label to the indirect goto. Every subsequent indirect goto is
1402 /// codegen'd as a jump to the IndirectBranch's basic block.
1403 llvm::IndirectBrInst *IndirectBranch = nullptr;
1404
1405 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1406 /// decls.
1407 DeclMapTy LocalDeclMap;
1408
1409 // Keep track of the cleanups for callee-destructed parameters pushed to the
1410 // cleanup stack so that they can be deactivated later.
1411 llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
1412 CalleeDestructedParamCleanups;
1413
1414 /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1415 /// will contain a mapping from said ParmVarDecl to its implicit "object_size"
1416 /// parameter.
1417 llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2>
1418 SizeArguments;
1419
1420 /// Track escaped local variables with auto storage. Used during SEH
1421 /// outlining to produce a call to llvm.localescape.
1422 llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
1423
1424 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1425 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
1426
1427 // BreakContinueStack - This keeps track of where break and continue
1428 // statements should jump to.
1429 struct BreakContinue {
1430 BreakContinue(JumpDest Break, JumpDest Continue)
1431 : BreakBlock(Break), ContinueBlock(Continue) {}
1432
1433 JumpDest BreakBlock;
1434 JumpDest ContinueBlock;
1435 };
1436 SmallVector<BreakContinue, 8> BreakContinueStack;
1437
1438 /// Handles cancellation exit points in OpenMP-related constructs.
1439 class OpenMPCancelExitStack {
1440 /// Tracks cancellation exit point and join point for cancel-related exit
1441 /// and normal exit.
1442 struct CancelExit {
1443 CancelExit() = default;
1444 CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
1445 JumpDest ContBlock)
1446 : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
1447 OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
1448 /// true if the exit block has been emitted already by the special
1449 /// emitExit() call, false if the default codegen is used.
1450 bool HasBeenEmitted = false;
1451 JumpDest ExitBlock;
1452 JumpDest ContBlock;
1453 };
1454
1455 SmallVector<CancelExit, 8> Stack;
1456
1457 public:
1458 OpenMPCancelExitStack() : Stack(1) {}
1459 ~OpenMPCancelExitStack() = default;
1460 /// Fetches the exit block for the current OpenMP construct.
1461 JumpDest getExitBlock() const { return Stack.back().ExitBlock; }
1462 /// Emits exit block with special codegen procedure specific for the related
1463 /// OpenMP construct + emits code for normal construct cleanup.
1464 void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
1465 const llvm::function_ref<void(CodeGenFunction &)> CodeGen) {
1466 if (Stack.back().Kind == Kind && getExitBlock().isValid()) {
1467 assert(CGF.getOMPCancelDestination(Kind).isValid());
1468 assert(CGF.HaveInsertPoint());
1469 assert(!Stack.back().HasBeenEmitted);
1470 auto IP = CGF.Builder.saveAndClearIP();
1471 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1472 CodeGen(CGF);
1473 CGF.EmitBranch(Stack.back().ContBlock.getBlock());
1474 CGF.Builder.restoreIP(IP);
1475 Stack.back().HasBeenEmitted = true;
1476 }
1477 CodeGen(CGF);
1478 }
1479 /// Enter the cancel supporting \a Kind construct.
1480 /// \param Kind OpenMP directive that supports cancel constructs.
1481 /// \param HasCancel true, if the construct has inner cancel directive,
1482 /// false otherwise.
1483 void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) {
1484 Stack.push_back({Kind,
1485 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1486 : JumpDest(),
1487 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1488 : JumpDest()});
1489 }
1490 /// Emits default exit point for the cancel construct (if the special one
1491 /// has not be used) + join point for cancel/normal exits.
1492 void exit(CodeGenFunction &CGF) {
1493 if (getExitBlock().isValid()) {
1494 assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid());
1495 bool HaveIP = CGF.HaveInsertPoint();
1496 if (!Stack.back().HasBeenEmitted) {
1497 if (HaveIP)
1498 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1499 CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1500 CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1501 }
1502 CGF.EmitBlock(Stack.back().ContBlock.getBlock());
1503 if (!HaveIP) {
1504 CGF.Builder.CreateUnreachable();
1505 CGF.Builder.ClearInsertionPoint();
1506 }
1507 }
1508 Stack.pop_back();
1509 }
1510 };
1511 OpenMPCancelExitStack OMPCancelStack;
1512
1513 /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
1514 llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
1515 Stmt::Likelihood LH);
1516
1517 CodeGenPGO PGO;
1518
1519 /// Calculate branch weights appropriate for PGO data
1520 llvm::MDNode *createProfileWeights(uint64_t TrueCount,
1521 uint64_t FalseCount) const;
1522 llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
1523 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1524 uint64_t LoopCount) const;
1525
1526 public:
1527 /// Increment the profiler's counter for the given statement by \p StepV.
1528 /// If \p StepV is null, the default increment is 1.
1529 void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
1530 if (CGM.getCodeGenOpts().hasProfileClangInstr() &&
1531 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile) &&
1532 !CurFn->hasFnAttribute(llvm::Attribute::SkipProfile))
1533 PGO.emitCounterIncrement(Builder, S, StepV);
1534 PGO.setCurrentStmt(S);
1535 }
1536
1537 /// Get the profiler's count for the given statement.
1538 uint64_t getProfileCount(const Stmt *S) {
1539 return PGO.getStmtCount(S).value_or(0);
1540 }
1541
1542 /// Set the profiler's current count.
1543 void setCurrentProfileCount(uint64_t Count) {
1544 PGO.setCurrentRegionCount(Count);
1545 }
1546
1547 /// Get the profiler's current count. This is generally the count for the most
1548 /// recently incremented counter.
1549 uint64_t getCurrentProfileCount() {
1550 return PGO.getCurrentRegionCount();
1551 }
1552
1553 private:
1554
1555 /// SwitchInsn - This is nearest current switch instruction. It is null if
1556 /// current context is not in a switch.
1557 llvm::SwitchInst *SwitchInsn = nullptr;
1558 /// The branch weights of SwitchInsn when doing instrumentation based PGO.
1559 SmallVector<uint64_t, 16> *SwitchWeights = nullptr;
1560
1561 /// The likelihood attributes of the SwitchCase.
1562 SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr;
1563
1564 /// CaseRangeBlock - This block holds if condition check for last case
1565 /// statement range in current switch instruction.
1566 llvm::BasicBlock *CaseRangeBlock = nullptr;
1567
1568 /// OpaqueLValues - Keeps track of the current set of opaque value
1569 /// expressions.
1570 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1571 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1572
1573 // VLASizeMap - This keeps track of the associated size for each VLA type.
1574 // We track this by the size expression rather than the type itself because
1575 // in certain situations, like a const qualifier applied to an VLA typedef,
1576 // multiple VLA types can share the same size expression.
1577 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1578 // enter/leave scopes.
1579 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
1580
1581 /// A block containing a single 'unreachable' instruction. Created
1582 /// lazily by getUnreachableBlock().
1583 llvm::BasicBlock *UnreachableBlock = nullptr;
1584
1585 /// Counts of the number return expressions in the function.
1586 unsigned NumReturnExprs = 0;
1587
1588 /// Count the number of simple (constant) return expressions in the function.
1589 unsigned NumSimpleReturnExprs = 0;
1590
1591 /// The last regular (non-return) debug location (breakpoint) in the function.
1592 SourceLocation LastStopPoint;
1593
1594 public:
1595 /// Source location information about the default argument or member
1596 /// initializer expression we're evaluating, if any.
1597 CurrentSourceLocExprScope CurSourceLocExprScope;
1598 using SourceLocExprScopeGuard =
1599 CurrentSourceLocExprScope::SourceLocExprScopeGuard;
1600
1601 /// A scope within which we are constructing the fields of an object which
1602 /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use
1603 /// if we need to evaluate a CXXDefaultInitExpr within the evaluation.
1604 class FieldConstructionScope {
1605 public:
1606 FieldConstructionScope(CodeGenFunction &CGF, Address This)
1607 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1608 CGF.CXXDefaultInitExprThis = This;
1609 }
1610 ~FieldConstructionScope() {
1611 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1612 }
1613
1614 private:
1615 CodeGenFunction &CGF;
1616 Address OldCXXDefaultInitExprThis;
1617 };
1618
1619 /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
1620 /// is overridden to be the object under construction.
1621 class CXXDefaultInitExprScope {
1622 public:
1623 CXXDefaultInitExprScope(CodeGenFunction &CGF, const CXXDefaultInitExpr *E)
1624 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
1625 OldCXXThisAlignment(CGF.CXXThisAlignment),
1626 SourceLocScope(E, CGF.CurSourceLocExprScope) {
1627 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getPointer();
1628 CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
1629 }
1630 ~CXXDefaultInitExprScope() {
1631 CGF.CXXThisValue = OldCXXThisValue;
1632 CGF.CXXThisAlignment = OldCXXThisAlignment;
1633 }
1634
1635 public:
1636 CodeGenFunction &CGF;
1637 llvm::Value *OldCXXThisValue;
1638 CharUnits OldCXXThisAlignment;
1639 SourceLocExprScopeGuard SourceLocScope;
1640 };
1641
1642 struct CXXDefaultArgExprScope : SourceLocExprScopeGuard {
1643 CXXDefaultArgExprScope(CodeGenFunction &CGF, const CXXDefaultArgExpr *E)
1644 : SourceLocExprScopeGuard(E, CGF.CurSourceLocExprScope) {}
1645 };
1646
1647 /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
1648 /// current loop index is overridden.
1649 class ArrayInitLoopExprScope {
1650 public:
1651 ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index)
1652 : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {
1653 CGF.ArrayInitIndex = Index;
1654 }
1655 ~ArrayInitLoopExprScope() {
1656 CGF.ArrayInitIndex = OldArrayInitIndex;
1657 }
1658
1659 private:
1660 CodeGenFunction &CGF;
1661 llvm::Value *OldArrayInitIndex;
1662 };
1663
1664 class InlinedInheritingConstructorScope {
1665 public:
1666 InlinedInheritingConstructorScope(CodeGenFunction &CGF, GlobalDecl GD)
1667 : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl),
1668 OldCurCodeDecl(CGF.CurCodeDecl),
1669 OldCXXABIThisDecl(CGF.CXXABIThisDecl),
1670 OldCXXABIThisValue(CGF.CXXABIThisValue),
1671 OldCXXThisValue(CGF.CXXThisValue),
1672 OldCXXABIThisAlignment(CGF.CXXABIThisAlignment),
1673 OldCXXThisAlignment(CGF.CXXThisAlignment),
1674 OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy),
1675 OldCXXInheritedCtorInitExprArgs(
1676 std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1677 CGF.CurGD = GD;
1678 CGF.CurFuncDecl = CGF.CurCodeDecl =
1679 cast<CXXConstructorDecl>(GD.getDecl());
1680 CGF.CXXABIThisDecl = nullptr;
1681 CGF.CXXABIThisValue = nullptr;
1682 CGF.CXXThisValue = nullptr;
1683 CGF.CXXABIThisAlignment = CharUnits();
1684 CGF.CXXThisAlignment = CharUnits();
1685 CGF.ReturnValue = Address::invalid();
1686 CGF.FnRetTy = QualType();
1687 CGF.CXXInheritedCtorInitExprArgs.clear();
1688 }
1689 ~InlinedInheritingConstructorScope() {
1690 CGF.CurGD = OldCurGD;
1691 CGF.CurFuncDecl = OldCurFuncDecl;
1692 CGF.CurCodeDecl = OldCurCodeDecl;
1693 CGF.CXXABIThisDecl = OldCXXABIThisDecl;
1694 CGF.CXXABIThisValue = OldCXXABIThisValue;
1695 CGF.CXXThisValue = OldCXXThisValue;
1696 CGF.CXXABIThisAlignment = OldCXXABIThisAlignment;
1697 CGF.CXXThisAlignment = OldCXXThisAlignment;
1698 CGF.ReturnValue = OldReturnValue;
1699 CGF.FnRetTy = OldFnRetTy;
1700 CGF.CXXInheritedCtorInitExprArgs =
1701 std::move(OldCXXInheritedCtorInitExprArgs);
1702 }
1703
1704 private:
1705 CodeGenFunction &CGF;
1706 GlobalDecl OldCurGD;
1707 const Decl *OldCurFuncDecl;
1708 const Decl *OldCurCodeDecl;
1709 ImplicitParamDecl *OldCXXABIThisDecl;
1710 llvm::Value *OldCXXABIThisValue;
1711 llvm::Value *OldCXXThisValue;
1712 CharUnits OldCXXABIThisAlignment;
1713 CharUnits OldCXXThisAlignment;
1714 Address OldReturnValue;
1715 QualType OldFnRetTy;
1716 CallArgList OldCXXInheritedCtorInitExprArgs;
1717 };
1718
1719 // Helper class for the OpenMP IR Builder. Allows reusability of code used for
1720 // region body, and finalization codegen callbacks. This will class will also
1721 // contain privatization functions used by the privatization call backs
1722 //
1723 // TODO: this is temporary class for things that are being moved out of
1724 // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or
1725 // utility function for use with the OMPBuilder. Once that move to use the
1726 // OMPBuilder is done, everything here will either become part of CodeGenFunc.
1727 // directly, or a new helper class that will contain functions used by both
1728 // this and the OMPBuilder
1729
1730 struct OMPBuilderCBHelpers {
1731
1732 OMPBuilderCBHelpers() = delete;
1733 OMPBuilderCBHelpers(const OMPBuilderCBHelpers &) = delete;
1734 OMPBuilderCBHelpers &operator=(const OMPBuilderCBHelpers &) = delete;
1735
1736 using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
1737
1738 /// Cleanup action for allocate support.
1739 class OMPAllocateCleanupTy final : public EHScopeStack::Cleanup {
1740
1741 private:
1742 llvm::CallInst *RTLFnCI;
1743
1744 public:
1745 OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) {
1746 RLFnCI->removeFromParent();
1747 }
1748
1749 void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
1750 if (!CGF.HaveInsertPoint())
1751 return;
1752 CGF.Builder.Insert(RTLFnCI);
1753 }
1754 };
1755
1756 /// Returns address of the threadprivate variable for the current
1757 /// thread. This Also create any necessary OMP runtime calls.
1758 ///
1759 /// \param VD VarDecl for Threadprivate variable.
1760 /// \param VDAddr Address of the Vardecl
1761 /// \param Loc The location where the barrier directive was encountered
1762 static Address getAddrOfThreadPrivate(CodeGenFunction &CGF,
1763 const VarDecl *VD, Address VDAddr,
1764 SourceLocation Loc);
1765
1766 /// Gets the OpenMP-specific address of the local variable /p VD.
1767 static Address getAddressOfLocalVariable(CodeGenFunction &CGF,
1768 const VarDecl *VD);
1769 /// Get the platform-specific name separator.
1770 /// \param Parts different parts of the final name that needs separation
1771 /// \param FirstSeparator First separator used between the initial two
1772 /// parts of the name.
1773 /// \param Separator separator used between all of the rest consecutinve
1774 /// parts of the name
1775 static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
1776 StringRef FirstSeparator = ".",
1777 StringRef Separator = ".");
1778 /// Emit the Finalization for an OMP region
1779 /// \param CGF The Codegen function this belongs to
1780 /// \param IP Insertion point for generating the finalization code.
1781 static void FinalizeOMPRegion(CodeGenFunction &CGF, InsertPointTy IP) {
1782 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1783 assert(IP.getBlock()->end() != IP.getPoint() &&
1784 "OpenMP IR Builder should cause terminated block!");
1785
1786 llvm::BasicBlock *IPBB = IP.getBlock();
1787 llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1788 assert(DestBB && "Finalization block should have one successor!");
1789
1790 // erase and replace with cleanup branch.
1791 IPBB->getTerminator()->eraseFromParent();
1792 CGF.Builder.SetInsertPoint(IPBB);
1793 CodeGenFunction::JumpDest Dest = CGF.getJumpDestInCurrentScope(DestBB);
1794 CGF.EmitBranchThroughCleanup(Dest);
1795 }
1796
1797 /// Emit the body of an OMP region
1798 /// \param CGF The Codegen function this belongs to
1799 /// \param RegionBodyStmt The body statement for the OpenMP region being
1800 /// generated
1801 /// \param AllocaIP Where to insert alloca instructions
1802 /// \param CodeGenIP Where to insert the region code
1803 /// \param RegionName Name to be used for new blocks
1804 static void EmitOMPInlinedRegionBody(CodeGenFunction &CGF,
1805 const Stmt *RegionBodyStmt,
1806 InsertPointTy AllocaIP,
1807 InsertPointTy CodeGenIP,
1808 Twine RegionName);
1809
1810 static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP,
1811 llvm::BasicBlock &FiniBB, llvm::Function *Fn,
1812 ArrayRef<llvm::Value *> Args) {
1813 llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1814 if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1815 CodeGenIPBBTI->eraseFromParent();
1816
1817 CGF.Builder.SetInsertPoint(CodeGenIPBB);
1818
1819 if (Fn->doesNotThrow())
1820 CGF.EmitNounwindRuntimeCall(Fn, Args);
1821 else
1822 CGF.EmitRuntimeCall(Fn, Args);
1823
1824 if (CGF.Builder.saveIP().isSet())
1825 CGF.Builder.CreateBr(&FiniBB);
1826 }
1827
1828 /// Emit the body of an OMP region that will be outlined in
1829 /// OpenMPIRBuilder::finalize().
1830 /// \param CGF The Codegen function this belongs to
1831 /// \param RegionBodyStmt The body statement for the OpenMP region being
1832 /// generated
1833 /// \param AllocaIP Where to insert alloca instructions
1834 /// \param CodeGenIP Where to insert the region code
1835 /// \param RegionName Name to be used for new blocks
1836 static void EmitOMPOutlinedRegionBody(CodeGenFunction &CGF,
1837 const Stmt *RegionBodyStmt,
1838 InsertPointTy AllocaIP,
1839 InsertPointTy CodeGenIP,
1840 Twine RegionName);
1841
1842 /// RAII for preserving necessary info during Outlined region body codegen.
1843 class OutlinedRegionBodyRAII {
1844
1845 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
1846 CodeGenFunction::JumpDest OldReturnBlock;
1847 CodeGenFunction &CGF;
1848
1849 public:
1850 OutlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP,
1851 llvm::BasicBlock &RetBB)
1852 : CGF(cgf) {
1853 assert(AllocaIP.isSet() &&
1854 "Must specify Insertion point for allocas of outlined function");
1855 OldAllocaIP = CGF.AllocaInsertPt;
1856 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
1857
1858 OldReturnBlock = CGF.ReturnBlock;
1859 CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB);
1860 }
1861
1862 ~OutlinedRegionBodyRAII() {
1863 CGF.AllocaInsertPt = OldAllocaIP;
1864 CGF.ReturnBlock = OldReturnBlock;
1865 }
1866 };
1867
1868 /// RAII for preserving necessary info during inlined region body codegen.
1869 class InlinedRegionBodyRAII {
1870
1871 llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
1872 CodeGenFunction &CGF;
1873
1874 public:
1875 InlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP,
1876 llvm::BasicBlock &FiniBB)
1877 : CGF(cgf) {
1878 // Alloca insertion block should be in the entry block of the containing
1879 // function so it expects an empty AllocaIP in which case will reuse the
1880 // old alloca insertion point, or a new AllocaIP in the same block as
1881 // the old one
1882 assert((!AllocaIP.isSet() ||
1883 CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
1884 "Insertion point should be in the entry block of containing "
1885 "function!");
1886 OldAllocaIP = CGF.AllocaInsertPt;
1887 if (AllocaIP.isSet())
1888 CGF.AllocaInsertPt = &*AllocaIP.getPoint();
1889
1890 // TODO: Remove the call, after making sure the counter is not used by
1891 // the EHStack.
1892 // Since this is an inlined region, it should not modify the
1893 // ReturnBlock, and should reuse the one for the enclosing outlined
1894 // region. So, the JumpDest being return by the function is discarded
1895 (void)CGF.getJumpDestInCurrentScope(&FiniBB);
1896 }
1897
1898 ~InlinedRegionBodyRAII() { CGF.AllocaInsertPt = OldAllocaIP; }
1899 };
1900 };
1901
1902 private:
1903 /// CXXThisDecl - When generating code for a C++ member function,
1904 /// this will hold the implicit 'this' declaration.
1905 ImplicitParamDecl *CXXABIThisDecl = nullptr;
1906 llvm::Value *CXXABIThisValue = nullptr;
1907 llvm::Value *CXXThisValue = nullptr;
1908 CharUnits CXXABIThisAlignment;
1909 CharUnits CXXThisAlignment;
1910
1911 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
1912 /// this expression.
1913 Address CXXDefaultInitExprThis = Address::invalid();
1914
1915 /// The current array initialization index when evaluating an
1916 /// ArrayInitIndexExpr within an ArrayInitLoopExpr.
1917 llvm::Value *ArrayInitIndex = nullptr;
1918
1919 /// The values of function arguments to use when evaluating
1920 /// CXXInheritedCtorInitExprs within this context.
1921 CallArgList CXXInheritedCtorInitExprArgs;
1922
1923 /// CXXStructorImplicitParamDecl - When generating code for a constructor or
1924 /// destructor, this will hold the implicit argument (e.g. VTT).
1925 ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr;
1926 llvm::Value *CXXStructorImplicitParamValue = nullptr;
1927
1928 /// OutermostConditional - Points to the outermost active
1929 /// conditional control. This is used so that we know if a
1930 /// temporary should be destroyed conditionally.
1931 ConditionalEvaluation *OutermostConditional = nullptr;
1932
1933 /// The current lexical scope.
1934 LexicalScope *CurLexicalScope = nullptr;
1935
1936 /// The current source location that should be used for exception
1937 /// handling code.
1938 SourceLocation CurEHLocation;
1939
1940 /// BlockByrefInfos - For each __block variable, contains
1941 /// information about the layout of the variable.
1942 llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
1943
1944 /// Used by -fsanitize=nullability-return to determine whether the return
1945 /// value can be checked.
1946 llvm::Value *RetValNullabilityPrecondition = nullptr;
1947
1948 /// Check if -fsanitize=nullability-return instrumentation is required for
1949 /// this function.
1950 bool requiresReturnValueNullabilityCheck() const {
1951 return RetValNullabilityPrecondition;
1952 }
1953
1954 /// Used to store precise source locations for return statements by the
1955 /// runtime return value checks.
1956 Address ReturnLocation = Address::invalid();
1957
1958 /// Check if the return value of this function requires sanitization.
1959 bool requiresReturnValueCheck() const;
1960
1961 llvm::BasicBlock *TerminateLandingPad = nullptr;
1962 llvm::BasicBlock *TerminateHandler = nullptr;
1963 llvm::SmallVector<llvm::BasicBlock *, 2> TrapBBs;
1964
1965 /// Terminate funclets keyed by parent funclet pad.
1966 llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
1967
1968 /// Largest vector width used in ths function. Will be used to create a
1969 /// function attribute.
1970 unsigned LargestVectorWidth = 0;
1971
1972 /// True if we need emit the life-time markers. This is initially set in
1973 /// the constructor, but could be overwritten to true if this is a coroutine.
1974 bool ShouldEmitLifetimeMarkers;
1975
1976 /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
1977 /// the function metadata.
1978 void EmitKernelMetadata(const FunctionDecl *FD, llvm::Function *Fn);
1979
1980 public:
1981 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
1982 ~CodeGenFunction();
1983
1984 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
1985 ASTContext &getContext() const { return CGM.getContext(); }
1986 CGDebugInfo *getDebugInfo() {
1987 if (DisableDebugInfo)
1988 return nullptr;
1989 return DebugInfo;
1990 }
1991 void disableDebugInfo() { DisableDebugInfo = true; }
1992 void enableDebugInfo() { DisableDebugInfo = false; }
1993
1994 bool shouldUseFusedARCCalls() {
1995 return CGM.getCodeGenOpts().OptimizationLevel == 0;
1996 }
1997
1998 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
1999
2000 /// Returns a pointer to the function's exception object and selector slot,
2001 /// which is assigned in every landing pad.
2002 Address getExceptionSlot();
2003 Address getEHSelectorSlot();
2004
2005 /// Returns the contents of the function's exception object and selector
2006 /// slots.
2007 llvm::Value *getExceptionFromSlot();
2008 llvm::Value *getSelectorFromSlot();
2009
2010 Address getNormalCleanupDestSlot();
2011
2012 llvm::BasicBlock *getUnreachableBlock() {
2013 if (!UnreachableBlock) {
2014 UnreachableBlock = createBasicBlock("unreachable");
2015 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
2016 }
2017 return UnreachableBlock;
2018 }
2019
2020 llvm::BasicBlock *getInvokeDest() {
2021 if (!EHStack.requiresLandingPad()) return nullptr;
2022 return getInvokeDestImpl();
2023 }
2024
2025 bool currentFunctionUsesSEHTry() const { return !!CurSEHParent; }
2026
2027 const TargetInfo &getTarget() const { return Target; }
2028 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
2029 const TargetCodeGenInfo &getTargetHooks() const {
2030 return CGM.getTargetCodeGenInfo();
2031 }
2032
2033 //===--------------------------------------------------------------------===//
2034 // Cleanups
2035 //===--------------------------------------------------------------------===//
2036
2037 typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
2038
2039 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
2040 Address arrayEndPointer,
2041 QualType elementType,
2042 CharUnits elementAlignment,
2043 Destroyer *destroyer);
2044 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
2045 llvm::Value *arrayEnd,
2046 QualType elementType,
2047 CharUnits elementAlignment,
2048 Destroyer *destroyer);
2049
2050 void pushDestroy(QualType::DestructionKind dtorKind,
2051 Address addr, QualType type);
2052 void pushEHDestroy(QualType::DestructionKind dtorKind,
2053 Address addr, QualType type);
2054 void pushDestroy(CleanupKind kind, Address addr, QualType type,
2055 Destroyer *destroyer, bool useEHCleanupForArray);
2056 void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr,
2057 QualType type, Destroyer *destroyer,
2058 bool useEHCleanupForArray);
2059 void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
2060 llvm::Value *CompletePtr,
2061 QualType ElementType);
2062 void pushStackRestore(CleanupKind kind, Address SPMem);
2063 void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
2064 bool useEHCleanupForArray);
2065 llvm::Function *generateDestroyHelper(Address addr, QualType type,
2066 Destroyer *destroyer,
2067 bool useEHCleanupForArray,
2068 const VarDecl *VD);
2069 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
2070 QualType elementType, CharUnits elementAlign,
2071 Destroyer *destroyer,
2072 bool checkZeroLength, bool useEHCleanup);
2073
2074 Destroyer *getDestroyer(QualType::DestructionKind destructionKind);
2075
2076 /// Determines whether an EH cleanup is required to destroy a type
2077 /// with the given destruction kind.
2078 bool needsEHCleanup(QualType::DestructionKind kind) {
2079 switch (kind) {
2080 case QualType::DK_none:
2081 return false;
2082 case QualType::DK_cxx_destructor:
2083 case QualType::DK_objc_weak_lifetime:
2084 case QualType::DK_nontrivial_c_struct:
2085 return getLangOpts().Exceptions;
2086 case QualType::DK_objc_strong_lifetime:
2087 return getLangOpts().Exceptions &&
2088 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
2089 }
2090 llvm_unreachable("bad destruction kind");
2091 }
2092
2093 CleanupKind getCleanupKind(QualType::DestructionKind kind) {
2094 return (needsEHCleanup(kind) ? NormalAndEHCleanup : NormalCleanup);
2095 }
2096
2097 //===--------------------------------------------------------------------===//
2098 // Objective-C
2099 //===--------------------------------------------------------------------===//
2100
2101 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
2102
2103 void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD);
2104
2105 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2106 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
2107 const ObjCPropertyImplDecl *PID);
2108 void generateObjCGetterBody(const ObjCImplementationDecl *classImpl,
2109 const ObjCPropertyImplDecl *propImpl,
2110 const ObjCMethodDecl *GetterMothodDecl,
2111 llvm::Constant *AtomicHelperFn);
2112
2113 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
2114 ObjCMethodDecl *MD, bool ctor);
2115
2116 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2117 /// for the given property.
2118 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
2119 const ObjCPropertyImplDecl *PID);
2120 void generateObjCSetterBody(const ObjCImplementationDecl *classImpl,
2121 const ObjCPropertyImplDecl *propImpl,
2122 llvm::Constant *AtomicHelperFn);
2123
2124 //===--------------------------------------------------------------------===//
2125 // Block Bits
2126 //===--------------------------------------------------------------------===//
2127
2128 /// Emit block literal.
2129 /// \return an LLVM value which is a pointer to a struct which contains
2130 /// information about the block, including the block invoke function, the
2131 /// captured variables, etc.
2132 llvm::Value *EmitBlockLiteral(const BlockExpr *);
2133
2134 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
2135 const CGBlockInfo &Info,
2136 const DeclMapTy &ldm,
2137 bool IsLambdaConversionToBlock,
2138 bool BuildGlobalBlock);
2139
2140 /// Check if \p T is a C++ class that has a destructor that can throw.
2141 static bool cxxDestructorCanThrow(QualType T);
2142
2143 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
2144 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
2145 llvm::Constant *GenerateObjCAtomicSetterCopyHelperFunction(
2146 const ObjCPropertyImplDecl *PID);
2147 llvm::Constant *GenerateObjCAtomicGetterCopyHelperFunction(
2148 const ObjCPropertyImplDecl *PID);
2149 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
2150
2151 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
2152 bool CanThrow);
2153
2154 class AutoVarEmission;
2155
2156 void emitByrefStructureInit(const AutoVarEmission &emission);
2157
2158 /// Enter a cleanup to destroy a __block variable. Note that this
2159 /// cleanup should be a no-op if the variable hasn't left the stack
2160 /// yet; if a cleanup is required for the variable itself, that needs
2161 /// to be done externally.
2162 ///
2163 /// \param Kind Cleanup kind.
2164 ///
2165 /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block
2166 /// structure that will be passed to _Block_object_dispose. When
2167 /// \p LoadBlockVarAddr is true, the address of the field of the block
2168 /// structure that holds the address of the __block structure.
2169 ///
2170 /// \param Flags The flag that will be passed to _Block_object_dispose.
2171 ///
2172 /// \param LoadBlockVarAddr Indicates whether we need to emit a load from
2173 /// \p Addr to get the address of the __block structure.
2174 void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags,
2175 bool LoadBlockVarAddr, bool CanThrow);
2176
2177 void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum,
2178 llvm::Value *ptr);
2179
2180 Address LoadBlockStruct();
2181 Address GetAddrOfBlockDecl(const VarDecl *var);
2182
2183 /// BuildBlockByrefAddress - Computes the location of the
2184 /// data in a variable which is declared as __block.
2185 Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V,
2186 bool followForward = true);
2187 Address emitBlockByrefAddress(Address baseAddr,
2188 const BlockByrefInfo &info,
2189 bool followForward,
2190 const llvm::Twine &name);
2191
2192 const BlockByrefInfo &getBlockByrefInfo(const VarDecl *var);
2193
2194 QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args);
2195
2196 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
2197 const CGFunctionInfo &FnInfo);
2198
2199 /// Annotate the function with an attribute that disables TSan checking at
2200 /// runtime.
2201 void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
2202
2203 /// Emit code for the start of a function.
2204 /// \param Loc The location to be associated with the function.
2205 /// \param StartLoc The location of the function body.
2206 void StartFunction(GlobalDecl GD,
2207 QualType RetTy,
2208 llvm::Function *Fn,
2209 const CGFunctionInfo &FnInfo,
2210 const FunctionArgList &Args,
2211 SourceLocation Loc = SourceLocation(),
2212 SourceLocation StartLoc = SourceLocation());
2213
2214 static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor);
2215
2216 void EmitConstructorBody(FunctionArgList &Args);
2217 void EmitDestructorBody(FunctionArgList &Args);
2218 void emitImplicitAssignmentOperatorBody(FunctionArgList &Args);
2219 void EmitFunctionBody(const Stmt *Body);
2220 void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2221
2222 void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator,
2223 CallArgList &CallArgs);
2224 void EmitLambdaBlockInvokeBody();
2225 void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD);
2226 void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD);
2227 void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV) {
2228 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2229 }
2230 void EmitAsanPrologueOrEpilogue(bool Prologue);
2231
2232 /// Emit the unified return block, trying to avoid its emission when
2233 /// possible.
2234 /// \return The debug location of the user written return statement if the
2235 /// return block is avoided.
2236 llvm::DebugLoc EmitReturnBlock();
2237
2238 /// FinishFunction - Complete IR generation of the current function. It is
2239 /// legal to call this function even if there is no current insertion point.
2240 void FinishFunction(SourceLocation EndLoc=SourceLocation());
2241
2242 void StartThunk(llvm::Function *Fn, GlobalDecl GD,
2243 const CGFunctionInfo &FnInfo, bool IsUnprototyped);
2244
2245 void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
2246 const ThunkInfo *Thunk, bool IsUnprototyped);
2247
2248 void FinishThunk();
2249
2250 /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
2251 void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
2252 llvm::FunctionCallee Callee);
2253
2254 /// Generate a thunk for the given method.
2255 void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
2256 GlobalDecl GD, const ThunkInfo &Thunk,
2257 bool IsUnprototyped);
2258
2259 llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
2260 const CGFunctionInfo &FnInfo,
2261 GlobalDecl GD, const ThunkInfo &Thunk);
2262
2263 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
2264 FunctionArgList &Args);
2265
2266 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
2267
2268 /// Struct with all information about dynamic [sub]class needed to set vptr.
2269 struct VPtr {
2270 BaseSubobject Base;
2271 const CXXRecordDecl *NearestVBase;
2272 CharUnits OffsetFromNearestVBase;
2273 const CXXRecordDecl *VTableClass;
2274 };
2275
2276 /// Initialize the vtable pointer of the given subobject.
2277 void InitializeVTablePointer(const VPtr &vptr);
2278
2279 typedef llvm::SmallVector<VPtr, 4> VPtrsVector;
2280
2281 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
2282 VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass);
2283
2284 void getVTablePointers(BaseSubobject Base, const CXXRecordDecl *NearestVBase,
2285 CharUnits OffsetFromNearestVBase,
2286 bool BaseIsNonVirtualPrimaryBase,
2287 const CXXRecordDecl *VTableClass,
2288 VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs);
2289
2290 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
2291
2292 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2293 /// to by This.
2294 llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
2295 const CXXRecordDecl *VTableClass);
2296
2297 enum CFITypeCheckKind {
2298 CFITCK_VCall,
2299 CFITCK_NVCall,
2300 CFITCK_DerivedCast,
2301 CFITCK_UnrelatedCast,
2302 CFITCK_ICall,
2303 CFITCK_NVMFCall,
2304 CFITCK_VMFCall,
2305 };
2306
2307 /// Derived is the presumed address of an object of type T after a
2308 /// cast. If T is a polymorphic class type, emit a check that the virtual
2309 /// table for Derived belongs to a class derived from T.
2310 void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull,
2311 CFITypeCheckKind TCK, SourceLocation Loc);
2312
2313 /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2314 /// If vptr CFI is enabled, emit a check that VTable is valid.
2315 void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable,
2316 CFITypeCheckKind TCK, SourceLocation Loc);
2317
2318 /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2319 /// RD using llvm.type.test.
2320 void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable,
2321 CFITypeCheckKind TCK, SourceLocation Loc);
2322
2323 /// If whole-program virtual table optimization is enabled, emit an assumption
2324 /// that VTable is a member of RD's type identifier. Or, if vptr CFI is
2325 /// enabled, emit a check that VTable is a member of RD's type identifier.
2326 void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD,
2327 llvm::Value *VTable, SourceLocation Loc);
2328
2329 /// Returns whether we should perform a type checked load when loading a
2330 /// virtual function for virtual calls to members of RD. This is generally
2331 /// true when both vcall CFI and whole-program-vtables are enabled.
2332 bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD);
2333
2334 /// Emit a type checked load from the given vtable.
2335 llvm::Value *EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD,
2336 llvm::Value *VTable,
2337 llvm::Type *VTableTy,
2338 uint64_t VTableByteOffset);
2339
2340 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2341 /// given phase of destruction for a destructor. The end result
2342 /// should call destructors on members and base classes in reverse
2343 /// order of their construction.
2344 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
2345
2346 /// ShouldInstrumentFunction - Return true if the current function should be
2347 /// instrumented with __cyg_profile_func_* calls
2348 bool ShouldInstrumentFunction();
2349
2350 /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2351 /// should not be instrumented with sanitizers.
2352 bool ShouldSkipSanitizerInstrumentation();
2353
2354 /// ShouldXRayInstrument - Return true if the current function should be
2355 /// instrumented with XRay nop sleds.
2356 bool ShouldXRayInstrumentFunction() const;
2357
2358 /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2359 /// XRay custom event handling calls.
2360 bool AlwaysEmitXRayCustomEvents() const;
2361
2362 /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2363 /// XRay typed event handling calls.
2364 bool AlwaysEmitXRayTypedEvents() const;
2365
2366 /// Decode an address used in a function prologue, encoded by \c
2367 /// EncodeAddrForUseInPrologue.
2368 llvm::Value *DecodeAddrUsedInPrologue(llvm::Value *F,
2369 llvm::Value *EncodedAddr);
2370
2371 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2372 /// arguments for the given function. This is also responsible for naming the
2373 /// LLVM function arguments.
2374 void EmitFunctionProlog(const CGFunctionInfo &FI,
2375 llvm::Function *Fn,
2376 const FunctionArgList &Args);
2377
2378 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2379 /// given temporary.
2380 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc,
2381 SourceLocation EndLoc);
2382
2383 /// Emit a test that checks if the return value \p RV is nonnull.
2384 void EmitReturnValueCheck(llvm::Value *RV);
2385
2386 /// EmitStartEHSpec - Emit the start of the exception spec.
2387 void EmitStartEHSpec(const Decl *D);
2388
2389 /// EmitEndEHSpec - Emit the end of the exception spec.
2390 void EmitEndEHSpec(const Decl *D);
2391
2392 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2393 llvm::BasicBlock *getTerminateLandingPad();
2394
2395 /// getTerminateLandingPad - Return a cleanup funclet that just calls
2396 /// terminate.
2397 llvm::BasicBlock *getTerminateFunclet();
2398
2399 /// getTerminateHandler - Return a handler (not a landing pad, just
2400 /// a catch handler) that just calls terminate. This is used when
2401 /// a terminate scope encloses a try.
2402 llvm::BasicBlock *getTerminateHandler();
2403
2404 llvm::Type *ConvertTypeForMem(QualType T);
2405 llvm::Type *ConvertType(QualType T);
2406 llvm::Type *ConvertType(const TypeDecl *T) {
2407 return ConvertType(getContext().getTypeDeclType(T));
2408 }
2409
2410 /// LoadObjCSelf - Load the value of self. This function is only valid while
2411 /// generating code for an Objective-C method.
2412 llvm::Value *LoadObjCSelf();
2413
2414 /// TypeOfSelfObject - Return type of object that this self represents.
2415 QualType TypeOfSelfObject();
2416
2417 /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2418 static TypeEvaluationKind getEvaluationKind(QualType T);
2419
2420 static bool hasScalarEvaluationKind(QualType T) {
2421 return getEvaluationKind(T) == TEK_Scalar;
2422 }
2423
2424 static bool hasAggregateEvaluationKind(QualType T) {
2425 return getEvaluationKind(T) == TEK_Aggregate;
2426 }
2427
2428 /// createBasicBlock - Create an LLVM basic block.
2429 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
2430 llvm::Function *parent = nullptr,
2431 llvm::BasicBlock *before = nullptr) {
2432 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
2433 }
2434
2435 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2436 /// label maps to.
2437 JumpDest getJumpDestForLabel(const LabelDecl *S);
2438
2439 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2440 /// another basic block, simplify it. This assumes that no other code could
2441 /// potentially reference the basic block.
2442 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
2443
2444 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2445 /// adding a fall-through branch from the current insert block if
2446 /// necessary. It is legal to call this function even if there is no current
2447 /// insertion point.
2448 ///
2449 /// IsFinished - If true, indicates that the caller has finished emitting
2450 /// branches to the given block and does not expect to emit code into it. This
2451 /// means the block can be ignored if it is unreachable.
2452 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
2453
2454 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2455 /// near its uses, and leave the insertion point in it.
2456 void EmitBlockAfterUses(llvm::BasicBlock *BB);
2457
2458 /// EmitBranch - Emit a branch to the specified basic block from the current
2459 /// insert block, taking care to avoid creation of branches from dummy
2460 /// blocks. It is legal to call this function even if there is no current
2461 /// insertion point.
2462 ///
2463 /// This function clears the current insertion point. The caller should follow
2464 /// calls to this function with calls to Emit*Block prior to generation new
2465 /// code.
2466 void EmitBranch(llvm::BasicBlock *Block);
2467
2468 /// HaveInsertPoint - True if an insertion point is defined. If not, this
2469 /// indicates that the current code being emitted is unreachable.
2470 bool HaveInsertPoint() const {
2471 return Builder.GetInsertBlock() != nullptr;
2472 }
2473
2474 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2475 /// emitted IR has a place to go. Note that by definition, if this function
2476 /// creates a block then that block is unreachable; callers may do better to
2477 /// detect when no insertion point is defined and simply skip IR generation.
2478 void EnsureInsertPoint() {
2479 if (!HaveInsertPoint())
2480 EmitBlock(createBasicBlock());
2481 }
2482
2483 /// ErrorUnsupported - Print out an error that codegen doesn't support the
2484 /// specified stmt yet.
2485 void ErrorUnsupported(const Stmt *S, const char *Type);
2486
2487 //===--------------------------------------------------------------------===//
2488 // Helpers
2489 //===--------------------------------------------------------------------===//
2490
2491 LValue MakeAddrLValue(Address Addr, QualType T,
2492 AlignmentSource Source = AlignmentSource::Type) {
2493 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2494 CGM.getTBAAAccessInfo(T));
2495 }
2496
2497 LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo,
2498 TBAAAccessInfo TBAAInfo) {
2499 return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2500 }
2501
2502 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2503 AlignmentSource Source = AlignmentSource::Type) {
2504 Address Addr(V, ConvertTypeForMem(T), Alignment);
2505 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2506 CGM.getTBAAAccessInfo(T));
2507 }
2508
2509 LValue
2510 MakeAddrLValueWithoutTBAA(Address Addr, QualType T,
2511 AlignmentSource Source = AlignmentSource::Type) {
2512 return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2513 TBAAAccessInfo());
2514 }
2515
2516 LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T);
2517 LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T);
2518
2519 Address EmitLoadOfReference(LValue RefLVal,
2520 LValueBaseInfo *PointeeBaseInfo = nullptr,
2521 TBAAAccessInfo *PointeeTBAAInfo = nullptr);
2522 LValue EmitLoadOfReferenceLValue(LValue RefLVal);
2523 LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy,
2524 AlignmentSource Source =
2525 AlignmentSource::Type) {
2526 LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2527 CGM.getTBAAAccessInfo(RefTy));
2528 return EmitLoadOfReferenceLValue(RefLVal);
2529 }
2530
2531 /// Load a pointer with type \p PtrTy stored at address \p Ptr.
2532 /// Note that \p PtrTy is the type of the loaded pointer, not the addresses
2533 /// it is loaded from.
2534 Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy,
2535 LValueBaseInfo *BaseInfo = nullptr,
2536 TBAAAccessInfo *TBAAInfo = nullptr);
2537 LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy);
2538
2539 /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2540 /// block if \p ArraySize is nullptr, otherwise inserts it at the current
2541 /// insertion point of the builder. The caller is responsible for setting an
2542 /// appropriate alignment on
2543 /// the alloca.
2544 ///
2545 /// \p ArraySize is the number of array elements to be allocated if it
2546 /// is not nullptr.
2547 ///
2548 /// LangAS::Default is the address space of pointers to local variables and
2549 /// temporaries, as exposed in the source language. In certain
2550 /// configurations, this is not the same as the alloca address space, and a
2551 /// cast is needed to lift the pointer from the alloca AS into
2552 /// LangAS::Default. This can happen when the target uses a restricted
2553 /// address space for the stack but the source language requires
2554 /// LangAS::Default to be a generic address space. The latter condition is
2555 /// common for most programming languages; OpenCL is an exception in that
2556 /// LangAS::Default is the private address space, which naturally maps
2557 /// to the stack.
2558 ///
2559 /// Because the address of a temporary is often exposed to the program in
2560 /// various ways, this function will perform the cast. The original alloca
2561 /// instruction is returned through \p Alloca if it is not nullptr.
2562 ///
2563 /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2564 /// more efficient if the caller knows that the address will not be exposed.
2565 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2566 llvm::Value *ArraySize = nullptr);
2567 Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
2568 const Twine &Name = "tmp",
2569 llvm::Value *ArraySize = nullptr,
2570 Address *Alloca = nullptr);
2571 Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align,
2572 const Twine &Name = "tmp",
2573 llvm::Value *ArraySize = nullptr);
2574
2575 /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2576 /// default ABI alignment of the given LLVM type.
2577 ///
2578 /// IMPORTANT NOTE: This is *not* generally the right alignment for
2579 /// any given AST type that happens to have been lowered to the
2580 /// given IR type. This should only ever be used for function-local,
2581 /// IR-driven manipulations like saving and restoring a value. Do
2582 /// not hand this address off to arbitrary IRGen routines, and especially
2583 /// do not pass it as an argument to a function that might expect a
2584 /// properly ABI-aligned value.
2585 Address CreateDefaultAlignTempAlloca(llvm::Type *Ty,
2586 const Twine &Name = "tmp");
2587
2588 /// CreateIRTemp - Create a temporary IR object of the given type, with
2589 /// appropriate alignment. This routine should only be used when an temporary
2590 /// value needs to be stored into an alloca (for example, to avoid explicit
2591 /// PHI construction), but the type is the IR type, not the type appropriate
2592 /// for storing in memory.
2593 ///
2594 /// That is, this is exactly equivalent to CreateMemTemp, but calling
2595 /// ConvertType instead of ConvertTypeForMem.
2596 Address CreateIRTemp(QualType T, const Twine &Name = "tmp");
2597
2598 /// CreateMemTemp - Create a temporary memory object of the given type, with
2599 /// appropriate alignmen and cast it to the default address space. Returns
2600 /// the original alloca instruction by \p Alloca if it is not nullptr.
2601 Address CreateMemTemp(QualType T, const Twine &Name = "tmp",
2602 Address *Alloca = nullptr);
2603 Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp",
2604 Address *Alloca = nullptr);
2605
2606 /// CreateMemTemp - Create a temporary memory object of the given type, with
2607 /// appropriate alignmen without casting it to the default address space.
2608 Address CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2609 Address CreateMemTempWithoutCast(QualType T, CharUnits Align,
2610 const Twine &Name = "tmp");
2611
2612 /// CreateAggTemp - Create a temporary memory object for the given
2613 /// aggregate type.
2614 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp",
2615 Address *Alloca = nullptr) {
2616 return AggValueSlot::forAddr(CreateMemTemp(T, Name, Alloca),
2617 T.getQualifiers(),
2618 AggValueSlot::IsNotDestructed,
2619 AggValueSlot::DoesNotNeedGCBarriers,
2620 AggValueSlot::IsNotAliased,
2621 AggValueSlot::DoesNotOverlap);
2622 }
2623
2624 /// Emit a cast to void* in the appropriate address space.
2625 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
2626
2627 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2628 /// expression and compare the result against zero, returning an Int1Ty value.
2629 llvm::Value *EvaluateExprAsBool(const Expr *E);
2630
2631 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
2632 void EmitIgnoredExpr(const Expr *E);
2633
2634 /// EmitAnyExpr - Emit code to compute the specified expression which can have
2635 /// any type. The result is returned as an RValue struct. If this is an
2636 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
2637 /// the result should be returned.
2638 ///
2639 /// \param ignoreResult True if the resulting value isn't used.
2640 RValue EmitAnyExpr(const Expr *E,
2641 AggValueSlot aggSlot = AggValueSlot::ignored(),
2642 bool ignoreResult = false);
2643
2644 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2645 // or the value of the expression, depending on how va_list is defined.
2646 Address EmitVAListRef(const Expr *E);
2647
2648 /// Emit a "reference" to a __builtin_ms_va_list; this is
2649 /// always the value of the expression, because a __builtin_ms_va_list is a
2650 /// pointer to a char.
2651 Address EmitMSVAListRef(const Expr *E);
2652
2653 /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2654 /// always be accessible even if no aggregate location is provided.
2655 RValue EmitAnyExprToTemp(const Expr *E);
2656
2657 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2658 /// arbitrary expression into the given memory location.
2659 void EmitAnyExprToMem(const Expr *E, Address Location,
2660 Qualifiers Quals, bool IsInitializer);
2661
2662 void EmitAnyExprToExn(const Expr *E, Address Addr);
2663
2664 /// EmitExprAsInit - Emits the code necessary to initialize a
2665 /// location in memory with the given initializer.
2666 void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2667 bool capturedByInit);
2668
2669 /// hasVolatileMember - returns true if aggregate type has a volatile
2670 /// member.
2671 bool hasVolatileMember(QualType T) {
2672 if (const RecordType *RT = T->getAs<RecordType>()) {
2673 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2674 return RD->hasVolatileMember();
2675 }
2676 return false;
2677 }
2678
2679 /// Determine whether a return value slot may overlap some other object.
2680 AggValueSlot::Overlap_t getOverlapForReturnValue() {
2681 // FIXME: Assuming no overlap here breaks guaranteed copy elision for base
2682 // class subobjects. These cases may need to be revisited depending on the
2683 // resolution of the relevant core issue.
2684 return AggValueSlot::DoesNotOverlap;
2685 }
2686
2687 /// Determine whether a field initialization may overlap some other object.
2688 AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD);
2689
2690 /// Determine whether a base class initialization may overlap some other
2691 /// object.
2692 AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD,
2693 const CXXRecordDecl *BaseRD,
2694 bool IsVirtual);
2695
2696 /// Emit an aggregate assignment.
2697 void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) {
2698 bool IsVolatile = hasVolatileMember(EltTy);
2699 EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile);
2700 }
2701
2702 void EmitAggregateCopyCtor(LValue Dest, LValue Src,
2703 AggValueSlot::Overlap_t MayOverlap) {
2704 EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap);
2705 }
2706
2707 /// EmitAggregateCopy - Emit an aggregate copy.
2708 ///
2709 /// \param isVolatile \c true iff either the source or the destination is
2710 /// volatile.
2711 /// \param MayOverlap Whether the tail padding of the destination might be
2712 /// occupied by some other object. More efficient code can often be
2713 /// generated if not.
2714 void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy,
2715 AggValueSlot::Overlap_t MayOverlap,
2716 bool isVolatile = false);
2717
2718 /// GetAddrOfLocalVar - Return the address of a local variable.
2719 Address GetAddrOfLocalVar(const VarDecl *VD) {
2720 auto it = LocalDeclMap.find(VD);
2721 assert(it != LocalDeclMap.end() &&
2722 "Invalid argument to GetAddrOfLocalVar(), no decl!");
2723 return it->second;
2724 }
2725
2726 /// Given an opaque value expression, return its LValue mapping if it exists,
2727 /// otherwise create one.
2728 LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e);
2729
2730 /// Given an opaque value expression, return its RValue mapping if it exists,
2731 /// otherwise create one.
2732 RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e);
2733
2734 /// Get the index of the current ArrayInitLoopExpr, if any.
2735 llvm::Value *getArrayInitIndex() { return ArrayInitIndex; }
2736
2737 /// getAccessedFieldNo - Given an encoded value and a result number, return
2738 /// the input field number being accessed.
2739 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
2740
2741 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
2742 llvm::BasicBlock *GetIndirectGotoBlock();
2743
2744 /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
2745 static bool IsWrappedCXXThis(const Expr *E);
2746
2747 /// EmitNullInitialization - Generate code to set a value of the given type to
2748 /// null, If the type contains data member pointers, they will be initialized
2749 /// to -1 in accordance with the Itanium C++ ABI.
2750 void EmitNullInitialization(Address DestPtr, QualType Ty);
2751
2752 /// Emits a call to an LLVM variable-argument intrinsic, either
2753 /// \c llvm.va_start or \c llvm.va_end.
2754 /// \param ArgValue A reference to the \c va_list as emitted by either
2755 /// \c EmitVAListRef or \c EmitMSVAListRef.
2756 /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise,
2757 /// calls \c llvm.va_end.
2758 llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart);
2759
2760 /// Generate code to get an argument from the passed in pointer
2761 /// and update it accordingly.
2762 /// \param VE The \c VAArgExpr for which to generate code.
2763 /// \param VAListAddr Receives a reference to the \c va_list as emitted by
2764 /// either \c EmitVAListRef or \c EmitMSVAListRef.
2765 /// \returns A pointer to the argument.
2766 // FIXME: We should be able to get rid of this method and use the va_arg
2767 // instruction in LLVM instead once it works well enough.
2768 Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr);
2769
2770 /// emitArrayLength - Compute the length of an array, even if it's a
2771 /// VLA, and drill down to the base element type.
2772 llvm::Value *emitArrayLength(const ArrayType *arrayType,
2773 QualType &baseType,
2774 Address &addr);
2775
2776 /// EmitVLASize - Capture all the sizes for the VLA expressions in
2777 /// the given variably-modified type and store them in the VLASizeMap.
2778 ///
2779 /// This function can be called with a null (unreachable) insert point.
2780 void EmitVariablyModifiedType(QualType Ty);
2781
2782 struct VlaSizePair {
2783 llvm::Value *NumElts;
2784 QualType Type;
2785
2786 VlaSizePair(llvm::Value *NE, QualType T) : NumElts(NE), Type(T) {}
2787 };
2788
2789 /// Return the number of elements for a single dimension
2790 /// for the given array type.
2791 VlaSizePair getVLAElements1D(const VariableArrayType *vla);
2792 VlaSizePair getVLAElements1D(QualType vla);
2793
2794 /// Returns an LLVM value that corresponds to the size,
2795 /// in non-variably-sized elements, of a variable length array type,
2796 /// plus that largest non-variably-sized element type. Assumes that
2797 /// the type has already been emitted with EmitVariablyModifiedType.
2798 VlaSizePair getVLASize(const VariableArrayType *vla);
2799 VlaSizePair getVLASize(QualType vla);
2800
2801 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
2802 /// generating code for an C++ member function.
2803 llvm::Value *LoadCXXThis() {
2804 assert(CXXThisValue && "no 'this' value for this function");
2805 return CXXThisValue;
2806 }
2807 Address LoadCXXThisAddress();
2808
2809 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
2810 /// virtual bases.
2811 // FIXME: Every place that calls LoadCXXVTT is something
2812 // that needs to be abstracted properly.
2813 llvm::Value *LoadCXXVTT() {
2814 assert(CXXStructorImplicitParamValue && "no VTT value for this function");
2815 return CXXStructorImplicitParamValue;
2816 }
2817
2818 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
2819 /// complete class to the given direct base.
2820 Address
2821 GetAddressOfDirectBaseInCompleteClass(Address Value,
2822 const CXXRecordDecl *Derived,
2823 const CXXRecordDecl *Base,
2824 bool BaseIsVirtual);
2825
2826 static bool ShouldNullCheckClassCastValue(const CastExpr *Cast);
2827
2828 /// GetAddressOfBaseClass - This function will add the necessary delta to the
2829 /// load of 'this' and returns address of the base class.
2830 Address GetAddressOfBaseClass(Address Value,
2831 const CXXRecordDecl *Derived,
2832 CastExpr::path_const_iterator PathBegin,
2833 CastExpr::path_const_iterator PathEnd,
2834 bool NullCheckValue, SourceLocation Loc);
2835
2836 Address GetAddressOfDerivedClass(Address Value,
2837 const CXXRecordDecl *Derived,
2838 CastExpr::path_const_iterator PathBegin,
2839 CastExpr::path_const_iterator PathEnd,
2840 bool NullCheckValue);
2841
2842 /// GetVTTParameter - Return the VTT parameter that should be passed to a
2843 /// base constructor/destructor with virtual bases.
2844 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
2845 /// to ItaniumCXXABI.cpp together with all the references to VTT.
2846 llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
2847 bool Delegating);
2848
2849 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
2850 CXXCtorType CtorType,
2851 const FunctionArgList &Args,
2852 SourceLocation Loc);
2853 // It's important not to confuse this and the previous function. Delegating
2854 // constructors are the C++0x feature. The constructor delegate optimization
2855 // is used to reduce duplication in the base and complete consturctors where
2856 // they are substantially the same.
2857 void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor,
2858 const FunctionArgList &Args);
2859
2860 /// Emit a call to an inheriting constructor (that is, one that invokes a
2861 /// constructor inherited from a base class) by inlining its definition. This
2862 /// is necessary if the ABI does not support forwarding the arguments to the
2863 /// base class constructor (because they're variadic or similar).
2864 void EmitInlinedInheritingCXXConstructorCall(const CXXConstructorDecl *Ctor,
2865 CXXCtorType CtorType,
2866 bool ForVirtualBase,
2867 bool Delegating,
2868 CallArgList &Args);
2869
2870 /// Emit a call to a constructor inherited from a base class, passing the
2871 /// current constructor's arguments along unmodified (without even making
2872 /// a copy).
2873 void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D,
2874 bool ForVirtualBase, Address This,
2875 bool InheritedFromVBase,
2876 const CXXInheritedCtorInitExpr *E);
2877
2878 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
2879 bool ForVirtualBase, bool Delegating,
2880 AggValueSlot ThisAVS, const CXXConstructExpr *E);
2881
2882 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
2883 bool ForVirtualBase, bool Delegating,
2884 Address This, CallArgList &Args,
2885 AggValueSlot::Overlap_t Overlap,
2886 SourceLocation Loc, bool NewPointerIsChecked);
2887
2888 /// Emit assumption load for all bases. Requires to be called only on
2889 /// most-derived class and not under construction of the object.
2890 void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This);
2891
2892 /// Emit assumption that vptr load == global vtable.
2893 void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
2894
2895 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
2896 Address This, Address Src,
2897 const CXXConstructExpr *E);
2898
2899 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
2900 const ArrayType *ArrayTy,
2901 Address ArrayPtr,
2902 const CXXConstructExpr *E,
2903 bool NewPointerIsChecked,
2904 bool ZeroInitialization = false);
2905
2906 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
2907 llvm::Value *NumElements,
2908 Address ArrayPtr,
2909 const CXXConstructExpr *E,
2910 bool NewPointerIsChecked,
2911 bool ZeroInitialization = false);
2912
2913 static Destroyer destroyCXXObject;
2914
2915 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
2916 bool ForVirtualBase, bool Delegating, Address This,
2917 QualType ThisTy);
2918
2919 void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType,
2920 llvm::Type *ElementTy, Address NewPtr,
2921 llvm::Value *NumElements,
2922 llvm::Value *AllocSizeWithoutCookie);
2923
2924 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
2925 Address Ptr);
2926
2927 void EmitSehCppScopeBegin();
2928 void EmitSehCppScopeEnd();
2929 void EmitSehTryScopeBegin();
2930 void EmitSehTryScopeEnd();
2931
2932 llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr);
2933 void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
2934
2935 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
2936 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
2937
2938 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
2939 QualType DeleteTy, llvm::Value *NumElements = nullptr,
2940 CharUnits CookieSize = CharUnits());
2941
2942 RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
2943 const CallExpr *TheCallExpr, bool IsDelete);
2944
2945 llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E);
2946 llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE);
2947 Address EmitCXXUuidofExpr(const CXXUuidofExpr *E);
2948
2949 /// Situations in which we might emit a check for the suitability of a
2950 /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
2951 /// compiler-rt.
2952 enum TypeCheckKind {
2953 /// Checking the operand of a load. Must be suitably sized and aligned.
2954 TCK_Load,
2955 /// Checking the destination of a store. Must be suitably sized and aligned.
2956 TCK_Store,
2957 /// Checking the bound value in a reference binding. Must be suitably sized
2958 /// and aligned, but is not required to refer to an object (until the
2959 /// reference is used), per core issue 453.
2960 TCK_ReferenceBinding,
2961 /// Checking the object expression in a non-static data member access. Must
2962 /// be an object within its lifetime.
2963 TCK_MemberAccess,
2964 /// Checking the 'this' pointer for a call to a non-static member function.
2965 /// Must be an object within its lifetime.
2966 TCK_MemberCall,
2967 /// Checking the 'this' pointer for a constructor call.
2968 TCK_ConstructorCall,
2969 /// Checking the operand of a static_cast to a derived pointer type. Must be
2970 /// null or an object within its lifetime.
2971 TCK_DowncastPointer,
2972 /// Checking the operand of a static_cast to a derived reference type. Must
2973 /// be an object within its lifetime.
2974 TCK_DowncastReference,
2975 /// Checking the operand of a cast to a base object. Must be suitably sized
2976 /// and aligned.
2977 TCK_Upcast,
2978 /// Checking the operand of a cast to a virtual base object. Must be an
2979 /// object within its lifetime.
2980 TCK_UpcastToVirtualBase,
2981 /// Checking the value assigned to a _Nonnull pointer. Must not be null.
2982 TCK_NonnullAssign,
2983 /// Checking the operand of a dynamic_cast or a typeid expression. Must be
2984 /// null or an object within its lifetime.
2985 TCK_DynamicOperation
2986 };
2987
2988 /// Determine whether the pointer type check \p TCK permits null pointers.
2989 static bool isNullPointerAllowed(TypeCheckKind TCK);
2990
2991 /// Determine whether the pointer type check \p TCK requires a vptr check.
2992 static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty);
2993
2994 /// Whether any type-checking sanitizers are enabled. If \c false,
2995 /// calls to EmitTypeCheck can be skipped.
2996 bool sanitizePerformTypeCheck() const;
2997
2998 /// Emit a check that \p V is the address of storage of the
2999 /// appropriate size and alignment for an object of type \p Type
3000 /// (or if ArraySize is provided, for an array of that bound).
3001 void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V,
3002 QualType Type, CharUnits Alignment = CharUnits::Zero(),
3003 SanitizerSet SkippedChecks = SanitizerSet(),
3004 llvm::Value *ArraySize = nullptr);
3005
3006 /// Emit a check that \p Base points into an array object, which
3007 /// we can access at index \p Index. \p Accessed should be \c false if we
3008 /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
3009 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
3010 QualType IndexType, bool Accessed);
3011
3012 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
3013 bool isInc, bool isPre);
3014 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
3015 bool isInc, bool isPre);
3016
3017 /// Converts Location to a DebugLoc, if debug information is enabled.
3018 llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location);
3019
3020 /// Get the record field index as represented in debug info.
3021 unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex);
3022
3023
3024 //===--------------------------------------------------------------------===//
3025 // Declaration Emission
3026 //===--------------------------------------------------------------------===//
3027
3028 /// EmitDecl - Emit a declaration.
3029 ///
3030 /// This function can be called with a null (unreachable) insert point.
3031 void EmitDecl(const Decl &D);
3032
3033 /// EmitVarDecl - Emit a local variable declaration.
3034 ///
3035 /// This function can be called with a null (unreachable) insert point.
3036 void EmitVarDecl(const VarDecl &D);
3037
3038 void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
3039 bool capturedByInit);
3040
3041 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
3042 llvm::Value *Address);
3043
3044 /// Determine whether the given initializer is trivial in the sense
3045 /// that it requires no code to be generated.
3046 bool isTrivialInitializer(const Expr *Init);
3047
3048 /// EmitAutoVarDecl - Emit an auto variable declaration.
3049 ///
3050 /// This function can be called with a null (unreachable) insert point.
3051 void EmitAutoVarDecl(const VarDecl &D);
3052
3053 class AutoVarEmission {
3054 friend class CodeGenFunction;
3055
3056 const VarDecl *Variable;
3057
3058 /// The address of the alloca for languages with explicit address space
3059 /// (e.g. OpenCL) or alloca casted to generic pointer for address space
3060 /// agnostic languages (e.g. C++). Invalid if the variable was emitted
3061 /// as a global constant.
3062 Address Addr;
3063
3064 llvm::Value *NRVOFlag;
3065
3066 /// True if the variable is a __block variable that is captured by an
3067 /// escaping block.
3068 bool IsEscapingByRef;
3069
3070 /// True if the variable is of aggregate type and has a constant
3071 /// initializer.
3072 bool IsConstantAggregate;
3073
3074 /// Non-null if we should use lifetime annotations.
3075 llvm::Value *SizeForLifetimeMarkers;
3076
3077 /// Address with original alloca instruction. Invalid if the variable was
3078 /// emitted as a global constant.
3079 Address AllocaAddr;
3080
3081 struct Invalid {};
3082 AutoVarEmission(Invalid)
3083 : Variable(nullptr), Addr(Address::invalid()),
3084 AllocaAddr(Address::invalid()) {}
3085
3086 AutoVarEmission(const VarDecl &variable)
3087 : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
3088 IsEscapingByRef(false), IsConstantAggregate(false),
3089 SizeForLifetimeMarkers(nullptr), AllocaAddr(Address::invalid()) {}
3090
3091 bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
3092
3093 public:
3094 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
3095
3096 bool useLifetimeMarkers() const {
3097 return SizeForLifetimeMarkers != nullptr;
3098 }
3099 llvm::Value *getSizeForLifetimeMarkers() const {
3100 assert(useLifetimeMarkers());
3101 return SizeForLifetimeMarkers;
3102 }
3103
3104 /// Returns the raw, allocated address, which is not necessarily
3105 /// the address of the object itself. It is casted to default
3106 /// address space for address space agnostic languages.
3107 Address getAllocatedAddress() const {
3108 return Addr;
3109 }
3110
3111 /// Returns the address for the original alloca instruction.
3112 Address getOriginalAllocatedAddress() const { return AllocaAddr; }
3113
3114 /// Returns the address of the object within this declaration.
3115 /// Note that this does not chase the forwarding pointer for
3116 /// __block decls.
3117 Address getObjectAddress(CodeGenFunction &CGF) const {
3118 if (!IsEscapingByRef) return Addr;
3119
3120 return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false);
3121 }
3122 };
3123 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
3124 void EmitAutoVarInit(const AutoVarEmission &emission);
3125 void EmitAutoVarCleanups(const AutoVarEmission &emission);
3126 void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
3127 QualType::DestructionKind dtorKind);
3128
3129 /// Emits the alloca and debug information for the size expressions for each
3130 /// dimension of an array. It registers the association of its (1-dimensional)
3131 /// QualTypes and size expression's debug node, so that CGDebugInfo can
3132 /// reference this node when creating the DISubrange object to describe the
3133 /// array types.
3134 void EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI,
3135 const VarDecl &D,
3136 bool EmitDebugInfo);
3137
3138 void EmitStaticVarDecl(const VarDecl &D,
3139 llvm::GlobalValue::LinkageTypes Linkage);
3140
3141 class ParamValue {
3142 llvm::Value *Value;
3143 llvm::Type *ElementType;
3144 unsigned Alignment;
3145 ParamValue(llvm::Value *V, llvm::Type *T, unsigned A)
3146 : Value(V), ElementType(T), Alignment(A) {}
3147 public:
3148 static ParamValue forDirect(llvm::Value *value) {
3149 return ParamValue(value, nullptr, 0);
3150 }
3151 static ParamValue forIndirect(Address addr) {
3152 assert(!addr.getAlignment().isZero());
3153 return ParamValue(addr.getPointer(), addr.getElementType(),
3154 addr.getAlignment().getQuantity());
3155 }
3156
3157 bool isIndirect() const { return Alignment != 0; }
3158 llvm::Value *getAnyValue() const { return Value; }
3159
3160 llvm::Value *getDirectValue() const {
3161 assert(!isIndirect());
3162 return Value;
3163 }
3164
3165 Address getIndirectAddress() const {
3166 assert(isIndirect());
3167 return Address(Value, ElementType, CharUnits::fromQuantity(Alignment));
3168 }
3169 };
3170
3171 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3172 void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo);
3173
3174 /// protectFromPeepholes - Protect a value that we're intending to
3175 /// store to the side, but which will probably be used later, from
3176 /// aggressive peepholing optimizations that might delete it.
3177 ///
3178 /// Pass the result to unprotectFromPeepholes to declare that
3179 /// protection is no longer required.
3180 ///
3181 /// There's no particular reason why this shouldn't apply to
3182 /// l-values, it's just that no existing peepholes work on pointers.
3183 PeepholeProtection protectFromPeepholes(RValue rvalue);
3184 void unprotectFromPeepholes(PeepholeProtection protection);
3185
3186 void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty,
3187 SourceLocation Loc,
3188 SourceLocation AssumptionLoc,
3189 llvm::Value *Alignment,
3190 llvm::Value *OffsetValue,
3191 llvm::Value *TheCheck,
3192 llvm::Instruction *Assumption);
3193
3194 void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
3195 SourceLocation Loc, SourceLocation AssumptionLoc,
3196 llvm::Value *Alignment,
3197 llvm::Value *OffsetValue = nullptr);
3198
3199 void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3200 SourceLocation AssumptionLoc,
3201 llvm::Value *Alignment,
3202 llvm::Value *OffsetValue = nullptr);
3203
3204 //===--------------------------------------------------------------------===//
3205 // Statement Emission
3206 //===--------------------------------------------------------------------===//
3207
3208 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3209 void EmitStopPoint(const Stmt *S);
3210
3211 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3212 /// this function even if there is no current insertion point.
3213 ///
3214 /// This function may clear the current insertion point; callers should use
3215 /// EnsureInsertPoint if they wish to subsequently generate code without first
3216 /// calling EmitBlock, EmitBranch, or EmitStmt.
3217 void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = std::nullopt);
3218
3219 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3220 /// necessarily require an insertion point or debug information; typically
3221 /// because the statement amounts to a jump or a container of other
3222 /// statements.
3223 ///
3224 /// \return True if the statement was handled.
3225 bool EmitSimpleStmt(const Stmt *S, ArrayRef<const Attr *> Attrs);
3226
3227 Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
3228 AggValueSlot AVS = AggValueSlot::ignored());
3229 Address EmitCompoundStmtWithoutScope(const CompoundStmt &S,
3230 bool GetLast = false,
3231 AggValueSlot AVS =
3232 AggValueSlot::ignored());
3233
3234 /// EmitLabel - Emit the block for the given label. It is legal to call this
3235 /// function even if there is no current insertion point.
3236 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
3237
3238 void EmitLabelStmt(const LabelStmt &S);
3239 void EmitAttributedStmt(const AttributedStmt &S);
3240 void EmitGotoStmt(const GotoStmt &S);
3241 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
3242 void EmitIfStmt(const IfStmt &S);
3243
3244 void EmitWhileStmt(const WhileStmt &S,
3245 ArrayRef<const Attr *> Attrs = std::nullopt);
3246 void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = std::nullopt);
3247 void EmitForStmt(const ForStmt &S,
3248 ArrayRef<const Attr *> Attrs = std::nullopt);
3249 void EmitReturnStmt(const ReturnStmt &S);
3250 void EmitDeclStmt(const DeclStmt &S);
3251 void EmitBreakStmt(const BreakStmt &S);
3252 void EmitContinueStmt(const ContinueStmt &S);
3253 void EmitSwitchStmt(const SwitchStmt &S);
3254 void EmitDefaultStmt(const DefaultStmt &S, ArrayRef<const Attr *> Attrs);
3255 void EmitCaseStmt(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3256 void EmitCaseStmtRange(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3257 void EmitAsmStmt(const AsmStmt &S);
3258
3259 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
3260 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
3261 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
3262 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
3263 void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S);
3264
3265 void EmitCoroutineBody(const CoroutineBodyStmt &S);
3266 void EmitCoreturnStmt(const CoreturnStmt &S);
3267 RValue EmitCoawaitExpr(const CoawaitExpr &E,
3268 AggValueSlot aggSlot = AggValueSlot::ignored(),
3269 bool ignoreResult = false);
3270 LValue EmitCoawaitLValue(const CoawaitExpr *E);
3271 RValue EmitCoyieldExpr(const CoyieldExpr &E,
3272 AggValueSlot aggSlot = AggValueSlot::ignored(),
3273 bool ignoreResult = false);
3274 LValue EmitCoyieldLValue(const CoyieldExpr *E);
3275 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3276
3277 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3278 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3279
3280 void EmitCXXTryStmt(const CXXTryStmt &S);
3281 void EmitSEHTryStmt(const SEHTryStmt &S);
3282 void EmitSEHLeaveStmt(const SEHLeaveStmt &S);
3283 void EnterSEHTryStmt(const SEHTryStmt &S);
3284 void ExitSEHTryStmt(const SEHTryStmt &S);
3285 void VolatilizeTryBlocks(llvm::BasicBlock *BB,
3286 llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V);
3287
3288 void pushSEHCleanup(CleanupKind kind,
3289 llvm::Function *FinallyFunc);
3290 void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter,
3291 const Stmt *OutlinedStmt);
3292
3293 llvm::Function *GenerateSEHFilterFunction(CodeGenFunction &ParentCGF,
3294 const SEHExceptStmt &Except);
3295
3296 llvm::Function *GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF,
3297 const SEHFinallyStmt &Finally);
3298
3299 void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF,
3300 llvm::Value *ParentFP,
3301 llvm::Value *EntryEBP);
3302 llvm::Value *EmitSEHExceptionCode();
3303 llvm::Value *EmitSEHExceptionInfo();
3304 llvm::Value *EmitSEHAbnormalTermination();
3305
3306 /// Emit simple code for OpenMP directives in Simd-only mode.
3307 void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D);
3308
3309 /// Scan the outlined statement for captures from the parent function. For
3310 /// each capture, mark the capture as escaped and emit a call to
3311 /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap.
3312 void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt,
3313 bool IsFilter);
3314
3315 /// Recovers the address of a local in a parent function. ParentVar is the
3316 /// address of the variable used in the immediate parent function. It can
3317 /// either be an alloca or a call to llvm.localrecover if there are nested
3318 /// outlined functions. ParentFP is the frame pointer of the outermost parent
3319 /// frame.
3320 Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
3321 Address ParentVar,
3322 llvm::Value *ParentFP);
3323
3324 void EmitCXXForRangeStmt(const CXXForRangeStmt &S,
3325 ArrayRef<const Attr *> Attrs = std::nullopt);
3326
3327 /// Controls insertion of cancellation exit blocks in worksharing constructs.
3328 class OMPCancelStackRAII {
3329 CodeGenFunction &CGF;
3330
3331 public:
3332 OMPCancelStackRAII(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
3333 bool HasCancel)
3334 : CGF(CGF) {
3335 CGF.OMPCancelStack.enter(CGF, Kind, HasCancel);
3336 }
3337 ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); }
3338 };
3339
3340 /// Returns calculated size of the specified type.
3341 llvm::Value *getTypeSize(QualType Ty);
3342 LValue InitCapturedStruct(const CapturedStmt &S);
3343 llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
3344 llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
3345 Address GenerateCapturedStmtArgument(const CapturedStmt &S);
3346 llvm::Function *GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S,
3347 SourceLocation Loc);
3348 void GenerateOpenMPCapturedVars(const CapturedStmt &S,
3349 SmallVectorImpl<llvm::Value *> &CapturedVars);
3350 void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3351 SourceLocation Loc);
3352 /// Perform element by element copying of arrays with type \a
3353 /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
3354 /// generated by \a CopyGen.
3355 ///
3356 /// \param DestAddr Address of the destination array.
3357 /// \param SrcAddr Address of the source array.
3358 /// \param OriginalType Type of destination and source arrays.
3359 /// \param CopyGen Copying procedure that copies value of single array element
3360 /// to another single array element.
3361 void EmitOMPAggregateAssign(
3362 Address DestAddr, Address SrcAddr, QualType OriginalType,
3363 const llvm::function_ref<void(Address, Address)> CopyGen);
3364 /// Emit proper copying of data from one variable to another.
3365 ///
3366 /// \param OriginalType Original type of the copied variables.
3367 /// \param DestAddr Destination address.
3368 /// \param SrcAddr Source address.
3369 /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3370 /// type of the base array element).
3371 /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3372 /// the base array element).
3373 /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
3374 /// DestVD.
3375 void EmitOMPCopy(QualType OriginalType,
3376 Address DestAddr, Address SrcAddr,
3377 const VarDecl *DestVD, const VarDecl *SrcVD,
3378 const Expr *Copy);
3379 /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or
3380 /// \a X = \a E \a BO \a E.
3381 ///
3382 /// \param X Value to be updated.
3383 /// \param E Update value.
3384 /// \param BO Binary operation for update operation.
3385 /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3386 /// expression, false otherwise.
3387 /// \param AO Atomic ordering of the generated atomic instructions.
3388 /// \param CommonGen Code generator for complex expressions that cannot be
3389 /// expressed through atomicrmw instruction.
3390 /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was
3391 /// generated, <false, RValue::get(nullptr)> otherwise.
3392 std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3393 LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3394 llvm::AtomicOrdering AO, SourceLocation Loc,
3395 const llvm::function_ref<RValue(RValue)> CommonGen);
3396 bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D,
3397 OMPPrivateScope &PrivateScope);
3398 void EmitOMPPrivateClause(const OMPExecutableDirective &D,
3399 OMPPrivateScope &PrivateScope);
3400 void EmitOMPUseDevicePtrClause(
3401 const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope,
3402 const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);
3403 void EmitOMPUseDeviceAddrClause(
3404 const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope,
3405 const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);
3406 /// Emit code for copyin clause in \a D directive. The next code is
3407 /// generated at the start of outlined functions for directives:
3408 /// \code
3409 /// threadprivate_var1 = master_threadprivate_var1;
3410 /// operator=(threadprivate_var2, master_threadprivate_var2);
3411 /// ...
3412 /// __kmpc_barrier(&loc, global_tid);
3413 /// \endcode
3414 ///
3415 /// \param D OpenMP directive possibly with 'copyin' clause(s).
3416 /// \returns true if at least one copyin variable is found, false otherwise.
3417 bool EmitOMPCopyinClause(const OMPExecutableDirective &D);
3418 /// Emit initial code for lastprivate variables. If some variable is
3419 /// not also firstprivate, then the default initialization is used. Otherwise
3420 /// initialization of this variable is performed by EmitOMPFirstprivateClause
3421 /// method.
3422 ///
3423 /// \param D Directive that may have 'lastprivate' directives.
3424 /// \param PrivateScope Private scope for capturing lastprivate variables for
3425 /// proper codegen in internal captured statement.
3426 ///
3427 /// \returns true if there is at least one lastprivate variable, false
3428 /// otherwise.
3429 bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D,
3430 OMPPrivateScope &PrivateScope);
3431 /// Emit final copying of lastprivate values to original variables at
3432 /// the end of the worksharing or simd directive.
3433 ///
3434 /// \param D Directive that has at least one 'lastprivate' directives.
3435 /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
3436 /// it is the last iteration of the loop code in associated directive, or to
3437 /// 'i1 false' otherwise. If this item is nullptr, no final check is required.
3438 void EmitOMPLastprivateClauseFinal(const OMPExecutableDirective &D,
3439 bool NoFinals,
3440 llvm::Value *IsLastIterCond = nullptr);
3441 /// Emit initial code for linear clauses.
3442 void EmitOMPLinearClause(const OMPLoopDirective &D,
3443 CodeGenFunction::OMPPrivateScope &PrivateScope);
3444 /// Emit final code for linear clauses.
3445 /// \param CondGen Optional conditional code for final part of codegen for
3446 /// linear clause.
3447 void EmitOMPLinearClauseFinal(
3448 const OMPLoopDirective &D,
3449 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3450 /// Emit initial code for reduction variables. Creates reduction copies
3451 /// and initializes them with the values according to OpenMP standard.
3452 ///
3453 /// \param D Directive (possibly) with the 'reduction' clause.
3454 /// \param PrivateScope Private scope for capturing reduction variables for
3455 /// proper codegen in internal captured statement.
3456 ///
3457 void EmitOMPReductionClauseInit(const OMPExecutableDirective &D,
3458 OMPPrivateScope &PrivateScope,
3459 bool ForInscan = false);
3460 /// Emit final update of reduction values to original variables at
3461 /// the end of the directive.
3462 ///
3463 /// \param D Directive that has at least one 'reduction' directives.
3464 /// \param ReductionKind The kind of reduction to perform.
3465 void EmitOMPReductionClauseFinal(const OMPExecutableDirective &D,
3466 const OpenMPDirectiveKind ReductionKind);
3467 /// Emit initial code for linear variables. Creates private copies
3468 /// and initializes them with the values according to OpenMP standard.
3469 ///
3470 /// \param D Directive (possibly) with the 'linear' clause.
3471 /// \return true if at least one linear variable is found that should be
3472 /// initialized with the value of the original variable, false otherwise.
3473 bool EmitOMPLinearClauseInit(const OMPLoopDirective &D);
3474
3475 typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/,
3476 llvm::Function * /*OutlinedFn*/,
3477 const OMPTaskDataTy & /*Data*/)>
3478 TaskGenTy;
3479 void EmitOMPTaskBasedDirective(const OMPExecutableDirective &S,
3480 const OpenMPDirectiveKind CapturedRegion,
3481 const RegionCodeGenTy &BodyGen,
3482 const TaskGenTy &TaskGen, OMPTaskDataTy &Data);
3483 struct OMPTargetDataInfo {
3484 Address BasePointersArray = Address::invalid();
3485 Address PointersArray = Address::invalid();
3486 Address SizesArray = Address::invalid();
3487 Address MappersArray = Address::invalid();
3488 unsigned NumberOfTargetItems = 0;
3489 explicit OMPTargetDataInfo() = default;
3490 OMPTargetDataInfo(Address BasePointersArray, Address PointersArray,
3491 Address SizesArray, Address MappersArray,
3492 unsigned NumberOfTargetItems)
3493 : BasePointersArray(BasePointersArray), PointersArray(PointersArray),
3494 SizesArray(SizesArray), MappersArray(MappersArray),
3495 NumberOfTargetItems(NumberOfTargetItems) {}
3496 };
3497 void EmitOMPTargetTaskBasedDirective(const OMPExecutableDirective &S,
3498 const RegionCodeGenTy &BodyGen,
3499 OMPTargetDataInfo &InputInfo);
3500 void processInReduction(const OMPExecutableDirective &S,
3501 OMPTaskDataTy &Data,
3502 CodeGenFunction &CGF,
3503 const CapturedStmt *CS,
3504 OMPPrivateScope &Scope);
3505 void EmitOMPMetaDirective(const OMPMetaDirective &S);
3506 void EmitOMPParallelDirective(const OMPParallelDirective &S);
3507 void EmitOMPSimdDirective(const OMPSimdDirective &S);
3508 void EmitOMPTileDirective(const OMPTileDirective &S);
3509 void EmitOMPUnrollDirective(const OMPUnrollDirective &S);
3510 void EmitOMPForDirective(const OMPForDirective &S);
3511 void EmitOMPForSimdDirective(const OMPForSimdDirective &S);
3512 void EmitOMPSectionsDirective(const OMPSectionsDirective &S);
3513 void EmitOMPSectionDirective(const OMPSectionDirective &S);
3514 void EmitOMPSingleDirective(const OMPSingleDirective &S);
3515 void EmitOMPMasterDirective(const OMPMasterDirective &S);
3516 void EmitOMPMaskedDirective(const OMPMaskedDirective &S);
3517 void EmitOMPCriticalDirective(const OMPCriticalDirective &S);
3518 void EmitOMPParallelForDirective(const OMPParallelForDirective &S);
3519 void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S);
3520 void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S);
3521 void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S);
3522 void EmitOMPTaskDirective(const OMPTaskDirective &S);
3523 void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S);
3524 void EmitOMPErrorDirective(const OMPErrorDirective &S);
3525 void EmitOMPBarrierDirective(const OMPBarrierDirective &S);
3526 void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S);
3527 void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S);
3528 void EmitOMPFlushDirective(const OMPFlushDirective &S);
3529 void EmitOMPDepobjDirective(const OMPDepobjDirective &S);
3530 void EmitOMPScanDirective(const OMPScanDirective &S);
3531 void EmitOMPOrderedDirective(const OMPOrderedDirective &S);
3532 void EmitOMPAtomicDirective(const OMPAtomicDirective &S);
3533 void EmitOMPTargetDirective(const OMPTargetDirective &S);
3534 void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S);
3535 void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S);
3536 void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S);
3537 void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S);
3538 void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S);
3539 void
3540 EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S);
3541 void EmitOMPTeamsDirective(const OMPTeamsDirective &S);
3542 void
3543 EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S);
3544 void EmitOMPCancelDirective(const OMPCancelDirective &S);
3545 void EmitOMPTaskLoopBasedDirective(const OMPLoopDirective &S);
3546 void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S);
3547 void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S);
3548 void EmitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &S);
3549 void
3550 EmitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &S);
3551 void EmitOMPParallelMasterTaskLoopDirective(
3552 const OMPParallelMasterTaskLoopDirective &S);
3553 void EmitOMPParallelMasterTaskLoopSimdDirective(
3554 const OMPParallelMasterTaskLoopSimdDirective &S);
3555 void EmitOMPDistributeDirective(const OMPDistributeDirective &S);
3556 void EmitOMPDistributeParallelForDirective(
3557 const OMPDistributeParallelForDirective &S);
3558 void EmitOMPDistributeParallelForSimdDirective(
3559 const OMPDistributeParallelForSimdDirective &S);
3560 void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S);
3561 void EmitOMPTargetParallelForSimdDirective(
3562 const OMPTargetParallelForSimdDirective &S);
3563 void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S);
3564 void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S);
3565 void
3566 EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S);
3567 void EmitOMPTeamsDistributeParallelForSimdDirective(
3568 const OMPTeamsDistributeParallelForSimdDirective &S);
3569 void EmitOMPTeamsDistributeParallelForDirective(
3570 const OMPTeamsDistributeParallelForDirective &S);
3571 void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S);
3572 void EmitOMPTargetTeamsDistributeDirective(
3573 const OMPTargetTeamsDistributeDirective &S);
3574 void EmitOMPTargetTeamsDistributeParallelForDirective(
3575 const OMPTargetTeamsDistributeParallelForDirective &S);
3576 void EmitOMPTargetTeamsDistributeParallelForSimdDirective(
3577 const OMPTargetTeamsDistributeParallelForSimdDirective &S);
3578 void EmitOMPTargetTeamsDistributeSimdDirective(
3579 const OMPTargetTeamsDistributeSimdDirective &S);
3580 void EmitOMPGenericLoopDirective(const OMPGenericLoopDirective &S);
3581 void EmitOMPInteropDirective(const OMPInteropDirective &S);
3582
3583 /// Emit device code for the target directive.
3584 static void EmitOMPTargetDeviceFunction(CodeGenModule &CGM,
3585 StringRef ParentName,
3586 const OMPTargetDirective &S);
3587 static void
3588 EmitOMPTargetParallelDeviceFunction(CodeGenModule &CGM, StringRef ParentName,
3589 const OMPTargetParallelDirective &S);
3590 /// Emit device code for the target parallel for directive.
3591 static void EmitOMPTargetParallelForDeviceFunction(
3592 CodeGenModule &CGM, StringRef ParentName,
3593 const OMPTargetParallelForDirective &S);
3594 /// Emit device code for the target parallel for simd directive.
3595 static void EmitOMPTargetParallelForSimdDeviceFunction(
3596 CodeGenModule &CGM, StringRef ParentName,
3597 const OMPTargetParallelForSimdDirective &S);
3598 /// Emit device code for the target teams directive.
3599 static void
3600 EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName,
3601 const OMPTargetTeamsDirective &S);
3602 /// Emit device code for the target teams distribute directive.
3603 static void EmitOMPTargetTeamsDistributeDeviceFunction(
3604 CodeGenModule &CGM, StringRef ParentName,
3605 const OMPTargetTeamsDistributeDirective &S);
3606 /// Emit device code for the target teams distribute simd directive.
3607 static void EmitOMPTargetTeamsDistributeSimdDeviceFunction(
3608 CodeGenModule &CGM, StringRef ParentName,
3609 const OMPTargetTeamsDistributeSimdDirective &S);
3610 /// Emit device code for the target simd directive.
3611 static void EmitOMPTargetSimdDeviceFunction(CodeGenModule &CGM,
3612 StringRef ParentName,
3613 const OMPTargetSimdDirective &S);
3614 /// Emit device code for the target teams distribute parallel for simd
3615 /// directive.
3616 static void EmitOMPTargetTeamsDistributeParallelForSimdDeviceFunction(
3617 CodeGenModule &CGM, StringRef ParentName,
3618 const OMPTargetTeamsDistributeParallelForSimdDirective &S);
3619
3620 static void EmitOMPTargetTeamsDistributeParallelForDeviceFunction(
3621 CodeGenModule &CGM, StringRef ParentName,
3622 const OMPTargetTeamsDistributeParallelForDirective &S);
3623
3624 /// Emit the Stmt \p S and return its topmost canonical loop, if any.
3625 /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
3626 /// future it is meant to be the number of loops expected in the loop nests
3627 /// (usually specified by the "collapse" clause) that are collapsed to a
3628 /// single loop by this function.
3629 llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S,
3630 int Depth);
3631
3632 /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
3633 void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S);
3634
3635 /// Emit inner loop of the worksharing/simd construct.
3636 ///
3637 /// \param S Directive, for which the inner loop must be emitted.
3638 /// \param RequiresCleanup true, if directive has some associated private
3639 /// variables.
3640 /// \param LoopCond Bollean condition for loop continuation.
3641 /// \param IncExpr Increment expression for loop control variable.
3642 /// \param BodyGen Generator for the inner body of the inner loop.
3643 /// \param PostIncGen Genrator for post-increment code (required for ordered
3644 /// loop directvies).
3645 void EmitOMPInnerLoop(
3646 const OMPExecutableDirective &S, bool RequiresCleanup,
3647 const Expr *LoopCond, const Expr *IncExpr,
3648 const llvm::function_ref<void(CodeGenFunction &)> BodyGen,
3649 const llvm::function_ref<void(CodeGenFunction &)> PostIncGen);
3650
3651 JumpDest getOMPCancelDestination(OpenMPDirectiveKind Kind);
3652 /// Emit initial code for loop counters of loop-based directives.
3653 void EmitOMPPrivateLoopCounters(const OMPLoopDirective &S,
3654 OMPPrivateScope &LoopScope);
3655
3656 /// Helper for the OpenMP loop directives.
3657 void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit);
3658
3659 /// Emit code for the worksharing loop-based directive.
3660 /// \return true, if this construct has any lastprivate clause, false -
3661 /// otherwise.
3662 bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB,
3663 const CodeGenLoopBoundsTy &CodeGenLoopBounds,
3664 const CodeGenDispatchBoundsTy &CGDispatchBounds);
3665
3666 /// Emit code for the distribute loop-based directive.
3667 void EmitOMPDistributeLoop(const OMPLoopDirective &S,
3668 const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
3669
3670 /// Helpers for the OpenMP loop directives.
3671 void EmitOMPSimdInit(const OMPLoopDirective &D);
3672 void EmitOMPSimdFinal(
3673 const OMPLoopDirective &D,
3674 const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3675
3676 /// Emits the lvalue for the expression with possibly captured variable.
3677 LValue EmitOMPSharedLValue(const Expr *E);
3678
3679 private:
3680 /// Helpers for blocks.
3681 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info);
3682
3683 /// struct with the values to be passed to the OpenMP loop-related functions
3684 struct OMPLoopArguments {
3685 /// loop lower bound
3686 Address LB = Address::invalid();
3687 /// loop upper bound
3688 Address UB = Address::invalid();
3689 /// loop stride
3690 Address ST = Address::invalid();
3691 /// isLastIteration argument for runtime functions
3692 Address IL = Address::invalid();
3693 /// Chunk value generated by sema
3694 llvm::Value *Chunk = nullptr;
3695 /// EnsureUpperBound
3696 Expr *EUB = nullptr;
3697 /// IncrementExpression
3698 Expr *IncExpr = nullptr;
3699 /// Loop initialization
3700 Expr *Init = nullptr;
3701 /// Loop exit condition
3702 Expr *Cond = nullptr;
3703 /// Update of LB after a whole chunk has been executed
3704 Expr *NextLB = nullptr;
3705 /// Update of UB after a whole chunk has been executed
3706 Expr *NextUB = nullptr;
3707 OMPLoopArguments() = default;
3708 OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3709 llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
3710 Expr *IncExpr = nullptr, Expr *Init = nullptr,
3711 Expr *Cond = nullptr, Expr *NextLB = nullptr,
3712 Expr *NextUB = nullptr)
3713 : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB),
3714 IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB),
3715 NextUB(NextUB) {}
3716 };
3717 void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic,
3718 const OMPLoopDirective &S, OMPPrivateScope &LoopScope,
3719 const OMPLoopArguments &LoopArgs,
3720 const CodeGenLoopTy &CodeGenLoop,
3721 const CodeGenOrderedTy &CodeGenOrdered);
3722 void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind,
3723 bool IsMonotonic, const OMPLoopDirective &S,
3724 OMPPrivateScope &LoopScope, bool Ordered,
3725 const OMPLoopArguments &LoopArgs,
3726 const CodeGenDispatchBoundsTy &CGDispatchBounds);
3727 void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind,
3728 const OMPLoopDirective &S,
3729 OMPPrivateScope &LoopScope,
3730 const OMPLoopArguments &LoopArgs,
3731 const CodeGenLoopTy &CodeGenLoopContent);
3732 /// Emit code for sections directive.
3733 void EmitSections(const OMPExecutableDirective &S);
3734
3735 public:
3736
3737 //===--------------------------------------------------------------------===//
3738 // LValue Expression Emission
3739 //===--------------------------------------------------------------------===//
3740
3741 /// Create a check that a scalar RValue is non-null.
3742 llvm::Value *EmitNonNullRValueCheck(RValue RV, QualType T);
3743
3744 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
3745 RValue GetUndefRValue(QualType Ty);
3746
3747 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
3748 /// and issue an ErrorUnsupported style diagnostic (using the
3749 /// provided Name).
3750 RValue EmitUnsupportedRValue(const Expr *E,
3751 const char *Name);
3752
3753 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
3754 /// an ErrorUnsupported style diagnostic (using the provided Name).
3755 LValue EmitUnsupportedLValue(const Expr *E,
3756 const char *Name);
3757
3758 /// EmitLValue - Emit code to compute a designator that specifies the location
3759 /// of the expression.
3760 ///
3761 /// This can return one of two things: a simple address or a bitfield
3762 /// reference. In either case, the LLVM Value* in the LValue structure is
3763 /// guaranteed to be an LLVM pointer type.
3764 ///
3765 /// If this returns a bitfield reference, nothing about the pointee type of
3766 /// the LLVM value is known: For example, it may not be a pointer to an
3767 /// integer.
3768 ///
3769 /// If this returns a normal address, and if the lvalue's C type is fixed
3770 /// size, this method guarantees that the returned pointer type will point to
3771 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
3772 /// variable length type, this is not possible.
3773 ///
3774 LValue EmitLValue(const Expr *E);
3775
3776 /// Same as EmitLValue but additionally we generate checking code to
3777 /// guard against undefined behavior. This is only suitable when we know
3778 /// that the address will be used to access the object.
3779 LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK);
3780
3781 RValue convertTempToRValue(Address addr, QualType type,
3782 SourceLocation Loc);
3783
3784 void EmitAtomicInit(Expr *E, LValue lvalue);
3785
3786 bool LValueIsSuitableForInlineAtomic(LValue Src);
3787
3788 RValue EmitAtomicLoad(LValue LV, SourceLocation SL,
3789 AggValueSlot Slot = AggValueSlot::ignored());
3790
3791 RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc,
3792 llvm::AtomicOrdering AO, bool IsVolatile = false,
3793 AggValueSlot slot = AggValueSlot::ignored());
3794
3795 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
3796
3797 void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
3798 bool IsVolatile, bool isInit);
3799
3800 std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
3801 LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
3802 llvm::AtomicOrdering Success =
3803 llvm::AtomicOrdering::SequentiallyConsistent,
3804 llvm::AtomicOrdering Failure =
3805 llvm::AtomicOrdering::SequentiallyConsistent,
3806 bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored());
3807
3808 void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
3809 const llvm::function_ref<RValue(RValue)> &UpdateOp,
3810 bool IsVolatile);
3811
3812 /// EmitToMemory - Change a scalar value from its value
3813 /// representation to its in-memory representation.
3814 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
3815
3816 /// EmitFromMemory - Change a scalar value from its memory
3817 /// representation to its value representation.
3818 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
3819
3820 /// Check if the scalar \p Value is within the valid range for the given
3821 /// type \p Ty.
3822 ///
3823 /// Returns true if a check is needed (even if the range is unknown).
3824 bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty,
3825 SourceLocation Loc);
3826
3827 /// EmitLoadOfScalar - Load a scalar value from an address, taking
3828 /// care to appropriately convert from the memory representation to
3829 /// the LLVM value representation.
3830 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3831 SourceLocation Loc,
3832 AlignmentSource Source = AlignmentSource::Type,
3833 bool isNontemporal = false) {
3834 return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source),
3835 CGM.getTBAAAccessInfo(Ty), isNontemporal);
3836 }
3837
3838 llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3839 SourceLocation Loc, LValueBaseInfo BaseInfo,
3840 TBAAAccessInfo TBAAInfo,
3841 bool isNontemporal = false);
3842
3843 /// EmitLoadOfScalar - Load a scalar value from an address, taking
3844 /// care to appropriately convert from the memory representation to
3845 /// the LLVM value representation. The l-value must be a simple
3846 /// l-value.
3847 llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc);
3848
3849 /// EmitStoreOfScalar - Store a scalar value to an address, taking
3850 /// care to appropriately convert from the memory representation to
3851 /// the LLVM value representation.
3852 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
3853 bool Volatile, QualType Ty,
3854 AlignmentSource Source = AlignmentSource::Type,
3855 bool isInit = false, bool isNontemporal = false) {
3856 EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source),
3857 CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal);
3858 }
3859
3860 void EmitStoreOfScalar(llvm::Value *Value, Address Addr,
3861 bool Volatile, QualType Ty,
3862 LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo,
3863 bool isInit = false, bool isNontemporal = false);
3864
3865 /// EmitStoreOfScalar - Store a scalar value to an address, taking
3866 /// care to appropriately convert from the memory representation to
3867 /// the LLVM value representation. The l-value must be a simple
3868 /// l-value. The isInit flag indicates whether this is an initialization.
3869 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
3870 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
3871
3872 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
3873 /// this method emits the address of the lvalue, then loads the result as an
3874 /// rvalue, returning the rvalue.
3875 RValue EmitLoadOfLValue(LValue V, SourceLocation Loc);
3876 RValue EmitLoadOfExtVectorElementLValue(LValue V);
3877 RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc);
3878 RValue EmitLoadOfGlobalRegLValue(LValue LV);
3879
3880 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
3881 /// lvalue, where both are guaranteed to the have the same type, and that type
3882 /// is 'Ty'.
3883 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
3884 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
3885 void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst);
3886
3887 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
3888 /// as EmitStoreThroughLValue.
3889 ///
3890 /// \param Result [out] - If non-null, this will be set to a Value* for the
3891 /// bit-field contents after the store, appropriate for use as the result of
3892 /// an assignment to the bit-field.
3893 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
3894 llvm::Value **Result=nullptr);
3895
3896 /// Emit an l-value for an assignment (simple or compound) of complex type.
3897 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
3898 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
3899 LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
3900 llvm::Value *&Result);
3901
3902 // Note: only available for agg return types
3903 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
3904 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
3905 // Note: only available for agg return types
3906 LValue EmitCallExprLValue(const CallExpr *E);
3907 // Note: only available for agg return types
3908 LValue EmitVAArgExprLValue(const VAArgExpr *E);
3909 LValue EmitDeclRefLValue(const DeclRefExpr *E);
3910 LValue EmitStringLiteralLValue(const StringLiteral *E);
3911 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
3912 LValue EmitPredefinedLValue(const PredefinedExpr *E);
3913 LValue EmitUnaryOpLValue(const UnaryOperator *E);
3914 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E,
3915 bool Accessed = false);
3916 LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E);
3917 LValue EmitOMPArraySectionExpr(const OMPArraySectionExpr *E,
3918 bool IsLowerBound = true);
3919 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
3920 LValue EmitMemberExpr(const MemberExpr *E);
3921 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
3922 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
3923 LValue EmitInitListLValue(const InitListExpr *E);
3924 void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E);
3925 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E);
3926 LValue EmitCastLValue(const CastExpr *E);
3927 LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
3928 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
3929
3930 Address EmitExtVectorElementLValue(LValue V);
3931
3932 RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc);
3933
3934 Address EmitArrayToPointerDecay(const Expr *Array,
3935 LValueBaseInfo *BaseInfo = nullptr,
3936 TBAAAccessInfo *TBAAInfo = nullptr);
3937
3938 class ConstantEmission {
3939 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
3940 ConstantEmission(llvm::Constant *C, bool isReference)
3941 : ValueAndIsReference(C, isReference) {}
3942 public:
3943 ConstantEmission() {}
3944 static ConstantEmission forReference(llvm::Constant *C) {
3945 return ConstantEmission(C, true);
3946 }
3947 static ConstantEmission forValue(llvm::Constant *C) {
3948 return ConstantEmission(C, false);
3949 }
3950
3951 explicit operator bool() const {
3952 return ValueAndIsReference.getOpaqueValue() != nullptr;
3953 }
3954
3955 bool isReference() const { return ValueAndIsReference.getInt(); }
3956 LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const {
3957 assert(isReference());
3958 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
3959 refExpr->getType());
3960 }
3961
3962 llvm::Constant *getValue() const {
3963 assert(!isReference());
3964 return ValueAndIsReference.getPointer();
3965 }
3966 };
3967
3968 ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr);
3969 ConstantEmission tryEmitAsConstant(const MemberExpr *ME);
3970 llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
3971
3972 RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e,
3973 AggValueSlot slot = AggValueSlot::ignored());
3974 LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
3975
3976 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
3977 const ObjCIvarDecl *Ivar);
3978 llvm::Value *EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface,
3979 const ObjCIvarDecl *Ivar);
3980 LValue EmitLValueForField(LValue Base, const FieldDecl* Field);
3981 LValue EmitLValueForLambdaField(const FieldDecl *Field);
3982
3983 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
3984 /// if the Field is a reference, this will return the address of the reference
3985 /// and not the address of the value stored in the reference.
3986 LValue EmitLValueForFieldInitialization(LValue Base,
3987 const FieldDecl* Field);
3988
3989 LValue EmitLValueForIvar(QualType ObjectTy,
3990 llvm::Value* Base, const ObjCIvarDecl *Ivar,
3991 unsigned CVRQualifiers);
3992
3993 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
3994 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
3995 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
3996 LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E);
3997
3998 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
3999 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
4000 LValue EmitStmtExprLValue(const StmtExpr *E);
4001 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
4002 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
4003 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init);
4004
4005 //===--------------------------------------------------------------------===//
4006 // Scalar Expression Emission
4007 //===--------------------------------------------------------------------===//
4008
4009 /// EmitCall - Generate a call of the given function, expecting the given
4010 /// result type, and using the given argument list which specifies both the
4011 /// LLVM arguments and the types they were derived from.
4012 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4013 ReturnValueSlot ReturnValue, const CallArgList &Args,
4014 llvm::CallBase **callOrInvoke, bool IsMustTail,
4015 SourceLocation Loc);
4016 RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
4017 ReturnValueSlot ReturnValue, const CallArgList &Args,
4018 llvm::CallBase **callOrInvoke = nullptr,
4019 bool IsMustTail = false) {
4020 return EmitCall(CallInfo, Callee, ReturnValue, Args, callOrInvoke,
4021 IsMustTail, SourceLocation());
4022 }
4023 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
4024 ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr);
4025 RValue EmitCallExpr(const CallExpr *E,
4026 ReturnValueSlot ReturnValue = ReturnValueSlot());
4027 RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
4028 CGCallee EmitCallee(const Expr *E);
4029
4030 void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
4031 void checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl);
4032
4033 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4034 const Twine &name = "");
4035 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4036 ArrayRef<llvm::Value *> args,
4037 const Twine &name = "");
4038 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4039 const Twine &name = "");
4040 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4041 ArrayRef<llvm::Value *> args,
4042 const Twine &name = "");
4043
4044 SmallVector<llvm::OperandBundleDef, 1>
4045 getBundlesForFunclet(llvm::Value *Callee);
4046
4047 llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee,
4048 ArrayRef<llvm::Value *> Args,
4049 const Twine &Name = "");
4050 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4051 ArrayRef<llvm::Value *> args,
4052 const Twine &name = "");
4053 llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4054 const Twine &name = "");
4055 void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4056 ArrayRef<llvm::Value *> args);
4057
4058 CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
4059 NestedNameSpecifier *Qual,
4060 llvm::Type *Ty);
4061
4062 CGCallee BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
4063 CXXDtorType Type,
4064 const CXXRecordDecl *RD);
4065
4066 // Return the copy constructor name with the prefix "__copy_constructor_"
4067 // removed.
4068 static std::string getNonTrivialCopyConstructorStr(QualType QT,
4069 CharUnits Alignment,
4070 bool IsVolatile,
4071 ASTContext &Ctx);
4072
4073 // Return the destructor name with the prefix "__destructor_" removed.
4074 static std::string getNonTrivialDestructorStr(QualType QT,
4075 CharUnits Alignment,
4076 bool IsVolatile,
4077 ASTContext &Ctx);
4078
4079 // These functions emit calls to the special functions of non-trivial C
4080 // structs.
4081 void defaultInitNonTrivialCStructVar(LValue Dst);
4082 void callCStructDefaultConstructor(LValue Dst);
4083 void callCStructDestructor(LValue Dst);
4084 void callCStructCopyConstructor(LValue Dst, LValue Src);
4085 void callCStructMoveConstructor(LValue Dst, LValue Src);
4086 void callCStructCopyAssignmentOperator(LValue Dst, LValue Src);
4087 void callCStructMoveAssignmentOperator(LValue Dst, LValue Src);
4088
4089 RValue
4090 EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method,
4091 const CGCallee &Callee,
4092 ReturnValueSlot ReturnValue, llvm::Value *This,
4093 llvm::Value *ImplicitParam,
4094 QualType ImplicitParamTy, const CallExpr *E,
4095 CallArgList *RtlArgs);
4096 RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee,
4097 llvm::Value *This, QualType ThisTy,
4098 llvm::Value *ImplicitParam,
4099 QualType ImplicitParamTy, const CallExpr *E);
4100 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
4101 ReturnValueSlot ReturnValue);
4102 RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE,
4103 const CXXMethodDecl *MD,
4104 ReturnValueSlot ReturnValue,
4105 bool HasQualifier,
4106 NestedNameSpecifier *Qualifier,
4107 bool IsArrow, const Expr *Base);
4108 // Compute the object pointer.
4109 Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
4110 llvm::Value *memberPtr,
4111 const MemberPointerType *memberPtrType,
4112 LValueBaseInfo *BaseInfo = nullptr,
4113 TBAAAccessInfo *TBAAInfo = nullptr);
4114 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
4115 ReturnValueSlot ReturnValue);
4116
4117 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
4118 const CXXMethodDecl *MD,
4119 ReturnValueSlot ReturnValue);
4120 RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
4121
4122 RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
4123 ReturnValueSlot ReturnValue);
4124
4125 RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E);
4126 RValue EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E);
4127 RValue EmitOpenMPDevicePrintfCallExpr(const CallExpr *E);
4128
4129 RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
4130 const CallExpr *E, ReturnValueSlot ReturnValue);
4131
4132 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
4133
4134 /// Emit IR for __builtin_os_log_format.
4135 RValue emitBuiltinOSLogFormat(const CallExpr &E);
4136
4137 /// Emit IR for __builtin_is_aligned.
4138 RValue EmitBuiltinIsAligned(const CallExpr *E);
4139 /// Emit IR for __builtin_align_up/__builtin_align_down.
4140 RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp);
4141
4142 llvm::Function *generateBuiltinOSLogHelperFunction(
4143 const analyze_os_log::OSLogBufferLayout &Layout,
4144 CharUnits BufferAlignment);
4145
4146 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
4147
4148 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4149 /// is unhandled by the current target.
4150 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4151 ReturnValueSlot ReturnValue);
4152
4153 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty,
4154 const llvm::CmpInst::Predicate Fp,
4155 const llvm::CmpInst::Predicate Ip,
4156 const llvm::Twine &Name = "");
4157 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4158 ReturnValueSlot ReturnValue,
4159 llvm::Triple::ArchType Arch);
4160 llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4161 ReturnValueSlot ReturnValue,
4162 llvm::Triple::ArchType Arch);
4163 llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4164 ReturnValueSlot ReturnValue,
4165 llvm::Triple::ArchType Arch);
4166 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy,
4167 QualType RTy);
4168 llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy,
4169 QualType RTy);
4170
4171 llvm::Value *EmitCommonNeonBuiltinExpr(unsigned BuiltinID,
4172 unsigned LLVMIntrinsic,
4173 unsigned AltLLVMIntrinsic,
4174 const char *NameHint,
4175 unsigned Modifier,
4176 const CallExpr *E,
4177 SmallVectorImpl<llvm::Value *> &Ops,
4178 Address PtrOp0, Address PtrOp1,
4179 llvm::Triple::ArchType Arch);
4180
4181 llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
4182 unsigned Modifier, llvm::Type *ArgTy,
4183 const CallExpr *E);
4184 llvm::Value *EmitNeonCall(llvm::Function *F,
4185 SmallVectorImpl<llvm::Value*> &O,
4186 const char *name,
4187 unsigned shift = 0, bool rightshift = false);
4188 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
4189 const llvm::ElementCount &Count);
4190 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
4191 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
4192 bool negateForRightShift);
4193 llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt,
4194 llvm::Type *Ty, bool usgn, const char *name);
4195 llvm::Value *vectorWrapScalar16(llvm::Value *Op);
4196 /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4197 /// access builtin. Only required if it can't be inferred from the base
4198 /// pointer operand.
4199 llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags);
4200
4201 SmallVector<llvm::Type *, 2>
4202 getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType,
4203 ArrayRef<llvm::Value *> Ops);
4204 llvm::Type *getEltType(const SVETypeFlags &TypeFlags);
4205 llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags);
4206 llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags);
4207 llvm::Value *EmitSVETupleSetOrGet(const SVETypeFlags &TypeFlags,
4208 llvm::Type *ReturnType,
4209 ArrayRef<llvm::Value *> Ops);
4210 llvm::Value *EmitSVETupleCreate(const SVETypeFlags &TypeFlags,
4211 llvm::Type *ReturnType,
4212 ArrayRef<llvm::Value *> Ops);
4213 llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags);
4214 llvm::Value *EmitSVEDupX(llvm::Value *Scalar);
4215 llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty);
4216 llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty);
4217 llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags,
4218 llvm::SmallVectorImpl<llvm::Value *> &Ops,
4219 unsigned BuiltinID);
4220 llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags,
4221 llvm::ArrayRef<llvm::Value *> Ops,
4222 unsigned BuiltinID);
4223 llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred,
4224 llvm::ScalableVectorType *VTy);
4225 llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags,
4226 llvm::SmallVectorImpl<llvm::Value *> &Ops,
4227 unsigned IntID);
4228 llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags,
4229 llvm::SmallVectorImpl<llvm::Value *> &Ops,
4230 unsigned IntID);
4231 llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy,
4232 SmallVectorImpl<llvm::Value *> &Ops,
4233 unsigned BuiltinID, bool IsZExtReturn);
4234 llvm::Value *EmitSVEMaskedStore(const CallExpr *,
4235 SmallVectorImpl<llvm::Value *> &Ops,
4236 unsigned BuiltinID);
4237 llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags,
4238 SmallVectorImpl<llvm::Value *> &Ops,
4239 unsigned BuiltinID);
4240 llvm::Value *EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags,
4241 SmallVectorImpl<llvm::Value *> &Ops,
4242 unsigned IntID);
4243 llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags,
4244 SmallVectorImpl<llvm::Value *> &Ops,
4245 unsigned IntID);
4246 llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags,
4247 SmallVectorImpl<llvm::Value *> &Ops,
4248 unsigned IntID);
4249 llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4250
4251 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4252 llvm::Triple::ArchType Arch);
4253 llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4254
4255 llvm::Value *BuildVector(ArrayRef<llvm::Value*> Ops);
4256 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4257 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4258 llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4259 llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4260 llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4261 llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
4262 const CallExpr *E);
4263 llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4264 llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4265 ReturnValueSlot ReturnValue);
4266 llvm::Value *EmitLoongArchBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4267 void ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope,
4268 llvm::AtomicOrdering &AO,
4269 llvm::SyncScope::ID &SSID);
4270
4271 enum class MSVCIntrin;
4272 llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4273
4274 llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version);
4275
4276 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
4277 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
4278 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E);
4279 llvm::Value *EmitObjCArrayLiteral(const ObjCArrayLiteral *E);
4280 llvm::Value *EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E);
4281 llvm::Value *EmitObjCCollectionLiteral(const Expr *E,
4282 const ObjCMethodDecl *MethodWithObjects);
4283 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
4284 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
4285 ReturnValueSlot Return = ReturnValueSlot());
4286
4287 /// Retrieves the default cleanup kind for an ARC cleanup.
4288 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4289 CleanupKind getARCCleanupKind() {
4290 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
4291 ? NormalAndEHCleanup : NormalCleanup;
4292 }
4293
4294 // ARC primitives.
4295 void EmitARCInitWeak(Address addr, llvm::Value *value);
4296 void EmitARCDestroyWeak(Address addr);
4297 llvm::Value *EmitARCLoadWeak(Address addr);
4298 llvm::Value *EmitARCLoadWeakRetained(Address addr);
4299 llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
4300 void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4301 void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4302 void EmitARCCopyWeak(Address dst, Address src);
4303 void EmitARCMoveWeak(Address dst, Address src);
4304 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
4305 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
4306 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
4307 bool resultIgnored);
4308 llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value,
4309 bool resultIgnored);
4310 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
4311 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
4312 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
4313 void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise);
4314 void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4315 llvm::Value *EmitARCAutorelease(llvm::Value *value);
4316 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
4317 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
4318 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
4319 llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value);
4320
4321 llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
4322 llvm::Value *EmitObjCRetainNonBlock(llvm::Value *value,
4323 llvm::Type *returnType);
4324 void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4325
4326 std::pair<LValue,llvm::Value*>
4327 EmitARCStoreAutoreleasing(const BinaryOperator *e);
4328 std::pair<LValue,llvm::Value*>
4329 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
4330 std::pair<LValue,llvm::Value*>
4331 EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored);
4332
4333 llvm::Value *EmitObjCAlloc(llvm::Value *value,
4334 llvm::Type *returnType);
4335 llvm::Value *EmitObjCAllocWithZone(llvm::Value *value,
4336 llvm::Type *returnType);
4337 llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
4338
4339 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
4340 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
4341 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
4342
4343 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
4344 llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
4345 bool allowUnsafeClaim);
4346 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
4347 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
4348 llvm::Value *EmitARCUnsafeUnretainedScalarExpr(const Expr *expr);
4349
4350 void EmitARCIntrinsicUse(ArrayRef<llvm::Value*> values);
4351
4352 void EmitARCNoopIntrinsicUse(ArrayRef<llvm::Value *> values);
4353
4354 static Destroyer destroyARCStrongImprecise;
4355 static Destroyer destroyARCStrongPrecise;
4356 static Destroyer destroyARCWeak;
4357 static Destroyer emitARCIntrinsicUse;
4358 static Destroyer destroyNonTrivialCStruct;
4359
4360 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
4361 llvm::Value *EmitObjCAutoreleasePoolPush();
4362 llvm::Value *EmitObjCMRRAutoreleasePoolPush();
4363 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
4364 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
4365
4366 /// Emits a reference binding to the passed in expression.
4367 RValue EmitReferenceBindingToExpr(const Expr *E);
4368
4369 //===--------------------------------------------------------------------===//
4370 // Expression Emission
4371 //===--------------------------------------------------------------------===//
4372
4373 // Expressions are broken into three classes: scalar, complex, aggregate.
4374
4375 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
4376 /// scalar type, returning the result.
4377 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
4378
4379 /// Emit a conversion from the specified type to the specified destination
4380 /// type, both of which are LLVM scalar types.
4381 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
4382 QualType DstTy, SourceLocation Loc);
4383
4384 /// Emit a conversion from the specified complex type to the specified
4385 /// destination type, where the destination type is an LLVM scalar type.
4386 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
4387 QualType DstTy,
4388 SourceLocation Loc);
4389
4390 /// EmitAggExpr - Emit the computation of the specified expression
4391 /// of aggregate type. The result is computed into the given slot,
4392 /// which may be null to indicate that the value is not needed.
4393 void EmitAggExpr(const Expr *E, AggValueSlot AS);
4394
4395 /// EmitAggExprToLValue - Emit the computation of the specified expression of
4396 /// aggregate type into a temporary LValue.
4397 LValue EmitAggExprToLValue(const Expr *E);
4398
4399 /// Build all the stores needed to initialize an aggregate at Dest with the
4400 /// value Val.
4401 void EmitAggregateStore(llvm::Value *Val, Address Dest, bool DestIsVolatile);
4402
4403 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
4404 /// make sure it survives garbage collection until this point.
4405 void EmitExtendGCLifetime(llvm::Value *object);
4406
4407 /// EmitComplexExpr - Emit the computation of the specified expression of
4408 /// complex type, returning the result.
4409 ComplexPairTy EmitComplexExpr(const Expr *E,
4410 bool IgnoreReal = false,
4411 bool IgnoreImag = false);
4412
4413 /// EmitComplexExprIntoLValue - Emit the given expression of complex
4414 /// type and place its result into the specified l-value.
4415 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
4416
4417 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
4418 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
4419
4420 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
4421 ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc);
4422
4423 ComplexPairTy EmitPromotedComplexExpr(const Expr *E, QualType PromotionType);
4424 llvm::Value *EmitPromotedScalarExpr(const Expr *E, QualType PromotionType);
4425 ComplexPairTy EmitPromotedValue(ComplexPairTy result, QualType PromotionType);
4426 ComplexPairTy EmitUnPromotedValue(ComplexPairTy result, QualType PromotionType);
4427
4428 Address emitAddrOfRealComponent(Address complex, QualType complexType);
4429 Address emitAddrOfImagComponent(Address complex, QualType complexType);
4430
4431 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
4432 /// global variable that has already been created for it. If the initializer
4433 /// has a different type than GV does, this may free GV and return a different
4434 /// one. Otherwise it just returns GV.
4435 llvm::GlobalVariable *
4436 AddInitializerToStaticVarDecl(const VarDecl &D,
4437 llvm::GlobalVariable *GV);
4438
4439 // Emit an @llvm.invariant.start call for the given memory region.
4440 void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
4441
4442 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
4443 /// variable with global storage.
4444 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV,
4445 bool PerformInit);
4446
4447 llvm::Function *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
4448 llvm::Constant *Addr);
4449
4450 llvm::Function *createTLSAtExitStub(const VarDecl &VD,
4451 llvm::FunctionCallee Dtor,
4452 llvm::Constant *Addr,
4453 llvm::FunctionCallee &AtExit);
4454
4455 /// Call atexit() with a function that passes the given argument to
4456 /// the given function.
4457 void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
4458 llvm::Constant *addr);
4459
4460 /// Call atexit() with function dtorStub.
4461 void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
4462
4463 /// Call unatexit() with function dtorStub.
4464 llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub);
4465
4466 /// Emit code in this function to perform a guarded variable
4467 /// initialization. Guarded initializations are used when it's not
4468 /// possible to prove that an initialization will be done exactly
4469 /// once, e.g. with a static local variable or a static data member
4470 /// of a class template.
4471 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
4472 bool PerformInit);
4473
4474 enum class GuardKind { VariableGuard, TlsGuard };
4475
4476 /// Emit a branch to select whether or not to perform guarded initialization.
4477 void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
4478 llvm::BasicBlock *InitBlock,
4479 llvm::BasicBlock *NoInitBlock,
4480 GuardKind Kind, const VarDecl *D);
4481
4482 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
4483 /// variables.
4484 void
4485 GenerateCXXGlobalInitFunc(llvm::Function *Fn,
4486 ArrayRef<llvm::Function *> CXXThreadLocals,
4487 ConstantAddress Guard = ConstantAddress::invalid());
4488
4489 /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
4490 /// variables.
4491 void GenerateCXXGlobalCleanUpFunc(
4492 llvm::Function *Fn,
4493 ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
4494 llvm::Constant *>>
4495 DtorsOrStermFinalizers);
4496
4497 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
4498 const VarDecl *D,
4499 llvm::GlobalVariable *Addr,
4500 bool PerformInit);
4501
4502 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
4503
4504 void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
4505
4506 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
4507
4508 RValue EmitAtomicExpr(AtomicExpr *E);
4509
4510 //===--------------------------------------------------------------------===//
4511 // Annotations Emission
4512 //===--------------------------------------------------------------------===//
4513
4514 /// Emit an annotation call (intrinsic).
4515 llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
4516 llvm::Value *AnnotatedVal,
4517 StringRef AnnotationStr,
4518 SourceLocation Location,
4519 const AnnotateAttr *Attr);
4520
4521 /// Emit local annotations for the local variable V, declared by D.
4522 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
4523
4524 /// Emit field annotations for the given field & value. Returns the
4525 /// annotation result.
4526 Address EmitFieldAnnotations(const FieldDecl *D, Address V);
4527
4528 //===--------------------------------------------------------------------===//
4529 // Internal Helpers
4530 //===--------------------------------------------------------------------===//
4531
4532 /// ContainsLabel - Return true if the statement contains a label in it. If
4533 /// this statement is not executed normally, it not containing a label means
4534 /// that we can just remove the code.
4535 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
4536
4537 /// containsBreak - Return true if the statement contains a break out of it.
4538 /// If the statement (recursively) contains a switch or loop with a break
4539 /// inside of it, this is fine.
4540 static bool containsBreak(const Stmt *S);
4541
4542 /// Determine if the given statement might introduce a declaration into the
4543 /// current scope, by being a (possibly-labelled) DeclStmt.
4544 static bool mightAddDeclToScope(const Stmt *S);
4545
4546 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
4547 /// to a constant, or if it does but contains a label, return false. If it
4548 /// constant folds return true and set the boolean result in Result.
4549 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result,
4550 bool AllowLabels = false);
4551
4552 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
4553 /// to a constant, or if it does but contains a label, return false. If it
4554 /// constant folds return true and set the folded value.
4555 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result,
4556 bool AllowLabels = false);
4557
4558 /// isInstrumentedCondition - Determine whether the given condition is an
4559 /// instrumentable condition (i.e. no "&&" or "||").
4560 static bool isInstrumentedCondition(const Expr *C);
4561
4562 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
4563 /// increments a profile counter based on the semantics of the given logical
4564 /// operator opcode. This is used to instrument branch condition coverage
4565 /// for logical operators.
4566 void EmitBranchToCounterBlock(const Expr *Cond, BinaryOperator::Opcode LOp,
4567 llvm::BasicBlock *TrueBlock,
4568 llvm::BasicBlock *FalseBlock,
4569 uint64_t TrueCount = 0,
4570 Stmt::Likelihood LH = Stmt::LH_None,
4571 const Expr *CntrIdx = nullptr);
4572
4573 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
4574 /// if statement) to the specified blocks. Based on the condition, this might
4575 /// try to simplify the codegen of the conditional based on the branch.
4576 /// TrueCount should be the number of times we expect the condition to
4577 /// evaluate to true based on PGO data.
4578 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
4579 llvm::BasicBlock *FalseBlock, uint64_t TrueCount,
4580 Stmt::Likelihood LH = Stmt::LH_None);
4581
4582 /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is
4583 /// nonnull, if \p LHS is marked _Nonnull.
4584 void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc);
4585
4586 /// An enumeration which makes it easier to specify whether or not an
4587 /// operation is a subtraction.
4588 enum { NotSubtraction = false, IsSubtraction = true };
4589
4590 /// Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to
4591 /// detect undefined behavior when the pointer overflow sanitizer is enabled.
4592 /// \p SignedIndices indicates whether any of the GEP indices are signed.
4593 /// \p IsSubtraction indicates whether the expression used to form the GEP
4594 /// is a subtraction.
4595 llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr,
4596 ArrayRef<llvm::Value *> IdxList,
4597 bool SignedIndices,
4598 bool IsSubtraction,
4599 SourceLocation Loc,
4600 const Twine &Name = "");
4601
4602 /// Specifies which type of sanitizer check to apply when handling a
4603 /// particular builtin.
4604 enum BuiltinCheckKind {
4605 BCK_CTZPassedZero,
4606 BCK_CLZPassedZero,
4607 };
4608
4609 /// Emits an argument for a call to a builtin. If the builtin sanitizer is
4610 /// enabled, a runtime check specified by \p Kind is also emitted.
4611 llvm::Value *EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind);
4612
4613 /// Emit a description of a type in a format suitable for passing to
4614 /// a runtime sanitizer handler.
4615 llvm::Constant *EmitCheckTypeDescriptor(QualType T);
4616
4617 /// Convert a value into a format suitable for passing to a runtime
4618 /// sanitizer handler.
4619 llvm::Value *EmitCheckValue(llvm::Value *V);
4620
4621 /// Emit a description of a source location in a format suitable for
4622 /// passing to a runtime sanitizer handler.
4623 llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc);
4624
4625 void EmitKCFIOperandBundle(const CGCallee &Callee,
4626 SmallVectorImpl<llvm::OperandBundleDef> &Bundles);
4627
4628 /// Create a basic block that will either trap or call a handler function in
4629 /// the UBSan runtime with the provided arguments, and create a conditional
4630 /// branch to it.
4631 void EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked,
4632 SanitizerHandler Check, ArrayRef<llvm::Constant *> StaticArgs,
4633 ArrayRef<llvm::Value *> DynamicArgs);
4634
4635 /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath
4636 /// if Cond if false.
4637 void EmitCfiSlowPathCheck(SanitizerMask Kind, llvm::Value *Cond,
4638 llvm::ConstantInt *TypeId, llvm::Value *Ptr,
4639 ArrayRef<llvm::Constant *> StaticArgs);
4640
4641 /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime
4642 /// checking is enabled. Otherwise, just emit an unreachable instruction.
4643 void EmitUnreachable(SourceLocation Loc);
4644
4645 /// Create a basic block that will call the trap intrinsic, and emit a
4646 /// conditional branch to it, for the -ftrapv checks.
4647 void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID);
4648
4649 /// Emit a call to trap or debugtrap and attach function attribute
4650 /// "trap-func-name" if specified.
4651 llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID);
4652
4653 /// Emit a stub for the cross-DSO CFI check function.
4654 void EmitCfiCheckStub();
4655
4656 /// Emit a cross-DSO CFI failure handling function.
4657 void EmitCfiCheckFail();
4658
4659 /// Create a check for a function parameter that may potentially be
4660 /// declared as non-null.
4661 void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc,
4662 AbstractCallee AC, unsigned ParmNum);
4663
4664 /// EmitCallArg - Emit a single call argument.
4665 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
4666
4667 /// EmitDelegateCallArg - We are performing a delegate call; that
4668 /// is, the current function is delegating to another one. Produce
4669 /// a r-value suitable for passing the given parameter.
4670 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param,
4671 SourceLocation loc);
4672
4673 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
4674 /// point operation, expressed as the maximum relative error in ulp.
4675 void SetFPAccuracy(llvm::Value *Val, float Accuracy);
4676
4677 /// Set the codegen fast-math flags.
4678 void SetFastMathFlags(FPOptions FPFeatures);
4679
4680 // Truncate or extend a boolean vector to the requested number of elements.
4681 llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec,
4682 unsigned NumElementsDst,
4683 const llvm::Twine &Name = "");
4684
4685 private:
4686 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
4687 void EmitReturnOfRValue(RValue RV, QualType Ty);
4688
4689 void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
4690
4691 llvm::SmallVector<std::pair<llvm::WeakTrackingVH, llvm::Value *>, 4>
4692 DeferredReplacements;
4693
4694 /// Set the address of a local variable.
4695 void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
4696 assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
4697 LocalDeclMap.insert({VD, Addr});
4698 }
4699
4700 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
4701 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
4702 ///
4703 /// \param AI - The first function argument of the expansion.
4704 void ExpandTypeFromArgs(QualType Ty, LValue Dst,
4705 llvm::Function::arg_iterator &AI);
4706
4707 /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg
4708 /// Ty, into individual arguments on the provided vector \arg IRCallArgs,
4709 /// starting at index \arg IRCallArgPos. See ABIArgInfo::Expand.
4710 void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
4711 SmallVectorImpl<llvm::Value *> &IRCallArgs,
4712 unsigned &IRCallArgPos);
4713
4714 std::pair<llvm::Value *, llvm::Type *>
4715 EmitAsmInput(const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr,
4716 std::string &ConstraintStr);
4717
4718 std::pair<llvm::Value *, llvm::Type *>
4719 EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue,
4720 QualType InputType, std::string &ConstraintStr,
4721 SourceLocation Loc);
4722
4723 /// Attempts to statically evaluate the object size of E. If that
4724 /// fails, emits code to figure the size of E out for us. This is
4725 /// pass_object_size aware.
4726 ///
4727 /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
4728 llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
4729 llvm::IntegerType *ResType,
4730 llvm::Value *EmittedE,
4731 bool IsDynamic);
4732
4733 /// Emits the size of E, as required by __builtin_object_size. This
4734 /// function is aware of pass_object_size parameters, and will act accordingly
4735 /// if E is a parameter with the pass_object_size attribute.
4736 llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type,
4737 llvm::IntegerType *ResType,
4738 llvm::Value *EmittedE,
4739 bool IsDynamic);
4740
4741 void emitZeroOrPatternForAutoVarInit(QualType type, const VarDecl &D,
4742 Address Loc);
4743
4744 public:
4745 enum class EvaluationOrder {
4746 ///! No language constraints on evaluation order.
4747 Default,
4748 ///! Language semantics require left-to-right evaluation.
4749 ForceLeftToRight,
4750 ///! Language semantics require right-to-left evaluation.
4751 ForceRightToLeft
4752 };
4753
4754 // Wrapper for function prototype sources. Wraps either a FunctionProtoType or
4755 // an ObjCMethodDecl.
4756 struct PrototypeWrapper {
4757 llvm::PointerUnion<const FunctionProtoType *, const ObjCMethodDecl *> P;
4758
4759 PrototypeWrapper(const FunctionProtoType *FT) : P(FT) {}
4760 PrototypeWrapper(const ObjCMethodDecl *MD) : P(MD) {}
4761 };
4762
4763 void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype,
4764 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
4765 AbstractCallee AC = AbstractCallee(),
4766 unsigned ParamsToSkip = 0,
4767 EvaluationOrder Order = EvaluationOrder::Default);
4768
4769 /// EmitPointerWithAlignment - Given an expression with a pointer type,
4770 /// emit the value and compute our best estimate of the alignment of the
4771 /// pointee.
4772 ///
4773 /// \param BaseInfo - If non-null, this will be initialized with
4774 /// information about the source of the alignment and the may-alias
4775 /// attribute. Note that this function will conservatively fall back on
4776 /// the type when it doesn't recognize the expression and may-alias will
4777 /// be set to false.
4778 ///
4779 /// One reasonable way to use this information is when there's a language
4780 /// guarantee that the pointer must be aligned to some stricter value, and
4781 /// we're simply trying to ensure that sufficiently obvious uses of under-
4782 /// aligned objects don't get miscompiled; for example, a placement new
4783 /// into the address of a local variable. In such a case, it's quite
4784 /// reasonable to just ignore the returned alignment when it isn't from an
4785 /// explicit source.
4786 Address EmitPointerWithAlignment(const Expr *Addr,
4787 LValueBaseInfo *BaseInfo = nullptr,
4788 TBAAAccessInfo *TBAAInfo = nullptr);
4789
4790 /// If \p E references a parameter with pass_object_size info or a constant
4791 /// array size modifier, emit the object size divided by the size of \p EltTy.
4792 /// Otherwise return null.
4793 llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy);
4794
4795 void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK);
4796
4797 struct MultiVersionResolverOption {
4798 llvm::Function *Function;
4799 struct Conds {
4800 StringRef Architecture;
4801 llvm::SmallVector<StringRef, 8> Features;
4802
4803 Conds(StringRef Arch, ArrayRef<StringRef> Feats)
4804 : Architecture(Arch), Features(Feats.begin(), Feats.end()) {}
4805 } Conditions;
4806
4807 MultiVersionResolverOption(llvm::Function *F, StringRef Arch,
4808 ArrayRef<StringRef> Feats)
4809 : Function(F), Conditions(Arch, Feats) {}
4810 };
4811
4812 // Emits the body of a multiversion function's resolver. Assumes that the
4813 // options are already sorted in the proper order, with the 'default' option
4814 // last (if it exists).
4815 void EmitMultiVersionResolver(llvm::Function *Resolver,
4816 ArrayRef<MultiVersionResolverOption> Options);
4817 void
4818 EmitX86MultiVersionResolver(llvm::Function *Resolver,
4819 ArrayRef<MultiVersionResolverOption> Options);
4820 void
4821 EmitAArch64MultiVersionResolver(llvm::Function *Resolver,
4822 ArrayRef<MultiVersionResolverOption> Options);
4823
4824 private:
4825 QualType getVarArgType(const Expr *Arg);
4826
4827 void EmitDeclMetadata();
4828
4829 BlockByrefHelpers *buildByrefHelpers(llvm::StructType &byrefType,
4830 const AutoVarEmission &emission);
4831
4832 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
4833
4834 llvm::Value *GetValueForARMHint(unsigned BuiltinID);
4835 llvm::Value *EmitX86CpuIs(const CallExpr *E);
4836 llvm::Value *EmitX86CpuIs(StringRef CPUStr);
4837 llvm::Value *EmitX86CpuSupports(const CallExpr *E);
4838 llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs);
4839 llvm::Value *EmitX86CpuSupports(uint64_t Mask);
4840 llvm::Value *EmitX86CpuInit();
4841 llvm::Value *FormX86ResolverCondition(const MultiVersionResolverOption &RO);
4842 llvm::Value *EmitAArch64CpuInit();
4843 llvm::Value *
4844 FormAArch64ResolverCondition(const MultiVersionResolverOption &RO);
4845 llvm::Value *EmitAArch64CpuSupports(ArrayRef<StringRef> FeatureStrs);
4846 };
4847
4848
4849 inline DominatingLLVMValue::saved_type
4850 DominatingLLVMValue::save(CodeGenFunction &CGF, llvm::Value *value) {
4851 if (!needsSaving(value)) return saved_type(value, false);
4852
4853 // Otherwise, we need an alloca.
4854 auto align = CharUnits::fromQuantity(
4855 CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
4856 Address alloca =
4857 CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
4858 CGF.Builder.CreateStore(value, alloca);
4859
4860 return saved_type(alloca.getPointer(), true);
4861 }
4862
4863 inline llvm::Value *DominatingLLVMValue::restore(CodeGenFunction &CGF,
4864 saved_type value) {
4865 // If the value says it wasn't saved, trust that it's still dominating.
4866 if (!value.getInt()) return value.getPointer();
4867
4868 // Otherwise, it should be an alloca instruction, as set up in save().
4869 auto alloca = cast<llvm::AllocaInst>(value.getPointer());
4870 return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca,
4871 alloca->getAlign());
4872 }
4873
4874 } // end namespace CodeGen
4875
4876 // Map the LangOption for floating point exception behavior into
4877 // the corresponding enum in the IR.
4878 llvm::fp::ExceptionBehavior
4879 ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind);
4880 } // end namespace clang
4881
4882 #endif