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