• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   llvm::SmallDenseMap<TagDecl *, DeclaratorDecl *>
74       UnnamedTagDeclToDeclaratorDecl;
75   llvm::SmallDenseMap<TagDecl *, TypedefNameDecl *>
76       UnnamedTagDeclToTypedefNameDecl;
77 
78 public:
MicrosoftCXXABI(ASTContext & Ctx)79   MicrosoftCXXABI(ASTContext &Ctx) : Context(Ctx) { }
80 
81   std::pair<uint64_t, unsigned>
82   getMemberPointerWidthAndAlign(const MemberPointerType *MPT) const override;
83 
getDefaultMethodCallConv(bool isVariadic) const84   CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
85     if (!isVariadic &&
86         Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
87       return CC_X86ThisCall;
88     return CC_C;
89   }
90 
isNearlyEmpty(const CXXRecordDecl * RD) const91   bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
92     llvm_unreachable("unapplicable to the MS ABI");
93   }
94 
addDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx,Expr * DAE)95   void addDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
96                                        unsigned ParmIdx, Expr *DAE) override {
97     CtorToDefaultArgExpr[std::make_pair(CD, ParmIdx)] = DAE;
98   }
99 
getDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx)100   Expr *getDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
101                                         unsigned ParmIdx) override {
102     return CtorToDefaultArgExpr[std::make_pair(CD, ParmIdx)];
103   }
104 
105   const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl * RD)106   getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
107     return RecordToCopyCtor[RD];
108   }
109 
110   void
addCopyConstructorForExceptionObject(CXXRecordDecl * RD,CXXConstructorDecl * CD)111   addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
112                                        CXXConstructorDecl *CD) override {
113     assert(CD != nullptr);
114     assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
115     RecordToCopyCtor[RD] = CD;
116   }
117 
addTypedefNameForUnnamedTagDecl(TagDecl * TD,TypedefNameDecl * DD)118   void addTypedefNameForUnnamedTagDecl(TagDecl *TD,
119                                        TypedefNameDecl *DD) override {
120     TD = TD->getCanonicalDecl();
121     DD = cast<TypedefNameDecl>(DD->getCanonicalDecl());
122     TypedefNameDecl *&I = UnnamedTagDeclToTypedefNameDecl[TD];
123     if (!I)
124       I = DD;
125   }
126 
getTypedefNameForUnnamedTagDecl(const TagDecl * TD)127   TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD) override {
128     return UnnamedTagDeclToTypedefNameDecl.lookup(
129         const_cast<TagDecl *>(TD->getCanonicalDecl()));
130   }
131 
addDeclaratorForUnnamedTagDecl(TagDecl * TD,DeclaratorDecl * DD)132   void addDeclaratorForUnnamedTagDecl(TagDecl *TD,
133                                       DeclaratorDecl *DD) override {
134     TD = TD->getCanonicalDecl();
135     DD = cast<DeclaratorDecl>(DD->getCanonicalDecl());
136     DeclaratorDecl *&I = UnnamedTagDeclToDeclaratorDecl[TD];
137     if (!I)
138       I = DD;
139   }
140 
getDeclaratorForUnnamedTagDecl(const TagDecl * TD)141   DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD) override {
142     return UnnamedTagDeclToDeclaratorDecl.lookup(
143         const_cast<TagDecl *>(TD->getCanonicalDecl()));
144   }
145 
createMangleNumberingContext() const146   MangleNumberingContext *createMangleNumberingContext() const override {
147     return new MicrosoftNumberingContext();
148   }
149 };
150 }
151 
152 // getNumBases() seems to only give us the number of direct bases, and not the
153 // total.  This function tells us if we inherit from anybody that uses MI, or if
154 // we have a non-primary base class, which uses the multiple inheritance model.
usesMultipleInheritanceModel(const CXXRecordDecl * RD)155 static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) {
156   while (RD->getNumBases() > 0) {
157     if (RD->getNumBases() > 1)
158       return true;
159     assert(RD->getNumBases() == 1);
160     const CXXRecordDecl *Base =
161         RD->bases_begin()->getType()->getAsCXXRecordDecl();
162     if (RD->isPolymorphic() && !Base->isPolymorphic())
163       return true;
164     RD = Base;
165   }
166   return false;
167 }
168 
calculateInheritanceModel() const169 MSInheritanceAttr::Spelling CXXRecordDecl::calculateInheritanceModel() const {
170   if (!hasDefinition() || isParsingBaseSpecifiers())
171     return MSInheritanceAttr::Keyword_unspecified_inheritance;
172   if (getNumVBases() > 0)
173     return MSInheritanceAttr::Keyword_virtual_inheritance;
174   if (usesMultipleInheritanceModel(this))
175     return MSInheritanceAttr::Keyword_multiple_inheritance;
176   return MSInheritanceAttr::Keyword_single_inheritance;
177 }
178 
179 MSInheritanceAttr::Spelling
getMSInheritanceModel() const180 CXXRecordDecl::getMSInheritanceModel() const {
181   MSInheritanceAttr *IA = getAttr<MSInheritanceAttr>();
182   assert(IA && "Expected MSInheritanceAttr on the CXXRecordDecl!");
183   return IA->getSemanticSpelling();
184 }
185 
getMSVtorDispMode() const186 MSVtorDispAttr::Mode CXXRecordDecl::getMSVtorDispMode() const {
187   if (MSVtorDispAttr *VDA = getAttr<MSVtorDispAttr>())
188     return VDA->getVtorDispMode();
189   return MSVtorDispAttr::Mode(getASTContext().getLangOpts().VtorDispMode);
190 }
191 
192 // Returns the number of pointer and integer slots used to represent a member
193 // pointer in the MS C++ ABI.
194 //
195 // Member function pointers have the following general form;  however, fields
196 // are dropped as permitted (under the MSVC interpretation) by the inheritance
197 // model of the actual class.
198 //
199 //   struct {
200 //     // A pointer to the member function to call.  If the member function is
201 //     // virtual, this will be a thunk that forwards to the appropriate vftable
202 //     // slot.
203 //     void *FunctionPointerOrVirtualThunk;
204 //
205 //     // An offset to add to the address of the vbtable pointer after
206 //     // (possibly) selecting the virtual base but before resolving and calling
207 //     // the function.
208 //     // Only needed if the class has any virtual bases or bases at a non-zero
209 //     // offset.
210 //     int NonVirtualBaseAdjustment;
211 //
212 //     // The offset of the vb-table pointer within the object.  Only needed for
213 //     // incomplete types.
214 //     int VBPtrOffset;
215 //
216 //     // An offset within the vb-table that selects the virtual base containing
217 //     // the member.  Loading from this offset produces a new offset that is
218 //     // added to the address of the vb-table pointer to produce the base.
219 //     int VirtualBaseAdjustmentOffset;
220 //   };
221 static std::pair<unsigned, unsigned>
getMSMemberPointerSlots(const MemberPointerType * MPT)222 getMSMemberPointerSlots(const MemberPointerType *MPT) {
223   const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
224   MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel();
225   unsigned Ptrs = 0;
226   unsigned Ints = 0;
227   if (MPT->isMemberFunctionPointer())
228     Ptrs = 1;
229   else
230     Ints = 1;
231   if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(),
232                                           Inheritance))
233     Ints++;
234   if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance))
235     Ints++;
236   if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance))
237     Ints++;
238   return std::make_pair(Ptrs, Ints);
239 }
240 
getMemberPointerWidthAndAlign(const MemberPointerType * MPT) const241 std::pair<uint64_t, unsigned> MicrosoftCXXABI::getMemberPointerWidthAndAlign(
242     const MemberPointerType *MPT) const {
243   // The nominal struct is laid out with pointers followed by ints and aligned
244   // to a pointer width if any are present and an int width otherwise.
245   const TargetInfo &Target = Context.getTargetInfo();
246   unsigned PtrSize = Target.getPointerWidth(0);
247   unsigned IntSize = Target.getIntWidth();
248 
249   unsigned Ptrs, Ints;
250   std::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT);
251   uint64_t Width = Ptrs * PtrSize + Ints * IntSize;
252   unsigned Align;
253 
254   // When MSVC does x86_32 record layout, it aligns aggregate member pointers to
255   // 8 bytes.  However, __alignof usually returns 4 for data memptrs and 8 for
256   // function memptrs.
257   if (Ptrs + Ints > 1 && Target.getTriple().isArch32Bit())
258     Align = 64;
259   else if (Ptrs)
260     Align = Target.getPointerAlign(0);
261   else
262     Align = Target.getIntAlign();
263 
264   if (Target.getTriple().isArch64Bit())
265     Width = llvm::alignTo(Width, Align);
266   return std::make_pair(Width, Align);
267 }
268 
CreateMicrosoftCXXABI(ASTContext & Ctx)269 CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) {
270   return new MicrosoftCXXABI(Ctx);
271 }
272 
273