1 //===------- MicrosoftCXXABI.cpp - AST support for the Microsoft C++ ABI --===//
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++ AST support targeting the Microsoft Visual C++
10 // ABI.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CXXABI.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/MangleNumberingContext.h"
20 #include "clang/AST/RecordLayout.h"
21 #include "clang/AST/Type.h"
22 #include "clang/Basic/TargetInfo.h"
23
24 using namespace clang;
25
26 namespace {
27
28 /// Numbers things which need to correspond across multiple TUs.
29 /// Typically these are things like static locals, lambdas, or blocks.
30 class MicrosoftNumberingContext : public MangleNumberingContext {
31 llvm::DenseMap<const Type *, unsigned> ManglingNumbers;
32 unsigned LambdaManglingNumber;
33 unsigned StaticLocalNumber;
34 unsigned StaticThreadlocalNumber;
35
36 public:
MicrosoftNumberingContext()37 MicrosoftNumberingContext()
38 : MangleNumberingContext(), LambdaManglingNumber(0),
39 StaticLocalNumber(0), StaticThreadlocalNumber(0) {}
40
getManglingNumber(const CXXMethodDecl * CallOperator)41 unsigned getManglingNumber(const CXXMethodDecl *CallOperator) override {
42 return ++LambdaManglingNumber;
43 }
44
getManglingNumber(const BlockDecl * BD)45 unsigned getManglingNumber(const BlockDecl *BD) override {
46 const Type *Ty = nullptr;
47 return ++ManglingNumbers[Ty];
48 }
49
getStaticLocalNumber(const VarDecl * VD)50 unsigned getStaticLocalNumber(const VarDecl *VD) override {
51 if (VD->getTLSKind())
52 return ++StaticThreadlocalNumber;
53 return ++StaticLocalNumber;
54 }
55
getManglingNumber(const VarDecl * VD,unsigned MSLocalManglingNumber)56 unsigned getManglingNumber(const VarDecl *VD,
57 unsigned MSLocalManglingNumber) override {
58 return MSLocalManglingNumber;
59 }
60
getManglingNumber(const TagDecl * TD,unsigned MSLocalManglingNumber)61 unsigned getManglingNumber(const TagDecl *TD,
62 unsigned MSLocalManglingNumber) override {
63 return MSLocalManglingNumber;
64 }
65 };
66
67 class MicrosoftCXXABI : public CXXABI {
68 ASTContext &Context;
69 llvm::SmallDenseMap<CXXRecordDecl *, CXXConstructorDecl *> RecordToCopyCtor;
70
71 llvm::SmallDenseMap<TagDecl *, DeclaratorDecl *>
72 UnnamedTagDeclToDeclaratorDecl;
73 llvm::SmallDenseMap<TagDecl *, TypedefNameDecl *>
74 UnnamedTagDeclToTypedefNameDecl;
75
76 public:
MicrosoftCXXABI(ASTContext & Ctx)77 MicrosoftCXXABI(ASTContext &Ctx) : Context(Ctx) { }
78
79 MemberPointerInfo
80 getMemberPointerInfo(const MemberPointerType *MPT) const override;
81
getDefaultMethodCallConv(bool isVariadic) const82 CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
83 if (!isVariadic &&
84 Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
85 return CC_X86ThisCall;
86 return Context.getTargetInfo().getDefaultCallingConv();
87 }
88
isNearlyEmpty(const CXXRecordDecl * RD) const89 bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
90 llvm_unreachable("unapplicable to the MS ABI");
91 }
92
93 const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl * RD)94 getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
95 return RecordToCopyCtor[RD];
96 }
97
98 void
addCopyConstructorForExceptionObject(CXXRecordDecl * RD,CXXConstructorDecl * CD)99 addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
100 CXXConstructorDecl *CD) override {
101 assert(CD != nullptr);
102 assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
103 RecordToCopyCtor[RD] = CD;
104 }
105
addTypedefNameForUnnamedTagDecl(TagDecl * TD,TypedefNameDecl * DD)106 void addTypedefNameForUnnamedTagDecl(TagDecl *TD,
107 TypedefNameDecl *DD) override {
108 TD = TD->getCanonicalDecl();
109 DD = DD->getCanonicalDecl();
110 TypedefNameDecl *&I = UnnamedTagDeclToTypedefNameDecl[TD];
111 if (!I)
112 I = DD;
113 }
114
getTypedefNameForUnnamedTagDecl(const TagDecl * TD)115 TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD) override {
116 return UnnamedTagDeclToTypedefNameDecl.lookup(
117 const_cast<TagDecl *>(TD->getCanonicalDecl()));
118 }
119
addDeclaratorForUnnamedTagDecl(TagDecl * TD,DeclaratorDecl * DD)120 void addDeclaratorForUnnamedTagDecl(TagDecl *TD,
121 DeclaratorDecl *DD) override {
122 TD = TD->getCanonicalDecl();
123 DD = cast<DeclaratorDecl>(DD->getCanonicalDecl());
124 DeclaratorDecl *&I = UnnamedTagDeclToDeclaratorDecl[TD];
125 if (!I)
126 I = DD;
127 }
128
getDeclaratorForUnnamedTagDecl(const TagDecl * TD)129 DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD) override {
130 return UnnamedTagDeclToDeclaratorDecl.lookup(
131 const_cast<TagDecl *>(TD->getCanonicalDecl()));
132 }
133
134 std::unique_ptr<MangleNumberingContext>
createMangleNumberingContext() const135 createMangleNumberingContext() const override {
136 return std::make_unique<MicrosoftNumberingContext>();
137 }
138 };
139 }
140
141 // getNumBases() seems to only give us the number of direct bases, and not the
142 // total. This function tells us if we inherit from anybody that uses MI, or if
143 // we have a non-primary base class, which uses the multiple inheritance model.
usesMultipleInheritanceModel(const CXXRecordDecl * RD)144 static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) {
145 while (RD->getNumBases() > 0) {
146 if (RD->getNumBases() > 1)
147 return true;
148 assert(RD->getNumBases() == 1);
149 const CXXRecordDecl *Base =
150 RD->bases_begin()->getType()->getAsCXXRecordDecl();
151 if (RD->isPolymorphic() && !Base->isPolymorphic())
152 return true;
153 RD = Base;
154 }
155 return false;
156 }
157
calculateInheritanceModel() const158 MSInheritanceModel CXXRecordDecl::calculateInheritanceModel() const {
159 if (!hasDefinition() || isParsingBaseSpecifiers())
160 return MSInheritanceModel::Unspecified;
161 if (getNumVBases() > 0)
162 return MSInheritanceModel::Virtual;
163 if (usesMultipleInheritanceModel(this))
164 return MSInheritanceModel::Multiple;
165 return MSInheritanceModel::Single;
166 }
167
getMSInheritanceModel() const168 MSInheritanceModel CXXRecordDecl::getMSInheritanceModel() const {
169 MSInheritanceAttr *IA = getAttr<MSInheritanceAttr>();
170 assert(IA && "Expected MSInheritanceAttr on the CXXRecordDecl!");
171 return IA->getInheritanceModel();
172 }
173
nullFieldOffsetIsZero() const174 bool CXXRecordDecl::nullFieldOffsetIsZero() const {
175 return !inheritanceModelHasOnlyOneField(/*IsMemberFunction=*/false,
176 getMSInheritanceModel()) ||
177 (hasDefinition() && isPolymorphic());
178 }
179
getMSVtorDispMode() const180 MSVtorDispMode CXXRecordDecl::getMSVtorDispMode() const {
181 if (MSVtorDispAttr *VDA = getAttr<MSVtorDispAttr>())
182 return VDA->getVtorDispMode();
183 return getASTContext().getLangOpts().getVtorDispMode();
184 }
185
186 // Returns the number of pointer and integer slots used to represent a member
187 // pointer in the MS C++ ABI.
188 //
189 // Member function pointers have the following general form; however, fields
190 // are dropped as permitted (under the MSVC interpretation) by the inheritance
191 // model of the actual class.
192 //
193 // struct {
194 // // A pointer to the member function to call. If the member function is
195 // // virtual, this will be a thunk that forwards to the appropriate vftable
196 // // slot.
197 // void *FunctionPointerOrVirtualThunk;
198 //
199 // // An offset to add to the address of the vbtable pointer after
200 // // (possibly) selecting the virtual base but before resolving and calling
201 // // the function.
202 // // Only needed if the class has any virtual bases or bases at a non-zero
203 // // offset.
204 // int NonVirtualBaseAdjustment;
205 //
206 // // The offset of the vb-table pointer within the object. Only needed for
207 // // incomplete types.
208 // int VBPtrOffset;
209 //
210 // // An offset within the vb-table that selects the virtual base containing
211 // // the member. Loading from this offset produces a new offset that is
212 // // added to the address of the vb-table pointer to produce the base.
213 // int VirtualBaseAdjustmentOffset;
214 // };
215 static std::pair<unsigned, unsigned>
getMSMemberPointerSlots(const MemberPointerType * MPT)216 getMSMemberPointerSlots(const MemberPointerType *MPT) {
217 const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
218 MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
219 unsigned Ptrs = 0;
220 unsigned Ints = 0;
221 if (MPT->isMemberFunctionPointer())
222 Ptrs = 1;
223 else
224 Ints = 1;
225 if (inheritanceModelHasNVOffsetField(MPT->isMemberFunctionPointer(),
226 Inheritance))
227 Ints++;
228 if (inheritanceModelHasVBPtrOffsetField(Inheritance))
229 Ints++;
230 if (inheritanceModelHasVBTableOffsetField(Inheritance))
231 Ints++;
232 return std::make_pair(Ptrs, Ints);
233 }
234
getMemberPointerInfo(const MemberPointerType * MPT) const235 CXXABI::MemberPointerInfo MicrosoftCXXABI::getMemberPointerInfo(
236 const MemberPointerType *MPT) const {
237 // The nominal struct is laid out with pointers followed by ints and aligned
238 // to a pointer width if any are present and an int width otherwise.
239 const TargetInfo &Target = Context.getTargetInfo();
240 unsigned PtrSize = Target.getPointerWidth(0);
241 unsigned IntSize = Target.getIntWidth();
242
243 unsigned Ptrs, Ints;
244 std::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT);
245 MemberPointerInfo MPI;
246 MPI.HasPadding = false;
247 MPI.Width = Ptrs * PtrSize + Ints * IntSize;
248
249 // When MSVC does x86_32 record layout, it aligns aggregate member pointers to
250 // 8 bytes. However, __alignof usually returns 4 for data memptrs and 8 for
251 // function memptrs.
252 if (Ptrs + Ints > 1 && Target.getTriple().isArch32Bit())
253 MPI.Align = 64;
254 else if (Ptrs)
255 MPI.Align = Target.getPointerAlign(0);
256 else
257 MPI.Align = Target.getIntAlign();
258
259 if (Target.getTriple().isArch64Bit()) {
260 MPI.Width = llvm::alignTo(MPI.Width, MPI.Align);
261 MPI.HasPadding = MPI.Width != (Ptrs * PtrSize + Ints * IntSize);
262 }
263 return MPI;
264 }
265
CreateMicrosoftCXXABI(ASTContext & Ctx)266 CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) {
267 return new MicrosoftCXXABI(Ctx);
268 }
269
270