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