diff options
Diffstat (limited to 'clang/test/CodeGenCXX')
3 files changed, 224 insertions, 9 deletions
diff --git a/clang/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp b/clang/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp new file mode 100644 index 00000000000..9059e6f028b --- /dev/null +++ b/clang/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp @@ -0,0 +1,147 @@ +// RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s + +struct Left { + virtual void left(); +}; + +struct Right { + virtual void right(); +}; + +struct ChildNoOverride : Left, Right { +}; + +struct ChildOverride : Left, Right { + virtual void left(); + virtual void right(); +}; + +extern "C" void foo(void *); + +void call_left_no_override(ChildNoOverride *child) { +// CHECK: define void @"\01?call_left_no_override +// CHECK: %[[CHILD:.*]] = load %struct.ChildNoOverride + + child->left(); +// Only need to cast 'this' to Left*. +// CHECK: %[[LEFT:.*]] = bitcast %struct.ChildNoOverride* %[[CHILD]] to %struct.Left* +// CHECK: %[[VFPTR:.*]] = bitcast %struct.Left* %[[LEFT]] to void (%struct.Left*)*** +// CHECK: %[[VFTABLE:.*]] = load void (%struct.Left*)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (%struct.Left*)** %[[VFTABLE]], i64 0 +// CHECK: %[[VFUN_VALUE:.*]] = load void (%struct.Left*)** %[[VFUN]] +// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](%struct.Left* %[[LEFT]]) +// CHECK: ret +} + +void ChildOverride::left() { +// CHECK: define x86_thiscallcc void @"\01?left@ChildOverride@@UAEXXZ"(%struct.ChildOverride* %[[THIS:.*]]) +// +// No need to adjust 'this' as the ChildOverride's layout begins with Left. +// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.ChildOverride*, align 4 +// CHECK: store %struct.ChildOverride* %[[THIS]], %struct.ChildOverride** %[[THIS_ADDR]], align 4 + + foo(this); +// CHECK: %[[THIS:.*]] = load %struct.ChildOverride** %[[THIS_ADDR]] +// CHECK: %[[THIS_i8:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i8* +// CHECK: call void @foo(i8* %[[THIS_i8]]) +// CHECK: ret +} + +void call_left_override(ChildOverride *child) { +// CHECK: define void @"\01?call_left_override +// CHECK: %[[CHILD:.*]] = load %struct.ChildOverride + + child->left(); +// CHECK: %[[VFPTR:.*]] = bitcast %struct.ChildOverride* %[[CHILD]] to void (%struct.ChildOverride*)*** +// CHECK: %[[VFTABLE:.*]] = load void (%struct.ChildOverride*)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (%struct.ChildOverride*)** %[[VFTABLE]], i64 0 +// CHECK: %[[VFUN_VALUE:.*]] = load void (%struct.ChildOverride*)** %[[VFUN]] +// +// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](%struct.ChildOverride* %[[CHILD]]) +// CHECK: ret +} + +void call_right_no_override(ChildNoOverride *child) { +// CHECK: define void @"\01?call_right_no_override +// CHECK: %[[CHILD:.*]] = load %struct.ChildNoOverride + + child->right(); +// When calling a right base's virtual method, one needs to adjust 'this' at +// the caller site. +// +// CHECK: %[[CHILD_i8:.*]] = bitcast %struct.ChildNoOverride* %[[CHILD]] to i8* +// CHECK: %[[RIGHT_i8:.*]] = getelementptr inbounds i8* %[[CHILD_i8]], i32 4 +// CHECK: %[[RIGHT:.*]] = bitcast i8* %[[RIGHT_i8]] to %struct.Right* +// +// CHECK: %[[VFPTR:.*]] = bitcast %struct.Right* %[[RIGHT]] to void (%struct.Right*)*** +// CHECK: %[[VFTABLE:.*]] = load void (%struct.Right*)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (%struct.Right*)** %[[VFTABLE]], i64 0 +// CHECK: %[[VFUN_VALUE:.*]] = load void (%struct.Right*)** %[[VFUN]] +// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](%struct.Right* %[[RIGHT]]) +// CHECK: ret +} + +void ChildOverride::right() { +// CHECK: define x86_thiscallcc void @"\01?right@ChildOverride@@UAEXXZ"(i8* +// +// ChildOverride::right gets 'this' cast to Right* in ECX (i.e. this+4) so we +// need to adjust 'this' before use. +// +// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.ChildOverride*, align 4 +// CHECK: %[[THIS_i8:.*]] = getelementptr i8* %[[ECX:.*]], i64 -4 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.ChildOverride* +// CHECK: store %struct.ChildOverride* %[[THIS]], %struct.ChildOverride** %[[THIS_ADDR]], align 4 + + foo(this); +// CHECK: %[[THIS:.*]] = load %struct.ChildOverride** %[[THIS_ADDR]] +// CHECK: %[[THIS_PARAM:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i8* +// CHECK: call void @foo(i8* %[[THIS_PARAM]]) +// CHECK: ret +} + +void call_right_override(ChildOverride *child) { +// CHECK: define void @"\01?call_right_override +// CHECK: %[[CHILD:.*]] = load %struct.ChildOverride + + child->right(); +// When calling a right child's virtual method, one needs to adjust 'this' at +// the caller site. +// +// CHECK: %[[CHILD_i8:.*]] = bitcast %struct.ChildOverride* %[[CHILD]] to i8* +// +// CHECK: %[[VFPTR_i8:.*]] = getelementptr inbounds i8* %[[CHILD_i8]], i64 4 +// CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to void (i8*)*** +// CHECK: %[[VFTABLE:.*]] = load void (i8*)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (i8*)** %[[VFTABLE]], i64 0 +// CHECK: %[[VFUN_VALUE:.*]] = load void (i8*)** %[[VFUN]] +// +// CHECK: %[[CHILD_i8:.*]] = bitcast %struct.ChildOverride* %[[CHILD]] to i8* +// CHECK: %[[RIGHT:.*]] = getelementptr inbounds i8* %[[CHILD_i8]], i64 4 +// +// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](i8* %[[RIGHT]]) +// CHECK: ret +} + +struct GrandchildOverride : ChildOverride { + virtual void right(); +}; + +void GrandchildOverride::right() { +// CHECK: define x86_thiscallcc void @"\01?right@GrandchildOverride@@UAEXXZ"(i8* +// +// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.GrandchildOverride*, align 4 +// CHECK: %[[THIS_i8:.*]] = getelementptr i8* %[[ECX:.*]], i64 -4 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.GrandchildOverride* +// CHECK: store %struct.GrandchildOverride* %[[THIS]], %struct.GrandchildOverride** %[[THIS_ADDR]], align 4 + + foo(this); +// CHECK: %[[THIS:.*]] = load %struct.GrandchildOverride** %[[THIS_ADDR]] +// CHECK: %[[THIS_PARAM:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to i8* +// CHECK: call void @foo(i8* %[[THIS_PARAM]]) +// CHECK: ret +} + +void call_grandchild_right(GrandchildOverride *obj) { + // Just make sure we don't crash. + obj->right(); +} diff --git a/clang/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp b/clang/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp index 7e631c1d78a..ecbb8433797 100644 --- a/clang/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp +++ b/clang/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp @@ -1,11 +1,79 @@ -// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o %t +// RUN: %clang_cc1 %s -fno-rtti -cxx-abi microsoft -triple=i386-pc-win32 -emit-llvm -o - | FileCheck %s -struct A {}; -struct B : virtual A { - virtual ~B(); +struct VBase { + virtual void foo(); + virtual void bar(); + int field; }; -struct C : B { - C(); + +struct B : virtual VBase { + virtual void foo(); + virtual void bar(); }; -C::C() {} +void B::foo() { +// CHECK: define x86_thiscallcc void @"\01?foo@B@@UAEXXZ"(i8* +// +// B::foo gets 'this' cast to VBase* in ECX (i.e. this+8) so we +// need to adjust 'this' before use. +// +// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B*, align 4 +// CHECK: %[[THIS_i8:.*]] = getelementptr i8* %[[ECX:.*]], i64 -8 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B* +// CHECK: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR]], align 4 + + field = 42; +// CHECK: %[[THIS:.*]] = load %struct.B** %[[THIS_ADDR]] +// CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8* +// CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[THIS8]], i32 0 +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** +// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] +// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 +// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] +// CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] +// CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8* +// CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8* %[[THIS8]], i32 %[[VBOFFSET]] +// CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.VBase* +// CHECK: %[[FIELD:.*]] = getelementptr inbounds %struct.VBase* %[[VBASE]], i32 0, i32 1 +// CHECK: store i32 42, i32* %[[FIELD]], align 4 +// +// CHECK: ret void +} + +void call_vbase_bar(B *obj) { +// CHECK: define void @"\01?call_vbase_bar@@YAXPAUB@@@Z"(%struct.B* %obj) +// CHECK: %[[OBJ:.*]] = load %struct.B + + obj->bar(); +// When calling a vbase's virtual method, one needs to adjust 'this' +// at the caller site. +// +// CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* +// CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** +// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] +// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 +// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] +// CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] +// CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] +// CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to void (i8*)*** +// CHECK: %[[VFTABLE:.*]] = load void (i8*)*** %[[VFPTR]] +// CHECK: %[[VFUN:.*]] = getelementptr inbounds void (i8*)** %[[VFTABLE]], i64 1 +// CHECK: %[[VFUN_VALUE:.*]] = load void (i8*)** %[[VFUN]] +// +// CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8* +// CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 0 +// CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i8** +// CHECK: %[[VBTABLE:.*]] = load i8** %[[VBPTR8]] +// CHECK: %[[VBENTRY8:.*]] = getelementptr inbounds i8* %[[VBTABLE]], i32 4 +// CHECK: %[[VBENTRY:.*]] = bitcast i8* %[[VBENTRY8]] to i32* +// CHECK: %[[VBOFFSET32:.*]] = load i32* %[[VBENTRY]] +// CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]] +// CHECK: %[[VBASE:.*]] = getelementptr inbounds i8* %[[OBJ_i8]], i32 %[[VBOFFSET]] +// +// CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](i8* %[[VBASE]]) +// +// CHECK: ret void +} diff --git a/clang/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp b/clang/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp index 1bebec9d67a..9a065d4c02f 100644 --- a/clang/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp +++ b/clang/test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp @@ -17,12 +17,12 @@ // v*table info was required by a constructor or a method definition. struct A { - // CHECK-A: Vtable for 'A' (3 entries) + // CHECK-A: VFTable 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() - // CHECK-A: VFTable for 'A' (3 entries) + // 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() |
