1 //===------- MicrosoftCXXABI.cpp - AST support for the Microsoft C++ ABI --===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This provides C++ AST support targeting the Microsoft Visual C++ 11 // ABI. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "CXXABI.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/Attr.h" 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/MangleNumberingContext.h" 20 #include "clang/AST/RecordLayout.h" 21 #include "clang/AST/Type.h" 22 #include "clang/Basic/TargetInfo.h" 23 24 using namespace clang; 25 26 namespace { 27 28 /// \brief Numbers things which need to correspond across multiple TUs. 29 /// Typically these are things like static locals, lambdas, or blocks. 30 class MicrosoftNumberingContext : public MangleNumberingContext { 31 public: 32 unsigned getManglingNumber(const VarDecl *VD, 33 unsigned MSLocalManglingNumber) override { 34 return MSLocalManglingNumber; 35 } 36 37 unsigned getManglingNumber(const TagDecl *TD, 38 unsigned MSLocalManglingNumber) override { 39 return MSLocalManglingNumber; 40 } 41 }; 42 43 class MicrosoftCXXABI : public CXXABI { 44 ASTContext &Context; 45 public: 46 MicrosoftCXXABI(ASTContext &Ctx) : Context(Ctx) { } 47 48 std::pair<uint64_t, unsigned> 49 getMemberPointerWidthAndAlign(const MemberPointerType *MPT) const override; 50 51 CallingConv getDefaultMethodCallConv(bool isVariadic) const override { 52 if (!isVariadic && 53 Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86) 54 return CC_X86ThisCall; 55 return CC_C; 56 } 57 58 bool isNearlyEmpty(const CXXRecordDecl *RD) const override { 59 // FIXME: Audit the corners 60 if (!RD->isDynamicClass()) 61 return false; 62 63 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 64 65 // In the Microsoft ABI, classes can have one or two vtable pointers. 66 CharUnits PointerSize = 67 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); 68 return Layout.getNonVirtualSize() == PointerSize || 69 Layout.getNonVirtualSize() == PointerSize * 2; 70 } 71 72 MangleNumberingContext *createMangleNumberingContext() const override { 73 return new MicrosoftNumberingContext(); 74 } 75 }; 76 } 77 78 // getNumBases() seems to only give us the number of direct bases, and not the 79 // total. This function tells us if we inherit from anybody that uses MI, or if 80 // we have a non-primary base class, which uses the multiple inheritance model. 81 static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) { 82 while (RD->getNumBases() > 0) { 83 if (RD->getNumBases() > 1) 84 return true; 85 assert(RD->getNumBases() == 1); 86 const CXXRecordDecl *Base = 87 RD->bases_begin()->getType()->getAsCXXRecordDecl(); 88 if (RD->isPolymorphic() && !Base->isPolymorphic()) 89 return true; 90 RD = Base; 91 } 92 return false; 93 } 94 95 MSInheritanceAttr::Spelling CXXRecordDecl::calculateInheritanceModel() const { 96 if (!hasDefinition() || isParsingBaseSpecifiers()) 97 return MSInheritanceAttr::Keyword_unspecified_inheritance; 98 if (getNumVBases() > 0) 99 return MSInheritanceAttr::Keyword_virtual_inheritance; 100 if (usesMultipleInheritanceModel(this)) 101 return MSInheritanceAttr::Keyword_multiple_inheritance; 102 return MSInheritanceAttr::Keyword_single_inheritance; 103 } 104 105 MSInheritanceAttr::Spelling 106 CXXRecordDecl::getMSInheritanceModel() const { 107 MSInheritanceAttr *IA = getAttr<MSInheritanceAttr>(); 108 assert(IA && "Expected MSInheritanceAttr on the CXXRecordDecl!"); 109 return IA->getSemanticSpelling(); 110 } 111 112 MSVtorDispAttr::Mode CXXRecordDecl::getMSVtorDispMode() const { 113 if (MSVtorDispAttr *VDA = getAttr<MSVtorDispAttr>()) 114 return VDA->getVtorDispMode(); 115 return MSVtorDispAttr::Mode(getASTContext().getLangOpts().VtorDispMode); 116 } 117 118 // Returns the number of pointer and integer slots used to represent a member 119 // pointer in the MS C++ ABI. 120 // 121 // Member function pointers have the following general form; however, fields 122 // are dropped as permitted (under the MSVC interpretation) by the inheritance 123 // model of the actual class. 124 // 125 // struct { 126 // // A pointer to the member function to call. If the member function is 127 // // virtual, this will be a thunk that forwards to the appropriate vftable 128 // // slot. 129 // void *FunctionPointerOrVirtualThunk; 130 // 131 // // An offset to add to the address of the vbtable pointer after (possibly) 132 // // selecting the virtual base but before resolving and calling the function. 133 // // Only needed if the class has any virtual bases or bases at a non-zero 134 // // offset. 135 // int NonVirtualBaseAdjustment; 136 // 137 // // The offset of the vb-table pointer within the object. Only needed for 138 // // incomplete types. 139 // int VBPtrOffset; 140 // 141 // // An offset within the vb-table that selects the virtual base containing 142 // // the member. Loading from this offset produces a new offset that is 143 // // added to the address of the vb-table pointer to produce the base. 144 // int VirtualBaseAdjustmentOffset; 145 // }; 146 static std::pair<unsigned, unsigned> 147 getMSMemberPointerSlots(const MemberPointerType *MPT) { 148 const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 149 MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 150 unsigned Ptrs = 0; 151 unsigned Ints = 0; 152 if (MPT->isMemberFunctionPointer()) 153 Ptrs = 1; 154 else 155 Ints = 1; 156 if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(), 157 Inheritance)) 158 Ints++; 159 if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) 160 Ints++; 161 if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 162 Ints++; 163 return std::make_pair(Ptrs, Ints); 164 } 165 166 std::pair<uint64_t, unsigned> MicrosoftCXXABI::getMemberPointerWidthAndAlign( 167 const MemberPointerType *MPT) const { 168 const TargetInfo &Target = Context.getTargetInfo(); 169 assert(Target.getTriple().getArch() == llvm::Triple::x86 || 170 Target.getTriple().getArch() == llvm::Triple::x86_64); 171 unsigned Ptrs, Ints; 172 std::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT); 173 // The nominal struct is laid out with pointers followed by ints and aligned 174 // to a pointer width if any are present and an int width otherwise. 175 unsigned PtrSize = Target.getPointerWidth(0); 176 unsigned IntSize = Target.getIntWidth(); 177 uint64_t Width = Ptrs * PtrSize + Ints * IntSize; 178 unsigned Align; 179 180 // When MSVC does x86_32 record layout, it aligns aggregate member pointers to 181 // 8 bytes. However, __alignof usually returns 4 for data memptrs and 8 for 182 // function memptrs. 183 if (Ptrs + Ints > 1 && Target.getTriple().getArch() == llvm::Triple::x86) 184 Align = 8 * 8; 185 else if (Ptrs) 186 Align = Target.getPointerAlign(0); 187 else 188 Align = Target.getIntAlign(); 189 190 if (Target.getTriple().getArch() == llvm::Triple::x86_64) 191 Width = llvm::RoundUpToAlignment(Width, Align); 192 return std::make_pair(Width, Align); 193 } 194 195 CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) { 196 return new MicrosoftCXXABI(Ctx); 197 } 198 199