clang  6.0.0svn
MicrosoftCXXABI.cpp
Go to the documentation of this file.
1 //===--- MicrosoftCXXABI.cpp - Emit LLVM Code from ASTs for a Module ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides C++ code generation targeting the Microsoft Visual C++ ABI.
11 // The class in this file generates structures that follow the Microsoft
12 // Visual C++ ABI, which is actually not very well documented at all outside
13 // of Microsoft.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "CGCXXABI.h"
18 #include "CGCleanup.h"
19 #include "CGVTables.h"
20 #include "CodeGenModule.h"
21 #include "CodeGenTypes.h"
22 #include "TargetInfo.h"
24 #include "clang/AST/Decl.h"
25 #include "clang/AST/DeclCXX.h"
26 #include "clang/AST/StmtCXX.h"
28 #include "llvm/ADT/StringExtras.h"
29 #include "llvm/ADT/StringSet.h"
30 #include "llvm/IR/CallSite.h"
31 #include "llvm/IR/Intrinsics.h"
32 
33 using namespace clang;
34 using namespace CodeGen;
35 
36 namespace {
37 
38 /// Holds all the vbtable globals for a given class.
39 struct VBTableGlobals {
40  const VPtrInfoVector *VBTables;
42 };
43 
44 class MicrosoftCXXABI : public CGCXXABI {
45 public:
46  MicrosoftCXXABI(CodeGenModule &CGM)
47  : CGCXXABI(CGM), BaseClassDescriptorType(nullptr),
48  ClassHierarchyDescriptorType(nullptr),
49  CompleteObjectLocatorType(nullptr), CatchableTypeType(nullptr),
50  ThrowInfoType(nullptr) {}
51 
52  bool HasThisReturn(GlobalDecl GD) const override;
53  bool hasMostDerivedReturn(GlobalDecl GD) const override;
54 
55  bool classifyReturnType(CGFunctionInfo &FI) const override;
56 
57  RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override;
58 
59  bool isSRetParameterAfterThis() const override { return true; }
60 
61  bool isThisCompleteObject(GlobalDecl GD) const override {
62  // The Microsoft ABI doesn't use separate complete-object vs.
63  // base-object variants of constructors, but it does of destructors.
64  if (isa<CXXDestructorDecl>(GD.getDecl())) {
65  switch (GD.getDtorType()) {
66  case Dtor_Complete:
67  case Dtor_Deleting:
68  return true;
69 
70  case Dtor_Base:
71  return false;
72 
73  case Dtor_Comdat: llvm_unreachable("emitting dtor comdat as function?");
74  }
75  llvm_unreachable("bad dtor kind");
76  }
77 
78  // No other kinds.
79  return false;
80  }
81 
82  size_t getSrcArgforCopyCtor(const CXXConstructorDecl *CD,
83  FunctionArgList &Args) const override {
84  assert(Args.size() >= 2 &&
85  "expected the arglist to have at least two args!");
86  // The 'most_derived' parameter goes second if the ctor is variadic and
87  // has v-bases.
88  if (CD->getParent()->getNumVBases() > 0 &&
89  CD->getType()->castAs<FunctionProtoType>()->isVariadic())
90  return 2;
91  return 1;
92  }
93 
94  std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD) override {
95  std::vector<CharUnits> VBPtrOffsets;
96  const ASTContext &Context = getContext();
97  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
98 
99  const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
100  for (const std::unique_ptr<VPtrInfo> &VBT : *VBGlobals.VBTables) {
101  const ASTRecordLayout &SubobjectLayout =
102  Context.getASTRecordLayout(VBT->IntroducingObject);
103  CharUnits Offs = VBT->NonVirtualOffset;
104  Offs += SubobjectLayout.getVBPtrOffset();
105  if (VBT->getVBaseWithVPtr())
106  Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr());
107  VBPtrOffsets.push_back(Offs);
108  }
109  llvm::array_pod_sort(VBPtrOffsets.begin(), VBPtrOffsets.end());
110  return VBPtrOffsets;
111  }
112 
113  StringRef GetPureVirtualCallName() override { return "_purecall"; }
114  StringRef GetDeletedVirtualCallName() override { return "_purecall"; }
115 
116  void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
117  Address Ptr, QualType ElementType,
118  const CXXDestructorDecl *Dtor) override;
119 
120  void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
121  void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
122 
123  void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
124 
125  llvm::GlobalVariable *getMSCompleteObjectLocator(const CXXRecordDecl *RD,
126  const VPtrInfo &Info);
127 
128  llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
130  getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType) override;
131 
132  /// MSVC needs an extra flag to indicate a catchall.
133  CatchTypeInfo getCatchAllTypeInfo() override {
134  return CatchTypeInfo{nullptr, 0x40};
135  }
136 
137  bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
138  void EmitBadTypeidCall(CodeGenFunction &CGF) override;
139  llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
140  Address ThisPtr,
141  llvm::Type *StdTypeInfoPtrTy) override;
142 
143  bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
144  QualType SrcRecordTy) override;
145 
146  llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
147  QualType SrcRecordTy, QualType DestTy,
148  QualType DestRecordTy,
149  llvm::BasicBlock *CastEnd) override;
150 
151  llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
152  QualType SrcRecordTy,
153  QualType DestTy) override;
154 
155  bool EmitBadCastCall(CodeGenFunction &CGF) override;
156  bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override {
157  return false;
158  }
159 
160  llvm::Value *
161  GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
162  const CXXRecordDecl *ClassDecl,
163  const CXXRecordDecl *BaseClassDecl) override;
164 
165  llvm::BasicBlock *
166  EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
167  const CXXRecordDecl *RD) override;
168 
169  llvm::BasicBlock *
170  EmitDtorCompleteObjectHandler(CodeGenFunction &CGF);
171 
172  void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF,
173  const CXXRecordDecl *RD) override;
174 
175  void EmitCXXConstructors(const CXXConstructorDecl *D) override;
176 
177  // Background on MSVC destructors
178  // ==============================
179  //
180  // Both Itanium and MSVC ABIs have destructor variants. The variant names
181  // roughly correspond in the following way:
182  // Itanium Microsoft
183  // Base -> no name, just ~Class
184  // Complete -> vbase destructor
185  // Deleting -> scalar deleting destructor
186  // vector deleting destructor
187  //
188  // The base and complete destructors are the same as in Itanium, although the
189  // complete destructor does not accept a VTT parameter when there are virtual
190  // bases. A separate mechanism involving vtordisps is used to ensure that
191  // virtual methods of destroyed subobjects are not called.
192  //
193  // The deleting destructors accept an i32 bitfield as a second parameter. Bit
194  // 1 indicates if the memory should be deleted. Bit 2 indicates if the this
195  // pointer points to an array. The scalar deleting destructor assumes that
196  // bit 2 is zero, and therefore does not contain a loop.
197  //
198  // For virtual destructors, only one entry is reserved in the vftable, and it
199  // always points to the vector deleting destructor. The vector deleting
200  // destructor is the most general, so it can be used to destroy objects in
201  // place, delete single heap objects, or delete arrays.
202  //
203  // A TU defining a non-inline destructor is only guaranteed to emit a base
204  // destructor, and all of the other variants are emitted on an as-needed basis
205  // in COMDATs. Because a non-base destructor can be emitted in a TU that
206  // lacks a definition for the destructor, non-base destructors must always
207  // delegate to or alias the base destructor.
208 
209  AddedStructorArgs
210  buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
211  SmallVectorImpl<CanQualType> &ArgTys) override;
212 
213  /// Non-base dtors should be emitted as delegating thunks in this ABI.
214  bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
215  CXXDtorType DT) const override {
216  return DT != Dtor_Base;
217  }
218 
219  void EmitCXXDestructors(const CXXDestructorDecl *D) override;
220 
221  const CXXRecordDecl *
222  getThisArgumentTypeForMethod(const CXXMethodDecl *MD) override {
223  MD = MD->getCanonicalDecl();
224  if (MD->isVirtual() && !isa<CXXDestructorDecl>(MD)) {
226  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(MD);
227  // The vbases might be ordered differently in the final overrider object
228  // and the complete object, so the "this" argument may sometimes point to
229  // memory that has no particular type (e.g. past the complete object).
230  // In this case, we just use a generic pointer type.
231  // FIXME: might want to have a more precise type in the non-virtual
232  // multiple inheritance case.
233  if (ML.VBase || !ML.VFPtrOffset.isZero())
234  return nullptr;
235  }
236  return MD->getParent();
237  }
238 
239  Address
240  adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,
241  Address This,
242  bool VirtualCall) override;
243 
244  void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
245  FunctionArgList &Params) override;
246 
247  llvm::Value *adjustThisParameterInVirtualFunctionPrologue(
248  CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) override;
249 
250  void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
251 
252  AddedStructorArgs
253  addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
254  CXXCtorType Type, bool ForVirtualBase,
255  bool Delegating, CallArgList &Args) override;
256 
257  void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
258  CXXDtorType Type, bool ForVirtualBase,
259  bool Delegating, Address This) override;
260 
261  void emitVTableTypeMetadata(const VPtrInfo &Info, const CXXRecordDecl *RD,
262  llvm::GlobalVariable *VTable);
263 
264  void emitVTableDefinitions(CodeGenVTables &CGVT,
265  const CXXRecordDecl *RD) override;
266 
267  bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
268  CodeGenFunction::VPtr Vptr) override;
269 
270  /// Don't initialize vptrs if dynamic class
271  /// is marked with with the 'novtable' attribute.
272  bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
273  return !VTableClass->hasAttr<MSNoVTableAttr>();
274  }
275 
276  llvm::Constant *
277  getVTableAddressPoint(BaseSubobject Base,
278  const CXXRecordDecl *VTableClass) override;
279 
280  llvm::Value *getVTableAddressPointInStructor(
281  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
282  BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;
283 
284  llvm::Constant *
285  getVTableAddressPointForConstExpr(BaseSubobject Base,
286  const CXXRecordDecl *VTableClass) override;
287 
288  llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
289  CharUnits VPtrOffset) override;
290 
291  CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
292  Address This, llvm::Type *Ty,
293  SourceLocation Loc) override;
294 
295  llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
296  const CXXDestructorDecl *Dtor,
297  CXXDtorType DtorType,
298  Address This,
299  const CXXMemberCallExpr *CE) override;
300 
301  void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD,
302  CallArgList &CallArgs) override {
303  assert(GD.getDtorType() == Dtor_Deleting &&
304  "Only deleting destructor thunks are available in this ABI");
305  CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)),
306  getContext().IntTy);
307  }
308 
309  void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
310 
311  llvm::GlobalVariable *
312  getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD,
313  llvm::GlobalVariable::LinkageTypes Linkage);
314 
315  llvm::GlobalVariable *
316  getAddrOfVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
317  const CXXRecordDecl *DstRD) {
318  SmallString<256> OutName;
319  llvm::raw_svector_ostream Out(OutName);
320  getMangleContext().mangleCXXVirtualDisplacementMap(SrcRD, DstRD, Out);
321  StringRef MangledName = OutName.str();
322 
323  if (auto *VDispMap = CGM.getModule().getNamedGlobal(MangledName))
324  return VDispMap;
325 
326  MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
327  unsigned NumEntries = 1 + SrcRD->getNumVBases();
328  SmallVector<llvm::Constant *, 4> Map(NumEntries,
329  llvm::UndefValue::get(CGM.IntTy));
330  Map[0] = llvm::ConstantInt::get(CGM.IntTy, 0);
331  bool AnyDifferent = false;
332  for (const auto &I : SrcRD->vbases()) {
333  const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl();
334  if (!DstRD->isVirtuallyDerivedFrom(VBase))
335  continue;
336 
337  unsigned SrcVBIndex = VTContext.getVBTableIndex(SrcRD, VBase);
338  unsigned DstVBIndex = VTContext.getVBTableIndex(DstRD, VBase);
339  Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.IntTy, DstVBIndex * 4);
340  AnyDifferent |= SrcVBIndex != DstVBIndex;
341  }
342  // This map would be useless, don't use it.
343  if (!AnyDifferent)
344  return nullptr;
345 
346  llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.IntTy, Map.size());
347  llvm::Constant *Init = llvm::ConstantArray::get(VDispMapTy, Map);
348  llvm::GlobalValue::LinkageTypes Linkage =
349  SrcRD->isExternallyVisible() && DstRD->isExternallyVisible()
350  ? llvm::GlobalValue::LinkOnceODRLinkage
352  auto *VDispMap = new llvm::GlobalVariable(
353  CGM.getModule(), VDispMapTy, /*Constant=*/true, Linkage,
354  /*Initializer=*/Init, MangledName);
355  return VDispMap;
356  }
357 
358  void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD,
359  llvm::GlobalVariable *GV) const;
360 
361  void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,
362  GlobalDecl GD, bool ReturnAdjustment) override {
363  // Never dllimport/dllexport thunks.
364  Thunk->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
365 
366  GVALinkage Linkage =
367  getContext().GetGVALinkageForFunction(cast<FunctionDecl>(GD.getDecl()));
368 
369  if (Linkage == GVA_Internal)
370  Thunk->setLinkage(llvm::GlobalValue::InternalLinkage);
371  else if (ReturnAdjustment)
372  Thunk->setLinkage(llvm::GlobalValue::WeakODRLinkage);
373  else
374  Thunk->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
375  }
376 
377  llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
378  const ThisAdjustment &TA) override;
379 
380  llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
381  const ReturnAdjustment &RA) override;
382 
383  void EmitThreadLocalInitFuncs(
384  CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
385  ArrayRef<llvm::Function *> CXXThreadLocalInits,
386  ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
387 
388  bool usesThreadWrapperFunction() const override { return false; }
389  LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
390  QualType LValType) override;
391 
392  void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
393  llvm::GlobalVariable *DeclPtr,
394  bool PerformInit) override;
395  void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
396  llvm::Constant *Dtor, llvm::Constant *Addr) override;
397 
398  // ==== Notes on array cookies =========
399  //
400  // MSVC seems to only use cookies when the class has a destructor; a
401  // two-argument usual array deallocation function isn't sufficient.
402  //
403  // For example, this code prints "100" and "1":
404  // struct A {
405  // char x;
406  // void *operator new[](size_t sz) {
407  // printf("%u\n", sz);
408  // return malloc(sz);
409  // }
410  // void operator delete[](void *p, size_t sz) {
411  // printf("%u\n", sz);
412  // free(p);
413  // }
414  // };
415  // int main() {
416  // A *p = new A[100];
417  // delete[] p;
418  // }
419  // Whereas it prints "104" and "104" if you give A a destructor.
420 
421  bool requiresArrayCookie(const CXXDeleteExpr *expr,
422  QualType elementType) override;
423  bool requiresArrayCookie(const CXXNewExpr *expr) override;
424  CharUnits getArrayCookieSizeImpl(QualType type) override;
425  Address InitializeArrayCookie(CodeGenFunction &CGF,
426  Address NewPtr,
427  llvm::Value *NumElements,
428  const CXXNewExpr *expr,
429  QualType ElementType) override;
430  llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
431  Address allocPtr,
432  CharUnits cookieSize) override;
433 
434  friend struct MSRTTIBuilder;
435 
436  bool isImageRelative() const {
437  return CGM.getTarget().getPointerWidth(/*AddressSpace=*/0) == 64;
438  }
439 
440  // 5 routines for constructing the llvm types for MS RTTI structs.
441  llvm::StructType *getTypeDescriptorType(StringRef TypeInfoString) {
442  llvm::SmallString<32> TDTypeName("rtti.TypeDescriptor");
443  TDTypeName += llvm::utostr(TypeInfoString.size());
444  llvm::StructType *&TypeDescriptorType =
445  TypeDescriptorTypeMap[TypeInfoString.size()];
446  if (TypeDescriptorType)
447  return TypeDescriptorType;
448  llvm::Type *FieldTypes[] = {
449  CGM.Int8PtrPtrTy,
450  CGM.Int8PtrTy,
451  llvm::ArrayType::get(CGM.Int8Ty, TypeInfoString.size() + 1)};
452  TypeDescriptorType =
453  llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, TDTypeName);
454  return TypeDescriptorType;
455  }
456 
457  llvm::Type *getImageRelativeType(llvm::Type *PtrType) {
458  if (!isImageRelative())
459  return PtrType;
460  return CGM.IntTy;
461  }
462 
463  llvm::StructType *getBaseClassDescriptorType() {
464  if (BaseClassDescriptorType)
465  return BaseClassDescriptorType;
466  llvm::Type *FieldTypes[] = {
467  getImageRelativeType(CGM.Int8PtrTy),
468  CGM.IntTy,
469  CGM.IntTy,
470  CGM.IntTy,
471  CGM.IntTy,
472  CGM.IntTy,
473  getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
474  };
475  BaseClassDescriptorType = llvm::StructType::create(
476  CGM.getLLVMContext(), FieldTypes, "rtti.BaseClassDescriptor");
477  return BaseClassDescriptorType;
478  }
479 
480  llvm::StructType *getClassHierarchyDescriptorType() {
481  if (ClassHierarchyDescriptorType)
482  return ClassHierarchyDescriptorType;
483  // Forward-declare RTTIClassHierarchyDescriptor to break a cycle.
484  ClassHierarchyDescriptorType = llvm::StructType::create(
485  CGM.getLLVMContext(), "rtti.ClassHierarchyDescriptor");
486  llvm::Type *FieldTypes[] = {
487  CGM.IntTy,
488  CGM.IntTy,
489  CGM.IntTy,
490  getImageRelativeType(
491  getBaseClassDescriptorType()->getPointerTo()->getPointerTo()),
492  };
493  ClassHierarchyDescriptorType->setBody(FieldTypes);
494  return ClassHierarchyDescriptorType;
495  }
496 
497  llvm::StructType *getCompleteObjectLocatorType() {
498  if (CompleteObjectLocatorType)
499  return CompleteObjectLocatorType;
500  CompleteObjectLocatorType = llvm::StructType::create(
501  CGM.getLLVMContext(), "rtti.CompleteObjectLocator");
502  llvm::Type *FieldTypes[] = {
503  CGM.IntTy,
504  CGM.IntTy,
505  CGM.IntTy,
506  getImageRelativeType(CGM.Int8PtrTy),
507  getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
508  getImageRelativeType(CompleteObjectLocatorType),
509  };
510  llvm::ArrayRef<llvm::Type *> FieldTypesRef(FieldTypes);
511  if (!isImageRelative())
512  FieldTypesRef = FieldTypesRef.drop_back();
513  CompleteObjectLocatorType->setBody(FieldTypesRef);
514  return CompleteObjectLocatorType;
515  }
516 
517  llvm::GlobalVariable *getImageBase() {
518  StringRef Name = "__ImageBase";
519  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name))
520  return GV;
521 
522  return new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty,
523  /*isConstant=*/true,
525  /*Initializer=*/nullptr, Name);
526  }
527 
528  llvm::Constant *getImageRelativeConstant(llvm::Constant *PtrVal) {
529  if (!isImageRelative())
530  return PtrVal;
531 
532  if (PtrVal->isNullValue())
533  return llvm::Constant::getNullValue(CGM.IntTy);
534 
535  llvm::Constant *ImageBaseAsInt =
536  llvm::ConstantExpr::getPtrToInt(getImageBase(), CGM.IntPtrTy);
537  llvm::Constant *PtrValAsInt =
538  llvm::ConstantExpr::getPtrToInt(PtrVal, CGM.IntPtrTy);
539  llvm::Constant *Diff =
540  llvm::ConstantExpr::getSub(PtrValAsInt, ImageBaseAsInt,
541  /*HasNUW=*/true, /*HasNSW=*/true);
542  return llvm::ConstantExpr::getTrunc(Diff, CGM.IntTy);
543  }
544 
545 private:
546  MicrosoftMangleContext &getMangleContext() {
547  return cast<MicrosoftMangleContext>(CodeGen::CGCXXABI::getMangleContext());
548  }
549 
550  llvm::Constant *getZeroInt() {
551  return llvm::ConstantInt::get(CGM.IntTy, 0);
552  }
553 
554  llvm::Constant *getAllOnesInt() {
555  return llvm::Constant::getAllOnesValue(CGM.IntTy);
556  }
557 
558  CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) override;
559 
560  void
561  GetNullMemberPointerFields(const MemberPointerType *MPT,
563 
564  /// \brief Shared code for virtual base adjustment. Returns the offset from
565  /// the vbptr to the virtual base. Optionally returns the address of the
566  /// vbptr itself.
567  llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
568  Address Base,
569  llvm::Value *VBPtrOffset,
570  llvm::Value *VBTableOffset,
571  llvm::Value **VBPtr = nullptr);
572 
573  llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
574  Address Base,
575  int32_t VBPtrOffset,
576  int32_t VBTableOffset,
577  llvm::Value **VBPtr = nullptr) {
578  assert(VBTableOffset % 4 == 0 && "should be byte offset into table of i32s");
579  llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),
580  *VBTOffset = llvm::ConstantInt::get(CGM.IntTy, VBTableOffset);
581  return GetVBaseOffsetFromVBPtr(CGF, Base, VBPOffset, VBTOffset, VBPtr);
582  }
583 
584  std::pair<Address, llvm::Value *>
585  performBaseAdjustment(CodeGenFunction &CGF, Address Value,
586  QualType SrcRecordTy);
587 
588  /// \brief Performs a full virtual base adjustment. Used to dereference
589  /// pointers to members of virtual bases.
590  llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E,
591  const CXXRecordDecl *RD, Address Base,
592  llvm::Value *VirtualBaseAdjustmentOffset,
593  llvm::Value *VBPtrOffset /* optional */);
594 
595  /// \brief Emits a full member pointer with the fields common to data and
596  /// function member pointers.
597  llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField,
598  bool IsMemberFunction,
599  const CXXRecordDecl *RD,
600  CharUnits NonVirtualBaseAdjustment,
601  unsigned VBTableIndex);
602 
603  bool MemberPointerConstantIsNull(const MemberPointerType *MPT,
604  llvm::Constant *MP);
605 
606  /// \brief - Initialize all vbptrs of 'this' with RD as the complete type.
607  void EmitVBPtrStores(CodeGenFunction &CGF, const CXXRecordDecl *RD);
608 
609  /// \brief Caching wrapper around VBTableBuilder::enumerateVBTables().
610  const VBTableGlobals &enumerateVBTables(const CXXRecordDecl *RD);
611 
612  /// \brief Generate a thunk for calling a virtual member function MD.
613  llvm::Function *EmitVirtualMemPtrThunk(
614  const CXXMethodDecl *MD,
616 
617 public:
618  llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
619 
620  bool isZeroInitializable(const MemberPointerType *MPT) override;
621 
622  bool isMemberPointerConvertible(const MemberPointerType *MPT) const override {
623  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
624  return RD->hasAttr<MSInheritanceAttr>();
625  }
626 
627  llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
628 
629  llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
630  CharUnits offset) override;
631  llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;
632  llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
633 
634  llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
635  llvm::Value *L,
636  llvm::Value *R,
637  const MemberPointerType *MPT,
638  bool Inequality) override;
639 
640  llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
641  llvm::Value *MemPtr,
642  const MemberPointerType *MPT) override;
643 
644  llvm::Value *
645  EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
646  Address Base, llvm::Value *MemPtr,
647  const MemberPointerType *MPT) override;
648 
649  llvm::Value *EmitNonNullMemberPointerConversion(
650  const MemberPointerType *SrcTy, const MemberPointerType *DstTy,
653  CGBuilderTy &Builder);
654 
655  llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
656  const CastExpr *E,
657  llvm::Value *Src) override;
658 
659  llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
660  llvm::Constant *Src) override;
661 
662  llvm::Constant *EmitMemberPointerConversion(
663  const MemberPointerType *SrcTy, const MemberPointerType *DstTy,
665  CastExpr::path_const_iterator PathEnd, llvm::Constant *Src);
666 
667  CGCallee
668  EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E,
669  Address This, llvm::Value *&ThisPtrForCall,
670  llvm::Value *MemPtr,
671  const MemberPointerType *MPT) override;
672 
673  void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override;
674 
675  llvm::StructType *getCatchableTypeType() {
676  if (CatchableTypeType)
677  return CatchableTypeType;
678  llvm::Type *FieldTypes[] = {
679  CGM.IntTy, // Flags
680  getImageRelativeType(CGM.Int8PtrTy), // TypeDescriptor
681  CGM.IntTy, // NonVirtualAdjustment
682  CGM.IntTy, // OffsetToVBPtr
683  CGM.IntTy, // VBTableIndex
684  CGM.IntTy, // Size
685  getImageRelativeType(CGM.Int8PtrTy) // CopyCtor
686  };
687  CatchableTypeType = llvm::StructType::create(
688  CGM.getLLVMContext(), FieldTypes, "eh.CatchableType");
689  return CatchableTypeType;
690  }
691 
692  llvm::StructType *getCatchableTypeArrayType(uint32_t NumEntries) {
693  llvm::StructType *&CatchableTypeArrayType =
694  CatchableTypeArrayTypeMap[NumEntries];
695  if (CatchableTypeArrayType)
696  return CatchableTypeArrayType;
697 
698  llvm::SmallString<23> CTATypeName("eh.CatchableTypeArray.");
699  CTATypeName += llvm::utostr(NumEntries);
700  llvm::Type *CTType =
701  getImageRelativeType(getCatchableTypeType()->getPointerTo());
702  llvm::Type *FieldTypes[] = {
703  CGM.IntTy, // NumEntries
704  llvm::ArrayType::get(CTType, NumEntries) // CatchableTypes
705  };
706  CatchableTypeArrayType =
707  llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, CTATypeName);
708  return CatchableTypeArrayType;
709  }
710 
711  llvm::StructType *getThrowInfoType() {
712  if (ThrowInfoType)
713  return ThrowInfoType;
714  llvm::Type *FieldTypes[] = {
715  CGM.IntTy, // Flags
716  getImageRelativeType(CGM.Int8PtrTy), // CleanupFn
717  getImageRelativeType(CGM.Int8PtrTy), // ForwardCompat
718  getImageRelativeType(CGM.Int8PtrTy) // CatchableTypeArray
719  };
720  ThrowInfoType = llvm::StructType::create(CGM.getLLVMContext(), FieldTypes,
721  "eh.ThrowInfo");
722  return ThrowInfoType;
723  }
724 
725  llvm::Constant *getThrowFn() {
726  // _CxxThrowException is passed an exception object and a ThrowInfo object
727  // which describes the exception.
728  llvm::Type *Args[] = {CGM.Int8PtrTy, getThrowInfoType()->getPointerTo()};
729  llvm::FunctionType *FTy =
730  llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false);
731  auto *Fn = cast<llvm::Function>(
732  CGM.CreateRuntimeFunction(FTy, "_CxxThrowException"));
733  // _CxxThrowException is stdcall on 32-bit x86 platforms.
734  if (CGM.getTarget().getTriple().getArch() == llvm::Triple::x86)
735  Fn->setCallingConv(llvm::CallingConv::X86_StdCall);
736  return Fn;
737  }
738 
739  llvm::Function *getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,
740  CXXCtorType CT);
741 
742  llvm::Constant *getCatchableType(QualType T,
743  uint32_t NVOffset = 0,
744  int32_t VBPtrOffset = -1,
745  uint32_t VBIndex = 0);
746 
747  llvm::GlobalVariable *getCatchableTypeArray(QualType T);
748 
749  llvm::GlobalVariable *getThrowInfo(QualType T) override;
750 
751 private:
752  typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy;
753  typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy;
754  typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy;
755  /// \brief All the vftables that have been referenced.
756  VFTablesMapTy VFTablesMap;
757  VTablesMapTy VTablesMap;
758 
759  /// \brief This set holds the record decls we've deferred vtable emission for.
760  llvm::SmallPtrSet<const CXXRecordDecl *, 4> DeferredVFTables;
761 
762 
763  /// \brief All the vbtables which have been referenced.
764  llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap;
765 
766  /// Info on the global variable used to guard initialization of static locals.
767  /// The BitIndex field is only used for externally invisible declarations.
768  struct GuardInfo {
769  GuardInfo() : Guard(nullptr), BitIndex(0) {}
770  llvm::GlobalVariable *Guard;
771  unsigned BitIndex;
772  };
773 
774  /// Map from DeclContext to the current guard variable. We assume that the
775  /// AST is visited in source code order.
776  llvm::DenseMap<const DeclContext *, GuardInfo> GuardVariableMap;
777  llvm::DenseMap<const DeclContext *, GuardInfo> ThreadLocalGuardVariableMap;
778  llvm::DenseMap<const DeclContext *, unsigned> ThreadSafeGuardNumMap;
779 
780  llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap;
781  llvm::StructType *BaseClassDescriptorType;
782  llvm::StructType *ClassHierarchyDescriptorType;
783  llvm::StructType *CompleteObjectLocatorType;
784 
785  llvm::DenseMap<QualType, llvm::GlobalVariable *> CatchableTypeArrays;
786 
787  llvm::StructType *CatchableTypeType;
788  llvm::DenseMap<uint32_t, llvm::StructType *> CatchableTypeArrayTypeMap;
789  llvm::StructType *ThrowInfoType;
790 };
791 
792 }
793 
796  switch (CGM.getTarget().getTriple().getArch()) {
797  default:
798  // FIXME: Implement for other architectures.
799  return RAA_Default;
800 
801  case llvm::Triple::thumb:
802  // Use the simple Itanium rules for now.
803  // FIXME: This is incompatible with MSVC for arguments with a dtor and no
804  // copy ctor.
805  return !canCopyArgument(RD) ? RAA_Indirect : RAA_Default;
806 
807  case llvm::Triple::x86:
808  // All record arguments are passed in memory on x86. Decide whether to
809  // construct the object directly in argument memory, or to construct the
810  // argument elsewhere and copy the bytes during the call.
811 
812  // If C++ prohibits us from making a copy, construct the arguments directly
813  // into argument memory.
814  if (!canCopyArgument(RD))
815  return RAA_DirectInMemory;
816 
817  // Otherwise, construct the argument into a temporary and copy the bytes
818  // into the outgoing argument memory.
819  return RAA_Default;
820 
821  case llvm::Triple::x86_64:
822  // If a class has a destructor, we'd really like to pass it indirectly
823  // because it allows us to elide copies. Unfortunately, MSVC makes that
824  // impossible for small types, which it will pass in a single register or
825  // stack slot. Most objects with dtors are large-ish, so handle that early.
826  // We can't call out all large objects as being indirect because there are
827  // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
828  // how we pass large POD types.
829  //
830  // Note: This permits small classes with nontrivial destructors to be
831  // passed in registers, which is non-conforming.
832  if (RD->hasNonTrivialDestructor() &&
833  getContext().getTypeSize(RD->getTypeForDecl()) > 64)
834  return RAA_Indirect;
835 
836  // If a class has at least one non-deleted, trivial copy constructor, it
837  // is passed according to the C ABI. Otherwise, it is passed indirectly.
838  //
839  // Note: This permits classes with non-trivial copy or move ctors to be
840  // passed in registers, so long as they *also* have a trivial copy ctor,
841  // which is non-conforming.
842  if (RD->needsImplicitCopyConstructor()) {
843  // If the copy ctor has not yet been declared, we can read its triviality
844  // off the AST.
847  return RAA_Default;
848  } else {
849  // Otherwise, we need to find the copy constructor(s) and ask.
850  for (const CXXConstructorDecl *CD : RD->ctors()) {
851  if (CD->isCopyConstructor()) {
852  // We had at least one nondeleted trivial copy ctor. Return directly.
853  if (!CD->isDeleted() && CD->isTrivial())
854  return RAA_Default;
855  }
856  }
857  }
858 
859  // We have no trivial, non-deleted copy constructor.
860  return RAA_Indirect;
861  }
862 
863  llvm_unreachable("invalid enum");
864 }
865 
866 void MicrosoftCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
867  const CXXDeleteExpr *DE,
868  Address Ptr,
869  QualType ElementType,
870  const CXXDestructorDecl *Dtor) {
871  // FIXME: Provide a source location here even though there's no
872  // CXXMemberCallExpr for dtor call.
873  bool UseGlobalDelete = DE->isGlobalDelete();
874  CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
875  llvm::Value *MDThis =
876  EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, /*CE=*/nullptr);
877  if (UseGlobalDelete)
878  CGF.EmitDeleteCall(DE->getOperatorDelete(), MDThis, ElementType);
879 }
880 
881 void MicrosoftCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
882  llvm::Value *Args[] = {
883  llvm::ConstantPointerNull::get(CGM.Int8PtrTy),
884  llvm::ConstantPointerNull::get(getThrowInfoType()->getPointerTo())};
885  auto *Fn = getThrowFn();
886  if (isNoReturn)
887  CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, Args);
888  else
889  CGF.EmitRuntimeCallOrInvoke(Fn, Args);
890 }
891 
892 namespace {
893 struct CatchRetScope final : EHScopeStack::Cleanup {
894  llvm::CatchPadInst *CPI;
895 
896  CatchRetScope(llvm::CatchPadInst *CPI) : CPI(CPI) {}
897 
898  void Emit(CodeGenFunction &CGF, Flags flags) override {
899  llvm::BasicBlock *BB = CGF.createBasicBlock("catchret.dest");
900  CGF.Builder.CreateCatchRet(CPI, BB);
901  CGF.EmitBlock(BB);
902  }
903 };
904 }
905 
906 void MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF,
907  const CXXCatchStmt *S) {
908  // In the MS ABI, the runtime handles the copy, and the catch handler is
909  // responsible for destruction.
910  VarDecl *CatchParam = S->getExceptionDecl();
911  llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock();
912  llvm::CatchPadInst *CPI =
913  cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
914  CGF.CurrentFuncletPad = CPI;
915 
916  // If this is a catch-all or the catch parameter is unnamed, we don't need to
917  // emit an alloca to the object.
918  if (!CatchParam || !CatchParam->getDeclName()) {
919  CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);
920  return;
921  }
922 
924  CPI->setArgOperand(2, var.getObjectAddress(CGF).getPointer());
925  CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);
926  CGF.EmitAutoVarCleanups(var);
927 }
928 
929 /// We need to perform a generic polymorphic operation (like a typeid
930 /// or a cast), which requires an object with a vfptr. Adjust the
931 /// address to point to an object with a vfptr.
932 std::pair<Address, llvm::Value *>
933 MicrosoftCXXABI::performBaseAdjustment(CodeGenFunction &CGF, Address Value,
934  QualType SrcRecordTy) {
935  Value = CGF.Builder.CreateBitCast(Value, CGF.Int8PtrTy);
936  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
937  const ASTContext &Context = getContext();
938 
939  // If the class itself has a vfptr, great. This check implicitly
940  // covers non-virtual base subobjects: a class with its own virtual
941  // functions would be a candidate to be a primary base.
942  if (Context.getASTRecordLayout(SrcDecl).hasExtendableVFPtr())
943  return std::make_pair(Value, llvm::ConstantInt::get(CGF.Int32Ty, 0));
944 
945  // Okay, one of the vbases must have a vfptr, or else this isn't
946  // actually a polymorphic class.
947  const CXXRecordDecl *PolymorphicBase = nullptr;
948  for (auto &Base : SrcDecl->vbases()) {
949  const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
950  if (Context.getASTRecordLayout(BaseDecl).hasExtendableVFPtr()) {
951  PolymorphicBase = BaseDecl;
952  break;
953  }
954  }
955  assert(PolymorphicBase && "polymorphic class has no apparent vfptr?");
956 
958  GetVirtualBaseClassOffset(CGF, Value, SrcDecl, PolymorphicBase);
959  llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(Value.getPointer(), Offset);
960  CharUnits VBaseAlign =
961  CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase);
962  return std::make_pair(Address(Ptr, VBaseAlign), Offset);
963 }
964 
965 bool MicrosoftCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
966  QualType SrcRecordTy) {
967  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
968  return IsDeref &&
969  !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
970 }
971 
972 static llvm::CallSite emitRTtypeidCall(CodeGenFunction &CGF,
973  llvm::Value *Argument) {
974  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
975  llvm::FunctionType *FTy =
976  llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false);
977  llvm::Value *Args[] = {Argument};
978  llvm::Constant *Fn = CGF.CGM.CreateRuntimeFunction(FTy, "__RTtypeid");
979  return CGF.EmitRuntimeCallOrInvoke(Fn, Args);
980 }
981 
982 void MicrosoftCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
983  llvm::CallSite Call =
984  emitRTtypeidCall(CGF, llvm::Constant::getNullValue(CGM.VoidPtrTy));
985  Call.setDoesNotReturn();
986  CGF.Builder.CreateUnreachable();
987 }
988 
989 llvm::Value *MicrosoftCXXABI::EmitTypeid(CodeGenFunction &CGF,
990  QualType SrcRecordTy,
991  Address ThisPtr,
992  llvm::Type *StdTypeInfoPtrTy) {
993  std::tie(ThisPtr, std::ignore) =
994  performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);
995  auto Typeid = emitRTtypeidCall(CGF, ThisPtr.getPointer()).getInstruction();
996  return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
997 }
998 
999 bool MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1000  QualType SrcRecordTy) {
1001  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1002  return SrcIsPtr &&
1003  !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
1004 }
1005 
1006 llvm::Value *MicrosoftCXXABI::EmitDynamicCastCall(
1007  CodeGenFunction &CGF, Address This, QualType SrcRecordTy,
1008  QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1009  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1010 
1011  llvm::Value *SrcRTTI =
1012  CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1013  llvm::Value *DestRTTI =
1014  CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1015 
1017  std::tie(This, Offset) = performBaseAdjustment(CGF, This, SrcRecordTy);
1018  llvm::Value *ThisPtr = This.getPointer();
1019  Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty);
1020 
1021  // PVOID __RTDynamicCast(
1022  // PVOID inptr,
1023  // LONG VfDelta,
1024  // PVOID SrcType,
1025  // PVOID TargetType,
1026  // BOOL isReference)
1027  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy, CGF.Int32Ty, CGF.Int8PtrTy,
1028  CGF.Int8PtrTy, CGF.Int32Ty};
1029  llvm::Constant *Function = CGF.CGM.CreateRuntimeFunction(
1030  llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
1031  "__RTDynamicCast");
1032  llvm::Value *Args[] = {
1033  ThisPtr, Offset, SrcRTTI, DestRTTI,
1034  llvm::ConstantInt::get(CGF.Int32Ty, DestTy->isReferenceType())};
1035  ThisPtr = CGF.EmitRuntimeCallOrInvoke(Function, Args).getInstruction();
1036  return CGF.Builder.CreateBitCast(ThisPtr, DestLTy);
1037 }
1038 
1039 llvm::Value *
1040 MicrosoftCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
1041  QualType SrcRecordTy,
1042  QualType DestTy) {
1043  std::tie(Value, std::ignore) = performBaseAdjustment(CGF, Value, SrcRecordTy);
1044 
1045  // PVOID __RTCastToVoid(
1046  // PVOID inptr)
1047  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
1048  llvm::Constant *Function = CGF.CGM.CreateRuntimeFunction(
1049  llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
1050  "__RTCastToVoid");
1051  llvm::Value *Args[] = {Value.getPointer()};
1052  return CGF.EmitRuntimeCall(Function, Args);
1053 }
1054 
1055 bool MicrosoftCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1056  return false;
1057 }
1058 
1059 llvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset(
1060  CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl,
1061  const CXXRecordDecl *BaseClassDecl) {
1062  const ASTContext &Context = getContext();
1063  int64_t VBPtrChars =
1064  Context.getASTRecordLayout(ClassDecl).getVBPtrOffset().getQuantity();
1065  llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars);
1066  CharUnits IntSize = Context.getTypeSizeInChars(Context.IntTy);
1067  CharUnits VBTableChars =
1068  IntSize *
1069  CGM.getMicrosoftVTableContext().getVBTableIndex(ClassDecl, BaseClassDecl);
1070  llvm::Value *VBTableOffset =
1071  llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity());
1072 
1073  llvm::Value *VBPtrToNewBase =
1074  GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset);
1075  VBPtrToNewBase =
1076  CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy);
1077  return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
1078 }
1079 
1080 bool MicrosoftCXXABI::HasThisReturn(GlobalDecl GD) const {
1081  return isa<CXXConstructorDecl>(GD.getDecl());
1082 }
1083 
1084 static bool isDeletingDtor(GlobalDecl GD) {
1085  return isa<CXXDestructorDecl>(GD.getDecl()) &&
1086  GD.getDtorType() == Dtor_Deleting;
1087 }
1088 
1089 bool MicrosoftCXXABI::hasMostDerivedReturn(GlobalDecl GD) const {
1090  return isDeletingDtor(GD);
1091 }
1092 
1094  const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
1095  if (!RD)
1096  return false;
1097 
1098  CharUnits Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
1099  if (FI.isInstanceMethod()) {
1100  // If it's an instance method, aggregates are always returned indirectly via
1101  // the second parameter.
1102  FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
1104  return true;
1105  } else if (!RD->isPOD()) {
1106  // If it's a free function, non-POD types are returned indirectly.
1107  FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
1108  return true;
1109  }
1110 
1111  // Otherwise, use the C ABI rules.
1112  return false;
1113 }
1114 
1115 llvm::BasicBlock *
1116 MicrosoftCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
1117  const CXXRecordDecl *RD) {
1118  llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1119  assert(IsMostDerivedClass &&
1120  "ctor for a class with virtual bases must have an implicit parameter");
1121  llvm::Value *IsCompleteObject =
1122  CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1123 
1124  llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases");
1125  llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases");
1126  CGF.Builder.CreateCondBr(IsCompleteObject,
1127  CallVbaseCtorsBB, SkipVbaseCtorsBB);
1128 
1129  CGF.EmitBlock(CallVbaseCtorsBB);
1130 
1131  // Fill in the vbtable pointers here.
1132  EmitVBPtrStores(CGF, RD);
1133 
1134  // CGF will put the base ctor calls in this basic block for us later.
1135 
1136  return SkipVbaseCtorsBB;
1137 }
1138 
1139 llvm::BasicBlock *
1140 MicrosoftCXXABI::EmitDtorCompleteObjectHandler(CodeGenFunction &CGF) {
1141  llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1142  assert(IsMostDerivedClass &&
1143  "ctor for a class with virtual bases must have an implicit parameter");
1144  llvm::Value *IsCompleteObject =
1145  CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1146 
1147  llvm::BasicBlock *CallVbaseDtorsBB = CGF.createBasicBlock("Dtor.dtor_vbases");
1148  llvm::BasicBlock *SkipVbaseDtorsBB = CGF.createBasicBlock("Dtor.skip_vbases");
1149  CGF.Builder.CreateCondBr(IsCompleteObject,
1150  CallVbaseDtorsBB, SkipVbaseDtorsBB);
1151 
1152  CGF.EmitBlock(CallVbaseDtorsBB);
1153  // CGF will put the base dtor calls in this basic block for us later.
1154 
1155  return SkipVbaseDtorsBB;
1156 }
1157 
1158 void MicrosoftCXXABI::initializeHiddenVirtualInheritanceMembers(
1159  CodeGenFunction &CGF, const CXXRecordDecl *RD) {
1160  // In most cases, an override for a vbase virtual method can adjust
1161  // the "this" parameter by applying a constant offset.
1162  // However, this is not enough while a constructor or a destructor of some
1163  // class X is being executed if all the following conditions are met:
1164  // - X has virtual bases, (1)
1165  // - X overrides a virtual method M of a vbase Y, (2)
1166  // - X itself is a vbase of the most derived class.
1167  //
1168  // If (1) and (2) are true, the vtorDisp for vbase Y is a hidden member of X
1169  // which holds the extra amount of "this" adjustment we must do when we use
1170  // the X vftables (i.e. during X ctor or dtor).
1171  // Outside the ctors and dtors, the values of vtorDisps are zero.
1172 
1173  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
1174  typedef ASTRecordLayout::VBaseOffsetsMapTy VBOffsets;
1175  const VBOffsets &VBaseMap = Layout.getVBaseOffsetsMap();
1176  CGBuilderTy &Builder = CGF.Builder;
1177 
1178  unsigned AS = getThisAddress(CGF).getAddressSpace();
1179  llvm::Value *Int8This = nullptr; // Initialize lazily.
1180 
1181  for (VBOffsets::const_iterator I = VBaseMap.begin(), E = VBaseMap.end();
1182  I != E; ++I) {
1183  if (!I->second.hasVtorDisp())
1184  continue;
1185 
1186  llvm::Value *VBaseOffset =
1187  GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, I->first);
1188  uint64_t ConstantVBaseOffset =
1189  Layout.getVBaseClassOffset(I->first).getQuantity();
1190 
1191  // vtorDisp_for_vbase = vbptr[vbase_idx] - offsetof(RD, vbase).
1192  llvm::Value *VtorDispValue = Builder.CreateSub(
1193  VBaseOffset, llvm::ConstantInt::get(CGM.PtrDiffTy, ConstantVBaseOffset),
1194  "vtordisp.value");
1195  VtorDispValue = Builder.CreateTruncOrBitCast(VtorDispValue, CGF.Int32Ty);
1196 
1197  if (!Int8This)
1198  Int8This = Builder.CreateBitCast(getThisValue(CGF),
1199  CGF.Int8Ty->getPointerTo(AS));
1200  llvm::Value *VtorDispPtr = Builder.CreateInBoundsGEP(Int8This, VBaseOffset);
1201  // vtorDisp is always the 32-bits before the vbase in the class layout.
1202  VtorDispPtr = Builder.CreateConstGEP1_32(VtorDispPtr, -4);
1203  VtorDispPtr = Builder.CreateBitCast(
1204  VtorDispPtr, CGF.Int32Ty->getPointerTo(AS), "vtordisp.ptr");
1205 
1206  Builder.CreateAlignedStore(VtorDispValue, VtorDispPtr,
1208  }
1209 }
1210 
1211 static bool hasDefaultCXXMethodCC(ASTContext &Context,
1212  const CXXMethodDecl *MD) {
1213  CallingConv ExpectedCallingConv = Context.getDefaultCallingConvention(
1214  /*IsVariadic=*/false, /*IsCXXMethod=*/true);
1215  CallingConv ActualCallingConv =
1216  MD->getType()->getAs<FunctionProtoType>()->getCallConv();
1217  return ExpectedCallingConv == ActualCallingConv;
1218 }
1219 
1220 void MicrosoftCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1221  // There's only one constructor type in this ABI.
1222  CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1223 
1224  // Exported default constructors either have a simple call-site where they use
1225  // the typical calling convention and have a single 'this' pointer for an
1226  // argument -or- they get a wrapper function which appropriately thunks to the
1227  // real default constructor. This thunk is the default constructor closure.
1228  if (D->hasAttr<DLLExportAttr>() && D->isDefaultConstructor())
1229  if (!hasDefaultCXXMethodCC(getContext(), D) || D->getNumParams() != 0) {
1230  llvm::Function *Fn = getAddrOfCXXCtorClosure(D, Ctor_DefaultClosure);
1231  Fn->setLinkage(llvm::GlobalValue::WeakODRLinkage);
1232  Fn->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1233  }
1234 }
1235 
1236 void MicrosoftCXXABI::EmitVBPtrStores(CodeGenFunction &CGF,
1237  const CXXRecordDecl *RD) {
1238  Address This = getThisAddress(CGF);
1239  This = CGF.Builder.CreateElementBitCast(This, CGM.Int8Ty, "this.int8");
1240  const ASTContext &Context = getContext();
1241  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1242 
1243  const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
1244  for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
1245  const std::unique_ptr<VPtrInfo> &VBT = (*VBGlobals.VBTables)[I];
1246  llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1247  const ASTRecordLayout &SubobjectLayout =
1248  Context.getASTRecordLayout(VBT->IntroducingObject);
1249  CharUnits Offs = VBT->NonVirtualOffset;
1250  Offs += SubobjectLayout.getVBPtrOffset();
1251  if (VBT->getVBaseWithVPtr())
1252  Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr());
1253  Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs);
1254  llvm::Value *GVPtr =
1255  CGF.Builder.CreateConstInBoundsGEP2_32(GV->getValueType(), GV, 0, 0);
1256  VBPtr = CGF.Builder.CreateElementBitCast(VBPtr, GVPtr->getType(),
1257  "vbptr." + VBT->ObjectWithVPtr->getName());
1258  CGF.Builder.CreateStore(GVPtr, VBPtr);
1259  }
1260 }
1261 
1263 MicrosoftCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
1264  SmallVectorImpl<CanQualType> &ArgTys) {
1265  AddedStructorArgs Added;
1266  // TODO: 'for base' flag
1267  if (T == StructorType::Deleting) {
1268  // The scalar deleting destructor takes an implicit int parameter.
1269  ArgTys.push_back(getContext().IntTy);
1270  ++Added.Suffix;
1271  }
1272  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
1273  if (!CD)
1274  return Added;
1275 
1276  // All parameters are already in place except is_most_derived, which goes
1277  // after 'this' if it's variadic and last if it's not.
1278 
1279  const CXXRecordDecl *Class = CD->getParent();
1280  const FunctionProtoType *FPT = CD->getType()->castAs<FunctionProtoType>();
1281  if (Class->getNumVBases()) {
1282  if (FPT->isVariadic()) {
1283  ArgTys.insert(ArgTys.begin() + 1, getContext().IntTy);
1284  ++Added.Prefix;
1285  } else {
1286  ArgTys.push_back(getContext().IntTy);
1287  ++Added.Suffix;
1288  }
1289  }
1290 
1291  return Added;
1292 }
1293 
1294 void MicrosoftCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1295  // The TU defining a dtor is only guaranteed to emit a base destructor. All
1296  // other destructor variants are delegating thunks.
1297  CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1298 }
1299 
1300 CharUnits
1301 MicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
1302  GD = GD.getCanonicalDecl();
1303  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1304 
1305  GlobalDecl LookupGD = GD;
1306  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1307  // Complete destructors take a pointer to the complete object as a
1308  // parameter, thus don't need this adjustment.
1309  if (GD.getDtorType() == Dtor_Complete)
1310  return CharUnits();
1311 
1312  // There's no Dtor_Base in vftable but it shares the this adjustment with
1313  // the deleting one, so look it up instead.
1314  LookupGD = GlobalDecl(DD, Dtor_Deleting);
1315  }
1316 
1318  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD);
1319  CharUnits Adjustment = ML.VFPtrOffset;
1320 
1321  // Normal virtual instance methods need to adjust from the vfptr that first
1322  // defined the virtual method to the virtual base subobject, but destructors
1323  // do not. The vector deleting destructor thunk applies this adjustment for
1324  // us if necessary.
1325  if (isa<CXXDestructorDecl>(MD))
1326  Adjustment = CharUnits::Zero();
1327 
1328  if (ML.VBase) {
1329  const ASTRecordLayout &DerivedLayout =
1330  getContext().getASTRecordLayout(MD->getParent());
1331  Adjustment += DerivedLayout.getVBaseClassOffset(ML.VBase);
1332  }
1333 
1334  return Adjustment;
1335 }
1336 
1337 Address MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall(
1338  CodeGenFunction &CGF, GlobalDecl GD, Address This,
1339  bool VirtualCall) {
1340  if (!VirtualCall) {
1341  // If the call of a virtual function is not virtual, we just have to
1342  // compensate for the adjustment the virtual function does in its prologue.
1343  CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1344  if (Adjustment.isZero())
1345  return This;
1346 
1347  This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
1348  assert(Adjustment.isPositive());
1349  return CGF.Builder.CreateConstByteGEP(This, Adjustment);
1350  }
1351 
1352  GD = GD.getCanonicalDecl();
1353  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1354 
1355  GlobalDecl LookupGD = GD;
1356  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1357  // Complete dtors take a pointer to the complete object,
1358  // thus don't need adjustment.
1359  if (GD.getDtorType() == Dtor_Complete)
1360  return This;
1361 
1362  // There's only Dtor_Deleting in vftable but it shares the this adjustment
1363  // with the base one, so look up the deleting one instead.
1364  LookupGD = GlobalDecl(DD, Dtor_Deleting);
1365  }
1367  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD);
1368 
1369  CharUnits StaticOffset = ML.VFPtrOffset;
1370 
1371  // Base destructors expect 'this' to point to the beginning of the base
1372  // subobject, not the first vfptr that happens to contain the virtual dtor.
1373  // However, we still need to apply the virtual base adjustment.
1374  if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
1375  StaticOffset = CharUnits::Zero();
1376 
1377  Address Result = This;
1378  if (ML.VBase) {
1379  Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1380 
1381  const CXXRecordDecl *Derived = MD->getParent();
1382  const CXXRecordDecl *VBase = ML.VBase;
1383  llvm::Value *VBaseOffset =
1384  GetVirtualBaseClassOffset(CGF, Result, Derived, VBase);
1385  llvm::Value *VBasePtr =
1386  CGF.Builder.CreateInBoundsGEP(Result.getPointer(), VBaseOffset);
1387  CharUnits VBaseAlign =
1388  CGF.CGM.getVBaseAlignment(Result.getAlignment(), Derived, VBase);
1389  Result = Address(VBasePtr, VBaseAlign);
1390  }
1391  if (!StaticOffset.isZero()) {
1392  assert(StaticOffset.isPositive());
1393  Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1394  if (ML.VBase) {
1395  // Non-virtual adjustment might result in a pointer outside the allocated
1396  // object, e.g. if the final overrider class is laid out after the virtual
1397  // base that declares a method in the most derived class.
1398  // FIXME: Update the code that emits this adjustment in thunks prologues.
1399  Result = CGF.Builder.CreateConstByteGEP(Result, StaticOffset);
1400  } else {
1401  Result = CGF.Builder.CreateConstInBoundsByteGEP(Result, StaticOffset);
1402  }
1403  }
1404  return Result;
1405 }
1406 
1407 void MicrosoftCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1408  QualType &ResTy,
1409  FunctionArgList &Params) {
1410  ASTContext &Context = getContext();
1411  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1412  assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1413  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
1414  auto *IsMostDerived = ImplicitParamDecl::Create(
1415  Context, /*DC=*/nullptr, CGF.CurGD.getDecl()->getLocation(),
1416  &Context.Idents.get("is_most_derived"), Context.IntTy,
1418  // The 'most_derived' parameter goes second if the ctor is variadic and last
1419  // if it's not. Dtors can't be variadic.
1420  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
1421  if (FPT->isVariadic())
1422  Params.insert(Params.begin() + 1, IsMostDerived);
1423  else
1424  Params.push_back(IsMostDerived);
1425  getStructorImplicitParamDecl(CGF) = IsMostDerived;
1426  } else if (isDeletingDtor(CGF.CurGD)) {
1427  auto *ShouldDelete = ImplicitParamDecl::Create(
1428  Context, /*DC=*/nullptr, CGF.CurGD.getDecl()->getLocation(),
1429  &Context.Idents.get("should_call_delete"), Context.IntTy,
1431  Params.push_back(ShouldDelete);
1432  getStructorImplicitParamDecl(CGF) = ShouldDelete;
1433  }
1434 }
1435 
1436 llvm::Value *MicrosoftCXXABI::adjustThisParameterInVirtualFunctionPrologue(
1437  CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) {
1438  // In this ABI, every virtual function takes a pointer to one of the
1439  // subobjects that first defines it as the 'this' parameter, rather than a
1440  // pointer to the final overrider subobject. Thus, we need to adjust it back
1441  // to the final overrider subobject before use.
1442  // See comments in the MicrosoftVFTableContext implementation for the details.
1443  CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1444  if (Adjustment.isZero())
1445  return This;
1446 
1447  unsigned AS = cast<llvm::PointerType>(This->getType())->getAddressSpace();
1448  llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS),
1449  *thisTy = This->getType();
1450 
1451  This = CGF.Builder.CreateBitCast(This, charPtrTy);
1452  assert(Adjustment.isPositive());
1453  This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This,
1454  -Adjustment.getQuantity());
1455  return CGF.Builder.CreateBitCast(This, thisTy);
1456 }
1457 
1458 void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1459  // Naked functions have no prolog.
1460  if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1461  return;
1462 
1463  EmitThisParam(CGF);
1464 
1465  /// If this is a function that the ABI specifies returns 'this', initialize
1466  /// the return slot to 'this' at the start of the function.
1467  ///
1468  /// Unlike the setting of return types, this is done within the ABI
1469  /// implementation instead of by clients of CGCXXABI because:
1470  /// 1) getThisValue is currently protected
1471  /// 2) in theory, an ABI could implement 'this' returns some other way;
1472  /// HasThisReturn only specifies a contract, not the implementation
1473  if (HasThisReturn(CGF.CurGD))
1474  CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1475  else if (hasMostDerivedReturn(CGF.CurGD))
1476  CGF.Builder.CreateStore(CGF.EmitCastToVoidPtr(getThisValue(CGF)),
1477  CGF.ReturnValue);
1478 
1479  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1480  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
1481  assert(getStructorImplicitParamDecl(CGF) &&
1482  "no implicit parameter for a constructor with virtual bases?");
1483  getStructorImplicitParamValue(CGF)
1484  = CGF.Builder.CreateLoad(
1485  CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1486  "is_most_derived");
1487  }
1488 
1489  if (isDeletingDtor(CGF.CurGD)) {
1490  assert(getStructorImplicitParamDecl(CGF) &&
1491  "no implicit parameter for a deleting destructor?");
1492  getStructorImplicitParamValue(CGF)
1493  = CGF.Builder.CreateLoad(
1494  CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1495  "should_call_delete");
1496  }
1497 }
1498 
1499 CGCXXABI::AddedStructorArgs MicrosoftCXXABI::addImplicitConstructorArgs(
1501  bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1502  assert(Type == Ctor_Complete || Type == Ctor_Base);
1503 
1504  // Check if we need a 'most_derived' parameter.
1505  if (!D->getParent()->getNumVBases())
1506  return AddedStructorArgs{};
1507 
1508  // Add the 'most_derived' argument second if we are variadic or last if not.
1509  const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
1510  llvm::Value *MostDerivedArg;
1511  if (Delegating) {
1512  MostDerivedArg = getStructorImplicitParamValue(CGF);
1513  } else {
1514  MostDerivedArg = llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete);
1515  }
1516  RValue RV = RValue::get(MostDerivedArg);
1517  if (FPT->isVariadic()) {
1518  Args.insert(Args.begin() + 1,
1519  CallArg(RV, getContext().IntTy, /*needscopy=*/false));
1520  return AddedStructorArgs::prefix(1);
1521  }
1522  Args.add(RV, getContext().IntTy);
1523  return AddedStructorArgs::suffix(1);
1524 }
1525 
1526 void MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1527  const CXXDestructorDecl *DD,
1528  CXXDtorType Type, bool ForVirtualBase,
1529  bool Delegating, Address This) {
1530  CGCallee Callee = CGCallee::forDirect(
1531  CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type)),
1532  DD);
1533 
1534  if (DD->isVirtual()) {
1535  assert(Type != CXXDtorType::Dtor_Deleting &&
1536  "The deleting destructor should only be called via a virtual call");
1537  This = adjustThisArgumentForVirtualFunctionCall(CGF, GlobalDecl(DD, Type),
1538  This, false);
1539  }
1540 
1541  llvm::BasicBlock *BaseDtorEndBB = nullptr;
1542  if (ForVirtualBase && isa<CXXConstructorDecl>(CGF.CurCodeDecl)) {
1543  BaseDtorEndBB = EmitDtorCompleteObjectHandler(CGF);
1544  }
1545 
1546  CGF.EmitCXXDestructorCall(DD, Callee, This.getPointer(),
1547  /*ImplicitParam=*/nullptr,
1548  /*ImplicitParamTy=*/QualType(), nullptr,
1549  getFromDtorType(Type));
1550  if (BaseDtorEndBB) {
1551  // Complete object handler should continue to be the remaining
1552  CGF.Builder.CreateBr(BaseDtorEndBB);
1553  CGF.EmitBlock(BaseDtorEndBB);
1554  }
1555 }
1556 
1557 void MicrosoftCXXABI::emitVTableTypeMetadata(const VPtrInfo &Info,
1558  const CXXRecordDecl *RD,
1559  llvm::GlobalVariable *VTable) {
1560  if (!CGM.getCodeGenOpts().LTOUnit)
1561  return;
1562 
1563  // The location of the first virtual function pointer in the virtual table,
1564  // aka the "address point" on Itanium. This is at offset 0 if RTTI is
1565  // disabled, or sizeof(void*) if RTTI is enabled.
1566  CharUnits AddressPoint =
1567  getContext().getLangOpts().RTTIData
1568  ? getContext().toCharUnitsFromBits(
1569  getContext().getTargetInfo().getPointerWidth(0))
1570  : CharUnits::Zero();
1571 
1572  if (Info.PathToIntroducingObject.empty()) {
1573  CGM.AddVTableTypeMetadata(VTable, AddressPoint, RD);
1574  return;
1575  }
1576 
1577  // Add a bitset entry for the least derived base belonging to this vftable.
1578  CGM.AddVTableTypeMetadata(VTable, AddressPoint,
1579  Info.PathToIntroducingObject.back());
1580 
1581  // Add a bitset entry for each derived class that is laid out at the same
1582  // offset as the least derived base.
1583  for (unsigned I = Info.PathToIntroducingObject.size() - 1; I != 0; --I) {
1584  const CXXRecordDecl *DerivedRD = Info.PathToIntroducingObject[I - 1];
1585  const CXXRecordDecl *BaseRD = Info.PathToIntroducingObject[I];
1586 
1587  const ASTRecordLayout &Layout =
1588  getContext().getASTRecordLayout(DerivedRD);
1589  CharUnits Offset;
1590  auto VBI = Layout.getVBaseOffsetsMap().find(BaseRD);
1591  if (VBI == Layout.getVBaseOffsetsMap().end())
1592  Offset = Layout.getBaseClassOffset(BaseRD);
1593  else
1594  Offset = VBI->second.VBaseOffset;
1595  if (!Offset.isZero())
1596  return;
1597  CGM.AddVTableTypeMetadata(VTable, AddressPoint, DerivedRD);
1598  }
1599 
1600  // Finally do the same for the most derived class.
1601  if (Info.FullOffsetInMDC.isZero())
1602  CGM.AddVTableTypeMetadata(VTable, AddressPoint, RD);
1603 }
1604 
1605 void MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1606  const CXXRecordDecl *RD) {
1607  MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext();
1608  const VPtrInfoVector &VFPtrs = VFTContext.getVFPtrOffsets(RD);
1609 
1610  for (const std::unique_ptr<VPtrInfo>& Info : VFPtrs) {
1611  llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->FullOffsetInMDC);
1612  if (VTable->hasInitializer())
1613  continue;
1614 
1615  const VTableLayout &VTLayout =
1616  VFTContext.getVFTableLayout(RD, Info->FullOffsetInMDC);
1617 
1618  llvm::Constant *RTTI = nullptr;
1619  if (any_of(VTLayout.vtable_components(),
1620  [](const VTableComponent &VTC) { return VTC.isRTTIKind(); }))
1621  RTTI = getMSCompleteObjectLocator(RD, *Info);
1622 
1623  ConstantInitBuilder Builder(CGM);
1624  auto Components = Builder.beginStruct();
1625  CGVT.createVTableInitializer(Components, VTLayout, RTTI);
1626  Components.finishAndSetAsInitializer(VTable);
1627 
1628  emitVTableTypeMetadata(*Info, RD, VTable);
1629  }
1630 }
1631 
1632 bool MicrosoftCXXABI::isVirtualOffsetNeededForVTableField(
1634  return Vptr.NearestVBase != nullptr;
1635 }
1636 
1637 llvm::Value *MicrosoftCXXABI::getVTableAddressPointInStructor(
1638  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1639  const CXXRecordDecl *NearestVBase) {
1640  llvm::Constant *VTableAddressPoint = getVTableAddressPoint(Base, VTableClass);
1641  if (!VTableAddressPoint) {
1642  assert(Base.getBase()->getNumVBases() &&
1643  !getContext().getASTRecordLayout(Base.getBase()).hasOwnVFPtr());
1644  }
1645  return VTableAddressPoint;
1646 }
1647 
1649  const CXXRecordDecl *RD, const VPtrInfo &VFPtr,
1650  SmallString<256> &Name) {
1651  llvm::raw_svector_ostream Out(Name);
1652  MangleContext.mangleCXXVFTable(RD, VFPtr.MangledPath, Out);
1653 }
1654 
1655 llvm::Constant *
1656 MicrosoftCXXABI::getVTableAddressPoint(BaseSubobject Base,
1657  const CXXRecordDecl *VTableClass) {
1658  (void)getAddrOfVTable(VTableClass, Base.getBaseOffset());
1659  VFTableIdTy ID(VTableClass, Base.getBaseOffset());
1660  return VFTablesMap[ID];
1661 }
1662 
1663 llvm::Constant *MicrosoftCXXABI::getVTableAddressPointForConstExpr(
1664  BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1665  llvm::Constant *VFTable = getVTableAddressPoint(Base, VTableClass);
1666  assert(VFTable && "Couldn't find a vftable for the given base?");
1667  return VFTable;
1668 }
1669 
1670 llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1671  CharUnits VPtrOffset) {
1672  // getAddrOfVTable may return 0 if asked to get an address of a vtable which
1673  // shouldn't be used in the given record type. We want to cache this result in
1674  // VFTablesMap, thus a simple zero check is not sufficient.
1675 
1676  VFTableIdTy ID(RD, VPtrOffset);
1677  VTablesMapTy::iterator I;
1678  bool Inserted;
1679  std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID, nullptr));
1680  if (!Inserted)
1681  return I->second;
1682 
1683  llvm::GlobalVariable *&VTable = I->second;
1684 
1685  MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
1686  const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD);
1687 
1688  if (DeferredVFTables.insert(RD).second) {
1689  // We haven't processed this record type before.
1690  // Queue up this vtable for possible deferred emission.
1691  CGM.addDeferredVTable(RD);
1692 
1693 #ifndef NDEBUG
1694  // Create all the vftables at once in order to make sure each vftable has
1695  // a unique mangled name.
1696  llvm::StringSet<> ObservedMangledNames;
1697  for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
1698  SmallString<256> Name;
1699  mangleVFTableName(getMangleContext(), RD, *VFPtrs[J], Name);
1700  if (!ObservedMangledNames.insert(Name.str()).second)
1701  llvm_unreachable("Already saw this mangling before?");
1702  }
1703 #endif
1704  }
1705 
1706  const std::unique_ptr<VPtrInfo> *VFPtrI = std::find_if(
1707  VFPtrs.begin(), VFPtrs.end(), [&](const std::unique_ptr<VPtrInfo>& VPI) {
1708  return VPI->FullOffsetInMDC == VPtrOffset;
1709  });
1710  if (VFPtrI == VFPtrs.end()) {
1711  VFTablesMap[ID] = nullptr;
1712  return nullptr;
1713  }
1714  const std::unique_ptr<VPtrInfo> &VFPtr = *VFPtrI;
1715 
1716  SmallString<256> VFTableName;
1717  mangleVFTableName(getMangleContext(), RD, *VFPtr, VFTableName);
1718 
1719  // Classes marked __declspec(dllimport) need vftables generated on the
1720  // import-side in order to support features like constexpr. No other
1721  // translation unit relies on the emission of the local vftable, translation
1722  // units are expected to generate them as needed.
1723  //
1724  // Because of this unique behavior, we maintain this logic here instead of
1725  // getVTableLinkage.
1726  llvm::GlobalValue::LinkageTypes VFTableLinkage =
1727  RD->hasAttr<DLLImportAttr>() ? llvm::GlobalValue::LinkOnceODRLinkage
1728  : CGM.getVTableLinkage(RD);
1729  bool VFTableComesFromAnotherTU =
1730  llvm::GlobalValue::isAvailableExternallyLinkage(VFTableLinkage) ||
1731  llvm::GlobalValue::isExternalLinkage(VFTableLinkage);
1732  bool VTableAliasIsRequred =
1733  !VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData;
1734 
1735  if (llvm::GlobalValue *VFTable =
1736  CGM.getModule().getNamedGlobal(VFTableName)) {
1737  VFTablesMap[ID] = VFTable;
1738  VTable = VTableAliasIsRequred
1739  ? cast<llvm::GlobalVariable>(
1740  cast<llvm::GlobalAlias>(VFTable)->getBaseObject())
1741  : cast<llvm::GlobalVariable>(VFTable);
1742  return VTable;
1743  }
1744 
1745  const VTableLayout &VTLayout =
1746  VTContext.getVFTableLayout(RD, VFPtr->FullOffsetInMDC);
1747  llvm::GlobalValue::LinkageTypes VTableLinkage =
1748  VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage;
1749 
1750  StringRef VTableName = VTableAliasIsRequred ? StringRef() : VFTableName.str();
1751 
1752  llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1753 
1754  // Create a backing variable for the contents of VTable. The VTable may
1755  // or may not include space for a pointer to RTTI data.
1756  llvm::GlobalValue *VFTable;
1757  VTable = new llvm::GlobalVariable(CGM.getModule(), VTableType,
1758  /*isConstant=*/true, VTableLinkage,
1759  /*Initializer=*/nullptr, VTableName);
1760  VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1761 
1762  llvm::Comdat *C = nullptr;
1763  if (!VFTableComesFromAnotherTU &&
1764  (llvm::GlobalValue::isWeakForLinker(VFTableLinkage) ||
1765  (llvm::GlobalValue::isLocalLinkage(VFTableLinkage) &&
1766  VTableAliasIsRequred)))
1767  C = CGM.getModule().getOrInsertComdat(VFTableName.str());
1768 
1769  // Only insert a pointer into the VFTable for RTTI data if we are not
1770  // importing it. We never reference the RTTI data directly so there is no
1771  // need to make room for it.
1772  if (VTableAliasIsRequred) {
1773  llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.Int32Ty, 0),
1774  llvm::ConstantInt::get(CGM.Int32Ty, 0),
1775  llvm::ConstantInt::get(CGM.Int32Ty, 1)};
1776  // Create a GEP which points just after the first entry in the VFTable,
1777  // this should be the location of the first virtual method.
1778  llvm::Constant *VTableGEP = llvm::ConstantExpr::getInBoundsGetElementPtr(
1779  VTable->getValueType(), VTable, GEPIndices);
1780  if (llvm::GlobalValue::isWeakForLinker(VFTableLinkage)) {
1781  VFTableLinkage = llvm::GlobalValue::ExternalLinkage;
1782  if (C)
1783  C->setSelectionKind(llvm::Comdat::Largest);
1784  }
1785  VFTable = llvm::GlobalAlias::create(CGM.Int8PtrTy,
1786  /*AddressSpace=*/0, VFTableLinkage,
1787  VFTableName.str(), VTableGEP,
1788  &CGM.getModule());
1789  VFTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1790  } else {
1791  // We don't need a GlobalAlias to be a symbol for the VTable if we won't
1792  // be referencing any RTTI data.
1793  // The GlobalVariable will end up being an appropriate definition of the
1794  // VFTable.
1795  VFTable = VTable;
1796  }
1797  if (C)
1798  VTable->setComdat(C);
1799 
1800  if (RD->hasAttr<DLLExportAttr>())
1801  VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1802 
1803  VFTablesMap[ID] = VFTable;
1804  return VTable;
1805 }
1806 
1807 CGCallee MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1808  GlobalDecl GD,
1809  Address This,
1810  llvm::Type *Ty,
1811  SourceLocation Loc) {
1812  GD = GD.getCanonicalDecl();
1813  CGBuilderTy &Builder = CGF.Builder;
1814 
1815  Ty = Ty->getPointerTo()->getPointerTo();
1816  Address VPtr =
1817  adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
1818 
1819  auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1820  llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty, MethodDecl->getParent());
1821 
1822  MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext();
1824  VFTContext.getMethodVFTableLocation(GD);
1825 
1826  // Compute the identity of the most derived class whose virtual table is
1827  // located at the MethodVFTableLocation ML.
1828  auto getObjectWithVPtr = [&] {
1829  return llvm::find_if(VFTContext.getVFPtrOffsets(
1830  ML.VBase ? ML.VBase : MethodDecl->getParent()),
1831  [&](const std::unique_ptr<VPtrInfo> &Info) {
1832  return Info->FullOffsetInMDC == ML.VFPtrOffset;
1833  })
1834  ->get()
1835  ->ObjectWithVPtr;
1836  };
1837 
1838  llvm::Value *VFunc;
1839  if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1840  VFunc = CGF.EmitVTableTypeCheckedLoad(
1841  getObjectWithVPtr(), VTable,
1842  ML.Index * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1843  } else {
1844  if (CGM.getCodeGenOpts().PrepareForLTO)
1845  CGF.EmitTypeMetadataCodeForVCall(getObjectWithVPtr(), VTable, Loc);
1846 
1847  llvm::Value *VFuncPtr =
1848  Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
1849  VFunc = Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1850  }
1851 
1852  CGCallee Callee(MethodDecl, VFunc);
1853  return Callee;
1854 }
1855 
1856 llvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall(
1857  CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1858  Address This, const CXXMemberCallExpr *CE) {
1859  assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1860  assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1861 
1862  // We have only one destructor in the vftable but can get both behaviors
1863  // by passing an implicit int parameter.
1864  GlobalDecl GD(Dtor, Dtor_Deleting);
1865  const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1866  Dtor, StructorType::Deleting);
1867  llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1868  CGCallee Callee = getVirtualFunctionPointer(
1869  CGF, GD, This, Ty, CE ? CE->getLocStart() : SourceLocation());
1870 
1871  ASTContext &Context = getContext();
1872  llvm::Value *ImplicitParam = llvm::ConstantInt::get(
1873  llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()),
1874  DtorType == Dtor_Deleting);
1875 
1876  This = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
1877  RValue RV =
1878  CGF.EmitCXXDestructorCall(Dtor, Callee, This.getPointer(), ImplicitParam,
1879  Context.IntTy, CE, StructorType::Deleting);
1880  return RV.getScalarVal();
1881 }
1882 
1883 const VBTableGlobals &
1884 MicrosoftCXXABI::enumerateVBTables(const CXXRecordDecl *RD) {
1885  // At this layer, we can key the cache off of a single class, which is much
1886  // easier than caching each vbtable individually.
1887  llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry;
1888  bool Added;
1889  std::tie(Entry, Added) =
1890  VBTablesMap.insert(std::make_pair(RD, VBTableGlobals()));
1891  VBTableGlobals &VBGlobals = Entry->second;
1892  if (!Added)
1893  return VBGlobals;
1894 
1895  MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext();
1896  VBGlobals.VBTables = &Context.enumerateVBTables(RD);
1897 
1898  // Cache the globals for all vbtables so we don't have to recompute the
1899  // mangled names.
1900  llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1901  for (VPtrInfoVector::const_iterator I = VBGlobals.VBTables->begin(),
1902  E = VBGlobals.VBTables->end();
1903  I != E; ++I) {
1904  VBGlobals.Globals.push_back(getAddrOfVBTable(**I, RD, Linkage));
1905  }
1906 
1907  return VBGlobals;
1908 }
1909 
1910 llvm::Function *MicrosoftCXXABI::EmitVirtualMemPtrThunk(
1911  const CXXMethodDecl *MD,
1913  assert(!isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) &&
1914  "can't form pointers to ctors or virtual dtors");
1915 
1916  // Calculate the mangled name.
1917  SmallString<256> ThunkName;
1918  llvm::raw_svector_ostream Out(ThunkName);
1919  getMangleContext().mangleVirtualMemPtrThunk(MD, Out);
1920 
1921  // If the thunk has been generated previously, just return it.
1922  if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName))
1923  return cast<llvm::Function>(GV);
1924 
1925  // Create the llvm::Function.
1926  const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSMemberPointerThunk(MD);
1927  llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
1928  llvm::Function *ThunkFn =
1930  ThunkName.str(), &CGM.getModule());
1931  assert(ThunkFn->getName() == ThunkName && "name was uniqued!");
1932 
1933  ThunkFn->setLinkage(MD->isExternallyVisible()
1934  ? llvm::GlobalValue::LinkOnceODRLinkage
1936  if (MD->isExternallyVisible())
1937  ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
1938 
1939  CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn);
1940  CGM.SetLLVMFunctionAttributesForDefinition(MD, ThunkFn);
1941 
1942  // Add the "thunk" attribute so that LLVM knows that the return type is
1943  // meaningless. These thunks can be used to call functions with differing
1944  // return types, and the caller is required to cast the prototype
1945  // appropriately to extract the correct value.
1946  ThunkFn->addFnAttr("thunk");
1947 
1948  // These thunks can be compared, so they are not unnamed.
1949  ThunkFn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);
1950 
1951  // Start codegen.
1952  CodeGenFunction CGF(CGM);
1953  CGF.CurGD = GlobalDecl(MD);
1954  CGF.CurFuncIsThunk = true;
1955 
1956  // Build FunctionArgs, but only include the implicit 'this' parameter
1957  // declaration.
1958  FunctionArgList FunctionArgs;
1959  buildThisParam(CGF, FunctionArgs);
1960 
1961  // Start defining the function.
1962  CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
1963  FunctionArgs, MD->getLocation(), SourceLocation());
1964  EmitThisParam(CGF);
1965 
1966  // Load the vfptr and then callee from the vftable. The callee should have
1967  // adjusted 'this' so that the vfptr is at offset zero.
1968  llvm::Value *VTable = CGF.GetVTablePtr(
1969  getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent());
1970 
1971  llvm::Value *VFuncPtr =
1972  CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
1973  llvm::Value *Callee =
1974  CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1975 
1976  CGF.EmitMustTailThunk(MD, getThisValue(CGF), Callee);
1977 
1978  return ThunkFn;
1979 }
1980 
1981 void MicrosoftCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1982  const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
1983  for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
1984  const std::unique_ptr<VPtrInfo>& VBT = (*VBGlobals.VBTables)[I];
1985  llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1986  if (GV->isDeclaration())
1987  emitVBTableDefinition(*VBT, RD, GV);
1988  }
1989 }
1990 
1991 llvm::GlobalVariable *
1992 MicrosoftCXXABI::getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD,
1993  llvm::GlobalVariable::LinkageTypes Linkage) {
1994  SmallString<256> OutName;
1995  llvm::raw_svector_ostream Out(OutName);
1996  getMangleContext().mangleCXXVBTable(RD, VBT.MangledPath, Out);
1997  StringRef Name = OutName.str();
1998 
1999  llvm::ArrayType *VBTableType =
2000  llvm::ArrayType::get(CGM.IntTy, 1 + VBT.ObjectWithVPtr->getNumVBases());
2001 
2002  assert(!CGM.getModule().getNamedGlobal(Name) &&
2003  "vbtable with this name already exists: mangling bug?");
2004  llvm::GlobalVariable *GV =
2005  CGM.CreateOrReplaceCXXRuntimeVariable(Name, VBTableType, Linkage);
2006  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2007 
2008  if (RD->hasAttr<DLLImportAttr>())
2009  GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2010  else if (RD->hasAttr<DLLExportAttr>())
2011  GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
2012 
2013  if (!GV->hasExternalLinkage())
2014  emitVBTableDefinition(VBT, RD, GV);
2015 
2016  return GV;
2017 }
2018 
2019 void MicrosoftCXXABI::emitVBTableDefinition(const VPtrInfo &VBT,
2020  const CXXRecordDecl *RD,
2021  llvm::GlobalVariable *GV) const {
2022  const CXXRecordDecl *ObjectWithVPtr = VBT.ObjectWithVPtr;
2023 
2024  assert(RD->getNumVBases() && ObjectWithVPtr->getNumVBases() &&
2025  "should only emit vbtables for classes with vbtables");
2026 
2027  const ASTRecordLayout &BaseLayout =
2028  getContext().getASTRecordLayout(VBT.IntroducingObject);
2029  const ASTRecordLayout &DerivedLayout = getContext().getASTRecordLayout(RD);
2030 
2031  SmallVector<llvm::Constant *, 4> Offsets(1 + ObjectWithVPtr->getNumVBases(),
2032  nullptr);
2033 
2034  // The offset from ObjectWithVPtr's vbptr to itself always leads.
2035  CharUnits VBPtrOffset = BaseLayout.getVBPtrOffset();
2036  Offsets[0] = llvm::ConstantInt::get(CGM.IntTy, -VBPtrOffset.getQuantity());
2037 
2038  MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext();
2039  for (const auto &I : ObjectWithVPtr->vbases()) {
2040  const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl();
2041  CharUnits Offset = DerivedLayout.getVBaseClassOffset(VBase);
2042  assert(!Offset.isNegative());
2043 
2044  // Make it relative to the subobject vbptr.
2045  CharUnits CompleteVBPtrOffset = VBT.NonVirtualOffset + VBPtrOffset;
2046  if (VBT.getVBaseWithVPtr())
2047  CompleteVBPtrOffset +=
2048  DerivedLayout.getVBaseClassOffset(VBT.getVBaseWithVPtr());
2049  Offset -= CompleteVBPtrOffset;
2050 
2051  unsigned VBIndex = Context.getVBTableIndex(ObjectWithVPtr, VBase);
2052  assert(Offsets[VBIndex] == nullptr && "The same vbindex seen twice?");
2053  Offsets[VBIndex] = llvm::ConstantInt::get(CGM.IntTy, Offset.getQuantity());
2054  }
2055 
2056  assert(Offsets.size() ==
2057  cast<llvm::ArrayType>(cast<llvm::PointerType>(GV->getType())
2058  ->getElementType())->getNumElements());
2059  llvm::ArrayType *VBTableType =
2060  llvm::ArrayType::get(CGM.IntTy, Offsets.size());
2061  llvm::Constant *Init = llvm::ConstantArray::get(VBTableType, Offsets);
2062  GV->setInitializer(Init);
2063 
2064  if (RD->hasAttr<DLLImportAttr>())
2065  GV->setLinkage(llvm::GlobalVariable::AvailableExternallyLinkage);
2066 }
2067 
2068 llvm::Value *MicrosoftCXXABI::performThisAdjustment(CodeGenFunction &CGF,
2069  Address This,
2070  const ThisAdjustment &TA) {
2071  if (TA.isEmpty())
2072  return This.getPointer();
2073 
2074  This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
2075 
2076  llvm::Value *V;
2077  if (TA.Virtual.isEmpty()) {
2078  V = This.getPointer();
2079  } else {
2080  assert(TA.Virtual.Microsoft.VtordispOffset < 0);
2081  // Adjust the this argument based on the vtordisp value.
2082  Address VtorDispPtr =
2085  VtorDispPtr = CGF.Builder.CreateElementBitCast(VtorDispPtr, CGF.Int32Ty);
2086  llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp");
2087  V = CGF.Builder.CreateGEP(This.getPointer(),
2088  CGF.Builder.CreateNeg(VtorDisp));
2089 
2090  // Unfortunately, having applied the vtordisp means that we no
2091  // longer really have a known alignment for the vbptr step.
2092  // We'll assume the vbptr is pointer-aligned.
2093 
2094  if (TA.Virtual.Microsoft.VBPtrOffset) {
2095  // If the final overrider is defined in a virtual base other than the one
2096  // that holds the vfptr, we have to use a vtordispex thunk which looks up
2097  // the vbtable of the derived class.
2098  assert(TA.Virtual.Microsoft.VBPtrOffset > 0);
2099  assert(TA.Virtual.Microsoft.VBOffsetOffset >= 0);
2100  llvm::Value *VBPtr;
2101  llvm::Value *VBaseOffset =
2102  GetVBaseOffsetFromVBPtr(CGF, Address(V, CGF.getPointerAlign()),
2104  TA.Virtual.Microsoft.VBOffsetOffset, &VBPtr);
2105  V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2106  }
2107  }
2108 
2109  if (TA.NonVirtual) {
2110  // Non-virtual adjustment might result in a pointer outside the allocated
2111  // object, e.g. if the final overrider class is laid out after the virtual
2112  // base that declares a method in the most derived class.
2113  V = CGF.Builder.CreateConstGEP1_32(V, TA.NonVirtual);
2114  }
2115 
2116  // Don't need to bitcast back, the call CodeGen will handle this.
2117  return V;
2118 }
2119 
2120 llvm::Value *
2121 MicrosoftCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
2122  const ReturnAdjustment &RA) {
2123  if (RA.isEmpty())
2124  return Ret.getPointer();
2125 
2126  auto OrigTy = Ret.getType();
2127  Ret = CGF.Builder.CreateElementBitCast(Ret, CGF.Int8Ty);
2128 
2129  llvm::Value *V = Ret.getPointer();
2130  if (RA.Virtual.Microsoft.VBIndex) {
2131  assert(RA.Virtual.Microsoft.VBIndex > 0);
2132  int32_t IntSize = CGF.getIntSize().getQuantity();
2133  llvm::Value *VBPtr;
2134  llvm::Value *VBaseOffset =
2135  GetVBaseOffsetFromVBPtr(CGF, Ret, RA.Virtual.Microsoft.VBPtrOffset,
2136  IntSize * RA.Virtual.Microsoft.VBIndex, &VBPtr);
2137  V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2138  }
2139 
2140  if (RA.NonVirtual)
2141  V = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, V, RA.NonVirtual);
2142 
2143  // Cast back to the original type.
2144  return CGF.Builder.CreateBitCast(V, OrigTy);
2145 }
2146 
2147 bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
2148  QualType elementType) {
2149  // Microsoft seems to completely ignore the possibility of a
2150  // two-argument usual deallocation function.
2151  return elementType.isDestructedType();
2152 }
2153 
2154 bool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
2155  // Microsoft seems to completely ignore the possibility of a
2156  // two-argument usual deallocation function.
2157  return expr->getAllocatedType().isDestructedType();
2158 }
2159 
2160 CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
2161  // The array cookie is always a size_t; we then pad that out to the
2162  // alignment of the element type.
2163  ASTContext &Ctx = getContext();
2164  return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
2165  Ctx.getTypeAlignInChars(type));
2166 }
2167 
2168 llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2169  Address allocPtr,
2170  CharUnits cookieSize) {
2171  Address numElementsPtr =
2172  CGF.Builder.CreateElementBitCast(allocPtr, CGF.SizeTy);
2173  return CGF.Builder.CreateLoad(numElementsPtr);
2174 }
2175 
2176 Address MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2177  Address newPtr,
2178  llvm::Value *numElements,
2179  const CXXNewExpr *expr,
2180  QualType elementType) {
2181  assert(requiresArrayCookie(expr));
2182 
2183  // The size of the cookie.
2184  CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
2185 
2186  // Compute an offset to the cookie.
2187  Address cookiePtr = newPtr;
2188 
2189  // Write the number of elements into the appropriate slot.
2190  Address numElementsPtr
2191  = CGF.Builder.CreateElementBitCast(cookiePtr, CGF.SizeTy);
2192  CGF.Builder.CreateStore(numElements, numElementsPtr);
2193 
2194  // Finally, compute a pointer to the actual data buffer by skipping
2195  // over the cookie completely.
2196  return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2197 }
2198 
2200  llvm::Constant *Dtor,
2201  llvm::Constant *Addr) {
2202  // Create a function which calls the destructor.
2203  llvm::Constant *DtorStub = CGF.createAtExitStub(VD, Dtor, Addr);
2204 
2205  // extern "C" int __tlregdtor(void (*f)(void));
2206  llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(
2207  CGF.IntTy, DtorStub->getType(), /*IsVarArg=*/false);
2208 
2209  llvm::Constant *TLRegDtor = CGF.CGM.CreateRuntimeFunction(
2210  TLRegDtorTy, "__tlregdtor", llvm::AttributeList(), /*Local=*/true);
2211  if (llvm::Function *TLRegDtorFn = dyn_cast<llvm::Function>(TLRegDtor))
2212  TLRegDtorFn->setDoesNotThrow();
2213 
2214  CGF.EmitNounwindRuntimeCall(TLRegDtor, DtorStub);
2215 }
2216 
2217 void MicrosoftCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2218  llvm::Constant *Dtor,
2219  llvm::Constant *Addr) {
2220  if (D.getTLSKind())
2221  return emitGlobalDtorWithTLRegDtor(CGF, D, Dtor, Addr);
2222 
2223  // The default behavior is to use atexit.
2224  CGF.registerGlobalDtorWithAtExit(D, Dtor, Addr);
2225 }
2226 
2227 void MicrosoftCXXABI::EmitThreadLocalInitFuncs(
2228  CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2229  ArrayRef<llvm::Function *> CXXThreadLocalInits,
2230  ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2231  if (CXXThreadLocalInits.empty())
2232  return;
2233 
2234  CGM.AppendLinkerOptions(CGM.getTarget().getTriple().getArch() ==
2235  llvm::Triple::x86
2236  ? "/include:___dyn_tls_init@12"
2237  : "/include:__dyn_tls_init");
2238 
2239  // This will create a GV in the .CRT$XDU section. It will point to our
2240  // initialization function. The CRT will call all of these function
2241  // pointers at start-up time and, eventually, at thread-creation time.
2242  auto AddToXDU = [&CGM](llvm::Function *InitFunc) {
2243  llvm::GlobalVariable *InitFuncPtr = new llvm::GlobalVariable(
2244  CGM.getModule(), InitFunc->getType(), /*IsConstant=*/true,
2246  Twine(InitFunc->getName(), "$initializer$"));
2247  InitFuncPtr->setSection(".CRT$XDU");
2248  // This variable has discardable linkage, we have to add it to @llvm.used to
2249  // ensure it won't get discarded.
2250  CGM.addUsedGlobal(InitFuncPtr);
2251  return InitFuncPtr;
2252  };
2253 
2254  std::vector<llvm::Function *> NonComdatInits;
2255  for (size_t I = 0, E = CXXThreadLocalInitVars.size(); I != E; ++I) {
2256  llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(
2257  CGM.GetGlobalValue(CGM.getMangledName(CXXThreadLocalInitVars[I])));
2258  llvm::Function *F = CXXThreadLocalInits[I];
2259 
2260  // If the GV is already in a comdat group, then we have to join it.
2261  if (llvm::Comdat *C = GV->getComdat())
2262  AddToXDU(F)->setComdat(C);
2263  else
2264  NonComdatInits.push_back(F);
2265  }
2266 
2267  if (!NonComdatInits.empty()) {
2268  llvm::FunctionType *FTy =
2269  llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2270  llvm::Function *InitFunc = CGM.CreateGlobalInitOrDestructFunction(
2271  FTy, "__tls_init", CGM.getTypes().arrangeNullaryFunction(),
2272  SourceLocation(), /*TLS=*/true);
2273  CodeGenFunction(CGM).GenerateCXXGlobalInitFunc(InitFunc, NonComdatInits);
2274 
2275  AddToXDU(InitFunc);
2276  }
2277 }
2278 
2279 LValue MicrosoftCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2280  const VarDecl *VD,
2281  QualType LValType) {
2282  CGF.CGM.ErrorUnsupported(VD, "thread wrappers");
2283  return LValue();
2284 }
2285 
2287  StringRef VarName("_Init_thread_epoch");
2288  CharUnits Align = CGM.getIntAlign();
2289  if (auto *GV = CGM.getModule().getNamedGlobal(VarName))
2290  return ConstantAddress(GV, Align);
2291  auto *GV = new llvm::GlobalVariable(
2292  CGM.getModule(), CGM.IntTy,
2293  /*Constant=*/false, llvm::GlobalVariable::ExternalLinkage,
2294  /*Initializer=*/nullptr, VarName,
2295  /*InsertBefore=*/nullptr, llvm::GlobalVariable::GeneralDynamicTLSModel);
2296  GV->setAlignment(Align.getQuantity());
2297  return ConstantAddress(GV, Align);
2298 }
2299 
2300 static llvm::Constant *getInitThreadHeaderFn(CodeGenModule &CGM) {
2301  llvm::FunctionType *FTy =
2302  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2303  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2304  return CGM.CreateRuntimeFunction(
2305  FTy, "_Init_thread_header",
2306  llvm::AttributeList::get(CGM.getLLVMContext(),
2307  llvm::AttributeList::FunctionIndex,
2308  llvm::Attribute::NoUnwind),
2309  /*Local=*/true);
2310 }
2311 
2312 static llvm::Constant *getInitThreadFooterFn(CodeGenModule &CGM) {
2313  llvm::FunctionType *FTy =
2314  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2315  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2316  return CGM.CreateRuntimeFunction(
2317  FTy, "_Init_thread_footer",
2318  llvm::AttributeList::get(CGM.getLLVMContext(),
2319  llvm::AttributeList::FunctionIndex,
2320  llvm::Attribute::NoUnwind),
2321  /*Local=*/true);
2322 }
2323 
2324 static llvm::Constant *getInitThreadAbortFn(CodeGenModule &CGM) {
2325  llvm::FunctionType *FTy =
2326  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2327  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2328  return CGM.CreateRuntimeFunction(
2329  FTy, "_Init_thread_abort",
2330  llvm::AttributeList::get(CGM.getLLVMContext(),
2331  llvm::AttributeList::FunctionIndex,
2332  llvm::Attribute::NoUnwind),
2333  /*Local=*/true);
2334 }
2335 
2336 namespace {
2337 struct ResetGuardBit final : EHScopeStack::Cleanup {
2338  Address Guard;
2339  unsigned GuardNum;
2340  ResetGuardBit(Address Guard, unsigned GuardNum)
2341  : Guard(Guard), GuardNum(GuardNum) {}
2342 
2343  void Emit(CodeGenFunction &CGF, Flags flags) override {
2344  // Reset the bit in the mask so that the static variable may be
2345  // reinitialized.
2346  CGBuilderTy &Builder = CGF.Builder;
2347  llvm::LoadInst *LI = Builder.CreateLoad(Guard);
2348  llvm::ConstantInt *Mask =
2349  llvm::ConstantInt::get(CGF.IntTy, ~(1ULL << GuardNum));
2350  Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard);
2351  }
2352 };
2353 
2354 struct CallInitThreadAbort final : EHScopeStack::Cleanup {
2355  llvm::Value *Guard;
2356  CallInitThreadAbort(Address Guard) : Guard(Guard.getPointer()) {}
2357 
2358  void Emit(CodeGenFunction &CGF, Flags flags) override {
2359  // Calling _Init_thread_abort will reset the guard's state.
2361  }
2362 };
2363 }
2364 
2365 void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
2366  llvm::GlobalVariable *GV,
2367  bool PerformInit) {
2368  // MSVC only uses guards for static locals.
2369  if (!D.isStaticLocal()) {
2370  assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage());
2371  // GlobalOpt is allowed to discard the initializer, so use linkonce_odr.
2372  llvm::Function *F = CGF.CurFn;
2373  F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
2374  F->setComdat(CGM.getModule().getOrInsertComdat(F->getName()));
2375  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2376  return;
2377  }
2378 
2379  bool ThreadlocalStatic = D.getTLSKind();
2380  bool ThreadsafeStatic = getContext().getLangOpts().ThreadsafeStatics;
2381 
2382  // Thread-safe static variables which aren't thread-specific have a
2383  // per-variable guard.
2384  bool HasPerVariableGuard = ThreadsafeStatic && !ThreadlocalStatic;
2385 
2386  CGBuilderTy &Builder = CGF.Builder;
2387  llvm::IntegerType *GuardTy = CGF.Int32Ty;
2388  llvm::ConstantInt *Zero = llvm::ConstantInt::get(GuardTy, 0);
2389  CharUnits GuardAlign = CharUnits::fromQuantity(4);
2390 
2391  // Get the guard variable for this function if we have one already.
2392  GuardInfo *GI = nullptr;
2393  if (ThreadlocalStatic)
2394  GI = &ThreadLocalGuardVariableMap[D.getDeclContext()];
2395  else if (!ThreadsafeStatic)
2396  GI = &GuardVariableMap[D.getDeclContext()];
2397 
2398  llvm::GlobalVariable *GuardVar = GI ? GI->Guard : nullptr;
2399  unsigned GuardNum;
2400  if (D.isExternallyVisible()) {
2401  // Externally visible variables have to be numbered in Sema to properly
2402  // handle unreachable VarDecls.
2403  GuardNum = getContext().getStaticLocalNumber(&D);
2404  assert(GuardNum > 0);
2405  GuardNum--;
2406  } else if (HasPerVariableGuard) {
2407  GuardNum = ThreadSafeGuardNumMap[D.getDeclContext()]++;
2408  } else {
2409  // Non-externally visible variables are numbered here in CodeGen.
2410  GuardNum = GI->BitIndex++;
2411  }
2412 
2413  if (!HasPerVariableGuard && GuardNum >= 32) {
2414  if (D.isExternallyVisible())
2415  ErrorUnsupportedABI(CGF, "more than 32 guarded initializations");
2416  GuardNum %= 32;
2417  GuardVar = nullptr;
2418  }
2419 
2420  if (!GuardVar) {
2421  // Mangle the name for the guard.
2422  SmallString<256> GuardName;
2423  {
2424  llvm::raw_svector_ostream Out(GuardName);
2425  if (HasPerVariableGuard)
2426  getMangleContext().mangleThreadSafeStaticGuardVariable(&D, GuardNum,
2427  Out);
2428  else
2429  getMangleContext().mangleStaticGuardVariable(&D, Out);
2430  }
2431 
2432  // Create the guard variable with a zero-initializer. Just absorb linkage,
2433  // visibility and dll storage class from the guarded variable.
2434  GuardVar =
2435  new llvm::GlobalVariable(CGM.getModule(), GuardTy, /*isConstant=*/false,
2436  GV->getLinkage(), Zero, GuardName.str());
2437  GuardVar->setVisibility(GV->getVisibility());
2438  GuardVar->setDLLStorageClass(GV->getDLLStorageClass());
2439  GuardVar->setAlignment(GuardAlign.getQuantity());
2440  if (GuardVar->isWeakForLinker())
2441  GuardVar->setComdat(
2442  CGM.getModule().getOrInsertComdat(GuardVar->getName()));
2443  if (D.getTLSKind())
2444  GuardVar->setThreadLocal(true);
2445  if (GI && !HasPerVariableGuard)
2446  GI->Guard = GuardVar;
2447  }
2448 
2449  ConstantAddress GuardAddr(GuardVar, GuardAlign);
2450 
2451  assert(GuardVar->getLinkage() == GV->getLinkage() &&
2452  "static local from the same function had different linkage");
2453 
2454  if (!HasPerVariableGuard) {
2455  // Pseudo code for the test:
2456  // if (!(GuardVar & MyGuardBit)) {
2457  // GuardVar |= MyGuardBit;
2458  // ... initialize the object ...;
2459  // }
2460 
2461  // Test our bit from the guard variable.
2462  llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);
2463  llvm::LoadInst *LI = Builder.CreateLoad(GuardAddr);
2464  llvm::Value *NeedsInit =
2465  Builder.CreateICmpEQ(Builder.CreateAnd(LI, Bit), Zero);
2466  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2467  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2468  CGF.EmitCXXGuardedInitBranch(NeedsInit, InitBlock, EndBlock,
2470 
2471  // Set our bit in the guard variable and emit the initializer and add a global
2472  // destructor if appropriate.
2473  CGF.EmitBlock(InitBlock);
2474  Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr);
2475  CGF.EHStack.pushCleanup<ResetGuardBit>(EHCleanup, GuardAddr, GuardNum);
2476  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2477  CGF.PopCleanupBlock();
2478  Builder.CreateBr(EndBlock);
2479 
2480  // Continue.
2481  CGF.EmitBlock(EndBlock);
2482  } else {
2483  // Pseudo code for the test:
2484  // if (TSS > _Init_thread_epoch) {
2485  // _Init_thread_header(&TSS);
2486  // if (TSS == -1) {
2487  // ... initialize the object ...;
2488  // _Init_thread_footer(&TSS);
2489  // }
2490  // }
2491  //
2492  // The algorithm is almost identical to what can be found in the appendix
2493  // found in N2325.
2494 
2495  // This BasicBLock determines whether or not we have any work to do.
2496  llvm::LoadInst *FirstGuardLoad = Builder.CreateLoad(GuardAddr);
2497  FirstGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2498  llvm::LoadInst *InitThreadEpoch =
2499  Builder.CreateLoad(getInitThreadEpochPtr(CGM));
2500  llvm::Value *IsUninitialized =
2501  Builder.CreateICmpSGT(FirstGuardLoad, InitThreadEpoch);
2502  llvm::BasicBlock *AttemptInitBlock = CGF.createBasicBlock("init.attempt");
2503  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2504  CGF.EmitCXXGuardedInitBranch(IsUninitialized, AttemptInitBlock, EndBlock,
2506 
2507  // This BasicBlock attempts to determine whether or not this thread is
2508  // responsible for doing the initialization.
2509  CGF.EmitBlock(AttemptInitBlock);
2511  GuardAddr.getPointer());
2512  llvm::LoadInst *SecondGuardLoad = Builder.CreateLoad(GuardAddr);
2513  SecondGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2514  llvm::Value *ShouldDoInit =
2515  Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt());
2516  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2517  Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);
2518 
2519  // Ok, we ended up getting selected as the initializing thread.
2520  CGF.EmitBlock(InitBlock);
2521  CGF.EHStack.pushCleanup<CallInitThreadAbort>(EHCleanup, GuardAddr);
2522  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2523  CGF.PopCleanupBlock();
2525  GuardAddr.getPointer());
2526  Builder.CreateBr(EndBlock);
2527 
2528  CGF.EmitBlock(EndBlock);
2529  }
2530 }
2531 
2532 bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
2533  // Null-ness for function memptrs only depends on the first field, which is
2534  // the function pointer. The rest don't matter, so we can zero initialize.
2535  if (MPT->isMemberFunctionPointer())
2536  return true;
2537 
2538  // The virtual base adjustment field is always -1 for null, so if we have one
2539  // we can't zero initialize. The field offset is sometimes also -1 if 0 is a
2540  // valid field offset.
2541  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2542  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2543  return (!MSInheritanceAttr::hasVBTableOffsetField(Inheritance) &&
2544  RD->nullFieldOffsetIsZero());
2545 }
2546 
2547 llvm::Type *
2548 MicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
2549  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2550  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2552  if (MPT->isMemberFunctionPointer())
2553  fields.push_back(CGM.VoidPtrTy); // FunctionPointerOrVirtualThunk
2554  else
2555  fields.push_back(CGM.IntTy); // FieldOffset
2556 
2557  if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
2558  Inheritance))
2559  fields.push_back(CGM.IntTy);
2560  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2561  fields.push_back(CGM.IntTy);
2562  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2563  fields.push_back(CGM.IntTy); // VirtualBaseAdjustmentOffset
2564 
2565  if (fields.size() == 1)
2566  return fields[0];
2567  return llvm::StructType::get(CGM.getLLVMContext(), fields);
2568 }
2569 
2570 void MicrosoftCXXABI::
2571 GetNullMemberPointerFields(const MemberPointerType *MPT,
2573  assert(fields.empty());
2574  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2575  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2576  if (MPT->isMemberFunctionPointer()) {
2577  // FunctionPointerOrVirtualThunk
2578  fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
2579  } else {
2580  if (RD->nullFieldOffsetIsZero())
2581  fields.push_back(getZeroInt()); // FieldOffset
2582  else
2583  fields.push_back(getAllOnesInt()); // FieldOffset
2584  }
2585 
2586  if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
2587  Inheritance))
2588  fields.push_back(getZeroInt());
2589  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2590  fields.push_back(getZeroInt());
2591  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2592  fields.push_back(getAllOnesInt());
2593 }
2594 
2595 llvm::Constant *
2596 MicrosoftCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
2598  GetNullMemberPointerFields(MPT, fields);
2599  if (fields.size() == 1)
2600  return fields[0];
2601  llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
2602  assert(Res->getType() == ConvertMemberPointerType(MPT));
2603  return Res;
2604 }
2605 
2606 llvm::Constant *
2607 MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,
2608  bool IsMemberFunction,
2609  const CXXRecordDecl *RD,
2610  CharUnits NonVirtualBaseAdjustment,
2611  unsigned VBTableIndex) {
2612  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2613 
2614  // Single inheritance class member pointer are represented as scalars instead
2615  // of aggregates.
2616  if (MSInheritanceAttr::hasOnlyOneField(IsMemberFunction, Inheritance))
2617  return FirstField;
2618 
2620  fields.push_back(FirstField);
2621 
2622  if (MSInheritanceAttr::hasNVOffsetField(IsMemberFunction, Inheritance))
2623  fields.push_back(llvm::ConstantInt::get(
2624  CGM.IntTy, NonVirtualBaseAdjustment.getQuantity()));
2625 
2626  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) {
2627  CharUnits Offs = CharUnits::Zero();
2628  if (VBTableIndex)
2629  Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
2630  fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity()));
2631  }
2632 
2633  // The rest of the fields are adjusted by conversions to a more derived class.
2634  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2635  fields.push_back(llvm::ConstantInt::get(CGM.IntTy, VBTableIndex));
2636 
2637  return llvm::ConstantStruct::getAnon(fields);
2638 }
2639 
2640 llvm::Constant *
2641 MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
2642  CharUnits offset) {
2643  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2644  if (RD->getMSInheritanceModel() ==
2645  MSInheritanceAttr::Keyword_virtual_inheritance)
2646  offset -= getContext().getOffsetOfBaseWithVBPtr(RD);
2647  llvm::Constant *FirstField =
2648  llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity());
2649  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD,
2650  CharUnits::Zero(), /*VBTableIndex=*/0);
2651 }
2652 
2653 llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP,
2654  QualType MPType) {
2655  const MemberPointerType *DstTy = MPType->castAs<MemberPointerType>();
2656  const ValueDecl *MPD = MP.getMemberPointerDecl();
2657  if (!MPD)
2658  return EmitNullMemberPointer(DstTy);
2659 
2660  ASTContext &Ctx = getContext();
2661  ArrayRef<const CXXRecordDecl *> MemberPointerPath = MP.getMemberPointerPath();
2662 
2663  llvm::Constant *C;
2664  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) {
2665  C = EmitMemberFunctionPointer(MD);
2666  } else {
2667  CharUnits FieldOffset = Ctx.toCharUnitsFromBits(Ctx.getFieldOffset(MPD));
2668  C = EmitMemberDataPointer(DstTy, FieldOffset);
2669  }
2670 
2671  if (!MemberPointerPath.empty()) {
2672  const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext());
2673  const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr();
2674  const MemberPointerType *SrcTy =
2675  Ctx.getMemberPointerType(DstTy->getPointeeType(), SrcRecTy)
2676  ->castAs<MemberPointerType>();
2677 
2678  bool DerivedMember = MP.isMemberPointerToDerivedMember();
2679  SmallVector<const CXXBaseSpecifier *, 4> DerivedToBasePath;
2680  const CXXRecordDecl *PrevRD = SrcRD;
2681  for (const CXXRecordDecl *PathElem : MemberPointerPath) {
2682  const CXXRecordDecl *Base = nullptr;
2683  const CXXRecordDecl *Derived = nullptr;
2684  if (DerivedMember) {
2685  Base = PathElem;
2686  Derived = PrevRD;
2687  } else {
2688  Base = PrevRD;
2689  Derived = PathElem;
2690  }
2691  for (const CXXBaseSpecifier &BS : Derived->bases())
2692  if (BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() ==
2693  Base->getCanonicalDecl())
2694  DerivedToBasePath.push_back(&BS);
2695  PrevRD = PathElem;
2696  }
2697  assert(DerivedToBasePath.size() == MemberPointerPath.size());
2698 
2699  CastKind CK = DerivedMember ? CK_DerivedToBaseMemberPointer
2700  : CK_BaseToDerivedMemberPointer;
2701  C = EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(),
2702  DerivedToBasePath.end(), C);
2703  }
2704  return C;
2705 }
2706 
2707 llvm::Constant *
2708 MicrosoftCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
2709  assert(MD->isInstance() && "Member function must not be static!");
2710 
2711  MD = MD->getCanonicalDecl();
2712  CharUnits NonVirtualBaseAdjustment = CharUnits::Zero();
2713  const CXXRecordDecl *RD = MD->getParent()->getMostRecentDecl();
2714  CodeGenTypes &Types = CGM.getTypes();
2715 
2716  unsigned VBTableIndex = 0;
2717  llvm::Constant *FirstField;
2718  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
2719  if (!MD->isVirtual()) {
2720  llvm::Type *Ty;
2721  // Check whether the function has a computable LLVM signature.
2722  if (Types.isFuncTypeConvertible(FPT)) {
2723  // The function has a computable LLVM signature; use the correct type.
2724  Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
2725  } else {
2726  // Use an arbitrary non-function type to tell GetAddrOfFunction that the
2727  // function type is incomplete.
2728  Ty = CGM.PtrDiffTy;
2729  }
2730  FirstField = CGM.GetAddrOfFunction(MD, Ty);
2731  } else {
2732  auto &VTableContext = CGM.getMicrosoftVTableContext();
2734  VTableContext.getMethodVFTableLocation(MD);
2735  FirstField = EmitVirtualMemPtrThunk(MD, ML);
2736  // Include the vfptr adjustment if the method is in a non-primary vftable.
2737  NonVirtualBaseAdjustment += ML.VFPtrOffset;
2738  if (ML.VBase)
2739  VBTableIndex = VTableContext.getVBTableIndex(RD, ML.VBase) * 4;
2740  }
2741 
2742  if (VBTableIndex == 0 &&
2743  RD->getMSInheritanceModel() ==
2744  MSInheritanceAttr::Keyword_virtual_inheritance)
2745  NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD);
2746 
2747  // The rest of the fields are common with data member pointers.
2748  FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy);
2749  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD,
2750  NonVirtualBaseAdjustment, VBTableIndex);
2751 }
2752 
2753 /// Member pointers are the same if they're either bitwise identical *or* both
2754 /// null. Null-ness for function members is determined by the first field,
2755 /// while for data member pointers we must compare all fields.
2756 llvm::Value *
2757 MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
2758  llvm::Value *L,
2759  llvm::Value *R,
2760  const MemberPointerType *MPT,
2761  bool Inequality) {
2762  CGBuilderTy &Builder = CGF.Builder;
2763 
2764  // Handle != comparisons by switching the sense of all boolean operations.
2765  llvm::ICmpInst::Predicate Eq;
2766  llvm::Instruction::BinaryOps And, Or;
2767  if (Inequality) {
2768  Eq = llvm::ICmpInst::ICMP_NE;
2769  And = llvm::Instruction::Or;
2771  } else {
2772  Eq = llvm::ICmpInst::ICMP_EQ;
2773  And = llvm::Instruction::And;
2774  Or = llvm::Instruction::Or;
2775  }
2776 
2777  // If this is a single field member pointer (single inheritance), this is a
2778  // single icmp.
2779  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2780  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2781  if (MSInheritanceAttr::hasOnlyOneField(MPT->isMemberFunctionPointer(),
2782  Inheritance))
2783  return Builder.CreateICmp(Eq, L, R);
2784 
2785  // Compare the first field.
2786  llvm::Value *L0 = Builder.CreateExtractValue(L, 0, "lhs.0");
2787  llvm::Value *R0 = Builder.CreateExtractValue(R, 0, "rhs.0");
2788  llvm::Value *Cmp0 = Builder.CreateICmp(Eq, L0, R0, "memptr.cmp.first");
2789 
2790  // Compare everything other than the first field.
2791  llvm::Value *Res = nullptr;
2792  llvm::StructType *LType = cast<llvm::StructType>(L->getType());
2793  for (unsigned I = 1, E = LType->getNumElements(); I != E; ++I) {
2794  llvm::Value *LF = Builder.CreateExtractValue(L, I);
2795  llvm::Value *RF = Builder.CreateExtractValue(R, I);
2796  llvm::Value *Cmp = Builder.CreateICmp(Eq, LF, RF, "memptr.cmp.rest");
2797  if (Res)
2798  Res = Builder.CreateBinOp(And, Res, Cmp);
2799  else
2800  Res = Cmp;
2801  }
2802 
2803  // Check if the first field is 0 if this is a function pointer.
2804  if (MPT->isMemberFunctionPointer()) {
2805  // (l1 == r1 && ...) || l0 == 0
2806  llvm::Value *Zero = llvm::Constant::getNullValue(L0->getType());
2807  llvm::Value *IsZero = Builder.CreateICmp(Eq, L0, Zero, "memptr.cmp.iszero");
2808  Res = Builder.CreateBinOp(Or, Res, IsZero);
2809  }
2810 
2811  // Combine the comparison of the first field, which must always be true for
2812  // this comparison to succeeed.
2813  return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
2814 }
2815 
2816 llvm::Value *
2817 MicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
2818  llvm::Value *MemPtr,
2819  const MemberPointerType *MPT) {
2820  CGBuilderTy &Builder = CGF.Builder;
2822  // We only need one field for member functions.
2823  if (MPT->isMemberFunctionPointer())
2824  fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
2825  else
2826  GetNullMemberPointerFields(MPT, fields);
2827  assert(!fields.empty());
2828  llvm::Value *FirstField = MemPtr;
2829  if (MemPtr->getType()->isStructTy())
2830  FirstField = Builder.CreateExtractValue(MemPtr, 0);
2831  llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0], "memptr.cmp0");
2832 
2833  // For function member pointers, we only need to test the function pointer
2834  // field. The other fields if any can be garbage.
2835  if (MPT->isMemberFunctionPointer())
2836  return Res;
2837 
2838  // Otherwise, emit a series of compares and combine the results.
2839  for (int I = 1, E = fields.size(); I < E; ++I) {
2840  llvm::Value *Field = Builder.CreateExtractValue(MemPtr, I);
2841  llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I], "memptr.cmp");
2842  Res = Builder.CreateOr(Res, Next, "memptr.tobool");
2843  }
2844  return Res;
2845 }
2846 
2847 bool MicrosoftCXXABI::MemberPointerConstantIsNull(const MemberPointerType *MPT,
2848  llvm::Constant *Val) {
2849  // Function pointers are null if the pointer in the first field is null.
2850  if (MPT->isMemberFunctionPointer()) {
2851  llvm::Constant *FirstField = Val->getType()->isStructTy() ?
2852  Val->getAggregateElement(0U) : Val;
2853  return FirstField->isNullValue();
2854  }
2855 
2856  // If it's not a function pointer and it's zero initializable, we can easily
2857  // check zero.
2858  if (isZeroInitializable(MPT) && Val->isNullValue())
2859  return true;
2860 
2861  // Otherwise, break down all the fields for comparison. Hopefully these
2862  // little Constants are reused, while a big null struct might not be.
2864  GetNullMemberPointerFields(MPT, Fields);
2865  if (Fields.size() == 1) {
2866  assert(Val->getType()->isIntegerTy());
2867  return Val == Fields[0];
2868  }
2869 
2870  unsigned I, E;
2871  for (I = 0, E = Fields.size(); I != E; ++I) {
2872  if (Val->getAggregateElement(I) != Fields[I])
2873  break;
2874  }
2875  return I == E;
2876 }
2877 
2878 llvm::Value *
2879 MicrosoftCXXABI::GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
2880  Address This,
2881  llvm::Value *VBPtrOffset,
2882  llvm::Value *VBTableOffset,
2883  llvm::Value **VBPtrOut) {
2884  CGBuilderTy &Builder = CGF.Builder;
2885  // Load the vbtable pointer from the vbptr in the instance.
2886  This = Builder.CreateElementBitCast(This, CGM.Int8Ty);
2887  llvm::Value *VBPtr =
2888  Builder.CreateInBoundsGEP(This.getPointer(), VBPtrOffset, "vbptr");
2889  if (VBPtrOut) *VBPtrOut = VBPtr;
2890  VBPtr = Builder.CreateBitCast(VBPtr,
2891  CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace()));
2892 
2893  CharUnits VBPtrAlign;
2894  if (auto CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) {
2895  VBPtrAlign = This.getAlignment().alignmentAtOffset(
2896  CharUnits::fromQuantity(CI->getSExtValue()));
2897  } else {
2898  VBPtrAlign = CGF.getPointerAlign();
2899  }
2900 
2901  llvm::Value *VBTable = Builder.CreateAlignedLoad(VBPtr, VBPtrAlign, "vbtable");
2902 
2903  // Translate from byte offset to table index. It improves analyzability.
2904  llvm::Value *VBTableIndex = Builder.CreateAShr(
2905  VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2),
2906  "vbtindex", /*isExact=*/true);
2907 
2908  // Load an i32 offset from the vb-table.
2909  llvm::Value *VBaseOffs = Builder.CreateInBoundsGEP(VBTable, VBTableIndex);
2910  VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
2911  return Builder.CreateAlignedLoad(VBaseOffs, CharUnits::fromQuantity(4),
2912  "vbase_offs");
2913 }
2914 
2915 // Returns an adjusted base cast to i8*, since we do more address arithmetic on
2916 // it.
2917 llvm::Value *MicrosoftCXXABI::AdjustVirtualBase(
2918  CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD,
2919  Address Base, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) {
2920  CGBuilderTy &Builder = CGF.Builder;
2921  Base = Builder.CreateElementBitCast(Base, CGM.Int8Ty);
2922  llvm::BasicBlock *OriginalBB = nullptr;
2923  llvm::BasicBlock *SkipAdjustBB = nullptr;
2924  llvm::BasicBlock *VBaseAdjustBB = nullptr;
2925 
2926  // In the unspecified inheritance model, there might not be a vbtable at all,
2927  // in which case we need to skip the virtual base lookup. If there is a
2928  // vbtable, the first entry is a no-op entry that gives back the original
2929  // base, so look for a virtual base adjustment offset of zero.
2930  if (VBPtrOffset) {
2931  OriginalBB = Builder.GetInsertBlock();
2932  VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust");
2933  SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust");
2934  llvm::Value *IsVirtual =
2935  Builder.CreateICmpNE(VBTableOffset, getZeroInt(),
2936  "memptr.is_vbase");
2937  Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
2938  CGF.EmitBlock(VBaseAdjustBB);
2939  }
2940 
2941  // If we weren't given a dynamic vbptr offset, RD should be complete and we'll
2942  // know the vbptr offset.
2943  if (!VBPtrOffset) {
2944  CharUnits offs = CharUnits::Zero();
2945  if (!RD->hasDefinition()) {
2946  DiagnosticsEngine &Diags = CGF.CGM.getDiags();
2947  unsigned DiagID = Diags.getCustomDiagID(
2949  "member pointer representation requires a "
2950  "complete class type for %0 to perform this expression");
2951  Diags.Report(E->getExprLoc(), DiagID) << RD << E->getSourceRange();
2952  } else if (RD->getNumVBases())
2953  offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
2954  VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity());
2955  }
2956  llvm::Value *VBPtr = nullptr;
2957  llvm::Value *VBaseOffs =
2958  GetVBaseOffsetFromVBPtr(CGF, Base, VBPtrOffset, VBTableOffset, &VBPtr);
2959  llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs);
2960 
2961  // Merge control flow with the case where we didn't have to adjust.
2962  if (VBaseAdjustBB) {
2963  Builder.CreateBr(SkipAdjustBB);
2964  CGF.EmitBlock(SkipAdjustBB);
2965  llvm::PHINode *Phi = Builder.CreatePHI(CGM.Int8PtrTy, 2, "memptr.base");
2966  Phi->addIncoming(Base.getPointer(), OriginalBB);
2967  Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
2968  return Phi;
2969  }
2970  return AdjustedBase;
2971 }
2972 
2973 llvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress(
2974  CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
2975  const MemberPointerType *MPT) {
2976  assert(MPT->isMemberDataPointer());
2977  unsigned AS = Base.getAddressSpace();
2978  llvm::Type *PType =
2979  CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
2980  CGBuilderTy &Builder = CGF.Builder;
2981  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2982  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2983 
2984  // Extract the fields we need, regardless of model. We'll apply them if we
2985  // have them.
2986  llvm::Value *FieldOffset = MemPtr;
2987  llvm::Value *VirtualBaseAdjustmentOffset = nullptr;
2988  llvm::Value *VBPtrOffset = nullptr;
2989  if (MemPtr->getType()->isStructTy()) {
2990  // We need to extract values.
2991  unsigned I = 0;
2992  FieldOffset = Builder.CreateExtractValue(MemPtr, I++);
2993  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2994  VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
2995  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2996  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
2997  }
2998 
2999  llvm::Value *Addr;
3000  if (VirtualBaseAdjustmentOffset) {
3001  Addr = AdjustVirtualBase(CGF, E, RD, Base, VirtualBaseAdjustmentOffset,
3002  VBPtrOffset);
3003  } else {
3004  Addr = Base.getPointer();
3005  }
3006 
3007  // Cast to char*.
3008  Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS));
3009 
3010  // Apply the offset, which we assume is non-null.
3011  Addr = Builder.CreateInBoundsGEP(Addr, FieldOffset, "memptr.offset");
3012 
3013  // Cast the address to the appropriate pointer type, adopting the address
3014  // space of the base pointer.
3015  return Builder.CreateBitCast(Addr, PType);
3016 }
3017 
3018 llvm::Value *
3019 MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
3020  const CastExpr *E,
3021  llvm::Value *Src) {
3022  assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
3023  E->getCastKind() == CK_BaseToDerivedMemberPointer ||
3024  E->getCastKind() == CK_ReinterpretMemberPointer);
3025 
3026  // Use constant emission if we can.
3027  if (isa<llvm::Constant>(Src))
3028  return EmitMemberPointerConversion(E, cast<llvm::Constant>(Src));
3029 
3030  // We may be adding or dropping fields from the member pointer, so we need
3031  // both types and the inheritance models of both records.
3032  const MemberPointerType *SrcTy =
3034  const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
3035  bool IsFunc = SrcTy->isMemberFunctionPointer();
3036 
3037  // If the classes use the same null representation, reinterpret_cast is a nop.
3038  bool IsReinterpret = E->getCastKind() == CK_ReinterpretMemberPointer;
3039  if (IsReinterpret && IsFunc)
3040  return Src;
3041 
3042  CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl();
3043  CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl();
3044  if (IsReinterpret &&
3045  SrcRD->nullFieldOffsetIsZero() == DstRD->nullFieldOffsetIsZero())
3046  return Src;
3047 
3048  CGBuilderTy &Builder = CGF.Builder;
3049 
3050  // Branch past the conversion if Src is null.
3051  llvm::Value *IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy);
3052  llvm::Constant *DstNull = EmitNullMemberPointer(DstTy);
3053 
3054  // C++ 5.2.10p9: The null member pointer value is converted to the null member
3055  // pointer value of the destination type.
3056  if (IsReinterpret) {
3057  // For reinterpret casts, sema ensures that src and dst are both functions
3058  // or data and have the same size, which means the LLVM types should match.
3059  assert(Src->getType() == DstNull->getType());
3060  return Builder.CreateSelect(IsNotNull, Src, DstNull);
3061  }
3062 
3063  llvm::BasicBlock *OriginalBB = Builder.GetInsertBlock();
3064  llvm::BasicBlock *ConvertBB = CGF.createBasicBlock("memptr.convert");
3065  llvm::BasicBlock *ContinueBB = CGF.createBasicBlock("memptr.converted");
3066  Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB);
3067  CGF.EmitBlock(ConvertBB);
3068 
3069  llvm::Value *Dst = EmitNonNullMemberPointerConversion(
3070  SrcTy, DstTy, E->getCastKind(), E->path_begin(), E->path_end(), Src,
3071  Builder);
3072 
3073  Builder.CreateBr(ContinueBB);
3074 
3075  // In the continuation, choose between DstNull and Dst.
3076  CGF.EmitBlock(ContinueBB);
3077  llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted");
3078  Phi->addIncoming(DstNull, OriginalBB);
3079  Phi->addIncoming(Dst, ConvertBB);
3080  return Phi;
3081 }
3082 
3083 llvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion(
3084  const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK,
3087  CGBuilderTy &Builder) {
3088  const CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl();
3089  const CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl();
3090  MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel();
3091  MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel();
3092  bool IsFunc = SrcTy->isMemberFunctionPointer();
3093  bool IsConstant = isa<llvm::Constant>(Src);
3094 
3095  // Decompose src.
3096  llvm::Value *FirstField = Src;
3097  llvm::Value *NonVirtualBaseAdjustment = getZeroInt();
3098  llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt();
3099  llvm::Value *VBPtrOffset = getZeroInt();
3100  if (!MSInheritanceAttr::hasOnlyOneField(IsFunc, SrcInheritance)) {
3101  // We need to extract values.
3102  unsigned I = 0;
3103  FirstField = Builder.CreateExtractValue(Src, I++);
3104  if (MSInheritanceAttr::hasNVOffsetField(IsFunc, SrcInheritance))
3105  NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++);
3106  if (MSInheritanceAttr::hasVBPtrOffsetField(SrcInheritance))
3107  VBPtrOffset = Builder.CreateExtractValue(Src, I++);
3108  if (MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance))
3109  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++);
3110  }
3111 
3112  bool IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer);
3113  const MemberPointerType *DerivedTy = IsDerivedToBase ? SrcTy : DstTy;
3114  const CXXRecordDecl *DerivedClass = DerivedTy->getMostRecentCXXRecordDecl();
3115 
3116  // For data pointers, we adjust the field offset directly. For functions, we
3117  // have a separate field.
3118  llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField;
3119 
3120  // The virtual inheritance model has a quirk: the virtual base table is always
3121  // referenced when dereferencing a member pointer even if the member pointer
3122  // is non-virtual. This is accounted for by adjusting the non-virtual offset
3123  // to point backwards to the top of the MDC from the first VBase. Undo this
3124  // adjustment to normalize the member pointer.
3125  llvm::Value *SrcVBIndexEqZero =
3126  Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3127  if (SrcInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) {
3128  if (int64_t SrcOffsetToFirstVBase =
3129  getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) {
3130  llvm::Value *UndoSrcAdjustment = Builder.CreateSelect(
3131  SrcVBIndexEqZero,
3132  llvm::ConstantInt::get(CGM.IntTy, SrcOffsetToFirstVBase),
3133  getZeroInt());
3134  NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment);
3135  }
3136  }
3137 
3138  // A non-zero vbindex implies that we are dealing with a source member in a
3139  // floating virtual base in addition to some non-virtual offset. If the
3140  // vbindex is zero, we are dealing with a source that exists in a non-virtual,
3141  // fixed, base. The difference between these two cases is that the vbindex +
3142  // nvoffset *always* point to the member regardless of what context they are
3143  // evaluated in so long as the vbindex is adjusted. A member inside a fixed
3144  // base requires explicit nv adjustment.
3145  llvm::Constant *BaseClassOffset = llvm::ConstantInt::get(
3146  CGM.IntTy,
3147  CGM.computeNonVirtualBaseClassOffset(DerivedClass, PathBegin, PathEnd)
3148  .getQuantity());
3149 
3150  llvm::Value *NVDisp;
3151  if (IsDerivedToBase)
3152  NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset, "adj");
3153  else
3154  NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset, "adj");
3155 
3156  NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt());
3157 
3158  // Update the vbindex to an appropriate value in the destination because
3159  // SrcRD's vbtable might not be a strict prefix of the one in DstRD.
3160  llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero;
3161  if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance) &&
3162  MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) {
3163  if (llvm::GlobalVariable *VDispMap =
3164  getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) {
3165  llvm::Value *VBIndex = Builder.CreateExactUDiv(
3166  VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.IntTy, 4));
3167  if (IsConstant) {
3168  llvm::Constant *Mapping = VDispMap->getInitializer();
3169  VirtualBaseAdjustmentOffset =
3170  Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex));
3171  } else {
3172  llvm::Value *Idxs[] = {getZeroInt(), VBIndex};
3173  VirtualBaseAdjustmentOffset =
3174  Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(VDispMap, Idxs),
3176  }
3177 
3178  DstVBIndexEqZero =
3179  Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3180  }
3181  }
3182 
3183  // Set the VBPtrOffset to zero if the vbindex is zero. Otherwise, initialize
3184  // it to the offset of the vbptr.
3185  if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) {
3186  llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get(
3187  CGM.IntTy,
3188  getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity());
3189  VBPtrOffset =
3190  Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset);
3191  }
3192 
3193  // Likewise, apply a similar adjustment so that dereferencing the member
3194  // pointer correctly accounts for the distance between the start of the first
3195  // virtual base and the top of the MDC.
3196  if (DstInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) {
3197  if (int64_t DstOffsetToFirstVBase =
3198  getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) {
3199  llvm::Value *DoDstAdjustment = Builder.CreateSelect(
3200  DstVBIndexEqZero,
3201  llvm::ConstantInt::get(CGM.IntTy, DstOffsetToFirstVBase),
3202  getZeroInt());
3203  NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment);
3204  }
3205  }
3206 
3207  // Recompose dst from the null struct and the adjusted fields from src.
3208  llvm::Value *Dst;
3209  if (MSInheritanceAttr::hasOnlyOneField(IsFunc, DstInheritance)) {
3210  Dst = FirstField;
3211  } else {
3212  Dst = llvm::UndefValue::get(ConvertMemberPointerType(DstTy));
3213  unsigned Idx = 0;
3214  Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++);
3215  if (MSInheritanceAttr::hasNVOffsetField(IsFunc, DstInheritance))
3216  Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++);
3217  if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance))
3218  Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++);
3219  if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance))
3220  Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++);
3221  }
3222  return Dst;
3223 }
3224 
3225 llvm::Constant *
3226 MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E,
3227  llvm::Constant *Src) {
3228  const MemberPointerType *SrcTy =
3230  const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
3231 
3232  CastKind CK = E->getCastKind();
3233 
3234  return EmitMemberPointerConversion(SrcTy, DstTy, CK, E->path_begin(),
3235  E->path_end(), Src);
3236 }
3237 
3238 llvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion(
3239  const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK,
3241  CastExpr::path_const_iterator PathEnd, llvm::Constant *Src) {
3242  assert(CK == CK_DerivedToBaseMemberPointer ||
3243  CK == CK_BaseToDerivedMemberPointer ||
3244  CK == CK_ReinterpretMemberPointer);
3245  // If src is null, emit a new null for dst. We can't return src because dst
3246  // might have a new representation.
3247  if (MemberPointerConstantIsNull(SrcTy, Src))
3248  return EmitNullMemberPointer(DstTy);
3249 
3250  // We don't need to do anything for reinterpret_casts of non-null member
3251  // pointers. We should only get here when the two type representations have
3252  // the same size.
3253  if (CK == CK_ReinterpretMemberPointer)
3254  return Src;
3255 
3256  CGBuilderTy Builder(CGM, CGM.getLLVMContext());
3257  auto *Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion(
3258  SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder));
3259 
3260  return Dst;
3261 }
3262 
3263 CGCallee MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(
3264  CodeGenFunction &CGF, const Expr *E, Address This,
3265  llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,
3266  const MemberPointerType *MPT) {
3267  assert(MPT->isMemberFunctionPointer());
3268  const FunctionProtoType *FPT =
3270  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
3271  llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
3272  CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
3273  CGBuilderTy &Builder = CGF.Builder;
3274 
3275  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
3276 
3277  // Extract the fields we need, regardless of model. We'll apply them if we
3278  // have them.
3279  llvm::Value *FunctionPointer = MemPtr;
3280  llvm::Value *NonVirtualBaseAdjustment = nullptr;
3281  llvm::Value *VirtualBaseAdjustmentOffset = nullptr;
3282  llvm::Value *VBPtrOffset = nullptr;
3283  if (MemPtr->getType()->isStructTy()) {
3284  // We need to extract values.
3285  unsigned I = 0;
3286  FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);
3287  if (MSInheritanceAttr::hasNVOffsetField(MPT, Inheritance))
3288  NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);
3289  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
3290  VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
3291  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
3292  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
3293  }
3294 
3295  if (VirtualBaseAdjustmentOffset) {
3296  ThisPtrForCall = AdjustVirtualBase(CGF, E, RD, This,
3297  VirtualBaseAdjustmentOffset, VBPtrOffset);
3298  } else {
3299  ThisPtrForCall = This.getPointer();
3300  }
3301 
3302  if (NonVirtualBaseAdjustment) {
3303  // Apply the adjustment and cast back to the original struct type.
3304  llvm::Value *Ptr = Builder.CreateBitCast(ThisPtrForCall, CGF.Int8PtrTy);
3305  Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment);
3306  ThisPtrForCall = Builder.CreateBitCast(Ptr, ThisPtrForCall->getType(),
3307  "this.adjusted");
3308  }
3309 
3310  FunctionPointer =
3311  Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
3312  CGCallee Callee(FPT, FunctionPointer);
3313  return Callee;
3314 }
3315 
3317  return new MicrosoftCXXABI(CGM);
3318 }
3319 
3320 // MS RTTI Overview:
3321 // The run time type information emitted by cl.exe contains 5 distinct types of
3322 // structures. Many of them reference each other.
3323 //
3324 // TypeInfo: Static classes that are returned by typeid.
3325 //
3326 // CompleteObjectLocator: Referenced by vftables. They contain information
3327 // required for dynamic casting, including OffsetFromTop. They also contain
3328 // a reference to the TypeInfo for the type and a reference to the
3329 // CompleteHierarchyDescriptor for the type.
3330 //
3331 // ClassHieararchyDescriptor: Contains information about a class hierarchy.
3332 // Used during dynamic_cast to walk a class hierarchy. References a base
3333 // class array and the size of said array.
3334 //
3335 // BaseClassArray: Contains a list of classes in a hierarchy. BaseClassArray is
3336 // somewhat of a misnomer because the most derived class is also in the list
3337 // as well as multiple copies of virtual bases (if they occur multiple times
3338 // in the hiearchy.) The BaseClassArray contains one BaseClassDescriptor for
3339 // every path in the hierarchy, in pre-order depth first order. Note, we do
3340 // not declare a specific llvm type for BaseClassArray, it's merely an array
3341 // of BaseClassDescriptor pointers.
3342 //
3343 // BaseClassDescriptor: Contains information about a class in a class hierarchy.
3344 // BaseClassDescriptor is also somewhat of a misnomer for the same reason that
3345 // BaseClassArray is. It contains information about a class within a
3346 // hierarchy such as: is this base is ambiguous and what is its offset in the
3347 // vbtable. The names of the BaseClassDescriptors have all of their fields
3348 // mangled into them so they can be aggressively deduplicated by the linker.
3349 
3350 static llvm::GlobalVariable *getTypeInfoVTable(CodeGenModule &CGM) {
3351  StringRef MangledName("\01??_7type_info@@6B@");
3352  if (auto VTable = CGM.getModule().getNamedGlobal(MangledName))
3353  return VTable;
3354  return new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
3355  /*Constant=*/true,
3357  /*Initializer=*/nullptr, MangledName);
3358 }
3359 
3360 namespace {
3361 
3362 /// \brief A Helper struct that stores information about a class in a class
3363 /// hierarchy. The information stored in these structs struct is used during
3364 /// the generation of ClassHierarchyDescriptors and BaseClassDescriptors.
3365 // During RTTI creation, MSRTTIClasses are stored in a contiguous array with
3366 // implicit depth first pre-order tree connectivity. getFirstChild and
3367 // getNextSibling allow us to walk the tree efficiently.
3368 struct MSRTTIClass {
3369  enum {
3370  IsPrivateOnPath = 1 | 8,
3371  IsAmbiguous = 2,
3372  IsPrivate = 4,
3373  IsVirtual = 16,
3374  HasHierarchyDescriptor = 64
3375  };
3376  MSRTTIClass(const CXXRecordDecl *RD) : RD(RD) {}
3377  uint32_t initialize(const MSRTTIClass *Parent,
3378  const CXXBaseSpecifier *Specifier);
3379 
3380  MSRTTIClass *getFirstChild() { return this + 1; }
3381  static MSRTTIClass *getNextChild(MSRTTIClass *Child) {
3382  return Child + 1 + Child->NumBases;
3383  }
3384 
3385  const CXXRecordDecl *RD, *VirtualRoot;
3386  uint32_t Flags, NumBases, OffsetInVBase;
3387 };
3388 
3389 /// \brief Recursively initialize the base class array.
3390 uint32_t MSRTTIClass::initialize(const MSRTTIClass *Parent,
3391  const CXXBaseSpecifier *Specifier) {
3392  Flags = HasHierarchyDescriptor;
3393  if (!Parent) {
3394  VirtualRoot = nullptr;
3395  OffsetInVBase = 0;
3396  } else {
3397  if (Specifier->getAccessSpecifier() != AS_public)
3398  Flags |= IsPrivate | IsPrivateOnPath;
3399  if (Specifier->isVirtual()) {
3400  Flags |= IsVirtual;
3401  VirtualRoot = RD;
3402  OffsetInVBase = 0;
3403  } else {
3404  if (Parent->Flags & IsPrivateOnPath)
3405  Flags |= IsPrivateOnPath;
3406  VirtualRoot = Parent->VirtualRoot;
3407  OffsetInVBase = Parent->OffsetInVBase + RD->getASTContext()
3409  }
3410  }
3411  NumBases = 0;
3412  MSRTTIClass *Child = getFirstChild();
3413  for (const CXXBaseSpecifier &Base : RD->bases()) {
3414  NumBases += Child->initialize(this, &Base) + 1;
3415  Child = getNextChild(Child);
3416  }
3417  return NumBases;
3418 }
3419 
3420 static llvm::GlobalValue::LinkageTypes getLinkageForRTTI(QualType Ty) {
3421  switch (Ty->getLinkage()) {
3422  case NoLinkage:
3423  case InternalLinkage:
3424  case UniqueExternalLinkage:
3426 
3427  case VisibleNoLinkage:
3428  case ModuleInternalLinkage:
3429  case ModuleLinkage:
3430  case ExternalLinkage:
3431  return llvm::GlobalValue::LinkOnceODRLinkage;
3432  }
3433  llvm_unreachable("Invalid linkage!");
3434 }
3435 
3436 /// \brief An ephemeral helper class for building MS RTTI types. It caches some
3437 /// calls to the module and information about the most derived class in a
3438 /// hierarchy.
3439 struct MSRTTIBuilder {
3440  enum {
3441  HasBranchingHierarchy = 1,
3442  HasVirtualBranchingHierarchy = 2,
3443  HasAmbiguousBases = 4
3444  };
3445 
3446  MSRTTIBuilder(MicrosoftCXXABI &ABI, const CXXRecordDecl *RD)
3447  : CGM(ABI.CGM), Context(CGM.getContext()),
3448  VMContext(CGM.getLLVMContext()), Module(CGM.getModule()), RD(RD),
3449  Linkage(getLinkageForRTTI(CGM.getContext().getTagDeclType(RD))),
3450  ABI(ABI) {}
3451 
3452  llvm::GlobalVariable *getBaseClassDescriptor(const MSRTTIClass &Classes);
3453  llvm::GlobalVariable *
3454  getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes);
3455  llvm::GlobalVariable *getClassHierarchyDescriptor();
3456  llvm::GlobalVariable *getCompleteObjectLocator(const VPtrInfo &Info);
3457 
3458  CodeGenModule &CGM;
3459  ASTContext &Context;
3460  llvm::LLVMContext &VMContext;
3461  llvm::Module &Module;
3462  const CXXRecordDecl *RD;
3463  llvm::GlobalVariable::LinkageTypes Linkage;
3464  MicrosoftCXXABI &ABI;
3465 };
3466 
3467 } // namespace
3468 
3469 /// \brief Recursively serializes a class hierarchy in pre-order depth first
3470 /// order.
3472  const CXXRecordDecl *RD) {
3473  Classes.push_back(MSRTTIClass(RD));
3474  for (const CXXBaseSpecifier &Base : RD->bases())
3475  serializeClassHierarchy(Classes, Base.getType()->getAsCXXRecordDecl());
3476 }
3477 
3478 /// \brief Find ambiguity among base classes.
3479 static void
3481  llvm::SmallPtrSet<const CXXRecordDecl *, 8> VirtualBases;
3482  llvm::SmallPtrSet<const CXXRecordDecl *, 8> UniqueBases;
3483  llvm::SmallPtrSet<const CXXRecordDecl *, 8> AmbiguousBases;
3484  for (MSRTTIClass *Class = &Classes.front(); Class <= &Classes.back();) {
3485  if ((Class->Flags & MSRTTIClass::IsVirtual) &&
3486  !VirtualBases.insert(Class->RD).second) {
3487  Class = MSRTTIClass::getNextChild(Class);
3488  continue;
3489  }
3490  if (!UniqueBases.insert(Class->RD).second)
3491  AmbiguousBases.insert(Class->RD);
3492  Class++;
3493  }
3494  if (AmbiguousBases.empty())
3495  return;
3496  for (MSRTTIClass &Class : Classes)
3497  if (AmbiguousBases.count(Class.RD))
3498  Class.Flags |= MSRTTIClass::IsAmbiguous;
3499 }
3500 
3501 llvm::GlobalVariable *MSRTTIBuilder::getClassHierarchyDescriptor() {
3502  SmallString<256> MangledName;
3503  {
3504  llvm::raw_svector_ostream Out(MangledName);
3505  ABI.getMangleContext().mangleCXXRTTIClassHierarchyDescriptor(RD, Out);
3506  }
3507 
3508  // Check to see if we've already declared this ClassHierarchyDescriptor.
3509  if (auto CHD = Module.getNamedGlobal(MangledName))
3510  return CHD;
3511 
3512  // Serialize the class hierarchy and initialize the CHD Fields.
3514  serializeClassHierarchy(Classes, RD);
3515  Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr);
3516  detectAmbiguousBases(Classes);
3517  int Flags = 0;
3518  for (auto Class : Classes) {
3519  if (Class.RD->getNumBases() > 1)
3520  Flags |= HasBranchingHierarchy;
3521  // Note: cl.exe does not calculate "HasAmbiguousBases" correctly. We
3522  // believe the field isn't actually used.
3523  if (Class.Flags & MSRTTIClass::IsAmbiguous)
3524  Flags |= HasAmbiguousBases;
3525  }
3526  if ((Flags & HasBranchingHierarchy) && RD->getNumVBases() != 0)
3527  Flags |= HasVirtualBranchingHierarchy;
3528  // These gep indices are used to get the address of the first element of the
3529  // base class array.
3530  llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0),
3531  llvm::ConstantInt::get(CGM.IntTy, 0)};
3532 
3533  // Forward-declare the class hierarchy descriptor
3534  auto Type = ABI.getClassHierarchyDescriptorType();
3535  auto CHD = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3536  /*Initializer=*/nullptr,
3537  MangledName);
3538  if (CHD->isWeakForLinker())
3539  CHD->setComdat(CGM.getModule().getOrInsertComdat(CHD->getName()));
3540 
3541  auto *Bases = getBaseClassArray(Classes);
3542 
3543  // Initialize the base class ClassHierarchyDescriptor.
3544  llvm::Constant *Fields[] = {
3545  llvm::ConstantInt::get(CGM.IntTy, 0), // reserved by the runtime
3546  llvm::ConstantInt::get(CGM.IntTy, Flags),
3547  llvm::ConstantInt::get(CGM.IntTy, Classes.size()),
3548  ABI.getImageRelativeConstant(llvm::ConstantExpr::getInBoundsGetElementPtr(
3549  Bases->getValueType(), Bases,
3550  llvm::ArrayRef<llvm::Value *>(GEPIndices))),
3551  };
3552  CHD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
3553  return CHD;
3554 }
3555 
3556 llvm::GlobalVariable *
3557 MSRTTIBuilder::getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes) {
3558  SmallString<256> MangledName;
3559  {
3560  llvm::raw_svector_ostream Out(MangledName);
3561  ABI.getMangleContext().mangleCXXRTTIBaseClassArray(RD, Out);
3562  }
3563 
3564  // Forward-declare the base class array.
3565  // cl.exe pads the base class array with 1 (in 32 bit mode) or 4 (in 64 bit
3566  // mode) bytes of padding. We provide a pointer sized amount of padding by
3567  // adding +1 to Classes.size(). The sections have pointer alignment and are
3568  // marked pick-any so it shouldn't matter.
3569  llvm::Type *PtrType = ABI.getImageRelativeType(
3570  ABI.getBaseClassDescriptorType()->getPointerTo());
3571  auto *ArrType = llvm::ArrayType::get(PtrType, Classes.size() + 1);
3572  auto *BCA =
3573  new llvm::GlobalVariable(Module, ArrType,
3574  /*Constant=*/true, Linkage,
3575  /*Initializer=*/nullptr, MangledName);
3576  if (BCA->isWeakForLinker())
3577  BCA->setComdat(CGM.getModule().getOrInsertComdat(BCA->getName()));
3578 
3579  // Initialize the BaseClassArray.
3580  SmallVector<llvm::Constant *, 8> BaseClassArrayData;
3581  for (MSRTTIClass &Class : Classes)
3582  BaseClassArrayData.push_back(
3583  ABI.getImageRelativeConstant(getBaseClassDescriptor(Class)));
3584  BaseClassArrayData.push_back(llvm::Constant::getNullValue(PtrType));
3585  BCA->setInitializer(llvm::ConstantArray::get(ArrType, BaseClassArrayData));
3586  return BCA;
3587 }
3588 
3589 llvm::GlobalVariable *
3590 MSRTTIBuilder::getBaseClassDescriptor(const MSRTTIClass &Class) {
3591  // Compute the fields for the BaseClassDescriptor. They are computed up front
3592  // because they are mangled into the name of the object.
3593  uint32_t OffsetInVBTable = 0;
3594  int32_t VBPtrOffset = -1;
3595  if (Class.VirtualRoot) {
3596  auto &VTableContext = CGM.getMicrosoftVTableContext();
3597  OffsetInVBTable = VTableContext.getVBTableIndex(RD, Class.VirtualRoot) * 4;
3598  VBPtrOffset = Context.getASTRecordLayout(RD).getVBPtrOffset().getQuantity();
3599  }
3600 
3601  SmallString<256> MangledName;
3602  {
3603  llvm::raw_svector_ostream Out(MangledName);
3604  ABI.getMangleContext().mangleCXXRTTIBaseClassDescriptor(
3605  Class.RD, Class.OffsetInVBase, VBPtrOffset, OffsetInVBTable,
3606  Class.Flags, Out);
3607  }
3608 
3609  // Check to see if we've already declared this object.
3610  if (auto BCD = Module.getNamedGlobal(MangledName))
3611  return BCD;
3612 
3613  // Forward-declare the base class descriptor.
3614  auto Type = ABI.getBaseClassDescriptorType();
3615  auto BCD =
3616  new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3617  /*Initializer=*/nullptr, MangledName);
3618  if (BCD->isWeakForLinker())
3619  BCD->setComdat(CGM.getModule().getOrInsertComdat(BCD->getName()));
3620 
3621  // Initialize the BaseClassDescriptor.
3622  llvm::Constant *Fields[] = {
3623  ABI.getImageRelativeConstant(
3624  ABI.getAddrOfRTTIDescriptor(Context.getTypeDeclType(Class.RD))),
3625  llvm::ConstantInt::get(CGM.IntTy, Class.NumBases),
3626  llvm::ConstantInt::get(CGM.IntTy, Class.OffsetInVBase),
3627  llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),
3628  llvm::ConstantInt::get(CGM.IntTy, OffsetInVBTable),
3629  llvm::ConstantInt::get(CGM.IntTy, Class.Flags),
3630  ABI.getImageRelativeConstant(
3631  MSRTTIBuilder(ABI, Class.RD).getClassHierarchyDescriptor()),
3632  };
3633  BCD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
3634  return BCD;
3635 }
3636 
3637 llvm::GlobalVariable *
3638 MSRTTIBuilder::getCompleteObjectLocator(const VPtrInfo &Info) {
3639  SmallString<256> MangledName;
3640  {
3641  llvm::raw_svector_ostream Out(MangledName);
3642  ABI.getMangleContext().mangleCXXRTTICompleteObjectLocator(RD, Info.MangledPath, Out);
3643  }
3644 
3645  // Check to see if we've already computed this complete object locator.
3646  if (auto COL = Module.getNamedGlobal(MangledName))
3647  return COL;
3648 
3649  // Compute the fields of the complete object locator.
3650  int OffsetToTop = Info.FullOffsetInMDC.getQuantity();
3651  int VFPtrOffset = 0;
3652  // The offset includes the vtordisp if one exists.
3653  if (const CXXRecordDecl *VBase = Info.getVBaseWithVPtr())
3654  if (Context.getASTRecordLayout(RD)
3656  .find(VBase)
3657  ->second.hasVtorDisp())
3658  VFPtrOffset = Info.NonVirtualOffset.getQuantity() + 4;
3659 
3660  // Forward-declare the complete object locator.
3661  llvm::StructType *Type = ABI.getCompleteObjectLocatorType();
3662  auto COL = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3663  /*Initializer=*/nullptr, MangledName);
3664 
3665  // Initialize the CompleteObjectLocator.
3666  llvm::Constant *Fields[] = {
3667  llvm::ConstantInt::get(CGM.IntTy, ABI.isImageRelative()),
3668  llvm::ConstantInt::get(CGM.IntTy, OffsetToTop),
3669  llvm::ConstantInt::get(CGM.IntTy, VFPtrOffset),
3670  ABI.getImageRelativeConstant(
3671  CGM.GetAddrOfRTTIDescriptor(Context.getTypeDeclType(RD))),
3672  ABI.getImageRelativeConstant(getClassHierarchyDescriptor()),
3673  ABI.getImageRelativeConstant(COL),
3674  };
3675  llvm::ArrayRef<llvm::Constant *> FieldsRef(Fields);
3676  if (!ABI.isImageRelative())
3677  FieldsRef = FieldsRef.drop_back();
3678  COL->setInitializer(llvm::ConstantStruct::get(Type, FieldsRef));
3679  if (COL->isWeakForLinker())
3680  COL->setComdat(CGM.getModule().getOrInsertComdat(COL->getName()));
3681  return COL;
3682 }
3683 
3685  bool &IsConst, bool &IsVolatile,
3686  bool &IsUnaligned) {
3687  T = Context.getExceptionObjectType(T);
3688 
3689  // C++14 [except.handle]p3:
3690  // A handler is a match for an exception object of type E if [...]
3691  // - the handler is of type cv T or const T& where T is a pointer type and
3692  // E is a pointer type that can be converted to T by [...]
3693  // - a qualification conversion
3694  IsConst = false;
3695  IsVolatile = false;
3696  IsUnaligned = false;
3697  QualType PointeeType = T->getPointeeType();
3698  if (!PointeeType.isNull()) {
3699  IsConst = PointeeType.isConstQualified();
3700  IsVolatile = PointeeType.isVolatileQualified();
3701  IsUnaligned = PointeeType.getQualifiers().hasUnaligned();
3702  }
3703 
3704  // Member pointer types like "const int A::*" are represented by having RTTI
3705  // for "int A::*" and separately storing the const qualifier.
3706  if (const auto *MPTy = T->getAs<MemberPointerType>())
3707  T = Context.getMemberPointerType(PointeeType.getUnqualifiedType(),
3708  MPTy->getClass());
3709 
3710  // Pointer types like "const int * const *" are represented by having RTTI
3711  // for "const int **" and separately storing the const qualifier.
3712  if (T->isPointerType())
3713  T = Context.getPointerType(PointeeType.getUnqualifiedType());
3714 
3715  return T;
3716 }
3717 
3719 MicrosoftCXXABI::getAddrOfCXXCatchHandlerType(QualType Type,
3720  QualType CatchHandlerType) {
3721  // TypeDescriptors for exceptions never have qualified pointer types,
3722  // qualifiers are stored separately in order to support qualification
3723  // conversions.
3724  bool IsConst, IsVolatile, IsUnaligned;
3725  Type =
3726  decomposeTypeForEH(getContext(), Type, IsConst, IsVolatile, IsUnaligned);
3727 
3728  bool IsReference = CatchHandlerType->isReferenceType();
3729 
3730  uint32_t Flags = 0;
3731  if (IsConst)
3732  Flags |= 1;
3733  if (IsVolatile)
3734  Flags |= 2;
3735  if (IsUnaligned)
3736  Flags |= 4;
3737  if (IsReference)
3738  Flags |= 8;
3739 
3740  return CatchTypeInfo{getAddrOfRTTIDescriptor(Type)->stripPointerCasts(),
3741  Flags};
3742 }
3743 
3744 /// \brief Gets a TypeDescriptor. Returns a llvm::Constant * rather than a
3745 /// llvm::GlobalVariable * because different type descriptors have different
3746 /// types, and need to be abstracted. They are abstracting by casting the
3747 /// address to an Int8PtrTy.
3748 llvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(QualType Type) {
3749  SmallString<256> MangledName;
3750  {
3751  llvm::raw_svector_ostream Out(MangledName);
3752  getMangleContext().mangleCXXRTTI(Type, Out);
3753  }
3754 
3755  // Check to see if we've already declared this TypeDescriptor.
3756  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
3757  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3758 
3759  // Note for the future: If we would ever like to do deferred emission of
3760  // RTTI, check if emitting vtables opportunistically need any adjustment.
3761 
3762  // Compute the fields for the TypeDescriptor.
3763  SmallString<256> TypeInfoString;
3764  {
3765  llvm::raw_svector_ostream Out(TypeInfoString);
3766  getMangleContext().mangleCXXRTTIName(Type, Out);
3767  }
3768 
3769  // Declare and initialize the TypeDescriptor.
3770  llvm::Constant *Fields[] = {
3771  getTypeInfoVTable(CGM), // VFPtr
3772  llvm::ConstantPointerNull::get(CGM.Int8PtrTy), // Runtime data
3773  llvm::ConstantDataArray::getString(CGM.getLLVMContext(), TypeInfoString)};
3774  llvm::StructType *TypeDescriptorType =
3775  getTypeDescriptorType(TypeInfoString);
3776  auto *Var = new llvm::GlobalVariable(
3777  CGM.getModule(), TypeDescriptorType, /*Constant=*/false,
3778  getLinkageForRTTI(Type),
3779  llvm::ConstantStruct::get(TypeDescriptorType, Fields),
3780  MangledName);
3781  if (Var->isWeakForLinker())
3782  Var->setComdat(CGM.getModule().getOrInsertComdat(Var->getName()));
3783  return llvm::ConstantExpr::getBitCast(Var, CGM.Int8PtrTy);
3784 }
3785 
3786 /// \brief Gets or a creates a Microsoft CompleteObjectLocator.
3787 llvm::GlobalVariable *
3788 MicrosoftCXXABI::getMSCompleteObjectLocator(const CXXRecordDecl *RD,
3789  const VPtrInfo &Info) {
3790  return MSRTTIBuilder(*this, RD).getCompleteObjectLocator(Info);
3791 }
3792 
3794  const CXXConstructorDecl *ctor,
3795  StructorType ctorType) {
3796  // There are no constructor variants, always emit the complete destructor.
3797  llvm::Function *Fn = CGM.codegenCXXStructor(ctor, StructorType::Complete);
3798  CGM.maybeSetTrivialComdat(*ctor, *Fn);
3799 }
3800 
3801 static void emitCXXDestructor(CodeGenModule &CGM, const CXXDestructorDecl *dtor,
3802  StructorType dtorType) {
3803  // The complete destructor is equivalent to the base destructor for
3804  // classes with no virtual bases, so try to emit it as an alias.
3805  if (!dtor->getParent()->getNumVBases() &&
3806  (dtorType == StructorType::Complete || dtorType == StructorType::Base)) {
3807  bool ProducedAlias = !CGM.TryEmitDefinitionAsAlias(
3808  GlobalDecl(dtor, Dtor_Complete), GlobalDecl(dtor, Dtor_Base));
3809  if (ProducedAlias) {
3810  if (dtorType == StructorType::Complete)
3811  return;
3812  if (dtor->isVirtual())
3814  }
3815  }
3816 
3817  // The base destructor is equivalent to the base destructor of its
3818  // base class if there is exactly one non-virtual base class with a
3819  // non-trivial destructor, there are no fields with a non-trivial
3820  // destructor, and the body of the destructor is trivial.
3821  if (dtorType == StructorType::Base && !CGM.TryEmitBaseDestructorAsAlias(dtor))
3822  return;
3823 
3824  llvm::Function *Fn = CGM.codegenCXXStructor(dtor, dtorType);
3825  if (Fn->isWeakForLinker())
3826  Fn->setComdat(CGM.getModule().getOrInsertComdat(Fn->getName()));
3827 }
3828 
3829 void MicrosoftCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3830  StructorType Type) {
3831  if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
3832  emitCXXConstructor(CGM, CD, Type);
3833  return;
3834  }
3835  emitCXXDestructor(CGM, cast<CXXDestructorDecl>(MD), Type);
3836 }
3837 
3838 llvm::Function *
3839 MicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,
3840  CXXCtorType CT) {
3841  assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure);
3842 
3843  // Calculate the mangled name.
3844  SmallString<256> ThunkName;
3845  llvm::raw_svector_ostream Out(ThunkName);
3846  getMangleContext().mangleCXXCtor(CD, CT, Out);
3847 
3848  // If the thunk has been generated previously, just return it.
3849  if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName))
3850  return cast<llvm::Function>(GV);
3851 
3852  // Create the llvm::Function.
3853  const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSCtorClosure(CD, CT);
3854  llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
3855  const CXXRecordDecl *RD = CD->getParent();
3856  QualType RecordTy = getContext().getRecordType(RD);
3857  llvm::Function *ThunkFn = llvm::Function::Create(
3858  ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.getModule());
3859  ThunkFn->setCallingConv(static_cast<llvm::CallingConv::ID>(
3860  FnInfo.getEffectiveCallingConvention()));
3861  if (ThunkFn->isWeakForLinker())
3862  ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
3863  bool IsCopy = CT == Ctor_CopyingClosure;
3864 
3865  // Start codegen.
3866  CodeGenFunction CGF(CGM);
3867  CGF.CurGD = GlobalDecl(CD, Ctor_Complete);
3868 
3869  // Build FunctionArgs.
3870  FunctionArgList FunctionArgs;
3871 
3872  // A constructor always starts with a 'this' pointer as its first argument.
3873  buildThisParam(CGF, FunctionArgs);
3874 
3875  // Following the 'this' pointer is a reference to the source object that we
3876  // are copying from.
3877  ImplicitParamDecl SrcParam(
3878  getContext(), /*DC=*/nullptr, SourceLocation(),
3879  &getContext().Idents.get("src"),
3880  getContext().getLValueReferenceType(RecordTy,
3881  /*SpelledAsLValue=*/true),
3883  if (IsCopy)
3884  FunctionArgs.push_back(&SrcParam);
3885 
3886  // Constructors for classes which utilize virtual bases have an additional
3887  // parameter which indicates whether or not it is being delegated to by a more
3888  // derived constructor.
3889  ImplicitParamDecl IsMostDerived(getContext(), /*DC=*/nullptr,
3890  SourceLocation(),
3891  &getContext().Idents.get("is_most_derived"),
3892  getContext().IntTy, ImplicitParamDecl::Other);
3893  // Only add the parameter to the list if thie class has virtual bases.
3894  if (RD->getNumVBases() > 0)
3895  FunctionArgs.push_back(&IsMostDerived);
3896 
3897  // Start defining the function.
3898  auto NL = ApplyDebugLocation::CreateEmpty(CGF);
3899  CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
3900  FunctionArgs, CD->getLocation(), SourceLocation());
3901  // Create a scope with an artificial location for the body of this function.
3902  auto AL = ApplyDebugLocation::CreateArtificial(CGF);
3903  EmitThisParam(CGF);
3904  llvm::Value *This = getThisValue(CGF);
3905 
3906  llvm::Value *SrcVal =
3907  IsCopy ? CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&SrcParam), "src")
3908  : nullptr;
3909 
3910  CallArgList Args;
3911 
3912  // Push the this ptr.
3913  Args.add(RValue::get(This), CD->getThisType(getContext()));
3914 
3915  // Push the src ptr.
3916  if (SrcVal)
3917  Args.add(RValue::get(SrcVal), SrcParam.getType());
3918 
3919  // Add the rest of the default arguments.
3921  ArrayRef<ParmVarDecl *> params = CD->parameters().drop_front(IsCopy ? 1 : 0);
3922  for (const ParmVarDecl *PD : params) {
3923  assert(PD->hasDefaultArg() && "ctor closure lacks default args");
3924  ArgVec.push_back(PD->getDefaultArg());
3925  }
3926 
3927  CodeGenFunction::RunCleanupsScope Cleanups(CGF);
3928 
3929  const auto *FPT = CD->getType()->castAs<FunctionProtoType>();
3930  CGF.EmitCallArgs(Args, FPT, llvm::makeArrayRef(ArgVec), CD, IsCopy ? 1 : 0);
3931 
3932  // Insert any ABI-specific implicit constructor arguments.
3933  AddedStructorArgs ExtraArgs =
3934  addImplicitConstructorArgs(CGF, CD, Ctor_Complete,
3935  /*ForVirtualBase=*/false,
3936  /*Delegating=*/false, Args);
3937  // Call the destructor with our arguments.
3938  llvm::Constant *CalleePtr =
3940  CGCallee Callee = CGCallee::forDirect(CalleePtr, CD);
3941  const CGFunctionInfo &CalleeInfo = CGM.getTypes().arrangeCXXConstructorCall(
3942  Args, CD, Ctor_Complete, ExtraArgs.Prefix, ExtraArgs.Suffix);
3943  CGF.EmitCall(CalleeInfo, Callee, ReturnValueSlot(), Args);
3944 
3945  Cleanups.ForceCleanup();
3946 
3947  // Emit the ret instruction, remove any temporary instructions created for the
3948  // aid of CodeGen.
3950 
3951  return ThunkFn;
3952 }
3953 
3954 llvm::Constant *MicrosoftCXXABI::getCatchableType(QualType T,
3955  uint32_t NVOffset,
3956  int32_t VBPtrOffset,
3957  uint32_t VBIndex) {
3958  assert(!T->isReferenceType());
3959 
3960  CXXRecordDecl *RD = T->getAsCXXRecordDecl();
3961  const CXXConstructorDecl *CD =
3962  RD ? CGM.getContext().getCopyConstructorForExceptionObject(RD) : nullptr;
3964  if (CD)
3965  if (!hasDefaultCXXMethodCC(getContext(), CD) || CD->getNumParams() != 1)
3966  CT = Ctor_CopyingClosure;
3967 
3968  uint32_t Size = getContext().getTypeSizeInChars(T).getQuantity();
3969  SmallString<256> MangledName;
3970  {
3971  llvm::raw_svector_ostream Out(MangledName);
3972  getMangleContext().mangleCXXCatchableType(T, CD, CT, Size, NVOffset,
3973  VBPtrOffset, VBIndex, Out);
3974  }
3975  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
3976  return getImageRelativeConstant(GV);
3977 
3978  // The TypeDescriptor is used by the runtime to determine if a catch handler
3979  // is appropriate for the exception object.
3980  llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(T));
3981 
3982  // The runtime is responsible for calling the copy constructor if the
3983  // exception is caught by value.
3984  llvm::Constant *CopyCtor;
3985  if (CD) {
3986  if (CT == Ctor_CopyingClosure)
3987  CopyCtor = getAddrOfCXXCtorClosure(CD, Ctor_CopyingClosure);
3988  else
3989  CopyCtor = CGM.getAddrOfCXXStructor(CD, StructorType::Complete);
3990 
3991  CopyCtor = llvm::ConstantExpr::getBitCast(CopyCtor, CGM.Int8PtrTy);
3992  } else {
3993  CopyCtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3994  }
3995  CopyCtor = getImageRelativeConstant(CopyCtor);
3996 
3997  bool IsScalar = !RD;
3998  bool HasVirtualBases = false;
3999  bool IsStdBadAlloc = false; // std::bad_alloc is special for some reason.
4000  QualType PointeeType = T;
4001  if (T->isPointerType())
4002  PointeeType = T->getPointeeType();
4003  if (const CXXRecordDecl *RD = PointeeType->getAsCXXRecordDecl()) {
4004  HasVirtualBases = RD->getNumVBases() > 0;
4005  if (IdentifierInfo *II = RD->getIdentifier())
4006  IsStdBadAlloc = II->isStr("bad_alloc") && RD->isInStdNamespace();
4007  }
4008 
4009  // Encode the relevant CatchableType properties into the Flags bitfield.
4010  // FIXME: Figure out how bits 2 or 8 can get set.
4011  uint32_t Flags = 0;
4012  if (IsScalar)
4013  Flags |= 1;
4014  if (HasVirtualBases)
4015  Flags |= 4;
4016  if (IsStdBadAlloc)
4017  Flags |= 16;
4018 
4019  llvm::Constant *Fields[] = {
4020  llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
4021  TD, // TypeDescriptor
4022  llvm::ConstantInt::get(CGM.IntTy, NVOffset), // NonVirtualAdjustment
4023  llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), // OffsetToVBPtr
4024  llvm::ConstantInt::get(CGM.IntTy, VBIndex), // VBTableIndex
4025  llvm::ConstantInt::get(CGM.IntTy, Size), // Size
4026  CopyCtor // CopyCtor
4027  };
4028  llvm::StructType *CTType = getCatchableTypeType();
4029  auto *GV = new llvm::GlobalVariable(
4030  CGM.getModule(), CTType, /*Constant=*/true, getLinkageForRTTI(T),
4031  llvm::ConstantStruct::get(CTType, Fields), MangledName);
4032  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4033  GV->setSection(".xdata");
4034  if (GV->isWeakForLinker())
4035  GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName()));
4036  return getImageRelativeConstant(GV);
4037 }
4038 
4039 llvm::GlobalVariable *MicrosoftCXXABI::getCatchableTypeArray(QualType T) {
4040  assert(!T->isReferenceType());
4041 
4042  // See if we've already generated a CatchableTypeArray for this type before.
4043  llvm::GlobalVariable *&CTA = CatchableTypeArrays[T];
4044  if (CTA)
4045  return CTA;
4046 
4047  // Ensure that we don't have duplicate entries in our CatchableTypeArray by
4048  // using a SmallSetVector. Duplicates may arise due to virtual bases
4049  // occurring more than once in the hierarchy.
4051 
4052  // C++14 [except.handle]p3:
4053  // A handler is a match for an exception object of type E if [...]
4054  // - the handler is of type cv T or cv T& and T is an unambiguous public
4055  // base class of E, or
4056  // - the handler is of type cv T or const T& where T is a pointer type and
4057  // E is a pointer type that can be converted to T by [...]
4058  // - a standard pointer conversion (4.10) not involving conversions to
4059  // pointers to private or protected or ambiguous classes
4060  const CXXRecordDecl *MostDerivedClass = nullptr;
4061  bool IsPointer = T->isPointerType();
4062  if (IsPointer)
4063  MostDerivedClass = T->getPointeeType()->getAsCXXRecordDecl();
4064  else
4065  MostDerivedClass = T->getAsCXXRecordDecl();
4066 
4067  // Collect all the unambiguous public bases of the MostDerivedClass.
4068  if (MostDerivedClass) {
4069  const ASTContext &Context = getContext();
4070  const ASTRecordLayout &MostDerivedLayout =
4071  Context.getASTRecordLayout(MostDerivedClass);
4072  MicrosoftVTableContext &VTableContext = CGM.getMicrosoftVTableContext();
4074  serializeClassHierarchy(Classes, MostDerivedClass);
4075  Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr);
4076  detectAmbiguousBases(Classes);
4077  for (const MSRTTIClass &Class : Classes) {
4078  // Skip any ambiguous or private bases.
4079  if (Class.Flags &
4080  (MSRTTIClass::IsPrivateOnPath | MSRTTIClass::IsAmbiguous))
4081  continue;
4082  // Write down how to convert from a derived pointer to a base pointer.
4083  uint32_t OffsetInVBTable = 0;
4084  int32_t VBPtrOffset = -1;
4085  if (Class.VirtualRoot) {
4086  OffsetInVBTable =
4087  VTableContext.getVBTableIndex(MostDerivedClass, Class.VirtualRoot)*4;
4088  VBPtrOffset = MostDerivedLayout.getVBPtrOffset().getQuantity();
4089  }
4090 
4091  // Turn our record back into a pointer if the exception object is a
4092  // pointer.
4093  QualType RTTITy = QualType(Class.RD->getTypeForDecl(), 0);
4094  if (IsPointer)
4095  RTTITy = Context.getPointerType(RTTITy);
4096  CatchableTypes.insert(getCatchableType(RTTITy, Class.OffsetInVBase,
4097  VBPtrOffset, OffsetInVBTable));
4098  }
4099  }
4100 
4101  // C++14 [except.handle]p3:
4102  // A handler is a match for an exception object of type E if
4103  // - The handler is of type cv T or cv T& and E and T are the same type
4104  // (ignoring the top-level cv-qualifiers)
4105  CatchableTypes.insert(getCatchableType(T));
4106 
4107  // C++14 [except.handle]p3:
4108  // A handler is a match for an exception object of type E if
4109  // - the handler is of type cv T or const T& where T is a pointer type and
4110  // E is a pointer type that can be converted to T by [...]
4111  // - a standard pointer conversion (4.10) not involving conversions to
4112  // pointers to private or protected or ambiguous classes
4113  //
4114  // C++14 [conv.ptr]p2:
4115  // A prvalue of type "pointer to cv T," where T is an object type, can be
4116  // converted to a prvalue of type "pointer to cv void".
4117  if (IsPointer && T->getPointeeType()->isObjectType())
4118  CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4119 
4120  // C++14 [except.handle]p3:
4121  // A handler is a match for an exception object of type E if [...]
4122  // - the handler is of type cv T or const T& where T is a pointer or
4123  // pointer to member type and E is std::nullptr_t.
4124  //
4125  // We cannot possibly list all possible pointer types here, making this
4126  // implementation incompatible with the standard. However, MSVC includes an
4127  // entry for pointer-to-void in this case. Let's do the same.
4128  if (T->isNullPtrType())
4129  CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4130 
4131  uint32_t NumEntries = CatchableTypes.size();
4132  llvm::Type *CTType =
4133  getImageRelativeType(getCatchableTypeType()->getPointerTo());
4134  llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries);
4135  llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries);
4136  llvm::Constant *Fields[] = {
4137  llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries
4138  llvm::ConstantArray::get(
4139  AT, llvm::makeArrayRef(CatchableTypes.begin(),
4140  CatchableTypes.end())) // CatchableTypes
4141  };
4142  SmallString<256> MangledName;
4143  {
4144  llvm::raw_svector_ostream Out(MangledName);
4145  getMangleContext().mangleCXXCatchableTypeArray(T, NumEntries, Out);
4146  }
4147  CTA = new llvm::GlobalVariable(
4148  CGM.getModule(), CTAType, /*Constant=*/true, getLinkageForRTTI(T),
4149  llvm::ConstantStruct::get(CTAType, Fields), MangledName);
4150  CTA->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4151  CTA->setSection(".xdata");
4152  if (CTA->isWeakForLinker())
4153  CTA->setComdat(CGM.getModule().getOrInsertComdat(CTA->getName()));
4154  return CTA;
4155 }
4156 
4157 llvm::GlobalVariable *MicrosoftCXXABI::getThrowInfo(QualType T) {
4158  bool IsConst, IsVolatile, IsUnaligned;
4159  T = decomposeTypeForEH(getContext(), T, IsConst, IsVolatile, IsUnaligned);
4160 
4161  // The CatchableTypeArray enumerates the various (CV-unqualified) types that
4162  // the exception object may be caught as.
4163  llvm::GlobalVariable *CTA = getCatchableTypeArray(T);
4164  // The first field in a CatchableTypeArray is the number of CatchableTypes.
4165  // This is used as a component of the mangled name which means that we need to
4166  // know what it is in order to see if we have previously generated the
4167  // ThrowInfo.
4168  uint32_t NumEntries =
4169  cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0U))
4170  ->getLimitedValue();
4171 
4172  SmallString<256> MangledName;
4173  {
4174  llvm::raw_svector_ostream Out(MangledName);
4175  getMangleContext().mangleCXXThrowInfo(T, IsConst, IsVolatile, IsUnaligned,
4176  NumEntries, Out);
4177  }
4178 
4179  // Reuse a previously generated ThrowInfo if we have generated an appropriate
4180  // one before.
4181  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
4182  return GV;
4183 
4184  // The RTTI TypeDescriptor uses an unqualified type but catch clauses must
4185  // be at least as CV qualified. Encode this requirement into the Flags
4186  // bitfield.
4187  uint32_t Flags = 0;
4188  if (IsConst)
4189  Flags |= 1;
4190  if (IsVolatile)
4191  Flags |= 2;
4192  if (IsUnaligned)
4193  Flags |= 4;
4194 
4195  // The cleanup-function (a destructor) must be called when the exception
4196  // object's lifetime ends.
4197  llvm::Constant *CleanupFn = llvm::Constant::getNullValue(CGM.Int8PtrTy);
4198  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4199  if (CXXDestructorDecl *DtorD = RD->getDestructor())
4200  if (!DtorD->isTrivial())
4201  CleanupFn = llvm::ConstantExpr::getBitCast(
4203  CGM.Int8PtrTy);
4204  // This is unused as far as we can tell, initialize it to null.
4205  llvm::Constant *ForwardCompat =
4206  getImageRelativeConstant(llvm::Constant::getNullValue(CGM.Int8PtrTy));
4207  llvm::Constant *PointerToCatchableTypes = getImageRelativeConstant(
4208  llvm::ConstantExpr::getBitCast(CTA, CGM.Int8PtrTy));
4209  llvm::StructType *TIType = getThrowInfoType();
4210  llvm::Constant *Fields[] = {
4211  llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
4212  getImageRelativeConstant(CleanupFn), // CleanupFn
4213  ForwardCompat, // ForwardCompat
4214  PointerToCatchableTypes // CatchableTypeArray
4215  };
4216  auto *GV = new llvm::GlobalVariable(
4217  CGM.getModule(), TIType, /*Constant=*/true, getLinkageForRTTI(T),
4218  llvm::ConstantStruct::get(TIType, Fields), StringRef(MangledName));
4219  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4220  GV->setSection(".xdata");
4221  if (GV->isWeakForLinker())
4222  GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName()));
4223  return GV;
4224 }
4225 
4226 void MicrosoftCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
4227  const Expr *SubExpr = E->getSubExpr();
4228  QualType ThrowType = SubExpr->getType();
4229  // The exception object lives on the stack and it's address is passed to the
4230  // runtime function.
4231  Address AI = CGF.CreateMemTemp(ThrowType);
4232  CGF.EmitAnyExprToMem(SubExpr, AI, ThrowType.getQualifiers(),
4233  /*IsInit=*/true);
4234 
4235  // The so-called ThrowInfo is used to describe how the exception object may be
4236  // caught.
4237  llvm::GlobalVariable *TI = getThrowInfo(ThrowType);
4238 
4239  // Call into the runtime to throw the exception.
4240  llvm::Value *Args[] = {
4241  CGF.Builder.CreateBitCast(AI.getPointer(), CGM.Int8PtrTy),
4242  TI
4243  };
4245 }
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:281
void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D)
Emit a branch to select whether or not to perform guarded initialization.
Definition: CGDeclCXX.cpp:263
static QualType decomposeTypeForEH(ASTContext &Context, QualType T, bool &IsConst, bool &IsVolatile, bool &IsUnaligned)
llvm::IntegerType * IntTy
int
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1538
void setSRetAfterThis(bool AfterThis)
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:61
Parameter for captured context.
Definition: Decl.h:1408
Complete object ctor.
Definition: ABI.h:26
static void emitGlobalDtorWithTLRegDtor(CodeGenFunction &CGF, const VarDecl &VD, llvm::Constant *Dtor, llvm::Constant *Addr)
A (possibly-)qualified type.
Definition: Type.h:614
static llvm::Constant * getInitThreadFooterFn(CodeGenModule &CGM)
llvm::DenseMap< const CXXRecordDecl *, VBaseInfo > VBaseOffsetsMapTy
Definition: RecordLayout.h:57
base_class_range bases()
Definition: DeclCXX.h:736
llvm::Type * ConvertTypeForMem(QualType T)
uint32_t VBPtrOffset
The offset (in bytes) of the vbptr, relative to the beginning of the derived class.
Definition: ABI.h:61
Internal linkage according to the Modules TS, but can be referred to from other translation units ind...
Definition: Linkage.h:51
const Expr * getSubExpr() const
Definition: ExprCXX.h:948
bool isEmpty() const
Definition: ABI.h:155
llvm::LLVMContext & getLLVMContext()
static void detectAmbiguousBases(SmallVectorImpl< MSRTTIClass > &Classes)
Find ambiguity among base classes.
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:69
The standard implementation of ConstantInitBuilder used in Clang.
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function *> CXXThreadLocals, Address Guard=Address::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
Definition: CGDeclCXX.cpp:565
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:435
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:782
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:219
No linkage, which means that the entity is unique and can only be referred to from within its scope...
Definition: Linkage.h:28
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:751
bool isEmpty() const
Definition: ABI.h:87
const Type * getTypeForDecl() const
Definition: Decl.h:2701
bool isVariadic() const
Definition: Type.h:3497
const CGFunctionInfo & arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD)
Arrange the argument and result information for a call to an unknown C++ non-static member function o...
Definition: CGCall.cpp:242
bool isVirtual() const
Definition: DeclCXX.h:1972
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:211
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1221
GlobalDecl getCanonicalDecl() const
Definition: GlobalDecl.h:54
The base class of the type hierarchy.
Definition: Type.h:1300
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:111
struct clang::ReturnAdjustment::VirtualAdjustment::@119 Microsoft
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1205
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const NestedNameSpecifier * Specifier
bool isFuncTypeConvertible(const FunctionType *FT)
isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i...
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3457
BasePath MangledPath
The bases from the inheritance path that got used to mangle the vbtable name.
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2354
bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D)
Try to emit a base destructor as an alias to its primary base-class destructor.
Definition: CGCXX.cpp:34
Default closure variant of a ctor.
Definition: ABI.h:30
MSInheritanceAttr::Spelling getMSInheritanceModel() const
Returns the inheritance model used for this record.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2077
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:2775
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:771
Address getObjectAddress(CodeGenFunction &CGF) const
Returns the address of the object within this declaration.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6099
static llvm::Constant * getInitThreadHeaderFn(CodeGenModule &CGM)
A this pointer adjustment.
Definition: ABI.h:108
DiagnosticsEngine & getDiags() const
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
Definition: CGBuilder.h:234
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
llvm::Value * getPointer() const
Definition: Address.h:38
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:928
static llvm::Constant * getInitThreadAbortFn(CodeGenModule &CGM)
bool hasDefinition() const
Definition: DeclCXX.h:701
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1447
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
unsigned getAddressSpace() const
Return the address space that this address resides in.
Definition: Address.h:57
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:615
CharUnits getBaseOffset() const
getBaseOffset - Returns the base class offset.
Definition: BaseSubobject.h:43
int32_t VBOffsetOffset
The offset (in bytes) of the vbase offset in the vbtable.
Definition: ABI.h:132
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
One of these records is kept for each identifier that is lexed.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
virtual void mangleCXXVFTable(const CXXRecordDecl *Derived, ArrayRef< const CXXRecordDecl *> BasePath, raw_ostream &Out)=0
Mangle vftable symbols.
llvm::Constant * getAddrOfCXXStructor(const CXXMethodDecl *MD, StructorType Type, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
Definition: CGCXX.cpp:238
bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
Definition: CGClass.cpp:2711
StructorType getFromDtorType(CXXDtorType T)
Definition: CodeGenTypes.h:104
llvm::CallInst * EmitRuntimeCall(llvm::Value *callee, const Twine &name="")
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2009
ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type)
Classify the rules for how to return a particular type.
bool isReferenceType() const
Definition: Type.h:5775
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
A return adjustment.
Definition: ABI.h:42
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:227
Expr * getSubExpr()
Definition: Expr.h:2762
llvm::Function * codegenCXXStructor(const CXXMethodDecl *MD, StructorType Type)
Definition: CGCXX.cpp:213
Describes a module or submodule.
Definition: Module.h:57
IdentifierTable & Idents
Definition: ASTContext.h:515
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:651
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2090
ArrayRef< VTableComponent > vtable_components() const
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1913
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2037
Base object ctor.
Definition: ABI.h:27
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:157
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, llvm::Value *VTable, SourceLocation Loc)
If whole-program virtual table optimization is enabled, emit an assumption that VTable is a member of...
Definition: CGClass.cpp:2564
uint32_t Offset
Definition: CacheTokens.cpp:43
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:238
const CXXRecordDecl * IntroducingObject
This is the class that introduced the vptr by declaring new virtual methods or virtual bases...
path_iterator path_begin()
Definition: Expr.h:2778
Deleting dtor.
Definition: ABI.h:35
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
CharUnits VFPtrOffset
This is the offset of the vfptr from the start of the last vbase, or the complete type if there are n...
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
static ConstantAddress getInitThreadEpochPtr(CodeGenModule &CGM)
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5613
const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs=true)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:378
void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::Constant *fn, llvm::Constant *addr)
Call atexit() with a function that passes the given argument to the given function.
Definition: CGDeclCXX.cpp:230
QualType getExceptionObjectType(QualType T) const
const VPtrInfoVector & getVFPtrOffsets(const CXXRecordDecl *RD)
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5543
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:670
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
Definition: CGExprCXX.cpp:1723
static bool hasDefaultCXXMethodCC(ASTContext &Context, const CXXMethodDecl *MD)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
Definition: EHScopeStack.h:85
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2710
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
const VBaseOffsetsMapTy & getVBaseOffsetsMap() const
Definition: RecordLayout.h:302
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition: CGCall.cpp:263
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
bool isInstance() const
Definition: DeclCXX.h:1955
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1437
bool isNegative() const
isNegative - Test whether the quantity is less than zero.
Definition: CharUnits.h:125
arg_iterator arg_end()
Definition: Expr.h:2309
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create a new runtime function with the specified type and name.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4155
NodeId Parent
Definition: ASTDiff.cpp:192
const CXXRecordDecl * VBase
If nonnull, holds the last vbase which contains the vfptr that the method definition is adjusted to...
bool hasAttr() const
Definition: DeclBase.h:521
CanQualType getReturnType() const
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition: CGDecl.cpp:957
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1569
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3170
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)
EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...
Definition: CGExpr.cpp:199
CastKind
CastKind - The kind of operation required for a conversion.
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
union clang::ReturnAdjustment::VirtualAdjustment Virtual
Module linkage, which indicates that the entity can be referred to from other translation units withi...
Definition: Linkage.h:57
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
static void emitCXXConstructor(CodeGenModule &CGM, const CXXConstructorDecl *ctor, StructorType ctorType)
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:34
llvm::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass)
GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.
Definition: CGClass.cpp:2515
CXXDtorType
C++ destructor types.
Definition: ABI.h:34
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:593
Expr - This represents one expression.
Definition: Expr.h:106
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
Definition: CharUnits.h:122
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const FunctionProtoType * T
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type &#39;void ()&#39;.
Definition: CGCall.cpp:682
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6162
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:125
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2576
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:50
static llvm::CallSite emitRTtypeidCall(CodeGenFunction &CGF, llvm::Value *Argument)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
bool isNullPtrType() const
Definition: Type.h:5976
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclContext * getDeclContext()
Definition: DeclBase.h:416
TLSKind getTLSKind() const
Definition: Decl.cpp:1861
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
MicrosoftVTableContext & getMicrosoftVTableContext()
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:207
llvm::LLVMContext & getLLVMContext()
const CXXRecordDecl * getBase() const
getBase - Returns the base class declaration.
Definition: BaseSubobject.h:40
Base object dtor.
Definition: ABI.h:37
QualType getType() const
Definition: Expr.h:128
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1367
bool hasExtendableVFPtr() const
hasVFPtr - Does this class have a virtual function table pointer that can be extended by a derived cl...
Definition: RecordLayout.h:254
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1303
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:50
CharUnits getVBPtrOffset() const
getVBPtrOffset - Get the offset for virtual base table pointer.
Definition: RecordLayout.h:292
const TargetInfo & getTarget() const
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1305
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
Definition: CGDeclCXX.cpp:143
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1309
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1930
ASTContext & getContext() const
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:681
bool nullFieldOffsetIsZero() const
In the Microsoft C++ ABI, use zero for the field offset of a null data member pointer if we can guara...
Definition: DeclCXX.h:1817
The COMDAT used for dtors.
Definition: ABI.h:38
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5602
The l-value was considered opaque, so the alignment was determined from a type.
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:45
bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target)
Try to emit a definition as a global alias for another definition.
Definition: CGCXX.cpp:119
unsigned getVBTableIndex(const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)
Returns the index of VBase in the vbtable of Derived.
unsigned getEffectiveCallingConvention() const
getEffectiveCallingConvention - Return the actual calling convention to use, which may depend on the ...
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
bool isMemberDataPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2469
CastKind getCastKind() const
Definition: Expr.h:2758
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1780
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3657
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:136
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:346
const Decl * getDecl() const
Definition: GlobalDecl.h:62
llvm::Constant * createAtExitStub(const VarDecl &VD, llvm::Constant *Dtor, llvm::Constant *Addr)
Create a stub function, suitable for being passed to atexit, which passes the given address to the gi...
Definition: CGDeclCXX.cpp:197
Represents a single component in a vtable.
Definition: VTableBuilder.h:30
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:42
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1928
const VTableLayout & getVFTableLayout(const CXXRecordDecl *RD, CharUnits VFPtrOffset)
QualType getAllocatedType() const
Definition: ExprCXX.h:1841
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
void createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti)
Add vtable components for the given vtable layout to the given global initializer.
Definition: CGVTables.cpp:649
const CXXRecordDecl * ObjectWithVPtr
This is the most derived class that has this vptr at offset zero.
An aligned address.
Definition: Address.h:25
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1052
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:689
All available information about a concrete callee.
Definition: CGCall.h:66
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:96
Complete object dtor.
Definition: ABI.h:36
llvm::Instruction * CurrentFuncletPad
CGCXXABI * CreateMicrosoftCXXABI(CodeGenModule &CGM)
Creates a Microsoft-family ABI.
static void mangleVFTableName(MicrosoftMangleContext &MangleContext, const CXXRecordDecl *RD, const VPtrInfo &VFPtr, SmallString< 256 > &Name)
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:622
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
Definition: DeclCXX.h:823
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler...
Definition: CGCleanup.h:38
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
CXXCtorType
C++ constructor types.
Definition: ABI.h:25
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:276
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Definition: Type.cpp:3872
bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is virtually derived from the class Base.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn&#39;t support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset...
Definition: CharUnits.h:190
llvm::GlobalValue * GetGlobalValue(StringRef Ref)
Dataflow Directional Tag Classes.
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2343
External linkage within a unique namespace.
Definition: Linkage.h:42
static bool isDeletingDtor(GlobalDecl GD)
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:1992
const VPtrInfoVector & enumerateVBTables(const CXXRecordDecl *RD)
void EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value *> args)
Emits a call or invoke to the given noreturn runtime function.
Definition: CGCall.cpp:3626
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.cpp:2086
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:91
llvm::Constant * getPointer() const
Definition: Address.h:84
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2043
struct clang::ThisAdjustment::VirtualAdjustment::@121 Microsoft
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2440
CharUnits NonVirtualOffset
IntroducingObject is at this offset from its containing complete object or virtual base...
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
llvm::Module & getModule() const
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
CharUnits getVBaseAlignment(CharUnits DerivedAlign, const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)
Returns the assumed alignment of a virtual base of a class.
Definition: CGClass.cpp:55
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:629
void EmitThunks(GlobalDecl GD)
EmitThunks - Emit the associated thunks for the given global decl.
Definition: CGVTables.cpp:509
union clang::ThisAdjustment::VirtualAdjustment Virtual
path_iterator path_end()
Definition: Expr.h:2779
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1417
void AppendLinkerOptions(StringRef Opts)
Appends Opts to the "llvm.linker.options" metadata value.
static llvm::GlobalVariable * getTypeInfoVTable(CodeGenModule &CGM)
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
const CXXRecordDecl * getVBaseWithVPtr() const
The vptr is stored inside the non-virtual component of this virtual base.
arg_iterator arg_begin()
Definition: Expr.h:2308
Implements C++ ABI-specific code generation functions.
Definition: CGCXXABI.h:44
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:120
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1000
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1326
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
StringRef getMangledName(GlobalDecl GD)
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:436
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1607
static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT, CGCXXABI &CXXABI)
Definition: TargetInfo.cpp:140
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
Definition: DeclCXX.h:916
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5623
Address CreateConstByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:240
bool hasUnaligned() const
Definition: Type.h:276
Represents a C++ struct/union/class.
Definition: DeclCXX.h:266
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2463
llvm::Function * CreateGlobalInitOrDestructFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false)
Definition: CGDeclCXX.cpp:300
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
llvm::Type * ConvertType(QualType T)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5570
static void emitCXXDestructor(CodeGenModule &CGM, const CXXDestructorDecl *dtor, StructorType dtorType)
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
int32_t VtordispOffset
The offset of the vtordisp (in bytes), relative to the ECX.
Definition: ABI.h:125
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
No linkage according to the standard, but is visible from other translation units because of types de...
Definition: Linkage.h:46
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
bool isGlobalDelete() const
Definition: ExprCXX.h:2025
Copying closure variant of a ctor.
Definition: ABI.h:29
CharUnits computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start, CastExpr::path_const_iterator End)
Definition: CGClass.cpp:149
CharUnits FullOffsetInMDC
Static offset from the top of the most derived class to this vfptr, including any virtual base offset...
uint64_t Index
Method&#39;s index in the vftable.
const CGFunctionInfo & arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT)
Definition: CGCall.cpp:526
CanQualType IntTy
Definition: ASTContext.h:973
Struct with all informations about dynamic [sub]class needed to set vptr.
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:75
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2000
Holds information about the inheritance path to a virtual base or function table pointer.
bool isPointerType() const
Definition: Type.h:5766
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
Definition: CGDebugInfo.h:668
llvm::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)
Definition: CGBuilder.h:115
QualType getType() const
Definition: Decl.h:602
CodeGenVTables & getVTables()
uint32_t VBIndex
Index of the virtual base in the vbtable.
Definition: ABI.h:64
LValue - This represents an lvalue references.
Definition: CGValue.h:172
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
BasePath PathToIntroducingObject
This holds the base classes path from the complete type to the first base with the given vfptr offset...
const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list...
Definition: CGCXXABI.h:299
RecordArgABI
Specify how one should pass an argument of a record type.
Definition: CGCXXABI.h:125
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2877
ctor_range ctors() const
Definition: DeclCXX.h:797
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:182
int32_t VBPtrOffset
The offset of the vbptr of the derived class (in bytes), relative to the ECX after vtordisp adjustmen...
Definition: ABI.h:129
Address CreateMemTemp(QualType T, const Twine &Name="tmp", bool CastToDefaultAddrSpace=true)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
Definition: CGExpr.cpp:124
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:640
static void serializeClassHierarchy(SmallVectorImpl< MSRTTIClass > &Classes, const CXXRecordDecl *RD)
Recursively serializes a class hierarchy in pre-order depth first order.
base_class_range vbases()
Definition: DeclCXX.h:753
static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)
llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, uint64_t VTableByteOffset)
Emit a type checked load from the given vtable.
Definition: CGClass.cpp:2723
const MethodVFTableLocation & getMethodVFTableLocation(GlobalDecl GD)
SourceLocation getLocation() const
Definition: DeclBase.h:407
QualType getPointeeType() const
Definition: Type.h:2459
bool isExternallyVisible() const
Definition: Decl.h:338
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::Instruction **callOrInvoke=nullptr)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3708
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
void EmitMustTailThunk(const CXXMethodDecl *MD, llvm::Value *AdjustedThisPtr, llvm::Value *Callee)
Emit a musttail call for a thunk with a potentially adjusted this pointer.
Definition: CGVTables.cpp:346
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static llvm::Constant * getThrowFn(CodeGenModule &CGM)
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1524