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 } 333