diff --git include/clang/AST/VTableBuilder.h include/clang/AST/VTableBuilder.h index a6aa40b..15cc02d 100644 --- include/clang/AST/VTableBuilder.h +++ include/clang/AST/VTableBuilder.h @@ -251,10 +251,7 @@ public: assert(AddressPoints.count(Base) && "Did not find address point!"); - uint64_t AddressPoint = AddressPoints.lookup(Base); - assert(AddressPoint && "Address point must not be zero!"); - - return AddressPoint; + return AddressPoints.lookup(Base); } const AddressPointsMapTy &getAddressPoints() const { diff --git lib/AST/VTableBuilder.cpp lib/AST/VTableBuilder.cpp index 1ab2b99..c4826b9 100644 --- lib/AST/VTableBuilder.cpp +++ lib/AST/VTableBuilder.cpp @@ -1296,9 +1296,18 @@ VTableBuilder::AddMethod(const CXXMethodDecl *MD, assert(ReturnAdjustment.isEmpty() && "Destructor can't have return adjustment!"); - // Add both the complete destructor and the deleting destructor. - Components.push_back(VTableComponent::MakeCompleteDtor(DD)); - Components.push_back(VTableComponent::MakeDeletingDtor(DD)); + // FIXME: Should probably add a layer of abstraction for vtable generation. + if (Context.getTargetInfo().getCXXABI() != CXXABI_Microsoft) { + // Add both the complete destructor and the deleting destructor. + Components.push_back(VTableComponent::MakeCompleteDtor(DD)); + Components.push_back(VTableComponent::MakeDeletingDtor(DD)); + } else { + // Add only one destructor in MS mode. + // FIXME: The virtual destructors are handled differently in MS ABI, + // we should add such a support later. For now, put the complete + // destructor into the vftable just to make its layout right. + Components.push_back(VTableComponent::MakeCompleteDtor(DD)); + } } else { // Add the return adjustment if necessary. if (!ReturnAdjustment.isEmpty()) @@ -1613,14 +1622,19 @@ VTableBuilder::LayoutPrimaryAndSecondaryVTables(BaseSubobject Base, if (Base.getBase() == MostDerivedClass) VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets(); - // Add the offset to top. - CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass; - Components.push_back( - VTableComponent::MakeOffsetToTop(OffsetToTop)); - - // Next, add the RTTI. - Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass)); - + // FIXME: Should probably add a layer of abstraction for vtable generation. + if (Context.getTargetInfo().getCXXABI() != CXXABI_Microsoft) { + // Add the offset to top. + CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass; + Components.push_back(VTableComponent::MakeOffsetToTop(OffsetToTop)); + + // Next, add the RTTI. + Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass)); + } else { + // FIXME: unclear what to do with RTTI in MS ABI as emitting it anywhere + // breaks the vftable layout. Just skip RTTI for now, can't mangle anyway. + } + uint64_t AddressPoint = Components.size(); // Now go through all virtual member functions and add them. @@ -2121,10 +2135,16 @@ void VTableBuilder::dumpLayout(raw_ostream& Out) { MD); if (const CXXDestructorDecl *DD = dyn_cast(MD)) { - IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Complete))] = - MethodName + " [complete]"; - IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Deleting))] = - MethodName + " [deleting]"; + // FIXME: Should add a layer of abstraction for vtable generation. + if (Context.getTargetInfo().getCXXABI() != CXXABI_Microsoft) { + IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Complete))] + = MethodName + " [complete]"; + IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Deleting))] + = MethodName + " [deleting]"; + } else { + IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Complete))] + = MethodName; + } } else { IndicesMap[VTables.getMethodVTableIndex(MD)] = MethodName; } @@ -2200,7 +2220,10 @@ void VTableContext::ComputeMethodVTableIndices(const CXXRecordDecl *RD) { // between their return types does not require an adjustment. int64_t CurrentIndex = 0; - + + // FIXME: Should probably add a layer of abstraction for vtable generation. + bool isMicrosoft = (Context.getTargetInfo().getCXXABI() == CXXABI_Microsoft); + const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase(); @@ -2240,12 +2263,17 @@ void VTableContext::ComputeMethodVTableIndices(const CXXRecordDecl *RD) { if (const CXXDestructorDecl *DD = dyn_cast(MD)) { const CXXDestructorDecl *OverriddenDD = cast(OverriddenMD); - - // Add both the complete and deleting entries. - MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = - getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Complete)); - MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = - getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting)); + + if (!isMicrosoft) { + // Add both the complete and deleting entries. + MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = + getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Complete)); + MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = + getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting)); + } else { + MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = + getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Complete)); + } } else { MethodVTableIndices[MD] = getMethodVTableIndex(OverriddenMD); } @@ -2263,11 +2291,19 @@ void VTableContext::ComputeMethodVTableIndices(const CXXRecordDecl *RD) { continue; } - // Add the complete dtor. - MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++; - - // Add the deleting dtor. - MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++; + if (!isMicrosoft) { + // Add the complete dtor. + MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++; + + // Add the deleting dtor. + MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++; + } else { + // Add only the deleting dtor. + // FIXME: The virtual destructors are handled differently in MS ABI, + // we should add such a support later. For now, put the complete + // destructor into the vftable indices. + MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++; + } } else { // Add the entry. MethodVTableIndices[MD] = CurrentIndex++; @@ -2279,6 +2315,9 @@ void VTableContext::ComputeMethodVTableIndices(const CXXRecordDecl *RD) { // If a class has an implicitly-defined virtual destructor, // its entries come after the declared virtual function pointers. + assert(!isMicrosoft && + "Implicit virtual dtors are not yet supported in MS ABI"); + // Add the complete dtor. MethodVTableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] = CurrentIndex++; diff --git lib/CodeGen/MicrosoftCXXABI.cpp lib/CodeGen/MicrosoftCXXABI.cpp index 8d205c3..8e49292 100644 --- lib/CodeGen/MicrosoftCXXABI.cpp +++ lib/CodeGen/MicrosoftCXXABI.cpp @@ -207,7 +207,7 @@ void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, } void MicrosoftCXXABI::EmitVTables(const CXXRecordDecl *Class) { - // FIXME: implement + CGM.getVTables().GenerateClassData(CGM.getVTableLinkage(Class), Class); } CGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) { diff --git test/CodeGenCXX/microsoft-abi-constructors.cpp test/CodeGenCXX/microsoft-abi-constructors.cpp index 89731ff..c9701e8 100644 --- test/CodeGenCXX/microsoft-abi-constructors.cpp +++ test/CodeGenCXX/microsoft-abi-constructors.cpp @@ -22,3 +22,14 @@ void no_contstructor_destructor_infinite_recursion() { // CHECK: ret } +struct B { + virtual ~B(); + virtual void foo(); +}; + +void check_vftable_offset() { + B b; +// The vftable pointer should point at the beginning of the vftable. +// CHECK: [[THIS_PTR:%[0-9]+]] = bitcast %struct.B* {{.*}} to i8*** +// CHECK: store i8** getelementptr inbounds ([2 x i8*]* @"\01??_7B@@6B@", i64 0, i64 0), i8*** [[THIS_PTR]] +} diff --git test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp new file mode 100644 index 0000000..176ecf1 --- /dev/null +++ test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp @@ -0,0 +1,113 @@ +// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -fdump-vtable-layouts -o - > %t 2>&1 +// RUN: FileCheck --check-prefix=EMITS-VTABLE %s < %t +// RUN: FileCheck --check-prefix=CHECK-A %s < %t +// RUN: FileCheck --check-prefix=CHECK-B %s < %t +// RUN: FileCheck --check-prefix=CHECK-C %s < %t +// RUN: FileCheck --check-prefix=CHECK-D %s < %t +// RUN: FileCheck --check-prefix=CHECK-E %s < %t +// RUN: FileCheck --check-prefix=CHECK-F %s < %t +// RUN: FileCheck --check-prefix=CHECK-G %s < %t + +struct A { + // CHECK-A: Vtable for 'A' (3 entries) + // CHECK-A-NEXT: 0 | void A::f() + // CHECK-A-NEXT: 1 | void A::g() + // CHECK-A-NEXT: 2 | void A::h() + // EMITS-VTABLE: @"\01??_7A@@6B@" = unnamed_addr constant [3 x i8*] + virtual void f(); + virtual void g(); + virtual void h(); + int ia; +}; +void A::f() {} + +struct B : A { + // CHECK-B: Vtable for 'B' (5 entries) + // CHECK-B-NEXT: 0 | void B::f() + // CHECK-B-NEXT: 1 | void A::g() + // CHECK-B-NEXT: 2 | void A::h() + // CHECK-B-NEXT: 3 | void B::i() + // CHECK-B-NEXT: 4 | void B::j() + // EMITS-VTABLE: @"\01??_7B@@6B@" = unnamed_addr constant [5 x i8*] + virtual void f(); // overrides A::f() + virtual void i(); + virtual void j(); +}; +void B::f() {} + +struct C { + // CHECK-C: Vtable for 'C' (2 entries) + // CHECK-C-NEXT: 0 | C::~C() + // CHECK-C-NEXT: 1 | void C::f() + // CHECK-C: VTable indices for 'C' (2 entries). + // CHECK-C-NEXT: 0 | C::~C() + // CHECK-C-NEXT: 1 | void C::f() + // Never used, so doesn't emit a vtable. + virtual ~C(); + + virtual void f(); +}; +void C::f() {} + +struct D { + // CHECK-D: Vtable for 'D' (2 entries) + // CHECK-D-NEXT: 0 | void D::f() + // CHECK-D-NEXT: 1 | D::~D() + // EMITS-VTABLE: @"\01??_7D@@6B@" = unnamed_addr constant [2 x i8*] + virtual void f(); + + virtual ~D(); +}; +void D::f() {} + +struct E : A { + // CHECK-E: Vtable for 'E' (5 entries) + // CHECK-E-NEXT: 0 | void A::f() + // CHECK-E-NEXT: 1 | void A::g() + // CHECK-E-NEXT: 2 | void A::h() + // CHECK-E-NEXT: 3 | E::~E() + // CHECK-E-NEXT: 4 | void E::i() + // CHECK-E: VTable indices for 'E' (2 entries). + // CHECK-E-NEXT: 3 | E::~E() + // CHECK-E-NEXT: 4 | void E::i() + + // Never used, so doesn't emit a vtable. + virtual ~E(); + virtual void i(); +}; +void E::i() {} + +struct F : A { + // CHECK-F: Vtable for 'F' (5 entries) + // CHECK-F-NEXT: 0 | void A::f() + // CHECK-F-NEXT: 1 | void A::g() + // CHECK-F-NEXT: 2 | void A::h() + // CHECK-F-NEXT: 3 | void F::i() + // CHECK-F-NEXT: 4 | F::~F() + // CHECK-F: VTable indices for 'F' (2 entries). + // CHECK-F-NEXT: 3 | void F::i() + // CHECK-F-NEXT: 4 | F::~F() + // EMITS-VTABLE: @"\01??_7F@@6B@" = unnamed_addr constant [5 x i8*] + virtual void i(); + virtual ~F(); +}; +void F::i() {} + +struct G : E { + // CHECK-G: Vtable for 'G' (6 entries) + // CHECK-G-NEXT: 0 | void G::f() + // CHECK-G-NEXT: 1 | void A::g() + // CHECK-G-NEXT: 2 | void A::h() + // CHECK-G-NEXT: 3 | G::~G() + // CHECK-G-NEXT: 4 | void E::i() + // CHECK-G-NEXT: 5 | void G::j() + // CHECK-G: VTable indices for 'G' (3 entries). + // CHECK-G-NEXT: 0 | void G::f() + // CHECK-G-NEXT: 3 | G::~G() + // CHECK-G-NEXT: 5 | void G::j() + // Never used, so doesn't emit a vtable. + virtual void f(); // overrides A::f() + virtual ~G(); + virtual void j(); +}; +void G::j() {}