Coverage Report

Created: 2019-07-24 05:18

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