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