clang  14.0.0git
CodeGenFunction.h
Go to the documentation of this file.
1 //===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This is the internal per-function state used for llvm translation.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H
14 #define LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H
15 
16 #include "CGBuilder.h"
17 #include "CGDebugInfo.h"
18 #include "CGLoopInfo.h"
19 #include "CGValue.h"
20 #include "CodeGenModule.h"
21 #include "CodeGenPGO.h"
22 #include "EHScopeStack.h"
23 #include "VarBypassDetector.h"
24 #include "clang/AST/CharUnits.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/ExprOpenMP.h"
29 #include "clang/AST/StmtOpenMP.h"
30 #include "clang/AST/Type.h"
31 #include "clang/Basic/ABI.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 
45 namespace llvm {
46 class BasicBlock;
47 class LLVMContext;
48 class MDNode;
49 class SwitchInst;
50 class Twine;
51 class Value;
52 class CanonicalLoopInfo;
53 }
54 
55 namespace clang {
56 class ASTContext;
57 class CXXDestructorDecl;
58 class CXXForRangeStmt;
59 class CXXTryStmt;
60 class Decl;
61 class LabelDecl;
62 class FunctionDecl;
63 class FunctionProtoType;
64 class LabelStmt;
65 class ObjCContainerDecl;
66 class ObjCInterfaceDecl;
67 class ObjCIvarDecl;
68 class ObjCMethodDecl;
69 class ObjCImplementationDecl;
70 class ObjCPropertyImplDecl;
71 class TargetInfo;
72 class VarDecl;
73 class ObjCForCollectionStmt;
74 class ObjCAtTryStmt;
75 class ObjCAtThrowStmt;
76 class ObjCAtSynchronizedStmt;
77 class ObjCAutoreleasePoolStmt;
78 class OMPUseDevicePtrClause;
79 class OMPUseDeviceAddrClause;
80 class SVETypeFlags;
81 class OMPExecutableDirective;
82 
83 namespace analyze_os_log {
84 class OSLogBufferLayout;
85 }
86 
87 namespace CodeGen {
88 class CodeGenTypes;
89 class CGCallee;
90 class CGFunctionInfo;
91 class CGBlockInfo;
92 class CGCXXABI;
93 class BlockByrefHelpers;
94 class BlockByrefInfo;
95 class BlockFieldFlags;
96 class RegionCodeGenTy;
97 class TargetCodeGenInfo;
98 struct OMPTaskDataTy;
99 struct CGCoroData;
100 
101 /// The kind of evaluation to perform on values of a particular
102 /// type. Basically, is the code in CGExprScalar, CGExprComplex, or
103 /// CGExprAgg?
104 ///
105 /// TODO: should vectors maybe be split out into their own thing?
110 };
111 
112 #define LIST_SANITIZER_CHECKS \
113  SANITIZER_CHECK(AddOverflow, add_overflow, 0) \
114  SANITIZER_CHECK(BuiltinUnreachable, builtin_unreachable, 0) \
115  SANITIZER_CHECK(CFICheckFail, cfi_check_fail, 0) \
116  SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0) \
117  SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0) \
118  SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0) \
119  SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 1) \
120  SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0) \
121  SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0) \
122  SANITIZER_CHECK(InvalidObjCCast, invalid_objc_cast, 0) \
123  SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0) \
124  SANITIZER_CHECK(MissingReturn, missing_return, 0) \
125  SANITIZER_CHECK(MulOverflow, mul_overflow, 0) \
126  SANITIZER_CHECK(NegateOverflow, negate_overflow, 0) \
127  SANITIZER_CHECK(NullabilityArg, nullability_arg, 0) \
128  SANITIZER_CHECK(NullabilityReturn, nullability_return, 1) \
129  SANITIZER_CHECK(NonnullArg, nonnull_arg, 0) \
130  SANITIZER_CHECK(NonnullReturn, nonnull_return, 1) \
131  SANITIZER_CHECK(OutOfBounds, out_of_bounds, 0) \
132  SANITIZER_CHECK(PointerOverflow, pointer_overflow, 0) \
133  SANITIZER_CHECK(ShiftOutOfBounds, shift_out_of_bounds, 0) \
134  SANITIZER_CHECK(SubOverflow, sub_overflow, 0) \
135  SANITIZER_CHECK(TypeMismatch, type_mismatch, 1) \
136  SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0) \
137  SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0)
138 
140 #define SANITIZER_CHECK(Enum, Name, Version) Enum,
142 #undef SANITIZER_CHECK
143 };
144 
145 /// Helper class with most of the code for saving a value for a
146 /// conditional expression cleanup.
148  typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
149 
150  /// Answer whether the given value needs extra work to be saved.
151  static bool needsSaving(llvm::Value *value) {
152  // If it's not an instruction, we don't need to save.
153  if (!isa<llvm::Instruction>(value)) return false;
154 
155  // If it's an instruction in the entry block, we don't need to save.
156  llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
157  return (block != &block->getParent()->getEntryBlock());
158  }
159 
160  static saved_type save(CodeGenFunction &CGF, llvm::Value *value);
161  static llvm::Value *restore(CodeGenFunction &CGF, saved_type value);
162 };
163 
164 /// A partial specialization of DominatingValue for llvm::Values that
165 /// might be llvm::Instructions.
166 template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
167  typedef T *type;
168  static type restore(CodeGenFunction &CGF, saved_type value) {
169  return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
170  }
171 };
172 
173 /// A specialization of DominatingValue for Address.
174 template <> struct DominatingValue<Address> {
175  typedef Address type;
176 
177  struct saved_type {
179  llvm::Type *ElementType;
181  };
182 
183  static bool needsSaving(type value) {
185  }
186  static saved_type save(CodeGenFunction &CGF, type value) {
187  return { DominatingLLVMValue::save(CGF, value.getPointer()),
188  value.getElementType(), value.getAlignment() };
189  }
190  static type restore(CodeGenFunction &CGF, saved_type value) {
191  return Address(DominatingLLVMValue::restore(CGF, value.SavedValue),
192  value.ElementType, value.Alignment);
193  }
194 };
195 
196 /// A specialization of DominatingValue for RValue.
197 template <> struct DominatingValue<RValue> {
198  typedef RValue type;
199  class saved_type {
200  enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
201  AggregateAddress, ComplexAddress };
202 
204  unsigned K : 3;
205  unsigned Align : 29;
206  saved_type(llvm::Value *v, Kind k, unsigned a = 0)
207  : Value(v), K(k), Align(a) {}
208 
209  public:
210  static bool needsSaving(RValue value);
211  static saved_type save(CodeGenFunction &CGF, RValue value);
213 
214  // implementations in CGCleanup.cpp
215  };
216 
217  static bool needsSaving(type value) {
218  return saved_type::needsSaving(value);
219  }
220  static saved_type save(CodeGenFunction &CGF, type value) {
221  return saved_type::save(CGF, value);
222  }
223  static type restore(CodeGenFunction &CGF, saved_type value) {
224  return value.restore(CGF);
225  }
226 };
227 
228 /// CodeGenFunction - This class organizes the per-function state that is used
229 /// while generating LLVM code.
231  CodeGenFunction(const CodeGenFunction &) = delete;
232  void operator=(const CodeGenFunction &) = delete;
233 
234  friend class CGCXXABI;
235 public:
236  /// A jump destination is an abstract label, branching to which may
237  /// require a jump out through normal cleanups.
238  struct JumpDest {
239  JumpDest() : Block(nullptr), Index(0) {}
240  JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth,
241  unsigned Index)
242  : Block(Block), ScopeDepth(Depth), Index(Index) {}
243 
244  bool isValid() const { return Block != nullptr; }
245  llvm::BasicBlock *getBlock() const { return Block; }
246  EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
247  unsigned getDestIndex() const { return Index; }
248 
249  // This should be used cautiously.
251  ScopeDepth = depth;
252  }
253 
254  private:
255  llvm::BasicBlock *Block;
257  unsigned Index;
258  };
259 
260  CodeGenModule &CGM; // Per-module state.
262 
263  // For EH/SEH outlined funclets, this field points to parent's CGF
265 
266  typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
269 
270  // Stores variables for which we can't generate correct lifetime markers
271  // because of jumps.
273 
274  /// List of recently emitted OMPCanonicalLoops.
275  ///
276  /// Since OMPCanonicalLoops are nested inside other statements (in particular
277  /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
278  /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its
279  /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any
280  /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to
281  /// this stack when done. Entering a new loop requires clearing this list; it
282  /// either means we start parsing a new loop nest (in which case the previous
283  /// loop nest goes out of scope) or a second loop in the same level in which
284  /// case it would be ambiguous into which of the two (or more) loops the loop
285  /// nest would extend.
287 
288  /// Number of nested loop to be consumed by the last surrounding
289  /// loop-associated directive.
291 
292  // CodeGen lambda for loops and support for ordered clause
293  typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
294  JumpDest)>
296  typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
297  const unsigned, const bool)>
299 
300  // Codegen lambda for loop bounds in worksharing loop constructs
301  typedef llvm::function_ref<std::pair<LValue, LValue>(
304 
305  // Codegen lambda for loop bounds in dispatch-based loop implementation
306  typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
308  Address UB)>
310 
311  /// CGBuilder insert helper. This function is called after an
312  /// instruction is created using Builder.
313  void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
314  llvm::BasicBlock *BB,
315  llvm::BasicBlock::iterator InsertPt) const;
316 
317  /// CurFuncDecl - Holds the Decl for the current outermost
318  /// non-closure context.
320  /// CurCodeDecl - This is the inner-most code context, which includes blocks.
324  llvm::Function *CurFn = nullptr;
325 
326  /// Save Parameter Decl for coroutine.
328 
329  // Holds coroutine data if the current function is a coroutine. We use a
330  // wrapper to manage its lifetime, so that we don't have to define CGCoroData
331  // in this header.
332  struct CGCoroInfo {
333  std::unique_ptr<CGCoroData> Data;
334  CGCoroInfo();
335  ~CGCoroInfo();
336  };
338 
339  bool isCoroutine() const {
340  return CurCoro.Data != nullptr;
341  }
342 
343  /// CurGD - The GlobalDecl for the current function being compiled.
345 
346  /// PrologueCleanupDepth - The cleanup depth enclosing all the
347  /// cleanups associated with the parameters.
349 
350  /// ReturnBlock - Unified return block.
352 
353  /// ReturnValue - The temporary alloca to hold the return
354  /// value. This is invalid iff the function has no return value.
356 
357  /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
358  /// This is invalid if sret is not in use.
360 
361  /// If a return statement is being visited, this holds the return statment's
362  /// result expression.
363  const Expr *RetExpr = nullptr;
364 
365  /// Return true if a label was seen in the current scope.
367  if (CurLexicalScope)
368  return CurLexicalScope->hasLabels();
369  return !LabelMap.empty();
370  }
371 
372  /// AllocaInsertPoint - This is an instruction in the entry block before which
373  /// we prefer to insert allocas.
374  llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
375 
376 private:
377  /// PostAllocaInsertPt - This is a place in the prologue where code can be
378  /// inserted that will be dominated by all the static allocas. This helps
379  /// achieve two things:
380  /// 1. Contiguity of all static allocas (within the prologue) is maintained.
381  /// 2. All other prologue code (which are dominated by static allocas) do
382  /// appear in the source order immediately after all static allocas.
383  ///
384  /// PostAllocaInsertPt will be lazily created when it is *really* required.
385  llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr;
386 
387 public:
388  /// Return PostAllocaInsertPt. If it is not yet created, then insert it
389  /// immediately after AllocaInsertPt.
390  llvm::Instruction *getPostAllocaInsertPoint() {
391  if (!PostAllocaInsertPt) {
392  assert(AllocaInsertPt &&
393  "Expected static alloca insertion point at function prologue");
394  assert(AllocaInsertPt->getParent()->isEntryBlock() &&
395  "EBB should be entry block of the current code gen function");
396  PostAllocaInsertPt = AllocaInsertPt->clone();
397  PostAllocaInsertPt->setName("postallocapt");
398  PostAllocaInsertPt->insertAfter(AllocaInsertPt);
399  }
400 
401  return PostAllocaInsertPt;
402  }
403 
404  /// API for captured statement code generation.
406  public:
408  : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
409  explicit CGCapturedStmtInfo(const CapturedStmt &S,
411  : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
412 
414  S.getCapturedRecordDecl()->field_begin();
415  for (CapturedStmt::const_capture_iterator I = S.capture_begin(),
416  E = S.capture_end();
417  I != E; ++I, ++Field) {
418  if (I->capturesThis())
419  CXXThisFieldDecl = *Field;
420  else if (I->capturesVariable())
421  CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
422  else if (I->capturesVariableByCopy())
423  CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
424  }
425  }
426 
427  virtual ~CGCapturedStmtInfo();
428 
429  CapturedRegionKind getKind() const { return Kind; }
430 
431  virtual void setContextValue(llvm::Value *V) { ThisValue = V; }
432  // Retrieve the value of the context parameter.
433  virtual llvm::Value *getContextValue() const { return ThisValue; }
434 
435  /// Lookup the captured field decl for a variable.
436  virtual const FieldDecl *lookup(const VarDecl *VD) const {
437  return CaptureFields.lookup(VD->getCanonicalDecl());
438  }
439 
440  bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; }
441  virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; }
442 
443  static bool classof(const CGCapturedStmtInfo *) {
444  return true;
445  }
446 
447  /// Emit the captured statement body.
448  virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
450  CGF.EmitStmt(S);
451  }
452 
453  /// Get the name of the capture helper.
454  virtual StringRef getHelperName() const { return "__captured_stmt"; }
455 
456  /// Get the CaptureFields
457  llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() {
458  return CaptureFields;
459  }
460 
461  private:
462  /// The kind of captured statement being generated.
463  CapturedRegionKind Kind;
464 
465  /// Keep the map between VarDecl and FieldDecl.
466  llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields;
467 
468  /// The base address of the captured record, passed in as the first
469  /// argument of the parallel region function.
470  llvm::Value *ThisValue;
471 
472  /// Captured 'this' type.
473  FieldDecl *CXXThisFieldDecl;
474  };
476 
477  /// RAII for correct setting/restoring of CapturedStmtInfo.
479  private:
480  CodeGenFunction &CGF;
481  CGCapturedStmtInfo *PrevCapturedStmtInfo;
482  public:
484  CGCapturedStmtInfo *NewCapturedStmtInfo)
485  : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
486  CGF.CapturedStmtInfo = NewCapturedStmtInfo;
487  }
488  ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
489  };
490 
491  /// An abstract representation of regular/ObjC call/message targets.
493  /// The function declaration of the callee.
494  const Decl *CalleeDecl;
495 
496  public:
497  AbstractCallee() : CalleeDecl(nullptr) {}
498  AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
499  AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {}
500  bool hasFunctionDecl() const {
501  return isa_and_nonnull<FunctionDecl>(CalleeDecl);
502  }
503  const Decl *getDecl() const { return CalleeDecl; }
504  unsigned getNumParams() const {
505  if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
506  return FD->getNumParams();
507  return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
508  }
509  const ParmVarDecl *getParamDecl(unsigned I) const {
510  if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl))
511  return FD->getParamDecl(I);
512  return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
513  }
514  };
515 
516  /// Sanitizers enabled for this function.
518 
519  /// True if CodeGen currently emits code implementing sanitizer checks.
520  bool IsSanitizerScope = false;
521 
522  /// RAII object to set/unset CodeGenFunction::IsSanitizerScope.
524  CodeGenFunction *CGF;
525  public:
527  ~SanitizerScope();
528  };
529 
530  /// In C++, whether we are code generating a thunk. This controls whether we
531  /// should emit cleanups.
532  bool CurFuncIsThunk = false;
533 
534  /// In ARC, whether we should autorelease the return value.
535  bool AutoreleaseResult = false;
536 
537  /// Whether we processed a Microsoft-style asm block during CodeGen. These can
538  /// potentially set the return value.
539  bool SawAsmBlock = false;
540 
541  const NamedDecl *CurSEHParent = nullptr;
542 
543  /// True if the current function is an outlined SEH helper. This can be a
544  /// finally block or filter expression.
545  bool IsOutlinedSEHHelper = false;
546 
547  /// True if CodeGen currently emits code inside presereved access index
548  /// region.
549  bool IsInPreservedAIRegion = false;
550 
551  /// True if the current statement has nomerge attribute.
553 
554  // The CallExpr within the current statement that the musttail attribute
555  // applies to. nullptr if there is no 'musttail' on the current statement.
556  const CallExpr *MustTailCall = nullptr;
557 
558  /// Returns true if a function must make progress, which means the
559  /// mustprogress attribute can be added.
561  if (CGM.getCodeGenOpts().getFiniteLoops() ==
562  CodeGenOptions::FiniteLoopsKind::Never)
563  return false;
564 
565  // C++11 and later guarantees that a thread eventually will do one of the
566  // following (6.9.2.3.1 in C++11):
567  // - terminate,
568  // - make a call to a library I/O function,
569  // - perform an access through a volatile glvalue, or
570  // - perform a synchronization operation or an atomic operation.
571  //
572  // Hence each function is 'mustprogress' in C++11 or later.
573  return getLangOpts().CPlusPlus11;
574  }
575 
576  /// Returns true if a loop must make progress, which means the mustprogress
577  /// attribute can be added. \p HasConstantCond indicates whether the branch
578  /// condition is a known constant.
579  bool checkIfLoopMustProgress(bool HasConstantCond) {
580  if (CGM.getCodeGenOpts().getFiniteLoops() ==
581  CodeGenOptions::FiniteLoopsKind::Always)
582  return true;
583  if (CGM.getCodeGenOpts().getFiniteLoops() ==
584  CodeGenOptions::FiniteLoopsKind::Never)
585  return false;
586 
587  // If the containing function must make progress, loops also must make
588  // progress (as in C++11 and later).
590  return true;
591 
592  // Now apply rules for plain C (see 6.8.5.6 in C11).
593  // Loops with constant conditions do not have to make progress in any C
594  // version.
595  if (HasConstantCond)
596  return false;
597 
598  // Loops with non-constant conditions must make progress in C11 and later.
599  return getLangOpts().C11;
600  }
601 
602  const CodeGen::CGBlockInfo *BlockInfo = nullptr;
604 
605  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
607 
608  /// A mapping from NRVO variables to the flags used to indicate
609  /// when the NRVO has been applied to this variable.
610  llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
611 
615 
616  llvm::Instruction *CurrentFuncletPad = nullptr;
617 
618  class CallLifetimeEnd final : public EHScopeStack::Cleanup {
619  bool isRedundantBeforeReturn() override { return true; }
620 
621  llvm::Value *Addr;
622  llvm::Value *Size;
623 
624  public:
626  : Addr(addr.getPointer()), Size(size) {}
627 
628  void Emit(CodeGenFunction &CGF, Flags flags) override {
629  CGF.EmitLifetimeEnd(Size, Addr);
630  }
631  };
632 
633  /// Header for data within LifetimeExtendedCleanupStack.
635  /// The size of the following cleanup object.
636  unsigned Size;
637  /// The kind of cleanup to push: a value from the CleanupKind enumeration.
638  unsigned Kind : 31;
639  /// Whether this is a conditional cleanup.
640  unsigned IsConditional : 1;
641 
642  size_t getSize() const { return Size; }
643  CleanupKind getKind() const { return (CleanupKind)Kind; }
644  bool isConditional() const { return IsConditional; }
645  };
646 
647  /// i32s containing the indexes of the cleanup destinations.
649 
650  unsigned NextCleanupDestIndex = 1;
651 
652  /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
653  llvm::BasicBlock *EHResumeBlock = nullptr;
654 
655  /// The exception slot. All landing pads write the current exception pointer
656  /// into this alloca.
658 
659  /// The selector slot. Under the MandatoryCleanup model, all landing pads
660  /// write the current selector value into this alloca.
661  llvm::AllocaInst *EHSelectorSlot = nullptr;
662 
663  /// A stack of exception code slots. Entering an __except block pushes a slot
664  /// on the stack and leaving pops one. The __exception_code() intrinsic loads
665  /// a value from the top of the stack.
667 
668  /// Value returned by __exception_info intrinsic.
669  llvm::Value *SEHInfo = nullptr;
670 
671  /// Emits a landing pad for the current EH stack.
672  llvm::BasicBlock *EmitLandingPad();
673 
674  llvm::BasicBlock *getInvokeDestImpl();
675 
676  /// Parent loop-based directive for scan directive.
678  llvm::BasicBlock *OMPBeforeScanBlock = nullptr;
679  llvm::BasicBlock *OMPAfterScanBlock = nullptr;
680  llvm::BasicBlock *OMPScanExitBlock = nullptr;
681  llvm::BasicBlock *OMPScanDispatch = nullptr;
682  bool OMPFirstScanLoop = false;
683 
684  /// Manages parent directive for scan directives.
686  CodeGenFunction &CGF;
687  const OMPExecutableDirective *ParentLoopDirectiveForScan;
688 
689  public:
691  CodeGenFunction &CGF,
692  const OMPExecutableDirective &ParentLoopDirectiveForScan)
693  : CGF(CGF),
694  ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) {
695  CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan;
696  }
698  CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan;
699  }
700  };
701 
702  template <class T>
704  return DominatingValue<T>::save(*this, value);
705  }
706 
708  public:
709  CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures);
710  CGFPOptionsRAII(CodeGenFunction &CGF, const Expr *E);
712 
713  private:
714  void ConstructorHelper(FPOptions FPFeatures);
715  CodeGenFunction &CGF;
716  FPOptions OldFPFeatures;
717  llvm::fp::ExceptionBehavior OldExcept;
718  llvm::RoundingMode OldRounding;
720  };
722 
723 public:
724  /// ObjCEHValueStack - Stack of Objective-C exception values, used for
725  /// rethrows.
727 
728  /// A class controlling the emission of a finally block.
729  class FinallyInfo {
730  /// Where the catchall's edge through the cleanup should go.
731  JumpDest RethrowDest;
732 
733  /// A function to call to enter the catch.
734  llvm::FunctionCallee BeginCatchFn;
735 
736  /// An i1 variable indicating whether or not the @finally is
737  /// running for an exception.
738  llvm::AllocaInst *ForEHVar;
739 
740  /// An i8* variable into which the exception pointer to rethrow
741  /// has been saved.
742  llvm::AllocaInst *SavedExnVar;
743 
744  public:
745  void enter(CodeGenFunction &CGF, const Stmt *Finally,
746  llvm::FunctionCallee beginCatchFn,
747  llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
748  void exit(CodeGenFunction &CGF);
749  };
750 
751  /// Returns true inside SEH __try blocks.
752  bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); }
753 
754  /// Returns true while emitting a cleanuppad.
755  bool isCleanupPadScope() const {
756  return CurrentFuncletPad && isa<llvm::CleanupPadInst>(CurrentFuncletPad);
757  }
758 
759  /// pushFullExprCleanup - Push a cleanup to be run at the end of the
760  /// current full-expression. Safe against the possibility that
761  /// we're currently inside a conditionally-evaluated expression.
762  template <class T, class... As>
764  // If we're not in a conditional branch, or if none of the
765  // arguments requires saving, then use the unconditional cleanup.
766  if (!isInConditionalBranch())
767  return EHStack.pushCleanup<T>(kind, A...);
768 
769  // Stash values in a tuple so we can guarantee the order of saves.
770  typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
771  SavedTuple Saved{saveValueInCond(A)...};
772 
773  typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
774  EHStack.pushCleanupTuple<CleanupType>(kind, Saved);
776  }
777 
778  /// Queue a cleanup to be pushed after finishing the current full-expression,
779  /// potentially with an active flag.
780  template <class T, class... As>
782  if (!isInConditionalBranch())
783  return pushCleanupAfterFullExprWithActiveFlag<T>(Kind, Address::invalid(),
784  A...);
785 
786  Address ActiveFlag = createCleanupActiveFlag();
787  assert(!DominatingValue<Address>::needsSaving(ActiveFlag) &&
788  "cleanup active flag should never need saving");
789 
790  typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple;
791  SavedTuple Saved{saveValueInCond(A)...};
792 
793  typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
794  pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved);
795  }
796 
797  template <class T, class... As>
799  Address ActiveFlag, As... A) {
800  LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind,
801  ActiveFlag.isValid()};
802 
803  size_t OldSize = LifetimeExtendedCleanupStack.size();
805  LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size +
806  (Header.IsConditional ? sizeof(ActiveFlag) : 0));
807 
808  static_assert(sizeof(Header) % alignof(T) == 0,
809  "Cleanup will be allocated on misaligned address");
810  char *Buffer = &LifetimeExtendedCleanupStack[OldSize];
811  new (Buffer) LifetimeExtendedCleanupHeader(Header);
812  new (Buffer + sizeof(Header)) T(A...);
813  if (Header.IsConditional)
814  new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag);
815  }
816 
817  /// Set up the last cleanup that was pushed as a conditional
818  /// full-expression cleanup.
821  }
822 
823  void initFullExprCleanupWithFlag(Address ActiveFlag);
825 
826  /// PushDestructorCleanup - Push a cleanup to call the
827  /// complete-object destructor of an object of the given type at the
828  /// given address. Does nothing if T is not a C++ class type with a
829  /// non-trivial destructor.
830  void PushDestructorCleanup(QualType T, Address Addr);
831 
832  /// PushDestructorCleanup - Push a cleanup to call the
833  /// complete-object variant of the given destructor on the object at
834  /// the given address.
836  Address Addr);
837 
838  /// PopCleanupBlock - Will pop the cleanup entry on the stack and
839  /// process all branch fixups.
840  void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
841 
842  /// DeactivateCleanupBlock - Deactivates the given cleanup block.
843  /// The block cannot be reactivated. Pops it if it's the top of the
844  /// stack.
845  ///
846  /// \param DominatingIP - An instruction which is known to
847  /// dominate the current IP (if set) and which lies along
848  /// all paths of execution between the current IP and the
849  /// the point at which the cleanup comes into scope.
851  llvm::Instruction *DominatingIP);
852 
853  /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
854  /// Cannot be used to resurrect a deactivated cleanup.
855  ///
856  /// \param DominatingIP - An instruction which is known to
857  /// dominate the current IP (if set) and which lies along
858  /// all paths of execution between the current IP and the
859  /// the point at which the cleanup comes into scope.
861  llvm::Instruction *DominatingIP);
862 
863  /// Enters a new scope for capturing cleanups, all of which
864  /// will be executed once the scope is exited.
866  EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth;
867  size_t LifetimeExtendedCleanupStackSize;
868  bool OldDidCallStackSave;
869  protected:
871  private:
872 
873  RunCleanupsScope(const RunCleanupsScope &) = delete;
874  void operator=(const RunCleanupsScope &) = delete;
875 
876  protected:
878 
879  public:
880  /// Enter a new cleanup scope.
883  {
884  CleanupStackDepth = CGF.EHStack.stable_begin();
885  LifetimeExtendedCleanupStackSize =
887  OldDidCallStackSave = CGF.DidCallStackSave;
888  CGF.DidCallStackSave = false;
889  OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth;
890  CGF.CurrentCleanupScopeDepth = CleanupStackDepth;
891  }
892 
893  /// Exit this cleanup scope, emitting any accumulated cleanups.
895  if (PerformCleanup)
896  ForceCleanup();
897  }
898 
899  /// Determine whether this scope requires any cleanups.
900  bool requiresCleanups() const {
901  return CGF.EHStack.stable_begin() != CleanupStackDepth;
902  }
903 
904  /// Force the emission of cleanups now, instead of waiting
905  /// until this object is destroyed.
906  /// \param ValuesToReload - A list of values that need to be available at
907  /// the insertion point after cleanup emission. If cleanup emission created
908  /// a shared cleanup block, these value pointers will be rewritten.
909  /// Otherwise, they not will be modified.
910  void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
911  assert(PerformCleanup && "Already forced cleanup");
912  CGF.DidCallStackSave = OldDidCallStackSave;
913  CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
914  ValuesToReload);
915  PerformCleanup = false;
916  CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
917  }
918  };
919 
920  // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
923 
925  SourceRange Range;
927  LexicalScope *ParentScope;
928 
929  LexicalScope(const LexicalScope &) = delete;
930  void operator=(const LexicalScope &) = delete;
931 
932  public:
933  /// Enter a new cleanup scope.
935  : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) {
936  CGF.CurLexicalScope = this;
937  if (CGDebugInfo *DI = CGF.getDebugInfo())
938  DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
939  }
940 
941  void addLabel(const LabelDecl *label) {
942  assert(PerformCleanup && "adding label to dead scope?");
943  Labels.push_back(label);
944  }
945 
946  /// Exit this cleanup scope, emitting any accumulated
947  /// cleanups.
949  if (CGDebugInfo *DI = CGF.getDebugInfo())
950  DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
951 
952  // If we should perform a cleanup, force them now. Note that
953  // this ends the cleanup scope before rescoping any labels.
954  if (PerformCleanup) {
955  ApplyDebugLocation DL(CGF, Range.getEnd());
956  ForceCleanup();
957  }
958  }
959 
960  /// Force the emission of cleanups now, instead of waiting
961  /// until this object is destroyed.
962  void ForceCleanup() {
963  CGF.CurLexicalScope = ParentScope;
965 
966  if (!Labels.empty())
967  rescopeLabels();
968  }
969 
970  bool hasLabels() const {
971  return !Labels.empty();
972  }
973 
974  void rescopeLabels();
975  };
976 
977  typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
978 
979  /// The class used to assign some variables some temporarily addresses.
980  class OMPMapVars {
981  DeclMapTy SavedLocals;
982  DeclMapTy SavedTempAddresses;
983  OMPMapVars(const OMPMapVars &) = delete;
984  void operator=(const OMPMapVars &) = delete;
985 
986  public:
987  explicit OMPMapVars() = default;
989  assert(SavedLocals.empty() && "Did not restored original addresses.");
990  };
991 
992  /// Sets the address of the variable \p LocalVD to be \p TempAddr in
993  /// function \p CGF.
994  /// \return true if at least one variable was set already, false otherwise.
995  bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD,
996  Address TempAddr) {
997  LocalVD = LocalVD->getCanonicalDecl();
998  // Only save it once.
999  if (SavedLocals.count(LocalVD)) return false;
1000 
1001  // Copy the existing local entry to SavedLocals.
1002  auto it = CGF.LocalDeclMap.find(LocalVD);
1003  if (it != CGF.LocalDeclMap.end())
1004  SavedLocals.try_emplace(LocalVD, it->second);
1005  else
1006  SavedLocals.try_emplace(LocalVD, Address::invalid());
1007 
1008  // Generate the private entry.
1009  QualType VarTy = LocalVD->getType();
1010  if (VarTy->isReferenceType()) {
1011  Address Temp = CGF.CreateMemTemp(VarTy);
1012  CGF.Builder.CreateStore(TempAddr.getPointer(), Temp);
1013  TempAddr = Temp;
1014  }
1015  SavedTempAddresses.try_emplace(LocalVD, TempAddr);
1016 
1017  return true;
1018  }
1019 
1020  /// Applies new addresses to the list of the variables.
1021  /// \return true if at least one variable is using new address, false
1022  /// otherwise.
1023  bool apply(CodeGenFunction &CGF) {
1024  copyInto(SavedTempAddresses, CGF.LocalDeclMap);
1025  SavedTempAddresses.clear();
1026  return !SavedLocals.empty();
1027  }
1028 
1029  /// Restores original addresses of the variables.
1031  if (!SavedLocals.empty()) {
1032  copyInto(SavedLocals, CGF.LocalDeclMap);
1033  SavedLocals.clear();
1034  }
1035  }
1036 
1037  private:
1038  /// Copy all the entries in the source map over the corresponding
1039  /// entries in the destination, which must exist.
1040  static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) {
1041  for (auto &Pair : Src) {
1042  if (!Pair.second.isValid()) {
1043  Dest.erase(Pair.first);
1044  continue;
1045  }
1046 
1047  auto I = Dest.find(Pair.first);
1048  if (I != Dest.end())
1049  I->second = Pair.second;
1050  else
1051  Dest.insert(Pair);
1052  }
1053  }
1054  };
1055 
1056  /// The scope used to remap some variables as private in the OpenMP loop body
1057  /// (or other captured region emitted without outlining), and to restore old
1058  /// vars back on exit.
1060  OMPMapVars MappedVars;
1061  OMPPrivateScope(const OMPPrivateScope &) = delete;
1062  void operator=(const OMPPrivateScope &) = delete;
1063 
1064  public:
1065  /// Enter a new OpenMP private scope.
1067 
1068  /// Registers \p LocalVD variable as a private and apply \p PrivateGen
1069  /// function for it to generate corresponding private variable. \p
1070  /// PrivateGen returns an address of the generated private variable.
1071  /// \return true if the variable is registered as private, false if it has
1072  /// been privatized already.
1073  bool addPrivate(const VarDecl *LocalVD,
1074  const llvm::function_ref<Address()> PrivateGen) {
1075  assert(PerformCleanup && "adding private to dead scope");
1076  return MappedVars.setVarAddr(CGF, LocalVD, PrivateGen());
1077  }
1078 
1079  /// Privatizes local variables previously registered as private.
1080  /// Registration is separate from the actual privatization to allow
1081  /// initializers use values of the original variables, not the private one.
1082  /// This is important, for example, if the private variable is a class
1083  /// variable initialized by a constructor that references other private
1084  /// variables. But at initialization original variables must be used, not
1085  /// private copies.
1086  /// \return true if at least one variable was privatized, false otherwise.
1087  bool Privatize() { return MappedVars.apply(CGF); }
1088 
1089  void ForceCleanup() {
1091  MappedVars.restore(CGF);
1092  }
1093 
1094  /// Exit scope - all the mapped variables are restored.
1096  if (PerformCleanup)
1097  ForceCleanup();
1098  }
1099 
1100  /// Checks if the global variable is captured in current function.
1101  bool isGlobalVarCaptured(const VarDecl *VD) const {
1102  VD = VD->getCanonicalDecl();
1103  return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1104  }
1105  };
1106 
1107  /// Save/restore original map of previously emitted local vars in case when we
1108  /// need to duplicate emission of the same code several times in the same
1109  /// function for OpenMP code.
1111  CodeGenFunction &CGF;
1112  DeclMapTy SavedMap;
1113 
1114  public:
1116  : CGF(CGF), SavedMap(CGF.LocalDeclMap) {}
1117  ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); }
1118  };
1119 
1120  /// Takes the old cleanup stack size and emits the cleanup blocks
1121  /// that have been added.
1122  void
1123  PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize,
1124  std::initializer_list<llvm::Value **> ValuesToReload = {});
1125 
1126  /// Takes the old cleanup stack size and emits the cleanup blocks
1127  /// that have been added, then adds all lifetime-extended cleanups from
1128  /// the given position to the stack.
1129  void
1130  PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize,
1131  size_t OldLifetimeExtendedStackSize,
1132  std::initializer_list<llvm::Value **> ValuesToReload = {});
1133 
1134  void ResolveBranchFixups(llvm::BasicBlock *Target);
1135 
1136  /// The given basic block lies in the current EH scope, but may be a
1137  /// target of a potentially scope-crossing jump; get a stable handle
1138  /// to which we can perform this jump later.
1140  return JumpDest(Target,
1143  }
1144 
1145  /// The given basic block lies in the current EH scope, but may be a
1146  /// target of a potentially scope-crossing jump; get a stable handle
1147  /// to which we can perform this jump later.
1148  JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
1150  }
1151 
1152  /// EmitBranchThroughCleanup - Emit a branch from the current insert
1153  /// block through the normal cleanup handling code (if any) and then
1154  /// on to \arg Dest.
1155  void EmitBranchThroughCleanup(JumpDest Dest);
1156 
1157  /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1158  /// specified destination obviously has no cleanups to run. 'false' is always
1159  /// a conservatively correct answer for this method.
1160  bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const;
1161 
1162  /// popCatchScope - Pops the catch scope at the top of the EHScope
1163  /// stack, emitting any required code (other than the catch handlers
1164  /// themselves).
1165  void popCatchScope();
1166 
1167  llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
1168  llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope);
1169  llvm::BasicBlock *
1171 
1172  /// An object to manage conditionally-evaluated expressions.
1174  llvm::BasicBlock *StartBB;
1175 
1176  public:
1178  : StartBB(CGF.Builder.GetInsertBlock()) {}
1179 
1180  void begin(CodeGenFunction &CGF) {
1181  assert(CGF.OutermostConditional != this);
1182  if (!CGF.OutermostConditional)
1183  CGF.OutermostConditional = this;
1184  }
1185 
1186  void end(CodeGenFunction &CGF) {
1187  assert(CGF.OutermostConditional != nullptr);
1188  if (CGF.OutermostConditional == this)
1189  CGF.OutermostConditional = nullptr;
1190  }
1191 
1192  /// Returns a block which will be executed prior to each
1193  /// evaluation of the conditional code.
1194  llvm::BasicBlock *getStartingBlock() const {
1195  return StartBB;
1196  }
1197  };
1198 
1199  /// isInConditionalBranch - Return true if we're currently emitting
1200  /// one branch or the other of a conditional expression.
1201  bool isInConditionalBranch() const { return OutermostConditional != nullptr; }
1202 
1204  assert(isInConditionalBranch());
1205  llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1206  auto store = new llvm::StoreInst(value, addr.getPointer(), &block->back());
1207  store->setAlignment(addr.getAlignment().getAsAlign());
1208  }
1209 
1210  /// An RAII object to record that we're evaluating a statement
1211  /// expression.
1213  CodeGenFunction &CGF;
1214 
1215  /// We have to save the outermost conditional: cleanups in a
1216  /// statement expression aren't conditional just because the
1217  /// StmtExpr is.
1218  ConditionalEvaluation *SavedOutermostConditional;
1219 
1220  public:
1222  : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1223  CGF.OutermostConditional = nullptr;
1224  }
1225 
1227  CGF.OutermostConditional = SavedOutermostConditional;
1228  CGF.EnsureInsertPoint();
1229  }
1230  };
1231 
1232  /// An object which temporarily prevents a value from being
1233  /// destroyed by aggressive peephole optimizations that assume that
1234  /// all uses of a value have been realized in the IR.
1236  llvm::Instruction *Inst;
1237  friend class CodeGenFunction;
1238 
1239  public:
1240  PeepholeProtection() : Inst(nullptr) {}
1241  };
1242 
1243  /// A non-RAII class containing all the information about a bound
1244  /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
1245  /// this which makes individual mappings very simple; using this
1246  /// class directly is useful when you have a variable number of
1247  /// opaque values or don't want the RAII functionality for some
1248  /// reason.
1250  const OpaqueValueExpr *OpaqueValue;
1251  bool BoundLValue;
1253 
1255  bool boundLValue)
1256  : OpaqueValue(ov), BoundLValue(boundLValue) {}
1257  public:
1258  OpaqueValueMappingData() : OpaqueValue(nullptr) {}
1259 
1260  static bool shouldBindAsLValue(const Expr *expr) {
1261  // gl-values should be bound as l-values for obvious reasons.
1262  // Records should be bound as l-values because IR generation
1263  // always keeps them in memory. Expressions of function type
1264  // act exactly like l-values but are formally required to be
1265  // r-values in C.
1266  return expr->isGLValue() ||
1267  expr->getType()->isFunctionType() ||
1268  hasAggregateEvaluationKind(expr->getType());
1269  }
1270 
1272  const OpaqueValueExpr *ov,
1273  const Expr *e) {
1274  if (shouldBindAsLValue(ov))
1275  return bind(CGF, ov, CGF.EmitLValue(e));
1276  return bind(CGF, ov, CGF.EmitAnyExpr(e));
1277  }
1278 
1280  const OpaqueValueExpr *ov,
1281  const LValue &lv) {
1282  assert(shouldBindAsLValue(ov));
1283  CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1284  return OpaqueValueMappingData(ov, true);
1285  }
1286 
1288  const OpaqueValueExpr *ov,
1289  const RValue &rv) {
1290  assert(!shouldBindAsLValue(ov));
1291  CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1292 
1293  OpaqueValueMappingData data(ov, false);
1294 
1295  // Work around an extremely aggressive peephole optimization in
1296  // EmitScalarConversion which assumes that all other uses of a
1297  // value are extant.
1298  data.Protection = CGF.protectFromPeepholes(rv);
1299 
1300  return data;
1301  }
1302 
1303  bool isValid() const { return OpaqueValue != nullptr; }
1304  void clear() { OpaqueValue = nullptr; }
1305 
1307  assert(OpaqueValue && "no data to unbind!");
1308 
1309  if (BoundLValue) {
1310  CGF.OpaqueLValues.erase(OpaqueValue);
1311  } else {
1312  CGF.OpaqueRValues.erase(OpaqueValue);
1313  CGF.unprotectFromPeepholes(Protection);
1314  }
1315  }
1316  };
1317 
1318  /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1320  CodeGenFunction &CGF;
1322 
1323  public:
1324  static bool shouldBindAsLValue(const Expr *expr) {
1326  }
1327 
1328  /// Build the opaque value mapping for the given conditional
1329  /// operator if it's the GNU ?: extension. This is a common
1330  /// enough pattern that the convenience operator is really
1331  /// helpful.
1332  ///
1334  const AbstractConditionalOperator *op) : CGF(CGF) {
1335  if (isa<ConditionalOperator>(op))
1336  // Leave Data empty.
1337  return;
1338 
1339  const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
1341  e->getCommon());
1342  }
1343 
1344  /// Build the opaque value mapping for an OpaqueValueExpr whose source
1345  /// expression is set to the expression the OVE represents.
1347  : CGF(CGF) {
1348  if (OV) {
1349  assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1350  "for OVE with no source expression");
1351  Data = OpaqueValueMappingData::bind(CGF, OV, OV->getSourceExpr());
1352  }
1353  }
1354 
1356  const OpaqueValueExpr *opaqueValue,
1357  LValue lvalue)
1358  : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
1359  }
1360 
1362  const OpaqueValueExpr *opaqueValue,
1363  RValue rvalue)
1364  : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
1365  }
1366 
1367  void pop() {
1368  Data.unbind(CGF);
1369  Data.clear();
1370  }
1371 
1373  if (Data.isValid()) Data.unbind(CGF);
1374  }
1375  };
1376 
1377 private:
1378  CGDebugInfo *DebugInfo;
1379  /// Used to create unique names for artificial VLA size debug info variables.
1380  unsigned VLAExprCounter = 0;
1381  bool DisableDebugInfo = false;
1382 
1383  /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1384  /// calling llvm.stacksave for multiple VLAs in the same scope.
1385  bool DidCallStackSave = false;
1386 
1387  /// IndirectBranch - The first time an indirect goto is seen we create a block
1388  /// with an indirect branch. Every time we see the address of a label taken,
1389  /// we add the label to the indirect goto. Every subsequent indirect goto is
1390  /// codegen'd as a jump to the IndirectBranch's basic block.
1391  llvm::IndirectBrInst *IndirectBranch = nullptr;
1392 
1393  /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1394  /// decls.
1395  DeclMapTy LocalDeclMap;
1396 
1397  // Keep track of the cleanups for callee-destructed parameters pushed to the
1398  // cleanup stack so that they can be deactivated later.
1399  llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
1400  CalleeDestructedParamCleanups;
1401 
1402  /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1403  /// will contain a mapping from said ParmVarDecl to its implicit "object_size"
1404  /// parameter.
1405  llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2>
1406  SizeArguments;
1407 
1408  /// Track escaped local variables with auto storage. Used during SEH
1409  /// outlining to produce a call to llvm.localescape.
1410  llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
1411 
1412  /// LabelMap - This keeps track of the LLVM basic block for each C label.
1413  llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
1414 
1415  // BreakContinueStack - This keeps track of where break and continue
1416  // statements should jump to.
1417  struct BreakContinue {
1418  BreakContinue(JumpDest Break, JumpDest Continue)
1419  : BreakBlock(Break), ContinueBlock(Continue) {}
1420 
1421  JumpDest BreakBlock;
1422  JumpDest ContinueBlock;
1423  };
1424  SmallVector<BreakContinue, 8> BreakContinueStack;
1425 
1426  /// Handles cancellation exit points in OpenMP-related constructs.
1427  class OpenMPCancelExitStack {
1428  /// Tracks cancellation exit point and join point for cancel-related exit
1429  /// and normal exit.
1430  struct CancelExit {
1431  CancelExit() = default;
1432  CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
1433  JumpDest ContBlock)
1434  : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
1435  OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
1436  /// true if the exit block has been emitted already by the special
1437  /// emitExit() call, false if the default codegen is used.
1438  bool HasBeenEmitted = false;
1439  JumpDest ExitBlock;
1440  JumpDest ContBlock;
1441  };
1442 
1443  SmallVector<CancelExit, 8> Stack;
1444 
1445  public:
1446  OpenMPCancelExitStack() : Stack(1) {}
1447  ~OpenMPCancelExitStack() = default;
1448  /// Fetches the exit block for the current OpenMP construct.
1449  JumpDest getExitBlock() const { return Stack.back().ExitBlock; }
1450  /// Emits exit block with special codegen procedure specific for the related
1451  /// OpenMP construct + emits code for normal construct cleanup.
1452  void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind,
1453  const llvm::function_ref<void(CodeGenFunction &)> CodeGen) {
1454  if (Stack.back().Kind == Kind && getExitBlock().isValid()) {
1455  assert(CGF.getOMPCancelDestination(Kind).isValid());
1456  assert(CGF.HaveInsertPoint());
1457  assert(!Stack.back().HasBeenEmitted);
1458  auto IP = CGF.Builder.saveAndClearIP();
1459  CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1460  CodeGen(CGF);
1461  CGF.EmitBranch(Stack.back().ContBlock.getBlock());
1462  CGF.Builder.restoreIP(IP);
1463  Stack.back().HasBeenEmitted = true;
1464  }
1465  CodeGen(CGF);
1466  }
1467  /// Enter the cancel supporting \a Kind construct.
1468  /// \param Kind OpenMP directive that supports cancel constructs.
1469  /// \param HasCancel true, if the construct has inner cancel directive,
1470  /// false otherwise.
1471  void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) {
1472  Stack.push_back({Kind,
1473  HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1474  : JumpDest(),
1475  HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1476  : JumpDest()});
1477  }
1478  /// Emits default exit point for the cancel construct (if the special one
1479  /// has not be used) + join point for cancel/normal exits.
1480  void exit(CodeGenFunction &CGF) {
1481  if (getExitBlock().isValid()) {
1482  assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid());
1483  bool HaveIP = CGF.HaveInsertPoint();
1484  if (!Stack.back().HasBeenEmitted) {
1485  if (HaveIP)
1486  CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1487  CGF.EmitBlock(Stack.back().ExitBlock.getBlock());
1488  CGF.EmitBranchThroughCleanup(Stack.back().ContBlock);
1489  }
1490  CGF.EmitBlock(Stack.back().ContBlock.getBlock());
1491  if (!HaveIP) {
1492  CGF.Builder.CreateUnreachable();
1493  CGF.Builder.ClearInsertionPoint();
1494  }
1495  }
1496  Stack.pop_back();
1497  }
1498  };
1499  OpenMPCancelExitStack OMPCancelStack;
1500 
1501  /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin.
1502  llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
1503  Stmt::Likelihood LH);
1504 
1505  CodeGenPGO PGO;
1506 
1507  /// Calculate branch weights appropriate for PGO data
1508  llvm::MDNode *createProfileWeights(uint64_t TrueCount,
1509  uint64_t FalseCount) const;
1510  llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const;
1511  llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1512  uint64_t LoopCount) const;
1513 
1514 public:
1515  /// Increment the profiler's counter for the given statement by \p StepV.
1516  /// If \p StepV is null, the default increment is 1.
1517  void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
1519  !CurFn->hasFnAttribute(llvm::Attribute::NoProfile))
1520  PGO.emitCounterIncrement(Builder, S, StepV);
1521  PGO.setCurrentStmt(S);
1522  }
1523 
1524  /// Get the profiler's count for the given statement.
1525  uint64_t getProfileCount(const Stmt *S) {
1526  Optional<uint64_t> Count = PGO.getStmtCount(S);
1527  if (!Count.hasValue())
1528  return 0;
1529  return *Count;
1530  }
1531 
1532  /// Set the profiler's current count.
1533  void setCurrentProfileCount(uint64_t Count) {
1534  PGO.setCurrentRegionCount(Count);
1535  }
1536 
1537  /// Get the profiler's current count. This is generally the count for the most
1538  /// recently incremented counter.
1540  return PGO.getCurrentRegionCount();
1541  }
1542 
1543 private:
1544 
1545  /// SwitchInsn - This is nearest current switch instruction. It is null if
1546  /// current context is not in a switch.
1547  llvm::SwitchInst *SwitchInsn = nullptr;
1548  /// The branch weights of SwitchInsn when doing instrumentation based PGO.
1549  SmallVector<uint64_t, 16> *SwitchWeights = nullptr;
1550 
1551  /// The likelihood attributes of the SwitchCase.
1552  SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr;
1553 
1554  /// CaseRangeBlock - This block holds if condition check for last case
1555  /// statement range in current switch instruction.
1556  llvm::BasicBlock *CaseRangeBlock = nullptr;
1557 
1558  /// OpaqueLValues - Keeps track of the current set of opaque value
1559  /// expressions.
1560  llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1561  llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
1562 
1563  // VLASizeMap - This keeps track of the associated size for each VLA type.
1564  // We track this by the size expression rather than the type itself because
1565  // in certain situations, like a const qualifier applied to an VLA typedef,
1566  // multiple VLA types can share the same size expression.
1567  // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1568  // enter/leave scopes.
1569  llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
1570 
1571  /// A block containing a single 'unreachable' instruction. Created
1572  /// lazily by getUnreachableBlock().
1573  llvm::BasicBlock *UnreachableBlock = nullptr;
1574 
1575  /// Counts of the number return expressions in the function.
1576  unsigned NumReturnExprs = 0;
1577 
1578  /// Count the number of simple (constant) return expressions in the function.
1579  unsigned NumSimpleReturnExprs = 0;
1580 
1581  /// The last regular (non-return) debug location (breakpoint) in the function.
1582  SourceLocation LastStopPoint;
1583 
1584 public:
1585  /// Source location information about the default argument or member
1586  /// initializer expression we're evaluating, if any.
1588  using SourceLocExprScopeGuard =
1590 
1591  /// A scope within which we are constructing the fields of an object which
1592  /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use
1593  /// if we need to evaluate a CXXDefaultInitExpr within the evaluation.
1595  public:
1597  : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1598  CGF.CXXDefaultInitExprThis = This;
1599  }
1601  CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1602  }
1603 
1604  private:
1605  CodeGenFunction &CGF;
1606  Address OldCXXDefaultInitExprThis;
1607  };
1608 
1609  /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
1610  /// is overridden to be the object under construction.
1612  public:
1614  : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue),
1615  OldCXXThisAlignment(CGF.CXXThisAlignment),
1617  CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getPointer();
1618  CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment();
1619  }
1621  CGF.CXXThisValue = OldCXXThisValue;
1622  CGF.CXXThisAlignment = OldCXXThisAlignment;
1623  }
1624 
1625  public:
1630  };
1631 
1635  };
1636 
1637  /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the
1638  /// current loop index is overridden.
1640  public:
1642  : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) {
1643  CGF.ArrayInitIndex = Index;
1644  }
1646  CGF.ArrayInitIndex = OldArrayInitIndex;
1647  }
1648 
1649  private:
1650  CodeGenFunction &CGF;
1651  llvm::Value *OldArrayInitIndex;
1652  };
1653 
1655  public:
1657  : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl),
1658  OldCurCodeDecl(CGF.CurCodeDecl),
1659  OldCXXABIThisDecl(CGF.CXXABIThisDecl),
1660  OldCXXABIThisValue(CGF.CXXABIThisValue),
1661  OldCXXThisValue(CGF.CXXThisValue),
1662  OldCXXABIThisAlignment(CGF.CXXABIThisAlignment),
1663  OldCXXThisAlignment(CGF.CXXThisAlignment),
1664  OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy),
1665  OldCXXInheritedCtorInitExprArgs(
1666  std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1667  CGF.CurGD = GD;
1668  CGF.CurFuncDecl = CGF.CurCodeDecl =
1669  cast<CXXConstructorDecl>(GD.getDecl());
1670  CGF.CXXABIThisDecl = nullptr;
1671  CGF.CXXABIThisValue = nullptr;
1672  CGF.CXXThisValue = nullptr;
1673  CGF.CXXABIThisAlignment = CharUnits();
1674  CGF.CXXThisAlignment = CharUnits();
1675  CGF.ReturnValue = Address::invalid();
1676  CGF.FnRetTy = QualType();
1677  CGF.CXXInheritedCtorInitExprArgs.clear();
1678  }
1680  CGF.CurGD = OldCurGD;
1681  CGF.CurFuncDecl = OldCurFuncDecl;
1682  CGF.CurCodeDecl = OldCurCodeDecl;
1683  CGF.CXXABIThisDecl = OldCXXABIThisDecl;
1684  CGF.CXXABIThisValue = OldCXXABIThisValue;
1685  CGF.CXXThisValue = OldCXXThisValue;
1686  CGF.CXXABIThisAlignment = OldCXXABIThisAlignment;
1687  CGF.CXXThisAlignment = OldCXXThisAlignment;
1688  CGF.ReturnValue = OldReturnValue;
1689  CGF.FnRetTy = OldFnRetTy;
1690  CGF.CXXInheritedCtorInitExprArgs =
1691  std::move(OldCXXInheritedCtorInitExprArgs);
1692  }
1693 
1694  private:
1695  CodeGenFunction &CGF;
1696  GlobalDecl OldCurGD;
1697  const Decl *OldCurFuncDecl;
1698  const Decl *OldCurCodeDecl;
1699  ImplicitParamDecl *OldCXXABIThisDecl;
1700  llvm::Value *OldCXXABIThisValue;
1701  llvm::Value *OldCXXThisValue;
1702  CharUnits OldCXXABIThisAlignment;
1703  CharUnits OldCXXThisAlignment;
1704  Address OldReturnValue;
1705  QualType OldFnRetTy;
1706  CallArgList OldCXXInheritedCtorInitExprArgs;
1707  };
1708 
1709  // Helper class for the OpenMP IR Builder. Allows reusability of code used for
1710  // region body, and finalization codegen callbacks. This will class will also
1711  // contain privatization functions used by the privatization call backs
1712  //
1713  // TODO: this is temporary class for things that are being moved out of
1714  // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or
1715  // utility function for use with the OMPBuilder. Once that move to use the
1716  // OMPBuilder is done, everything here will either become part of CodeGenFunc.
1717  // directly, or a new helper class that will contain functions used by both
1718  // this and the OMPBuilder
1719 
1721 
1722  OMPBuilderCBHelpers() = delete;
1723  OMPBuilderCBHelpers(const OMPBuilderCBHelpers &) = delete;
1725 
1726  using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
1727 
1728  /// Cleanup action for allocate support.
1730 
1731  private:
1732  llvm::CallInst *RTLFnCI;
1733 
1734  public:
1735  OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) {
1736  RLFnCI->removeFromParent();
1737  }
1738 
1739  void Emit(CodeGenFunction &CGF, Flags /*flags*/) override {
1740  if (!CGF.HaveInsertPoint())
1741  return;
1742  CGF.Builder.Insert(RTLFnCI);
1743  }
1744  };
1745 
1746  /// Returns address of the threadprivate variable for the current
1747  /// thread. This Also create any necessary OMP runtime calls.
1748  ///
1749  /// \param VD VarDecl for Threadprivate variable.
1750  /// \param VDAddr Address of the Vardecl
1751  /// \param Loc The location where the barrier directive was encountered
1753  const VarDecl *VD, Address VDAddr,
1754  SourceLocation Loc);
1755 
1756  /// Gets the OpenMP-specific address of the local variable /p VD.
1758  const VarDecl *VD);
1759  /// Get the platform-specific name separator.
1760  /// \param Parts different parts of the final name that needs separation
1761  /// \param FirstSeparator First separator used between the initial two
1762  /// parts of the name.
1763  /// \param Separator separator used between all of the rest consecutinve
1764  /// parts of the name
1766  StringRef FirstSeparator = ".",
1767  StringRef Separator = ".");
1768  /// Emit the Finalization for an OMP region
1769  /// \param CGF The Codegen function this belongs to
1770  /// \param IP Insertion point for generating the finalization code.
1772  CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1773  assert(IP.getBlock()->end() != IP.getPoint() &&
1774  "OpenMP IR Builder should cause terminated block!");
1775 
1776  llvm::BasicBlock *IPBB = IP.getBlock();
1777  llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1778  assert(DestBB && "Finalization block should have one successor!");
1779 
1780  // erase and replace with cleanup branch.
1781  IPBB->getTerminator()->eraseFromParent();
1782  CGF.Builder.SetInsertPoint(IPBB);
1784  CGF.EmitBranchThroughCleanup(Dest);
1785  }
1786 
1787  /// Emit the body of an OMP region
1788  /// \param CGF The Codegen function this belongs to
1789  /// \param RegionBodyStmt The body statement for the OpenMP region being
1790  /// generated
1791  /// \param CodeGenIP Insertion point for generating the body code.
1792  /// \param FiniBB The finalization basic block
1794  const Stmt *RegionBodyStmt,
1795  InsertPointTy CodeGenIP,
1796  llvm::BasicBlock &FiniBB) {
1797  llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1798  if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1799  CodeGenIPBBTI->eraseFromParent();
1800 
1801  CGF.Builder.SetInsertPoint(CodeGenIPBB);
1802 
1803  CGF.EmitStmt(RegionBodyStmt);
1804 
1805  if (CGF.Builder.saveIP().isSet())
1806  CGF.Builder.CreateBr(&FiniBB);
1807  }
1808 
1809  static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP,
1810  llvm::BasicBlock &FiniBB, llvm::Function *Fn,
1811  ArrayRef<llvm::Value *> Args) {
1812  llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock();
1813  if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1814  CodeGenIPBBTI->eraseFromParent();
1815 
1816  CGF.Builder.SetInsertPoint(CodeGenIPBB);
1817 
1818  if (Fn->doesNotThrow())
1819  CGF.EmitNounwindRuntimeCall(Fn, Args);
1820  else
1821  CGF.EmitRuntimeCall(Fn, Args);
1822 
1823  if (CGF.Builder.saveIP().isSet())
1824  CGF.Builder.CreateBr(&FiniBB);
1825  }
1826 
1827  /// RAII for preserving necessary info during Outlined region body codegen.
1829 
1830  llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
1831  CodeGenFunction::JumpDest OldReturnBlock;
1832  CGBuilderTy::InsertPoint IP;
1833  CodeGenFunction &CGF;
1834 
1835  public:
1837  llvm::BasicBlock &RetBB)
1838  : CGF(cgf) {
1839  assert(AllocaIP.isSet() &&
1840  "Must specify Insertion point for allocas of outlined function");
1841  OldAllocaIP = CGF.AllocaInsertPt;
1842  CGF.AllocaInsertPt = &*AllocaIP.getPoint();
1843  IP = CGF.Builder.saveIP();
1844 
1845  OldReturnBlock = CGF.ReturnBlock;
1846  CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB);
1847  }
1848 
1850  CGF.AllocaInsertPt = OldAllocaIP;
1851  CGF.ReturnBlock = OldReturnBlock;
1852  CGF.Builder.restoreIP(IP);
1853  }
1854  };
1855 
1856  /// RAII for preserving necessary info during inlined region body codegen.
1858 
1859  llvm::AssertingVH<llvm::Instruction> OldAllocaIP;
1860  CodeGenFunction &CGF;
1861 
1862  public:
1864  llvm::BasicBlock &FiniBB)
1865  : CGF(cgf) {
1866  // Alloca insertion block should be in the entry block of the containing
1867  // function so it expects an empty AllocaIP in which case will reuse the
1868  // old alloca insertion point, or a new AllocaIP in the same block as
1869  // the old one
1870  assert((!AllocaIP.isSet() ||
1871  CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
1872  "Insertion point should be in the entry block of containing "
1873  "function!");
1874  OldAllocaIP = CGF.AllocaInsertPt;
1875  if (AllocaIP.isSet())
1876  CGF.AllocaInsertPt = &*AllocaIP.getPoint();
1877 
1878  // TODO: Remove the call, after making sure the counter is not used by
1879  // the EHStack.
1880  // Since this is an inlined region, it should not modify the
1881  // ReturnBlock, and should reuse the one for the enclosing outlined
1882  // region. So, the JumpDest being return by the function is discarded
1883  (void)CGF.getJumpDestInCurrentScope(&FiniBB);
1884  }
1885 
1886  ~InlinedRegionBodyRAII() { CGF.AllocaInsertPt = OldAllocaIP; }
1887  };
1888  };
1889 
1890 private:
1891  /// CXXThisDecl - When generating code for a C++ member function,
1892  /// this will hold the implicit 'this' declaration.
1893  ImplicitParamDecl *CXXABIThisDecl = nullptr;
1894  llvm::Value *CXXABIThisValue = nullptr;
1895  llvm::Value *CXXThisValue = nullptr;
1896  CharUnits CXXABIThisAlignment;
1897  CharUnits CXXThisAlignment;
1898 
1899  /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
1900  /// this expression.
1901  Address CXXDefaultInitExprThis = Address::invalid();
1902 
1903  /// The current array initialization index when evaluating an
1904  /// ArrayInitIndexExpr within an ArrayInitLoopExpr.
1905  llvm::Value *ArrayInitIndex = nullptr;
1906 
1907  /// The values of function arguments to use when evaluating
1908  /// CXXInheritedCtorInitExprs within this context.
1909  CallArgList CXXInheritedCtorInitExprArgs;
1910 
1911  /// CXXStructorImplicitParamDecl - When generating code for a constructor or
1912  /// destructor, this will hold the implicit argument (e.g. VTT).
1913  ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr;
1914  llvm::Value *CXXStructorImplicitParamValue = nullptr;
1915 
1916  /// OutermostConditional - Points to the outermost active
1917  /// conditional control. This is used so that we know if a
1918  /// temporary should be destroyed conditionally.
1919  ConditionalEvaluation *OutermostConditional = nullptr;
1920 
1921  /// The current lexical scope.
1922  LexicalScope *CurLexicalScope = nullptr;
1923 
1924  /// The current source location that should be used for exception
1925  /// handling code.
1926  SourceLocation CurEHLocation;
1927 
1928  /// BlockByrefInfos - For each __block variable, contains
1929  /// information about the layout of the variable.
1930  llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
1931 
1932  /// Used by -fsanitize=nullability-return to determine whether the return
1933  /// value can be checked.
1934  llvm::Value *RetValNullabilityPrecondition = nullptr;
1935 
1936  /// Check if -fsanitize=nullability-return instrumentation is required for
1937  /// this function.
1938  bool requiresReturnValueNullabilityCheck() const {
1939  return RetValNullabilityPrecondition;
1940  }
1941 
1942  /// Used to store precise source locations for return statements by the
1943  /// runtime return value checks.
1944  Address ReturnLocation = Address::invalid();
1945 
1946  /// Check if the return value of this function requires sanitization.
1947  bool requiresReturnValueCheck() const;
1948 
1949  llvm::BasicBlock *TerminateLandingPad = nullptr;
1950  llvm::BasicBlock *TerminateHandler = nullptr;
1952 
1953  /// Terminate funclets keyed by parent funclet pad.
1954  llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
1955 
1956  /// Largest vector width used in ths function. Will be used to create a
1957  /// function attribute.
1958  unsigned LargestVectorWidth = 0;
1959 
1960  /// True if we need emit the life-time markers. This is initially set in
1961  /// the constructor, but could be overwritten to true if this is a coroutine.
1962  bool ShouldEmitLifetimeMarkers;
1963 
1964  /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
1965  /// the function metadata.
1966  void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
1967  llvm::Function *Fn);
1968 
1969 public:
1970  CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
1971  ~CodeGenFunction();
1972 
1973  CodeGenTypes &getTypes() const { return CGM.getTypes(); }
1974  ASTContext &getContext() const { return CGM.getContext(); }
1976  if (DisableDebugInfo)
1977  return nullptr;
1978  return DebugInfo;
1979  }
1980  void disableDebugInfo() { DisableDebugInfo = true; }
1981  void enableDebugInfo() { DisableDebugInfo = false; }
1982 
1984  return CGM.getCodeGenOpts().OptimizationLevel == 0;
1985  }
1986 
1987  const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
1988 
1989  /// Returns a pointer to the function's exception object and selector slot,
1990  /// which is assigned in every landing pad.
1993 
1994  /// Returns the contents of the function's exception object and selector
1995  /// slots.
1998 
2000 
2001  llvm::BasicBlock *getUnreachableBlock() {
2002  if (!UnreachableBlock) {
2003  UnreachableBlock = createBasicBlock("unreachable");
2004  new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
2005  }
2006  return UnreachableBlock;
2007  }
2008 
2009  llvm::BasicBlock *getInvokeDest() {
2010  if (!EHStack.requiresLandingPad()) return nullptr;
2011  return getInvokeDestImpl();
2012  }
2013 
2014  bool currentFunctionUsesSEHTry() const { return CurSEHParent != nullptr; }
2015 
2016  const TargetInfo &getTarget() const { return Target; }
2017  llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
2019  return CGM.getTargetCodeGenInfo();
2020  }
2021 
2022  //===--------------------------------------------------------------------===//
2023  // Cleanups
2024  //===--------------------------------------------------------------------===//
2025 
2026  typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty);
2027 
2029  Address arrayEndPointer,
2030  QualType elementType,
2031  CharUnits elementAlignment,
2032  Destroyer *destroyer);
2034  llvm::Value *arrayEnd,
2035  QualType elementType,
2036  CharUnits elementAlignment,
2037  Destroyer *destroyer);
2038 
2039  void pushDestroy(QualType::DestructionKind dtorKind,
2040  Address addr, QualType type);
2042  Address addr, QualType type);
2044  Destroyer *destroyer, bool useEHCleanupForArray);
2046  QualType type, Destroyer *destroyer,
2047  bool useEHCleanupForArray);
2048  void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
2049  llvm::Value *CompletePtr,
2050  QualType ElementType);
2052  void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
2053  bool useEHCleanupForArray);
2054  llvm::Function *generateDestroyHelper(Address addr, QualType type,
2055  Destroyer *destroyer,
2056  bool useEHCleanupForArray,
2057  const VarDecl *VD);
2058  void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
2059  QualType elementType, CharUnits elementAlign,
2060  Destroyer *destroyer,
2061  bool checkZeroLength, bool useEHCleanup);
2062 
2064 
2065  /// Determines whether an EH cleanup is required to destroy a type
2066  /// with the given destruction kind.
2068  switch (kind) {
2069  case QualType::DK_none:
2070  return false;
2074  return getLangOpts().Exceptions;
2076  return getLangOpts().Exceptions &&
2077  CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
2078  }
2079  llvm_unreachable("bad destruction kind");
2080  }
2081 
2084  }
2085 
2086  //===--------------------------------------------------------------------===//
2087  // Objective-C
2088  //===--------------------------------------------------------------------===//
2089 
2090  void GenerateObjCMethod(const ObjCMethodDecl *OMD);
2091 
2092  void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD);
2093 
2094  /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2096  const ObjCPropertyImplDecl *PID);
2097  void generateObjCGetterBody(const ObjCImplementationDecl *classImpl,
2098  const ObjCPropertyImplDecl *propImpl,
2099  const ObjCMethodDecl *GetterMothodDecl,
2100  llvm::Constant *AtomicHelperFn);
2101 
2103  ObjCMethodDecl *MD, bool ctor);
2104 
2105  /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2106  /// for the given property.
2108  const ObjCPropertyImplDecl *PID);
2109  void generateObjCSetterBody(const ObjCImplementationDecl *classImpl,
2110  const ObjCPropertyImplDecl *propImpl,
2111  llvm::Constant *AtomicHelperFn);
2112 
2113  //===--------------------------------------------------------------------===//
2114  // Block Bits
2115  //===--------------------------------------------------------------------===//
2116 
2117  /// Emit block literal.
2118  /// \return an LLVM value which is a pointer to a struct which contains
2119  /// information about the block, including the block invoke function, the
2120  /// captured variables, etc.
2122 
2123  llvm::Function *GenerateBlockFunction(GlobalDecl GD,
2124  const CGBlockInfo &Info,
2125  const DeclMapTy &ldm,
2126  bool IsLambdaConversionToBlock,
2127  bool BuildGlobalBlock);
2128 
2129  /// Check if \p T is a C++ class that has a destructor that can throw.
2130  static bool cxxDestructorCanThrow(QualType T);
2131 
2132  llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
2133  llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
2135  const ObjCPropertyImplDecl *PID);
2137  const ObjCPropertyImplDecl *PID);
2139 
2140  void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
2141  bool CanThrow);
2142 
2143  class AutoVarEmission;
2144 
2145  void emitByrefStructureInit(const AutoVarEmission &emission);
2146 
2147  /// Enter a cleanup to destroy a __block variable. Note that this
2148  /// cleanup should be a no-op if the variable hasn't left the stack
2149  /// yet; if a cleanup is required for the variable itself, that needs
2150  /// to be done externally.
2151  ///
2152  /// \param Kind Cleanup kind.
2153  ///
2154  /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block
2155  /// structure that will be passed to _Block_object_dispose. When
2156  /// \p LoadBlockVarAddr is true, the address of the field of the block
2157  /// structure that holds the address of the __block structure.
2158  ///
2159  /// \param Flags The flag that will be passed to _Block_object_dispose.
2160  ///
2161  /// \param LoadBlockVarAddr Indicates whether we need to emit a load from
2162  /// \p Addr to get the address of the __block structure.
2164  bool LoadBlockVarAddr, bool CanThrow);
2165 
2166  void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum,
2167  llvm::Value *ptr);
2168 
2170  Address GetAddrOfBlockDecl(const VarDecl *var);
2171 
2172  /// BuildBlockByrefAddress - Computes the location of the
2173  /// data in a variable which is declared as __block.
2174  Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V,
2175  bool followForward = true);
2177  const BlockByrefInfo &info,
2178  bool followForward,
2179  const llvm::Twine &name);
2180 
2181  const BlockByrefInfo &getBlockByrefInfo(const VarDecl *var);
2182 
2184 
2185  void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
2186  const CGFunctionInfo &FnInfo);
2187 
2188  /// Annotate the function with an attribute that disables TSan checking at
2189  /// runtime.
2190  void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
2191 
2192  /// Emit code for the start of a function.
2193  /// \param Loc The location to be associated with the function.
2194  /// \param StartLoc The location of the function body.
2195  void StartFunction(GlobalDecl GD,
2196  QualType RetTy,
2197  llvm::Function *Fn,
2198  const CGFunctionInfo &FnInfo,
2199  const FunctionArgList &Args,
2201  SourceLocation StartLoc = SourceLocation());
2202 
2203  static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor);
2204 
2206  void EmitDestructorBody(FunctionArgList &Args);
2208  void EmitFunctionBody(const Stmt *Body);
2209  void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2210 
2211  void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator,
2212  CallArgList &CallArgs);
2215  void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD);
2217  EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2218  }
2219  void EmitAsanPrologueOrEpilogue(bool Prologue);
2220 
2221  /// Emit the unified return block, trying to avoid its emission when
2222  /// possible.
2223  /// \return The debug location of the user written return statement if the
2224  /// return block is is avoided.
2225  llvm::DebugLoc EmitReturnBlock();
2226 
2227  /// FinishFunction - Complete IR generation of the current function. It is
2228  /// legal to call this function even if there is no current insertion point.
2230 
2231  void StartThunk(llvm::Function *Fn, GlobalDecl GD,
2232  const CGFunctionInfo &FnInfo, bool IsUnprototyped);
2233 
2234  void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee,
2235  const ThunkInfo *Thunk, bool IsUnprototyped);
2236 
2237  void FinishThunk();
2238 
2239  /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
2240  void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr,
2241  llvm::FunctionCallee Callee);
2242 
2243  /// Generate a thunk for the given method.
2244  void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
2245  GlobalDecl GD, const ThunkInfo &Thunk,
2246  bool IsUnprototyped);
2247 
2248  llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
2249  const CGFunctionInfo &FnInfo,
2250  GlobalDecl GD, const ThunkInfo &Thunk);
2251 
2253  FunctionArgList &Args);
2254 
2255  void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
2256 
2257  /// Struct with all information about dynamic [sub]class needed to set vptr.
2258  struct VPtr {
2263  };
2264 
2265  /// Initialize the vtable pointer of the given subobject.
2266  void InitializeVTablePointer(const VPtr &vptr);
2267 
2269 
2271  VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass);
2272 
2273  void getVTablePointers(BaseSubobject Base, const CXXRecordDecl *NearestVBase,
2274  CharUnits OffsetFromNearestVBase,
2275  bool BaseIsNonVirtualPrimaryBase,
2276  const CXXRecordDecl *VTableClass,
2277  VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs);
2278 
2279  void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
2280 
2281  /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2282  /// to by This.
2283  llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
2284  const CXXRecordDecl *VTableClass);
2285 
2294  };
2295 
2296  /// Derived is the presumed address of an object of type T after a
2297  /// cast. If T is a polymorphic class type, emit a check that the virtual
2298  /// table for Derived belongs to a class derived from T.
2300  bool MayBeNull, CFITypeCheckKind TCK,
2301  SourceLocation Loc);
2302 
2303  /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2304  /// If vptr CFI is enabled, emit a check that VTable is valid.
2305  void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable,
2306  CFITypeCheckKind TCK, SourceLocation Loc);
2307 
2308  /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2309  /// RD using llvm.type.test.
2310  void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable,
2311  CFITypeCheckKind TCK, SourceLocation Loc);
2312 
2313  /// If whole-program virtual table optimization is enabled, emit an assumption
2314  /// that VTable is a member of RD's type identifier. Or, if vptr CFI is
2315  /// enabled, emit a check that VTable is a member of RD's type identifier.
2317  llvm::Value *VTable, SourceLocation Loc);
2318 
2319  /// Returns whether we should perform a type checked load when loading a
2320  /// virtual function for virtual calls to members of RD. This is generally
2321  /// true when both vcall CFI and whole-program-vtables are enabled.
2323 
2324  /// Emit a type checked load from the given vtable.
2326  uint64_t VTableByteOffset);
2327 
2328  /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2329  /// given phase of destruction for a destructor. The end result
2330  /// should call destructors on members and base classes in reverse
2331  /// order of their construction.
2333 
2334  /// ShouldInstrumentFunction - Return true if the current function should be
2335  /// instrumented with __cyg_profile_func_* calls
2336  bool ShouldInstrumentFunction();
2337 
2338  /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2339  /// should not be instrumented with sanitizers.
2341 
2342  /// ShouldXRayInstrument - Return true if the current function should be
2343  /// instrumented with XRay nop sleds.
2344  bool ShouldXRayInstrumentFunction() const;
2345 
2346  /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2347  /// XRay custom event handling calls.
2348  bool AlwaysEmitXRayCustomEvents() const;
2349 
2350  /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2351  /// XRay typed event handling calls.
2352  bool AlwaysEmitXRayTypedEvents() const;
2353 
2354  /// Encode an address into a form suitable for use in a function prologue.
2355  llvm::Constant *EncodeAddrForUseInPrologue(llvm::Function *F,
2356  llvm::Constant *Addr);
2357 
2358  /// Decode an address used in a function prologue, encoded by \c
2359  /// EncodeAddrForUseInPrologue.
2361  llvm::Value *EncodedAddr);
2362 
2363  /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2364  /// arguments for the given function. This is also responsible for naming the
2365  /// LLVM function arguments.
2366  void EmitFunctionProlog(const CGFunctionInfo &FI,
2367  llvm::Function *Fn,
2368  const FunctionArgList &Args);
2369 
2370  /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2371  /// given temporary.
2372  void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc,
2373  SourceLocation EndLoc);
2374 
2375  /// Emit a test that checks if the return value \p RV is nonnull.
2377 
2378  /// EmitStartEHSpec - Emit the start of the exception spec.
2379  void EmitStartEHSpec(const Decl *D);
2380 
2381  /// EmitEndEHSpec - Emit the end of the exception spec.
2382  void EmitEndEHSpec(const Decl *D);
2383 
2384  /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2385  llvm::BasicBlock *getTerminateLandingPad();
2386 
2387  /// getTerminateLandingPad - Return a cleanup funclet that just calls
2388  /// terminate.
2389  llvm::BasicBlock *getTerminateFunclet();
2390 
2391  /// getTerminateHandler - Return a handler (not a landing pad, just
2392  /// a catch handler) that just calls terminate. This is used when
2393  /// a terminate scope encloses a try.
2394  llvm::BasicBlock *getTerminateHandler();
2395 
2396  llvm::Type *ConvertTypeForMem(QualType T);
2397  llvm::Type *ConvertType(QualType T);
2398  llvm::Type *ConvertType(const TypeDecl *T) {
2399  return ConvertType(getContext().getTypeDeclType(T));
2400  }
2401 
2402  /// LoadObjCSelf - Load the value of self. This function is only valid while
2403  /// generating code for an Objective-C method.
2405 
2406  /// TypeOfSelfObject - Return type of object that this self represents.
2408 
2409  /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2411 
2413  return getEvaluationKind(T) == TEK_Scalar;
2414  }
2415 
2417  return getEvaluationKind(T) == TEK_Aggregate;
2418  }
2419 
2420  /// createBasicBlock - Create an LLVM basic block.
2421  llvm::BasicBlock *createBasicBlock(const Twine &name = "",
2422  llvm::Function *parent = nullptr,
2423  llvm::BasicBlock *before = nullptr) {
2424  return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
2425  }
2426 
2427  /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2428  /// label maps to.
2429  JumpDest getJumpDestForLabel(const LabelDecl *S);
2430 
2431  /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2432  /// another basic block, simplify it. This assumes that no other code could
2433  /// potentially reference the basic block.
2434  void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
2435 
2436  /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2437  /// adding a fall-through branch from the current insert block if
2438  /// necessary. It is legal to call this function even if there is no current
2439  /// insertion point.
2440  ///
2441  /// IsFinished - If true, indicates that the caller has finished emitting
2442  /// branches to the given block and does not expect to emit code into it. This
2443  /// means the block can be ignored if it is unreachable.
2444  void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
2445 
2446  /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2447  /// near its uses, and leave the insertion point in it.
2448  void EmitBlockAfterUses(llvm::BasicBlock *BB);
2449 
2450  /// EmitBranch - Emit a branch to the specified basic block from the current
2451  /// insert block, taking care to avoid creation of branches from dummy
2452  /// blocks. It is legal to call this function even if there is no current
2453  /// insertion point.
2454  ///
2455  /// This function clears the current insertion point. The caller should follow
2456  /// calls to this function with calls to Emit*Block prior to generation new
2457  /// code.
2458  void EmitBranch(llvm::BasicBlock *Block);
2459 
2460  /// HaveInsertPoint - True if an insertion point is defined. If not, this
2461  /// indicates that the current code being emitted is unreachable.
2462  bool HaveInsertPoint() const {
2463  return Builder.GetInsertBlock() != nullptr;
2464  }
2465 
2466  /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2467  /// emitted IR has a place to go. Note that by definition, if this function
2468  /// creates a block then that block is unreachable; callers may do better to
2469  /// detect when no insertion point is defined and simply skip IR generation.
2471  if (!HaveInsertPoint())
2473  }
2474 
2475  /// ErrorUnsupported - Print out an error that codegen doesn't support the
2476  /// specified stmt yet.
2477  void ErrorUnsupported(const Stmt *S, const char *Type);
2478 
2479  //===--------------------------------------------------------------------===//
2480  // Helpers
2481  //===--------------------------------------------------------------------===//
2482 
2485  return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2486  CGM.getTBAAAccessInfo(T));
2487  }
2488 
2490  TBAAAccessInfo TBAAInfo) {
2491  return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);
2492  }
2493 
2496  Address Addr(V, ConvertTypeForMem(T), Alignment);
2497  return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2498  CGM.getTBAAAccessInfo(T));
2499  }
2500 
2501  LValue
2504  return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source),
2505  TBAAAccessInfo());
2506  }
2507 
2510 
2512  LValueBaseInfo *PointeeBaseInfo = nullptr,
2513  TBAAAccessInfo *PointeeTBAAInfo = nullptr);
2516  AlignmentSource Source =
2518  LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source),
2519  CGM.getTBAAAccessInfo(RefTy));
2520  return EmitLoadOfReferenceLValue(RefLVal);
2521  }
2522 
2523  Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy,
2524  LValueBaseInfo *BaseInfo = nullptr,
2525  TBAAAccessInfo *TBAAInfo = nullptr);
2527 
2528  /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2529  /// block if \p ArraySize is nullptr, otherwise inserts it at the current
2530  /// insertion point of the builder. The caller is responsible for setting an
2531  /// appropriate alignment on
2532  /// the alloca.
2533  ///
2534  /// \p ArraySize is the number of array elements to be allocated if it
2535  /// is not nullptr.
2536  ///
2537  /// LangAS::Default is the address space of pointers to local variables and
2538  /// temporaries, as exposed in the source language. In certain
2539  /// configurations, this is not the same as the alloca address space, and a
2540  /// cast is needed to lift the pointer from the alloca AS into
2541  /// LangAS::Default. This can happen when the target uses a restricted
2542  /// address space for the stack but the source language requires
2543  /// LangAS::Default to be a generic address space. The latter condition is
2544  /// common for most programming languages; OpenCL is an exception in that
2545  /// LangAS::Default is the private address space, which naturally maps
2546  /// to the stack.
2547  ///
2548  /// Because the address of a temporary is often exposed to the program in
2549  /// various ways, this function will perform the cast. The original alloca
2550  /// instruction is returned through \p Alloca if it is not nullptr.
2551  ///
2552  /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2553  /// more efficient if the caller knows that the address will not be exposed.
2554  llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2555  llvm::Value *ArraySize = nullptr);
2556  Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
2557  const Twine &Name = "tmp",
2558  llvm::Value *ArraySize = nullptr,
2559  Address *Alloca = nullptr);
2561  const Twine &Name = "tmp",
2562  llvm::Value *ArraySize = nullptr);
2563 
2564  /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2565  /// default ABI alignment of the given LLVM type.
2566  ///
2567  /// IMPORTANT NOTE: This is *not* generally the right alignment for
2568  /// any given AST type that happens to have been lowered to the
2569  /// given IR type. This should only ever be used for function-local,
2570  /// IR-driven manipulations like saving and restoring a value. Do
2571  /// not hand this address off to arbitrary IRGen routines, and especially
2572  /// do not pass it as an argument to a function that might expect a
2573  /// properly ABI-aligned value.
2574  Address CreateDefaultAlignTempAlloca(llvm::Type *Ty,
2575  const Twine &Name = "tmp");
2576 
2577  /// CreateIRTemp - Create a temporary IR object of the given type, with
2578  /// appropriate alignment. This routine should only be used when an temporary
2579  /// value needs to be stored into an alloca (for example, to avoid explicit
2580  /// PHI construction), but the type is the IR type, not the type appropriate
2581  /// for storing in memory.
2582  ///
2583  /// That is, this is exactly equivalent to CreateMemTemp, but calling
2584  /// ConvertType instead of ConvertTypeForMem.
2585  Address CreateIRTemp(QualType T, const Twine &Name = "tmp");
2586 
2587  /// CreateMemTemp - Create a temporary memory object of the given type, with
2588  /// appropriate alignmen and cast it to the default address space. Returns
2589  /// the original alloca instruction by \p Alloca if it is not nullptr.
2590  Address CreateMemTemp(QualType T, const Twine &Name = "tmp",
2591  Address *Alloca = nullptr);
2592  Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp",
2593  Address *Alloca = nullptr);
2594 
2595  /// CreateMemTemp - Create a temporary memory object of the given type, with
2596  /// appropriate alignmen without casting it to the default address space.
2597  Address CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp");
2599  const Twine &Name = "tmp");
2600 
2601  /// CreateAggTemp - Create a temporary memory object for the given
2602  /// aggregate type.
2603  AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp",
2604  Address *Alloca = nullptr) {
2605  return AggValueSlot::forAddr(CreateMemTemp(T, Name, Alloca),
2606  T.getQualifiers(),
2611  }
2612 
2613  /// Emit a cast to void* in the appropriate address space.
2615 
2616  /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2617  /// expression and compare the result against zero, returning an Int1Ty value.
2618  llvm::Value *EvaluateExprAsBool(const Expr *E);
2619 
2620  /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
2621  void EmitIgnoredExpr(const Expr *E);
2622 
2623  /// EmitAnyExpr - Emit code to compute the specified expression which can have
2624  /// any type. The result is returned as an RValue struct. If this is an
2625  /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
2626  /// the result should be returned.
2627  ///
2628  /// \param ignoreResult True if the resulting value isn't used.
2629  RValue EmitAnyExpr(const Expr *E,
2630  AggValueSlot aggSlot = AggValueSlot::ignored(),
2631  bool ignoreResult = false);
2632 
2633  // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2634  // or the value of the expression, depending on how va_list is defined.
2635  Address EmitVAListRef(const Expr *E);
2636 
2637  /// Emit a "reference" to a __builtin_ms_va_list; this is
2638  /// always the value of the expression, because a __builtin_ms_va_list is a
2639  /// pointer to a char.
2640  Address EmitMSVAListRef(const Expr *E);
2641 
2642  /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2643  /// always be accessible even if no aggregate location is provided.
2644  RValue EmitAnyExprToTemp(const Expr *E);
2645 
2646  /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2647  /// arbitrary expression into the given memory location.
2648  void EmitAnyExprToMem(const Expr *E, Address Location,
2649  Qualifiers Quals, bool IsInitializer);
2650 
2651  void EmitAnyExprToExn(const Expr *E, Address Addr);
2652 
2653  /// EmitExprAsInit - Emits the code necessary to initialize a
2654  /// location in memory with the given initializer.
2655  void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue,
2656  bool capturedByInit);
2657 
2658  /// hasVolatileMember - returns true if aggregate type has a volatile
2659  /// member.
2661  if (const RecordType *RT = T->getAs<RecordType>()) {
2662  const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2663  return RD->hasVolatileMember();
2664  }
2665  return false;
2666  }
2667 
2668  /// Determine whether a return value slot may overlap some other object.
2670  // FIXME: Assuming no overlap here breaks guaranteed copy elision for base
2671  // class subobjects. These cases may need to be revisited depending on the
2672  // resolution of the relevant core issue.
2674  }
2675 
2676  /// Determine whether a field initialization may overlap some other object.
2678 
2679  /// Determine whether a base class initialization may overlap some other
2680  /// object.
2682  const CXXRecordDecl *BaseRD,
2683  bool IsVirtual);
2684 
2685  /// Emit an aggregate assignment.
2686  void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) {
2687  bool IsVolatile = hasVolatileMember(EltTy);
2688  EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile);
2689  }
2690 
2692  AggValueSlot::Overlap_t MayOverlap) {
2693  EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap);
2694  }
2695 
2696  /// EmitAggregateCopy - Emit an aggregate copy.
2697  ///
2698  /// \param isVolatile \c true iff either the source or the destination is
2699  /// volatile.
2700  /// \param MayOverlap Whether the tail padding of the destination might be
2701  /// occupied by some other object. More efficient code can often be
2702  /// generated if not.
2703  void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy,
2704  AggValueSlot::Overlap_t MayOverlap,
2705  bool isVolatile = false);
2706 
2707  /// GetAddrOfLocalVar - Return the address of a local variable.
2709  auto it = LocalDeclMap.find(VD);
2710  assert(it != LocalDeclMap.end() &&
2711  "Invalid argument to GetAddrOfLocalVar(), no decl!");
2712  return it->second;
2713  }
2714 
2715  /// Given an opaque value expression, return its LValue mapping if it exists,
2716  /// otherwise create one.
2718 
2719  /// Given an opaque value expression, return its RValue mapping if it exists,
2720  /// otherwise create one.
2722 
2723  /// Get the index of the current ArrayInitLoopExpr, if any.
2724  llvm::Value *getArrayInitIndex() { return ArrayInitIndex; }
2725 
2726  /// getAccessedFieldNo - Given an encoded value and a result number, return
2727  /// the input field number being accessed.
2728  static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
2729 
2730  llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
2731  llvm::BasicBlock *GetIndirectGotoBlock();
2732 
2733  /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
2734  static bool IsWrappedCXXThis(const Expr *E);
2735 
2736  /// EmitNullInitialization - Generate code to set a value of the given type to
2737  /// null, If the type contains data member pointers, they will be initialized
2738  /// to -1 in accordance with the Itanium C++ ABI.
2739  void EmitNullInitialization(Address DestPtr, QualType Ty);
2740 
2741  /// Emits a call to an LLVM variable-argument intrinsic, either
2742  /// \c llvm.va_start or \c llvm.va_end.
2743  /// \param ArgValue A reference to the \c va_list as emitted by either
2744  /// \c EmitVAListRef or \c EmitMSVAListRef.
2745  /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise,
2746  /// calls \c llvm.va_end.
2747  llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart);
2748 
2749  /// Generate code to get an argument from the passed in pointer
2750  /// and update it accordingly.
2751  /// \param VE The \c VAArgExpr for which to generate code.
2752  /// \param VAListAddr Receives a reference to the \c va_list as emitted by
2753  /// either \c EmitVAListRef or \c EmitMSVAListRef.
2754  /// \returns A pointer to the argument.
2755  // FIXME: We should be able to get rid of this method and use the va_arg
2756  // instruction in LLVM instead once it works well enough.
2757  Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr);
2758 
2759  /// emitArrayLength - Compute the length of an array, even if it's a
2760  /// VLA, and drill down to the base element type.
2762  QualType &baseType,
2763  Address &addr);
2764 
2765  /// EmitVLASize - Capture all the sizes for the VLA expressions in
2766  /// the given variably-modified type and store them in the VLASizeMap.
2767  ///
2768  /// This function can be called with a null (unreachable) insert point.
2770 
2771  struct VlaSizePair {
2774 
2776  };
2777 
2778  /// Return the number of elements for a single dimension
2779  /// for the given array type.
2780  VlaSizePair getVLAElements1D(const VariableArrayType *vla);
2781  VlaSizePair getVLAElements1D(QualType vla);
2782 
2783  /// Returns an LLVM value that corresponds to the size,
2784  /// in non-variably-sized elements, of a variable length array type,
2785  /// plus that largest non-variably-sized element type. Assumes that
2786  /// the type has already been emitted with EmitVariablyModifiedType.
2787  VlaSizePair getVLASize(const VariableArrayType *vla);
2788  VlaSizePair getVLASize(QualType vla);
2789 
2790  /// LoadCXXThis - Load the value of 'this'. This function is only valid while
2791  /// generating code for an C++ member function.
2793  assert(CXXThisValue && "no 'this' value for this function");
2794  return CXXThisValue;
2795  }
2797 
2798  /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
2799  /// virtual bases.
2800  // FIXME: Every place that calls LoadCXXVTT is something
2801  // that needs to be abstracted properly.
2803  assert(CXXStructorImplicitParamValue && "no VTT value for this function");
2804  return CXXStructorImplicitParamValue;
2805  }
2806 
2807  /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
2808  /// complete class to the given direct base.
2809  Address
2811  const CXXRecordDecl *Derived,
2812  const CXXRecordDecl *Base,
2813  bool BaseIsVirtual);
2814 
2815  static bool ShouldNullCheckClassCastValue(const CastExpr *Cast);
2816 
2817  /// GetAddressOfBaseClass - This function will add the necessary delta to the
2818  /// load of 'this' and returns address of the base class.
2820  const CXXRecordDecl *Derived,
2823  bool NullCheckValue, SourceLocation Loc);
2824 
2826  const CXXRecordDecl *Derived,
2829  bool NullCheckValue);
2830 
2831  /// GetVTTParameter - Return the VTT parameter that should be passed to a
2832  /// base constructor/destructor with virtual bases.
2833  /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
2834  /// to ItaniumCXXABI.cpp together with all the references to VTT.
2835  llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
2836  bool Delegating);
2837 
2839  CXXCtorType CtorType,
2840  const FunctionArgList &Args,
2841  SourceLocation Loc);
2842  // It's important not to confuse this and the previous function. Delegating
2843  // constructors are the C++0x feature. The constructor delegate optimization
2844  // is used to reduce duplication in the base and complete consturctors where
2845  // they are substantially the same.
2847  const FunctionArgList &Args);
2848 
2849  /// Emit a call to an inheriting constructor (that is, one that invokes a
2850  /// constructor inherited from a base class) by inlining its definition. This
2851  /// is necessary if the ABI does not support forwarding the arguments to the
2852  /// base class constructor (because they're variadic or similar).
2854  CXXCtorType CtorType,
2855  bool ForVirtualBase,
2856  bool Delegating,
2857  CallArgList &Args);
2858 
2859  /// Emit a call to a constructor inherited from a base class, passing the
2860  /// current constructor's arguments along unmodified (without even making
2861  /// a copy).
2863  bool ForVirtualBase, Address This,
2864  bool InheritedFromVBase,
2865  const CXXInheritedCtorInitExpr *E);
2866 
2868  bool ForVirtualBase, bool Delegating,
2869  AggValueSlot ThisAVS, const CXXConstructExpr *E);
2870 
2872  bool ForVirtualBase, bool Delegating,
2873  Address This, CallArgList &Args,
2874  AggValueSlot::Overlap_t Overlap,
2875  SourceLocation Loc, bool NewPointerIsChecked);
2876 
2877  /// Emit assumption load for all bases. Requires to be be called only on
2878  /// most-derived class and not under construction of the object.
2879  void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This);
2880 
2881  /// Emit assumption that vptr load == global vtable.
2882  void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
2883 
2885  Address This, Address Src,
2886  const CXXConstructExpr *E);
2887 
2889  const ArrayType *ArrayTy,
2890  Address ArrayPtr,
2891  const CXXConstructExpr *E,
2892  bool NewPointerIsChecked,
2893  bool ZeroInitialization = false);
2894 
2896  llvm::Value *NumElements,
2897  Address ArrayPtr,
2898  const CXXConstructExpr *E,
2899  bool NewPointerIsChecked,
2900  bool ZeroInitialization = false);
2901 
2903 
2905  bool ForVirtualBase, bool Delegating, Address This,
2906  QualType ThisTy);
2907 
2908  void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType,
2909  llvm::Type *ElementTy, Address NewPtr,
2910  llvm::Value *NumElements,
2911  llvm::Value *AllocSizeWithoutCookie);
2912 
2913  void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
2914  Address Ptr);
2915 
2916  void EmitSehCppScopeBegin();
2917  void EmitSehCppScopeEnd();
2918  void EmitSehTryScopeBegin();
2919  void EmitSehTryScopeEnd();
2920 
2921  llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr);
2922  void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
2923 
2925  void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
2926 
2927  void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
2928  QualType DeleteTy, llvm::Value *NumElements = nullptr,
2929  CharUnits CookieSize = CharUnits());
2930 
2932  const CallExpr *TheCallExpr, bool IsDelete);
2933 
2937 
2938  /// Situations in which we might emit a check for the suitability of a
2939  /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
2940  /// compiler-rt.
2942  /// Checking the operand of a load. Must be suitably sized and aligned.
2944  /// Checking the destination of a store. Must be suitably sized and aligned.
2946  /// Checking the bound value in a reference binding. Must be suitably sized
2947  /// and aligned, but is not required to refer to an object (until the
2948  /// reference is used), per core issue 453.
2950  /// Checking the object expression in a non-static data member access. Must
2951  /// be an object within its lifetime.
2953  /// Checking the 'this' pointer for a call to a non-static member function.
2954  /// Must be an object within its lifetime.
2956  /// Checking the 'this' pointer for a constructor call.
2958  /// Checking the operand of a static_cast to a derived pointer type. Must be
2959  /// null or an object within its lifetime.
2961  /// Checking the operand of a static_cast to a derived reference type. Must
2962  /// be an object within its lifetime.
2964  /// Checking the operand of a cast to a base object. Must be suitably sized
2965  /// and aligned.
2967  /// Checking the operand of a cast to a virtual base object. Must be an
2968  /// object within its lifetime.
2970  /// Checking the value assigned to a _Nonnull pointer. Must not be null.
2972  /// Checking the operand of a dynamic_cast or a typeid expression. Must be
2973  /// null or an object within its lifetime.
2975  };
2976 
2977  /// Determine whether the pointer type check \p TCK permits null pointers.
2978  static bool isNullPointerAllowed(TypeCheckKind TCK);
2979 
2980  /// Determine whether the pointer type check \p TCK requires a vptr check.
2981  static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty);
2982 
2983  /// Whether any type-checking sanitizers are enabled. If \c false,
2984  /// calls to EmitTypeCheck can be skipped.
2985  bool sanitizePerformTypeCheck() const;
2986 
2987  /// Emit a check that \p V is the address of storage of the
2988  /// appropriate size and alignment for an object of type \p Type
2989  /// (or if ArraySize is provided, for an array of that bound).
2991  QualType Type, CharUnits Alignment = CharUnits::Zero(),
2992  SanitizerSet SkippedChecks = SanitizerSet(),
2993  llvm::Value *ArraySize = nullptr);
2994 
2995  /// Emit a check that \p Base points into an array object, which
2996  /// we can access at index \p Index. \p Accessed should be \c false if we
2997  /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
2998  void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
2999  QualType IndexType, bool Accessed);
3000 
3002  bool isInc, bool isPre);
3004  bool isInc, bool isPre);
3005 
3006  /// Converts Location to a DebugLoc, if debug information is enabled.
3007  llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location);
3008 
3009  /// Get the record field index as represented in debug info.
3010  unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex);
3011 
3012 
3013  //===--------------------------------------------------------------------===//
3014  // Declaration Emission
3015  //===--------------------------------------------------------------------===//
3016 
3017  /// EmitDecl - Emit a declaration.
3018  ///
3019  /// This function can be called with a null (unreachable) insert point.
3020  void EmitDecl(const Decl &D);
3021 
3022  /// EmitVarDecl - Emit a local variable declaration.
3023  ///
3024  /// This function can be called with a null (unreachable) insert point.
3025  void EmitVarDecl(const VarDecl &D);
3026 
3027  void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue,
3028  bool capturedByInit);
3029 
3030  typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
3031  llvm::Value *Address);
3032 
3033  /// Determine whether the given initializer is trivial in the sense
3034  /// that it requires no code to be generated.
3035  bool isTrivialInitializer(const Expr *Init);
3036 
3037  /// EmitAutoVarDecl - Emit an auto variable declaration.
3038  ///
3039  /// This function can be called with a null (unreachable) insert point.
3040  void EmitAutoVarDecl(const VarDecl &D);
3041 
3043  friend class CodeGenFunction;
3044 
3045  const VarDecl *Variable;
3046 
3047  /// The address of the alloca for languages with explicit address space
3048  /// (e.g. OpenCL) or alloca casted to generic pointer for address space
3049  /// agnostic languages (e.g. C++). Invalid if the variable was emitted
3050  /// as a global constant.
3051  Address Addr;
3052 
3053  llvm::Value *NRVOFlag;
3054 
3055  /// True if the variable is a __block variable that is captured by an
3056  /// escaping block.
3057  bool IsEscapingByRef;
3058 
3059  /// True if the variable is of aggregate type and has a constant
3060  /// initializer.
3061  bool IsConstantAggregate;
3062 
3063  /// Non-null if we should use lifetime annotations.
3064  llvm::Value *SizeForLifetimeMarkers;
3065 
3066  /// Address with original alloca instruction. Invalid if the variable was
3067  /// emitted as a global constant.
3068  Address AllocaAddr;
3069 
3070  struct Invalid {};
3071  AutoVarEmission(Invalid)
3072  : Variable(nullptr), Addr(Address::invalid()),
3073  AllocaAddr(Address::invalid()) {}
3074 
3075  AutoVarEmission(const VarDecl &variable)
3076  : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr),
3077  IsEscapingByRef(false), IsConstantAggregate(false),
3078  SizeForLifetimeMarkers(nullptr), AllocaAddr(Address::invalid()) {}
3079 
3080  bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
3081 
3082  public:
3083  static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
3084 
3085  bool useLifetimeMarkers() const {
3086  return SizeForLifetimeMarkers != nullptr;
3087  }
3089  assert(useLifetimeMarkers());
3090  return SizeForLifetimeMarkers;
3091  }
3092 
3093  /// Returns the raw, allocated address, which is not necessarily
3094  /// the address of the object itself. It is casted to default
3095  /// address space for address space agnostic languages.
3097  return Addr;
3098  }
3099 
3100  /// Returns the address for the original alloca instruction.
3101  Address getOriginalAllocatedAddress() const { return AllocaAddr; }
3102 
3103  /// Returns the address of the object within this declaration.
3104  /// Note that this does not chase the forwarding pointer for
3105  /// __block decls.
3107  if (!IsEscapingByRef) return Addr;
3108 
3109  return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false);
3110  }
3111  };
3112  AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
3113  void EmitAutoVarInit(const AutoVarEmission &emission);
3114  void EmitAutoVarCleanups(const AutoVarEmission &emission);
3115  void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
3116  QualType::DestructionKind dtorKind);
3117 
3118  /// Emits the alloca and debug information for the size expressions for each
3119  /// dimension of an array. It registers the association of its (1-dimensional)
3120  /// QualTypes and size expression's debug node, so that CGDebugInfo can
3121  /// reference this node when creating the DISubrange object to describe the
3122  /// array types.
3124  const VarDecl &D,
3125  bool EmitDebugInfo);
3126 
3127  void EmitStaticVarDecl(const VarDecl &D,
3128  llvm::GlobalValue::LinkageTypes Linkage);
3129 
3130  class ParamValue {
3131  llvm::Value *Value;
3132  llvm::Type *ElementType;
3133  unsigned Alignment;
3134  ParamValue(llvm::Value *V, llvm::Type *T, unsigned A)
3135  : Value(V), ElementType(T), Alignment(A) {}
3136  public:
3138  return ParamValue(value, nullptr, 0);
3139  }
3141  assert(!addr.getAlignment().isZero());
3142  return ParamValue(addr.getPointer(), addr.getElementType(),
3143  addr.getAlignment().getQuantity());
3144  }
3145 
3146  bool isIndirect() const { return Alignment != 0; }
3147  llvm::Value *getAnyValue() const { return Value; }
3148 
3150  assert(!isIndirect());
3151  return Value;
3152  }
3153 
3155  assert(isIndirect());
3156  return Address(Value, ElementType, CharUnits::fromQuantity(Alignment));
3157  }
3158  };
3159 
3160  /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3161  void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo);
3162 
3163  /// protectFromPeepholes - Protect a value that we're intending to
3164  /// store to the side, but which will probably be used later, from
3165  /// aggressive peepholing optimizations that might delete it.
3166  ///
3167  /// Pass the result to unprotectFromPeepholes to declare that
3168  /// protection is no longer required.
3169  ///
3170  /// There's no particular reason why this shouldn't apply to
3171  /// l-values, it's just that no existing peepholes work on pointers.
3172  PeepholeProtection protectFromPeepholes(RValue rvalue);
3173  void unprotectFromPeepholes(PeepholeProtection protection);
3174 
3176  SourceLocation Loc,
3177  SourceLocation AssumptionLoc,
3178  llvm::Value *Alignment,
3179  llvm::Value *OffsetValue,
3180  llvm::Value *TheCheck,
3181  llvm::Instruction *Assumption);
3182 
3183  void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
3184  SourceLocation Loc, SourceLocation AssumptionLoc,
3185  llvm::Value *Alignment,
3186  llvm::Value *OffsetValue = nullptr);
3187 
3188  void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E,
3189  SourceLocation AssumptionLoc,
3190  llvm::Value *Alignment,
3191  llvm::Value *OffsetValue = nullptr);
3192 
3193  //===--------------------------------------------------------------------===//
3194  // Statement Emission
3195  //===--------------------------------------------------------------------===//
3196 
3197  /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3198  void EmitStopPoint(const Stmt *S);
3199 
3200  /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3201  /// this function even if there is no current insertion point.
3202  ///
3203  /// This function may clear the current insertion point; callers should use
3204  /// EnsureInsertPoint if they wish to subsequently generate code without first
3205  /// calling EmitBlock, EmitBranch, or EmitStmt.
3206  void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = None);
3207 
3208  /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3209  /// necessarily require an insertion point or debug information; typically
3210  /// because the statement amounts to a jump or a container of other
3211  /// statements.
3212  ///
3213  /// \return True if the statement was handled.
3214  bool EmitSimpleStmt(const Stmt *S, ArrayRef<const Attr *> Attrs);
3215 
3216  Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
3219  bool GetLast = false,
3220  AggValueSlot AVS =
3222 
3223  /// EmitLabel - Emit the block for the given label. It is legal to call this
3224  /// function even if there is no current insertion point.
3225  void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
3226 
3227  void EmitLabelStmt(const LabelStmt &S);
3228  void EmitAttributedStmt(const AttributedStmt &S);
3229  void EmitGotoStmt(const GotoStmt &S);
3230  void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
3231  void EmitIfStmt(const IfStmt &S);
3232 
3233  void EmitWhileStmt(const WhileStmt &S,
3234  ArrayRef<const Attr *> Attrs = None);
3235  void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = None);
3236  void EmitForStmt(const ForStmt &S,
3237  ArrayRef<const Attr *> Attrs = None);
3238  void EmitReturnStmt(const ReturnStmt &S);
3239  void EmitDeclStmt(const DeclStmt &S);
3240  void EmitBreakStmt(const BreakStmt &S);
3241  void EmitContinueStmt(const ContinueStmt &S);
3242  void EmitSwitchStmt(const SwitchStmt &S);
3243  void EmitDefaultStmt(const DefaultStmt &S, ArrayRef<const Attr *> Attrs);
3244  void EmitCaseStmt(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3245  void EmitCaseStmtRange(const CaseStmt &S, ArrayRef<const Attr *> Attrs);
3246  void EmitAsmStmt(const AsmStmt &S);
3247 
3249  void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
3250  void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
3253 
3254  void EmitCoroutineBody(const CoroutineBodyStmt &S);
3255  void EmitCoreturnStmt(const CoreturnStmt &S);
3257  AggValueSlot aggSlot = AggValueSlot::ignored(),
3258  bool ignoreResult = false);
3261  AggValueSlot aggSlot = AggValueSlot::ignored(),
3262  bool ignoreResult = false);
3264  RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3265 
3266  void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3267  void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
3268 
3269  void EmitCXXTryStmt(const CXXTryStmt &S);
3270  void EmitSEHTryStmt(const SEHTryStmt &S);
3271  void EmitSEHLeaveStmt(const SEHLeaveStmt &S);
3272  void EnterSEHTryStmt(const SEHTryStmt &S);
3273  void ExitSEHTryStmt(const SEHTryStmt &S);
3274  void VolatilizeTryBlocks(llvm::BasicBlock *BB,
3276 
3278  llvm::Function *FinallyFunc);
3279  void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter,
3280  const Stmt *OutlinedStmt);
3281 
3283  const SEHExceptStmt &Except);
3284 
3286  const SEHFinallyStmt &Finally);
3287 
3289  llvm::Value *ParentFP,
3290  llvm::Value *EntryEBP);
3294 
3295  /// Emit simple code for OpenMP directives in Simd-only mode.
3297 
3298  /// Scan the outlined statement for captures from the parent function. For
3299  /// each capture, mark the capture as escaped and emit a call to
3300  /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap.
3301  void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt,
3302  bool IsFilter);
3303 
3304  /// Recovers the address of a local in a parent function. ParentVar is the
3305  /// address of the variable used in the immediate parent function. It can
3306  /// either be an alloca or a call to llvm.localrecover if there are nested
3307  /// outlined functions. ParentFP is the frame pointer of the outermost parent
3308  /// frame.
3310  Address ParentVar,
3311  llvm::Value *ParentFP);
3312 
3313  void EmitCXXForRangeStmt(const CXXForRangeStmt &S,
3314  ArrayRef<const Attr *> Attrs = None);
3315 
3316  /// Controls insertion of cancellation exit blocks in worksharing constructs.
3318  CodeGenFunction &CGF;
3319 
3320  public:
3322  bool HasCancel)
3323  : CGF(CGF) {
3324  CGF.OMPCancelStack.enter(CGF, Kind, HasCancel);
3325  }
3326  ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); }
3327  };
3328 
3329  /// Returns calculated size of the specified type.
3332  llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
3333  llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
3335  llvm::Function *GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S,
3336  SourceLocation Loc);
3338  SmallVectorImpl<llvm::Value *> &CapturedVars);
3339  void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy,
3340  SourceLocation Loc);
3341  /// Perform element by element copying of arrays with type \a
3342  /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
3343  /// generated by \a CopyGen.
3344  ///
3345  /// \param DestAddr Address of the destination array.
3346  /// \param SrcAddr Address of the source array.
3347  /// \param OriginalType Type of destination and source arrays.
3348  /// \param CopyGen Copying procedure that copies value of single array element
3349  /// to another single array element.
3351  Address DestAddr, Address SrcAddr, QualType OriginalType,
3352  const llvm::function_ref<void(Address, Address)> CopyGen);
3353  /// Emit proper copying of data from one variable to another.
3354  ///
3355  /// \param OriginalType Original type of the copied variables.
3356  /// \param DestAddr Destination address.
3357  /// \param SrcAddr Source address.
3358  /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3359  /// type of the base array element).
3360  /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3361  /// the base array element).
3362  /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
3363  /// DestVD.
3364  void EmitOMPCopy(QualType OriginalType,
3365  Address DestAddr, Address SrcAddr,
3366  const VarDecl *DestVD, const VarDecl *SrcVD,
3367  const Expr *Copy);
3368  /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or
3369  /// \a X = \a E \a BO \a E.
3370  ///
3371  /// \param X Value to be updated.
3372  /// \param E Update value.
3373  /// \param BO Binary operation for update operation.
3374  /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3375  /// expression, false otherwise.
3376  /// \param AO Atomic ordering of the generated atomic instructions.
3377  /// \param CommonGen Code generator for complex expressions that cannot be
3378  /// expressed through atomicrmw instruction.
3379  /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was
3380  /// generated, <false, RValue::get(nullptr)> otherwise.
3381  std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr(
3382  LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
3383  llvm::AtomicOrdering AO, SourceLocation Loc,
3384  const llvm::function_ref<RValue(RValue)> CommonGen);
3386  OMPPrivateScope &PrivateScope);
3388  OMPPrivateScope &PrivateScope);
3390  const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope,
3391  const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);
3393  const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope,
3394  const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);
3395  /// Emit code for copyin clause in \a D directive. The next code is
3396  /// generated at the start of outlined functions for directives:
3397  /// \code
3398  /// threadprivate_var1 = master_threadprivate_var1;
3399  /// operator=(threadprivate_var2, master_threadprivate_var2);
3400  /// ...
3401  /// __kmpc_barrier(&loc, global_tid);
3402  /// \endcode
3403  ///
3404  /// \param D OpenMP directive possibly with 'copyin' clause(s).
3405  /// \returns true if at least one copyin variable is found, false otherwise.
3407  /// Emit initial code for lastprivate variables. If some variable is
3408  /// not also firstprivate, then the default initialization is used. Otherwise
3409  /// initialization of this variable is performed by EmitOMPFirstprivateClause
3410  /// method.
3411  ///
3412  /// \param D Directive that may have 'lastprivate' directives.
3413  /// \param PrivateScope Private scope for capturing lastprivate variables for
3414  /// proper codegen in internal captured statement.
3415  ///
3416  /// \returns true if there is at least one lastprivate variable, false
3417  /// otherwise.
3419  OMPPrivateScope &PrivateScope);
3420  /// Emit final copying of lastprivate values to original variables at
3421  /// the end of the worksharing or simd directive.
3422  ///
3423  /// \param D Directive that has at least one 'lastprivate' directives.
3424  /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
3425  /// it is the last iteration of the loop code in associated directive, or to
3426  /// 'i1 false' otherwise. If this item is nullptr, no final check is required.
3428  bool NoFinals,
3429  llvm::Value *IsLastIterCond = nullptr);
3430  /// Emit initial code for linear clauses.
3431  void EmitOMPLinearClause(const OMPLoopDirective &D,
3432  CodeGenFunction::OMPPrivateScope &PrivateScope);
3433  /// Emit final code for linear clauses.
3434  /// \param CondGen Optional conditional code for final part of codegen for
3435  /// linear clause.
3437  const OMPLoopDirective &D,
3438  const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3439  /// Emit initial code for reduction variables. Creates reduction copies
3440  /// and initializes them with the values according to OpenMP standard.
3441  ///
3442  /// \param D Directive (possibly) with the 'reduction' clause.
3443  /// \param PrivateScope Private scope for capturing reduction variables for
3444  /// proper codegen in internal captured statement.
3445  ///
3447  OMPPrivateScope &PrivateScope,
3448  bool ForInscan = false);
3449  /// Emit final update of reduction values to original variables at
3450  /// the end of the directive.
3451  ///
3452  /// \param D Directive that has at least one 'reduction' directives.
3453  /// \param ReductionKind The kind of reduction to perform.
3455  const OpenMPDirectiveKind ReductionKind);
3456  /// Emit initial code for linear variables. Creates private copies
3457  /// and initializes them with the values according to OpenMP standard.
3458  ///
3459  /// \param D Directive (possibly) with the 'linear' clause.
3460  /// \return true if at least one linear variable is found that should be
3461  /// initialized with the value of the original variable, false otherwise.
3463 
3464  typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/,
3465  llvm::Function * /*OutlinedFn*/,
3466  const OMPTaskDataTy & /*Data*/)>
3469  const OpenMPDirectiveKind CapturedRegion,
3470  const RegionCodeGenTy &BodyGen,
3471  const TaskGenTy &TaskGen, OMPTaskDataTy &Data);
3477  unsigned NumberOfTargetItems = 0;
3478  explicit OMPTargetDataInfo() = default;
3481  unsigned NumberOfTargetItems)
3485  };
3487  const RegionCodeGenTy &BodyGen,
3488  OMPTargetDataInfo &InputInfo);
3489 
3490  void EmitOMPMetaDirective(const OMPMetaDirective &S);
3492  void EmitOMPSimdDirective(const OMPSimdDirective &S);
3493  void EmitOMPTileDirective(const OMPTileDirective &S);
3495  void EmitOMPForDirective(const OMPForDirective &S);
3507  void EmitOMPTaskDirective(const OMPTaskDirective &S);
3514  void EmitOMPScanDirective(const OMPScanDirective &S);
3523  void
3526  void
3533  void
3549  void
3565 
3566  /// Emit device code for the target directive.
3568  StringRef ParentName,
3569  const OMPTargetDirective &S);
3570  static void
3571  EmitOMPTargetParallelDeviceFunction(CodeGenModule &CGM, StringRef ParentName,
3572  const OMPTargetParallelDirective &S);
3573  /// Emit device code for the target parallel for directive.
3575  CodeGenModule &CGM, StringRef ParentName,
3577  /// Emit device code for the target parallel for simd directive.
3579  CodeGenModule &CGM, StringRef ParentName,
3581  /// Emit device code for the target teams directive.
3582  static void
3583  EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName,
3584  const OMPTargetTeamsDirective &S);
3585  /// Emit device code for the target teams distribute directive.
3587  CodeGenModule &CGM, StringRef ParentName,
3589  /// Emit device code for the target teams distribute simd directive.
3591  CodeGenModule &CGM, StringRef ParentName,
3593  /// Emit device code for the target simd directive.
3595  StringRef ParentName,
3596  const OMPTargetSimdDirective &S);
3597  /// Emit device code for the target teams distribute parallel for simd
3598  /// directive.
3600  CodeGenModule &CGM, StringRef ParentName,
3602 
3604  CodeGenModule &CGM, StringRef ParentName,
3606 
3607  /// Emit the Stmt \p S and return its topmost canonical loop, if any.
3608  /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
3609  /// future it is meant to be the number of loops expected in the loop nests
3610  /// (usually specified by the "collapse" clause) that are collapsed to a
3611  /// single loop by this function.
3612  llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S,
3613  int Depth);
3614 
3615  /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder.
3616  void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S);
3617 
3618  /// Emit inner loop of the worksharing/simd construct.
3619  ///
3620  /// \param S Directive, for which the inner loop must be emitted.
3621  /// \param RequiresCleanup true, if directive has some associated private
3622  /// variables.
3623  /// \param LoopCond Bollean condition for loop continuation.
3624  /// \param IncExpr Increment expression for loop control variable.
3625  /// \param BodyGen Generator for the inner body of the inner loop.
3626  /// \param PostIncGen Genrator for post-increment code (required for ordered
3627  /// loop directvies).
3628  void EmitOMPInnerLoop(
3629  const OMPExecutableDirective &S, bool RequiresCleanup,
3630  const Expr *LoopCond, const Expr *IncExpr,
3631  const llvm::function_ref<void(CodeGenFunction &)> BodyGen,
3632  const llvm::function_ref<void(CodeGenFunction &)> PostIncGen);
3633 
3635  /// Emit initial code for loop counters of loop-based directives.
3637  OMPPrivateScope &LoopScope);
3638 
3639  /// Helper for the OpenMP loop directives.
3640  void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit);
3641 
3642  /// Emit code for the worksharing loop-based directive.
3643  /// \return true, if this construct has any lastprivate clause, false -
3644  /// otherwise.
3645  bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB,
3646  const CodeGenLoopBoundsTy &CodeGenLoopBounds,
3647  const CodeGenDispatchBoundsTy &CGDispatchBounds);
3648 
3649  /// Emit code for the distribute loop-based directive.
3651  const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr);
3652 
3653  /// Helpers for the OpenMP loop directives.
3654  void EmitOMPSimdInit(const OMPLoopDirective &D);
3655  void EmitOMPSimdFinal(
3656  const OMPLoopDirective &D,
3657  const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen);
3658 
3659  /// Emits the lvalue for the expression with possibly captured variable.
3660  LValue EmitOMPSharedLValue(const Expr *E);
3661 
3662 private:
3663  /// Helpers for blocks.
3665 
3666  /// struct with the values to be passed to the OpenMP loop-related functions
3667  struct OMPLoopArguments {
3668  /// loop lower bound
3669  Address LB = Address::invalid();
3670  /// loop upper bound
3671  Address UB = Address::invalid();
3672  /// loop stride
3673  Address ST = Address::invalid();
3674  /// isLastIteration argument for runtime functions
3675  Address IL = Address::invalid();
3676  /// Chunk value generated by sema
3677  llvm::Value *Chunk = nullptr;
3678  /// EnsureUpperBound
3679  Expr *EUB = nullptr;
3680  /// IncrementExpression
3681  Expr *IncExpr = nullptr;
3682  /// Loop initialization
3683  Expr *Init = nullptr;
3684  /// Loop exit condition
3685  Expr *Cond = nullptr;
3686  /// Update of LB after a whole chunk has been executed
3687  Expr *NextLB = nullptr;
3688  /// Update of UB after a whole chunk has been executed
3689  Expr *NextUB = nullptr;
3690  OMPLoopArguments() = default;
3691  OMPLoopArguments(Address LB, Address UB, Address ST, Address IL,
3692  llvm::Value *Chunk = nullptr, Expr *EUB = nullptr,
3693  Expr *IncExpr = nullptr, Expr *Init = nullptr,
3694  Expr *Cond = nullptr, Expr *NextLB = nullptr,
3695  Expr *NextUB = nullptr)
3696  : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB),
3697  IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB),
3698  NextUB(NextUB) {}
3699  };
3700  void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic,
3701  const OMPLoopDirective &S, OMPPrivateScope &LoopScope,
3702  const OMPLoopArguments &LoopArgs,
3703  const CodeGenLoopTy &CodeGenLoop,
3704  const CodeGenOrderedTy &CodeGenOrdered);
3705  void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind,
3706  bool IsMonotonic, const OMPLoopDirective &S,
3707  OMPPrivateScope &LoopScope, bool Ordered,
3708  const OMPLoopArguments &LoopArgs,
3709  const CodeGenDispatchBoundsTy &CGDispatchBounds);
3710  void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind,
3711  const OMPLoopDirective &S,
3712  OMPPrivateScope &LoopScope,
3713  const OMPLoopArguments &LoopArgs,
3714  const CodeGenLoopTy &CodeGenLoopContent);
3715  /// Emit code for sections directive.
3716  void EmitSections(const OMPExecutableDirective &S);
3717 
3718 public:
3719 
3720  //===--------------------------------------------------------------------===//
3721  // LValue Expression Emission
3722  //===--------------------------------------------------------------------===//
3723 
3724  /// Create a check that a scalar RValue is non-null.
3725  llvm::Value *EmitNonNullRValueCheck(RValue RV, QualType T);
3726 
3727  /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
3728  RValue GetUndefRValue(QualType Ty);
3729 
3730  /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
3731  /// and issue an ErrorUnsupported style diagnostic (using the
3732  /// provided Name).
3733  RValue EmitUnsupportedRValue(const Expr *E,
3734  const char *Name);
3735 
3736  /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
3737  /// an ErrorUnsupported style diagnostic (using the provided Name).
3738  LValue EmitUnsupportedLValue(const Expr *E,
3739  const char *Name);
3740 
3741  /// EmitLValue - Emit code to compute a designator that specifies the location
3742  /// of the expression.
3743  ///
3744  /// This can return one of two things: a simple address or a bitfield
3745  /// reference. In either case, the LLVM Value* in the LValue structure is
3746  /// guaranteed to be an LLVM pointer type.
3747  ///
3748  /// If this returns a bitfield reference, nothing about the pointee type of
3749  /// the LLVM value is known: For example, it may not be a pointer to an
3750  /// integer.
3751  ///
3752  /// If this returns a normal address, and if the lvalue's C type is fixed
3753  /// size, this method guarantees that the returned pointer type will point to
3754  /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
3755  /// variable length type, this is not possible.
3756  ///
3757  LValue EmitLValue(const Expr *E);
3758 
3759  /// Same as EmitLValue but additionally we generate checking code to
3760  /// guard against undefined behavior. This is only suitable when we know
3761  /// that the address will be used to access the object.
3762  LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK);
3763 
3764  RValue convertTempToRValue(Address addr, QualType type,
3765  SourceLocation Loc);
3766 
3767  void EmitAtomicInit(Expr *E, LValue lvalue);
3768 
3769  bool LValueIsSuitableForInlineAtomic(LValue Src);
3770 
3771  RValue EmitAtomicLoad(LValue LV, SourceLocation SL,
3772  AggValueSlot Slot = AggValueSlot::ignored());
3773 
3774  RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc,
3775  llvm::AtomicOrdering AO, bool IsVolatile = false,
3776  AggValueSlot slot = AggValueSlot::ignored());
3777 
3778  void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
3779 
3780  void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO,
3781  bool IsVolatile, bool isInit);
3782 
3783  std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
3784  LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc,
3785  llvm::AtomicOrdering Success =
3786  llvm::AtomicOrdering::SequentiallyConsistent,
3787  llvm::AtomicOrdering Failure =
3788  llvm::AtomicOrdering::SequentiallyConsistent,
3789  bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored());
3790 
3791  void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO,
3792  const llvm::function_ref<RValue(RValue)> &UpdateOp,
3793  bool IsVolatile);
3794 
3795  /// EmitToMemory - Change a scalar value from its value
3796  /// representation to its in-memory representation.
3797  llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
3798 
3799  /// EmitFromMemory - Change a scalar value from its memory
3800  /// representation to its value representation.
3801  llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
3802 
3803  /// Check if the scalar \p Value is within the valid range for the given
3804  /// type \p Ty.
3805  ///
3806  /// Returns true if a check is needed (even if the range is unknown).
3807  bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty,
3808  SourceLocation Loc);
3809 
3810  /// EmitLoadOfScalar - Load a scalar value from an address, taking
3811  /// care to appropriately convert from the memory representation to
3812  /// the LLVM value representation.
3813  llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3814  SourceLocation Loc,
3816  bool isNontemporal = false) {
3817  return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source),
3818  CGM.getTBAAAccessInfo(Ty), isNontemporal);
3819  }
3820 
3821  llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty,
3822  SourceLocation Loc, LValueBaseInfo BaseInfo,
3823  TBAAAccessInfo TBAAInfo,
3824  bool isNontemporal = false);
3825 
3826  /// EmitLoadOfScalar - Load a scalar value from an address, taking
3827  /// care to appropriately convert from the memory representation to
3828  /// the LLVM value representation. The l-value must be a simple
3829  /// l-value.
3831 
3832  /// EmitStoreOfScalar - Store a scalar value to an address, taking
3833  /// care to appropriately convert from the memory representation to
3834  /// the LLVM value representation.
3836  bool Volatile, QualType Ty,
3838  bool isInit = false, bool isNontemporal = false) {
3839  EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source),
3840  CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal);
3841  }
3842 
3844  bool Volatile, QualType Ty,
3845  LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo,
3846  bool isInit = false, bool isNontemporal = false);
3847 
3848  /// EmitStoreOfScalar - Store a scalar value to an address, taking
3849  /// care to appropriately convert from the memory representation to
3850  /// the LLVM value representation. The l-value must be a simple
3851  /// l-value. The isInit flag indicates whether this is an initialization.
3852  /// If so, atomic qualifiers are ignored and the store is always non-atomic.
3853  void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
3854 
3855  /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
3856  /// this method emits the address of the lvalue, then loads the result as an
3857  /// rvalue, returning the rvalue.
3862 
3863  /// EmitStoreThroughLValue - Store the specified rvalue into the specified
3864  /// lvalue, where both are guaranteed to the have the same type, and that type
3865  /// is 'Ty'.
3866  void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
3869 
3870  /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
3871  /// as EmitStoreThroughLValue.
3872  ///
3873  /// \param Result [out] - If non-null, this will be set to a Value* for the
3874  /// bit-field contents after the store, appropriate for use as the result of
3875  /// an assignment to the bit-field.
3877  llvm::Value **Result=nullptr);
3878 
3879  /// Emit an l-value for an assignment (simple or compound) of complex type.
3883  llvm::Value *&Result);
3884 
3885  // Note: only available for agg return types
3888  // Note: only available for agg return types
3890  // Note: only available for agg return types
3898  bool Accessed = false);
3901  bool IsLowerBound = true);
3903  LValue EmitMemberExpr(const MemberExpr *E);
3908  LValue EmitCastLValue(const CastExpr *E);
3911 
3913 
3915 
3916  Address EmitArrayToPointerDecay(const Expr *Array,
3917  LValueBaseInfo *BaseInfo = nullptr,
3918  TBAAAccessInfo *TBAAInfo = nullptr);
3919 
3921  llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
3922  ConstantEmission(llvm::Constant *C, bool isReference)
3923  : ValueAndIsReference(C, isReference) {}
3924  public:
3926  static ConstantEmission forReference(llvm::Constant *C) {
3927  return ConstantEmission(C, true);
3928  }
3929  static ConstantEmission forValue(llvm::Constant *C) {
3930  return ConstantEmission(C, false);
3931  }
3932 
3933  explicit operator bool() const {
3934  return ValueAndIsReference.getOpaqueValue() != nullptr;
3935  }
3936 
3937  bool isReference() const { return ValueAndIsReference.getInt(); }
3939  assert(isReference());
3940  return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
3941  refExpr->getType());
3942  }
3943 
3944  llvm::Constant *getValue() const {
3945  assert(!isReference());
3946  return ValueAndIsReference.getPointer();
3947  }
3948  };
3949 
3950  ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr);
3951  ConstantEmission tryEmitAsConstant(const MemberExpr *ME);
3952  llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E);
3953 
3957 
3958  llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
3959  const ObjCIvarDecl *Ivar);
3962 
3963  /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
3964  /// if the Field is a reference, this will return the address of the reference
3965  /// and not the address of the value stored in the reference.
3967  const FieldDecl* Field);
3968 
3970  llvm::Value* Base, const ObjCIvarDecl *Ivar,
3971  unsigned CVRQualifiers);
3972 
3977 
3983  void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init);
3984 
3985  //===--------------------------------------------------------------------===//
3986  // Scalar Expression Emission
3987  //===--------------------------------------------------------------------===//
3988 
3989  /// EmitCall - Generate a call of the given function, expecting the given
3990  /// result type, and using the given argument list which specifies both the
3991  /// LLVM arguments and the types they were derived from.
3992  RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
3994  llvm::CallBase **callOrInvoke, bool IsMustTail,
3995  SourceLocation Loc);
3996  RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee,
3998  llvm::CallBase **callOrInvoke = nullptr,
3999  bool IsMustTail = false) {
4000  return EmitCall(CallInfo, Callee, ReturnValue, Args, callOrInvoke,
4001  IsMustTail, SourceLocation());
4002  }
4003  RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
4004  ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr);
4005  RValue EmitCallExpr(const CallExpr *E,
4008  CGCallee EmitCallee(const Expr *E);
4009 
4010  void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
4011  void checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl);
4012 
4013  llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4014  const Twine &name = "");
4015  llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
4017  const Twine &name = "");
4018  llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4019  const Twine &name = "");
4020  llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4022  const Twine &name = "");
4023 
4026 
4027  llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee,
4029  const Twine &Name = "");
4030  llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4032  const Twine &name = "");
4033  llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4034  const Twine &name = "");
4035  void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee,
4037 
4039  NestedNameSpecifier *Qual,
4040  llvm::Type *Ty);
4041 
4043  CXXDtorType Type,
4044  const CXXRecordDecl *RD);
4045 
4046  // Return the copy constructor name with the prefix "__copy_constructor_"
4047  // removed.
4049  CharUnits Alignment,
4050  bool IsVolatile,
4051  ASTContext &Ctx);
4052 
4053  // Return the destructor name with the prefix "__destructor_" removed.
4055  CharUnits Alignment,
4056  bool IsVolatile,
4057  ASTContext &Ctx);
4058 
4059  // These functions emit calls to the special functions of non-trivial C
4060  // structs.
4063  void callCStructDestructor(LValue Dst);
4064  void callCStructCopyConstructor(LValue Dst, LValue Src);
4065  void callCStructMoveConstructor(LValue Dst, LValue Src);
4068 
4069  RValue
4071  const CGCallee &Callee,
4073  llvm::Value *ImplicitParam,
4074  QualType ImplicitParamTy, const CallExpr *E,
4075  CallArgList *RtlArgs);
4076  RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee,
4077  llvm::Value *This, QualType ThisTy,
4078  llvm::Value *ImplicitParam,
4079  QualType ImplicitParamTy, const CallExpr *E);
4083  const CXXMethodDecl *MD,
4085  bool HasQualifier,
4086  NestedNameSpecifier *Qualifier,
4087  bool IsArrow, const Expr *Base);
4088  // Compute the object pointer.
4090  llvm::Value *memberPtr,
4091  const MemberPointerType *memberPtrType,
4092  LValueBaseInfo *BaseInfo = nullptr,
4093  TBAAAccessInfo *TBAAInfo = nullptr);
4096 
4098  const CXXMethodDecl *MD,
4101 
4104 
4108 
4109  RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
4111 
4112  RValue emitRotate(const CallExpr *E, bool IsRotateRight);
4113 
4114  /// Emit IR for __builtin_os_log_format.
4116 
4117  /// Emit IR for __builtin_is_aligned.
4119  /// Emit IR for __builtin_align_up/__builtin_align_down.
4120  RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp);
4121 
4122  llvm::Function *generateBuiltinOSLogHelperFunction(
4123  const analyze_os_log::OSLogBufferLayout &Layout,
4124  CharUnits BufferAlignment);
4125 
4127 
4128  /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4129  /// is unhandled by the current target.
4130  llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4132 
4134  const llvm::CmpInst::Predicate Fp,
4135  const llvm::CmpInst::Predicate Ip,
4136  const llvm::Twine &Name = "");
4137  llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4139  llvm::Triple::ArchType Arch);
4140  llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4142  llvm::Triple::ArchType Arch);
4143  llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4145  llvm::Triple::ArchType Arch);
4146  llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy,
4147  QualType RTy);
4148  llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy,
4149  QualType RTy);
4150 
4151  llvm::Value *EmitCommonNeonBuiltinExpr(unsigned BuiltinID,
4152  unsigned LLVMIntrinsic,
4153  unsigned AltLLVMIntrinsic,
4154  const char *NameHint,
4155  unsigned Modifier,
4156  const CallExpr *E,
4158  Address PtrOp0, Address PtrOp1,
4159  llvm::Triple::ArchType Arch);
4160 
4161  llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
4162  unsigned Modifier, llvm::Type *ArgTy,
4163  const CallExpr *E);
4164  llvm::Value *EmitNeonCall(llvm::Function *F,
4166  const char *name,
4167  unsigned shift = 0, bool rightshift = false);
4168  llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
4169  const llvm::ElementCount &Count);
4170  llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
4171  llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
4172  bool negateForRightShift);
4174  llvm::Type *Ty, bool usgn, const char *name);
4176  /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4177  /// access builtin. Only required if it can't be inferred from the base
4178  /// pointer operand.
4179  llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags);
4180 
4182  getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType,
4184  llvm::Type *getEltType(const SVETypeFlags &TypeFlags);
4185  llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags);
4186  llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags);
4187  llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags);
4189  llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty);
4190  llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty);
4191  llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags,
4193  unsigned BuiltinID);
4194  llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags,
4196  unsigned BuiltinID);
4198  llvm::ScalableVectorType *VTy);
4199  llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags,
4201  unsigned IntID);
4202  llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags,
4204  unsigned IntID);
4205  llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy,
4207  unsigned BuiltinID, bool IsZExtReturn);
4210  unsigned BuiltinID);
4211  llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags,
4213  unsigned BuiltinID);
4216  unsigned IntID);
4217  llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags,
4219  unsigned IntID);
4220  llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags,
4222  unsigned IntID);
4223  llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4224 
4225  llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4226  llvm::Triple::ArchType Arch);
4227  llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4228 
4230  llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4231  llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4232  llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4233  llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4234  llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4235  llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
4236  const CallExpr *E);
4237  llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
4238  llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
4241  llvm::AtomicOrdering &AO,
4242  llvm::SyncScope::ID &SSID);
4243 
4244  enum class MSVCIntrin;
4245  llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4246 
4247  llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version);
4248 
4255  const ObjCMethodDecl *MethodWithObjects);
4258  ReturnValueSlot Return = ReturnValueSlot());
4259 
4260  /// Retrieves the default cleanup kind for an ARC cleanup.
4261  /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4263  return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
4265  }
4266 
4267  // ARC primitives.
4268  void EmitARCInitWeak(Address addr, llvm::Value *value);
4269  void EmitARCDestroyWeak(Address addr);
4272  llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored);
4273  void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4274  void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr);
4275  void EmitARCCopyWeak(Address dst, Address src);
4276  void EmitARCMoveWeak(Address dst, Address src);
4280  bool resultIgnored);
4282  bool resultIgnored);
4285  llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
4287  void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4293 
4294  llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
4296  llvm::Type *returnType);
4297  void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise);
4298 
4299  std::pair<LValue,llvm::Value*>
4301  std::pair<LValue,llvm::Value*>
4302  EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
4303  std::pair<LValue,llvm::Value*>
4304  EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored);
4305 
4307  llvm::Type *returnType);
4309  llvm::Type *returnType);
4310  llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
4311 
4315 
4318  bool allowUnsafeClaim);
4322 
4324 
4326 
4332 
4338 
4339  /// Emits a reference binding to the passed in expression.
4341 
4342  //===--------------------------------------------------------------------===//
4343  // Expression Emission
4344  //===--------------------------------------------------------------------===//
4345 
4346  // Expressions are broken into three classes: scalar, complex, aggregate.
4347 
4348  /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
4349  /// scalar type, returning the result.
4350  llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
4351 
4352  /// Emit a conversion from the specified type to the specified destination
4353  /// type, both of which are LLVM scalar types.
4355  QualType DstTy, SourceLocation Loc);
4356 
4357  /// Emit a conversion from the specified complex type to the specified
4358  /// destination type, where the destination type is an LLVM scalar type.
4360  QualType DstTy,
4361  SourceLocation Loc);
4362 
4363  /// EmitAggExpr - Emit the computation of the specified expression
4364  /// of aggregate type. The result is computed into the given slot,
4365  /// which may be null to indicate that the value is not needed.
4366  void EmitAggExpr(const Expr *E, AggValueSlot AS);
4367 
4368  /// EmitAggExprToLValue - Emit the computation of the specified expression of
4369  /// aggregate type into a temporary LValue.
4370  LValue EmitAggExprToLValue(const Expr *E);
4371 
4372  /// Build all the stores needed to initialize an aggregate at Dest with the
4373  /// value Val.
4374  void EmitAggregateStore(llvm::Value *Val, Address Dest, bool DestIsVolatile);
4375 
4376  /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
4377  /// make sure it survives garbage collection until this point.
4378  void EmitExtendGCLifetime(llvm::Value *object);
4379 
4380  /// EmitComplexExpr - Emit the computation of the specified expression of
4381  /// complex type, returning the result.
4383  bool IgnoreReal = false,
4384  bool IgnoreImag = false);
4385 
4386  /// EmitComplexExprIntoLValue - Emit the given expression of complex
4387  /// type and place its result into the specified l-value.
4388  void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit);
4389 
4390  /// EmitStoreOfComplex - Store a complex number into the specified l-value.
4391  void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
4392 
4393  /// EmitLoadOfComplex - Load a complex number from the specified l-value.
4395 
4398 
4399  /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
4400  /// global variable that has already been created for it. If the initializer
4401  /// has a different type than GV does, this may free GV and return a different
4402  /// one. Otherwise it just returns GV.
4403  llvm::GlobalVariable *
4405  llvm::GlobalVariable *GV);
4406 
4407  // Emit an @llvm.invariant.start call for the given memory region.
4408  void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
4409 
4410  /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
4411  /// variable with global storage.
4412  void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV,
4413  bool PerformInit);
4414 
4415  llvm::Function *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
4416  llvm::Constant *Addr);
4417 
4418  llvm::Function *createTLSAtExitStub(const VarDecl &VD,
4419  llvm::FunctionCallee Dtor,
4420  llvm::Constant *Addr,
4421  llvm::FunctionCallee &AtExit);
4422 
4423  /// Call atexit() with a function that passes the given argument to
4424  /// the given function.
4425  void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
4426  llvm::Constant *addr);
4427 
4428  /// Call atexit() with function dtorStub.
4429  void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
4430 
4431  /// Call unatexit() with function dtorStub.
4432  llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub);
4433 
4434  /// Emit code in this function to perform a guarded variable
4435  /// initialization. Guarded initializations are used when it's not
4436  /// possible to prove that an initialization will be done exactly
4437  /// once, e.g. with a static local variable or a static data member
4438  /// of a class template.
4439  void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
4440  bool PerformInit);
4441 
4443 
4444  /// Emit a branch to select whether or not to perform guarded initialization.
4445  void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
4446  llvm::BasicBlock *InitBlock,
4447  llvm::BasicBlock *NoInitBlock,
4448  GuardKind Kind, const VarDecl *D);
4449 
4450  /// GenerateCXXGlobalInitFunc - Generates code for initializing global
4451  /// variables.
4452  void
4453  GenerateCXXGlobalInitFunc(llvm::Function *Fn,
4454  ArrayRef<llvm::Function *> CXXThreadLocals,
4456 
4457  /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
4458  /// variables.
4460  llvm::Function *Fn,
4461  ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
4462  llvm::Constant *>>
4463  DtorsOrStermFinalizers);
4464 
4465  void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
4466  const VarDecl *D,
4467  llvm::GlobalVariable *Addr,
4468  bool PerformInit);
4469 
4470  void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
4471 
4472  void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp);
4473 
4474  void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
4475 
4477 
4478  //===--------------------------------------------------------------------===//
4479  // Annotations Emission
4480  //===--------------------------------------------------------------------===//
4481 
4482  /// Emit an annotation call (intrinsic).