clang  3.9.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 emitVTableTypeMetadata(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) override;
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  CharUnits VBaseAlign =
946  CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase);
947  return std::make_pair(Address(Ptr, VBaseAlign), Offset);
948 }
949 
950 bool MicrosoftCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
951  QualType SrcRecordTy) {
952  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
953  return IsDeref &&
954  !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
955 }
956 
957 static llvm::CallSite emitRTtypeidCall(CodeGenFunction &CGF,
958  llvm::Value *Argument) {
959  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
960  llvm::FunctionType *FTy =
961  llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false);
962  llvm::Value *Args[] = {Argument};
963  llvm::Constant *Fn = CGF.CGM.CreateRuntimeFunction(FTy, "__RTtypeid");
964  return CGF.EmitRuntimeCallOrInvoke(Fn, Args);
965 }
966 
967 void MicrosoftCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
968  llvm::CallSite Call =
969  emitRTtypeidCall(CGF, llvm::Constant::getNullValue(CGM.VoidPtrTy));
970  Call.setDoesNotReturn();
971  CGF.Builder.CreateUnreachable();
972 }
973 
974 llvm::Value *MicrosoftCXXABI::EmitTypeid(CodeGenFunction &CGF,
975  QualType SrcRecordTy,
976  Address ThisPtr,
977  llvm::Type *StdTypeInfoPtrTy) {
978  std::tie(ThisPtr, std::ignore) =
979  performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);
980  auto Typeid = emitRTtypeidCall(CGF, ThisPtr.getPointer()).getInstruction();
981  return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
982 }
983 
984 bool MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
985  QualType SrcRecordTy) {
986  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
987  return SrcIsPtr &&
988  !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
989 }
990 
991 llvm::Value *MicrosoftCXXABI::EmitDynamicCastCall(
992  CodeGenFunction &CGF, Address This, QualType SrcRecordTy,
993  QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
994  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
995 
996  llvm::Value *SrcRTTI =
998  llvm::Value *DestRTTI =
999  CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1000 
1002  std::tie(This, Offset) = performBaseAdjustment(CGF, This, SrcRecordTy);
1003  llvm::Value *ThisPtr = This.getPointer();
1004  Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty);
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) {
1028  std::tie(Value, std::ignore) = performBaseAdjustment(CGF, Value, SrcRecordTy);
1029 
1030  // PVOID __RTCastToVoid(
1031  // PVOID inptr)
1032  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
1033  llvm::Constant *Function = CGF.CGM.CreateRuntimeFunction(
1034  llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
1035  "__RTCastToVoid");
1036  llvm::Value *Args[] = {Value.getPointer()};
1037  return CGF.EmitRuntimeCall(Function, Args);
1038 }
1039 
1040 bool MicrosoftCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1041  return false;
1042 }
1043 
1044 llvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset(
1045  CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl,
1046  const CXXRecordDecl *BaseClassDecl) {
1047  const ASTContext &Context = getContext();
1048  int64_t VBPtrChars =
1049  Context.getASTRecordLayout(ClassDecl).getVBPtrOffset().getQuantity();
1050  llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars);
1051  CharUnits IntSize = Context.getTypeSizeInChars(Context.IntTy);
1052  CharUnits VBTableChars =
1053  IntSize *
1054  CGM.getMicrosoftVTableContext().getVBTableIndex(ClassDecl, BaseClassDecl);
1055  llvm::Value *VBTableOffset =
1056  llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity());
1057 
1058  llvm::Value *VBPtrToNewBase =
1059  GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset);
1060  VBPtrToNewBase =
1061  CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy);
1062  return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
1063 }
1064 
1065 bool MicrosoftCXXABI::HasThisReturn(GlobalDecl GD) const {
1066  return isa<CXXConstructorDecl>(GD.getDecl());
1067 }
1068 
1069 static bool isDeletingDtor(GlobalDecl GD) {
1070  return isa<CXXDestructorDecl>(GD.getDecl()) &&
1071  GD.getDtorType() == Dtor_Deleting;
1072 }
1073 
1074 bool MicrosoftCXXABI::hasMostDerivedReturn(GlobalDecl GD) const {
1075  return isDeletingDtor(GD);
1076 }
1077 
1079  const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
1080  if (!RD)
1081  return false;
1082 
1083  CharUnits Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
1084  if (FI.isInstanceMethod()) {
1085  // If it's an instance method, aggregates are always returned indirectly via
1086  // the second parameter.
1087  FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
1089  return true;
1090  } else if (!RD->isPOD()) {
1091  // If it's a free function, non-POD types are returned indirectly.
1092  FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
1093  return true;
1094  }
1095 
1096  // Otherwise, use the C ABI rules.
1097  return false;
1098 }
1099 
1100 llvm::BasicBlock *
1101 MicrosoftCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
1102  const CXXRecordDecl *RD) {
1103  llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1104  assert(IsMostDerivedClass &&
1105  "ctor for a class with virtual bases must have an implicit parameter");
1106  llvm::Value *IsCompleteObject =
1107  CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1108 
1109  llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases");
1110  llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases");
1111  CGF.Builder.CreateCondBr(IsCompleteObject,
1112  CallVbaseCtorsBB, SkipVbaseCtorsBB);
1113 
1114  CGF.EmitBlock(CallVbaseCtorsBB);
1115 
1116  // Fill in the vbtable pointers here.
1117  EmitVBPtrStores(CGF, RD);
1118 
1119  // CGF will put the base ctor calls in this basic block for us later.
1120 
1121  return SkipVbaseCtorsBB;
1122 }
1123 
1124 void MicrosoftCXXABI::initializeHiddenVirtualInheritanceMembers(
1125  CodeGenFunction &CGF, const CXXRecordDecl *RD) {
1126  // In most cases, an override for a vbase virtual method can adjust
1127  // the "this" parameter by applying a constant offset.
1128  // However, this is not enough while a constructor or a destructor of some
1129  // class X is being executed if all the following conditions are met:
1130  // - X has virtual bases, (1)
1131  // - X overrides a virtual method M of a vbase Y, (2)
1132  // - X itself is a vbase of the most derived class.
1133  //
1134  // If (1) and (2) are true, the vtorDisp for vbase Y is a hidden member of X
1135  // which holds the extra amount of "this" adjustment we must do when we use
1136  // the X vftables (i.e. during X ctor or dtor).
1137  // Outside the ctors and dtors, the values of vtorDisps are zero.
1138 
1139  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
1140  typedef ASTRecordLayout::VBaseOffsetsMapTy VBOffsets;
1141  const VBOffsets &VBaseMap = Layout.getVBaseOffsetsMap();
1142  CGBuilderTy &Builder = CGF.Builder;
1143 
1144  unsigned AS = getThisAddress(CGF).getAddressSpace();
1145  llvm::Value *Int8This = nullptr; // Initialize lazily.
1146 
1147  for (VBOffsets::const_iterator I = VBaseMap.begin(), E = VBaseMap.end();
1148  I != E; ++I) {
1149  if (!I->second.hasVtorDisp())
1150  continue;
1151 
1152  llvm::Value *VBaseOffset =
1153  GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, I->first);
1154  uint64_t ConstantVBaseOffset =
1155  Layout.getVBaseClassOffset(I->first).getQuantity();
1156 
1157  // vtorDisp_for_vbase = vbptr[vbase_idx] - offsetof(RD, vbase).
1158  llvm::Value *VtorDispValue = Builder.CreateSub(
1159  VBaseOffset, llvm::ConstantInt::get(CGM.PtrDiffTy, ConstantVBaseOffset),
1160  "vtordisp.value");
1161  VtorDispValue = Builder.CreateTruncOrBitCast(VtorDispValue, CGF.Int32Ty);
1162 
1163  if (!Int8This)
1164  Int8This = Builder.CreateBitCast(getThisValue(CGF),
1165  CGF.Int8Ty->getPointerTo(AS));
1166  llvm::Value *VtorDispPtr = Builder.CreateInBoundsGEP(Int8This, VBaseOffset);
1167  // vtorDisp is always the 32-bits before the vbase in the class layout.
1168  VtorDispPtr = Builder.CreateConstGEP1_32(VtorDispPtr, -4);
1169  VtorDispPtr = Builder.CreateBitCast(
1170  VtorDispPtr, CGF.Int32Ty->getPointerTo(AS), "vtordisp.ptr");
1171 
1172  Builder.CreateAlignedStore(VtorDispValue, VtorDispPtr,
1174  }
1175 }
1176 
1177 static bool hasDefaultCXXMethodCC(ASTContext &Context,
1178  const CXXMethodDecl *MD) {
1179  CallingConv ExpectedCallingConv = Context.getDefaultCallingConvention(
1180  /*IsVariadic=*/false, /*IsCXXMethod=*/true);
1181  CallingConv ActualCallingConv =
1182  MD->getType()->getAs<FunctionProtoType>()->getCallConv();
1183  return ExpectedCallingConv == ActualCallingConv;
1184 }
1185 
1186 void MicrosoftCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1187  // There's only one constructor type in this ABI.
1188  CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1189 
1190  // Exported default constructors either have a simple call-site where they use
1191  // the typical calling convention and have a single 'this' pointer for an
1192  // argument -or- they get a wrapper function which appropriately thunks to the
1193  // real default constructor. This thunk is the default constructor closure.
1194  if (D->hasAttr<DLLExportAttr>() && D->isDefaultConstructor())
1195  if (!hasDefaultCXXMethodCC(getContext(), D) || D->getNumParams() != 0) {
1196  llvm::Function *Fn = getAddrOfCXXCtorClosure(D, Ctor_DefaultClosure);
1197  Fn->setLinkage(llvm::GlobalValue::WeakODRLinkage);
1198  Fn->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1199  }
1200 }
1201 
1202 void MicrosoftCXXABI::EmitVBPtrStores(CodeGenFunction &CGF,
1203  const CXXRecordDecl *RD) {
1204  Address This = getThisAddress(CGF);
1205  This = CGF.Builder.CreateElementBitCast(This, CGM.Int8Ty, "this.int8");
1206  const ASTContext &Context = getContext();
1207  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1208 
1209  const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
1210  for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
1211  const VPtrInfo *VBT = (*VBGlobals.VBTables)[I];
1212  llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1213  const ASTRecordLayout &SubobjectLayout =
1214  Context.getASTRecordLayout(VBT->BaseWithVPtr);
1215  CharUnits Offs = VBT->NonVirtualOffset;
1216  Offs += SubobjectLayout.getVBPtrOffset();
1217  if (VBT->getVBaseWithVPtr())
1218  Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr());
1219  Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs);
1220  llvm::Value *GVPtr =
1221  CGF.Builder.CreateConstInBoundsGEP2_32(GV->getValueType(), GV, 0, 0);
1222  VBPtr = CGF.Builder.CreateElementBitCast(VBPtr, GVPtr->getType(),
1223  "vbptr." + VBT->ReusingBase->getName());
1224  CGF.Builder.CreateStore(GVPtr, VBPtr);
1225  }
1226 }
1227 
1228 void
1229 MicrosoftCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
1230  SmallVectorImpl<CanQualType> &ArgTys) {
1231  // TODO: 'for base' flag
1232  if (T == StructorType::Deleting) {
1233  // The scalar deleting destructor takes an implicit int parameter.
1234  ArgTys.push_back(getContext().IntTy);
1235  }
1236  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
1237  if (!CD)
1238  return;
1239 
1240  // All parameters are already in place except is_most_derived, which goes
1241  // after 'this' if it's variadic and last if it's not.
1242 
1243  const CXXRecordDecl *Class = CD->getParent();
1244  const FunctionProtoType *FPT = CD->getType()->castAs<FunctionProtoType>();
1245  if (Class->getNumVBases()) {
1246  if (FPT->isVariadic())
1247  ArgTys.insert(ArgTys.begin() + 1, getContext().IntTy);
1248  else
1249  ArgTys.push_back(getContext().IntTy);
1250  }
1251 }
1252 
1253 void MicrosoftCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1254  // The TU defining a dtor is only guaranteed to emit a base destructor. All
1255  // other destructor variants are delegating thunks.
1256  CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1257 }
1258 
1259 CharUnits
1260 MicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
1261  GD = GD.getCanonicalDecl();
1262  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1263 
1264  GlobalDecl LookupGD = GD;
1265  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1266  // Complete destructors take a pointer to the complete object as a
1267  // parameter, thus don't need this adjustment.
1268  if (GD.getDtorType() == Dtor_Complete)
1269  return CharUnits();
1270 
1271  // There's no Dtor_Base in vftable but it shares the this adjustment with
1272  // the deleting one, so look it up instead.
1273  LookupGD = GlobalDecl(DD, Dtor_Deleting);
1274  }
1275 
1277  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD);
1278  CharUnits Adjustment = ML.VFPtrOffset;
1279 
1280  // Normal virtual instance methods need to adjust from the vfptr that first
1281  // defined the virtual method to the virtual base subobject, but destructors
1282  // do not. The vector deleting destructor thunk applies this adjustment for
1283  // us if necessary.
1284  if (isa<CXXDestructorDecl>(MD))
1285  Adjustment = CharUnits::Zero();
1286 
1287  if (ML.VBase) {
1288  const ASTRecordLayout &DerivedLayout =
1289  getContext().getASTRecordLayout(MD->getParent());
1290  Adjustment += DerivedLayout.getVBaseClassOffset(ML.VBase);
1291  }
1292 
1293  return Adjustment;
1294 }
1295 
1296 Address MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall(
1297  CodeGenFunction &CGF, GlobalDecl GD, Address This,
1298  bool VirtualCall) {
1299  if (!VirtualCall) {
1300  // If the call of a virtual function is not virtual, we just have to
1301  // compensate for the adjustment the virtual function does in its prologue.
1302  CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1303  if (Adjustment.isZero())
1304  return This;
1305 
1306  This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
1307  assert(Adjustment.isPositive());
1308  return CGF.Builder.CreateConstByteGEP(This, Adjustment);
1309  }
1310 
1311  GD = GD.getCanonicalDecl();
1312  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1313 
1314  GlobalDecl LookupGD = GD;
1315  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1316  // Complete dtors take a pointer to the complete object,
1317  // thus don't need adjustment.
1318  if (GD.getDtorType() == Dtor_Complete)
1319  return This;
1320 
1321  // There's only Dtor_Deleting in vftable but it shares the this adjustment
1322  // with the base one, so look up the deleting one instead.
1323  LookupGD = GlobalDecl(DD, Dtor_Deleting);
1324  }
1326  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD);
1327 
1328  CharUnits StaticOffset = ML.VFPtrOffset;
1329 
1330  // Base destructors expect 'this' to point to the beginning of the base
1331  // subobject, not the first vfptr that happens to contain the virtual dtor.
1332  // However, we still need to apply the virtual base adjustment.
1333  if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
1334  StaticOffset = CharUnits::Zero();
1335 
1336  Address Result = This;
1337  if (ML.VBase) {
1338  Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1339 
1340  const CXXRecordDecl *Derived = MD->getParent();
1341  const CXXRecordDecl *VBase = ML.VBase;
1342  llvm::Value *VBaseOffset =
1343  GetVirtualBaseClassOffset(CGF, Result, Derived, VBase);
1344  llvm::Value *VBasePtr =
1345  CGF.Builder.CreateInBoundsGEP(Result.getPointer(), VBaseOffset);
1346  CharUnits VBaseAlign =
1347  CGF.CGM.getVBaseAlignment(Result.getAlignment(), Derived, VBase);
1348  Result = Address(VBasePtr, VBaseAlign);
1349  }
1350  if (!StaticOffset.isZero()) {
1351  assert(StaticOffset.isPositive());
1352  Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1353  if (ML.VBase) {
1354  // Non-virtual adjustment might result in a pointer outside the allocated
1355  // object, e.g. if the final overrider class is laid out after the virtual
1356  // base that declares a method in the most derived class.
1357  // FIXME: Update the code that emits this adjustment in thunks prologues.
1358  Result = CGF.Builder.CreateConstByteGEP(Result, StaticOffset);
1359  } else {
1360  Result = CGF.Builder.CreateConstInBoundsByteGEP(Result, StaticOffset);
1361  }
1362  }
1363  return Result;
1364 }
1365 
1366 void MicrosoftCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1367  QualType &ResTy,
1368  FunctionArgList &Params) {
1369  ASTContext &Context = getContext();
1370  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1371  assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1372  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
1373  ImplicitParamDecl *IsMostDerived
1374  = ImplicitParamDecl::Create(Context, nullptr,
1375  CGF.CurGD.getDecl()->getLocation(),
1376  &Context.Idents.get("is_most_derived"),
1377  Context.IntTy);
1378  // The 'most_derived' parameter goes second if the ctor is variadic and last
1379  // if it's not. Dtors can't be variadic.
1380  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
1381  if (FPT->isVariadic())
1382  Params.insert(Params.begin() + 1, IsMostDerived);
1383  else
1384  Params.push_back(IsMostDerived);
1385  getStructorImplicitParamDecl(CGF) = IsMostDerived;
1386  } else if (isDeletingDtor(CGF.CurGD)) {
1387  ImplicitParamDecl *ShouldDelete
1388  = ImplicitParamDecl::Create(Context, nullptr,
1389  CGF.CurGD.getDecl()->getLocation(),
1390  &Context.Idents.get("should_call_delete"),
1391  Context.IntTy);
1392  Params.push_back(ShouldDelete);
1393  getStructorImplicitParamDecl(CGF) = ShouldDelete;
1394  }
1395 }
1396 
1397 llvm::Value *MicrosoftCXXABI::adjustThisParameterInVirtualFunctionPrologue(
1398  CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) {
1399  // In this ABI, every virtual function takes a pointer to one of the
1400  // subobjects that first defines it as the 'this' parameter, rather than a
1401  // pointer to the final overrider subobject. Thus, we need to adjust it back
1402  // to the final overrider subobject before use.
1403  // See comments in the MicrosoftVFTableContext implementation for the details.
1404  CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1405  if (Adjustment.isZero())
1406  return This;
1407 
1408  unsigned AS = cast<llvm::PointerType>(This->getType())->getAddressSpace();
1409  llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS),
1410  *thisTy = This->getType();
1411 
1412  This = CGF.Builder.CreateBitCast(This, charPtrTy);
1413  assert(Adjustment.isPositive());
1414  This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This,
1415  -Adjustment.getQuantity());
1416  return CGF.Builder.CreateBitCast(This, thisTy);
1417 }
1418 
1419 void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1420  EmitThisParam(CGF);
1421 
1422  /// If this is a function that the ABI specifies returns 'this', initialize
1423  /// the return slot to 'this' at the start of the function.
1424  ///
1425  /// Unlike the setting of return types, this is done within the ABI
1426  /// implementation instead of by clients of CGCXXABI because:
1427  /// 1) getThisValue is currently protected
1428  /// 2) in theory, an ABI could implement 'this' returns some other way;
1429  /// HasThisReturn only specifies a contract, not the implementation
1430  if (HasThisReturn(CGF.CurGD))
1431  CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1432  else if (hasMostDerivedReturn(CGF.CurGD))
1433  CGF.Builder.CreateStore(CGF.EmitCastToVoidPtr(getThisValue(CGF)),
1434  CGF.ReturnValue);
1435 
1436  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1437  if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
1438  assert(getStructorImplicitParamDecl(CGF) &&
1439  "no implicit parameter for a constructor with virtual bases?");
1440  getStructorImplicitParamValue(CGF)
1441  = CGF.Builder.CreateLoad(
1442  CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1443  "is_most_derived");
1444  }
1445 
1446  if (isDeletingDtor(CGF.CurGD)) {
1447  assert(getStructorImplicitParamDecl(CGF) &&
1448  "no implicit parameter for a deleting destructor?");
1449  getStructorImplicitParamValue(CGF)
1450  = CGF.Builder.CreateLoad(
1451  CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
1452  "should_call_delete");
1453  }
1454 }
1455 
1456 unsigned MicrosoftCXXABI::addImplicitConstructorArgs(
1458  bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1459  assert(Type == Ctor_Complete || Type == Ctor_Base);
1460 
1461  // Check if we need a 'most_derived' parameter.
1462  if (!D->getParent()->getNumVBases())
1463  return 0;
1464 
1465  // Add the 'most_derived' argument second if we are variadic or last if not.
1466  const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
1467  llvm::Value *MostDerivedArg;
1468  if (Delegating) {
1469  MostDerivedArg = getStructorImplicitParamValue(CGF);
1470  } else {
1471  MostDerivedArg = llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete);
1472  }
1473  RValue RV = RValue::get(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  return 1; // Added one arg.
1481 }
1482 
1483 void MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1484  const CXXDestructorDecl *DD,
1485  CXXDtorType Type, bool ForVirtualBase,
1486  bool Delegating, Address This) {
1487  llvm::Value *Callee = CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type));
1488 
1489  if (DD->isVirtual()) {
1490  assert(Type != CXXDtorType::Dtor_Deleting &&
1491  "The deleting destructor should only be called via a virtual call");
1492  This = adjustThisArgumentForVirtualFunctionCall(CGF, GlobalDecl(DD, Type),
1493  This, false);
1494  }
1495 
1496  CGF.EmitCXXDestructorCall(DD, Callee, This.getPointer(),
1497  /*ImplicitParam=*/nullptr,
1498  /*ImplicitParamTy=*/QualType(), nullptr,
1499  getFromDtorType(Type));
1500 }
1501 
1502 void MicrosoftCXXABI::emitVTableTypeMetadata(VPtrInfo *Info,
1503  const CXXRecordDecl *RD,
1504  llvm::GlobalVariable *VTable) {
1505  if (!CGM.getCodeGenOpts().PrepareForLTO)
1506  return;
1507 
1508  // The location of the first virtual function pointer in the virtual table,
1509  // aka the "address point" on Itanium. This is at offset 0 if RTTI is
1510  // disabled, or sizeof(void*) if RTTI is enabled.
1511  CharUnits AddressPoint =
1512  getContext().getLangOpts().RTTIData
1513  ? getContext().toCharUnitsFromBits(
1514  getContext().getTargetInfo().getPointerWidth(0))
1515  : CharUnits::Zero();
1516 
1517  if (Info->PathToBaseWithVPtr.empty()) {
1518  CGM.AddVTableTypeMetadata(VTable, AddressPoint, RD);
1519  return;
1520  }
1521 
1522  // Add a bitset entry for the least derived base belonging to this vftable.
1523  CGM.AddVTableTypeMetadata(VTable, AddressPoint,
1524  Info->PathToBaseWithVPtr.back());
1525 
1526  // Add a bitset entry for each derived class that is laid out at the same
1527  // offset as the least derived base.
1528  for (unsigned I = Info->PathToBaseWithVPtr.size() - 1; I != 0; --I) {
1529  const CXXRecordDecl *DerivedRD = Info->PathToBaseWithVPtr[I - 1];
1530  const CXXRecordDecl *BaseRD = Info->PathToBaseWithVPtr[I];
1531 
1532  const ASTRecordLayout &Layout =
1533  getContext().getASTRecordLayout(DerivedRD);
1534  CharUnits Offset;
1535  auto VBI = Layout.getVBaseOffsetsMap().find(BaseRD);
1536  if (VBI == Layout.getVBaseOffsetsMap().end())
1537  Offset = Layout.getBaseClassOffset(BaseRD);
1538  else
1539  Offset = VBI->second.VBaseOffset;
1540  if (!Offset.isZero())
1541  return;
1542  CGM.AddVTableTypeMetadata(VTable, AddressPoint, DerivedRD);
1543  }
1544 
1545  // Finally do the same for the most derived class.
1546  if (Info->FullOffsetInMDC.isZero())
1547  CGM.AddVTableTypeMetadata(VTable, AddressPoint, RD);
1548 }
1549 
1550 void MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1551  const CXXRecordDecl *RD) {
1552  MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext();
1553  const VPtrInfoVector &VFPtrs = VFTContext.getVFPtrOffsets(RD);
1554 
1555  for (VPtrInfo *Info : VFPtrs) {
1556  llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->FullOffsetInMDC);
1557  if (VTable->hasInitializer())
1558  continue;
1559 
1560  const VTableLayout &VTLayout =
1561  VFTContext.getVFTableLayout(RD, Info->FullOffsetInMDC);
1562 
1563  llvm::Constant *RTTI = nullptr;
1564  if (any_of(VTLayout.vtable_components(),
1565  [](const VTableComponent &VTC) { return VTC.isRTTIKind(); }))
1566  RTTI = getMSCompleteObjectLocator(RD, Info);
1567 
1568  llvm::Constant *Init = CGVT.CreateVTableInitializer(
1569  RD, VTLayout.vtable_component_begin(),
1570  VTLayout.getNumVTableComponents(), VTLayout.vtable_thunk_begin(),
1571  VTLayout.getNumVTableThunks(), RTTI);
1572 
1573  VTable->setInitializer(Init);
1574 
1575  emitVTableTypeMetadata(Info, RD, VTable);
1576  }
1577 }
1578 
1579 bool MicrosoftCXXABI::isVirtualOffsetNeededForVTableField(
1581  return Vptr.NearestVBase != nullptr;
1582 }
1583 
1584 llvm::Value *MicrosoftCXXABI::getVTableAddressPointInStructor(
1585  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1586  const CXXRecordDecl *NearestVBase) {
1587  llvm::Constant *VTableAddressPoint = getVTableAddressPoint(Base, VTableClass);
1588  if (!VTableAddressPoint) {
1589  assert(Base.getBase()->getNumVBases() &&
1590  !getContext().getASTRecordLayout(Base.getBase()).hasOwnVFPtr());
1591  }
1592  return VTableAddressPoint;
1593 }
1594 
1596  const CXXRecordDecl *RD, const VPtrInfo *VFPtr,
1597  SmallString<256> &Name) {
1598  llvm::raw_svector_ostream Out(Name);
1599  MangleContext.mangleCXXVFTable(RD, VFPtr->MangledPath, Out);
1600 }
1601 
1602 llvm::Constant *
1603 MicrosoftCXXABI::getVTableAddressPoint(BaseSubobject Base,
1604  const CXXRecordDecl *VTableClass) {
1605  (void)getAddrOfVTable(VTableClass, Base.getBaseOffset());
1606  VFTableIdTy ID(VTableClass, Base.getBaseOffset());
1607  return VFTablesMap[ID];
1608 }
1609 
1610 llvm::Constant *MicrosoftCXXABI::getVTableAddressPointForConstExpr(
1611  BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1612  llvm::Constant *VFTable = getVTableAddressPoint(Base, VTableClass);
1613  assert(VFTable && "Couldn't find a vftable for the given base?");
1614  return VFTable;
1615 }
1616 
1617 llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1618  CharUnits VPtrOffset) {
1619  // getAddrOfVTable may return 0 if asked to get an address of a vtable which
1620  // shouldn't be used in the given record type. We want to cache this result in
1621  // VFTablesMap, thus a simple zero check is not sufficient.
1622 
1623  VFTableIdTy ID(RD, VPtrOffset);
1625  bool Inserted;
1626  std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID, nullptr));
1627  if (!Inserted)
1628  return I->second;
1629 
1630  llvm::GlobalVariable *&VTable = I->second;
1631 
1632  MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
1633  const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD);
1634 
1635  if (DeferredVFTables.insert(RD).second) {
1636  // We haven't processed this record type before.
1637  // Queue up this vtable for possible deferred emission.
1638  CGM.addDeferredVTable(RD);
1639 
1640 #ifndef NDEBUG
1641  // Create all the vftables at once in order to make sure each vftable has
1642  // a unique mangled name.
1643  llvm::StringSet<> ObservedMangledNames;
1644  for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
1646  mangleVFTableName(getMangleContext(), RD, VFPtrs[J], Name);
1647  if (!ObservedMangledNames.insert(Name.str()).second)
1648  llvm_unreachable("Already saw this mangling before?");
1649  }
1650 #endif
1651  }
1652 
1653  VPtrInfo *const *VFPtrI =
1654  std::find_if(VFPtrs.begin(), VFPtrs.end(), [&](VPtrInfo *VPI) {
1655  return VPI->FullOffsetInMDC == VPtrOffset;
1656  });
1657  if (VFPtrI == VFPtrs.end()) {
1658  VFTablesMap[ID] = nullptr;
1659  return nullptr;
1660  }
1661  VPtrInfo *VFPtr = *VFPtrI;
1662 
1663  SmallString<256> VFTableName;
1664  mangleVFTableName(getMangleContext(), RD, VFPtr, VFTableName);
1665 
1666  // Classes marked __declspec(dllimport) need vftables generated on the
1667  // import-side in order to support features like constexpr. No other
1668  // translation unit relies on the emission of the local vftable, translation
1669  // units are expected to generate them as needed.
1670  //
1671  // Because of this unique behavior, we maintain this logic here instead of
1672  // getVTableLinkage.
1673  llvm::GlobalValue::LinkageTypes VFTableLinkage =
1674  RD->hasAttr<DLLImportAttr>() ? llvm::GlobalValue::LinkOnceODRLinkage
1675  : CGM.getVTableLinkage(RD);
1676  bool VFTableComesFromAnotherTU =
1677  llvm::GlobalValue::isAvailableExternallyLinkage(VFTableLinkage) ||
1678  llvm::GlobalValue::isExternalLinkage(VFTableLinkage);
1679  bool VTableAliasIsRequred =
1680  !VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData;
1681 
1682  if (llvm::GlobalValue *VFTable =
1683  CGM.getModule().getNamedGlobal(VFTableName)) {
1684  VFTablesMap[ID] = VFTable;
1685  VTable = VTableAliasIsRequred
1686  ? cast<llvm::GlobalVariable>(
1687  cast<llvm::GlobalAlias>(VFTable)->getBaseObject())
1688  : cast<llvm::GlobalVariable>(VFTable);
1689  return VTable;
1690  }
1691 
1692  uint64_t NumVTableSlots =
1693  VTContext.getVFTableLayout(RD, VFPtr->FullOffsetInMDC)
1695  llvm::GlobalValue::LinkageTypes VTableLinkage =
1696  VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage;
1697 
1698  StringRef VTableName = VTableAliasIsRequred ? StringRef() : VFTableName.str();
1699 
1700  llvm::ArrayType *VTableType =
1701  llvm::ArrayType::get(CGM.Int8PtrTy, NumVTableSlots);
1702 
1703  // Create a backing variable for the contents of VTable. The VTable may
1704  // or may not include space for a pointer to RTTI data.
1705  llvm::GlobalValue *VFTable;
1706  VTable = new llvm::GlobalVariable(CGM.getModule(), VTableType,
1707  /*isConstant=*/true, VTableLinkage,
1708  /*Initializer=*/nullptr, VTableName);
1709  VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1710 
1711  llvm::Comdat *C = nullptr;
1712  if (!VFTableComesFromAnotherTU &&
1713  (llvm::GlobalValue::isWeakForLinker(VFTableLinkage) ||
1714  (llvm::GlobalValue::isLocalLinkage(VFTableLinkage) &&
1715  VTableAliasIsRequred)))
1716  C = CGM.getModule().getOrInsertComdat(VFTableName.str());
1717 
1718  // Only insert a pointer into the VFTable for RTTI data if we are not
1719  // importing it. We never reference the RTTI data directly so there is no
1720  // need to make room for it.
1721  if (VTableAliasIsRequred) {
1722  llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0),
1723  llvm::ConstantInt::get(CGM.IntTy, 1)};
1724  // Create a GEP which points just after the first entry in the VFTable,
1725  // this should be the location of the first virtual method.
1726  llvm::Constant *VTableGEP = llvm::ConstantExpr::getInBoundsGetElementPtr(
1727  VTable->getValueType(), VTable, GEPIndices);
1728  if (llvm::GlobalValue::isWeakForLinker(VFTableLinkage)) {
1729  VFTableLinkage = llvm::GlobalValue::ExternalLinkage;
1730  if (C)
1731  C->setSelectionKind(llvm::Comdat::Largest);
1732  }
1733  VFTable = llvm::GlobalAlias::create(CGM.Int8PtrTy,
1734  /*AddressSpace=*/0, VFTableLinkage,
1735  VFTableName.str(), VTableGEP,
1736  &CGM.getModule());
1737  VFTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1738  } else {
1739  // We don't need a GlobalAlias to be a symbol for the VTable if we won't
1740  // be referencing any RTTI data.
1741  // The GlobalVariable will end up being an appropriate definition of the
1742  // VFTable.
1743  VFTable = VTable;
1744  }
1745  if (C)
1746  VTable->setComdat(C);
1747 
1748  if (RD->hasAttr<DLLExportAttr>())
1749  VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1750 
1751  VFTablesMap[ID] = VFTable;
1752  return VTable;
1753 }
1754 
1755 // Compute the identity of the most derived class whose virtual table is located
1756 // at the given offset into RD.
1758  const CXXRecordDecl *RD,
1759  CharUnits Offset) {
1760  if (Offset.isZero())
1761  return RD;
1762 
1763  const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
1764  const CXXRecordDecl *MaxBase = nullptr;
1765  CharUnits MaxBaseOffset;
1766  for (auto &&B : RD->bases()) {
1767  const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl();
1768  CharUnits BaseOffset = Layout.getBaseClassOffset(Base);
1769  if (BaseOffset <= Offset && BaseOffset >= MaxBaseOffset) {
1770  MaxBase = Base;
1771  MaxBaseOffset = BaseOffset;
1772  }
1773  }
1774  for (auto &&B : RD->vbases()) {
1775  const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl();
1776  CharUnits BaseOffset = Layout.getVBaseClassOffset(Base);
1777  if (BaseOffset <= Offset && BaseOffset >= MaxBaseOffset) {
1778  MaxBase = Base;
1779  MaxBaseOffset = BaseOffset;
1780  }
1781  }
1782  assert(MaxBase);
1783  return getClassAtVTableLocation(Ctx, MaxBase, Offset - MaxBaseOffset);
1784 }
1785 
1786 // Compute the identity of the most derived class whose virtual table is located
1787 // at the MethodVFTableLocation ML.
1788 static const CXXRecordDecl *
1791  const CXXRecordDecl *RD = ML.VBase;
1792  if (!RD)
1793  RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
1794 
1795  return getClassAtVTableLocation(Ctx, RD, ML.VFPtrOffset);
1796 }
1797 
1798 llvm::Value *MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1799  GlobalDecl GD,
1800  Address This,
1801  llvm::Type *Ty,
1802  SourceLocation Loc) {
1803  GD = GD.getCanonicalDecl();
1804  CGBuilderTy &Builder = CGF.Builder;
1805 
1806  Ty = Ty->getPointerTo()->getPointerTo();
1807  Address VPtr =
1808  adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
1809 
1810  auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1811  llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty, MethodDecl->getParent());
1812 
1814  CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD);
1815 
1816  if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1817  return CGF.EmitVTableTypeCheckedLoad(
1818  getClassAtVTableLocation(getContext(), GD, ML), VTable,
1819  ML.Index * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1820  } else {
1821  if (CGM.getCodeGenOpts().PrepareForLTO)
1823  getClassAtVTableLocation(getContext(), GD, ML), VTable, Loc);
1824 
1825  llvm::Value *VFuncPtr =
1826  Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
1827  return Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1828  }
1829 }
1830 
1831 llvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall(
1832  CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1833  Address This, const CXXMemberCallExpr *CE) {
1834  assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1835  assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1836 
1837  // We have only one destructor in the vftable but can get both behaviors
1838  // by passing an implicit int parameter.
1839  GlobalDecl GD(Dtor, Dtor_Deleting);
1840  const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1841  Dtor, StructorType::Deleting);
1842  llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1843  llvm::Value *Callee = getVirtualFunctionPointer(
1844  CGF, GD, This, Ty, CE ? CE->getLocStart() : SourceLocation());
1845 
1846  ASTContext &Context = getContext();
1847  llvm::Value *ImplicitParam = llvm::ConstantInt::get(
1848  llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()),
1849  DtorType == Dtor_Deleting);
1850 
1851  This = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
1852  RValue RV =
1853  CGF.EmitCXXDestructorCall(Dtor, Callee, This.getPointer(), ImplicitParam,
1854  Context.IntTy, CE, StructorType::Deleting);
1855  return RV.getScalarVal();
1856 }
1857 
1858 const VBTableGlobals &
1859 MicrosoftCXXABI::enumerateVBTables(const CXXRecordDecl *RD) {
1860  // At this layer, we can key the cache off of a single class, which is much
1861  // easier than caching each vbtable individually.
1863  bool Added;
1864  std::tie(Entry, Added) =
1865  VBTablesMap.insert(std::make_pair(RD, VBTableGlobals()));
1866  VBTableGlobals &VBGlobals = Entry->second;
1867  if (!Added)
1868  return VBGlobals;
1869 
1870  MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext();
1871  VBGlobals.VBTables = &Context.enumerateVBTables(RD);
1872 
1873  // Cache the globals for all vbtables so we don't have to recompute the
1874  // mangled names.
1875  llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1876  for (VPtrInfoVector::const_iterator I = VBGlobals.VBTables->begin(),
1877  E = VBGlobals.VBTables->end();
1878  I != E; ++I) {
1879  VBGlobals.Globals.push_back(getAddrOfVBTable(**I, RD, Linkage));
1880  }
1881 
1882  return VBGlobals;
1883 }
1884 
1885 llvm::Function *MicrosoftCXXABI::EmitVirtualMemPtrThunk(
1886  const CXXMethodDecl *MD,
1888  assert(!isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) &&
1889  "can't form pointers to ctors or virtual dtors");
1890 
1891  // Calculate the mangled name.
1892  SmallString<256> ThunkName;
1893  llvm::raw_svector_ostream Out(ThunkName);
1894  getMangleContext().mangleVirtualMemPtrThunk(MD, Out);
1895 
1896  // If the thunk has been generated previously, just return it.
1897  if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName))
1898  return cast<llvm::Function>(GV);
1899 
1900  // Create the llvm::Function.
1901  const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSMemberPointerThunk(MD);
1902  llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
1903  llvm::Function *ThunkFn =
1905  ThunkName.str(), &CGM.getModule());
1906  assert(ThunkFn->getName() == ThunkName && "name was uniqued!");
1907 
1908  ThunkFn->setLinkage(MD->isExternallyVisible()
1909  ? llvm::GlobalValue::LinkOnceODRLinkage
1911  if (MD->isExternallyVisible())
1912  ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
1913 
1914  CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn);
1915  CGM.SetLLVMFunctionAttributesForDefinition(MD, ThunkFn);
1916 
1917  // Add the "thunk" attribute so that LLVM knows that the return type is
1918  // meaningless. These thunks can be used to call functions with differing
1919  // return types, and the caller is required to cast the prototype
1920  // appropriately to extract the correct value.
1921  ThunkFn->addFnAttr("thunk");
1922 
1923  // These thunks can be compared, so they are not unnamed.
1924  ThunkFn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);
1925 
1926  // Start codegen.
1927  CodeGenFunction CGF(CGM);
1928  CGF.CurGD = GlobalDecl(MD);
1929  CGF.CurFuncIsThunk = true;
1930 
1931  // Build FunctionArgs, but only include the implicit 'this' parameter
1932  // declaration.
1933  FunctionArgList FunctionArgs;
1934  buildThisParam(CGF, FunctionArgs);
1935 
1936  // Start defining the function.
1937  CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
1938  FunctionArgs, MD->getLocation(), SourceLocation());
1939  EmitThisParam(CGF);
1940 
1941  // Load the vfptr and then callee from the vftable. The callee should have
1942  // adjusted 'this' so that the vfptr is at offset zero.
1943  llvm::Value *VTable = CGF.GetVTablePtr(
1944  getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent());
1945 
1946  llvm::Value *VFuncPtr =
1947  CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
1948  llvm::Value *Callee =
1949  CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1950 
1951  CGF.EmitMustTailThunk(MD, getThisValue(CGF), Callee);
1952 
1953  return ThunkFn;
1954 }
1955 
1956 void MicrosoftCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1957  const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
1958  for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
1959  const VPtrInfo *VBT = (*VBGlobals.VBTables)[I];
1960  llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1961  if (GV->isDeclaration())
1962  emitVBTableDefinition(*VBT, RD, GV);
1963  }
1964 }
1965 
1966 llvm::GlobalVariable *
1967 MicrosoftCXXABI::getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD,
1968  llvm::GlobalVariable::LinkageTypes Linkage) {
1969  SmallString<256> OutName;
1970  llvm::raw_svector_ostream Out(OutName);
1971  getMangleContext().mangleCXXVBTable(RD, VBT.MangledPath, Out);
1972  StringRef Name = OutName.str();
1973 
1974  llvm::ArrayType *VBTableType =
1975  llvm::ArrayType::get(CGM.IntTy, 1 + VBT.ReusingBase->getNumVBases());
1976 
1977  assert(!CGM.getModule().getNamedGlobal(Name) &&
1978  "vbtable with this name already exists: mangling bug?");
1979  llvm::GlobalVariable *GV =
1980  CGM.CreateOrReplaceCXXRuntimeVariable(Name, VBTableType, Linkage);
1981  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1982 
1983  if (RD->hasAttr<DLLImportAttr>())
1984  GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1985  else if (RD->hasAttr<DLLExportAttr>())
1986  GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1987 
1988  if (!GV->hasExternalLinkage())
1989  emitVBTableDefinition(VBT, RD, GV);
1990 
1991  return GV;
1992 }
1993 
1994 void MicrosoftCXXABI::emitVBTableDefinition(const VPtrInfo &VBT,
1995  const CXXRecordDecl *RD,
1996  llvm::GlobalVariable *GV) const {
1997  const CXXRecordDecl *ReusingBase = VBT.ReusingBase;
1998 
1999  assert(RD->getNumVBases() && ReusingBase->getNumVBases() &&
2000  "should only emit vbtables for classes with vbtables");
2001 
2002  const ASTRecordLayout &BaseLayout =
2003  getContext().getASTRecordLayout(VBT.BaseWithVPtr);
2004  const ASTRecordLayout &DerivedLayout = getContext().getASTRecordLayout(RD);
2005 
2006  SmallVector<llvm::Constant *, 4> Offsets(1 + ReusingBase->getNumVBases(),
2007  nullptr);
2008 
2009  // The offset from ReusingBase's vbptr to itself always leads.
2010  CharUnits VBPtrOffset = BaseLayout.getVBPtrOffset();
2011  Offsets[0] = llvm::ConstantInt::get(CGM.IntTy, -VBPtrOffset.getQuantity());
2012 
2013  MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext();
2014  for (const auto &I : ReusingBase->vbases()) {
2015  const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl();
2016  CharUnits Offset = DerivedLayout.getVBaseClassOffset(VBase);
2017  assert(!Offset.isNegative());
2018 
2019  // Make it relative to the subobject vbptr.
2020  CharUnits CompleteVBPtrOffset = VBT.NonVirtualOffset + VBPtrOffset;
2021  if (VBT.getVBaseWithVPtr())
2022  CompleteVBPtrOffset +=
2023  DerivedLayout.getVBaseClassOffset(VBT.getVBaseWithVPtr());
2024  Offset -= CompleteVBPtrOffset;
2025 
2026  unsigned VBIndex = Context.getVBTableIndex(ReusingBase, VBase);
2027  assert(Offsets[VBIndex] == nullptr && "The same vbindex seen twice?");
2028  Offsets[VBIndex] = llvm::ConstantInt::get(CGM.IntTy, Offset.getQuantity());
2029  }
2030 
2031  assert(Offsets.size() ==
2032  cast<llvm::ArrayType>(cast<llvm::PointerType>(GV->getType())
2033  ->getElementType())->getNumElements());
2034  llvm::ArrayType *VBTableType =
2035  llvm::ArrayType::get(CGM.IntTy, Offsets.size());
2036  llvm::Constant *Init = llvm::ConstantArray::get(VBTableType, Offsets);
2037  GV->setInitializer(Init);
2038 
2039  if (RD->hasAttr<DLLImportAttr>())
2040  GV->setLinkage(llvm::GlobalVariable::AvailableExternallyLinkage);
2041 }
2042 
2043 llvm::Value *MicrosoftCXXABI::performThisAdjustment(CodeGenFunction &CGF,
2044  Address This,
2045  const ThisAdjustment &TA) {
2046  if (TA.isEmpty())
2047  return This.getPointer();
2048 
2049  This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
2050 
2051  llvm::Value *V;
2052  if (TA.Virtual.isEmpty()) {
2053  V = This.getPointer();
2054  } else {
2055  assert(TA.Virtual.Microsoft.VtordispOffset < 0);
2056  // Adjust the this argument based on the vtordisp value.
2057  Address VtorDispPtr =
2060  VtorDispPtr = CGF.Builder.CreateElementBitCast(VtorDispPtr, CGF.Int32Ty);
2061  llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp");
2062  V = CGF.Builder.CreateGEP(This.getPointer(),
2063  CGF.Builder.CreateNeg(VtorDisp));
2064 
2065  // Unfortunately, having applied the vtordisp means that we no
2066  // longer really have a known alignment for the vbptr step.
2067  // We'll assume the vbptr is pointer-aligned.
2068 
2069  if (TA.Virtual.Microsoft.VBPtrOffset) {
2070  // If the final overrider is defined in a virtual base other than the one
2071  // that holds the vfptr, we have to use a vtordispex thunk which looks up
2072  // the vbtable of the derived class.
2073  assert(TA.Virtual.Microsoft.VBPtrOffset > 0);
2074  assert(TA.Virtual.Microsoft.VBOffsetOffset >= 0);
2075  llvm::Value *VBPtr;
2076  llvm::Value *VBaseOffset =
2077  GetVBaseOffsetFromVBPtr(CGF, Address(V, CGF.getPointerAlign()),
2079  TA.Virtual.Microsoft.VBOffsetOffset, &VBPtr);
2080  V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2081  }
2082  }
2083 
2084  if (TA.NonVirtual) {
2085  // Non-virtual adjustment might result in a pointer outside the allocated
2086  // object, e.g. if the final overrider class is laid out after the virtual
2087  // base that declares a method in the most derived class.
2088  V = CGF.Builder.CreateConstGEP1_32(V, TA.NonVirtual);
2089  }
2090 
2091  // Don't need to bitcast back, the call CodeGen will handle this.
2092  return V;
2093 }
2094 
2095 llvm::Value *
2096 MicrosoftCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
2097  const ReturnAdjustment &RA) {
2098  if (RA.isEmpty())
2099  return Ret.getPointer();
2100 
2101  auto OrigTy = Ret.getType();
2102  Ret = CGF.Builder.CreateElementBitCast(Ret, CGF.Int8Ty);
2103 
2104  llvm::Value *V = Ret.getPointer();
2105  if (RA.Virtual.Microsoft.VBIndex) {
2106  assert(RA.Virtual.Microsoft.VBIndex > 0);
2107  int32_t IntSize = CGF.getIntSize().getQuantity();
2108  llvm::Value *VBPtr;
2109  llvm::Value *VBaseOffset =
2110  GetVBaseOffsetFromVBPtr(CGF, Ret, RA.Virtual.Microsoft.VBPtrOffset,
2111  IntSize * RA.Virtual.Microsoft.VBIndex, &VBPtr);
2112  V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2113  }
2114 
2115  if (RA.NonVirtual)
2116  V = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, V, RA.NonVirtual);
2117 
2118  // Cast back to the original type.
2119  return CGF.Builder.CreateBitCast(V, OrigTy);
2120 }
2121 
2122 bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
2123  QualType elementType) {
2124  // Microsoft seems to completely ignore the possibility of a
2125  // two-argument usual deallocation function.
2126  return elementType.isDestructedType();
2127 }
2128 
2129 bool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
2130  // Microsoft seems to completely ignore the possibility of a
2131  // two-argument usual deallocation function.
2132  return expr->getAllocatedType().isDestructedType();
2133 }
2134 
2135 CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
2136  // The array cookie is always a size_t; we then pad that out to the
2137  // alignment of the element type.
2138  ASTContext &Ctx = getContext();
2139  return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
2140  Ctx.getTypeAlignInChars(type));
2141 }
2142 
2143 llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2144  Address allocPtr,
2145  CharUnits cookieSize) {
2146  Address numElementsPtr =
2147  CGF.Builder.CreateElementBitCast(allocPtr, CGF.SizeTy);
2148  return CGF.Builder.CreateLoad(numElementsPtr);
2149 }
2150 
2151 Address MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2152  Address newPtr,
2153  llvm::Value *numElements,
2154  const CXXNewExpr *expr,
2155  QualType elementType) {
2156  assert(requiresArrayCookie(expr));
2157 
2158  // The size of the cookie.
2159  CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
2160 
2161  // Compute an offset to the cookie.
2162  Address cookiePtr = newPtr;
2163 
2164  // Write the number of elements into the appropriate slot.
2165  Address numElementsPtr
2166  = CGF.Builder.CreateElementBitCast(cookiePtr, CGF.SizeTy);
2167  CGF.Builder.CreateStore(numElements, numElementsPtr);
2168 
2169  // Finally, compute a pointer to the actual data buffer by skipping
2170  // over the cookie completely.
2171  return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2172 }
2173 
2175  llvm::Constant *Dtor,
2176  llvm::Constant *Addr) {
2177  // Create a function which calls the destructor.
2178  llvm::Constant *DtorStub = CGF.createAtExitStub(VD, Dtor, Addr);
2179 
2180  // extern "C" int __tlregdtor(void (*f)(void));
2181  llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(
2182  CGF.IntTy, DtorStub->getType(), /*IsVarArg=*/false);
2183 
2184  llvm::Constant *TLRegDtor =
2185  CGF.CGM.CreateRuntimeFunction(TLRegDtorTy, "__tlregdtor");
2186  if (llvm::Function *TLRegDtorFn = dyn_cast<llvm::Function>(TLRegDtor))
2187  TLRegDtorFn->setDoesNotThrow();
2188 
2189  CGF.EmitNounwindRuntimeCall(TLRegDtor, DtorStub);
2190 }
2191 
2192 void MicrosoftCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2193  llvm::Constant *Dtor,
2194  llvm::Constant *Addr) {
2195  if (D.getTLSKind())
2196  return emitGlobalDtorWithTLRegDtor(CGF, D, Dtor, Addr);
2197 
2198  // The default behavior is to use atexit.
2199  CGF.registerGlobalDtorWithAtExit(D, Dtor, Addr);
2200 }
2201 
2202 void MicrosoftCXXABI::EmitThreadLocalInitFuncs(
2203  CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2204  ArrayRef<llvm::Function *> CXXThreadLocalInits,
2205  ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2206  // This will create a GV in the .CRT$XDU section. It will point to our
2207  // initialization function. The CRT will call all of these function
2208  // pointers at start-up time and, eventually, at thread-creation time.
2209  auto AddToXDU = [&CGM](llvm::Function *InitFunc) {
2210  llvm::GlobalVariable *InitFuncPtr = new llvm::GlobalVariable(
2211  CGM.getModule(), InitFunc->getType(), /*IsConstant=*/true,
2213  Twine(InitFunc->getName(), "$initializer$"));
2214  InitFuncPtr->setSection(".CRT$XDU");
2215  // This variable has discardable linkage, we have to add it to @llvm.used to
2216  // ensure it won't get discarded.
2217  CGM.addUsedGlobal(InitFuncPtr);
2218  return InitFuncPtr;
2219  };
2220 
2221  std::vector<llvm::Function *> NonComdatInits;
2222  for (size_t I = 0, E = CXXThreadLocalInitVars.size(); I != E; ++I) {
2223  llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(
2224  CGM.GetGlobalValue(CGM.getMangledName(CXXThreadLocalInitVars[I])));
2225  llvm::Function *F = CXXThreadLocalInits[I];
2226 
2227  // If the GV is already in a comdat group, then we have to join it.
2228  if (llvm::Comdat *C = GV->getComdat())
2229  AddToXDU(F)->setComdat(C);
2230  else
2231  NonComdatInits.push_back(F);
2232  }
2233 
2234  if (!NonComdatInits.empty()) {
2235  llvm::FunctionType *FTy =
2236  llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2237  llvm::Function *InitFunc = CGM.CreateGlobalInitOrDestructFunction(
2238  FTy, "__tls_init", CGM.getTypes().arrangeNullaryFunction(),
2239  SourceLocation(), /*TLS=*/true);
2240  CodeGenFunction(CGM).GenerateCXXGlobalInitFunc(InitFunc, NonComdatInits);
2241 
2242  AddToXDU(InitFunc);
2243  }
2244 }
2245 
2246 LValue MicrosoftCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2247  const VarDecl *VD,
2248  QualType LValType) {
2249  CGF.CGM.ErrorUnsupported(VD, "thread wrappers");
2250  return LValue();
2251 }
2252 
2254  StringRef VarName("_Init_thread_epoch");
2255  CharUnits Align = CGM.getIntAlign();
2256  if (auto *GV = CGM.getModule().getNamedGlobal(VarName))
2257  return ConstantAddress(GV, Align);
2258  auto *GV = new llvm::GlobalVariable(
2259  CGM.getModule(), CGM.IntTy,
2260  /*Constant=*/false, llvm::GlobalVariable::ExternalLinkage,
2261  /*Initializer=*/nullptr, VarName,
2262  /*InsertBefore=*/nullptr, llvm::GlobalVariable::GeneralDynamicTLSModel);
2263  GV->setAlignment(Align.getQuantity());
2264  return ConstantAddress(GV, Align);
2265 }
2266 
2267 static llvm::Constant *getInitThreadHeaderFn(CodeGenModule &CGM) {
2268  llvm::FunctionType *FTy =
2269  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2270  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2271  return CGM.CreateRuntimeFunction(
2272  FTy, "_Init_thread_header",
2273  llvm::AttributeSet::get(CGM.getLLVMContext(),
2274  llvm::AttributeSet::FunctionIndex,
2275  llvm::Attribute::NoUnwind));
2276 }
2277 
2278 static llvm::Constant *getInitThreadFooterFn(CodeGenModule &CGM) {
2279  llvm::FunctionType *FTy =
2280  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2281  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2282  return CGM.CreateRuntimeFunction(
2283  FTy, "_Init_thread_footer",
2284  llvm::AttributeSet::get(CGM.getLLVMContext(),
2285  llvm::AttributeSet::FunctionIndex,
2286  llvm::Attribute::NoUnwind));
2287 }
2288 
2289 static llvm::Constant *getInitThreadAbortFn(CodeGenModule &CGM) {
2290  llvm::FunctionType *FTy =
2291  llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2292  CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
2293  return CGM.CreateRuntimeFunction(
2294  FTy, "_Init_thread_abort",
2295  llvm::AttributeSet::get(CGM.getLLVMContext(),
2296  llvm::AttributeSet::FunctionIndex,
2297  llvm::Attribute::NoUnwind));
2298 }
2299 
2300 namespace {
2301 struct ResetGuardBit final : EHScopeStack::Cleanup {
2302  Address Guard;
2303  unsigned GuardNum;
2304  ResetGuardBit(Address Guard, unsigned GuardNum)
2305  : Guard(Guard), GuardNum(GuardNum) {}
2306 
2307  void Emit(CodeGenFunction &CGF, Flags flags) override {
2308  // Reset the bit in the mask so that the static variable may be
2309  // reinitialized.
2310  CGBuilderTy &Builder = CGF.Builder;
2311  llvm::LoadInst *LI = Builder.CreateLoad(Guard);
2312  llvm::ConstantInt *Mask =
2313  llvm::ConstantInt::get(CGF.IntTy, ~(1ULL << GuardNum));
2314  Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard);
2315  }
2316 };
2317 
2318 struct CallInitThreadAbort final : EHScopeStack::Cleanup {
2319  llvm::Value *Guard;
2320  CallInitThreadAbort(Address Guard) : Guard(Guard.getPointer()) {}
2321 
2322  void Emit(CodeGenFunction &CGF, Flags flags) override {
2323  // Calling _Init_thread_abort will reset the guard's state.
2325  }
2326 };
2327 }
2328 
2329 void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
2330  llvm::GlobalVariable *GV,
2331  bool PerformInit) {
2332  // MSVC only uses guards for static locals.
2333  if (!D.isStaticLocal()) {
2334  assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage());
2335  // GlobalOpt is allowed to discard the initializer, so use linkonce_odr.
2336  llvm::Function *F = CGF.CurFn;
2337  F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
2338  F->setComdat(CGM.getModule().getOrInsertComdat(F->getName()));
2339  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2340  return;
2341  }
2342 
2343  bool ThreadlocalStatic = D.getTLSKind();
2344  bool ThreadsafeStatic = getContext().getLangOpts().ThreadsafeStatics;
2345 
2346  // Thread-safe static variables which aren't thread-specific have a
2347  // per-variable guard.
2348  bool HasPerVariableGuard = ThreadsafeStatic && !ThreadlocalStatic;
2349 
2350  CGBuilderTy &Builder = CGF.Builder;
2351  llvm::IntegerType *GuardTy = CGF.Int32Ty;
2352  llvm::ConstantInt *Zero = llvm::ConstantInt::get(GuardTy, 0);
2353  CharUnits GuardAlign = CharUnits::fromQuantity(4);
2354 
2355  // Get the guard variable for this function if we have one already.
2356  GuardInfo *GI = nullptr;
2357  if (ThreadlocalStatic)
2358  GI = &ThreadLocalGuardVariableMap[D.getDeclContext()];
2359  else if (!ThreadsafeStatic)
2360  GI = &GuardVariableMap[D.getDeclContext()];
2361 
2362  llvm::GlobalVariable *GuardVar = GI ? GI->Guard : nullptr;
2363  unsigned GuardNum;
2364  if (D.isExternallyVisible()) {
2365  // Externally visible variables have to be numbered in Sema to properly
2366  // handle unreachable VarDecls.
2367  GuardNum = getContext().getStaticLocalNumber(&D);
2368  assert(GuardNum > 0);
2369  GuardNum--;
2370  } else if (HasPerVariableGuard) {
2371  GuardNum = ThreadSafeGuardNumMap[D.getDeclContext()]++;
2372  } else {
2373  // Non-externally visible variables are numbered here in CodeGen.
2374  GuardNum = GI->BitIndex++;
2375  }
2376 
2377  if (!HasPerVariableGuard && GuardNum >= 32) {
2378  if (D.isExternallyVisible())
2379  ErrorUnsupportedABI(CGF, "more than 32 guarded initializations");
2380  GuardNum %= 32;
2381  GuardVar = nullptr;
2382  }
2383 
2384  if (!GuardVar) {
2385  // Mangle the name for the guard.
2386  SmallString<256> GuardName;
2387  {
2388  llvm::raw_svector_ostream Out(GuardName);
2389  if (HasPerVariableGuard)
2390  getMangleContext().mangleThreadSafeStaticGuardVariable(&D, GuardNum,
2391  Out);
2392  else
2393  getMangleContext().mangleStaticGuardVariable(&D, Out);
2394  }
2395 
2396  // Create the guard variable with a zero-initializer. Just absorb linkage,
2397  // visibility and dll storage class from the guarded variable.
2398  GuardVar =
2399  new llvm::GlobalVariable(CGM.getModule(), GuardTy, /*isConstant=*/false,
2400  GV->getLinkage(), Zero, GuardName.str());
2401  GuardVar->setVisibility(GV->getVisibility());
2402  GuardVar->setDLLStorageClass(GV->getDLLStorageClass());
2403  GuardVar->setAlignment(GuardAlign.getQuantity());
2404  if (GuardVar->isWeakForLinker())
2405  GuardVar->setComdat(
2406  CGM.getModule().getOrInsertComdat(GuardVar->getName()));
2407  if (D.getTLSKind())
2408  GuardVar->setThreadLocal(true);
2409  if (GI && !HasPerVariableGuard)
2410  GI->Guard = GuardVar;
2411  }
2412 
2413  ConstantAddress GuardAddr(GuardVar, GuardAlign);
2414 
2415  assert(GuardVar->getLinkage() == GV->getLinkage() &&
2416  "static local from the same function had different linkage");
2417 
2418  if (!HasPerVariableGuard) {
2419  // Pseudo code for the test:
2420  // if (!(GuardVar & MyGuardBit)) {
2421  // GuardVar |= MyGuardBit;
2422  // ... initialize the object ...;
2423  // }
2424 
2425  // Test our bit from the guard variable.
2426  llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);
2427  llvm::LoadInst *LI = Builder.CreateLoad(GuardAddr);
2428  llvm::Value *IsInitialized =
2429  Builder.CreateICmpNE(Builder.CreateAnd(LI, Bit), Zero);
2430  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2431  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2432  Builder.CreateCondBr(IsInitialized, EndBlock, InitBlock);
2433 
2434  // Set our bit in the guard variable and emit the initializer and add a global
2435  // destructor if appropriate.
2436  CGF.EmitBlock(InitBlock);
2437  Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr);
2438  CGF.EHStack.pushCleanup<ResetGuardBit>(EHCleanup, GuardAddr, GuardNum);
2439  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2440  CGF.PopCleanupBlock();
2441  Builder.CreateBr(EndBlock);
2442 
2443  // Continue.
2444  CGF.EmitBlock(EndBlock);
2445  } else {
2446  // Pseudo code for the test:
2447  // if (TSS > _Init_thread_epoch) {
2448  // _Init_thread_header(&TSS);
2449  // if (TSS == -1) {
2450  // ... initialize the object ...;
2451  // _Init_thread_footer(&TSS);
2452  // }
2453  // }
2454  //
2455  // The algorithm is almost identical to what can be found in the appendix
2456  // found in N2325.
2457 
2458  // This BasicBLock determines whether or not we have any work to do.
2459  llvm::LoadInst *FirstGuardLoad = Builder.CreateLoad(GuardAddr);
2460  FirstGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2461  llvm::LoadInst *InitThreadEpoch =
2462  Builder.CreateLoad(getInitThreadEpochPtr(CGM));
2463  llvm::Value *IsUninitialized =
2464  Builder.CreateICmpSGT(FirstGuardLoad, InitThreadEpoch);
2465  llvm::BasicBlock *AttemptInitBlock = CGF.createBasicBlock("init.attempt");
2466  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2467  Builder.CreateCondBr(IsUninitialized, AttemptInitBlock, EndBlock);
2468 
2469  // This BasicBlock attempts to determine whether or not this thread is
2470  // responsible for doing the initialization.
2471  CGF.EmitBlock(AttemptInitBlock);
2473  GuardAddr.getPointer());
2474  llvm::LoadInst *SecondGuardLoad = Builder.CreateLoad(GuardAddr);
2475  SecondGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2476  llvm::Value *ShouldDoInit =
2477  Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt());
2478  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2479  Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);
2480 
2481  // Ok, we ended up getting selected as the initializing thread.
2482  CGF.EmitBlock(InitBlock);
2483  CGF.EHStack.pushCleanup<CallInitThreadAbort>(EHCleanup, GuardAddr);
2484  CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit);
2485  CGF.PopCleanupBlock();
2487  GuardAddr.getPointer());
2488  Builder.CreateBr(EndBlock);
2489 
2490  CGF.EmitBlock(EndBlock);
2491  }
2492 }
2493 
2494 bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
2495  // Null-ness for function memptrs only depends on the first field, which is
2496  // the function pointer. The rest don't matter, so we can zero initialize.
2497  if (MPT->isMemberFunctionPointer())
2498  return true;
2499 
2500  // The virtual base adjustment field is always -1 for null, so if we have one
2501  // we can't zero initialize. The field offset is sometimes also -1 if 0 is a
2502  // valid field offset.
2503  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2504  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2505  return (!MSInheritanceAttr::hasVBTableOffsetField(Inheritance) &&
2506  RD->nullFieldOffsetIsZero());
2507 }
2508 
2509 llvm::Type *
2510 MicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
2511  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2512  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2514  if (MPT->isMemberFunctionPointer())
2515  fields.push_back(CGM.VoidPtrTy); // FunctionPointerOrVirtualThunk
2516  else
2517  fields.push_back(CGM.IntTy); // FieldOffset
2518 
2519  if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
2520  Inheritance))
2521  fields.push_back(CGM.IntTy);
2522  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2523  fields.push_back(CGM.IntTy);
2524  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2525  fields.push_back(CGM.IntTy); // VirtualBaseAdjustmentOffset
2526 
2527  if (fields.size() == 1)
2528  return fields[0];
2529  return llvm::StructType::get(CGM.getLLVMContext(), fields);
2530 }
2531 
2532 void MicrosoftCXXABI::
2533 GetNullMemberPointerFields(const MemberPointerType *MPT,
2535  assert(fields.empty());
2536  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2537  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2538  if (MPT->isMemberFunctionPointer()) {
2539  // FunctionPointerOrVirtualThunk
2540  fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
2541  } else {
2542  if (RD->nullFieldOffsetIsZero())
2543  fields.push_back(getZeroInt()); // FieldOffset
2544  else
2545  fields.push_back(getAllOnesInt()); // FieldOffset
2546  }
2547 
2548  if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
2549  Inheritance))
2550  fields.push_back(getZeroInt());
2551  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2552  fields.push_back(getZeroInt());
2553  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2554  fields.push_back(getAllOnesInt());
2555 }
2556 
2557 llvm::Constant *
2558 MicrosoftCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
2560  GetNullMemberPointerFields(MPT, fields);
2561  if (fields.size() == 1)
2562  return fields[0];
2563  llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
2564  assert(Res->getType() == ConvertMemberPointerType(MPT));
2565  return Res;
2566 }
2567 
2568 llvm::Constant *
2569 MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,
2570  bool IsMemberFunction,
2571  const CXXRecordDecl *RD,
2572  CharUnits NonVirtualBaseAdjustment,
2573  unsigned VBTableIndex) {
2574  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2575 
2576  // Single inheritance class member pointer are represented as scalars instead
2577  // of aggregates.
2578  if (MSInheritanceAttr::hasOnlyOneField(IsMemberFunction, Inheritance))
2579  return FirstField;
2580 
2582  fields.push_back(FirstField);
2583 
2584  if (MSInheritanceAttr::hasNVOffsetField(IsMemberFunction, Inheritance))
2585  fields.push_back(llvm::ConstantInt::get(
2586  CGM.IntTy, NonVirtualBaseAdjustment.getQuantity()));
2587 
2588  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) {
2589  CharUnits Offs = CharUnits::Zero();
2590  if (VBTableIndex)
2591  Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
2592  fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity()));
2593  }
2594 
2595  // The rest of the fields are adjusted by conversions to a more derived class.
2596  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2597  fields.push_back(llvm::ConstantInt::get(CGM.IntTy, VBTableIndex));
2598 
2599  return llvm::ConstantStruct::getAnon(fields);
2600 }
2601 
2602 llvm::Constant *
2603 MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
2604  CharUnits offset) {
2605  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2606  if (RD->getMSInheritanceModel() ==
2607  MSInheritanceAttr::Keyword_virtual_inheritance)
2608  offset -= getContext().getOffsetOfBaseWithVBPtr(RD);
2609  llvm::Constant *FirstField =
2610  llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity());
2611  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD,
2612  CharUnits::Zero(), /*VBTableIndex=*/0);
2613 }
2614 
2615 llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP,
2616  QualType MPType) {
2617  const MemberPointerType *DstTy = MPType->castAs<MemberPointerType>();
2618  const ValueDecl *MPD = MP.getMemberPointerDecl();
2619  if (!MPD)
2620  return EmitNullMemberPointer(DstTy);
2621 
2622  ASTContext &Ctx = getContext();
2623  ArrayRef<const CXXRecordDecl *> MemberPointerPath = MP.getMemberPointerPath();
2624 
2625  llvm::Constant *C;
2626  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) {
2627  C = EmitMemberFunctionPointer(MD);
2628  } else {
2629  CharUnits FieldOffset = Ctx.toCharUnitsFromBits(Ctx.getFieldOffset(MPD));
2630  C = EmitMemberDataPointer(DstTy, FieldOffset);
2631  }
2632 
2633  if (!MemberPointerPath.empty()) {
2634  const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext());
2635  const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr();
2636  const MemberPointerType *SrcTy =
2637  Ctx.getMemberPointerType(DstTy->getPointeeType(), SrcRecTy)
2638  ->castAs<MemberPointerType>();
2639 
2640  bool DerivedMember = MP.isMemberPointerToDerivedMember();
2641  SmallVector<const CXXBaseSpecifier *, 4> DerivedToBasePath;
2642  const CXXRecordDecl *PrevRD = SrcRD;
2643  for (const CXXRecordDecl *PathElem : MemberPointerPath) {
2644  const CXXRecordDecl *Base = nullptr;
2645  const CXXRecordDecl *Derived = nullptr;
2646  if (DerivedMember) {
2647  Base = PathElem;
2648  Derived = PrevRD;
2649  } else {
2650  Base = PrevRD;
2651  Derived = PathElem;
2652  }
2653  for (const CXXBaseSpecifier &BS : Derived->bases())
2654  if (BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() ==
2655  Base->getCanonicalDecl())
2656  DerivedToBasePath.push_back(&BS);
2657  PrevRD = PathElem;
2658  }
2659  assert(DerivedToBasePath.size() == MemberPointerPath.size());
2660 
2661  CastKind CK = DerivedMember ? CK_DerivedToBaseMemberPointer
2662  : CK_BaseToDerivedMemberPointer;
2663  C = EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(),
2664  DerivedToBasePath.end(), C);
2665  }
2666  return C;
2667 }
2668 
2669 llvm::Constant *
2670 MicrosoftCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
2671  assert(MD->isInstance() && "Member function must not be static!");
2672 
2673  MD = MD->getCanonicalDecl();
2674  CharUnits NonVirtualBaseAdjustment = CharUnits::Zero();
2675  const CXXRecordDecl *RD = MD->getParent()->getMostRecentDecl();
2676  CodeGenTypes &Types = CGM.getTypes();
2677 
2678  unsigned VBTableIndex = 0;
2679  llvm::Constant *FirstField;
2680  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
2681  if (!MD->isVirtual()) {
2682  llvm::Type *Ty;
2683  // Check whether the function has a computable LLVM signature.
2684  if (Types.isFuncTypeConvertible(FPT)) {
2685  // The function has a computable LLVM signature; use the correct type.
2686  Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
2687  } else {
2688  // Use an arbitrary non-function type to tell GetAddrOfFunction that the
2689  // function type is incomplete.
2690  Ty = CGM.PtrDiffTy;
2691  }
2692  FirstField = CGM.GetAddrOfFunction(MD, Ty);
2693  } else {
2694  auto &VTableContext = CGM.getMicrosoftVTableContext();
2696  VTableContext.getMethodVFTableLocation(MD);
2697  FirstField = EmitVirtualMemPtrThunk(MD, ML);
2698  // Include the vfptr adjustment if the method is in a non-primary vftable.
2699  NonVirtualBaseAdjustment += ML.VFPtrOffset;
2700  if (ML.VBase)
2701  VBTableIndex = VTableContext.getVBTableIndex(RD, ML.VBase) * 4;
2702  }
2703 
2704  if (VBTableIndex == 0 &&
2705  RD->getMSInheritanceModel() ==
2706  MSInheritanceAttr::Keyword_virtual_inheritance)
2707  NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD);
2708 
2709  // The rest of the fields are common with data member pointers.
2710  FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy);
2711  return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD,
2712  NonVirtualBaseAdjustment, VBTableIndex);
2713 }
2714 
2715 /// Member pointers are the same if they're either bitwise identical *or* both
2716 /// null. Null-ness for function members is determined by the first field,
2717 /// while for data member pointers we must compare all fields.
2718 llvm::Value *
2719 MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
2720  llvm::Value *L,
2721  llvm::Value *R,
2722  const MemberPointerType *MPT,
2723  bool Inequality) {
2724  CGBuilderTy &Builder = CGF.Builder;
2725 
2726  // Handle != comparisons by switching the sense of all boolean operations.
2727  llvm::ICmpInst::Predicate Eq;
2728  llvm::Instruction::BinaryOps And, Or;
2729  if (Inequality) {
2730  Eq = llvm::ICmpInst::ICMP_NE;
2731  And = llvm::Instruction::Or;
2733  } else {
2734  Eq = llvm::ICmpInst::ICMP_EQ;
2735  And = llvm::Instruction::And;
2736  Or = llvm::Instruction::Or;
2737  }
2738 
2739  // If this is a single field member pointer (single inheritance), this is a
2740  // single icmp.
2741  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2742  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2743  if (MSInheritanceAttr::hasOnlyOneField(MPT->isMemberFunctionPointer(),
2744  Inheritance))
2745  return Builder.CreateICmp(Eq, L, R);
2746 
2747  // Compare the first field.
2748  llvm::Value *L0 = Builder.CreateExtractValue(L, 0, "lhs.0");
2749  llvm::Value *R0 = Builder.CreateExtractValue(R, 0, "rhs.0");
2750  llvm::Value *Cmp0 = Builder.CreateICmp(Eq, L0, R0, "memptr.cmp.first");
2751 
2752  // Compare everything other than the first field.
2753  llvm::Value *Res = nullptr;
2754  llvm::StructType *LType = cast<llvm::StructType>(L->getType());
2755  for (unsigned I = 1, E = LType->getNumElements(); I != E; ++I) {
2756  llvm::Value *LF = Builder.CreateExtractValue(L, I);
2757  llvm::Value *RF = Builder.CreateExtractValue(R, I);
2758  llvm::Value *Cmp = Builder.CreateICmp(Eq, LF, RF, "memptr.cmp.rest");
2759  if (Res)
2760  Res = Builder.CreateBinOp(And, Res, Cmp);
2761  else
2762  Res = Cmp;
2763  }
2764 
2765  // Check if the first field is 0 if this is a function pointer.
2766  if (MPT->isMemberFunctionPointer()) {
2767  // (l1 == r1 && ...) || l0 == 0
2768  llvm::Value *Zero = llvm::Constant::getNullValue(L0->getType());
2769  llvm::Value *IsZero = Builder.CreateICmp(Eq, L0, Zero, "memptr.cmp.iszero");
2770  Res = Builder.CreateBinOp(Or, Res, IsZero);
2771  }
2772 
2773  // Combine the comparison of the first field, which must always be true for
2774  // this comparison to succeeed.
2775  return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
2776 }
2777 
2778 llvm::Value *
2779 MicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
2780  llvm::Value *MemPtr,
2781  const MemberPointerType *MPT) {
2782  CGBuilderTy &Builder = CGF.Builder;
2784  // We only need one field for member functions.
2785  if (MPT->isMemberFunctionPointer())
2786  fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy));
2787  else
2788  GetNullMemberPointerFields(MPT, fields);
2789  assert(!fields.empty());
2790  llvm::Value *FirstField = MemPtr;
2791  if (MemPtr->getType()->isStructTy())
2792  FirstField = Builder.CreateExtractValue(MemPtr, 0);
2793  llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0], "memptr.cmp0");
2794 
2795  // For function member pointers, we only need to test the function pointer
2796  // field. The other fields if any can be garbage.
2797  if (MPT->isMemberFunctionPointer())
2798  return Res;
2799 
2800  // Otherwise, emit a series of compares and combine the results.
2801  for (int I = 1, E = fields.size(); I < E; ++I) {
2802  llvm::Value *Field = Builder.CreateExtractValue(MemPtr, I);
2803  llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I], "memptr.cmp");
2804  Res = Builder.CreateOr(Res, Next, "memptr.tobool");
2805  }
2806  return Res;
2807 }
2808 
2809 bool MicrosoftCXXABI::MemberPointerConstantIsNull(const MemberPointerType *MPT,
2810  llvm::Constant *Val) {
2811  // Function pointers are null if the pointer in the first field is null.
2812  if (MPT->isMemberFunctionPointer()) {
2813  llvm::Constant *FirstField = Val->getType()->isStructTy() ?
2814  Val->getAggregateElement(0U) : Val;
2815  return FirstField->isNullValue();
2816  }
2817 
2818  // If it's not a function pointer and it's zero initializable, we can easily
2819  // check zero.
2820  if (isZeroInitializable(MPT) && Val->isNullValue())
2821  return true;
2822 
2823  // Otherwise, break down all the fields for comparison. Hopefully these
2824  // little Constants are reused, while a big null struct might not be.
2826  GetNullMemberPointerFields(MPT, Fields);
2827  if (Fields.size() == 1) {
2828  assert(Val->getType()->isIntegerTy());
2829  return Val == Fields[0];
2830  }
2831 
2832  unsigned I, E;
2833  for (I = 0, E = Fields.size(); I != E; ++I) {
2834  if (Val->getAggregateElement(I) != Fields[I])
2835  break;
2836  }
2837  return I == E;
2838 }
2839 
2840 llvm::Value *
2841 MicrosoftCXXABI::GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,
2842  Address This,
2843  llvm::Value *VBPtrOffset,
2844  llvm::Value *VBTableOffset,
2845  llvm::Value **VBPtrOut) {
2846  CGBuilderTy &Builder = CGF.Builder;
2847  // Load the vbtable pointer from the vbptr in the instance.
2848  This = Builder.CreateElementBitCast(This, CGM.Int8Ty);
2849  llvm::Value *VBPtr =
2850  Builder.CreateInBoundsGEP(This.getPointer(), VBPtrOffset, "vbptr");
2851  if (VBPtrOut) *VBPtrOut = VBPtr;
2852  VBPtr = Builder.CreateBitCast(VBPtr,
2853  CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace()));
2854 
2855  CharUnits VBPtrAlign;
2856  if (auto CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) {
2857  VBPtrAlign = This.getAlignment().alignmentAtOffset(
2858  CharUnits::fromQuantity(CI->getSExtValue()));
2859  } else {
2860  VBPtrAlign = CGF.getPointerAlign();
2861  }
2862 
2863  llvm::Value *VBTable = Builder.CreateAlignedLoad(VBPtr, VBPtrAlign, "vbtable");
2864 
2865  // Translate from byte offset to table index. It improves analyzability.
2866  llvm::Value *VBTableIndex = Builder.CreateAShr(
2867  VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2),
2868  "vbtindex", /*isExact=*/true);
2869 
2870  // Load an i32 offset from the vb-table.
2871  llvm::Value *VBaseOffs = Builder.CreateInBoundsGEP(VBTable, VBTableIndex);
2872  VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
2873  return Builder.CreateAlignedLoad(VBaseOffs, CharUnits::fromQuantity(4),
2874  "vbase_offs");
2875 }
2876 
2877 // Returns an adjusted base cast to i8*, since we do more address arithmetic on
2878 // it.
2879 llvm::Value *MicrosoftCXXABI::AdjustVirtualBase(
2880  CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD,
2881  Address Base, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) {
2882  CGBuilderTy &Builder = CGF.Builder;
2883  Base = Builder.CreateElementBitCast(Base, CGM.Int8Ty);
2884  llvm::BasicBlock *OriginalBB = nullptr;
2885  llvm::BasicBlock *SkipAdjustBB = nullptr;
2886  llvm::BasicBlock *VBaseAdjustBB = nullptr;
2887 
2888  // In the unspecified inheritance model, there might not be a vbtable at all,
2889  // in which case we need to skip the virtual base lookup. If there is a
2890  // vbtable, the first entry is a no-op entry that gives back the original
2891  // base, so look for a virtual base adjustment offset of zero.
2892  if (VBPtrOffset) {
2893  OriginalBB = Builder.GetInsertBlock();
2894  VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust");
2895  SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust");
2896  llvm::Value *IsVirtual =
2897  Builder.CreateICmpNE(VBTableOffset, getZeroInt(),
2898  "memptr.is_vbase");
2899  Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
2900  CGF.EmitBlock(VBaseAdjustBB);
2901  }
2902 
2903  // If we weren't given a dynamic vbptr offset, RD should be complete and we'll
2904  // know the vbptr offset.
2905  if (!VBPtrOffset) {
2906  CharUnits offs = CharUnits::Zero();
2907  if (!RD->hasDefinition()) {
2908  DiagnosticsEngine &Diags = CGF.CGM.getDiags();
2909  unsigned DiagID = Diags.getCustomDiagID(
2911  "member pointer representation requires a "
2912  "complete class type for %0 to perform this expression");
2913  Diags.Report(E->getExprLoc(), DiagID) << RD << E->getSourceRange();
2914  } else if (RD->getNumVBases())
2915  offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
2916  VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity());
2917  }
2918  llvm::Value *VBPtr = nullptr;
2919  llvm::Value *VBaseOffs =
2920  GetVBaseOffsetFromVBPtr(CGF, Base, VBPtrOffset, VBTableOffset, &VBPtr);
2921  llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs);
2922 
2923  // Merge control flow with the case where we didn't have to adjust.
2924  if (VBaseAdjustBB) {
2925  Builder.CreateBr(SkipAdjustBB);
2926  CGF.EmitBlock(SkipAdjustBB);
2927  llvm::PHINode *Phi = Builder.CreatePHI(CGM.Int8PtrTy, 2, "memptr.base");
2928  Phi->addIncoming(Base.getPointer(), OriginalBB);
2929  Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
2930  return Phi;
2931  }
2932  return AdjustedBase;
2933 }
2934 
2935 llvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress(
2936  CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
2937  const MemberPointerType *MPT) {
2938  assert(MPT->isMemberDataPointer());
2939  unsigned AS = Base.getAddressSpace();
2940  llvm::Type *PType =
2941  CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
2942  CGBuilderTy &Builder = CGF.Builder;
2943  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
2944  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
2945 
2946  // Extract the fields we need, regardless of model. We'll apply them if we
2947  // have them.
2948  llvm::Value *FieldOffset = MemPtr;
2949  llvm::Value *VirtualBaseAdjustmentOffset = nullptr;
2950  llvm::Value *VBPtrOffset = nullptr;
2951  if (MemPtr->getType()->isStructTy()) {
2952  // We need to extract values.
2953  unsigned I = 0;
2954  FieldOffset = Builder.CreateExtractValue(MemPtr, I++);
2955  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
2956  VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
2957  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
2958  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
2959  }
2960 
2961  llvm::Value *Addr;
2962  if (VirtualBaseAdjustmentOffset) {
2963  Addr = AdjustVirtualBase(CGF, E, RD, Base, VirtualBaseAdjustmentOffset,
2964  VBPtrOffset);
2965  } else {
2966  Addr = Base.getPointer();
2967  }
2968 
2969  // Cast to char*.
2970  Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS));
2971 
2972  // Apply the offset, which we assume is non-null.
2973  Addr = Builder.CreateInBoundsGEP(Addr, FieldOffset, "memptr.offset");
2974 
2975  // Cast the address to the appropriate pointer type, adopting the address
2976  // space of the base pointer.
2977  return Builder.CreateBitCast(Addr, PType);
2978 }
2979 
2980 llvm::Value *
2981 MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
2982  const CastExpr *E,
2983  llvm::Value *Src) {
2984  assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
2985  E->getCastKind() == CK_BaseToDerivedMemberPointer ||
2986  E->getCastKind() == CK_ReinterpretMemberPointer);
2987 
2988  // Use constant emission if we can.
2989  if (isa<llvm::Constant>(Src))
2990  return EmitMemberPointerConversion(E, cast<llvm::Constant>(Src));
2991 
2992  // We may be adding or dropping fields from the member pointer, so we need
2993  // both types and the inheritance models of both records.
2994  const MemberPointerType *SrcTy =
2996  const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
2997  bool IsFunc = SrcTy->isMemberFunctionPointer();
2998 
2999  // If the classes use the same null representation, reinterpret_cast is a nop.
3000  bool IsReinterpret = E->getCastKind() == CK_ReinterpretMemberPointer;
3001  if (IsReinterpret && IsFunc)
3002  return Src;
3003 
3004  CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl();
3005  CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl();
3006  if (IsReinterpret &&
3007  SrcRD->nullFieldOffsetIsZero() == DstRD->nullFieldOffsetIsZero())
3008  return Src;
3009 
3010  CGBuilderTy &Builder = CGF.Builder;
3011 
3012  // Branch past the conversion if Src is null.
3013  llvm::Value *IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy);
3014  llvm::Constant *DstNull = EmitNullMemberPointer(DstTy);
3015 
3016  // C++ 5.2.10p9: The null member pointer value is converted to the null member
3017  // pointer value of the destination type.
3018  if (IsReinterpret) {
3019  // For reinterpret casts, sema ensures that src and dst are both functions
3020  // or data and have the same size, which means the LLVM types should match.
3021  assert(Src->getType() == DstNull->getType());
3022  return Builder.CreateSelect(IsNotNull, Src, DstNull);
3023  }
3024 
3025  llvm::BasicBlock *OriginalBB = Builder.GetInsertBlock();
3026  llvm::BasicBlock *ConvertBB = CGF.createBasicBlock("memptr.convert");
3027  llvm::BasicBlock *ContinueBB = CGF.createBasicBlock("memptr.converted");
3028  Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB);
3029  CGF.EmitBlock(ConvertBB);
3030 
3031  llvm::Value *Dst = EmitNonNullMemberPointerConversion(
3032  SrcTy, DstTy, E->getCastKind(), E->path_begin(), E->path_end(), Src,
3033  Builder);
3034 
3035  Builder.CreateBr(ContinueBB);
3036 
3037  // In the continuation, choose between DstNull and Dst.
3038  CGF.EmitBlock(ContinueBB);
3039  llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted");
3040  Phi->addIncoming(DstNull, OriginalBB);
3041  Phi->addIncoming(Dst, ConvertBB);
3042  return Phi;
3043 }
3044 
3045 llvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion(
3046  const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK,
3049  CGBuilderTy &Builder) {
3050  const CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl();
3051  const CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl();
3052  MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel();
3053  MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel();
3054  bool IsFunc = SrcTy->isMemberFunctionPointer();
3055  bool IsConstant = isa<llvm::Constant>(Src);
3056 
3057  // Decompose src.
3058  llvm::Value *FirstField = Src;
3059  llvm::Value *NonVirtualBaseAdjustment = getZeroInt();
3060  llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt();
3061  llvm::Value *VBPtrOffset = getZeroInt();
3062  if (!MSInheritanceAttr::hasOnlyOneField(IsFunc, SrcInheritance)) {
3063  // We need to extract values.
3064  unsigned I = 0;
3065  FirstField = Builder.CreateExtractValue(Src, I++);
3066  if (MSInheritanceAttr::hasNVOffsetField(IsFunc, SrcInheritance))
3067  NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++);
3068  if (MSInheritanceAttr::hasVBPtrOffsetField(SrcInheritance))
3069  VBPtrOffset = Builder.CreateExtractValue(Src, I++);
3070  if (MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance))
3071  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++);
3072  }
3073 
3074  bool IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer);
3075  const MemberPointerType *DerivedTy = IsDerivedToBase ? SrcTy : DstTy;
3076  const CXXRecordDecl *DerivedClass = DerivedTy->getMostRecentCXXRecordDecl();
3077 
3078  // For data pointers, we adjust the field offset directly. For functions, we
3079  // have a separate field.
3080  llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField;
3081 
3082  // The virtual inheritance model has a quirk: the virtual base table is always
3083  // referenced when dereferencing a member pointer even if the member pointer
3084  // is non-virtual. This is accounted for by adjusting the non-virtual offset
3085  // to point backwards to the top of the MDC from the first VBase. Undo this
3086  // adjustment to normalize the member pointer.
3087  llvm::Value *SrcVBIndexEqZero =
3088  Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3089  if (SrcInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) {
3090  if (int64_t SrcOffsetToFirstVBase =
3091  getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) {
3092  llvm::Value *UndoSrcAdjustment = Builder.CreateSelect(
3093  SrcVBIndexEqZero,
3094  llvm::ConstantInt::get(CGM.IntTy, SrcOffsetToFirstVBase),
3095  getZeroInt());
3096  NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment);
3097  }
3098  }
3099 
3100  // A non-zero vbindex implies that we are dealing with a source member in a
3101  // floating virtual base in addition to some non-virtual offset. If the
3102  // vbindex is zero, we are dealing with a source that exists in a non-virtual,
3103  // fixed, base. The difference between these two cases is that the vbindex +
3104  // nvoffset *always* point to the member regardless of what context they are
3105  // evaluated in so long as the vbindex is adjusted. A member inside a fixed
3106  // base requires explicit nv adjustment.
3107  llvm::Constant *BaseClassOffset = llvm::ConstantInt::get(
3108  CGM.IntTy,
3109  CGM.computeNonVirtualBaseClassOffset(DerivedClass, PathBegin, PathEnd)
3110  .getQuantity());
3111 
3112  llvm::Value *NVDisp;
3113  if (IsDerivedToBase)
3114  NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset, "adj");
3115  else
3116  NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset, "adj");
3117 
3118  NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt());
3119 
3120  // Update the vbindex to an appropriate value in the destination because
3121  // SrcRD's vbtable might not be a strict prefix of the one in DstRD.
3122  llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero;
3123  if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance) &&
3124  MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) {
3125  if (llvm::GlobalVariable *VDispMap =
3126  getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) {
3127  llvm::Value *VBIndex = Builder.CreateExactUDiv(
3128  VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.IntTy, 4));
3129  if (IsConstant) {
3130  llvm::Constant *Mapping = VDispMap->getInitializer();
3131  VirtualBaseAdjustmentOffset =
3132  Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex));
3133  } else {
3134  llvm::Value *Idxs[] = {getZeroInt(), VBIndex};
3135  VirtualBaseAdjustmentOffset =
3136  Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(VDispMap, Idxs),
3138  }
3139 
3140  DstVBIndexEqZero =
3141  Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3142  }
3143  }
3144 
3145  // Set the VBPtrOffset to zero if the vbindex is zero. Otherwise, initialize
3146  // it to the offset of the vbptr.
3147  if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) {
3148  llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get(
3149  CGM.IntTy,
3150  getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity());
3151  VBPtrOffset =
3152  Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset);
3153  }
3154 
3155  // Likewise, apply a similar adjustment so that dereferencing the member
3156  // pointer correctly accounts for the distance between the start of the first
3157  // virtual base and the top of the MDC.
3158  if (DstInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) {
3159  if (int64_t DstOffsetToFirstVBase =
3160  getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) {
3161  llvm::Value *DoDstAdjustment = Builder.CreateSelect(
3162  DstVBIndexEqZero,
3163  llvm::ConstantInt::get(CGM.IntTy, DstOffsetToFirstVBase),
3164  getZeroInt());
3165  NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment);
3166  }
3167  }
3168 
3169  // Recompose dst from the null struct and the adjusted fields from src.
3170  llvm::Value *Dst;
3171  if (MSInheritanceAttr::hasOnlyOneField(IsFunc, DstInheritance)) {
3172  Dst = FirstField;
3173  } else {
3174  Dst = llvm::UndefValue::get(ConvertMemberPointerType(DstTy));
3175  unsigned Idx = 0;
3176  Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++);
3177  if (MSInheritanceAttr::hasNVOffsetField(IsFunc, DstInheritance))
3178  Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++);
3179  if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance))
3180  Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++);
3181  if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance))
3182  Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++);
3183  }
3184  return Dst;
3185 }
3186 
3187 llvm::Constant *
3188 MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E,
3189  llvm::Constant *Src) {
3190  const MemberPointerType *SrcTy =
3192  const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>();
3193 
3194  CastKind CK = E->getCastKind();
3195 
3196  return EmitMemberPointerConversion(SrcTy, DstTy, CK, E->path_begin(),
3197  E->path_end(), Src);
3198 }
3199 
3200 llvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion(
3201  const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK,
3203  CastExpr::path_const_iterator PathEnd, llvm::Constant *Src) {
3204  assert(CK == CK_DerivedToBaseMemberPointer ||
3205  CK == CK_BaseToDerivedMemberPointer ||
3206  CK == CK_ReinterpretMemberPointer);
3207  // If src is null, emit a new null for dst. We can't return src because dst
3208  // might have a new representation.
3209  if (MemberPointerConstantIsNull(SrcTy, Src))
3210  return EmitNullMemberPointer(DstTy);
3211 
3212  // We don't need to do anything for reinterpret_casts of non-null member
3213  // pointers. We should only get here when the two type representations have
3214  // the same size.
3215  if (CK == CK_ReinterpretMemberPointer)
3216  return Src;
3217 
3218  CGBuilderTy Builder(CGM, CGM.getLLVMContext());
3219  auto *Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion(
3220  SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder));
3221 
3222  return Dst;
3223 }
3224 
3225 llvm::Value *MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(
3226  CodeGenFunction &CGF, const Expr *E, Address This,
3227  llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,
3228  const MemberPointerType *MPT) {
3229  assert(MPT->isMemberFunctionPointer());
3230  const FunctionProtoType *FPT =
3232  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
3233  llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
3234  CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
3235  CGBuilderTy &Builder = CGF.Builder;
3236 
3237  MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
3238 
3239  // Extract the fields we need, regardless of model. We'll apply them if we
3240  // have them.
3241  llvm::Value *FunctionPointer = MemPtr;
3242  llvm::Value *NonVirtualBaseAdjustment = nullptr;
3243  llvm::Value *VirtualBaseAdjustmentOffset = nullptr;
3244  llvm::Value *VBPtrOffset = nullptr;
3245  if (MemPtr->getType()->isStructTy()) {
3246  // We need to extract values.
3247  unsigned I = 0;
3248  FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);
3249  if (MSInheritanceAttr::hasNVOffsetField(MPT, Inheritance))
3250  NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);
3251  if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
3252  VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
3253  if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
3254  VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
3255  }
3256 
3257  if (VirtualBaseAdjustmentOffset) {
3258  ThisPtrForCall = AdjustVirtualBase(CGF, E, RD, This,
3259  VirtualBaseAdjustmentOffset, VBPtrOffset);
3260  } else {
3261  ThisPtrForCall = This.getPointer();
3262  }
3263 
3264  if (NonVirtualBaseAdjustment) {
3265  // Apply the adjustment and cast back to the original struct type.
3266  llvm::Value *Ptr = Builder.CreateBitCast(ThisPtrForCall, CGF.Int8PtrTy);
3267  Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment);
3268  ThisPtrForCall = Builder.CreateBitCast(Ptr, ThisPtrForCall->getType(),
3269  "this.adjusted");
3270  }
3271 
3272  return Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
3273 }
3274 
3276  return new MicrosoftCXXABI(CGM);
3277 }
3278 
3279 // MS RTTI Overview:
3280 // The run time type information emitted by cl.exe contains 5 distinct types of
3281 // structures. Many of them reference each other.
3282 //
3283 // TypeInfo: Static classes that are returned by typeid.
3284 //
3285 // CompleteObjectLocator: Referenced by vftables. They contain information
3286 // required for dynamic casting, including OffsetFromTop. They also contain
3287 // a reference to the TypeInfo for the type and a reference to the
3288 // CompleteHierarchyDescriptor for the type.
3289 //
3290 // ClassHieararchyDescriptor: Contains information about a class hierarchy.
3291 // Used during dynamic_cast to walk a class hierarchy. References a base
3292 // class array and the size of said array.
3293 //
3294 // BaseClassArray: Contains a list of classes in a hierarchy. BaseClassArray is
3295 // somewhat of a misnomer because the most derived class is also in the list
3296 // as well as multiple copies of virtual bases (if they occur multiple times
3297 // in the hiearchy.) The BaseClassArray contains one BaseClassDescriptor for
3298 // every path in the hierarchy, in pre-order depth first order. Note, we do
3299 // not declare a specific llvm type for BaseClassArray, it's merely an array
3300 // of BaseClassDescriptor pointers.
3301 //
3302 // BaseClassDescriptor: Contains information about a class in a class hierarchy.
3303 // BaseClassDescriptor is also somewhat of a misnomer for the same reason that
3304 // BaseClassArray is. It contains information about a class within a
3305 // hierarchy such as: is this base is ambiguous and what is its offset in the
3306 // vbtable. The names of the BaseClassDescriptors have all of their fields
3307 // mangled into them so they can be aggressively deduplicated by the linker.
3308 
3309 static llvm::GlobalVariable *getTypeInfoVTable(CodeGenModule &CGM) {
3310  StringRef MangledName("\01??_7type_info@@6B@");
3311  if (auto VTable = CGM.getModule().getNamedGlobal(MangledName))
3312  return VTable;
3313  return new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
3314  /*Constant=*/true,
3316  /*Initializer=*/nullptr, MangledName);
3317 }
3318 
3319 namespace {
3320 
3321 /// \brief A Helper struct that stores information about a class in a class
3322 /// hierarchy. The information stored in these structs struct is used during
3323 /// the generation of ClassHierarchyDescriptors and BaseClassDescriptors.
3324 // During RTTI creation, MSRTTIClasses are stored in a contiguous array with
3325 // implicit depth first pre-order tree connectivity. getFirstChild and
3326 // getNextSibling allow us to walk the tree efficiently.
3327 struct MSRTTIClass {
3328  enum {
3329  IsPrivateOnPath = 1 | 8,
3330  IsAmbiguous = 2,
3331  IsPrivate = 4,
3332  IsVirtual = 16,
3333  HasHierarchyDescriptor = 64
3334  };
3335  MSRTTIClass(const CXXRecordDecl *RD) : RD(RD) {}
3336  uint32_t initialize(const MSRTTIClass *Parent,
3337  const CXXBaseSpecifier *Specifier);
3338 
3339  MSRTTIClass *getFirstChild() { return this + 1; }
3340  static MSRTTIClass *getNextChild(MSRTTIClass *Child) {
3341  return Child + 1 + Child->NumBases;
3342  }
3343 
3344  const CXXRecordDecl *RD, *VirtualRoot;
3345  uint32_t Flags, NumBases, OffsetInVBase;
3346 };
3347 
3348 /// \brief Recursively initialize the base class array.
3349 uint32_t MSRTTIClass::initialize(const MSRTTIClass *Parent,
3350  const CXXBaseSpecifier *Specifier) {
3351  Flags = HasHierarchyDescriptor;
3352  if (!Parent) {
3353  VirtualRoot = nullptr;
3354  OffsetInVBase = 0;
3355  } else {
3356  if (Specifier->getAccessSpecifier() != AS_public)
3357  Flags |= IsPrivate | IsPrivateOnPath;
3358  if (Specifier->isVirtual()) {
3359  Flags |= IsVirtual;
3360  VirtualRoot = RD;
3361  OffsetInVBase = 0;
3362  } else {
3363  if (Parent->Flags & IsPrivateOnPath)
3364  Flags |= IsPrivateOnPath;
3365  VirtualRoot = Parent->VirtualRoot;
3366  OffsetInVBase = Parent->OffsetInVBase + RD->getASTContext()
3367  .getASTRecordLayout(Parent->RD).getBaseClassOffset(RD).getQuantity();
3368  }
3369  }
3370  NumBases = 0;
3371  MSRTTIClass *Child = getFirstChild();
3372  for (const CXXBaseSpecifier &Base : RD->bases()) {
3373  NumBases += Child->initialize(this, &Base) + 1;
3374  Child = getNextChild(Child);
3375  }
3376  return NumBases;
3377 }
3378 
3379 static llvm::GlobalValue::LinkageTypes getLinkageForRTTI(QualType Ty) {
3380  switch (Ty->getLinkage()) {
3381  case NoLinkage:
3382  case InternalLinkage:
3383  case UniqueExternalLinkage:
3385 
3386  case VisibleNoLinkage:
3387  case ExternalLinkage:
3388  return llvm::GlobalValue::LinkOnceODRLinkage;
3389  }
3390  llvm_unreachable("Invalid linkage!");
3391 }
3392 
3393 /// \brief An ephemeral helper class for building MS RTTI types. It caches some
3394 /// calls to the module and information about the most derived class in a
3395 /// hierarchy.
3396 struct MSRTTIBuilder {
3397  enum {
3398  HasBranchingHierarchy = 1,
3399  HasVirtualBranchingHierarchy = 2,
3400  HasAmbiguousBases = 4
3401  };
3402 
3403  MSRTTIBuilder(MicrosoftCXXABI &ABI, const CXXRecordDecl *RD)
3404  : CGM(ABI.CGM), Context(CGM.getContext()),
3405  VMContext(CGM.getLLVMContext()), Module(CGM.getModule()), RD(RD),
3406  Linkage(getLinkageForRTTI(CGM.getContext().getTagDeclType(RD))),
3407  ABI(ABI) {}
3408 
3409  llvm::GlobalVariable *getBaseClassDescriptor(const MSRTTIClass &Classes);
3410  llvm::GlobalVariable *
3411  getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes);
3412  llvm::GlobalVariable *getClassHierarchyDescriptor();
3413  llvm::GlobalVariable *getCompleteObjectLocator(const VPtrInfo *Info);
3414 
3415  CodeGenModule &CGM;
3417  llvm::LLVMContext &VMContext;
3418  llvm::Module &Module;
3419  const CXXRecordDecl *RD;
3420  llvm::GlobalVariable::LinkageTypes Linkage;
3421  MicrosoftCXXABI &ABI;
3422 };
3423 
3424 } // namespace
3425 
3426 /// \brief Recursively serializes a class hierarchy in pre-order depth first
3427 /// order.
3429  const CXXRecordDecl *RD) {
3430  Classes.push_back(MSRTTIClass(RD));
3431  for (const CXXBaseSpecifier &Base : RD->bases())
3432  serializeClassHierarchy(Classes, Base.getType()->getAsCXXRecordDecl());
3433 }
3434 
3435 /// \brief Find ambiguity among base classes.
3436 static void
3438  llvm::SmallPtrSet<const CXXRecordDecl *, 8> VirtualBases;
3439  llvm::SmallPtrSet<const CXXRecordDecl *, 8> UniqueBases;
3440  llvm::SmallPtrSet<const CXXRecordDecl *, 8> AmbiguousBases;
3441  for (MSRTTIClass *Class = &Classes.front(); Class <= &Classes.back();) {
3442  if ((Class->Flags & MSRTTIClass::IsVirtual) &&
3443  !VirtualBases.insert(Class->RD).second) {
3444  Class = MSRTTIClass::getNextChild(Class);
3445  continue;
3446  }
3447  if (!UniqueBases.insert(Class->RD).second)
3448  AmbiguousBases.insert(Class->RD);
3449  Class++;
3450  }
3451  if (AmbiguousBases.empty())
3452  return;
3453  for (MSRTTIClass &Class : Classes)
3454  if (AmbiguousBases.count(Class.RD))
3455  Class.Flags |= MSRTTIClass::IsAmbiguous;
3456 }
3457 
3458 llvm::GlobalVariable *MSRTTIBuilder::getClassHierarchyDescriptor() {
3459  SmallString<256> MangledName;
3460  {
3461  llvm::raw_svector_ostream Out(MangledName);
3462  ABI.getMangleContext().mangleCXXRTTIClassHierarchyDescriptor(RD, Out);
3463  }
3464 
3465  // Check to see if we've already declared this ClassHierarchyDescriptor.
3466  if (auto CHD = Module.getNamedGlobal(MangledName))
3467  return CHD;
3468 
3469  // Serialize the class hierarchy and initialize the CHD Fields.
3471  serializeClassHierarchy(Classes, RD);
3472  Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr);
3473  detectAmbiguousBases(Classes);
3474  int Flags = 0;
3475  for (auto Class : Classes) {
3476  if (Class.RD->getNumBases() > 1)
3477  Flags |= HasBranchingHierarchy;
3478  // Note: cl.exe does not calculate "HasAmbiguousBases" correctly. We
3479  // believe the field isn't actually used.
3480  if (Class.Flags & MSRTTIClass::IsAmbiguous)
3481  Flags |= HasAmbiguousBases;
3482  }
3483  if ((Flags & HasBranchingHierarchy) && RD->getNumVBases() != 0)
3484  Flags |= HasVirtualBranchingHierarchy;
3485  // These gep indices are used to get the address of the first element of the
3486  // base class array.
3487  llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0),
3488  llvm::ConstantInt::get(CGM.IntTy, 0)};
3489 
3490  // Forward-declare the class hierarchy descriptor
3491  auto Type = ABI.getClassHierarchyDescriptorType();
3492  auto CHD = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3493  /*Initializer=*/nullptr,
3494  MangledName);
3495  if (CHD->isWeakForLinker())
3496  CHD->setComdat(CGM.getModule().getOrInsertComdat(CHD->getName()));
3497 
3498  auto *Bases = getBaseClassArray(Classes);
3499 
3500  // Initialize the base class ClassHierarchyDescriptor.
3501  llvm::Constant *Fields[] = {
3502  llvm::ConstantInt::get(CGM.IntTy, 0), // Unknown
3503  llvm::ConstantInt::get(CGM.IntTy, Flags),
3504  llvm::ConstantInt::get(CGM.IntTy, Classes.size()),
3505  ABI.getImageRelativeConstant(llvm::ConstantExpr::getInBoundsGetElementPtr(
3506  Bases->getValueType(), Bases,
3507  llvm::ArrayRef<llvm::Value *>(GEPIndices))),
3508  };
3509  CHD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
3510  return CHD;
3511 }
3512 
3513 llvm::GlobalVariable *
3514 MSRTTIBuilder::getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes) {
3515  SmallString<256> MangledName;
3516  {
3517  llvm::raw_svector_ostream Out(MangledName);
3518  ABI.getMangleContext().mangleCXXRTTIBaseClassArray(RD, Out);
3519  }
3520 
3521  // Forward-declare the base class array.
3522  // cl.exe pads the base class array with 1 (in 32 bit mode) or 4 (in 64 bit
3523  // mode) bytes of padding. We provide a pointer sized amount of padding by
3524  // adding +1 to Classes.size(). The sections have pointer alignment and are
3525  // marked pick-any so it shouldn't matter.
3526  llvm::Type *PtrType = ABI.getImageRelativeType(
3527  ABI.getBaseClassDescriptorType()->getPointerTo());
3528  auto *ArrType = llvm::ArrayType::get(PtrType, Classes.size() + 1);
3529  auto *BCA =
3530  new llvm::GlobalVariable(Module, ArrType,
3531  /*Constant=*/true, Linkage,
3532  /*Initializer=*/nullptr, MangledName);
3533  if (BCA->isWeakForLinker())
3534  BCA->setComdat(CGM.getModule().getOrInsertComdat(BCA->getName()));
3535 
3536  // Initialize the BaseClassArray.
3537  SmallVector<llvm::Constant *, 8> BaseClassArrayData;
3538  for (MSRTTIClass &Class : Classes)
3539  BaseClassArrayData.push_back(
3540  ABI.getImageRelativeConstant(getBaseClassDescriptor(Class)));
3541  BaseClassArrayData.push_back(llvm::Constant::getNullValue(PtrType));
3542  BCA->setInitializer(llvm::ConstantArray::get(ArrType, BaseClassArrayData));
3543  return BCA;
3544 }
3545 
3546 llvm::GlobalVariable *
3547 MSRTTIBuilder::getBaseClassDescriptor(const MSRTTIClass &Class) {
3548  // Compute the fields for the BaseClassDescriptor. They are computed up front
3549  // because they are mangled into the name of the object.
3550  uint32_t OffsetInVBTable = 0;
3551  int32_t VBPtrOffset = -1;
3552  if (Class.VirtualRoot) {
3553  auto &VTableContext = CGM.getMicrosoftVTableContext();
3554  OffsetInVBTable = VTableContext.getVBTableIndex(RD, Class.VirtualRoot) * 4;
3555  VBPtrOffset = Context.getASTRecordLayout(RD).getVBPtrOffset().getQuantity();
3556  }
3557 
3558  SmallString<256> MangledName;
3559  {
3560  llvm::raw_svector_ostream Out(MangledName);
3561  ABI.getMangleContext().mangleCXXRTTIBaseClassDescriptor(
3562  Class.RD, Class.OffsetInVBase, VBPtrOffset, OffsetInVBTable,
3563  Class.Flags, Out);
3564  }
3565 
3566  // Check to see if we've already declared this object.
3567  if (auto BCD = Module.getNamedGlobal(MangledName))
3568  return BCD;
3569 
3570  // Forward-declare the base class descriptor.
3571  auto Type = ABI.getBaseClassDescriptorType();
3572  auto BCD =
3573  new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3574  /*Initializer=*/nullptr, MangledName);
3575  if (BCD->isWeakForLinker())
3576  BCD->setComdat(CGM.getModule().getOrInsertComdat(BCD->getName()));
3577 
3578  // Initialize the BaseClassDescriptor.
3579  llvm::Constant *Fields[] = {
3580  ABI.getImageRelativeConstant(
3581  ABI.getAddrOfRTTIDescriptor(Context.getTypeDeclType(Class.RD))),
3582  llvm::ConstantInt::get(CGM.IntTy, Class.NumBases),
3583  llvm::ConstantInt::get(CGM.IntTy, Class.OffsetInVBase),
3584  llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),
3585  llvm::ConstantInt::get(CGM.IntTy, OffsetInVBTable),
3586  llvm::ConstantInt::get(CGM.IntTy, Class.Flags),
3587  ABI.getImageRelativeConstant(
3588  MSRTTIBuilder(ABI, Class.RD).getClassHierarchyDescriptor()),
3589  };
3590  BCD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
3591  return BCD;
3592 }
3593 
3594 llvm::GlobalVariable *
3595 MSRTTIBuilder::getCompleteObjectLocator(const VPtrInfo *Info) {
3596  SmallString<256> MangledName;
3597  {
3598  llvm::raw_svector_ostream Out(MangledName);
3599  ABI.getMangleContext().mangleCXXRTTICompleteObjectLocator(RD, Info->MangledPath, Out);
3600  }
3601 
3602  // Check to see if we've already computed this complete object locator.
3603  if (auto COL = Module.getNamedGlobal(MangledName))
3604  return COL;
3605 
3606  // Compute the fields of the complete object locator.
3607  int OffsetToTop = Info->FullOffsetInMDC.getQuantity();
3608  int VFPtrOffset = 0;
3609  // The offset includes the vtordisp if one exists.
3610  if (const CXXRecordDecl *VBase = Info->getVBaseWithVPtr())
3611  if (Context.getASTRecordLayout(RD)
3612  .getVBaseOffsetsMap()
3613  .find(VBase)
3614  ->second.hasVtorDisp())
3615  VFPtrOffset = Info->NonVirtualOffset.getQuantity() + 4;
3616 
3617  // Forward-declare the complete object locator.
3618  llvm::StructType *Type = ABI.getCompleteObjectLocatorType();
3619  auto COL = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage,
3620  /*Initializer=*/nullptr, MangledName);
3621 
3622  // Initialize the CompleteObjectLocator.
3623  llvm::Constant *Fields[] = {
3624  llvm::ConstantInt::get(CGM.IntTy, ABI.isImageRelative()),
3625  llvm::ConstantInt::get(CGM.IntTy, OffsetToTop),
3626  llvm::ConstantInt::get(CGM.IntTy, VFPtrOffset),
3627  ABI.getImageRelativeConstant(
3628  CGM.GetAddrOfRTTIDescriptor(Context.getTypeDeclType(RD))),
3629  ABI.getImageRelativeConstant(getClassHierarchyDescriptor()),
3630  ABI.getImageRelativeConstant(COL),
3631  };
3632  llvm::ArrayRef<llvm::Constant *> FieldsRef(Fields);
3633  if (!ABI.isImageRelative())
3634  FieldsRef = FieldsRef.drop_back();
3635  COL->setInitializer(llvm::ConstantStruct::get(Type, FieldsRef));
3636  if (COL->isWeakForLinker())
3637  COL->setComdat(CGM.getModule().getOrInsertComdat(COL->getName()));
3638  return COL;
3639 }
3640 
3642  bool &IsConst, bool &IsVolatile,
3643  bool &IsUnaligned) {
3644  T = Context.getExceptionObjectType(T);
3645 
3646  // C++14 [except.handle]p3:
3647  // A handler is a match for an exception object of type E if [...]
3648  // - the handler is of type cv T or const T& where T is a pointer type and
3649  // E is a pointer type that can be converted to T by [...]
3650  // - a qualification conversion
3651  IsConst = false;
3652  IsVolatile = false;
3653  IsUnaligned = false;
3654  QualType PointeeType = T->getPointeeType();
3655  if (!PointeeType.isNull()) {
3656  IsConst = PointeeType.isConstQualified();
3657  IsVolatile = PointeeType.isVolatileQualified();
3658  IsUnaligned = PointeeType.getQualifiers().hasUnaligned();
3659  }
3660 
3661  // Member pointer types like "const int A::*" are represented by having RTTI
3662  // for "int A::*" and separately storing the const qualifier.
3663  if (const auto *MPTy = T->getAs<MemberPointerType>())
3664  T = Context.getMemberPointerType(PointeeType.getUnqualifiedType(),
3665  MPTy->getClass());
3666 
3667  // Pointer types like "const int * const *" are represented by having RTTI
3668  // for "const int **" and separately storing the const qualifier.
3669  if (T->isPointerType())
3670  T = Context.getPointerType(PointeeType.getUnqualifiedType());
3671 
3672  return T;
3673 }
3674 
3676 MicrosoftCXXABI::getAddrOfCXXCatchHandlerType(QualType Type,
3677  QualType CatchHandlerType) {
3678  // TypeDescriptors for exceptions never have qualified pointer types,
3679  // qualifiers are stored seperately in order to support qualification
3680  // conversions.
3681  bool IsConst, IsVolatile, IsUnaligned;
3682  Type =
3683  decomposeTypeForEH(getContext(), Type, IsConst, IsVolatile, IsUnaligned);
3684 
3685  bool IsReference = CatchHandlerType->isReferenceType();
3686 
3687  uint32_t Flags = 0;
3688  if (IsConst)
3689  Flags |= 1;
3690  if (IsVolatile)
3691  Flags |= 2;
3692  if (IsUnaligned)
3693  Flags |= 4;
3694  if (IsReference)
3695  Flags |= 8;
3696 
3697  return CatchTypeInfo{getAddrOfRTTIDescriptor(Type)->stripPointerCasts(),
3698  Flags};
3699 }
3700 
3701 /// \brief Gets a TypeDescriptor. Returns a llvm::Constant * rather than a
3702 /// llvm::GlobalVariable * because different type descriptors have different
3703 /// types, and need to be abstracted. They are abstracting by casting the
3704 /// address to an Int8PtrTy.
3705 llvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(QualType Type) {
3706  SmallString<256> MangledName;
3707  {
3708  llvm::raw_svector_ostream Out(MangledName);
3709  getMangleContext().mangleCXXRTTI(Type, Out);
3710  }
3711 
3712  // Check to see if we've already declared this TypeDescriptor.
3713  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
3714  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3715 
3716  // Compute the fields for the TypeDescriptor.
3717  SmallString<256> TypeInfoString;
3718  {
3719  llvm::raw_svector_ostream Out(TypeInfoString);
3720  getMangleContext().mangleCXXRTTIName(Type, Out);
3721  }
3722 
3723  // Declare and initialize the TypeDescriptor.
3724  llvm::Constant *Fields[] = {
3725  getTypeInfoVTable(CGM), // VFPtr
3726  llvm::ConstantPointerNull::get(CGM.Int8PtrTy), // Runtime data
3727  llvm::ConstantDataArray::getString(CGM.getLLVMContext(), TypeInfoString)};
3728  llvm::StructType *TypeDescriptorType =
3729  getTypeDescriptorType(TypeInfoString);
3730  auto *Var = new llvm::GlobalVariable(
3731  CGM.getModule(), TypeDescriptorType, /*Constant=*/false,
3732  getLinkageForRTTI(Type),
3733  llvm::ConstantStruct::get(TypeDescriptorType, Fields),
3734  MangledName);
3735  if (Var->isWeakForLinker())
3736  Var->setComdat(CGM.getModule().getOrInsertComdat(Var->getName()));
3737  return llvm::ConstantExpr::getBitCast(Var, CGM.Int8PtrTy);
3738 }
3739 
3740 /// \brief Gets or a creates a Microsoft CompleteObjectLocator.
3741 llvm::GlobalVariable *
3742 MicrosoftCXXABI::getMSCompleteObjectLocator(const CXXRecordDecl *RD,
3743  const VPtrInfo *Info) {
3744  return MSRTTIBuilder(*this, RD).getCompleteObjectLocator(Info);
3745 }
3746 
3748  const CXXConstructorDecl *ctor,
3749  StructorType ctorType) {
3750  // There are no constructor variants, always emit the complete destructor.
3751  llvm::Function *Fn = CGM.codegenCXXStructor(ctor, StructorType::Complete);
3752  CGM.maybeSetTrivialComdat(*ctor, *Fn);
3753 }
3754 
3755 static void emitCXXDestructor(CodeGenModule &CGM, const CXXDestructorDecl *dtor,
3756  StructorType dtorType) {
3757  // The complete destructor is equivalent to the base destructor for
3758  // classes with no virtual bases, so try to emit it as an alias.
3759  if (!dtor->getParent()->getNumVBases() &&
3760  (dtorType == StructorType::Complete || dtorType == StructorType::Base)) {
3761  bool ProducedAlias = !CGM.TryEmitDefinitionAsAlias(
3762  GlobalDecl(dtor, Dtor_Complete), GlobalDecl(dtor, Dtor_Base), true);
3763  if (ProducedAlias) {
3764  if (dtorType == StructorType::Complete)
3765  return;
3766  if (dtor->isVirtual())
3768  }
3769  }
3770 
3771  // The base destructor is equivalent to the base destructor of its
3772  // base class if there is exactly one non-virtual base class with a
3773  // non-trivial destructor, there are no fields with a non-trivial
3774  // destructor, and the body of the destructor is trivial.
3775  if (dtorType == StructorType::Base && !CGM.TryEmitBaseDestructorAsAlias(dtor))
3776  return;
3777 
3778  llvm::Function *Fn = CGM.codegenCXXStructor(dtor, dtorType);
3779  if (Fn->isWeakForLinker())
3780  Fn->setComdat(CGM.getModule().getOrInsertComdat(Fn->getName()));
3781 }
3782 
3783 void MicrosoftCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3784  StructorType Type) {
3785  if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
3786  emitCXXConstructor(CGM, CD, Type);
3787  return;
3788  }
3789  emitCXXDestructor(CGM, cast<CXXDestructorDecl>(MD), Type);
3790 }
3791 
3792 llvm::Function *
3793 MicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,
3794  CXXCtorType CT) {
3795  assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure);
3796 
3797  // Calculate the mangled name.
3798  SmallString<256> ThunkName;
3799  llvm::raw_svector_ostream Out(ThunkName);
3800  getMangleContext().mangleCXXCtor(CD, CT, Out);
3801 
3802  // If the thunk has been generated previously, just return it.
3803  if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName))
3804  return cast<llvm::Function>(GV);
3805 
3806  // Create the llvm::Function.
3807  const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSCtorClosure(CD, CT);
3808  llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
3809  const CXXRecordDecl *RD = CD->getParent();
3810  QualType RecordTy = getContext().getRecordType(RD);
3811  llvm::Function *ThunkFn = llvm::Function::Create(
3812  ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.getModule());
3813  ThunkFn->setCallingConv(static_cast<llvm::CallingConv::ID>(
3814  FnInfo.getEffectiveCallingConvention()));
3815  if (ThunkFn->isWeakForLinker())
3816  ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
3817  bool IsCopy = CT == Ctor_CopyingClosure;
3818 
3819  // Start codegen.
3820  CodeGenFunction CGF(CGM);
3821  CGF.CurGD = GlobalDecl(CD, Ctor_Complete);
3822 
3823  // Build FunctionArgs.
3824  FunctionArgList FunctionArgs;
3825 
3826  // A constructor always starts with a 'this' pointer as its first argument.
3827  buildThisParam(CGF, FunctionArgs);
3828 
3829  // Following the 'this' pointer is a reference to the source object that we
3830  // are copying from.
3831  ImplicitParamDecl SrcParam(
3832  getContext(), nullptr, SourceLocation(), &getContext().Idents.get("src"),
3833  getContext().getLValueReferenceType(RecordTy,
3834  /*SpelledAsLValue=*/true));
3835  if (IsCopy)
3836  FunctionArgs.push_back(&SrcParam);
3837 
3838  // Constructors for classes which utilize virtual bases have an additional
3839  // parameter which indicates whether or not it is being delegated to by a more
3840  // derived constructor.
3841  ImplicitParamDecl IsMostDerived(getContext(), nullptr, SourceLocation(),
3842  &getContext().Idents.get("is_most_derived"),
3843  getContext().IntTy);
3844  // Only add the parameter to the list if thie class has virtual bases.
3845  if (RD->getNumVBases() > 0)
3846  FunctionArgs.push_back(&IsMostDerived);
3847 
3848  // Start defining the function.
3849  CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
3850  FunctionArgs, CD->getLocation(), SourceLocation());
3851  EmitThisParam(CGF);
3852  llvm::Value *This = getThisValue(CGF);
3853 
3854  llvm::Value *SrcVal =
3855  IsCopy ? CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&SrcParam), "src")
3856  : nullptr;
3857 
3858  CallArgList Args;
3859 
3860  // Push the this ptr.
3861  Args.add(RValue::get(This), CD->getThisType(getContext()));
3862 
3863  // Push the src ptr.
3864  if (SrcVal)
3865  Args.add(RValue::get(SrcVal), SrcParam.getType());
3866 
3867  // Add the rest of the default arguments.
3868  std::vector<Stmt *> ArgVec;
3869  for (unsigned I = IsCopy ? 1 : 0, E = CD->getNumParams(); I != E; ++I) {
3870  Stmt *DefaultArg = getContext().getDefaultArgExprForConstructor(CD, I);
3871  assert(DefaultArg && "sema forgot to instantiate default args");
3872  ArgVec.push_back(DefaultArg);
3873  }
3874 
3875  CodeGenFunction::RunCleanupsScope Cleanups(CGF);
3876 
3877  const auto *FPT = CD->getType()->castAs<FunctionProtoType>();
3878  CGF.EmitCallArgs(Args, FPT, llvm::makeArrayRef(ArgVec), CD, IsCopy ? 1 : 0);
3879 
3880  // Insert any ABI-specific implicit constructor arguments.
3881  unsigned ExtraArgs = addImplicitConstructorArgs(CGF, CD, Ctor_Complete,
3882  /*ForVirtualBase=*/false,
3883  /*Delegating=*/false, Args);
3884 
3885  // Call the destructor with our arguments.
3887  const CGFunctionInfo &CalleeInfo = CGM.getTypes().arrangeCXXConstructorCall(
3888  Args, CD, Ctor_Complete, ExtraArgs);
3889  CGF.EmitCall(CalleeInfo, CalleeFn, ReturnValueSlot(), Args, CD);
3890 
3891  Cleanups.ForceCleanup();
3892 
3893  // Emit the ret instruction, remove any temporary instructions created for the
3894  // aid of CodeGen.
3896 
3897  return ThunkFn;
3898 }
3899 
3900 llvm::Constant *MicrosoftCXXABI::getCatchableType(QualType T,
3901  uint32_t NVOffset,
3902  int32_t VBPtrOffset,
3903  uint32_t VBIndex) {
3904  assert(!T->isReferenceType());
3905 
3906  CXXRecordDecl *RD = T->getAsCXXRecordDecl();
3907  const CXXConstructorDecl *CD =
3908  RD ? CGM.getContext().getCopyConstructorForExceptionObject(RD) : nullptr;
3910  if (CD)
3911  if (!hasDefaultCXXMethodCC(getContext(), CD) || CD->getNumParams() != 1)
3912  CT = Ctor_CopyingClosure;
3913 
3914  uint32_t Size = getContext().getTypeSizeInChars(T).getQuantity();
3915  SmallString<256> MangledName;
3916  {
3917  llvm::raw_svector_ostream Out(MangledName);
3918  getMangleContext().mangleCXXCatchableType(T, CD, CT, Size, NVOffset,
3919  VBPtrOffset, VBIndex, Out);
3920  }
3921  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
3922  return getImageRelativeConstant(GV);
3923 
3924  // The TypeDescriptor is used by the runtime to determine if a catch handler
3925  // is appropriate for the exception object.
3926  llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(T));
3927 
3928  // The runtime is responsible for calling the copy constructor if the
3929  // exception is caught by value.
3930  llvm::Constant *CopyCtor;
3931  if (CD) {
3932  if (CT == Ctor_CopyingClosure)
3933  CopyCtor = getAddrOfCXXCtorClosure(CD, Ctor_CopyingClosure);
3934  else
3935  CopyCtor = CGM.getAddrOfCXXStructor(CD, StructorType::Complete);
3936 
3937  CopyCtor = llvm::ConstantExpr::getBitCast(CopyCtor, CGM.Int8PtrTy);
3938  } else {
3939  CopyCtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3940  }
3941  CopyCtor = getImageRelativeConstant(CopyCtor);
3942 
3943  bool IsScalar = !RD;
3944  bool HasVirtualBases = false;
3945  bool IsStdBadAlloc = false; // std::bad_alloc is special for some reason.
3946  QualType PointeeType = T;
3947  if (T->isPointerType())
3948  PointeeType = T->getPointeeType();
3949  if (const CXXRecordDecl *RD = PointeeType->getAsCXXRecordDecl()) {
3950  HasVirtualBases = RD->getNumVBases() > 0;
3951  if (IdentifierInfo *II = RD->getIdentifier())
3952  IsStdBadAlloc = II->isStr("bad_alloc") && RD->isInStdNamespace();
3953  }
3954 
3955  // Encode the relevant CatchableType properties into the Flags bitfield.
3956  // FIXME: Figure out how bits 2 or 8 can get set.
3957  uint32_t Flags = 0;
3958  if (IsScalar)
3959  Flags |= 1;
3960  if (HasVirtualBases)
3961  Flags |= 4;
3962  if (IsStdBadAlloc)
3963  Flags |= 16;
3964 
3965  llvm::Constant *Fields[] = {
3966  llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
3967  TD, // TypeDescriptor
3968  llvm::ConstantInt::get(CGM.IntTy, NVOffset), // NonVirtualAdjustment
3969  llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), // OffsetToVBPtr
3970  llvm::ConstantInt::get(CGM.IntTy, VBIndex), // VBTableIndex
3971  llvm::ConstantInt::get(CGM.IntTy, Size), // Size
3972  CopyCtor // CopyCtor
3973  };
3974  llvm::StructType *CTType = getCatchableTypeType();
3975  auto *GV = new llvm::GlobalVariable(
3976  CGM.getModule(), CTType, /*Constant=*/true, getLinkageForRTTI(T),
3977  llvm::ConstantStruct::get(CTType, Fields), MangledName);
3978  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3979  GV->setSection(".xdata");
3980  if (GV->isWeakForLinker())
3981  GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName()));
3982  return getImageRelativeConstant(GV);
3983 }
3984 
3985 llvm::GlobalVariable *MicrosoftCXXABI::getCatchableTypeArray(QualType T) {
3986  assert(!T->isReferenceType());
3987 
3988  // See if we've already generated a CatchableTypeArray for this type before.
3989  llvm::GlobalVariable *&CTA = CatchableTypeArrays[T];
3990  if (CTA)
3991  return CTA;
3992 
3993  // Ensure that we don't have duplicate entries in our CatchableTypeArray by
3994  // using a SmallSetVector. Duplicates may arise due to virtual bases
3995  // occurring more than once in the hierarchy.
3997 
3998  // C++14 [except.handle]p3:
3999  // A handler is a match for an exception object of type E if [...]
4000  // - the handler is of type cv T or cv T& and T is an unambiguous public
4001  // base class of E, or
4002  // - the handler is of type cv T or const T& where T is a pointer type and
4003  // E is a pointer type that can be converted to T by [...]
4004  // - a standard pointer conversion (4.10) not involving conversions to
4005  // pointers to private or protected or ambiguous classes
4006  const CXXRecordDecl *MostDerivedClass = nullptr;
4007  bool IsPointer = T->isPointerType();
4008  if (IsPointer)
4009  MostDerivedClass = T->getPointeeType()->getAsCXXRecordDecl();
4010  else
4011  MostDerivedClass = T->getAsCXXRecordDecl();
4012 
4013  // Collect all the unambiguous public bases of the MostDerivedClass.
4014  if (MostDerivedClass) {
4015  const ASTContext &Context = getContext();
4016  const ASTRecordLayout &MostDerivedLayout =
4017  Context.getASTRecordLayout(MostDerivedClass);
4018  MicrosoftVTableContext &VTableContext = CGM.getMicrosoftVTableContext();
4020  serializeClassHierarchy(Classes, MostDerivedClass);
4021  Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr);
4022  detectAmbiguousBases(Classes);
4023  for (const MSRTTIClass &Class : Classes) {
4024  // Skip any ambiguous or private bases.
4025  if (Class.Flags &
4026  (MSRTTIClass::IsPrivateOnPath | MSRTTIClass::IsAmbiguous))
4027  continue;
4028  // Write down how to convert from a derived pointer to a base pointer.
4029  uint32_t OffsetInVBTable = 0;
4030  int32_t VBPtrOffset = -1;
4031  if (Class.VirtualRoot) {
4032  OffsetInVBTable =
4033  VTableContext.getVBTableIndex(MostDerivedClass, Class.VirtualRoot)*4;
4034  VBPtrOffset = MostDerivedLayout.getVBPtrOffset().getQuantity();
4035  }
4036 
4037  // Turn our record back into a pointer if the exception object is a
4038  // pointer.
4039  QualType RTTITy = QualType(Class.RD->getTypeForDecl(), 0);
4040  if (IsPointer)
4041  RTTITy = Context.getPointerType(RTTITy);
4042  CatchableTypes.insert(getCatchableType(RTTITy, Class.OffsetInVBase,
4043  VBPtrOffset, OffsetInVBTable));
4044  }
4045  }
4046 
4047  // C++14 [except.handle]p3:
4048  // A handler is a match for an exception object of type E if
4049  // - The handler is of type cv T or cv T& and E and T are the same type
4050  // (ignoring the top-level cv-qualifiers)
4051  CatchableTypes.insert(getCatchableType(T));
4052 
4053  // C++14 [except.handle]p3:
4054  // A handler is a match for an exception object of type E if
4055  // - the handler is of type cv T or const T& where T is a pointer type and
4056  // E is a pointer type that can be converted to T by [...]
4057  // - a standard pointer conversion (4.10) not involving conversions to
4058  // pointers to private or protected or ambiguous classes
4059  //
4060  // C++14 [conv.ptr]p2:
4061  // A prvalue of type "pointer to cv T," where T is an object type, can be
4062  // converted to a prvalue of type "pointer to cv void".
4063  if (IsPointer && T->getPointeeType()->isObjectType())
4064  CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4065 
4066  // C++14 [except.handle]p3:
4067  // A handler is a match for an exception object of type E if [...]
4068  // - the handler is of type cv T or const T& where T is a pointer or
4069  // pointer to member type and E is std::nullptr_t.
4070  //
4071  // We cannot possibly list all possible pointer types here, making this
4072  // implementation incompatible with the standard. However, MSVC includes an
4073  // entry for pointer-to-void in this case. Let's do the same.
4074  if (T->isNullPtrType())
4075  CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4076 
4077  uint32_t NumEntries = CatchableTypes.size();
4078  llvm::Type *CTType =
4079  getImageRelativeType(getCatchableTypeType()->getPointerTo());
4080  llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries);
4081  llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries);
4082  llvm::Constant *Fields[] = {
4083  llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries
4084  llvm::ConstantArray::get(
4085  AT, llvm::makeArrayRef(CatchableTypes.begin(),
4086  CatchableTypes.end())) // CatchableTypes
4087  };
4088  SmallString<256> MangledName;
4089  {
4090  llvm::raw_svector_ostream Out(MangledName);
4091  getMangleContext().mangleCXXCatchableTypeArray(T, NumEntries, Out);
4092  }
4093  CTA = new llvm::GlobalVariable(
4094  CGM.getModule(), CTAType, /*Constant=*/true, getLinkageForRTTI(T),
4095  llvm::ConstantStruct::get(CTAType, Fields), MangledName);
4096  CTA->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4097  CTA->setSection(".xdata");
4098  if (CTA->isWeakForLinker())
4099  CTA->setComdat(CGM.getModule().getOrInsertComdat(CTA->getName()));
4100  return CTA;
4101 }
4102 
4103 llvm::GlobalVariable *MicrosoftCXXABI::getThrowInfo(QualType T) {
4104  bool IsConst, IsVolatile, IsUnaligned;
4105  T = decomposeTypeForEH(getContext(), T, IsConst, IsVolatile, IsUnaligned);
4106 
4107  // The CatchableTypeArray enumerates the various (CV-unqualified) types that
4108  // the exception object may be caught as.
4109  llvm::GlobalVariable *CTA = getCatchableTypeArray(T);
4110  // The first field in a CatchableTypeArray is the number of CatchableTypes.
4111  // This is used as a component of the mangled name which means that we need to
4112  // know what it is in order to see if we have previously generated the
4113  // ThrowInfo.
4114  uint32_t NumEntries =
4115  cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0U))
4116  ->getLimitedValue();
4117 
4118  SmallString<256> MangledName;
4119  {
4120  llvm::raw_svector_ostream Out(MangledName);
4121  getMangleContext().mangleCXXThrowInfo(T, IsConst, IsVolatile, IsUnaligned,
4122  NumEntries, Out);
4123  }
4124 
4125  // Reuse a previously generated ThrowInfo if we have generated an appropriate
4126  // one before.
4127  if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
4128  return GV;
4129 
4130  // The RTTI TypeDescriptor uses an unqualified type but catch clauses must
4131  // be at least as CV qualified. Encode this requirement into the Flags
4132  // bitfield.
4133  uint32_t Flags = 0;
4134  if (IsConst)
4135  Flags |= 1;
4136  if (IsVolatile)
4137  Flags |= 2;
4138  if (IsUnaligned)
4139  Flags |= 4;
4140 
4141  // The cleanup-function (a destructor) must be called when the exception
4142  // object's lifetime ends.
4143  llvm::Constant *CleanupFn = llvm::Constant::getNullValue(CGM.Int8PtrTy);
4144  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
4145  if (CXXDestructorDecl *DtorD = RD->getDestructor())
4146  if (!DtorD->isTrivial())
4147  CleanupFn = llvm::ConstantExpr::getBitCast(
4149  CGM.Int8PtrTy);
4150  // This is unused as far as we can tell, initialize it to null.
4151  llvm::Constant *ForwardCompat =
4152  getImageRelativeConstant(llvm::Constant::getNullValue(CGM.Int8PtrTy));
4153  llvm::Constant *PointerToCatchableTypes = getImageRelativeConstant(
4154  llvm::ConstantExpr::getBitCast(CTA, CGM.Int8PtrTy));
4155  llvm::StructType *TIType = getThrowInfoType();
4156  llvm::Constant *Fields[] = {
4157  llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
4158  getImageRelativeConstant(CleanupFn), // CleanupFn
4159  ForwardCompat, // ForwardCompat
4160  PointerToCatchableTypes // CatchableTypeArray
4161  };
4162  auto *GV = new llvm::GlobalVariable(
4163  CGM.getModule(), TIType, /*Constant=*/true, getLinkageForRTTI(T),
4164  llvm::ConstantStruct::get(TIType, Fields), StringRef(MangledName));
4165  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4166  GV->setSection(".xdata");
4167  if (GV->isWeakForLinker())
4168  GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName()));
4169  return GV;
4170 }
4171 
4172 void MicrosoftCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
4173  const Expr *SubExpr = E->getSubExpr();
4174  QualType ThrowType = SubExpr->getType();
4175  // The exception object lives on the stack and it's address is passed to the
4176  // runtime function.
4177  Address AI = CGF.CreateMemTemp(ThrowType);
4178  CGF.EmitAnyExprToMem(SubExpr, AI, ThrowType.getQualifiers(),
4179  /*IsInit=*/true);
4180 
4181  // The so-called ThrowInfo is used to describe how the exception object may be
4182  // caught.
4183  llvm::GlobalVariable *TI = getThrowInfo(ThrowType);
4184 
4185  // Call into the runtime to throw the exception.
4186  llvm::Value *Args[] = {
4187  CGF.Builder.CreateBitCast(AI.getPointer(), CGM.Int8PtrTy),
4188  TI
4189  };
4191 }
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
static QualType decomposeTypeForEH(ASTContext &Context, QualType T, bool &IsConst, bool &IsVolatile, bool &IsUnaligned)
CastKind getCastKind() const
Definition: Expr.h:2680
llvm::IntegerType * IntTy
int
bool isVariadic() const
Definition: Type.h:3366
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, Address Guard=Address::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
Definition: CGDeclCXX.cpp:523
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1367
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:5693
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
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:598
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:208
static llvm::Constant * getInitThreadFooterFn(CodeGenModule &CGM)
llvm::DenseMap< const CXXRecordDecl *, VBaseInfo > VBaseOffsetsMapTy
Definition: RecordLayout.h:57
base_class_range bases()
Definition: DeclCXX.h:718
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:1032
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:2041
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:179
ctor_range ctors() const
Definition: DeclCXX.h:779
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:212
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1275
vtable_component_iterator vtable_component_begin() const
bool hasDefinition() const
Definition: DeclCXX.h:685
QualType getPointeeType() const
Definition: Type.h:2420
The base class of the type hierarchy.
Definition: Type.h:1281
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:1124
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:1872
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:227
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:2187
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:2697
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:768
TLSKind getTLSKind() const
Definition: Decl.cpp:1818
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:1672
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:245
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:913
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:54
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:4549
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:92
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:1219
bool isReferenceType() const
Definition: Type.h:5491
static const CXXRecordDecl * getClassAtVTableLocation(ASTContext &Ctx, const CXXRecordDecl *RD, CharUnits Offset)
bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
Definition: CGClass.cpp:2772
uint64_t getNumVTableComponents() const
struct clang::ReturnAdjustment::VirtualAdjustment::@111 Microsoft
StructorType getFromDtorType(CXXDtorType T)
Definition: CodeGenTypes.h:104
llvm::CallInst * EmitRuntimeCall(llvm::Value *callee, const Twine &name="")
CXXMethodDecl * getCanonicalDecl() override
Definition: DeclCXX.h:1804
ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type)
Classify the rules for how to return a particular type.
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:2684
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:3507
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:1199
const Decl * getDecl() const
Definition: GlobalDecl.h:62
Describes a module or submodule.
Definition: Basic/Module.h:47
IdentifierTable & Idents
Definition: ASTContext.h:459
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:3425
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:168
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, llvm::Value *VTable, SourceLocation Loc)
If whole-program virtual table optimization is enabled, emit an assumption that VTable is a member of...
Definition: CGClass.cpp:2612
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:1838
path_iterator path_begin()
Definition: Expr.h:2700
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:227
const VPtrInfoVector & getVFPtrOffsets(const CXXRecordDecl *RD)
CXXRecordDecl * getCanonicalDecl() override
Definition: DeclCXX.h:654
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:1487
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition: CGCall.cpp:233
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:980
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:599
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2424
arg_iterator arg_end()
Definition: Expr.h:2248
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:3456
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2053
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:953
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
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:169
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)
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool hasUnaligned() const
Definition: Type.h:279
const CXXRecordDecl * getBase() const
getBase - Returns the base class declaration.
Definition: BaseSubobject.h:40
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:2563
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:1909
const Type * getTypeForDecl() const
Definition: Decl.h:2590
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
Expr - This represents one expression.
Definition: Expr.h:105
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:69
bool isInstance() const
Definition: DeclCXX.h:1763
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type 'void ()'.
Definition: CGCall.cpp:636
bool isVirtual() const
Definition: DeclCXX.h:1780
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:615
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2414
static llvm::CallSite emitRTtypeidCall(CodeGenFunction &CGF, llvm::Value *Argument)
ASTContext & getContext() const
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:219
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:1863
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
bool isExternallyVisible() const
Definition: Decl.h:348
CharUnits getVBPtrOffset() const
getVBPtrOffset - Get the offset for virtual base table pointer.
Definition: RecordLayout.h:292
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:46
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:712
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
Definition: CGDeclCXX.cpp:140
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:231
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1588
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:3782
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:160
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:2742
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5259
const TemplateArgument * iterator
Definition: Type.h:4233
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:1804
const std::string ID
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:121
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
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:194
Represents a single component in a vtable.
Definition: VTableBuilder.h:31
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:42
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
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:254
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:302
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:2430
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:5849
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:609
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
struct clang::ThisAdjustment::VirtualAdjustment::@113 Microsoft
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5329
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:126
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:933
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2391
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:2008
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:235
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:98
const VPtrInfoVector & enumerateVBTables(const CXXRecordDecl *RD)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
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:91
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
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:2401
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:113
vtable_component_range vtable_components() const
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
CharUnits getVBaseAlignment(CharUnits DerivedAlign, const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)
Returns the assumed alignment of a virtual base of a class.
Definition: CGClass.cpp:55
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:504
union clang::ThisAdjustment::VirtualAdjustment Virtual
vtable_thunk_iterator vtable_thunk_begin() const
path_iterator path_end()
Definition: Expr.h:2701
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1382
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:5818
static llvm::GlobalVariable * getTypeInfoVTable(CodeGenModule &CGM)
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T)
Definition: Decl.cpp:4016
arg_iterator arg_begin()
Definition: Expr.h:2247
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:1291
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1848
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:397
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:159
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3376
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:1863
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:5339
Address CreateConstByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:251
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
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:190
llvm::Function * CreateGlobalInitOrDestructFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false)
Definition: CGDeclCXX.cpp:259
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:523
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:147
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:485
CanQualType IntTy
Definition: ASTContext.h:901
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
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:120
CodeGenVTables & getVTables()
CharUnits getBaseOffset() const
getBaseOffset - Returns the base class offset.
Definition: BaseSubobject.h:43
uint32_t VBIndex
Index of the virtual base in the vbtable.
Definition: ABI.h:64
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:733
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
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:5318
RecordArgABI
Specify how one should pass an argument of a record type.
Definition: CGCXXABI.h:124
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
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:1691
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:603
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:735
bool isEmpty() const
Definition: ABI.h:87
static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)
llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, uint64_t VTableByteOffset)
Emit a type checked load from the given vtable.
Definition: CGClass.cpp:2783
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:341
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
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:351
bool isPointerType() const
Definition: Type.h:5482
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1135
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1466