1 //===------- MicrosoftCXXABI.cpp - AST support for the Microsoft C++ ABI --===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides C++ AST support targeting the Microsoft Visual C++
11 // ABI.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "CXXABI.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Attr.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 /// \brief 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 llvm::SmallDenseMap<std::pair<const CXXConstructorDecl *, unsigned>, Expr *>
71 CtorToDefaultArgExpr;
72
73 public:
MicrosoftCXXABI(ASTContext & Ctx)74 MicrosoftCXXABI(ASTContext &Ctx) : Context(Ctx) { }
75
76 std::pair<uint64_t, unsigned>
77 getMemberPointerWidthAndAlign(const MemberPointerType *MPT) const override;
78
getDefaultMethodCallConv(bool isVariadic) const79 CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
80 if (!isVariadic &&
81 Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
82 return CC_X86ThisCall;
83 return CC_C;
84 }
85
isNearlyEmpty(const CXXRecordDecl * RD) const86 bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
87 // FIXME: Audit the corners
88 if (!RD->isDynamicClass())
89 return false;
90
91 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
92
93 // In the Microsoft ABI, classes can have one or two vtable pointers.
94 CharUnits PointerSize =
95 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
96 return Layout.getNonVirtualSize() == PointerSize ||
97 Layout.getNonVirtualSize() == PointerSize * 2;
98 }
99
addDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx,Expr * DAE)100 void addDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
101 unsigned ParmIdx, Expr *DAE) override {
102 CtorToDefaultArgExpr[std::make_pair(CD, ParmIdx)] = DAE;
103 }
104
getDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx)105 Expr *getDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
106 unsigned ParmIdx) override {
107 return CtorToDefaultArgExpr[std::make_pair(CD, ParmIdx)];
108 }
109
110 const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl * RD)111 getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
112 return RecordToCopyCtor[RD];
113 }
114
115 void
addCopyConstructorForExceptionObject(CXXRecordDecl * RD,CXXConstructorDecl * CD)116 addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
117 CXXConstructorDecl *CD) override {
118 assert(CD != nullptr);
119 assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
120 RecordToCopyCtor[RD] = CD;
121 }
122
createMangleNumberingContext() const123 MangleNumberingContext *createMangleNumberingContext() const override {
124 return new MicrosoftNumberingContext();
125 }
126 };
127 }
128
129 // getNumBases() seems to only give us the number of direct bases, and not the
130 // total. This function tells us if we inherit from anybody that uses MI, or if
131 // we have a non-primary base class, which uses the multiple inheritance model.
usesMultipleInheritanceModel(const CXXRecordDecl * RD)132 static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) {
133 while (RD->getNumBases() > 0) {
134 if (RD->getNumBases() > 1)
135 return true;
136 assert(RD->getNumBases() == 1);
137 const CXXRecordDecl *Base =
138 RD->bases_begin()->getType()->getAsCXXRecordDecl();
139 if (RD->isPolymorphic() && !Base->isPolymorphic())
140 return true;
141 RD = Base;
142 }
143 return false;
144 }
145
calculateInheritanceModel() const146 MSInheritanceAttr::Spelling CXXRecordDecl::calculateInheritanceModel() const {
147 if (!hasDefinition() || isParsingBaseSpecifiers())
148 return MSInheritanceAttr::Keyword_unspecified_inheritance;
149 if (getNumVBases() > 0)
150 return MSInheritanceAttr::Keyword_virtual_inheritance;
151 if (usesMultipleInheritanceModel(this))
152 return MSInheritanceAttr::Keyword_multiple_inheritance;
153 return MSInheritanceAttr::Keyword_single_inheritance;
154 }
155
156 MSInheritanceAttr::Spelling
getMSInheritanceModel() const157 CXXRecordDecl::getMSInheritanceModel() const {
158 MSInheritanceAttr *IA = getAttr<MSInheritanceAttr>();
159 assert(IA && "Expected MSInheritanceAttr on the CXXRecordDecl!");
160 return IA->getSemanticSpelling();
161 }
162
getMSVtorDispMode() const163 MSVtorDispAttr::Mode CXXRecordDecl::getMSVtorDispMode() const {
164 if (MSVtorDispAttr *VDA = getAttr<MSVtorDispAttr>())
165 return VDA->getVtorDispMode();
166 return MSVtorDispAttr::Mode(getASTContext().getLangOpts().VtorDispMode);
167 }
168
169 // Returns the number of pointer and integer slots used to represent a member
170 // pointer in the MS C++ ABI.
171 //
172 // Member function pointers have the following general form; however, fields
173 // are dropped as permitted (under the MSVC interpretation) by the inheritance
174 // model of the actual class.
175 //
176 // struct {
177 // // A pointer to the member function to call. If the member function is
178 // // virtual, this will be a thunk that forwards to the appropriate vftable
179 // // slot.
180 // void *FunctionPointerOrVirtualThunk;
181 //
182 // // An offset to add to the address of the vbtable pointer after
183 // // (possibly) selecting the virtual base but before resolving and calling
184 // // the function.
185 // // Only needed if the class has any virtual bases or bases at a non-zero
186 // // offset.
187 // int NonVirtualBaseAdjustment;
188 //
189 // // The offset of the vb-table pointer within the object. Only needed for
190 // // incomplete types.
191 // int VBPtrOffset;
192 //
193 // // An offset within the vb-table that selects the virtual base containing
194 // // the member. Loading from this offset produces a new offset that is
195 // // added to the address of the vb-table pointer to produce the base.
196 // int VirtualBaseAdjustmentOffset;
197 // };
198 static std::pair<unsigned, unsigned>
getMSMemberPointerSlots(const MemberPointerType * MPT)199 getMSMemberPointerSlots(const MemberPointerType *MPT) {
200 const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
201 MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
202 unsigned Ptrs = 0;
203 unsigned Ints = 0;
204 if (MPT->isMemberFunctionPointer())
205 Ptrs = 1;
206 else
207 Ints = 1;
208 if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
209 Inheritance))
210 Ints++;
211 if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
212 Ints++;
213 if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
214 Ints++;
215 return std::make_pair(Ptrs, Ints);
216 }
217
getMemberPointerWidthAndAlign(const MemberPointerType * MPT) const218 std::pair<uint64_t, unsigned> MicrosoftCXXABI::getMemberPointerWidthAndAlign(
219 const MemberPointerType *MPT) const {
220 // The nominal struct is laid out with pointers followed by ints and aligned
221 // to a pointer width if any are present and an int width otherwise.
222 const TargetInfo &Target = Context.getTargetInfo();
223 unsigned PtrSize = Target.getPointerWidth(0);
224 unsigned IntSize = Target.getIntWidth();
225
226 unsigned Ptrs, Ints;
227 std::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT);
228 uint64_t Width = Ptrs * PtrSize + Ints * IntSize;
229 unsigned Align;
230
231 // When MSVC does x86_32 record layout, it aligns aggregate member pointers to
232 // 8 bytes. However, __alignof usually returns 4 for data memptrs and 8 for
233 // function memptrs.
234 if (Ptrs + Ints > 1 && Target.getTriple().isArch32Bit())
235 Align = 64;
236 else if (Ptrs)
237 Align = Target.getPointerAlign(0);
238 else
239 Align = Target.getIntAlign();
240
241 if (Target.getTriple().isArch64Bit())
242 Width = llvm::RoundUpToAlignment(Width, Align);
243 return std::make_pair(Width, Align);
244 }
245
CreateMicrosoftCXXABI(ASTContext & Ctx)246 CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) {
247 return new MicrosoftCXXABI(Ctx);
248 }
249
250