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