clang/lib/AST/MicrosoftCXXABI.cpp

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