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